org.rexxla.bsf.engines.rexx

## Class RexxEngine

- java.lang.Object
- - org.apache.bsf.util.BSFEngineImpl
  - - org.rexxla.bsf.engines.rexx.RexxEngine

- All Implemented Interfaces:
    java.beans.PropertyChangeListener, java.util.EventListener, org.apache.bsf.BSFEngine

      public class RexxEngine
      extends org.apache.bsf.util.BSFEngineImpl

  This class manages the calls from Java via JNI to Open Object Rexx (ooRexx).

      ------------------------ Apache Version 2.0 license -------------------------
          Copyright (C) 2001-2025 Rony G. Flatscher

          Licensed under the Apache License, Version 2.0 (the "License");
          you may not use this file except in compliance with the License.
          You may obtain a copy of the License at

              http://www.apache.org/licenses/LICENSE-2.0

          Unless required by applicable law or agreed to in writing, software
          distributed under the License is distributed on an "AS IS" BASIS,
          WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
          See the License for the specific language governing permissions and
          limitations under the License.
       -----------------------------------------------------------------------------

  Version:
    850, 20250827
  Author:
    Rony G. Flatscher (WU-Wien/Wirtschaftsuniversität Wien, http://www.wu-wien.ac.at/english)

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected boolean` | `bJNITerminated` Will be set to true, if terminate() used JNI to successfully terminate the Rexx interpreter instance.
    `protected boolean` | `bTerminated` If terminate() was invoked, then this instance must not be used anymore.
    `protected long` | `id`
    `protected static java.lang.String` | `languageVersionString` The `PARSE VERSION` string of the currently ooRexx interpreter in use.
    `static java.lang.String` | `version` Version string indicating version of this class (majorVersion*100+minorVersion concatenated with a dot and the sorted date of last change.

    - ### Fields inherited from class org.apache.bsf.util.BSFEngineImpl

      `classLoader, classPath, declaredBeans, lang, mgr, tempDir`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `RexxEngine()`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `java.lang.Object` | `apply(java.lang.String source, int lineNo, int columnNo, java.lang.Object oscript, java.util.Vector vArgNames, java.util.Vector vArgs)` Applies (evaluates) a piece of Rexx code (can be a whole program as well) with Java-supplied arguments and returns the result.
    `java.lang.Object` | `call(java.lang.Object object, java.lang.String name, java.lang.Object[] args)` Calls (executes) a Rexx program which code has been supplied before via an invocation of "apply()", "exec()" or "eval()" with the Java-supplied arguments and returns the result.
    `java.lang.Object` | `call(java.lang.Object object, java.lang.String name, java.lang.Object[] args, java.lang.Object scope)` Call version that allows for supplying a Rexx class serving as the scope for the method invocation (new in ooRexx 5.0, cf.
    `java.lang.Object` | `call(RexxProxy proxy, java.lang.reflect.Method methodObject, java.lang.Object[] args)` Allows forwarding a messages to a RexxProxy using the method name of the supplied `methodObject` object with the supplied `arguments`, if any.
    `java.lang.Object` | `call(RexxProxy proxy, java.lang.Object javaObject, java.lang.String methodName, java.lang.String methodDescriptor, java.lang.Object[] args)` Allows forwarding a messages to a RexxProxy using the supplied `methodName` the supplied `arguments`, if any.
    `void` | `declareBean(org.apache.bsf.BSFDeclaredBean bean)` Saves the supplied bean in `engineDeclaredBeans` which will be looked up by RexxAndJava.lookupBean() if a bean with the supplied name is not present in RexxAndJava's registry.
    `java.lang.Object` | `eval(java.lang.String source, int lineNo, int columnNo, java.lang.Object oscript)` Evaluates (executes) a piece of Rexx code (can be a whole program as well) without any Java-supplied arguments and returns the result.
    `java.lang.String` | `get_rii_ID()` Getter method.
    `java.lang.Object` | `getGlobalEnvironment()` Get the ooRexx `.environment` directory.
    `long` | `getId()` Returns the identifier of this RexxEngine.
    `long` | `getInterpreterVersion()` (Copied from the ooRexx `rexxpg.pdf` documentation) "Returns the version of the interpreter.
    `long` | `getLanguageLevel()` (Copied from the ooRexx `rexxpg.pdf` documentation) "Returns the language level of the interpreter.
    `static java.lang.String` | `getLanguageVersionString()` Getter method.
    `java.lang.Object` | `getLocalEnvironment()` Get the ooRexx `.local` directory.
    `java.lang.Object` | `getNil()` Get the ooRexx `.nil` object.
    `boolean` | `getResetLocalBeforeTerminate()` Returns the current value of `resetLocalBeforeTerminate`
    `static boolean` | `getResetLocalBeforeTerminateDefault()` Returns the current value of `resetLocalBeforeTerminateDefault`
    `RexxConfiguration` | `getRexxConfiguration()` Getter method.
    `org.rexxla.bsf.engines.rexx.RexxAndJava` | `getRexxInterface()` Returns the `RexxAndJava` instance that is used for interfacing with Rexx.
    `static java.lang.String` | `getTerminateFixed()` Returns the string indicating which major ooRexx version and compilation date fixed the Terminate() problem.
    `boolean` | `getTerminateOnSeparateThread()` Returns the current value of `TerminateOnSeparateThread`
    `static boolean` | `getTerminateOnSeparateThreadDefault()` Returns the current value of `TerminateOnSeparateThreadDefault`
    `void` | `halt()` Halt (raise the `HALT` condition) all Rexx threads of this engine's peer Rexx interperter instance (using the new ooRExx 4.0 APIs).
    `int` | `halt(java.lang.String tid)` Allow halting an individual Rexx thread (raising the `HALT` condition) having the given thread ID.
    `void` | `initialize(org.apache.bsf.BSFManager mgr, java.lang.String lang, java.util.Vector declaredBeans)` Initializes the Rexx engine and causes the external functions 'BSF' and 'BSFPollEvents' to be registered with the Rexx interpreter.
    `boolean` | `isResetLocalBeforeTerminate()` Returns the current value of `resetLocalBeforeTerminate`
    `static boolean` | `isResetLocalBeforeTerminateDefault()` Returns the current value of `resetLocalBeforeTerminateDefault`
    `boolean` | `isTerminated()` Getter method for field `bTerminated`.
    `boolean` | `isTerminateOnSeparateThread()` Returns the current value of `TerminateOnSeparateThread`
    `static boolean` | `isTerminateOnSeparateThreadDefault()` Returns the current value of `TerminateOnSeparateThreadDefault`
    `protected static boolean` | `isTerminationFixed()` Determines whether the ooRexx version string indicates an interpretr that has Terminate() fixed.
    `java.lang.Object` | `lookupBean(java.lang.String beanName)` Allow lookup of BSFRegistry entries.
    `java.lang.String` | `procEnvironment(int t, java.lang.String n, java.lang.String v)`
    `java.lang.String` | `registerBean(java.lang.Object object)` This method registers an object with the given beanName that gets created automatically in the BSF registry, if not registered yet.
    `java.lang.String` | `registerBean(java.lang.String beanName, java.lang.Object object)` This method registers an object with the given beanName with the BSF registry, if not registered yet.
    `protected void` | `set_rii_ID(java.lang.String rii_ID)` Setter method.
    `protected void` | `setId(long newValue)` Allows to set the id value which will be used starting with BSF4ooReex850 as it became possible to get the ooRexx Rexx interpreter identifier using .context~interpreter.
    `void` | `setResetLocalBeforeTerminate(boolean newValue)` Determines whether RexxEngine.terminate() executes on the current thread or on a separate thread.
    `static void` | `setResetLocalBeforeTerminateDefault(boolean newValue)` Determines whether RexxEngine.terminate() executes on the current thread (default) or on a separate thread.
    `static void` | `setTerminateFixed(java.lang.String newValue)` Allows to set the string indicating which major ooRexx version and compilation date fixed the Terminate() problem.
    `void` | `setTerminateOnSeparateThread(boolean newValue)` Determines whether RexxEngine.terminate() executes on the current thread or on a separate thread.
    `static void` | `setTerminateOnSeparateThreadDefault(boolean newValue)` Determines whether RexxEngine.terminate() executes on the current thread (default) or on a separate thread.
    `void` | `terminate()` Waits until all Rexx threads of this engine's Rexx interpreter instance peer have terminated (using the new ooRExx 4.0 APIs); this method must be called from the same thread that created the Rexx interpreter instance (i.e.
    `void` | `undeclareBean(org.apache.bsf.BSFDeclaredBean bean)` Removes the supplied bean from `engineDeclaredBeans`.
    `boolean` | `unregisterBean(java.lang.String beanName)` This method allows for unregistering Beans, taking into account reference counters.

    - ### Methods inherited from class org.apache.bsf.util.BSFEngineImpl

      `compileApply, compileExpr, compileScript, exec, iexec, propertyChange`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### version

          public static final java.lang.String version

      Version string indicating version of this class (majorVersion*100+minorVersion concatenated with a dot and the sorted date of last change.
      See Also:
        Constant Field Values

    - #### bTerminated

          protected boolean bTerminated

      If terminate() was invoked, then this instance must not be used anymore.

    - #### bJNITerminated

          protected boolean bJNITerminated

      Will be set to true, if terminate() used JNI to successfully terminate the Rexx interpreter instance.
      Since:
        2013-06-25

    - #### languageVersionString

          protected static java.lang.String languageVersionString

      The `PARSE VERSION` string of the currently ooRexx interpreter in use.

    - #### id

          protected long id

  - ### Constructor Detail

    - #### RexxEngine

          public RexxEngine()

  - ### Method Detail

    - #### isTerminated

          public boolean isTerminated()

      Getter method for field `bTerminated`.
      Returns:
        `true`, if Rexx engine got successfully terminated, `false`

    - #### getTerminateFixed

          public static java.lang.String getTerminateFixed()

      Returns the string indicating which major ooRexx version and compilation date fixed the Terminate() problem.
      Returns:
        current string

    - #### setTerminateFixed

          public static void setTerminateFixed(java.lang.String newValue)

      Allows to set the string indicating which major ooRexx version and compilation date fixed the Terminate() problem.
      Parameters:
        `newValue` - a string consisting of the major ooRexx version, a white space and a compilation date

    - #### setTerminateOnSeparateThreadDefault

          public static void setTerminateOnSeparateThreadDefault(boolean newValue)

      Determines whether RexxEngine.terminate() executes on the current thread (default) or on a separate thread. ooRexx 5 with RFE 806. fixed a memory leak for the price of abmysal performance (appr. a slow down of 50x).
      Parameters:
        `newValue` -

    - #### isTerminateOnSeparateThreadDefault

          public static boolean isTerminateOnSeparateThreadDefault()

      Returns the current value of `TerminateOnSeparateThreadDefault`
      Returns:
        current setting

    - #### getTerminateOnSeparateThreadDefault

          public static boolean getTerminateOnSeparateThreadDefault()

      Returns the current value of `TerminateOnSeparateThreadDefault`
      Returns:
        current setting

    - #### setTerminateOnSeparateThread

          public void setTerminateOnSeparateThread(boolean newValue)

      Determines whether RexxEngine.terminate() executes on the current thread or on a separate thread. ooRexx 5 with RFE 806. fixed a memory leak for the price of abmysal performance (appr. a slow down of 50x).
      Parameters:
        `newValue` -

    - #### isTerminateOnSeparateThread

          public boolean isTerminateOnSeparateThread()

      Returns the current value of `TerminateOnSeparateThread`
      Returns:
        current setting

    - #### getTerminateOnSeparateThread

          public boolean getTerminateOnSeparateThread()

      Returns the current value of `TerminateOnSeparateThread`
      Returns:
        current setting

    - #### setResetLocalBeforeTerminateDefault

          public static void setResetLocalBeforeTerminateDefault(boolean newValue)

      Determines whether RexxEngine.terminate() executes on the current thread (default) or on a separate thread. ooRexx 5 with RFE 806. fixed a memory leak for the price of abmysal performance (appr. a slow down of 50x).
      Parameters:
        `newValue` -

    - #### isResetLocalBeforeTerminateDefault

          public static boolean isResetLocalBeforeTerminateDefault()

      Returns the current value of `resetLocalBeforeTerminateDefault`
      Returns:
        current setting

    - #### getResetLocalBeforeTerminateDefault

          public static boolean getResetLocalBeforeTerminateDefault()

      Returns the current value of `resetLocalBeforeTerminateDefault`
      Returns:
        current setting

    - #### setResetLocalBeforeTerminate

          public void setResetLocalBeforeTerminate(boolean newValue)

      Determines whether RexxEngine.terminate() executes on the current thread or on a separate thread. ooRexx 5 with RFE 806. fixed a memory leak for the price of abmysal performance (appr. a slow down of 50x).
      Parameters:
        `newValue` -

    - #### isResetLocalBeforeTerminate

          public boolean isResetLocalBeforeTerminate()

      Returns the current value of `resetLocalBeforeTerminate`
      Returns:
        current setting

    - #### getResetLocalBeforeTerminate

          public boolean getResetLocalBeforeTerminate()

      Returns the current value of `resetLocalBeforeTerminate`
      Returns:
        current setting

    - #### getLanguageVersionString

          public static java.lang.String getLanguageVersionString()

      Getter method.
      Returns:
        returns the `PARSE VERSION` string of the currently ooRexx interpreter in use.

    - #### isTerminationFixed

          protected static boolean isTerminationFixed()

      Determines whether the ooRexx version string indicates an interpretr that has Terminate() fixed.

    - #### get_rii_ID

          public java.lang.String get_rii_ID()

      Getter method.
      Returns:
        the RexxInterpreter instance ID

    - #### set_rii_ID

          protected void set_rii_ID(java.lang.String rii_ID)

      Setter method. Only meant to be used by Java4Rexx.java.

    - #### getRexxConfiguration

          public RexxConfiguration getRexxConfiguration()

      Getter method.
      Returns:
        the RexxConfiguration object of this Rexx engine

    - #### getId

          public long getId()

      Returns the identifier of this RexxEngine. The RexxEngine ID is a positive long number generated when this RexxEngine was created. The RexxEngine ID is unique and remains unchanged during its lifetime.
      Returns:
        this RexxEngine's ID.

    - #### setId

          protected void setId(long newValue)

      Allows to set the id value which will be used starting with BSF4ooReex850 as it became possible to get the ooRexx Rexx interpreter identifier using .context~interpreter. This is meant to be used by RexxAndJava.createRexxInterpreterInstance(...) such that for debugging both, ooRexx and Java use the same id value.
      Since:
        20250827

    - #### getRexxInterface

          public org.rexxla.bsf.engines.rexx.RexxAndJava getRexxInterface()

      Returns the `RexxAndJava` instance that is used for interfacing with Rexx.

    - #### initialize

          public void initialize(org.apache.bsf.BSFManager mgr,
                                 java.lang.String lang,
                                 java.util.Vector declaredBeans)
                          throws org.apache.bsf.BSFException

      Initializes the Rexx engine and causes the external functions 'BSF' and 'BSFPollEvents' to be registered with the Rexx interpreter. Therefore Rexx programs invoked from Java have these two functions available to them and are therefore able to communicate with Java.

      Note: at this point in time the Rexx interpreter instance has not been created yet. If using apply(), eval() and the like an instance with the default configuration gets created such that no instance creation options that a Java client may be defining can get honored. Therefore never use apply(), eval() in here.

      Specified by:
        `initialize` in interface `org.apache.bsf.BSFEngine`
      Overrides:
        `initialize` in class `org.apache.bsf.util.BSFEngineImpl`
      Parameters:
        `mgr` - The BSFManager that's hosting this engine.
        `lang` - Language string which this engine is handling.
        `declaredBeans` - Vector of BSFDeclaredObject containing beans that should be declared into the language runtime at init time as best as possible.
      Throws:
        `org.apache.bsf.BSFException` - if anything goes wrong while init'ing a BSFException is thrown. The reason indicates the problem.

    - #### getLocalEnvironment

          public java.lang.Object getLocalEnvironment()

      Get the ooRexx `.local` directory.
      Returns:
        a `RexxProxy` allowing access to the ooRexx `.local` directory
      Since:
        2015-05-09

    - #### getGlobalEnvironment

          public java.lang.Object getGlobalEnvironment()

      Get the ooRexx `.environment` directory.
      Returns:
        a `RexxProxy` allowing access to the ooRexx `.environment` directory
      Since:
        2015-05-09

    - #### getNil

          public java.lang.Object getNil()

      Get the ooRexx `.nil` object.
      Returns:
        a `RexxProxy` representing the ooRexx `.nil` sentinel object
      Since:
        2015-05-09

    - #### getInterpreterVersion

          public long getInterpreterVersion()

      (Copied from the ooRexx `rexxpg.pdf` documentation) "Returns the version of the interpreter. The returned version is encoded in the 3 least significant bytes of the returned value, using 1 byte each for the interpreter version, release, and revision values. For example, on a 32-bit platform, this value would be `0x00040000` for version 4.0.0."
      Returns:
        the ooRexx interpreter version
      Since:
        2015-05-09

    - #### getLanguageLevel

          public long getLanguageLevel()

      (Copied from the ooRexx `rexxpg.pdf` documentation) "Returns the language level of the interpreter. The returned language level is encoded in the 2 least significant bytes of the returned value, using 1 byte each for the interpreter version, release, and revision values. For example, on a 32-bit platform, this value would be `0x00000603` for language level 6.03."
      Returns:
        the ooRexx language level
      Since:
        2015-05-09

    - #### eval

          public java.lang.Object eval(java.lang.String source,
                                       int lineNo,
                                       int columnNo,
                                       java.lang.Object oscript)
                                throws org.apache.bsf.BSFException

      Evaluates (executes) a piece of Rexx code (can be a whole program as well) without any Java-supplied arguments and returns the result.
      Parameters:
        `source` - if set to `RexxAndJava.EVENT_TEXT`, then `oscript` is put into the event queue to be polled by Rexx. If this text starts with the string `"/*2*/"` it is put into the alarm (highest dispatch) level vector, if it starts with the string `"/*0*/"` it is put into the batch (lowest dispatch) level vector, else it is put into the normal level vector.
        `lineNo` - not used.
        `columnNo` - not used.
        `oscript` - the String version of this object [using toString()] represents the Rexx code to be executed. Its statements are delimited with a ';' or a CR (carriage-return) and/or LF (line-feed).
      Returns:
        a String object with the result from Rexx or `null`.
      Throws:
        `org.apache.bsf.BSFException` - if anything goes wrong while eval'ing a BSFException is thrown. The reason indicates the problem.

    - #### call

          public java.lang.Object call(java.lang.Object object,
                                       java.lang.String name,
                                       java.lang.Object[] args)
                                throws org.apache.bsf.BSFException

      Calls (executes) a Rexx program which code has been supplied before via an invocation of "apply()", "exec()" or "eval()" with the Java-supplied arguments and returns the result.

      [Hint: This follows after learning how Xalan is employing BSF: it first calls "exec()" and then "call()", hence "call()" does not receive the source to be executed.]

      As of 2009-05-17 using the new ooRexx 4.0 APIs the following fundamental change has been implemented: if the argument `object` is an instance of `RexxProxy`, then a callback on the RexxProxy object is carried out, using `method as the ooRexx message name, supplying arguments, if any. Otherwise, the original behaviour takes place.`

      Note: if the RexxProxy's `userDataID` field is not set (i.e. `null`), then no slot argument will be supplied as the last argument to the Rexx method.

      Parameters:
        `object` - if an instance of RexxProxy, then a callback is carried out
        `name` - if given, name of the message to send to the ooRexx object
        `args` - arguments to be passed to Rexx, if any
      Returns:
        an object with the result from Rexx or `null`.
      Throws:
        `org.apache.bsf.BSFException` - if anything goes wrong while eval'ing a BSFException is thrown. The reason indicates the problem.

    - #### call

          public java.lang.Object call(java.lang.Object object,
                                       java.lang.String name,
                                       java.lang.Object[] args,
                                       java.lang.Object scope)
                                throws org.apache.bsf.BSFException

      Call version that allows for supplying a Rexx class serving as the scope for the method invocation (new in ooRexx 5.0, cf. rexxapi.pdf, `SendMessageScoped()`).
      Parameters:
        `object` - if an instance of RexxProxy, then a callback is carried out
        `name` - if given, name of the message to send to the ooRexx object
        `args` - arguments to be passed to Rexx, if any
        `scope` - a string or RexxProxy representing an ooRexx class object, message resolution will start at the supplied scope (must be a superclass of the Rexx object resolving the message)
      Returns:
        an object with the result from Rexx or `null`.
      Throws:
        `org.apache.bsf.BSFException`
      Since:
        850 (2022-08-11)

    - #### call

          public java.lang.Object call(RexxProxy proxy,
                                       java.lang.reflect.Method methodObject,
                                       java.lang.Object[] args)
                                throws org.apache.bsf.BSFException

      Allows forwarding a messages to a RexxProxy using the method name of the supplied `methodObject` object with the supplied `arguments`, if any. This method will be mostlikely invoked employing a `Proxy` object.

      As of 2009-05-17 using the new ooRexx 4.0 APIs the following fundamental change has been implemented: if the argument `object` is an instance of `RexxProxy`, then a callback on the RexxProxy object is carried out, using `method as the ooRexx message name, supplying arguments, if any. Otherwise, the original behaviour takes place.`

      Parameters:
        `proxy` - a RexxProxy to which the callback is to be carried out
        `methodObject` - the java.lang.reflect.Method object that is supposed to be invoked originally
        `args` - arguments to be passed to Rexx, if any
      Returns:
        a String object with the result from Rexx or `null`.
      Throws:
        `org.apache.bsf.BSFException`

    - #### call

          public java.lang.Object call(RexxProxy proxy,
                                       java.lang.Object javaObject,
                                       java.lang.String methodName,
                                       java.lang.String methodDescriptor,
                                       java.lang.Object[] args)
                                throws org.apache.bsf.BSFException

      Allows forwarding a messages to a RexxProxy using the supplied `methodName` the supplied `arguments`, if any. This method will be mostlikely invoked employing a RexxProxy object in the context of a dynamically created (proxy) Java class (e.g. an abstract class, where the abstract methods will forward their invocation to the RexxProxy object).
      Parameters:
        `proxy` - a RexxProxy to which the callback is to be carried out
        `javaObject` - object that invoked this callback
        `methodName` - this name is used as the message to be sent to the Rexx object
        `methodDescriptor` - the Java internal representation of the method's arguments and return type, if any
        `args` - arguments to be passed to Rexx, if any
      Returns:
        a String object with the result from Rexx or `null`.
      Throws:
        `org.apache.bsf.BSFException`

    - #### apply

          public java.lang.Object apply(java.lang.String source,
                                        int lineNo,
                                        int columnNo,
                                        java.lang.Object oscript,
                                        java.util.Vector vArgNames,
                                        java.util.Vector vArgs)
                                 throws org.apache.bsf.BSFException

      Applies (evaluates) a piece of Rexx code (can be a whole program as well) with Java-supplied arguments and returns the result.
      Specified by:
        `apply` in interface `org.apache.bsf.BSFEngine`
      Overrides:
        `apply` in class `org.apache.bsf.util.BSFEngineImpl`
      Parameters:
        `source` - name of source containing the script (e.g. fully qualified file name) or null
        `lineNo` - not used.
        `columnNo` - not used.
        `oscript` - the String version of this object [using toString()] represents the Rexx code to be executed. Its statements are delimited with a ';' or a an LF (line-feed, "0x0a"), preceeded by an optional CR (carriage-return, "0x0d").
        `vArgNames` - not used.
        `vArgs` - arguments to be passed to Rexx.
      Returns:
        a String object with the result from Rexx or `null`.
      Throws:
        `org.apache.bsf.BSFException` - if anything goes wrong while doin' it.

    - #### declareBean

          public void declareBean(org.apache.bsf.BSFDeclaredBean bean)
                           throws org.apache.bsf.BSFException

      Saves the supplied bean in `engineDeclaredBeans` which will be looked up by RexxAndJava.lookupBean() if a bean with the supplied name is not present in RexxAndJava's registry.
      Specified by:
        `declareBean` in interface `org.apache.bsf.BSFEngine`
      Overrides:
        `declareBean` in class `org.apache.bsf.util.BSFEngineImpl`
      Parameters:
        `bean` - the bean to be declared
      Throws:
        `org.apache.bsf.BSFException` - if the engine cannot do this operation

    - #### undeclareBean

          public void undeclareBean(org.apache.bsf.BSFDeclaredBean bean)
                             throws org.apache.bsf.BSFException

      Removes the supplied bean from `engineDeclaredBeans`.
      Specified by:
        `undeclareBean` in interface `org.apache.bsf.BSFEngine`
      Overrides:
        `undeclareBean` in class `org.apache.bsf.util.BSFEngineImpl`
      Parameters:
        `bean` - the bean to be declared for the already started language.
      Throws:
        `org.apache.bsf.BSFException` - if the engine cannot do this operation

    - #### terminate

          public void terminate()

      Waits until all Rexx threads of this engine's Rexx interpreter instance peer have terminated (using the new ooRExx 4.0 APIs); this method must be called from the same thread that created the Rexx interpreter instance (i.e. the thread that created this instance of the RexxEngine). Terminating the primodal Rexx interpreter instance makes it unavailable for use by the Java side, but remains running for the native code. All other Rexx interpreter instances will be terminated for good. Use `isTerminated()` to test whether the Rexx interpreter instance of this `RexxEngine` got terminated.

      Note: native termination of the RII (Rexx interpreter instance) MUST be solely done from here! To halt all Rexx threads of this engine's Rexx interpreter instance peer use `halt()`.

      Specified by:
        `terminate` in interface `org.apache.bsf.BSFEngine`
      Overrides:
        `terminate` in class `org.apache.bsf.util.BSFEngineImpl`

    - #### halt

          public void halt()
                    throws RexxException

      Halt (raise the `HALT` condition) all Rexx threads of this engine's peer Rexx interperter instance (using the new ooRExx 4.0 APIs).
      Throws:
        `RexxException`

    - #### halt

          public int halt(java.lang.String tid)

      Allow halting an individual Rexx thread (raising the `HALT` condition) having the given thread ID.
      Parameters:
        `tid` - a string with the target thread ID, or the string `"0"` (raises the `HALT` condition in all ooRexx threads)
      Returns:
        return code from `RexxSetHalt(...)`: `0`(o.k.), `1` (tid not found), or `2` (failure), or `3` (Rexx interpreter instance was not yet created)``

    - #### registerBean

          public java.lang.String registerBean(java.lang.Object object)
                                        throws RexxException

      This method registers an object with the given beanName that gets created automatically in the BSF registry, if not registered yet. In addition a reference counting is carried out.
      Parameters:
        `object` - to be registered
      Returns:
        returns the beanName
      Throws:
        `RexxException`
      Since:
        2012-02-19

    - #### registerBean

          public java.lang.String registerBean(java.lang.String beanName,
                                               java.lang.Object object)
                                        throws RexxException

      This method registers an object with the given beanName with the BSF registry, if not registered yet. In addition a reference counting is carried out.
      Parameters:
        `beanName` - name of the object to be registered
        `object` - to be registered
      Returns:
        returns the beanName
      Throws:
        `RexxException`
      Since:
        2012-02-19

    - #### unregisterBean

          public boolean unregisterBean(java.lang.String beanName)
                                 throws RexxException

      This method allows for unregistering Beans, taking into account reference counters. Only if the reference counter drops to 0, will the given Bean be unregistered.
      Parameters:
        `beanName` - name of the Bean to be unregistered
      Returns:
        returns `true`, if the Bean exists, `false` else.
      Throws:
        `RexxException`
      Since:
        2012-02-19

    - #### lookupBean

          public java.lang.Object lookupBean(java.lang.String beanName)
                                      throws RexxException

      Allow lookup of BSFRegistry entries.
      Parameters:
        `beanName` - string denoting the index into the BSFRegistry
      Returns:
        the Java object matching `beanName`, if not found in BSF registry returns `null`
      Throws:
        `RexxException`
      Since:
        2012-02-19

    - #### procEnvironment

          public java.lang.String procEnvironment(int t,
                                                  java.lang.String n,
                                                  java.lang.String v)
                                           throws RexxException

      Throws:
        `RexxException`