TruffleLanguage.Env

java.lang.Object
- com.oracle.truffle.api.TruffleLanguage.Env

Enclosing class:

TruffleLanguage<C>
```
public static final class TruffleLanguage.Env
extends Object
```
Represents execution environment of the TruffleLanguage. Each active TruffleLanguage receives instance of the environment before any code is executed upon it. The environment has knowledge of all active languages and can exchange symbols between them.

Since:

0.8 or earlier

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addToHostClassPath(TruffleFile entry)` Adds an entry to the Java host class loader.
`Object`	`asBoxedGuestValue(Object guestObject)` Wraps primitive interop values in a TruffleObject exposing their methods as members.
`Object`	`asGuestValue(Object hostObject)` Converts a existing Java host object to a guest language value.
`Throwable`	`asHostException(Throwable exception)` Unwraps a host exception thrown by a Java method invocation.
`Object`	`asHostObject(Object value)` Returns the java host representation of a Truffle guest object if it represents a Java host language object.
`Object`	`asHostSymbol(Class<?> symbolClass)` Converts a Java class to a host symbol as if by `lookupHostSymbol(symbolClass.getName())` but without an actual lookup.
`TruffleFile`	`createTempDirectory(TruffleFile dir, String prefix, FileAttribute<?>... attrs)` Creates a new directory in the specified or default temporary directory, using the given prefix to generate its name.
`TruffleFile`	`createTempFile(TruffleFile dir, String prefix, String suffix, FileAttribute<?>... attrs)` Creates a new empty file in the specified or default temporary directory, using the given prefix and suffix to generate its name.
`Thread`	`createThread(Runnable runnable)` Creates a new thread that has access to the current language context.
`Thread`	`createThread(Runnable runnable, TruffleContext context)` Creates a new thread that has access to the given context.
`Thread`	`createThread(Runnable runnable, TruffleContext context, ThreadGroup group)` Creates a new thread that has access to the given context.
`Thread`	`createThread(Runnable runnable, TruffleContext context, ThreadGroup group, long stackSize)` Creates a new thread that has access to the given context.
`OutputStream`	`err()` Standard error writer provided by `Context.Builder.err(OutputStream)` this language is being executed in.
`void`	`exportSymbol(String symbolName, Object value)` Explicitly exports a symbol to the polyglot bindings object.
`Object`	`findMetaObject(Object value)` Find a metaobject of a value, if any.
`String[]`	`getApplicationArguments()` Returns the application arguments that were provided for this context.
`Map<String,Object>`	`getConfig()` Configuration arguments passed from an outer language context to an inner language context.
`TruffleContext`	`getContext()` Returns the polyglot context associated with this environment.
`TruffleFile`	`getCurrentWorkingDirectory()` Gets the current working directory.
`Map<String,String>`	`getEnvironment()` Returns an unmodifiable map of the process environment.
`String`	`getFileNameSeparator()` Returns the name separator used to separate names in `TruffleFile`'s path string.
`Map<String,InstrumentInfo>`	`getInstruments()` Returns a map instrument-id to instrument instance of all instruments that are installed in the environment.
`Map<String,LanguageInfo>`	`getInternalLanguages()` Returns all languages that are installed and internally accessible in the environment.
`TruffleFile`	`getInternalTruffleFile(String path)` Returns a public or internal `TruffleFile` for given path.
`TruffleFile`	`getInternalTruffleFile(URI uri)` Returns a public or internal `TruffleFile` for given `URI`.
`org.graalvm.options.OptionValues`	`getOptions()` Returns option values for the options described in `TruffleLanguage.getOptionDescriptors()`.
`String`	`getPathSeparator()` Returns the path separator used to separate filenames in a path list.
`Object`	`getPolyglotBindings()` Returns a TruffleObject that represents the polyglot bindings.
`Map<String,LanguageInfo>`	`getPublicLanguages()` Returns all languages that are installed and publicly accessible in the environment.
`TruffleFile`	`getPublicTruffleFile(String path)` Returns a public `TruffleFile` for given path.
`TruffleFile`	`getPublicTruffleFile(URI uri)` Returns a public `TruffleFile` for given `URI`.
`ZoneId`	`getTimeZone()` Returns the default time zone of this environment.
`Object`	`importSymbol(String symbolName)` Explicitly imports a symbol from the polyglot bindings.
`InputStream`	`in()` Input stream provided by `Context.Builder.in(InputStream)` this language is being executed in.
`boolean`	`initializeLanguage(LanguageInfo targetLanguage)` Ensures that the target language is initialized.
`boolean`	`isCreateProcessAllowed()` Returns `true` if the creation of a sub-process is allowed in the current environment.
`boolean`	`isCreateThreadAllowed()` Returns `true` if the creation of new threads is allowed in the current environment.
`boolean`	`isHostException(Throwable exception)` Tests whether an exception is a host exception thrown by a Java Interop method invocation.
`boolean`	`isHostFunction(Object value)` Returns `true` if the argument is a Java host language function wrapped using Truffle interop.
`boolean`	`isHostLookupAllowed()` Returns `true` if host access is generally allowed.
`boolean`	`isHostObject(Object value)` Returns `true` if the argument is Java host language object wrapped using Truffle interop.
`boolean`	`isHostSymbol(Object guestObject)` Returns `true` if the argument is a host symbol, representing the constructor and static members of a Java class, as obtained by e.g.
`boolean`	`isMimeTypeSupported(String mimeType)` Allows it to be determined if this `Context` can execute code written in a language with a given MIME type.
`boolean`	`isNativeAccessAllowed()` Returns `true` if access to native code is generally allowed.
`boolean`	`isPolyglotBindingsAccessAllowed()` Returns `true` if polyglot bindings access is allowed, else `false` .
`boolean`	`isPolyglotEvalAllowed()` Returns `true` if polyglot evaluation is allowed, else `false`.
`boolean`	`isPreInitialization()` Returns `true` if this `Context` is being pre-initialized.
`<T> T`	`lookup(Class<T> type)` Looks additional service up.
`<S> S`	`lookup(InstrumentInfo instrument, Class<S> type)` Returns an additional service provided by this instrument, specified by type.
`<S> S`	`lookup(LanguageInfo language, Class<S> type)` Returns an additional service provided by the given language, specified by type.
`Object`	`lookupHostSymbol(String symbolName)` Looks up a Java class in the top-most scope the host environment.
`TruffleContext.Builder`	`newContextBuilder()` Returns a new context builder useful to create inner context instances.
`TruffleProcessBuilder`	`newProcessBuilder(String... command)` Creates a new process builder with the specified operating program and arguments.
`OutputStream`	`out()` Standard output writer provided by `Context.Builder.out(OutputStream)` this language is being executed in.
`CallTarget`	`parseInternal(Source source, String... argumentNames)` Parses the source of a public or internal language and returns the parse result as `CallTarget`.
`CallTarget`	`parsePublic(Source source, String... argumentNames)` Parses the source of a public language and returns the parse result as `CallTarget` .
`void`	`registerService(Object service)` Registers additional services provided by the language.
`void`	`setCurrentWorkingDirectory(TruffleFile currentWorkingDirectory)` Sets the current working directory.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - getOptions
```
public org.graalvm.options.OptionValues getOptions()
```
    Returns option values for the options described in TruffleLanguage.getOptionDescriptors(). The returned options are never null.
    
    Since:
    
    0.27
  - getApplicationArguments
```
public String[] getApplicationArguments()
```
    Returns the application arguments that were provided for this context. The arguments array and its elements are never null. It is up to the language implementation whether and how they are accessible within the guest language scripts.
    
    Since:
    
    0.27
  - isCreateThreadAllowed
```
public boolean isCreateThreadAllowed()
```
    Returns true if the creation of new threads is allowed in the current environment.
    
    Since:
    
    0.28
    
    See Also:
    
    TruffleLanguage.Env.createThread(Runnable)
  - createThread
```
public Thread createThread(Runnable runnable)
```
    Creates a new thread that has access to the current language context. See TruffleLanguage.Env.createThread(Runnable, TruffleContext, ThreadGroup, long) for a detailed description of the parameters. The group is null and stackSize set to 0.
    
    Since:
    
    0.28
  - createThread
```
public Thread createThread(Runnable runnable,
                           TruffleContext context)
```
    Creates a new thread that has access to the given context. See TruffleLanguage.Env.createThread(Runnable, TruffleContext, ThreadGroup, long) for a detailed description of the parameters. The group is null and stackSize set to 0.
    
    Since:
    
    0.28
    
    See Also:
    
    TruffleLanguage.Env.getContext(), TruffleLanguage.Env.newContextBuilder()
  - createThread
```
public Thread createThread(Runnable runnable,
                           TruffleContext context,
                           ThreadGroup group)
```
    Creates a new thread that has access to the given context. See TruffleLanguage.Env.createThread(Runnable, TruffleContext, ThreadGroup, long) for a detailed description of the parameters. The stackSize set to 0.
    
    Since:
    
    0.28
    
    See Also:
    
    TruffleLanguage.Env.getContext(), TruffleLanguage.Env.newContextBuilder()
  - createThread
```
public Thread createThread(Runnable runnable,
                           TruffleContext context,
                           ThreadGroup group,
                           long stackSize)
```
    Creates a new thread that has access to the given context. A thread is initialized when it is started and disposed as soon as the thread finished the execution.
    It is recommended to set an uncaught exception handler for the created thread. For example the thread can throw an uncaught exception if one of the initialized language contexts don't support execution on this thread.
    The language that created and started the thread is responsible to complete all running or waiting threads when the context is disposed.
    The TruffleContext can be either an inner context created by TruffleLanguage.Env.newContextBuilder().build(), or the context associated with this environment obtained from TruffleLanguage.Env.getContext().
    
    Parameters:
    
    runnable - the runnable to run on this thread.
    
    context - the context to enter and leave when the thread is started.
    
    group - the thread group, passed on to the underlying Thread.
    
    stackSize - the desired stack size for the new thread, or zero if this parameter is to be ignored.
    
    Throws:
    
    IllegalStateException - if thread creation is not allowed.
    
    Since:
    
    0.28
    
    See Also:
    
    TruffleLanguage.Env.getContext(), TruffleLanguage.Env.newContextBuilder()
  - newContextBuilder
```
public TruffleContext.Builder newContextBuilder()
```
    Returns a new context builder useful to create inner context instances.
    
    Since:
    
    0.27
    
    See Also:
    
    for details on language inner contexts.
  - getPolyglotBindings
```
public Object getPolyglotBindings()
```
    Returns a TruffleObject that represents the polyglot bindings. The polyglot bindings consists of a set of symbols that have been exported explicitly by the languages or the embedder. This set of symbols allows for data exchange between polyglot languages. The polyglot bindings is separate from language bindings. The symbols can by read using string identifiers, a list of symbols may be requested with the keys message. Existing identifiers are removable, modifiable, readable and any new identifiers are insertable.
    
    Throws:
    
    SecurityException - if polyglot access is not enabled
    
    Since:
    
    0.32
    
    See Also:
    
    TruffleLanguage.Env.isPolyglotBindingsAccessAllowed()
  - importSymbol
```
public Object importSymbol(String symbolName)
```
    Explicitly imports a symbol from the polyglot bindings. The behavior of this method is equivalent to sending a READ message to the polyglot bindings object. Reading a symbol that does not exist will return null.
    The returned symbol value can either be a TruffleObject (e.g. a native object from the other language) to support interoperability between languages, String or one of the Java primitive wrappers ( Integer, Double, Byte, Boolean, etc.).
    Polyglot symbols can only be imported if the polyglot bindings access is allowed.
    
    Parameters:
    
    symbolName - the name of the symbol to search for
    
    Returns:
    
    object representing the symbol or null if it does not exist
    
    Throws:
    
    SecurityException - if importing polyglot symbols is not allowed
    
    Since:
    
    0.8 or earlier
  - exportSymbol
```
public void exportSymbol(String symbolName,
                         Object value)
```
    Explicitly exports a symbol to the polyglot bindings object. The behavior of this method is equivalent to sending a WRITE message to the polyglot bindings object. Exporting a symbol with a null value will remove the symbol from the polyglot object.
    The exported symbol value can either be a TruffleObject (e.g. a native object from the other language) to support interoperability between languages, String or one of the Java primitive wrappers ( Integer, Double, Byte, Boolean, etc.).
    Polyglot symbols can only be export if the polyglot bindings access is allowed.
    
    Parameters:
    
    symbolName - the name with which the symbol should be exported into the polyglot scope
    
    value - the value to export for
    
    Throws:
    
    SecurityException - if exporting polyglot symbols is not allowed
    
    Since:
    
    0.27
  - isHostLookupAllowed
```
public boolean isHostLookupAllowed()
```
    Returns true if host access is generally allowed. If this method returns false then TruffleLanguage.Env.lookupHostSymbol(String) will always fail. Host lookup is generally disallowed if the embedder provided a null host class filter.
    
    Since:
    
    0.27
  - addToHostClassPath
```
public void addToHostClassPath(TruffleFile entry)
```
    Adds an entry to the Java host class loader. All classes looked up with TruffleLanguage.Env.lookupHostSymbol(String) will lookup classes with this new entry. If the entry was already added then calling this method again for the same entry has no effect. Given entry must not be null.
    
    Throws:
    
    SecurityException - if the file is not readable.
    
    Since:
    
    19.0
  - lookupHostSymbol
```
public Object lookupHostSymbol(String symbolName)
```
    Looks up a Java class in the top-most scope the host environment. Throws an error if no symbol was found or the symbol was not accessible. Symbols might not be accessible if a host class filter prevents access. The returned object is always a TruffleObject that represents the class symbol.
    
    Parameters:
    
    symbolName - the qualified class name in the host language.
    
    Since:
    
    0.27
  - isHostObject
```
public boolean isHostObject(Object value)
```
    Returns true if the argument is Java host language object wrapped using Truffle interop.
    
    Since:
    
    19.0
    
    See Also:
    
    TruffleLanguage.Env.asHostObject(Object)
  - asHostObject
```
public Object asHostObject(Object value)
```
    Returns the java host representation of a Truffle guest object if it represents a Java host language object. Throws ClassCastException if the provided argument is not a host object.
    
    Since:
    
    19.0
  - asGuestValue
```
public Object asGuestValue(Object hostObject)
```
    Converts a existing Java host object to a guest language value. If the value is already an interop value, then no conversion will be performed. Otherwise, the returned wraps the host object and provides support for the interop contract to access the java members. The interpretation of converted objects is described in Context.asValue(Object).
    This method should be used exclusively to convert already allocated Java objects to a guest language representation. To allocate new host objects users should use TruffleLanguage.Env.lookupHostSymbol(String) to lookup the class and then send a NEW interop message to that object to instantiate it. This method does not respect configured class filters.
    
    Parameters:
    
    hostObject - the host object to convert
    
    Since:
    
    19.0
  - asBoxedGuestValue
```
public Object asBoxedGuestValue(Object guestObject)
```
    Wraps primitive interop values in a TruffleObject exposing their methods as members. By default primitive host values are not wrapped in TruffleObjects to expose their members. This method is intended for compatibility with existing Java interop APIs that expect such behavior. This method boxes the following primitive interop values: Boolean, Byte, Short, Integer, Long, Float, Double , Character, String. If the provided value is already boxed then the current value will be returned. If the provided value is not an interop value then an IllegalArgumentException will be thrown.
    
    Parameters:
    
    guestObject - the primitive guest value to box
    
    Throws:
    
    IllegalArgumentException - if value is an invalid interop value.
    
    Since:
    
    19.0
    
    See Also:
    
    TruffleLanguage.Env.asGuestValue(Object)
  - isHostFunction
```
public boolean isHostFunction(Object value)
```
    Returns true if the argument is a Java host language function wrapped using Truffle interop.
    
    Since:
    
    19.0
  - findMetaObject
```
public Object findMetaObject(Object value)
```
    Find a metaobject of a value, if any. The metaobject represents a description of the object, reveals it's kind and it's features. Some information that a metaobject might define includes the base object's type, interface, class, methods, attributes, etc.
    When no metaobject is known, returns null. The metaobject is an interop value. An interop value can be either a TruffleObject (e.g. a native object from the other language) to support interoperability between languages or a String.
    
    Parameters:
    
    value - the value to find the meta object for.
    
    Since:
    
    19.0
  - isHostException
```
public boolean isHostException(Throwable exception)
```
    Tests whether an exception is a host exception thrown by a Java Interop method invocation. Host exceptions may be thrown by interoperability messages. The host exception may be unwrapped using TruffleLanguage.Env.asHostException(Throwable).
    
    Parameters:
    
    exception - the Throwable to test
    
    Returns:
    
    true if the exception is a host exception, false otherwise
    
    Since:
    
    19.0
    
    See Also:
    
    TruffleLanguage.Env.asHostException(Throwable)
  - asHostException
```
public Throwable asHostException(Throwable exception)
```
    Unwraps a host exception thrown by a Java method invocation. Host exceptions may be thrown by interoperability messages. The host exception may be unwrapped using TruffleLanguage.Env.asHostException(Throwable).
    
    Parameters:
    
    exception - the host exception to unwrap
    
    Returns:
    
    the original Java exception
    
    Throws:
    
    IllegalArgumentException - if the exception is not a host exception
    
    Since:
    
    19.0
    
    See Also:
    
    TruffleLanguage.Env.isHostException(Throwable)
  - isHostSymbol
```
public boolean isHostSymbol(Object guestObject)
```
    Returns true if the argument is a host symbol, representing the constructor and static members of a Java class, as obtained by e.g. TruffleLanguage.Env.lookupHostSymbol(java.lang.String).
    
    Since:
    
    19.0
    
    See Also:
    
    TruffleLanguage.Env.lookupHostSymbol(String)
  - asHostSymbol
```
public Object asHostSymbol(Class<?> symbolClass)
```
    Converts a Java class to a host symbol as if by lookupHostSymbol(symbolClass.getName()) but without an actual lookup. Must not be used with Truffle or guest language classes.
    
    Since:
    
    19.0
    
    See Also:
    
    TruffleLanguage.Env.lookupHostSymbol(String)
  - isNativeAccessAllowed
```
public boolean isNativeAccessAllowed()
```
    Returns true if access to native code is generally allowed. If this method returns false then loading native libraries with the Truffle NFI will fail.
    
    Since:
    
    19.0
  - isPolyglotEvalAllowed
```
public boolean isPolyglotEvalAllowed()
```
    Returns true if polyglot evaluation is allowed, else false. Guest languages should hide or disable all polyglot evaluation builtins if this flag is set to false. Note that if polyglot evaluation access is disabled, then the available languages list only shows the current language, dependent languages and internal languages.
    
    Since:
    
    19.2
    
    See Also:
    
    Context.Builder.allowPolyglotAccess(org.graalvm.polyglot.PolyglotAccess)
  - isPolyglotBindingsAccessAllowed
```
public boolean isPolyglotBindingsAccessAllowed()
```
    Returns true if polyglot bindings access is allowed, else false . Guest languages should hide or disable all polyglot bindings builtins if this flag is set to false. If polyglot bindings access is disabled then TruffleLanguage.Env.getPolyglotBindings(), TruffleLanguage.Env.importSymbol(String) or TruffleLanguage.Env.exportSymbol(String, Object) fails with a SecurityException.
    
    Since:
    
    19.2
    
    See Also:
    
    Context.Builder.allowPolyglotAccess(org.graalvm.polyglot.PolyglotAccess)
  - isMimeTypeSupported
```
public boolean isMimeTypeSupported(String mimeType)
```
    Allows it to be determined if this Context can execute code written in a language with a given MIME type.
    
    Returns:
    
    a boolean that indicates if the MIME type is supported
    
    Since:
    
    0.11
    
    See Also:
    
    Source.getMimeType(), TruffleLanguage.Env.parsePublic(Source, String...)
  - parseInternal
```
public CallTarget parseInternal(Source source,
                                String... argumentNames)
```
    Parses the source of a public or internal language and returns the parse result as CallTarget. The language id is used to identify the TruffleLanguage to use to perform the TruffleLanguage.parse(com.oracle.truffle.api.TruffleLanguage.ParsingRequest). The names of arguments are parameters for the resulting {#link CallTarget} that allow the source to reference the actual parameters passed to CallTarget.call(java.lang.Object...).
    Compared to TruffleLanguage.Env.parsePublic(Source, String...) this method provides also access to internal and dependent languages in addition to public languages. For example, in JavaScript, a call to the eval builtin should forward to TruffleLanguage.Env.parsePublic(Source, String...) as it contains code provided by the guest language user. Parsing regular expressions with the internal regular expression engine should call TruffleLanguage.Env.parseInternal(Source, String...) instead, as this is considered an implementation detail of the language.
    It is recommended that the language uses TruffleLanguage.Env.parsePublic(Source, String...) or TruffleLanguage.Env.parseInternal(Source, String...) instead of directly passing the Source to the parser, in order to support code caching with TruffleLanguage.ContextPolicy.SHARED and TruffleLanguage.ContextPolicy.REUSE.
    
    Parameters:
    
    source - the source to evaluate
    
    argumentNames - the names of CallTarget.call(java.lang.Object...) arguments that can be referenced from the source
    
    Returns:
    
    the call target representing the parsed result
    
    Since:
    
    19.2
    
    See Also:
    
    TruffleLanguage.Env.parsePublic(Source, String...)
  - parsePublic
```
public CallTarget parsePublic(Source source,
                              String... argumentNames)
```
    Parses the source of a public language and returns the parse result as CallTarget . The language id is used to identify the TruffleLanguage to use to perform the TruffleLanguage.parse(com.oracle.truffle.api.TruffleLanguage.ParsingRequest). The names of arguments are parameters for the resulting {#link CallTarget} that allow the source to reference the actual parameters passed to CallTarget.call(java.lang.Object...).
    Compared to TruffleLanguage.Env.parseInternal(Source, String...) this method does only provide access to non internal, non dependent, public languages. Public languages are configured by the embedder to be accessible to the guest language program. For example, in JavaScript, a call to the eval builtin should forward to TruffleLanguage.Env.parsePublic(Source, String...) as it contains code provided by the guest language user. Parsing regular expressions with the internal regular expression engine should call TruffleLanguage.Env.parseInternal(Source, String...) instead, as this is considered an implementation detail of the language.
    It is recommended that the language uses TruffleLanguage.Env.parsePublic(Source, String...) or TruffleLanguage.Env.parseInternal(Source, String...) instead of directly passing the Source to the parser, in order to support code caching with TruffleLanguage.ContextPolicy.SHARED and TruffleLanguage.ContextPolicy.REUSE.
    
    Parameters:
    
    source - the source to evaluate
    
    argumentNames - the names of CallTarget.call(java.lang.Object...) arguments that can be referenced from the source
    
    Returns:
    
    the call target representing the parsed result
    
    Since:
    
    19.2
    
    See Also:
    
    TruffleLanguage.Env.parseInternal(Source, String...)
  - in
```
public InputStream in()
```
    Input stream provided by Context.Builder.in(InputStream) this language is being executed in.
    
    Returns:
    
    reader, never null
    
    Since:
    
    0.8 or earlier
  - out
```
public OutputStream out()
```
    Standard output writer provided by Context.Builder.out(OutputStream) this language is being executed in.
    
    Returns:
    
    writer, never null
    
    Since:
    
    0.8 or earlier
  - err
```
public OutputStream err()
```
    Standard error writer provided by Context.Builder.err(OutputStream) this language is being executed in.
    
    Returns:
    
    writer, never null
    
    Since:
    
    0.8 or earlier
  - lookup
```
public <T> T lookup(Class<T> type)
```
    Looks additional service up. An environment for a particular language may also be associated with additional services. One can request implementations of such services by calling this method with the type identifying the requested service and its API. Services that can be obtained via this method include Instrumenter and others.
    
    Type Parameters:
    
    T - type of requested service
    
    Parameters:
    
    type - class of requested service
    
    Returns:
    
    instance of T or null if there is no such service available
    
    Since:
    
    0.12
  - lookup
```
public <S> S lookup(InstrumentInfo instrument,
                    Class<S> type)
```
    Returns an additional service provided by this instrument, specified by type. If an instrument is not enabled, it will be enabled automatically by requesting a supported service. If the instrument does not provide a service for a given type it will not be enabled automatically.
    
    Type Parameters:
    
    S - the requested type
    
    Parameters:
    
    instrument - identification of the instrument to query
    
    type - the class of the requested type
    
    Returns:
    
    the registered service or null if none is found
    
    Since:
    
    0.26
  - lookup
```
public <S> S lookup(LanguageInfo language,
                    Class<S> type)
```
    Returns an additional service provided by the given language, specified by type. For services registered by TruffleLanguage.Registration.services() the service lookup will ensure that the language is loaded and services are registered. The provided langauge and type must not be null.
    
    Type Parameters:
    
    S - the requested type
    
    Parameters:
    
    language - the language to query
    
    type - the class of the requested type
    
    Returns:
    
    the registered service or null if none is found
    
    Since:
    
    0.26, 19.0 supports services registered by registerService
  - initializeLanguage
```
public boolean initializeLanguage(LanguageInfo targetLanguage)
```
    Ensures that the target language is initialized. This method firstly verifies that the target language is accessible from this language. If not the SecurityException is thrown. Then the target language initialization is performed if not already done.
    
    Parameters:
    
    targetLanguage - the language to initialize
    
    Throws:
    
    SecurityException - if an access to targetLanguage is not permitted
    
    Since:
    
    20.1.0
  - getInternalLanguages
```
public Map<String,LanguageInfo> getInternalLanguages()
```
    Returns all languages that are installed and internally accessible in the environment. Using the language instance additional services can be looked up. TruffleLanguage.Env.parseInternal(Source, String...) is allowed for all languages returned by this method. This list of languages should not be exposed to guest language programs, as it lists internal languages.
    
    Since:
    
    19.2
    
    See Also:
    
    TruffleLanguage.Env.lookup(LanguageInfo, Class), TruffleLanguage.Env.parseInternal(Source, String...)
  - getPublicLanguages
```
public Map<String,LanguageInfo> getPublicLanguages()
```
    Returns all languages that are installed and publicly accessible in the environment. Using the language instance additional services can be looked up. TruffleLanguage.Env.parsePublic(Source, String...) is allowed for all languages returned by this method. This list of languages may be exposed ot the guest language program.
    
    Since:
    
    19.2
    
    See Also:
    
    TruffleLanguage.Env.parsePublic(Source, String...)
  - getInstruments
```
public Map<String,InstrumentInfo> getInstruments()
```
    Returns a map instrument-id to instrument instance of all instruments that are installed in the environment. Using the instrument instance additional services can be looked up .
    
    Since:
    
    0.26
  - getTimeZone
```
public ZoneId getTimeZone()
```
    Returns the default time zone of this environment. If the time-zone was not explicitly set by the embedder then the system default time-zone will be returned.
    
    Since:
    
    19.2
    
    See Also:
    
    ZoneId.systemDefault()
  - getConfig
```
public Map<String,Object> getConfig()
```
    Configuration arguments passed from an outer language context to an inner language context. Inner language contexts can be created using TruffleLanguage.Env.newContextBuilder().
    
    Since:
    
    0.11
    
    See Also:
    
    to create inner contexts., to pass configuration objects to the inner context.
  - getContext
```
public TruffleContext getContext()
```
    Returns the polyglot context associated with this environment.
    
    Returns:
    
    the polyglot context
    
    Since:
    
    0.30
  - isPreInitialization
```
public boolean isPreInitialization()
```
    Returns true if this Context is being pre-initialized. For a given environment, the return value of this method never changes.
    
    Since:
    
    19.0
    
    See Also:
    
    TruffleLanguage.initializeContext(Object), TruffleLanguage.patchContext(Object, Env)
  - getPublicTruffleFile
```
public TruffleFile getPublicTruffleFile(String path)
```
    Returns a public TruffleFile for given path. The access to public files depends on Context's IO policy. When IO is not enabled by the Context the TruffleFile operations throw SecurityException. The getPublicTruffleFile method should be used to access user files or to implement language IO builtins.
    
    Parameters:
    
    path - the absolute or relative path to create TruffleFile for
    
    Returns:
    
    TruffleFile
    
    Since:
    
    19.3.0
  - getPublicTruffleFile
```
public TruffleFile getPublicTruffleFile(URI uri)
```
    Returns a public TruffleFile for given URI. The access to public files depends on Context's IO policy. When IO is not enabled by the Context the TruffleFile operations throw SecurityException . The getPublicTruffleFile method should be used to access user files or to implement language IO builtins.
    
    Parameters:
    
    uri - the URI to create TruffleFile for
    
    Returns:
    
    TruffleFile
    
    Since:
    
    19.3.0
  - getInternalTruffleFile
```
public TruffleFile getInternalTruffleFile(String path)
```
    Returns a public or internal TruffleFile for given path. Unlike getPublicTruffleFile the TruffleFile returned by this method for a file in a language home is readable even when IO is not enabled by the Context. The getInternalTruffleFile method should be used to read language standard libraries in a language home. For security reasons the language should check that the file is a language source file in language standard libraries folder before using this method for a file in a language home.
    
    Parameters:
    
    path - the absolute or relative path to create TruffleFile for
    
    Returns:
    
    TruffleFile
    
    Since:
    
    19.3.0
    
    See Also:
    
    TruffleLanguage.Env.getPublicTruffleFile(java.lang.String)
  - getInternalTruffleFile
```
public TruffleFile getInternalTruffleFile(URI uri)
```
    Returns a public or internal TruffleFile for given URI. Unlike getPublicTruffleFile the TruffleFile returned by this method for a file in a language home is readable even when IO is not enabled by the Context. The getInternalTruffleFile method should be used to read language standard libraries in a language home. For security reasons the language should check that the file is a language source file in language standard libraries folder before using this method for a file in a language home.
    
    Parameters:
    
    uri - the URI to create TruffleFile for
    
    Returns:
    
    TruffleFile
    
    Since:
    
    19.3.0
    
    See Also:
    
    TruffleLanguage.Env.getPublicTruffleFile(java.net.URI)
  - getCurrentWorkingDirectory
```
public TruffleFile getCurrentWorkingDirectory()
```
    Gets the current working directory. The current working directory is used to resolve non absolute paths in TruffleFile methods.
    
    Returns:
    
    the current working directory
    
    Throws:
    
    SecurityException - if the filesystem denies reading of the current working directory
    
    Since:
    
    19.0
  - setCurrentWorkingDirectory
```
public void setCurrentWorkingDirectory(TruffleFile currentWorkingDirectory)
```
    Sets the current working directory. The current working directory is used to resolve non absolute paths in TruffleFile methods.
    
    Parameters:
    
    currentWorkingDirectory - the new current working directory
    
    Throws:
    
    UnsupportedOperationException - if setting of the current working directory is not supported
    
    IllegalArgumentException - if the currentWorkingDirectory is not a valid current working directory
    
    SecurityException - if currentWorkingDirectory is not readable
    
    Since:
    
    19.0
  - getFileNameSeparator
```
public String getFileNameSeparator()
```
    Returns the name separator used to separate names in TruffleFile's path string.
    
    Returns:
    
    the name separator
    
    Since:
    
    19.0
  - getPathSeparator
```
public String getPathSeparator()
```
    Returns the path separator used to separate filenames in a path list. On UNIX the path separator is ':'. On Windows it's ';'.
    
    Returns:
    
    the path separator
    
    Since:
    
    19.1.0
  - registerService
```
public void registerService(Object service)
```
    Registers additional services provided by the language. The registered services are made available to users via TruffleLanguage.Env.lookup(com.oracle.truffle.api.nodes.LanguageInfo, java.lang.Class) query method.
    For each service interface enumerated in language registration the language has to register a single service implementation.
    This method can be called only during the execution of the createContext method, then the services are collected and cannot be changed anymore.
    
    Parameters:
    
    service - a service to be returned from associated lookup method
    
    Throws:
    
    IllegalStateException - if the method is called outside of TruffleLanguage.createContext(com.oracle.truffle.api.TruffleLanguage.Env) method
    
    Since:
    
    19.0
  - isCreateProcessAllowed
```
public boolean isCreateProcessAllowed()
```
    Returns true if the creation of a sub-process is allowed in the current environment.
    
    Since:
    
    19.1.0
    
    See Also:
    
    TruffleLanguage.Env.newProcessBuilder(java.lang.String...)
  - newProcessBuilder
```
public TruffleProcessBuilder newProcessBuilder(String... command)
```
    Creates a new process builder with the specified operating program and arguments.
    
    Parameters:
    
    command - the executable and its arguments
    
    Throws:
    
    SecurityException - when process creation is not allowed
    
    Since:
    
    19.1.0
  - getEnvironment
```
public Map<String,String> getEnvironment()
```
    Returns an unmodifiable map of the process environment. When the Context is configured with EnvironmentAccess.INHERIT it returns the System.getenv() and the environment variables configured on the Context. For the EnvironmentAccess.NONE only the environment variables configured on the Context are returned.
    
    Returns:
    
    the process environment as a map of variable names to values
    
    Since:
    
    19.1.0
  - createTempFile
```
public TruffleFile createTempFile(TruffleFile dir,
                                  String prefix,
                                  String suffix,
                                  FileAttribute<?>... attrs)
                           throws IOException
```
    Creates a new empty file in the specified or default temporary directory, using the given prefix and suffix to generate its name.
    This method provides only part of a temporary file facility. To arrange for a file created by this method to be deleted automatically the resulting file must be opened using the DELETE_ON_CLOSE option. In this case the file is deleted when the appropriate close method is invoked. Alternatively, a shutdown hook may be used to delete the file automatically.
    
    Parameters:
    
    dir - the directory in which the file should be created or null for a default temporary directory
    
    prefix - the prefix to generate the file's name or null
    
    suffix - the suffix to generate the file's name or null in which case ".tmp" is used
    
    attrs - the optional attributes to set atomically when creating the file
    
    Returns:
    
    the TruffleFile representing the newly created file that did not exist before this method was invoked
    
    Throws:
    
    IOException - in case of IO error
    
    IllegalArgumentException - if the prefix or suffix cannot be used to generate a valid file name
    
    UnsupportedOperationException - if the attributes contain an attribute which cannot be set atomically or FileSystem does not support default temporary directory
    
    SecurityException - if the FileSystem denied the operation
    
    Since:
    
    19.3.0
  - createTempDirectory
```
public TruffleFile createTempDirectory(TruffleFile dir,
                                       String prefix,
                                       FileAttribute<?>... attrs)
                                throws IOException
```
    Creates a new directory in the specified or default temporary directory, using the given prefix to generate its name.
    This method provides only part of a temporary file facility. A shutdown hook may be used to delete the directory automatically.
    
    Parameters:
    
    dir - the directory in which the directory should be created or null for a default temporary directory
    
    prefix - the prefix to generate the directory's name or null
    
    attrs - the optional attributes to set atomically when creating the directory
    
    Returns:
    
    the TruffleFile representing the newly created directory that did not exist before this method was invoked
    
    Throws:
    
    IOException - in case of IO error
    
    IllegalArgumentException - if the prefix cannot be used to generate a valid file name
    
    UnsupportedOperationException - if the attributes contain an attribute which cannot be set atomically or FileSystem does not support default temporary directory
    
    SecurityException - if the FileSystem denied the operation
    
    Since:
    
    19.3.0

Class TruffleLanguage.Env

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getOptions

getApplicationArguments

isCreateThreadAllowed

createThread

createThread

createThread

createThread

newContextBuilder

getPolyglotBindings

importSymbol

exportSymbol

isHostLookupAllowed

addToHostClassPath

lookupHostSymbol

isHostObject

asHostObject

asGuestValue

asBoxedGuestValue

isHostFunction

findMetaObject

isHostException

asHostException

isHostSymbol

asHostSymbol

isNativeAccessAllowed

isPolyglotEvalAllowed

isPolyglotBindingsAccessAllowed

isMimeTypeSupported

parseInternal

parsePublic

in

out

err

lookup

lookup

lookup

initializeLanguage

getInternalLanguages

getPublicLanguages

getInstruments

getTimeZone

getConfig

getContext

isPreInitialization

getPublicTruffleFile

getPublicTruffleFile

getInternalTruffleFile

getInternalTruffleFile

getCurrentWorkingDirectory

setCurrentWorkingDirectory

getFileNameSeparator

getPathSeparator

registerService

isCreateProcessAllowed

newProcessBuilder

getEnvironment

createTempFile

createTempDirectory