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 @ 22132:19205292b0c7

Suppressing "try" lints

author	Jaroslav Tulach <jaroslav.tulach@oracle.com>
date	Fri, 04 Sep 2015 09:10:27 +0200
parents	0589cc5cab30
children	c334865b9d42

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
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	27 import com.oracle.truffle.api.*;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	28 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	29 import com.oracle.truffle.api.TruffleLanguage.Registration;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	30 import com.oracle.truffle.api.debug.*;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	31 import com.oracle.truffle.api.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	32 import com.oracle.truffle.api.instrument.*;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	33 import com.oracle.truffle.api.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	34 import java.io.*;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	35 import java.net.*;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	36 import java.nio.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	37 import java.util.*;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	38 import java.util.concurrent.CountDownLatch;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	39 import java.util.concurrent.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	40 import java.util.logging.*;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	41
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	42 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	43 * <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	44 * 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	45 * {@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	46 * 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	47 * 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	48 * <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	49 * 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	50 * 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	51 * 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	52 * 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	53 * 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	54 * {@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	55 * 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	56 * 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	57 * <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	58 * 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	59 * 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	60 * 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	61 * 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	62 * <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	63 * 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	64 * 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	65 * 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	66 * 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	67 * 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	68 * <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	69 * 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	70 * 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	71 * 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	72 * 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	73 */
f879b1fe3773 Separating 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 @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	75 public final class 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	76 private static final Logger LOG = Logger.getLogger(TruffleVM.class.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	77 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	78 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	79 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	80 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	81 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	82 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	83 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	84 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	85 private final Map<String, Object> globals;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	86 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	87
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating 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 * 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	90 */
f879b1fe3773 Separating 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 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	92 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	93 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	94 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	95 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	96 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	97 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	98 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	99 this.executor = null;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	100 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 * 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	104 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	105 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	106 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	107 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	108 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	109 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	110 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	111 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	112 this.globals = new HashMap<>(globals);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	113 this.langs = 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	114 Enumeration<URL> en;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	115 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	116 en = loader().getResources("META-INF/truffle/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	117 } 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	118 throw new IllegalStateException("Cannot read list of Truffle languages", 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	119 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	120 while (en.hasMoreElements()) {
f879b1fe3773 Separating 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 URL u = en.nextElement();
f879b1fe3773 Separating 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 Properties 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	123 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	124 p = new Properties();
f879b1fe3773 Separating 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 try (InputStream is = u.openStream()) {
f879b1fe3773 Separating 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 p.load(is);
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating 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 } 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	129 LOG.log(Level.CONFIG, "Cannot process " + u + " as language definition", 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	130 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	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 for (int cnt = 1;; cnt++) {
f879b1fe3773 Separating 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 String prefix = "language" + cnt + ".";
f879b1fe3773 Separating 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 if (p.getProperty(prefix + "name") == 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	135 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	136 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	137 Language l = new Language(prefix, 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	138 for (String mimeType : l.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	139 langs.put(mimeType, l);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	140 }
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	144
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	145 static ClassLoader loader() {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	146 ClassLoader l = TruffleVM.class.getClassLoader();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	147 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	148 l = ClassLoader.getSystemClassLoader();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	149 }
f879b1fe3773 Separating 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 return l;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	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 /**
f879b1fe3773 Separating 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 * 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	155 * 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	156 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	157 * <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	158 * {@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	159 * .{@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	160 * .{@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	161 * .{@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	162 * .{@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	163 * </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	164 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	165 * 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	166 * 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	167 * {@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	168 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	169 * @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	170 */
f879b1fe3773 Separating 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 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	172 // 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	173 // 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	174 // 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	175 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	176 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	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 /**
f879b1fe3773 Separating 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 * 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	181 * 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	182 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	183 * <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	184 * {@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	185 * .{@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	186 * .{@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	187 * .{@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	188 * .{@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	189 * </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	190 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	191 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	192 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	193 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	194 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	195 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	196 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	197 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	198
f879b1fe3773 Separating 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 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	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 /**
f879b1fe3773 Separating 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 * 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	204 * {@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	205 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	206 * @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	207 * @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	208 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	209 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	210 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	211 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	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 /**
f879b1fe3773 Separating 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 * 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	216 * {@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	217 *
f879b1fe3773 Separating 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 * @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	219 * @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	220 */
f879b1fe3773 Separating 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 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	222 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	223 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	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 /**
f879b1fe3773 Separating 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 * 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	228 * {@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	229 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	230 * @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	231 * @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	232 */
f879b1fe3773 Separating 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 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	234 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	235 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	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 /**
f879b1fe3773 Separating 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 * 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	240 * {@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	241 *
f879b1fe3773 Separating 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 * @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	243 * @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	244 */
f879b1fe3773 Separating 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 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	246 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	247 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	248 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	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 /**
f879b1fe3773 Separating 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 * 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	253 * 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	254 * 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	255 * 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	256 * 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	257 *
f879b1fe3773 Separating 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 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	259 * @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	260 * <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	261 * @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	262 * @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	263 */
f879b1fe3773 Separating 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 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	265 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	266 return this;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	267 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	268
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	269 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	270 * 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	271 * {@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	272 * {@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	273 * 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	274 * 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	275 * { {@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	276 * 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	277 * {@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	278 * 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	279 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	280 * @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	281 * 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	282 * @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	283 */
f879b1fe3773 Separating 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 @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	285 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	286 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	287 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	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 /**
f879b1fe3773 Separating 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 * 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	292 * 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	293 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	294 * @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	295 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	296 public 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	297 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	298 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	299 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	300 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	301 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	302 }
f879b1fe3773 Separating 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 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	304 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	305 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	306 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	307 @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	308 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	309 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	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 };
f879b1fe3773 Separating 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 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	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 /**
f879b1fe3773 Separating 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 * 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	318 *
f879b1fe3773 Separating 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 * @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	320 * 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	321 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	322 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	323 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	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 /**
f879b1fe3773 Separating 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 * 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	328 * 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	329 * 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	330 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	331 * @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	332 * @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	333 * @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	334 * 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	335 * @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	336 */
f879b1fe3773 Separating 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 @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	338 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	339 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	340 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	341 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	342 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	343 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	344 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	345 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	346 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	347 } 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	348 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	349 } 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	350 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	351 } 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	352 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	353 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	354 } 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	355 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	356 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	357 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	358 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	359 }
f879b1fe3773 Separating 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 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	361 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	362 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	363 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	364 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	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 /**
f879b1fe3773 Separating 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 * 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	369 * {@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	370 *
f879b1fe3773 Separating 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 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	372 * @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	373 * @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	374 * @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	375 * @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	376 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	377 @Deprecated
f879b1fe3773 Separating 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 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	379 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	380 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	381 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	382 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	383 }
f879b1fe3773 Separating 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 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	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 /**
f879b1fe3773 Separating 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 * 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	389 * {@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	390 *
f879b1fe3773 Separating 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 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	392 * @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	393 * @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	394 * @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	395 * @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	396 */
f879b1fe3773 Separating 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 @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	398 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	399 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	400 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	401 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	402 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	403 }
f879b1fe3773 Separating 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 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	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 /**
f879b1fe3773 Separating 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 * 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	409 * {@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	410 * 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	411 *
f879b1fe3773 Separating 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 * @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	413 * @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	414 * @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	415 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	416 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	417 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	418 checkThread();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	419 Language l = langs.get(mimeType);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	420 if (l == null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	421 throw new IOException("No language for MIME type " + mimeType + " found. Supported types: " + langs.keySet());
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	422 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	423 return eval(l, source);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	424 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	425
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	426 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	427 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	428 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	429 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	430 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	431 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	432 @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	433 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	434 TruffleLanguage<?> langImpl = l.getImpl();
f879b1fe3773 Separating 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 lang[0] = langImpl;
f879b1fe3773 Separating 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 TruffleVM.findDebuggerSupport(langImpl);
f879b1fe3773 Separating 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 evalImpl(fillIn, s, result, langImpl, 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 });
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	440 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	441 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	442 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	443
22132 19205292b0c7 Suppressing "try" lints Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22129 diff changeset	444 @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	445 private void evalImpl(Debugger[] fillIn, Source s, Object[] result, TruffleLanguage<?> l, 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	446 try (Closeable d = SPI.executionStart(this, 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	447 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	448 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	449 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	450 result[0] = SPI.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	451 } 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	452 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	453 } 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	454 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	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
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating 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 * 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	460 * 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	461 * 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	462 * <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	463 * 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	464 * 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	465 * <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	466 * <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	467 * <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	468 * </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	469 * 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	470 * 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	471 *
f879b1fe3773 Separating 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 * @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	473 * @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	474 */
f879b1fe3773 Separating 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 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	476 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	477 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	478 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	479 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	480 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	481 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	482 @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	483 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	484 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	485 }
f879b1fe3773 Separating 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 });
f879b1fe3773 Separating 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 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	488 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	489 } 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	490 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	491 }
f879b1fe3773 Separating 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 } 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	493 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	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 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	496 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 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	499 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	500 for (Language dl : 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	501 TruffleLanguage<?> l = dl.getImpl();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	502 obj[0] = SPI.findExportedSymbol(dl.getEnv(), globalName, 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	503 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	504 lang[0] = l;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	505 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	506 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	507 }
f879b1fe3773 Separating 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 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	510 for (Language dl : 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	511 TruffleLanguage<?> l = dl.getImpl();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	512 obj[0] = SPI.findExportedSymbol(dl.getEnv(), globalName, false);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	513 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	514 lang[0] = l;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	515 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	516 }
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	518 }
f879b1fe3773 Separating 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 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	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 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	523 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	524 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	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 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 @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	529 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	530 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	531 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	532 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	533 }
f879b1fe3773 Separating 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 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	535 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	536 }
f879b1fe3773 Separating 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 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	538 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 @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	541 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	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 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	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("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	549 <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	550 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	551 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	552 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	553 }
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	555 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	556
f879b1fe3773 Separating 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 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	558 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	559 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	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 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	562 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	563 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating 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 * 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	568 * 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	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 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	571 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	572 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	573 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	574 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	575
f879b1fe3773 Separating 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 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	577 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	578 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	579 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	580 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	582 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	583 * 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	584 * 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	585 * {@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	586 * 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	587 *
f879b1fe3773 Separating 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 * @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	589 * @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	590 */
f879b1fe3773 Separating 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 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	592 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	593 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	594 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	595 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating 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 * 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	599 * 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	600 * 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	601 * 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	602 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	603 * @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	604 * 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	605 * @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	606 * @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	607 * <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	608 * @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	609 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	610 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	611 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	612 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	613 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	614 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	615 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	616 @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	617 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	618 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	619 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	620 });
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	621 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	622 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	623 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	624
22132 19205292b0c7 Suppressing "try" lints Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22129 diff changeset	625 @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	626 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	627 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	628 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	629 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	630 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	631 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	632 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	633 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	634 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	635 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	636 }
f879b1fe3773 Separating 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 } 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	638 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	639 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	640 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	641 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	642 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	643 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	644 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	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 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	647 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	648 } 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	649 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	650 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	651 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	652 } 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	653 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	654 } 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	655 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	656 } 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	657 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	658 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	659 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	660
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	661 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	662 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	663 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	664 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	665 } 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	666 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	667 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	668 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	669 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	670
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	671 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	672 * 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	673 * 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	674 * 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	675 * 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	676 * 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	677 * 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	678 * {@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	679 */
f879b1fe3773 Separating 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 public final class 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	681 private final Properties props;
f879b1fe3773 Separating 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 private TruffleLanguage<?> 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	683 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	684 private final String prefix;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	685 private String shortName;
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 Language(String prefix, Properties props) {
f879b1fe3773 Separating 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 this.prefix = prefix;
f879b1fe3773 Separating 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 this.props = props;
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating 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 * 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	694 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	695 * @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	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 public Set<String> 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	698 TreeSet<String> ts = new TreeSet<>();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	699 for (int i = 0;; i++) {
f879b1fe3773 Separating 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 String mt = props.getProperty(prefix + "mimeType." + i);
f879b1fe3773 Separating 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 if (mt == 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	702 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	703 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	704 ts.add(mt);
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating 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 return Collections.unmodifiableSet(ts);
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 * 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	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 * @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	713 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	714 public String 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	715 return props.getProperty(prefix + "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	716 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 * 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	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 * @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	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 public String getVersion() {
f879b1fe3773 Separating 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 return props.getProperty(prefix + "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	725 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating 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 * 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	729 *
f879b1fe3773 Separating 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 * @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	731 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	732 public String getShortName() {
f879b1fe3773 Separating 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 if (shortName == 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	734 shortName = getName() + "(" + getVersion() + ")";
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	735 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	736 return shortName;
f879b1fe3773 Separating 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 TruffleLanguage<?> getImpl() {
f879b1fe3773 Separating 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 if (impl == 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	741 String n = props.getProperty(prefix + "className");
f879b1fe3773 Separating 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 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	743 impl = LanguageCache.find(n, loader());
f879b1fe3773 Separating 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 env = SPI.attachEnv(TruffleVM.this, impl, out, err, 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	745 } catch (Exception 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	746 throw new IllegalStateException("Cannot initialize " + getShortName() + " language with implementation " + n, 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	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 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	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
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	752 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	753 public 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	754 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	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 TruffleLanguage.Env getEnv() {
f879b1fe3773 Separating 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 if (env == 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	759 env = SPI.attachEnv(TruffleVM.this, impl, out, err, 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	760 }
f879b1fe3773 Separating 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 return 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	762 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	763 } // 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	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 // 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	767 //
f879b1fe3773 Separating 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 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	770 Class<? extends TruffleLanguage> languageClazz = SPI.findLanguage(probe);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	771 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	772 Language languageDescription = entrySet.getValue();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	773 if (languageClazz.isInstance(languageDescription.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	774 return languageDescription.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	775 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	776 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	777 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	778 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	779
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	780 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	781 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	782 Language languageDescription = entrySet.getValue();
f879b1fe3773 Separating 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 if (languageClazz.isInstance(languageDescription.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	784 return languageDescription.getEnv();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	785 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	786 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	787 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	788 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	789
f879b1fe3773 Separating 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 static DebugSupportProvider findDebuggerSupport(TruffleLanguage<?> l) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	791 return SPI.getDebugSupport(l);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	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 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	795 @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	796 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	797 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	798 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	799 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	800 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	801 }
f879b1fe3773 Separating 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 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	803 for (Language dl : uniqueLang) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	804 TruffleLanguage<?> l = dl.getImpl();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	805 if (l == ownLang) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	806 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	807 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	808 Object obj = SPI.findExportedSymbol(dl.getEnv(), globalName, 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	809 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	810 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	811 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	812 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	813 for (Language dl : uniqueLang) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	814 TruffleLanguage<?> l = dl.getImpl();
f879b1fe3773 Separating 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 if (l == ownLang) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	816 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	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 Object obj = SPI.findExportedSymbol(dl.getEnv(), globalName, false);
f879b1fe3773 Separating 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 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	820 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	821 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	822 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	823 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	824 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	825
f879b1fe3773 Separating 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 @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	827 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	828 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	829 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	830 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	831
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	832 @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	833 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	834 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	835 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	836
f879b1fe3773 Separating 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 @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	838 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	839 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	840 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	841
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	842 @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	843 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	844 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	845 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	846
f879b1fe3773 Separating 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 @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	848 public ToolSupportProvider getToolSupport(TruffleLanguage<?> l) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	849 return super.getToolSupport(l);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	850 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	851
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	852 @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	853 public DebugSupportProvider getDebugSupport(TruffleLanguage<?> l) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	854 return super.getDebugSupport(l);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	855 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	856
f879b1fe3773 Separating 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 @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	858 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	859 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	860 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	861
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	862 @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	863 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	864 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	865 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	866 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 @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	869 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	870 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	871 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	872 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	873
f879b1fe3773 Separating 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 @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	875 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	876 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	877 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	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 } // 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	880 }

Mercurial > hg > truffle

annotate truffle/com.oracle.truffle.api.vm/src/com/oracle/truffle/api/vm/TruffleVM.java @ 22132:19205292b0c7