-------------------------------------- 2025-09-02 ----------------------------------

- BSF.CLS

         - increase check for minimum ooRexx version to 5.0

         - show how to set bDebug globally via .local, remove debug block that
           uses a non-existent module

- adding new launcher "bin\rexxb4r.rex"

        - a new BSF4ooRexx launcher that automatically sets the startup
          option "--enable-native-access=ALL-UNNAMED" for Java/OpenJDK
          versions 24 or higher to avoid those stupid dreadful messages
          about JNI being dangerous which is nuisance;
          this needs to be a proper script as to not permanently load the
          JVM as after loading it one cannot change the CLASSPATH or the
          module path

-------------------------------------- 2025-08-27 ----------------------------------

- updated all samples/JavaFX samples

        - remove check whether ooRexx 5.0 is being used

        - add more debug info (show interpreter, thread and invocation ids)

        - add ability to show debug output when processing the FXML files

-------------------------------------- 2025-08-27 ----------------------------------

- RexxAndJava.java

        - RexxEngine gets as its id value the Rexx instance identifier (.context~interpreter) to
          ease debugging

- RexxEngine.java

        - add protected setId(...) for RexxAndJava's createRexxInterpreterInstance(...)
          to ease debugging by allowing Java to use the same identifier as ooRexx

        - change id_counter to produce negative numbers to distinguish between Java
          created instance numbers and (positive) Rexx identifiers

- RexxScriptEngineFactory.java

        - reflect that RexxEngine got changed and now uses as 'id' value
          the ooRexx interpreter instance identifier

-------------------------------------- 2025-08-24 ----------------------------------

- RexxReflectJava7.java

        - fixed reflection error: if a class does not have a public default constructor,
          reflectConstructor() would use one of the superclasses's public
          default constructor, thereby creating the wrong object; now throws
          a RuntimeException with appropriate error message

-------------------------------------- 2025-08-16 ----------------------------------

- RexxReflectJava7.java

         - in case a cached handle threw an exception and it is not possible
           to find working alternate version, return the cached exception

-------------------------------------- 2024-07-07 ----------------------------------

- RexxDispatcher.java

        - if the Rexx script is not found in the current directory, then use
          java.library.path to locate it and if found there use its canonical path
          representation

-------------------------------------- 2024-06-20 ----------------------------------

- RexxAndJava.java

        - added Josep Maria to kudos

- RexxHandler.java

        - corrected JavaDocs, kudos to Josep Maria Blasco

-------------------------------------- 2024-06-15 ----------------------------------

- BSF.CLS

        - honor environment variable "BSF4Rexx_quiet" set to 1 in addition to
          .bsf.quiet: if either is set to .true (1) do not show hints

        - change ppJavaExceptionChain() routine to prepend CR if .endofLine
          is "0d0a"x to all contained single LF

-------------------------------------- 2024-05-24 ----------------------------------

- BSF.CLS

        - .bsf.quiet: if set to .true, inhibits informal output

        - add bsf.isArray: returns .true if a BSF_ARRAY_REFERENCE, .false else


-------------------------------------- 2024-03-04 ----------------------------------

- releasing BSF4ooRexx850 as "GA" (general available) while the International
  2024 Rexx Symposium takes place in Brisbane, Australia

-------------------------------------- 2024-01-08 ----------------------------------

- macOS: Packages850 gui installer updated

- BSF4ooRexx.cc: - Windows: honors JAVA_HOME first on Windows,
                                   %JAVA_HOME%\bin\server\jvm.dll
                                   %JAVA_HOME%\jre\bin\server\jvm.dll
                                   jvm

        [remark: there would be bin\client\jvm.dll]

                 - on Apple/Linux: first /opt/BSF4ooRexx850/libjvm.{dylib|so}
                                   $JAVA_HOME/lib/server/libjvm.{dylib|so}
                                   $JAVA_HOME/jre/lib/server/libjvm.{dylib|so}
                                   libjvm.{dylib|so} (without path)

- new rexxjh.{sh|cmd}: honors JAVA_HOME first

        %JAVA_HOME%\bin\java.exe
        %JAVA_HOME%\jre\bin\java.exe
        java

        ---> "%JAVA_BINARY%"  %BSF4Rexx_JavaStartupOptions% org.rexxla.bsf.RexxDispatcher %*

-------------------------------------- 2023-10-30 ----------------------------------

- BSF.CLS: Cater for JDK_JAVA_OPTIONS environment variable, inform user if it gets
  picked up (like Java does), also (new!) notify user if BSF4Rexx_JavaStartupOptions
  gets picked up as well.

-------------------------------------- 2023-10-23 ----------------------------------

- BSF4ooRexx.cc: Fix two wrong upcalls (got only changed on the Java side);
  silence '-Xcheck:jni' by invoking ExceptionCheck(), even if not really necessary
  (cf. Java's use in awt)

-------------------------------------- 2023-07-16 ----------------------------------

- Add a utility-like example that lists members of a Java class.
 (samples/1-260_getJavaMembers.rxj)


-------------------------------------- 2023-07-06 ----------------------------------

- samples/JavaFX/fxml_02: Added (simplified) Chinese, placed character arrow at the other
  side for RTL languages (Arabian, Hebrew)

-------------------------------------- 2023-07-03 ----------------------------------

-  samples/JavaFX/fxml_02: add Spanish, French, Israelian/Hebrew, Indian/Hindi,
   Italian and Japanese properties files. Add Arabian, Bulgarian, Czeck, Finnish,
   Greek, Hungarian, Letvian, Lithuanian, Dutch, Norwegian, Polish, Romanian,
   Russian, Swedish, Turkish and Ukrainian.

-------------------------------------- 2023-06-14 ----------------------------------

- New sample '1-230_ClipBoard.rxj'.

-------------------------------------- 2023-06-12 ----------------------------------

- Complete JDOR with clipboard commands.

-------------------------------------- 2023-06-11 ----------------------------------

- Make system clipboard accessible. (BSF.CLS: new BSF.ClipBoard class)

-------------------------------------- 2023-06-10 ----------------------------------

- rename i2c() to id2c() to convey more meaning, add support for system
  clipboard (BsfSystemClipboard.java) for images and strings.

-------------------------------------- 2023-04-12 ----------------------------------

- Add and use new initialisation routine 'bsf.initRAJinstance' to allow
  RexxScriptEngine to initialize the RexxAndJava peer to add prefixes.

-------------------------------------- 2023-03-03 ----------------------------------

- Add RPATH for MacOS and Linux.

-------------------------------------- 2023-02-25 ----------------------------------

- CMakeLists.txt file (and supplementary files) for creating the BSF4ooRexx850
  library with CMake.


-------------------------------------- 2022-12-04 ----------------------------------

- Add support for Shapes (intentionally no command support for Area, Point2D,
  Path2D which can be used in BSF4ooRexx programs directly).

- Add '.dev.null' to .environment; purpose: null device target for redirected
  commands (ooRexx 5.0' ADDRESS...WITH), an instance of the singleton class .bsf.nulldevice

-------------------------------------- 2022-11-03 ----------------------------------

- Add 'user.home/BSF4ooRexx/lib/*' to CLASSPATH; this allows to copy jar-files to
  it and be able to immediately access them afterwards

-------------------------------------- 2022-10-16 ----------------------------------

- We need to resolve wildcard asterisk (*) in CLASSPATH if loading Java from Rexx.



-------------------------------------- 2022-10-03 ----------------------------------

- Add JavaDrawingHandler (JDOR). JDOR samples.

-------------------------------------- 2022-09-29 ----------------------------------

- Add i2x() routine which converts an identityHash numeric value to a hexadecimal
  string. On 64-bit systems the hexadecimal string gets an underscore inserted after the
  eight' character to ease legibility by default.

-------------------------------------- 2022-08-25 ----------------------------------

- Added new sample that configures a Rexx instances with command handlers and
  invokes a Rexx program that uses them. Also a pure Rexx solution doing 1:1 the same as
  the Java program is supplied.
-------------------------------------- 2022-08-24 ----------------------------------

- Adjust to new name of the dll/so/dylib: 'BSF4ooRexx850'.

====================================================================================

- above from here: major changes for BSF4ooRexx850 only

====================================================================================

-------------------------------------- 2022-08-23 ----------------------------------
-  Branches/850/bsf4oorexx.dev/bin/BSF.CLS
   Branches/850/bsf4oorexx.dev/source_cc/BSF4ooRexx.cc
   Branches/850/bsf4oorexx.dev/source_cc/lib/BSF4ooRexx.dll-64-amd64
   Branches/850/bsf4oorexx.dev/source_java/RexxHandler.class
   Branches/850/bsf4oorexx.dev/source_java/RexxHandler.java
   Branches/850/bsf4oorexx.dev/source_java/RexxRedirectingCommandHandler.java
   Branches/850/bsf4oorexx.dev/testUnits/bsf4rexx/rgf/H_850/05_redirectingHandler.testGroup
   Branches/850/bsf4oorexx.dev/testUnits/bsf4rexx/rgf/H_850/RedirectingHandler2.class
   Branches/850/bsf4oorexx.dev/testUnits/bsf4rexx/rgf/H_850/RedirectingHandler2.java
   branches/850/bsf4oorexx.dev/testUnits/bsf4rexx/rgf/H_850/01_sendMailScoped.testGroup (new)
   branches/850/bsf4oorexx.dev/testUnits/bsf4rexx/rgf/H_850/06_redirectingHandler_preconfigured.testGroup (new)

        - finalized implementation, adding new testgroups. Implementation of SendmailScoped
          and command handlers regarded to be complete and tested

- branches/850/bsf4oorexx.dev/source_java/AbstractDirectCommandHandler.java (new)
  branches/850/bsf4oorexx.dev/source_java/AbstractRedirectingCommandHandler.java (new)

        - added to allow command handlers to be implemented in ooRexx as well

-------------------------------------- 2022-08-22 ----------------------------------

-  branches/850/bsf4oorexx.dev/testUnits/bsf4rexx/rgf/H_850/05_redirectingHandler.testGroup
   branches/850/bsf4oorexx.dev/testUnits/bsf4rexx/rgf/H_850/DirectHandler1.java
   branches/850/bsf4oorexx.dev/testUnits/bsf4rexx/rgf/H_850/RedirectingHandler1.java
   branches/850/bsf4oorexx.dev/testUnits/bsf4rexx/rgf/H_850/RedirectingHandler2.java

        - preparing testunits for command handler

-  branches/850/bsf4oorexx.dev/source_java/RexxCommandHandler.java
   branches/850/bsf4oorexx.dev/source_java/RexxExitHandler.java
   branches/850/bsf4oorexx.dev/source_java/RexxHandler.java

        - turning RexxHandler from abstract to interface, redefining the
          static methods to default (instance) interface methods, rooting
          RexxCommandHandler and RexxExitHandler to RexxHandler such that all these
          utility methods (like setting, dropping context variables, getting access
          to .nil, .local, .environment etc.) become directly available to the
          handlers

-------------------------------------- 2022-08-20 ----------------------------------

-  branches/850/bsf4oorexx.dev/bin/BSF.CLS
   branches/850/bsf4oorexx.dev/cmpj.cmd
   branches/850/bsf4oorexx.dev/source_cc/BSF4ooRexx-32.def
   branches/850/bsf4oorexx.dev/source_cc/BSF4ooRexx-64.def
   branches/850/bsf4oorexx.dev/source_cc/BSF4ooRexx.cc
   branches/850/bsf4oorexx.dev/source_cc/org_rexxla_bsf_engines_rexx_RexxAndJava.h
   branches/850/bsf4oorexx.dev/source_java/RexxAndJava.java
   branches/850/bsf4oorexx.dev/source_java/RexxCommandHandler.java
   branches/850/bsf4oorexx.dev/source_java/RexxConfiguration.java
   branches/850/bsf4oorexx.dev/source_java/org_rexxla_bsf_engines_rexx_RexxAndJava.h
   branches/850/bsf4oorexx.dev/source_java/RexxRedirectingCommandHandler.java (new)

        - adding command handlers at runtime, support for redirecting command handlers
        - allow using RexxConfiguration to allow to configure redirecting command
          handlers as well (direct command handlers have been supported since 2012)

-------------------------------------- 2022-08-16 ----------------------------------

-  branches/850/bsf4oorexx.dev/source_cc/BSF4ooRexx.cc
   branches/850/bsf4oorexx.dev/source_cc/Makefile-64-windows
   branches/850/bsf4oorexx.dev/source_cc/lib/BSF4ooRexx.dll-64-amd64
   branches/850/bsf4oorexx.dev/source_cc/org_rexxla_bsf_engines_rexx_RexxAndJava.h
   branches/850/bsf4oorexx.dev/source_java/RexxAndJava.java
   branches/850/bsf4oorexx.dev/source_java/RexxEngine.java
   branches/850/bsf4oorexx.dev/source_java/RexxProxy.java
   branches/850/bsf4oorexx.dev/testUnits/bsf4rexx/rgf/G_misc/07_rexx_JSR_223.testGroup

        - added new SendMessageScoped-API to RexxProxy, adjusted code in all
          affected programs

        - added a new test group to test the new API

-------------------------------------- 2022-08-11 ----------------------------------

- for both 461 and 850, JavaFX samples: change ListView and TableView
  samples such that they do not start out in debug mode (too noisy,
  beginners get mixed up):

        - branches/461/samples/JavaFX/fxml_20/demoListView.fxml
          branches/461/samples/JavaFX/fxml_20/demoListView.rex
          branches/461/samples/JavaFX/fxml_25/demoTableViewSimple.fxml
          branches/461/samples/JavaFX/fxml_25/demoTableViewSimple.rex
          branches/461/samples/JavaFX/fxml_26/demoTableViewComboBoxCell.fxml
          branches/461/samples/JavaFX/fxml_26/demoTableViewComboBoxCell.rex
          branches/461/samples/JavaFX/fxml_27/demoTableView.fxml
          branches/461/samples/JavaFX/fxml_27/demoTableView.rex
          branches/850/samples/JavaFX/fxml_20/demoListView.fxml
          branches/850/samples/JavaFX/fxml_20/demoListView.rex
          branches/850/samples/JavaFX/fxml_25/demoTableViewSimple.fxml
          branches/850/samples/JavaFX/fxml_25/demoTableViewSimple.rex
          branches/850/samples/JavaFX/fxml_26/demoTableViewComboBoxCell.fxml
          branches/850/samples/JavaFX/fxml_26/demoTableViewComboBoxCell.rex
          branches/850/samples/JavaFX/fxml_27/demoTableView.fxml
          branches/850/samples/JavaFX/fxml_27/demoTableView.rex

-------------------------------------- 2022-08-10 ----------------------------------

- branches/461, branches/850 created

- branches/850

- renamed to createDistributionForBSF4ooRexx8.cmd

        - baseline Java version set to "-source 8 -target 8"

- BSF4ooRexx.cc

        - mandate ooRexx 5.0.0 as minimum

        - change version string to indicate new Java baseline 8 and ooRexx baseline 5.0

- Java4Rexx.java, RexxAndJava.java, RexxEngine.java

        - change version string to indicate new Java baseline 8 and ooRexx baseline 5.0

====================================================== below 641, above 850



-------------------------------------- 2022-08-09 ----------------------------------

- samples/JavaFX/fxml_03/fxml/registration.fxml

        - added third gender 'neuter'

- samples/JavaFX/fxml_05

        - updated ControlsFX jar files for Java 8 and Java 11 (removed the outdated
          Java 9 version)

        - added staff.rex, run_on_java_8.cmd, run_on_java_8.sh, run_on_java_11.cmd,
          run_on_java_11.sh:

                - demonstrate how to set CLASSPATH depending on the Java version in
                  use before running staff.rxj which depends on the correct ControlsFX
                  jar

- samples/JavaFX/fxml_20/demoListView.rex,
  samples/JavaFX/fxml_25/demoTableViewSimple.rex,
  samples/JavaFX/fxml_26/demoTableViewComboBoxCell.rex,
  samples/JavaFX/fxml_27/demoTableView.rex,

        - at startup make sure that listViewData/tableViewData is empty to match display

        - force picking remove(int) version by using box.strictArg()

        - corrected wrong "\selectedIndex~isNil" with "selectedIndex>-1"

        - correcting interface logic errors (in menu and popup menu):

          - added missing listener to id_menu_remove

          - make sure id_listview gets set to listViewData on first id_menu_add

          - make sure CTL-Click only operational if in edit mode


-------------------------------------- 2022-08-08 ----------------------------------

- samples/NetRexx/javax.script/nrxRunScript.nrx

        - adding System.exit(0)

- samples/NetRexx/javax.script/nutshell_01_eval.nrx

        - correcting import from 'org.rexxla.bsf.engines.rexx.jsr223' to
          'org.rexxla.bsf.engines.rexx'

- samples/NetRexx/javax.script/nutshell_02_invoke.nrx,
  samples/NetRexx/javax.script/nutshell_03_interface.nrx,
  samples/NetRexx/javax.script/nutshell_04_eval.nrx

        - correcting import from 'org.rexxla.bsf.engines.rexx.jsr223' to
          'org.rexxla.bsf.engines.rexx'

        - adding System.exit(0)

- samples/LeePeedin/queryfolder.rxj

        - changed to use bsf.loadClass("java.text.NumberFormat")


-------------------------------------- 2022-08-07 ----------------------------------

- new samples/1-062_DateRgfCatholicEaster.rxj

- samples/Java/handlers/commandHandlers/01_commandHandler/JavaRunRexxWithCommandHandler.java,
  samples/Java/handlers/commandHandlers/10_commandHandlers/JavaRunRexxWithCommandExits.java,
  samples/Java/handlers/exitHandlers/02_RXFNC/JavaRunRexxWith_RXFNC_Exit.java,
  samples/Java/handlers/exitHandlers/04_RXMSQ/JavaRunRexxWith_RXMSQ_Exit.java,
  samples/Java/handlers/exitHandlers/05_RXSIO/JavaRunRexxWith_RXSIO_Exit.java,
  samples/Java/handlers/exitHandlers/07_RXHLT/JavaRunRexxWith_RXHLT_Exit.java,
  samples/Java/handlers/exitHandlers/08_RXTRC/JavaRunRexxWith_RXTRC_Exit.java,
  samples/Java/handlers/exitHandlers/09_RXINI_10_RXTER/JavaRunRexxWith_RXINI_RXTER_Exit.java,
  samples/Java/handlers/exitHandlers/12_RXEXF/JavaRunRexxWith_RXEXF_Exit.java,
  samples/Java/handlers/exitHandlers/13_RXNOVAL/JavaRunRexxWith_RXNOVAL_Exit.java,
  samples/Java/handlers/exitHandlers/14_RXVALUE/JavaRunRexxWith_RXVALUE_Exit.java,
  samples/Java/handlers/exitHandlers/15_RXOFNC/JavaRunRexxWith_RXOFNC_Exit.java

        - added System.exit(0)

- BSF4ooRexx.cc

        - Using RexxAllocateMemory() instead of malloc() for RXSTRING as this now
          makes a difference (at least on Windows which otherwise causes errors
          when ooRexx releases memory from the heap)



-------------------------------------- 2022-08-06 ----------------------------------

- jsr223 package name change from 'org.rexxla.bsf.engines.rexx.jsr223' to 'org.rexxla.bsf.engines.rexx'

- BSF4ooRexx.cc, org_rexxla_bsf_engines_rexx_RexxAndJava.h

        - new native function 'Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniExecuteSimpleProcedureOnOwnRII'
          that runs a simple rexx script on a newly created Rexx interpreter
          instance supplying a single optional string as argument and returning the
          string value of the result (or null for no result)

- InvocationType.java

        - new enum type SIMPLE_EXECUTE_ARGUMENT named "simpleExecute"

- RexxAndJava.java

        - new static native function "String jniExecuteSimpleProcedureOnOwnRII(rexxCode,rexxArgument)"

        - new BSF subfunction SIMPLE_EXECUTE_ARGUMENT ('simpleExecute'[, [rexxCode], [rexxArgument]])

- RexxCompiledScript.java

        - changed package name to: 'org.rexxla.bsf.engines.rexx'

- RexxEngine.java

        - added static getter for languageVersionString

        - added static protected boolean isTerminationFixed() to determine
          the defaults for termination

- RexxScriptEngine.java

        - changed package name to: 'org.rexxla.bsf.engines.rexx'

- RexxScriptEngineFactory.java

        - changed package name to: 'org.rexxla.bsf.engines.rexx'


-------------------------------------- 2022-08-04 ----------------------------------

- install/portable added to installation package

        - allows a user to create a portable version of BSF4ooRexx

-------------------------------------- 2022-08-02 ----------------------------------

- BSF4ooRexx.cc, Makefile-64-windows

        - add "_DEBUG" to version information, if a debug compile (will
          be used for the Windows version, cf. Makefile-64-windows)

- rexxj3.cmd (new file), rexxj3.sh (new file)

        - honor the JAVA_HOME environment variable if present

        - allow to invoke Rexx scripts via Java

- RexxAnalyzeRegistry.java (new file)

        - This class allows to analyze the registry maintained by RexxAndJava.java, it
          needs at least Java/OpenJDK version 8.

- RexxCleanupRef.java

        - tidying up, refactoring names to make them self documentary

- RexxEngine.java

        - changed the name from "interpreterVersionString" to "languageVersionString"
          and its getter accordingly; this way the name is consistent to the
          RexxScriptEngineFactory "LANGUAGE_VERSION" field

- RexxScriptEngineFactory.java

        - use a RexxEngine to fetch the LANGUAGE_VERSION value

-------------------------------------- 2022-08-01 ----------------------------------

- Java4Rexx.java

        - logic in RexxEngine.initializer(...) got changed such that the ooRexx version
          strings gets fetched and Termination() related defaults set accordingly using
          apply which will cause the primodal Rexx interpreter to be created; as a
          result rii_ID for the peer RAJ and RE get set such that Java4Rexx must not
          set them again (which would cause an exception in RAJ)

- RexxEngine.java

        - added static protected field "interpreterVersionString" and static public
          getter "getInterpreterVersionString()" containing the ooRexx version string

        - initialize(...): queries ooRexx for its version string, checks whether
          ooRexx major version and date is the first one that possesses the fix
          for Terminate() on a separate thread; if so adjusts the static defaults
          for resetLocalBeforeTerminateDefault=false and
          terminateOnSeparateThread=true

          Note: this has a side effect on Java4Rexx (which gets used by Rexx to
                demand load Java and initialize the primodal/root instance): the
                rii_ID values of RexxAndJava and RexxEngine get set implicitly
                by RexxEngine.initialize(...) utilizing apply()

- RexxScriptEngine.java

        - instead of using public getters, directly access Rexx engine
          related static info, now that these fiels are made protected
          in RexxScriptEngineFactory

- RexxScriptEngineFactory.java

        - make the following final fields protected to allow RexxScriptEngine
          direct access: ENGINE_NAME, ENGINE_VERSION, EXTENSIONS, LANGUAGE_NAME,
          SHORT_NAME, MIME_TYPES, SCRIPT_ENGINE_SHORT_NAMES, THREADING


-------------------------------------- 2022-07-31 ----------------------------------

- RexxCleanupRef.java

        - tidying up, now that termination is done via RexxEngine.terminate() only


- samples/3-100_create_bitmap.rxj (new sample)

        - Demonstrates how to create a bitmap (an image) with Java's Graphics2D and
          draw images (bsf4oorexx_256.png, oorexx4ooo_256.png, oorexx_256.png) in
          original and 50% size, how to draw lines, strings (text), polygons and
          some more...  The resulting bitmap gets saved in the user's home directory
          under the name 3-100_create_bitmap.png and shown using the appropraite
          operating system's command.


-------------------------------------- 2022-07-25 ----------------------------------

- RexxEngine.java

        - added static resetLocalBeforeTerminateDefault=true with getters and setter:
          controls whether .local gets reset before invoking terminate(), set to
          true to mitigate memory leaks prior to the ooRexx 5 Terminate()-RFE
          <https://sourceforge.net/p/oorexx/feature-requests/806/>

        - added private static counter id_counter and private instance field id
          which get used to assign a unique, consecutive number to each RexxEngine
          instance to ease debugging in various contexts; added public getId()
          getter method


-------------------------------------- 2022-07-24 ----------------------------------

- BSF4ooRexx.cc

        - impl_jniRexxTerminateInterpreterInstance(), now returns -99
          in case the instance got removed from the RII list right before
          using it for termination;
          adding new critical section to protect termination while
          concurrently an instance lookup may take place

        - RgfRemoveProxyObject(): now uses the root/primodal instance (no
          need for an instance lookup in this case)


-------------------------------------- 2022-07-22 ----------------------------------

- RexxEngine.java

        - added option to run terminate() on a separate thread; by default
          termination occurs on the current thread; this gets controlled by
          the static field terminateOnSeparateThread=false for which a getter and
          setter got defined (ooRexx 4.x and ooRexx 5 as of July 31st 2022 cannot
          handle Terminate() on a separate thread correctly & safely); otherwise
          it should be set to true, as blocking while terminating an instance
          does not affect the clients

-------------------------------------- 2022-07-20 ----------------------------------

- RexxAndJava.java

        - since using ConcurrentHashMap() there is no need to synchronize anymore


-------------------------------------- 2022-07-19 ----------------------------------

- RexxEngine.java

        - it seems that ooRexx 5 r12473 does not run the .local monitor destination
          object's uninit methods; hence reseting .input, .output, .error,
          .traceOutput, .debugInput with new monitor objects monitoring .stdin,
          .stdout, .stderr, and the new .stderr, .stdin monitors respectively


-------------------------------------- 2022-07-16 ----------------------------------

- RexxCleanupRef.java

        - if there are more than 100 unfinalized RexxEngine, then
          System.gc() gets run on a separate thread to help clean
          up all BSF4ooRexx related objects (especially RexxProxy
          objects that may pin ooRexx objects)


-------------------------------------- 2022-07-15 ----------------------------------

- samples/4-020_EuroCalcJava.rxj

        - added Croatian Kuna rate of exchange (Croatia introduces the Euro on
          January 1st, 2023)

- RexxCleanupRef.java

        - changed logic to also cater for RexxScriptEngine (if freed,
          RexxEngine.terminate() needs to be invoked which will cause
          termination of the RII via jni), hence not invoking
          jniRexxTerminateInterpreterInstance(RII) anymore

        - before terminating "call bsf.redirectTo ooRexx" gets invoked to
          make sure that potentially redirected standard files & redirected
          ooRexx traceoutput and debuginput get redirected to the standard
          ooRexx streams

        - needed to change element from <String> to Object


-------------------------------------- 2022-07-14 ----------------------------------

- RexxAndJava.java

        - changed RexxReflectUtil.loadClass() to not automatically register the
          loaded class with the BSF registry, therefore LOAD_CLASS must do it instead

- RexxCleanupRef.java

        - added new kind REXX_SCRIPT_ENGINE

- RexxScriptEngine.java

        - removed field bsfMgr and public routine getBsfManager(): not
          needed in the context of this class

-------------------------------------- 2022-07-13 ----------------------------------

- RexxEngine.java

        - when terminating a RII it may be the case that it does not exist
          anymore due to the new RexxCleanupRef logic, therefore ignore the
          exception (RII = Rexx interpreter instance)

-------------------------------------- 2022-07-02 ----------------------------------

- samples/4-070_BezierCurves.rxj (new sample)

        - ooRexx solution of Ruurd Idenburg's NetRexx BezierCurves demo program.


-------------------------------------- 2022-06-27 ----------------------------------

- BSF.CLS

        - class .uno_proxy is usually not visible to BSF.CLS, adjust
          *createArrayOf routines/methods accordingly (use class id
          to determine whether instance of uno_proxy)

-------------------------------------- 2022-04-21 ----------------------------------

- RexxAndJava.java

        - add RAJBean.getName()

-------------------------------------- 2022-03-04 ----------------------------------

- RexxCleanupRef.java

        - cater for the eventual removal of System.runFinalization():
          catch Throwable and report it


-------------------------------------- 2022-01-31 ----------------------------------

================================================================
GA-version: 2022-01-31
================================================================

-------------------------------------- 2022-01-31 ----------------------------------

- samples/1-110_messageDigest.rxj: new (last minute) sample

        - this program demonstrates the external function BsfRawBytes() to turn a
          Rexx string into a Java byte array, a Java byte array into a Rexx string
          which makes it easy to take advantage of Java methods that expect or return
          Java byte arrays as is the case with some methods in the Java class
          java.security.MessageDigest

-------------------------------------- 2022-01-29 ----------------------------------

- rexxcUtil.rex

        - add sanity checks to prohibit running on incompatible ooRexx interpreter:
          METAVERSION increased to 43 on 26 Jan 2022, committed with revision 12349

-------------------------------------- 2022-01-26 ----------------------------------

- rexxcUtil.rex

        - if an error, show debug information

        - ooRexx r12326 (as of 2021-11-28) changed image format, but did not
          increase METAVERSION ("imageVersion") field from 42 to 43

        - imageVersion now 43: starting with ooRexx 5.0 r12349 (as of 2022-01-26)
          or later

-------------------------------------- 2022-01-20 ----------------------------------

- BSF.CLS

        - added optional fourth argument to bsf.compile(): by default .true
          and returns the newClass processed with bsf.importClass() such
          that it understands the ooRexx class message "new" and "newStrict";
          in the case that someone needs to define an abstract class then
          this fourth argument needs to not be .true such that the plain
          Java class proxy gets returned unprocessed (bsf.import() would
          raise an error, if the supplied Java class is abstract)

- samples renamed to better indicate their purpose

        - 2-031_GetJavaSystemProperties.rxj    --> 2-031_GetJavaSystemProperties_doWith.rxj
        - 2-050_GetJavaSystemProperties2.rxj   --> 2-050_GetJavaSystemProperties2_sortWithTreeSet.rxj
        - 2-051_GetJavaSystemProperties2.rxj   --> 2-051_GetJavaSystemProperties2_sortWithRexx.rxj
        - 2-060_GetJavaSystemProperties3.rxj   --> 2-060_GetJavaSystemProperties3_toXML.rxj

-------------------------------------- 2022-01-18 ----------------------------------

- added new samples

        - 2-031_GetJavaSystemProperties.rxj  ... demonstrates "do with ... over" on java.util.Properties

        - 2-051_GetJavaSystemProperties2.rxj ... demonstrates "makeArray" on java.util.Properites

- renamed samples:

      - 2-110_compileAndUseNetRexx.rxj          --> 4-500_compileAndRunEmbeddedNetRexx.rxj
      - 3-100_compileAndUseJava.rxj             --> 4-601_compileAndRunEmbeddedJava1.rxj
      - 3-100_compileAndUseNetRexx.rxj          --> 4-600_compileAndRunEmbeddedNetRexx1.rxj
      - 3-110_compileAndUseJava.rxj             --> 4-611_compileAndUseEmbeddedJava2.rxj
      - 3-110_compileAndUseNetRexx.rxj          --> 4-610_compileAndUseEmbeddedNetRexx2.rxj
      - 9-010_ExecuteMainMethodInJavaClass.rxj  --> 4-060_runJavaClassMainMethod.rxj
      - 9-020_swt_snippet108.rxj                --> 9-010_swt_snippet108.rxj
      - 9-030_compileJavaClassAndUseIt.rxj      --> 4-701_compileAndUseEmbeddedJava3.rxj
      - 9-030_compileNetRexxClassAndUseIt.rxj   --> 4-700_compileAndUseEmbeddedNetRexx3.rxj

-------------------------------------- 2022-01-13 ----------------------------------

- BSF.CLS

        - add ability to compile NetRexx programs to routine bsf.compile()

- 3-100_compileAndUseNetRexx.rxj

        - added syntax condition handler for demonstration

- 3-110_compileAndUseNetRexx.rxj

        - added syntax condition handler for demonstration

- 9-030_compileJavaClassAndUseIt.rxj

        - changed Java code slightly,
        - changed Java class name and method names
        - added syntax condition handler for demonstration

- added new samples

        - 3-100_compileAndUseJava.rxj ... counterpart to 3-100_compileAndUseNetRexx.rxj

        - 3-110_compileAndUseJava.rxj ... counterpart to 3-110_compileAndUseNetRexx.rxj

        - 9-030_compileNetRexxClassAndUseIt.rxj ... counterpart to 9-030_compileJavaClassAndUseIt.rxj

-------------------------------------- 2022-01-13 ----------------------------------

- BSF.CLS

        - add ability to compile NetRexx programs to routine bsf.compile()

- added new samples

        - samples/1-090_formattingDateDecimal.rxj ... localized formatting

        - samples/1-100_setGetClibboard.rxj       ... using system clipboard

        - samples/2-110_compileAndUseNetRexx.rxj  ... compile and use NetRexx program

        - samples/3-100_compileAndUseNetRexx.rxj  ... compile and use NetRexx program

        - samples/3-110_compileAndUseNetRexx.rxj  ... compile and use NetRexx class

-------------------------------------- 2021-11-16 ----------------------------------

- install/setupBSF.rex

        - Linux arm32 name was wrong ("libBSF4ooRexx.so-32-arm" instead of
          "libBSF4ooRexx.so-32-arm32")

-------------------------------------- 2021-10-04 ----------------------------------

- MacOS AOO installation/uninstallation

        - creates $HOME/Java/Extensions if it does not exist yet and also links
          libBSF4ooRexx.dylib there (needed on some AOO installations)


-------------------------------------- 2021-09-14 ----------------------------------

- RexxScriptEngine.java

        - bug fix in "public void setAddLatestPackageDynamically (boolean newValue)" (reported
          by Michael Hall)

- source_cc/Makefile-all-macosx

        - fix RPATH definitions for MacOS

-------------------------------------- 2021-08-29 ----------------------------------

- BSF.CLS

        - add System's "os.arch" property in quotes to the Java chunk in
          "display.version" entry

- Unix install scirpts

        - it might be possible that "/usr/local/bin" and "/usr/local/lib"
          do not exist on newly rolled out systems, so make sure that they get created
          as BSF4ooRexx places symbolic links there

-------------------------------------- 2021-08-28 ----------------------------------

- source_cc/lib/libBSF4ooRexx.so-32-arm32

        - new arm32 build

- source_cc/lib/libBSF4ooRexx.so-64-s390x

        - new build

-------------------------------------- 2021-08-26 ----------------------------------

- Makefile-all-macosx

        - changing name of resulting lib from libBSF4ooRexx.so-64-aarch64 to libBSF4ooRexx.so-64-arm64

- Makefile-all-macosx

        - adding RPATH to arm64 version (was overlooked)

- source_cc/lib/libBSF4ooRexx.so-64-arm64

        - new arm64 build, renamed libBSF4ooRexx.so-64-aarch64 to libBSF4ooRexx.so-64-arm64

- install/setupBSF.rex

        - 64-bit arm test against different machine names ("arm", "aarch64",
          "arm64") and use either "lib/libBSF4ooRexx.so-64-aarch64" or if not
          present "lib/libBSF4ooRexx.so-64-aarch64"


-------------------------------------- 2021-08-23 ----------------------------------

- BSF.CLS

        - if a weird "java.version" value gets returned that cannot be parsed
          into a whole number for the "major" part use "java.specification.version"
          instead

- all Linux Makefiles

        - add RPATH at link-time, Linux bitness set to either:

           $ORIGIN:$ORIGIN/../lib:/usr/local/lib:/usr/lib:/opt/ooRexx/lib
           $ORIGIN:$ORIGIN/../lib:/usr/local/lib64:/usr/lib64:/usr/local/lib:/usr/lib:/opt/ooRexx/lib

- Makefile-all-macosx

        - uppercasing "R" in /opt/ooRexx/lib, RPATH now set to:

          @loader_path:@loader_path/../lib:/usr/local/lib:/Library/Frameworks/ooRexx.framework/Libraries:/opt/ooRexx/lib

-------------------------------------- 2021-08-22 ----------------------------------

- BSF.CLS

        - "java.version" from early-access/beta versions of OpenJDKs may be of the
          form "18-ea" and the like, rather than in the form "major.minor.rest";
          cater for that by translating only numbers and dots and then parse that

- Makefile-all-macosx

        - RPATH now set to:

          @loader_path:@loader_path/../lib:/usr/local/lib:/Library/Frameworks/ooRexx.framework/Libraries:/opt/oorexx/lib

          so the searching order should be:

                1) same directory libBSF4ooRexx.dylib resides
                2) starting from the directory libBSF4ooRexx.dylib resides: ../lib
                3) /usr/local/lib
                4) /Library/Frameworks/ooRexx.framework/Libraries (GUI installer for BSF4ooRexx)
                5) /opt/oorexx/lib (whatever ooRexx version is there)

-------------------------------------- 2021-08-21 ----------------------------------

- Makefile-all-macosx

        - adding -rpath such that libBSF4ooRexx.dylib searches librexx[api].dylib
          according to it

-------------------------------------- 2021-08-14 ----------------------------------

- Mac GUI installer (Packages)

        - new logic for installing OpenOffice/LibreOffice support (scripts/AOO_install_support.sh,
          AOO_uninstall_support.sh)

                - if multiple OO/LO installed, process all of them

                - ScriptProviderForooRexx.oxt installed for user for the moment

-------------------------------------- 2021-08-14 ----------------------------------

- setupBSF.rex

        - MacOSX: add 'aarch64' (reported by Java as such) as another test,
                  default to 'universal' in case the name 'x86_64' is not
                  reported by Java

-------------------------------------- 2021-08-08 ----------------------------------

- RexxCleanupRef.java

        - clone in synchronized block

        - change format patterns to static final

-------------------------------------- 2021-08-07 ----------------------------------

- RexxCleanupRef.java

        - new public static methods "getStatistics()" and "getStatistics(title)"
          which return a formatted string showing the current totals of instances,
          finalizations, not yet finalized grouped by RefKind

        - not needed anymore hence removed static countInstances and
          countFinalizes with their getter methods

        - new public static method getRefkinds() which returns an array of the
          current enum values of the RefKind enum class

-------------------------------------- 2021-08-06 ----------------------------------

- RexxCleanupRef.java

         - make KindRef enum public

         - add two-dimensional long array "counters" for counting instances,
           finalizes grouped by enum values

         - add public getter getCounters() to return a copy of "counters"

         - added static main() method which tests RexxCleanupRef with
           TestObjects, to run use the following comand:
           java org.rexxla.bsf.engines.rexx.RexxCleanupRef

-------------------------------------- 2021-08-05 ----------------------------------

- BSF.CLS

        - mark all attributes and methods explicitly as guarded which to
          "defend" against side-effects of the new ooRexx 5.0 setting of
          methods by default to "unguarded", if they do not contain either
          the EXPOSE or the USE LOCAL statement; this has undesired side
          effects, hence making sure that the guard state is explicitly
          set to insulate from any future changes in this regards; this
          fix is necessary to get "bsf4oorexx/samples/JavaFX/javafx_update_GUI-from-non-GUI-thread.rxj"
          and "bsf4oorexx/samples/3-090_update_awtSwing_GUI-from-non-GUI-thread.rxj"
          working again

- RexxCleanupRef.java

        - make KindRef enum public

        - add two-dimensional long array "counters" for counting instances,
          finalizes grouped by enum values

        - add public getter getCounters() to return a copy of "counters"

        - added static main() method which tests RexxCleanupRef with
          TestObjects, to run use the following comand:
          java org.rexxla.bsf.engines.rexx.RexxCleanupRef

-------------------------------------- 2021-08-05 ----------------------------------

- RexxProxy.java and
- RexxAndJava.java

        - removing finalize() which got deprecated for Java

        - use PhantomReference as a replacement, ie., the RexxCleanupRef class
          in the constructor


-------------------------------------- 2021-08-04 ----------------------------------

- org_rexxla_bsf_engines_rexx_RexxCleanupRef.h

        - added new include file org_rexxla_bsf_engines_rexx_RexxCleanupRef.h

- BSF4ooRexx.cc

        - added new include file org_rexxla_bsf_engines_rexx_RexxCleanupRef.h

        - refactor three JNI functions to allow them to be used from RexxAndJava and
          the new RexxCleanupRef Java class:

          - inline impl_jniRexxHaltInterpreterInstance(...) invoked by
            - Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniRexxHaltInterpreterInstance
            - Java_org_rexxla_bsf_engines_rexx_RexxCleanupRef_jniRexxHaltInterpreterInstance

          - inline impl_jniRexxTerminateInterpreterInstance(...) invoked by
            - Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniRexxTerminateInterpreterInstance
            - Java_org_rexxla_bsf_engines_rexx_RexxCleanupRef_jniRexxTerminateInterpreterInstance

          - inline impl_jniUnregisterRexxObject(...) invoked by
            - Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniUnregisterRexxObject
            - Java_org_rexxla_bsf_engines_rexx_RexxCleanupRef_jniUnregisterRexxObject

- RexxCleanupRef.java

        - new class to replace the finalize() mechanism by PhantomReferences

- RexxDispatcher.java

        - Object.finalize() is slated to be removed from a future version of Java,
          possibly also System.runFinalization(), cater for it



-------------------------------------- 2021-07-28 ----------------------------------

- install/setupBSF.rex

        - Windows and Unix versions of rexxj.{cmd|sh} structured in a comparable manner
          to ease usage, maintenance and comparisons

                - sequence of determining which java to use for execution the same:
                  JAVA_HOME -> java used with setupBSF.rex -> default location -> java

        - fetches BSF4OOREXX_HOME's "bsf4ooRexx*bin.jar" as absolute path and prepends it
          to the CLASSPATH

        - Unix: after checking JAVA_HOME trying the Java version that was used to create
                the rexxj.sh script before falling back to "java"


-------------------------------------- 2021-07-25 ----------------------------------

- replaced janino 3.1.2 with 3.1.4 (May 2021) (cf. org.codehaus.commons and org.codehaus.janino)

-------------------------------------- 2021-07-24 ----------------------------------

- install/setupBSF.rex

        - changes for rexxj.{cm|sh}:

                - BSF4REXX_HOME gets defined to point to the directory where setupBSF.rex
                  resides; will be placed in front of java.library.path: this makes sure
                  that Java will find the dynamic link library [lib]BSF4ooRexx.{dll|so|dylib}

                - OOREXX_LIB_HOME environment variable gets set, if ooRexx 5.0 or higher;
                  will be placed after BSF4REXX_HOME, but before java.library.path: this
                  makes sure that Java loads this Rexx interpreter

                - if PREPEND_JAVA_LIBRARY environment variable is set, it will
                  be put in front of all of the java.library.path: this allows on MacOS
                  to be used in place of DYLD_LIBRARY_PATH/LD_LIBRARY_PATH which might
                  get wiped out by SIP (note: if a script defines DYLD_LIBRARY_PATH
                  then this will be honored if running programs from the same session)

                - if JAVA_HOME environment variable is set, use it, otherwise
                  fallback to the exact Java version that was employed when the script got
                  created; if that path does not exist anymore, fall back to "java" and
                  have the operating system find and run it


-------------------------------------- 2021-07-19 ----------------------------------

- Makefile-all-macosx

        - fat (universal) binary, simplify/tidy up a little bit

        - using "-target" instead of "-arch"

        - do not link against libjvm.dylib (was a long standing mistake/error)

-------------------------------------- 2021-07-18 ----------------------------------

- BSF4ooRexx.cc

        - Windows: new sequence for searching Java:

                        1) new: honoring JAVA_HOME, if set in the following sequence:

                               %JAVA_HOME%\bin\server\jvm.dll
                               %JAVA_HOME%\jre\bin\server\jvm.dll

                        ") just load unqualified "jvm.dll" and have the operating system
                           search and load it

        - Unix:    new sequence for searching Java:

                        1) /opt/BSF4ooRexx/libBSF4ooRexx.{so|dylib} (a symbolic link created at installation time)
                        2) new: honoring JAVA_HOME, if set in the following sequence:

                               ${JAVA_HOME}/lib/server/libjvm.{so|dylib}
                               ${JAVA_HOME}/jre/lib/server/libjvm.{so|dylib}

                        3) Apple only: use "/System/Library/Frameworks/JavaVM.framework/JavaVM" (used to be the default)
                        4) just load unqualified "libjvm.{so|dylib}" and have the operating system
                           search and load it


        - Unix only: if loading Java on Unix, 'java.library.path' gets set, unless it is passed as
                     "-Djava.library.path=..." in ${BSF4Rexx_JavaStartupOptions}; supplied value:

                        /opt/BSF4ooRexx:/usr/lib:/usr/lib64:/usr/local/lib:/usr/local/lib64:.

                     [this way we can help Java locate libBSF4ooRexx.{so|dylib} on all Unix systems]

-------------------------------------- 2021-07-17 ----------------------------------

- setupAllAndRun.rex

        - little cleanup of code

- setupBSF.rex

        - on Unix: - added cmd.eUseSymbolicLink?, cmd.eSymbolicLink, cmd.eChownOfSymbolicLink

                   - now using symbolic links for /usr/local/{bin|lib}

                     - apply owner:group

                     - making sure symbolic links get owner:group set (must use "-h")

                   - instead of copying the files physically, now only
                     symbolic links get created; to change this behaviour back to copying
                     change: "cmd.eUseSymbolicLink?=.false" below

                   - little cleanup of code

- setupOOo.rex

        - on Unix: - added cmd.eUseSymbolicLink?, cmd.eSymbolicLink, cmd.eChownOfSymbolicLink

                   - now using symbolic links for /usr/local/{bin|lib}

                     - apply owner:group

                     - making sure symbolic links get owner:group set (must use "-h")

                   - instead of copying the files physically, now only
                     symbolic links get created; to change this behaviour back to copying
                     change: "cmd.eUseSymbolicLink?=.false" below

                   - little cleanup of code

-------------------------------------- 2021-07-15 ----------------------------------

- setupOOo.rex

        - on Unix: - only copy UNO-related programs & chown /usr/local/bin/UNO*
                   - make sure owner gets set accordingly on Unix

- setupAllAndRun.rex

        - on Unix: new routine "determineHomeDir()", new "cmd.eHomeDir"

- setupBSF.rex

        - on Unix: - if new profile/bashrc/zshenv gets created change owner to realUserName afterwards

- setupFileAssociations.rex

        - on Unix: new routine "determineHomeDir()", new "cmd.eHomeDir"

-------------------------------------- 2021-07-13 ----------------------------------

- setupAllAndRun.rex

        - on Unix add "cmd.eChownUserGroup", new routine "determineGroupName(defGroup)"

- setupFileAssociations.rex

        - Unix

          - add "cmd.eSudoUser", "cmd.eChown", cmd.eSetExecutable

          - make real user the owner of the created scripts

          - on Unix add "cmd.eChownUserGroup", new routine "determineGroupName(defGroup)"

- setupBSF.rex

        - on Unix: - added: add/remove to/from $HOME/.zshenv

                   - correct needle test for conditionally setting environment from ~/.bashrc

                   - make real user the owner of the created un/install scripts

                   - added "cmd.eChown"

                   - on Unix add "cmd.eChownUserGroup", new routine "determineGroupName(defGroup)";
                     make sure libjvm.so link in /opt/BSF4ooRexx gets owner:group set;
                     new routine "determineHomeDir(userName, isMacOS)", result stored
                     in new "cmd.eHomeDir"

- setupOOo.rex

         - on Unix: - added: add/remove to/from $HOME/.zshenv

                    - correct needle test for conditionally setting environment from ~/.bashrc

                    - make real user the owner of the created un/install scripts

                    - removed unused "cmd.eSetOwner"

                    - added "cmd.eChown"

                    - on Unix add "cmd.eChownUserGroup", new routine "determineGroupName(defGroup)";
                      new routine "determineHomeDir(userName, isMacOS)", result stored
                      in new "cmd.eHomeDir"

-------------------------------------- 2021-07-12 ----------------------------------


- setupAllAndRun.rex

        - on Unix change owner after copying package to cmd.eRealUserName

        - show in logfile the command, if it returned with rc<>0

-------------------------------------- 2021-07-06 ----------------------------------

- utilities/ooRexxTry.rxj

        - ExecuteThread::run: unlike ooRexx 4.x ooRexx 5.0 will raise an error condition
          if .mm.dir~tempFile is .nil when being used in SysFileExists(.mm.dir~tempFile)

-------------------------------------- 2021-07-05 ----------------------------------

- RexxScriptEngine.java

        - added logic to cater for being used for a JSP (Java server page); if
          'out' and ScriptContext.getWriter() are the same object, it is assumed
          that the RexxScriptEngine gets employed for a JSP in which case no
          prefix is injected, no automatic flushing carried out and the linend
          is set to the sequence "0d0a"x to match HTML and XML linened conventions

-------------------------------------- 2021-05-16 ----------------------------------

- MacOS installation

        - added support for zsh, which now has become Apple's default shell

          - "~/.zshrc" for CLASSPATH settings as for "security reasons" one is not
            even able as root to create and maintain "/etc/zprofile"

          - changed Automator menu launcher (a Java program) to start Java in
            a subshell in the background and therefore become able to exit the
            shell that got automatically started

-------------------------------------- 2021-02-16 ----------------------------------

- BSF.CLS

        - routine parseJavaOptions() will now add option "-Djava.class.path=" if
          not defined, using CLASSPATH environment variable (remove duplicates,
          explode trailing asterisks '*'; in Java 6 explosion of asterisks was
          done, at least starting with Java 8 we need to do that!)

-------------------------------------- 2021-02-09 ----------------------------------

- Supplier.java

        - supplier instance method was missing (returns the instance itself)

-------------------------------------- 2021-02-07 ----------------------------------

- RexxReflectJava6.java (new: resolves nested classes now)

        - relocate code to fetch nested classes after normal methods got sought

- RexxReflectJava7.java (new: resolves nested classes now)

        - relocate code to fetch nested classes after normal methods got sought

-------------------------------------- 2021-02-05 ----------------------------------

- ArrayWrapper.java

        - new public supplier(RexxProxy clzSupplier) method that returns
          the supplier as an ooRexx .Supplier object to allow ooRexx 5.0
          new "DO WITH" to function

- BSF.CLS

        - Bsf_Array_Reference::supplier will now use new ArrayWrapper.supplier(RexxProxy)
          method and unbox the returned genuine ooRexx supplier object; this is to
          allow the new ooRexx 5.0 "DO WITH" construct to work with wrapped Java arrays;
          Supplier.java not used anymore by BSF4ooRexx

- RexxReflectJava6.java (new: resolves nested classes now)

        - if a method is expected, the bean is a class and no arguments are supplied,
          then first seek a nested class

        - new method reflectNestedClass(RexxReflectUtil rru) to carry out reflection

- RexxReflectJava7.java (new: resolves nested classes now)

        - if a method is expected, the bean is a class and no arguments are supplied,
          then first seek a nested class

        - new method reflectNestedClass(RexxReflectUtil rru) to carry out reflection

-------------------------------------- 2021-02-04 ----------------------------------

- Supplier.java

        - fix bug in nextElement(): skipping first index-element pair and causing
          a runtime exception when a Java array gets used in DO WITH ... OVER

-------------------------------------- 2020-12-17 ----------------------------------

- RexxScriptEngineFactory.java

        - introduced a boolean field that controls whether the
          getOutputStatement(someString) uses "SAY" (true) or
          ".output~charout" (false)

-------------------------------------- 2020-11-24 ----------------------------------

- RexxScriptEngineFactory.java

        - getProgram(): make comment a little bit more terse


-------------------------------------- 2020-11-20 ----------------------------------

- install/setupBSF.rex

        -  make sure the 64-bit "arm" library can be also "aarch64" and use
           the suffix "-aarch64" for it from now on

-------------------------------------- 2020-10-22 ----------------------------------

- BSF.CLS

         - add "string" methods to bsf.inputStream and bsf.outputStream

         - allow to configure bsf.outputStream to not use flush method (attribute "doFlush")

-------------------------------------- 2020-09-22 ----------------------------------

- RexxScriptEngine.java

        - make sure that redirected streams get only replaced when
          the ScriptContext's in, out or err are not yet redirected
          to monitored .bsf.inputStream or .bsf.outputStream objects;
          to reset the redirection use "call bsf.redirectTo 'Rexx'"

-------------------------------------- 2020-09-13 ----------------------------------

- RexxScriptEngine.java

        - let bsf.redirectTo do the wrapping

-------------------------------------- 2020-09-12 ----------------------------------

- BSF.CLS

        - fix bsf.redirectTo:
          - check if supplied objects are instances of bsf.inputStream or
            bsf.outputStream and change logic accordingly
          - if bsf.inputStream or bsf.outputStream objects supplied do not change prefix at all
          - fix reusing .input for debugInput and .error for traceOutput
        - bsf.outputStream: expose ENDOFLINE in lineout method

-------------------------------------- 2020-09-07 ----------------------------------

- BSF.CLS

        - BSF.OutputStream now allows an optional third argument, the
          end-of-line characters to use (defaults to .endOfLine); this
          allows one to make sure that e.g. in the context of creating
          HTML via J2EE the correct end-of-line character sequence
          is being used ("0d0a"x) independent of the current operating
          system's end-of-line

-------------------------------------- 2020-08-27 ----------------------------------

- RexxScriptEngine.java

        - make sure that compiled scripts do not get rewritten (no annotation processing)

        - if a compiled script is not encoded, then raise an appropraite ScriptException

- bin/rexxcUtil.rex

        - added rexxcUtil.rex such that programmers can encode a compiled Rexx program to
          allow it to run directly under BSF4ooRexx.

-------------------------------------- 2020-08-20 ----------------------------------

- Janino (http://janino-compiler.github.io/janino/)

  - replaced Janino 3.0.15 (from 2019) with latest version (3.1.2, baseline is Java 6 and
    is able to compile up to Java 1.8/8 features, check feature list as not everything
    of newer Java features is implemented, although almost everything :) )

-------------------------------------- 2020-08-17 ----------------------------------

- bsf4oorexx.dev/install/setupBSF.rex

        - add 64-bit arm library name

-------------------------------------- 2020-08-13 ----------------------------------

- samples/ReneJansen/jdbc.jrexx

        - added new databases, switches: "A" (MariaDB), "L" (SQLite), "Y" (MySQL)

        - tidying up a little bit


- samples/ReneJansen/xslt.jrexx

        - uses bsf.loadClass() for abstract TransformerFactory instead of bsf.import()

-------------------------------------- 2020-08-12 ----------------------------------

- BSF.CLS

        - added public routine ppJavaExceptionChain(co[,bStackTrace]) which
          returns a string showing the Java exception chain to ease spotting
          the source Java exception for debugging

- samples/JavaFX/*

        - removed dependency on rgf_util2.rex' ppCondition2() by replacing these
          calls with the new ppJavaExceptionChain() routine

-------------------------------------- 2020-07-27 ----------------------------------

- BSF.CLS

        - fixed some ooRexxDoc formatting errors

-------------------------------------- 2020-07-27 ----------------------------------

- samples\JavaFX, added new samples:

        - fxml_20: ListView sample

        - fxml_25: simple TableView sample

        - fxml_26: TableView sample with editable ComboBox column

        - fxml_27: TableView sample with editable ComboBox, DatePicker;
                   committing in addition to ENTER, when using TAB or focus change with
                   mouse

-------------------------------------- 2020-01-28 ----------------------------------

- RexxCompiledScript.java

        - removed code to change filename this is not possible for a
RexxCompiledScript

- RexxScriptEngine.java

        - when compiling and no filename is given, then try to use
          the FILENAME value in the ENGINE_SCOPE Bindings, if any, otherwise
          create an artificial filename that includes day and time of compiling;
          note: once compilation is done the filename cannot be changed anymore

-------------------------------------- 2020-01-27 ----------------------------------

- RexxCompiledScript.java

        - using createArgV(): only supply RexxScriptEngine instance and
          RexxCompiledScript instance if in debugging
mode

- RexxScriptEngine.java

        - using createArgV(): only supply RexxScriptEngine And RexxCompiledScript instance if debugging

-------------------------------------- 2020-01-20 ----------------------------------

- RexxScriptEngineFactory.java

        - error fix: return THREADING constant value instead of "THREADING"

- bsf4rexx\rgf\G_misc\07_rexx_JSR_223.testGroup

        - adjust for the change in getOutputStatement() which now uses .output~charout() instead of SAY

        - adjust for the change in returning "rexx" instead of "Rexx" in the extension list

bsf4rexx\rgf\F_testClassNames\01_rexx_ClassNameMusings.testGroup

        - remove erroneous empty ::attribute directive

bsf4rexx\rgf\G_misc\12_declareBean.testGroup

        - added new testGroup to test declareBean() and undeclareBean(), now that that
          functionality has been added to the RexxEngine

                - declareBean allows to define implicit values such that they automatically
                  get resolved in bsf.lookupBean(nameOfImplicitVariable)

                - undeclare Bean removes defined implicit values, hence RexxEngine must not
                  be able to be able to look them up anymore


-------------------------------------- 2019-12-11 ----------------------------------

- RexxEngine.java

        - added field hasDeclaredBeans to allow optimization in RexxAndJava.lookupBean()

-------------------------------------- 2019-11-26 ----------------------------------

- RexxAndJava.java

        - lookupBean(): if not found in the registry looks up the new HashMap
          RexxEngine.engineDeclaredBeans

        - lookupBean(), little optimization: only lookup declared beans, if there are any

- RexxEngine.java
        - rolled back changes of 2019-11-25, instead

        - added HashMap<String,BSFDeclaredBean> engineDeclaredBeans to maintain
          BSFManager's declareBean(bean) and undeclareBean(name) invocations; will
          be looked up by RexxAndJava.lookupBean(), if beanName not found in its
          registry

        - the Apache BSF taglib uses BSFManager.declareBean() to register Java objects
          for the scripts, therefore declareBean() and undeclareBean() must honor
          their invocations in order to make those beans available to ooRexx

          - declareBean(): now registers BSFDeclaredBean with RexxAndJava

          - undeclareBean(): now unregisters the bean with RexxAndJava



-------------------------------------- 2019-11-14 ----------------------------------

- RexxAndJava.java

        - new method truncObject() to make sure that any Object's String value gets
          truncated for better legibility in error messages

- RexxReflectUtil.java

        - new method truncObject() to make sure that any Object's String value gets
          truncated for better legibility in error messages


-------------------------------------- 2019-11-07 ----------------------------------

- samples\JavaFX\fxml_01\fxml_01_controller.rex

        - refactored dumping the Bindings to the new routine "dumpAllBindings"

- samples\JavaFX\fxml_02\fxml_02_controller.rex

        - refactored dumping the Bindings to the new routine "dumpAllBindings"

-------------------------------------- 2019-10-24 ----------------------------------

- samples\java\javax.script\RexxRunScript.rex

        - show Java supplied messages related to raised syntax conditions in test_engine_eval() routine

        - reformat output in routine testEngine() to make it a little bit terser

-------------------------------------- 2019-09-09 ----------------------------------

- samples\Java\ JavaRunRexx_02.java

        - added prominent comment to draw the attention to initialize
          the oo-support of BSF4ooRexx by executing the Rexx statement
          "::requires 'BSF.CLS'" before running Rexx scripts; once "BSF.CLS"
          was carried out BSF4ooRexx gets changed to supply the arguments
          directly as objects (and not as strings representing the objects)

-------------------------------------- 2019-08-29 ----------------------------------

- ClassAdapter.java

        - allow more control over generated class names consulting the new fields:
                static public boolean bAddCRC32toNewName=false;
                static public boolean bAddCRC32toGeneratedClassName=true;
                static public boolean bAddHashToGeneratedClassName=false;
                static public String extensionIndicator = "$RexxExtendClass$";
                static public String packageName="org.rexxla.bsf.engines.rexx.onTheFly";

-------------------------------------- 2019-08-26 ----------------------------------

- ClassAdapter.java

        - do not add BSFException to the throws clause of methods, rather
          throw a RuntimeException with the BSFException as the cause when
          a Rexx condition gets raised while invoking the proxy Rexx object

-------------------------------------- 2019-08-25 ----------------------------------

- ClassAdapter.java

        - supplying additional interface classes should be also honored for extending abstract classes

        - fix bug that only honored one interface method (instead of honoring all)

- bsf4rexx\rgf\D_abstractClasses\03_rexx_testAbstractCallback.testGroup

        - add tests for optional array of Interface classes as fourth argument

- bsf4rexx\rgf\E_extendNormalClasses\03_rexx_testExtendNormalCallback.testGroup

        - add tests for optional array of Interface classes as fourth argument

-------------------------------------- 2019-08-24 ----------------------------------

- ClassAdapter.java

        - there will always methods for public/protected abstract methods and constructors created

          - if message name array is null or an empty Array, then
            only abstract methods and constructors get created

          - if message name array has a single entry "*", then
            all declared public/protected methods get created

          - else all array elements that refer to public/protected listed methods will be honored

- BSF.CLS

        - adjust bsf.createProxyClass() documentation according to effective behaviour of
          ClassAdapter.java

- bsf4rexx\rgf\D_abstractClasses\03_rexx_testAbstractCallback.testGroup

        - adjust tests according to corrected behaviour of ClassAdapter.java

- bsf4rexx\rgf\E_extendNormalClasses\01_rexx_testExtendNormal.testGroup

        - adjust tests according to corrected behaviour of ClassAdapter.java

- bsf4rexx\rgf\E_extendNormalClasses\02_rexx_testExtendNormalCallback.testGroup

        - adjust tests according to corrected behaviour of ClassAdapter.java

- bsf4rexx\rgf\E_extendNormalClasses\03_rexx_testExtendNormalCallback.testGroup

        - adjust tests according to corrected behaviour of ClassAdapter.java


-------------------------------------- 2019-08-21 ----------------------------------

Removed ASM (cf. <https://asm.ow2.io/>) from package, adjusting necessary files

- BSF.CLS

        - adjust for renaming "org.rexxla.bsf.engines.rexx.ProxiedJavaClassTool" to
          "org.rexxla.bsf.engines.rexx.ClassAdapter"

- RexxExtendClass.java

        - removed (ASM)

- RexxExtendingClassLoader.java

        - removed (ASM)

- RexxProxy.java

        - renamed ProxiedJavaClassTool.java to ClassAdapter.java

- ProxiedJavaClassTool.java

        - renamed to ClassAdapter.java

- bsf4rexx\rgf\D_abstractClasses\03_rexx_testAbstractCallback.testGroup

        - ASM got replaced, adjust tests; ProxiedJavaTool got renamed to ClassAdapter

- bsf4rexx\rgf\E_extendNormalClasses\01_rexx_testExtendNormal.testGroup

        - ASM got replaced, adjust tests; ProxiedJavaTool got renamed to ClassAdapter

- bsf4rexx\rgf\E_extendNormalClasses\02_rexx_testExtendNormalCallback.testGroup

        - ASM got replaced, adjust tests; ProxiedJavaTool got renamed to ClassAdapter

- bsf4rexx\rgf\E_extendNormalClasses\03_rexx_testExtendNormalCallback.testGroup

        - ASM got replaced, adjust tests; ProxiedJavaTool got renamed to ClassAdapter

-------------------------------------- 2019-08-20 ----------------------------------

- RexxProxy.java

        - remove "ASM" as Janino suffices for our needs, is fast enough and compiles plain Java

-------------------------------------- 2019-08-16 ----------------------------------

- RexxCompiledScript.java

        - fix Javadoc references

- RexxReflectUtil.java

        - fix Javadoc references

- RexxScriptEngine.java

        - fix Javadoc references

- RexxStrictArgument.java

        - fix Javadoc references

-------------------------------------- 2019-08-15 ----------------------------------

- RexxReflectInterface.java

        - fix Javadoc references


- RexxReflectJava6.java

        - fix Javadoc references

- RexxReflectJava7.java

        - fix Javadoc references

-------------------------------------- 2019-08-13 ----------------------------------

- InvocationType.java

        - fix Javadoc references

- ProxiedJavaClassTool.java

        - fix Javadoc references

- RexxAndJava.java

        - fix Javadoc references

- RexxEngine.java

        - fix Javadoc references

-------------------------------------- 2019-07-26 ----------------------------------

- RexxScriptEngineFactory.java

        - add mime types "text/rexx", "text/oorexx", "application/rexx", "application/oorexx"

-------------------------------------- 2019-02-04 ----------------------------------

- BSF.CLS

  - removed "bsf.loadClass2environment()", changed "bsf.loadClass()" to save class
    object in environment, if a second argument with the index name is supplied

  - replaced "bsf.loadClass2environment()" with "bsf.loadClass()"

- bsf4oorexx/samples/JavaFX/fxml_05/staff.rxj

  - replaced "bsf.loadClass2environment()" with "bsf.loadClass()"

- utilities/ooRexxTry.rxj

  - replaced "bsf.loadClass2environment()" with "bsf.loadClass()"

-------------------------------------- 2019-02-03 ----------------------------------

- utilities/ooRexxTry.rxj

  - adjusted code to use bsf.loadClass2environment() for abstract classes, instead
    of bsf.importClass()

-------------------------------------- 2019-02-02 ----------------------------------

- BSF.CLS

  - to inhibit attempting to instantiate abstract classes indirectly via bsf.import()
    the logic got changed; as a result routine "initialize.bsf.dir" got adapted to use
    bsf.loadClass() instead of bsf.importClass() for it

  - added new routine "bsf.loadClass2environment(javaClassName[,indexName])": loads and
    saves class object in environment (currently .environment, with ooRexx 5.0 only
    support maybe in .package~local, cf "bsf4oorexx.dev/ToDo.txt")

  - adapted BSF.InputStream and BSF.outputStream to use bsf.loadClass2bsf4rexx()
    instead of bsf.import() for the abstract Java Reader and Writer classes

- The following nutshell programs now use bsf.loadClass()/bsf.loadClass2environment() for
  abstract classes, now that bsf.import() cannot be used for them anymore (avoiding a possible, subtle bug)

  - samples\JavaFX\javafx_02.rxj: because of abstract class "java.util.ResourceBundle"

  - samples\JavaFX\fxml_02\fxml_02.rex: because of abstract class "java.util.ResourceBundle"

  - samples\JavaFX\fxml_05\staff.rxj: because of abstract class "javafx.util.Callback"

  - samples\JavaFX\fxml_99\MainApp.rex: because of abstract class "java.util.prefs.Preferences"

-------------------------------------- 2019-02-01 ----------------------------------

- RexxReflectUtil.java

  - made sure that an abstract class gets not instantiated (possible reflectively,
    if concrete default constructor)


- BSF.CLS

  - propagate conditions in BSF's constructor method "init"

  - adapted BSF-version string to indicate minimum ooRexx level as well:
    minJavaVersion*100+minOoRexx*10 "." date-of-release


-------------------------------------- 2019-01-07 ----------------------------------

- InvocationType.java

  - added enum value "UNBOX"

- RexxAndJava.java

  - added subfunction "UNBOX": returns the unboxed value as a string or null, if not
    a wrapped object

- BSF.CLS

  - change routine "unbox" to take advantage of new BSF subfunction "unbox" (which
    returns the unboxed value as a string or .nil, if value was not of a boxed/wrapped
    type); the routine "unbox" will return the supplied value, if that is not a Java
    boxed/wrapped value without raising an exception


-------------------------------------- 2019-01-02 ----------------------------------

- BSF.CLS

  - change routine "unbox" to accept plain Rexx strings as well, in which
    case that value gets returned

-------------------------------------- 2018-12-30 ----------------------------------

- ooRexxTry.rxj

  - in case a Rexx condition was the cause display it in the Rexx style, otherwise
    use "rgf_util2.rex"'s ppCondition2() to show the full list of chained Java
    exceptions to allow user to identify the original cause of the Java exception

    - class "GUIErrorStream", method "lineout": make sure that after an explicit
      LF ("0a"x) the prefix "REXXerr>" gets inserted as well

    - class "CExitHandler", method "handleExit": make sure that after an explicit
      LF ("0a"x) the prefix ("REXXout>" or "REXXerr>") gets inserted as well

-------------------------------------- 2018-12-23 ----------------------------------

- BSF.CLS

  - new private routine "create_display.version_entry": encodes the
    currently employed versions of ooRexx, BSF.CLS and Java in a
    single string to ease debugging; fetch this value via .bsf4rexx~display.version

- ooRexxTry.rxj

  - removed routine createVersionStringToDisplay() as it got moved to BSF.CLS,
    from now on using new entry ".bsf4rexx~display.version" instead

-------------------------------------- 2018-12-21 ----------------------------------

- setupFileAssocations.rex

  - SysVersion() now returns the Windows version number with multiple dots, hence
    getting integer value using '.' in the parse template rather than via an
    arithmetic operation

-------------------------------------- 2018-11-27 ----------------------------------
- BSF.CLS

  - new private routine "create_display.version_entry": encodes the
    currently employed versions of ooRexx, BSF.CLS and Java in a
    single string to ease debugging; fetch this value via ".bsf4rexx~display.version"

- utilities/ooRexxTry.rxj

  - now uses ".bsf4rexx~display.version" for its title information

-------------------------------------- 2018-11-27 ----------------------------------

- BSF.CLS

  - add the Boolean truth objects named as "boolean.true" and "boolean.false"
    to the .bsf4rexx directory, such that they can be immediately used in
    Rexx implemented lambda function return values

-------------------------------------- 2018-11-13 ----------------------------------

- RexxReflectJava6.java

  - corrected bug in processField() when accessing first element in the
    returned value of coerceArgs(), which could also be the null value


- RexxReflectJava7.java

  - corrected bug in processField() when accessing first element in the
    returned value of coerceArgs(), which could also be the null value

-------------------------------------- 2018-11-11 ----------------------------------

- RexxAndJava.java

  - fixed IS_INSTANCE where an exception was raised, if a plain string got supplied

-------------------------------------- 2018-11-09 ----------------------------------

- RexxReflectJava6.java

  - reflectMethod(): reorder logic for special handling of primitive and interface classes

- RexxReflectJava7.java

  - reflectMethod(): reorder logic for special handling of primitive and interface classes

-------------------------------------- 2018-11-03 ----------------------------------

- RexxAndJava.java

  - subfunction CREATE_STRICT_ARGUMENT: make it usable if not employing BSF.CLS

  - some tidying up


- RexxReflectJava6.java

  - reflectMethod(): special handling for primitive classes needed, because a primitive
    class object does not have a superclass, so no instance methods can be invoked, which we want
    for ooRexx users; hence manually setting the superclass to the java.lang.Object class


- RexxReflectJava7.java

  - reflectMethod(): special handling for primitive classes needed, because a primitive
    class object does not have a superclass, so no instance methods can be invoked, which we want
    for ooRexx users; hence manually setting the superclass to the java.lang.Object class

-------------------------------------- 2018-11-02 ----------------------------------

- BSF.CLS

  - leave original implementation of BOX() for backward compatibility, it
    is semantically equivalent to the term in use for Java

  - added a new public routine BOX.STRICTARG() which will box the values
    in an instance of the new class RexxStrictArgument() and returns it;
    values of this type will force the contained classObject to be exactly
    in the signature in order for the candidate field, method or constructor
    to qualify

  - renamed 'runLaterPush' to 'runLaterLatestPush'

  - added 'runLaterPush' that pushes the message, but does not remove
    messages addressing the same object and message like 'runLaterLatestPush'

- RexxAndJava.java

  - adjust arrayPutStrict() to use RexxStrictArgument directly to wrap primitive value

-------------------------------------- 2018-11-01 ----------------------------------

- BSF.CLS

  - changed the routines BOX() and UNBOX() to adjust them to the new class
    RexxStrictArgument which allows to strictly pick the corresponding
    field, method or constructor candidates; the primitive types will
    now be forced to strictly pick primitive types in the signatures

- InvocationType.java

  - added enum value "CREATE_STRICT_ARGUMENT"


- RexxAndJava.java

  - changed convFromRexx() and coerceArgs() to use the new class RexxStrictArgument that
    makes sure that only fields, methods and constructors get picked that strictly match
    the classObject of RexxStrictArgument

  - added new subfunction "strictArg" which will employ convFromRexx() and return a RexxStrictArgument;
    meant to be used by box.strictArg() in BSF.CLS


- RexxReflectJava6.java

  - adjusting to new usage of RexxStrictArgument, which makes sure that its classObject
    is used to strictly compare signatures; is used in picking a strictly matching
    candidate field, method, constructor

  - remove access to RexxReflectUtil.bTryCoercions as that field is not used anymore


- RexxReflectJava7.java

  - adjusting to new usage of RexxStrictArgument, which makes sure that its classObject
    is used to strictly compare signatures; is used in picking a strictly matching
    candidate field, method, constructor

  - remove access to RexxReflectUtil.bTryCoercions as that field is not used anymore

-------------------------------------- 2018-10-25 ----------------------------------

- BSF.CLS

  - changed how "rexx.version" gets parsed and assembled; revision part is omitted,
    hence: major.minor

-------------------------------------- 2018-10-24 ----------------------------------
- BSF.CLS

  - added method "runLaterPush" to class "AbstractGuiThread": this method works
    like "runLaterLatest", removing duplicate messages (addressed to the same object
    using the same message name) from the queue, but pushes the new GUIMessage to
    the queue; this way such a message will run before any other ones that are in
    the queue at the time of the push

-------------------------------------- 2018-10-11 ----------------------------------

- new: bsf4oorexx.dev/source_cc/Makefile-32-linux-arm

  - adapted for ARM-32 (Raspberry Pi) by Igor Petrushin

- new: bsf4oorexx.dev/source_cc/lib/libBSF4ooRexx.so-32-arm

  - binary ARM-32

-------------------------------------- 2018-10-07 ----------------------------------

- BSF4ooRexx.cc

  - fixed subtle bug in RgfJavaObject2RexxObject(): only do a ReleaseLocalReference(), if
    bsf.wrap() returns a new Rexx object, otherwise ooRexx crashes may develop
    as wrong Rexx object pointers get used!

- BSF.CLS

  - add an entry "rexx.version" to .bsf4rexx

-------------------------------------- 2018-10-02 ----------------------------------

- BSF4ooRexx.cc

  - fixed subtle bug in RgfProcessJArgs(): only do a ReleaseLocalReference(), if
    bsf.wrap() returns a new Rexx object, otherwise ooRexx crashes may develop
    as wrong Rexx object pointers get used!

-------------------------------------- 2018-09-29 ----------------------------------

- samples/3-090_update_awtSwing_GUI-from-non-GUI-thread.rxj

  - commented "call SysSleep 0.001" which should not be needed for ooRexx 5.0

  - if stopping, do not clear label anymore


- samples/JavaFX/javafx_update_GUI-from-non-GUI-thread.rxj

  - commented "call SysSleep 0.001" which should not be needed for ooRexx 5.0

  - if stopping, do not clear label anymore

- BSF4ooRexx.cc

  - RexxAllocateMemory() and RexxFreeMemory() got employed in the original BSF4Rexx
    version that could run on other Rexx interpreters like Regina as well; BSF4ooRexx (two 'oo')
    was created with ooRexx 4.0 that introduced new APIs that allowed new features to
    be implemented; replacing the two APIs with malloc() and free() should remove overhead

-------------------------------------- 2018-09-21 ----------------------------------

- BSF4ooRexx.cc

  - RgfProcessJArgs(): make sure that ReleaseLocalReference(clzBSF) gets executed
    only if clzBSF is not NULL (older test units may have that condition)

-------------------------------------- 2018-09-20 ----------------------------------

- samples/JavaFX/fxml_05/staff.rxj

  - use absolute paths to jar files, such that the program executes from any directory

-------------------------------------- 2018-09-18 ----------------------------------

- rgf_util2.rex

  - ppCondition2(): test whether the class .BSF (from BSF4ooRexx) is present before
    using it in the isA(.bsf) test

- BSF.CLS:

    - routine bsf.contextClassLoader() now also accepts a list of URL strings/objects beside
      a single array object of URL strings/objects

- samples/JavaFX/fxml_05/staff.rxj

  - taking advantage of change in bsf.contextClassLoader() now allowing a plain
    list of URLs (no need to explicitly create an array of these values)

-------------------------------------- 2018-09-16 ----------------------------------

- BSF.CLS:

   - add ".bsf4rexx~bsf.cls.fullPath" and ".bsf4rexx~bsf.cls.location" to allow querying
     the location of this BSF.CLS from other Rexx programs easily

   - new public routine "bsf.contextClassLoader [urlOrDirOrFileName | urlCollection]" that allows
     to define the Thread's context class loader to find classes and resources in
     the supplied urlOrDirOrFileName | urlCollection

   - to ease the support for "bsf.contextClassLoader" the following Java classes:
     'java.lang.ClassLoader', 'java.lang.Thread', 'java.io.File',
     'java.net.URL', 'java.net.URLClassLoader'

- samples/JavaFX/fxml_05/staff.rxj

  - remove routine "makeResourcesAvailable", instead use the new public routine
    "bsf.contextClassLoader(urls)"

-------------------------------------- 2018-09-15 ----------------------------------

- samples/JavaFX/fxml_05/staff.rxj

  - set the Java thread context class loader to make the startup directory
    and the appropriate jar-files available:

    - with the modularization introduced in Java 9 the JavaFX 8 library
      "jar\controlsfx-8.40.14.jar" would not work anymore; the replacement
      version of this JavaFX library for Java 9 and higher ("jar\controlsfx-9.0.0.jar")
      would not work on Java 8;

    - the routine "makeResourcesAvailable" will determine the Java version and use
      an URLClassLoader in order to supply the URLs for the appropriate
      "controlsfx*jar" file and the directory this program resides; this URLClassLoader
      will use the current Thread's context class loader as its parent and then will
      be used as the new Thread context class loader

  - use the unqualified class name of the imported "javafx.beans.property.*" classes
    as the Rexx class name

  - removed the switching to the directory where the Rexx program resided, not
    necessary because of the customized URLClassLoader that adds that directory
    as URL to be looked up (removed change done at 2018-03-24)

-------------------------------------- 2018-09-14 ----------------------------------

- BSF.CLS:

  - restructured routines bsf.import() and its synonym bsf.importClass() to match
    arguments with class BSF's class method bsf.import()

-------------------------------------- 2018-07-23 ----------------------------------

- samples\1-080_charsetTranslations.rxj:

  - reinserted override for MacOSX, still necessary: output in Terminal needs to be in "UTF-8",
    Java "file.encoding" may be "MacRoman"

-------------------------------------- 2018-07-22 ----------------------------------

- BSF.CLS:

  - removed "unguarded" from AbstractGuiThread, FxGuiThread and AwtGuiThread methods
    as refactoring removed deadlock potential (attributes are now in subclasses
    and get fetched with getters if needed in AbstractGuiThread methods)

- samples\1-080_charsetTranslations.rxj:

  - using dash in UTF charset names (instead of underline),
  - added UTF-32*, "IBM-273" (IBM EBCIDC Austria, Germany)
  - removed override for MacOSX as not necessary ('file.encoding' is used on Terminal output)

- samples\JavaFX\javafx_dialog_demo.rxj:

  - prepended file name in creating Image with "file:" to allow it to find
    the bitmap in the current directory

-------------------------------------- 2018-07-19 ----------------------------------

- added samples\javafx\javafx_update_GUI-from-non-GUI-thread.rxj

  - this JavaFX GUI application demonstrates how to update a GUI object (a Label)
    from a non-GUI thread using the methods of the public class .FxGuiThread defined
    in BSF.CLS

- added samples\javafx_update_GUI-from-non-GUI-thread.rxj

   - this awt/swt GUI application demonstrates how to update a GUI object (a Label)
     from a non-GUI thread using the methods of the public class .AwtGuiThread defined
     in BSF.CLS

- added samples\1-080_charsetTranslations.rxj

   - this program demonstrates charset/codepage translations of strings using
     the BSF.CLS public routine "bsf.iconv(string,inCharset,outCharset)"

-------------------------------------- 2018-07-18 ----------------------------------

- added samples\javafx\javafx_dialog_demo.rxj

  - demonstrate using the JavaFX dialog classes that got introduced with JavaFX 8u40,
    cf. <http://code.makery.ch/blog/javafx-dialogs-official/>

-------------------------------------- 2018-07-14 ----------------------------------

- BSF.CLS:

  - refactoring the GUI related utility classes "FxGuiThread" and "AwtGuiThread" into
    a common private abstract class "AbstractGUIThread" defining abstract attribute
    and methods to be implemented by the refactored subclasses "FxGuiThread" and
    "AwtGuiThread"

-------------------------------------- 2018-07-13 ----------------------------------

- BSF.CLS:

  - added class "AwtGuiThread" as the awt/swing counterpart to "FxGuiThread" class
    having the same protocol (same methods and behaviour, just adapted to awt/swing)

  - corrected routine "BSF.terminateRexxEngine": .routines~rBsf with .routines~xBsf


-------------------------------------- 2018-06-07 ----------------------------------

- BSF.CLS:

  - added method "util.setmethod" to class BSF_REFERENCE to allow setting methods
    (with "float" scope) to individual instances; needed for decorating UNO.CLS
    UNO_ENUM instances (adding methods 'toString', 'name' and 'value')


-------------------------------------- 2018-06-04 ----------------------------------

- BSF.CLS:

  - added public routine bsf.iconv public(str,fromCp,toCp) to allow recoding of a Rexx string


-------------------------------------- 2018-04-03 ----------------------------------

- BSF.CLS:

  - adjust for ooRexx 4.1.3 restrictions (development and tests occurred
    on the *much* better ooRexx 5.0.0)

    - Array's appendAll is not documented, but operational, however does
      not return the receiver: cater for it using cascading messages instead

    - .debugInput and .traceOutput may not exist

-------------------------------------- 2018-03-15 ----------------------------------

- BSF.CLS:

  - correct type while fetching XBsfCreateRexxProxy() from .routines

-------------------------------------- 2018-03-12 ----------------------------------

- BSF.CLS:

  - bsf.compile(): if the source of a syntax error is related to the supplied
    Java class name a new syntax condition is raised with an error message hinting
    at two possible causes to help the programmer; otherwise the raised syntax
    gets propagated

  - corrected typo ("java.awt.Taskbar") for Java 9 usage

-------------------------------------- 2018-03-08 ----------------------------------

- all Rexx programs:

  - added or replaced existing hashbang line with "#!/usr/bin/etc rexx" which works
    on all Unix machines and allows flexible locations for the ooRexx interpreter

- RexxReflectUtil.java

  - finalized implementation that gets used by RexxReflect?.java

-------------------------------------- 2018-03-06 ----------------------------------

- samples\9-030_compileJavaClassAndUseIt.rxj

  - new sample demonstrating the use of bsf.compile(); requires ooRexx 5.0 or higher

-------------------------------------- 2018-03-05 ----------------------------------

- BSF.CLS:

  - new public routine "bsf.compile(javaClassName,code)" which returns the
    Java class object

- BSF4ooRexx.cc:

  - bsfDoUnregisterRexxObject: set default to "true", such that unregistering Rexx
    objects takes place in all cases

- RexxScriptEngine.java:

  - added method "removeHashBang(String script)" which blanks out the
    first Rexx script line, if it starts with a Unix hashbang (#!)

-------------------------------------- 2018-02-26 ----------------------------------

- RexxAndJava.java:

  - added native jniTestPing() method to allow for testing/debugging calls
    via JNI to the native layer

- BSF.CLS:

  - make INTERPRET-free

  - removed routine "createJavaLoadStatement"

-------------------------------------- 2018-02-25 ----------------------------------

- BSF.CLS:

  - finished rework of using rBSF/.routines~xBSF and the like

  - now the class methods and routines bsf.createArrayOf/bsf.createJavaArrayOf
    behave the same by not proxying .uno_reference objects (if OOo/AOO support
    is active); reason being that .UNO objects will forward unknown messages
    to their embedded BSF object peer

  - tidying up

-------------------------------------- 2018-02-24 ----------------------------------

- BSF4ooRexx.cc:

  - new external Rexx routine "BsfTestPing" which only returns; allows to test
    and time calling external Rexx functions from Rexx scripts

- BSF.CLS:

  - fetch the most used native routines to have them incorporated into .routines,
    change INTERPRET to call/callWith messages to those routines, which in total
    should speed up the bridge quite a bit (approximately at least 10 times)

-------------------------------------- 2018-02-23 ----------------------------------

- BSF4ooRexx.cc:

  - new function "BsfUninit4JavaBean(beanName)": called from UNINIT code in BSF,
    version uses RexxAndJava class object, therefore the Rexx interpreter instance
    used for uninits does not have a need for a peer RexxAndJava instance (ooRexx
    uninits may be run on a newly created Rexx interpreter instance that is not
    linked to Java otherwise)

  - unregisterBean[4JNI] now return -1 for not registered, or remaining leftCount
    (0=removed from registry)

- RexxEngine.java:

  - changed logic in unregisterBean() to adapt to change in RexxAndJava.unregisterBean
    return type (now int)

- BSF.CLS:

  - UNINITs now use the new "BsfUninit4JavaBean(beanName)" function which is
    able to be executed on an ooRexx created Rexx interpreter that has no
    connection to a Java RexxAndJava object established

  - routine "makeBSF4ooRexxLookLikeMacOSX": for Java 9 add Java 9 support
    to add an icon to the dock; also make sure that the routine will not
    stop running programs on MacOSX, if a syntax condition arises


-------------------------------------- 2018-02-22 ----------------------------------

- RexxAndJava.java:

   - added static method "unregisterBean4JNI" to allow native code to decrease
     the reference counter of the proxied Java object

   - unregisterBean now returns the value of the reference counter or -1, if
     not registered

   - added method "getBeanRefCount" which returns the current value of the reference
     counter or -1, if not registerd

   - added number argument to BSF-subfunction "rexxReflectObject" which allows
     for forcing e.g. to use RexxReflectJava6 even on much higher Java runtime
     environments (argument "6") for testing purposes and as a last resort
     fallback

- RexxReflect6.java:

  - new class for core reflection, i.e. taking advantage of java.lang.reflect package,
    used for Java 1.6 deployment, works flawlessly an later versions of Java as well

- RexxReflect7.java:

  - new class for core reflection, meant for for Java 1.7 and later as it
    takes advantage of the java.lang.invoke package introduced with Java 1.7


-------------------------------------- 2018-02-20 ----------------------------------

- BSF.CLS:

  - added new bsf4rexx-entries "java.version", "java.major.version" and
    "java.minor.version"

- BSF4ooRexx.cc:

  - remove the JNI methods jniForceConstructorNewInstance, jniForceFieldGet,
    jniForceFieldSet, jniForceMethodInvoke as they cannot be used to force the
    intended operations on Java 9; as the problem got solved by rewriting the
    reflection part in Java, these methods are not needed and get removed

- RexxAndJava.java:

  - remove the jni methods jniForceConstructorNewInstance, jniForceFieldGet,
    jniForceFieldSet, jniForceMethodInvoke as they cannot be used to force the
    intended operations on Java 9; as the problem got solved by rewriting the
    reflection part, these methods are not needed and get removed

  - deprecated use of PROPERTY and EVENT subfucntions; first invocation will
    show a deprecation warning

- ProxiedJavaClassTool.java

  - when creating interface methods, make sure that only abstract interface methods get proxied;
    starting with Java 1.8/8 there are concrete interface methods possible (static and default interface
    methods)

-------------------------------------- 2018-02-17 ----------------------------------

- RexxAndJava.java:

  - new reflection logic added: "RexxReflect6.java" is for the Java 1.6/6 baseline
    and Java 1.7/7; "RexxReflect7.java" compilable against Java 1.7/7, but will
    be deployed against 1.8/8 (which has been tested to be reliable) and higher

  - new subfunction "rexxReflectObject": will return the current RexxReflectJava* object in
    use; allows querying and setting fundamental behaviour via the boolean attributes
    "useCaching" on RexxReflectJava{6|7}, and on RexxReflectJava7 in addition the attributes
    "useReflectInvoke" and "useUnreflect"

-------------------------------------- 2018-02-07 ----------------------------------

- RexxAndJava.java:

  - allow from Rexx .true, "true", .false, "false" for boolean/Boolean, anything
    else will return null

-------------------------------------- 2018-01-19 ----------------------------------

- BSF4ooRexx.cc:

  - implement the four JNI methods named jniForceConstructorNewInstance,
    jniForceFieldGet, jniForceFieldSet, jniForceMethodInvoke (these "force"
    JNI routines are means of last resort, if Java 9 or later is not
    allowing to access protected members in superclasses via reflection
    unlike all the previous versions of Java)

  RexxAndJava.java

  - define four JNI methods named jniForceConstructorNewInstance,
    jniForceFieldGet, jniForceFieldSet, jniForceMethodInvoke (these "force"
    JNI routines are means of last resort, if Java 9 or later is not
    allowing to access protected members in superclasses via reflection
    unlike all the previous versions of Java)


-------------------------------------- 2018-01-13 ----------------------------------

- BSF4ooRexx.cc:

  - allow in addition a Routine object in BsfCreateRexxProxy as first argument

- BSF_OnTheFly.cls:

  - changed the code to make it even easier for Rexx programmers to implement Rexx lambda
    functions: BsfCretatRexxProxy now allows as the first argument a String, an array of
    Strings, a Method object or a Routine object that implements the single function;
    the Rexx code in all of these variants will receive the Java argument(s), if any,
    in the same order as Java has sent them; it is possible to learn more about the
    Java invocation by inspecting the trailing slot.argument (a Rexx directory)


-------------------------------------- 2018-01-09 ----------------------------------

- RexxAndJava.java:

   - renamed GET_STATIC_VALUE* to GET_STATIC_FIELD_VALUE*

   - removed 'private' modifier from: Object convFromRexx(String type, String value) throws BSFException

-------------------------------------- 2018-01-08 ----------------------------------

- InvocationType.java

  - new enum class for easying rewriting the reflection infrastructure to support
    Java 9 and later


- RexxAndJava.java:

  - changed switch to use new InvocationType enum class

-------------------------------------- 2018-01-07 ----------------------------------

- RexxAndJava.java:

   - make sure access to rajRegistry is synchronized where values might get changed

   - changed static private int constants (indicating the desired function from Rexx)
     to package private to allow RexxReflect* classes access them

- RexxProxy.java:

  - remove deprecation warning of the Java 9 compiler, if there is a Java 6 compliant,
    non-deprecated alternative; note: the deprecation warning on "finalize" will not
    be honored as this is intentional as it is the only means to allow garbage collection
    on the Rexx side as well, when Java Rexx peers get out of scope


-------------------------------------- 2018-01-06 ----------------------------------

- RexxAndJava.java:

  - remove deprecation warning of the Java 9 compiler, if there is a Java 6 compliant,
    non-deprecated alternative; note: the deprecation warning on "finalize" will not
    be honored as this is intentional as it is the only means to allow garbage collection
    on the Rexx side as well, when Java Rexx peers get out of scope

-------------------------------------- 2018-01-05 ----------------------------------

- RexxAndJava.java:

  - turn utility methods into static:

    -    static Object [] coerceArgs(Object [] funcArgs, Class [] paramTypes)
    -    static protected String makeString4Rexx(Object o)  // changed 2003-01-06 from "makeResultString()" to "makeString4Rexx()"
    -    static public String makeBeanName(Object o)
    -    static protected String registerBean(String beanName, Object object)
    -    static protected Object lookupBean(String beanName)
    -    static int spilloverCounter=0;

    - added new instance method for native code compatibility:

         private String makeString4Rexx(Object o)

    Need to supply RexxAndJava object/instance (named "rajo") to now static methods:

        Need to supply "bTerminated" to now static method:
        -    static protected String registerBean(String beanName, Object object)
        Need to supply or change "this" to RexxAndJava.class to now static method:
        -    static protected Object lookupBean(String beanName)
        -    static protected String registerBean(String beanName, Object object)
        -    static public String makeBeanName(RexxAndJava rajo, Object o)

- RexxEngine.java:

  - adapt RexxAndJava method invocations where methods got turned into static ones (e.g. registerBean)


- RexxReflectInterface.java:

  - new class defining the interface to be implemented by the new RexxReflect*.java classes


-------------------------------------- 2018-01-04 ----------------------------------

- RexxAndJava.java:

  - ARRAY_PUT with Boolean/boolean component type will now behave like SET PROPERTY_VALUE
    and SET_FIELD_VALUE:
    if Rexx string is "1" (.true) then Boolean.TRUE will be used, otherwise the
    type convertor will create the Boolean value (which means that a Rexx string
    value named "true" will yield Boolean.TRUE as well, otherwise BOOLEAN.FALSE,
    which follows from using java.lang.Boolean.valueOf(String))



-------------------------------------- 2018-01-01 ----------------------------------

- RexxAndJava.java:

  - fixed a bug in ARRAY_PUT: only use the type convertor, if convFromRexx() returns
    a string value and the component type is primitive, otherwise use the Object
    value convFromRexx() returned

-------------------------------------- 2017-12-24 ----------------------------------

- BSF4ooRexx.cc:

  - putting and removing LOCAL_PRIMODAL_TID ("BSF.PRIMODALTID") in/from .environment instead of .local


- RexxProxy.java:

  - corrected documentation: .local may go away, if its Rexx interpreter instance
    got terminated and its .local garbage collected


-------------------------------------- 2017-12-23 ----------------------------------

- BSF4ooRexx.cc:

  - implementing <https://sourceforge.net/p/bsf4oorexx/feature-requests/15/>:

    - remove rgfGetEntryFromLocal(), rgfGetEntryFromEnvironment(): not needed anymore

    - remove creation of "Slot.Argument" from native code, define as public class in BSF.CLS and
      use that one for adding a trailing slot argument for messages from Java to Rexx objects
      with optional context information

    - corrected error message in external Rexx routine BSF(), which erroneously was numbered 3 and
      referred to BSFCreateRexxProxy


- BSF.CLS:

    - define a public class "Slot.Argument" here instead of native code (BSF4ooRexx.cc
      and placing the class object in .environment); this class will be used to
      add useful, but optional information which get added as a trailing (a "slot")
      argument on callbacks from Java to Rexx objects

    - relocated .local~bsf4rexx to new class "BSF4REXX" serving as a proxy for the
      bsf4rexx-directory, making this important directory independent of .local

    - removed ".local~ooRexx.version", not used anywhere

    - bsf.import() now saves the class objects in .environment instead of .local

    - explicitly adding .BSF and .Slot.Argument to .environment in order for FindClass()
      to find them (in all contexts)

-------------------------------------- 2017-12-21 ----------------------------------

- rgf_util2.rex:

  - use .environment instead of .local to store important constant values
    (this way it does not matter if the package gets employed in a different
    Rexx interpreter instance)

  - changed version style

- BSF_OnTheFly.cls:

  - corrected comment, changed test for empty or .nil code, changed version style

-------------------------------------- 2017-11-21 ----------------------------------

- BSF.CLS:

  - make sure that in .FXGuiThread class "isGuiThread", "runLater" and
    "runLaterLatest" are unguarded, but "run" is guarded; this avoids
    hangs on Windows, reported as <https://sourceforge.net/p/oorexx/bugs/1505/>

-------------------------------------- 2017-11-20 ----------------------------------

- BSF.CLS:

  - further testing <https://sourceforge.net/p/oorexx/bugs/1505/> indicates
    that unguarding the BSF.OutputStream would probably not fix a three-way-
    deadlock, which is caused by SAY-debug statements in BSF.CLS in the
    context of RexxScript usage; this can be remedied by not using SAY-statements
    in BSF.CLS, but in case of thangs replace them with ".stdout~say(...)"
    statements

-------------------------------------- 2017-11-19 ----------------------------------

- BSF.CLS:

  - changed BSF.OutputStream: methods are unguarded, using guard on/off, if
    attribute's values get changed; this inhibits a hang on Windows, where
    special Windows message handling (for OLE support) may cause nested
    re-entrent AttachThread() that may yield hangs in that class SAY method,
    if SAY is used for debug statements

-------------------------------------- 2017-11-17 ----------------------------------

- BSF4ooRexx.cc:

  - added a counter to BSF() and also tid on debug outputs to become able
    in a multithreaded execution to identify the debug output


-------------------------------------- 2017-11-04 ----------------------------------

- RexxScriptEngine.java:

  - if missing filename for eval(): check whether ScriptContext Bindings have
    an entry "location" of type java.net.URL; if so, then assume that the
    execution comes from a JavaFX FXML file so use that location file as part
    of the artificially created filename to ease debugging


-------------------------------------- 2017-10-15 ----------------------------------

- BSF4ooRexx.cc:

  - BsfQueryRegisteredFunctions(): return external Rexx function names BSFGetRIID() and
    BSFGetRTC()

-------------------------------------- 2017-10-09 ----------------------------------

- RexxScriptEngine.java:

  - renamed "DispatchToToPublicRoutines" to "DispatchToPublicRoutines" (removing one "To")

-------------------------------------- 2017-10-08 ----------------------------------

- RexxScriptEngine.java:

  - make sure that the static method dumpScriptContext(sc) will supply
    an appropriate header for non-standard scopes


-------------------------------------- 2017-10-05 ----------------------------------

- BSF4ooRexx.cc:

  - new BSFGetRTC():  allow Rexx to retrieve the Rexx thread context pointer as a
    string for debugging purposes

-------------------------------------- 2017-09-25 ----------------------------------

- BSF4ooRexx.cc:

  - new BSFGetRIID(): allow Rexx to retrieve the Rexx instance ID (the instance pointer
    as string) for debugging purposes

-------------------------------------- 2017-09-23 ----------------------------------

- RexxScriptEngineFactory.java:

  - getLanguageVersion() explicitly terminates the Rexx engine after
    retrieving the Rexx version

-------------------------------------- 2017-09-22 ----------------------------------

- RexxScriptEngine.java:

  - make sure that in the constructor the RexxScriptEngine does not get
    used to execute Rexx scripts, such that it is still possible to configure
    the (to be created) Rexx interpreter instance

- RexxScriptEngineFactory.java:

  - getLanguageVersion() directly employs a BSF Rexx engine, making sure
    that BSF.CLS gets required

-------------------------------------- 2017-09-14 ----------------------------------

- BSF4ooRexx.cc:

  - BsfJavaException(): allow for omitting first argument; if omitted, then
    defaulting to option "CHECK" which returns .true, if a Java exception is
    pending, .false else

-------------------------------------- 2017-09-11 ----------------------------------

- BSF4ooRexx.cc:

  - BsfJavaException(): corrected leftover quick test that deleted the msg buffer,
    which caused an illegal pointer to be used thereafter

-------------------------------------- 2017-08-27 ----------------------------------

- BSF4ooRexx.cc:

  - added undocumented function BsfApplyHotFixCrash(), which will be
    removed; it allows to activate the "HotFix" in SendMessage() from Java
    and runProgram from Java which yields the thread before attaching to
    Rexx; this may help to overcome some crashes in the current ooRexx 5 beta;
    usage: bsfApplyHotFixCrash( | .true | false); if no argument, the current
    setting will be returned

-------------------------------------- 2017-08-23 ----------------------------------

- BSF4ooRexx.cc:

  - continue tidying up and refactoring to make code easier legible

    - remove "RGF_INFO_1", "RGF_INFO", "RGF_BIT", "RGF_BIT2", "DEBUG3", "DEBUG40",
      "RGF_ATTACH", "RGF_DETACH", "DEBUG_JAVA_ATTACH_DETACH"
    - introduced "DEBUG_CREATE_REXX_EXCEPTION"
    - renamed "DEBUG_LOADER_UNLOADER" to "DEBUG_BSF_LOADER_UNLOADER",
      "DEBUG_RGF_ATTACH_NEW" to "DEBUG_JAVA_ATTACH"
    - remove unused "DEBUG_SHOW_STRUCTURES", "RGF_MUTEX4RXSIOTRC", "RGF_INVALID_ROUTINE",
      "DEBUG_THREADS", "DEBUG_RGF_PROCESS_J_ARGS_UNO"
    - remove TID2NODE-related strctures, not needed anymore
    - replaced SNPRINTF with function snprinf(), now that MSC includes it as well under that name
    - removed MSC_VER "#pragma warning(disable:4100)"

-------------------------------------- 2017-08-21 ----------------------------------

- BSF4ooRexx.cc:

  - allow (temporarily) to disable HOT_FIX_CRASH for testing purposes: RexxRoutine "BsfApplyHotFixCrash()"

-------------------------------------- 2017-08-20 ----------------------------------

- BSF4ooRexx.cc:

  - continue tidying up and refactoring to make code easier legible

    - remove definition "CONFIG_REXX_HANDLERS_AS_INTERFACES" as we have been using
      Java interfaces only

    - remove definitions DEBUG40_NIXI, DEBUG_RGF_PROBES, USE_OREXX, USE_REXXTRANS,
      RGF_TRUE

-------------------------------------- 2017-08-19 ----------------------------------

- BSF4ooRexx.cc:

  - continue tidying up and refactoring to make code easier legible

    - added INFO_* statements for easying debugging calls from Java to Rexx to
      help trace down cause of Rexx crashes
    - added HOT_FIX_CRASH definition: sleeping/relinquisghing the thread before
      doing a Rexx AttachThread() significantly reduces crashes, cf. new function
      "hotfix_relinquish_thread()"; trying to remove the crashes by experimenting
      with the "rgf_multihreaded" test units to determine number of relinquishes
      needed to stabilize; still occassionally/rarely hangs occur

-------------------------------------- 2017-08-18 ----------------------------------

- BSF4ooRexx.cc:

  - start tidying up and refactoring to make code easier legible (has become a "cemetery" of all versions
    of bsf4rexx and bsf4oorexx in the past 16 years)

    - rename "const char *" (and PSZ) -> CSTRING; removed PSZ definition
    - removed trailing '\0' in format string "%s\n%s\0"
    - rename typedef "VOID" to "void", "PVOID" to "POINTER" (rexx.h), "TRUE" to "1"
    - remove outdated typedefs like VOID, PVOID, TRUE, APIRET, PFN, REXXPFN, PINT,
      TID and the like
    - replacing "TID" with "thread_id_t", removed typdef for TID and UNIX/WINDOWS conditionals
    - replaced RgfAllocateMemory() with RexxAllocateMemory() and RgfFreeMemory() with
      RexxFreeMemory(); removed obsolete RgfAllocateMemory() and RgfFreeMemory()
    - remove RGF_USE_MUTEX define for Windows, just use it (forgo critical section variant)
    - remove DEBUG_RAISE_CONDITION

-------------------------------------- 2017-08-15 ----------------------------------

- BSF4ooRexx.cc:

  - BSFCreateRexxProxy(): use "R[EXXOBJECT]" instead of "R[EXX]" to self-document how
    the first argument will be  used if of type .string, .method or .array, which
    by default will be used for the code to carry out for the dynamically created
    unknown method; make sure that now JavaProxy is attempted if third argument
    is "R[EXXOBJECT]"


-------------------------------------- 2017-08-14 ----------------------------------

- BSF4ooRexx.cc:

  - BSFCreateRexxProxy(): if first argument is a Rexx string, method or array and
    the third argument is "R[EXX]", then the first argument is proxied as is (allowing
    Java to send it all ooRexx messages) and not used as the code for a dynamically
    created UNKNOWN method that gets proxied by the invoked "BSF_OnTheFly.cls" program

---------------------------------------------------------------------------------------------------------------------------------

-------------------------------------- 2017-08-13 ----------------------------------

- BSF.CLS:

  - make sure that in class "GUIMessage" the constructor method "init" checks that
    the supplied message name is indeed of type .string and if arguments are supplied
    that they are in form of an .array

- JavaInfo4BSF4RexxInstallation.java

  - make sure that the Java System properties are sorted to ease analyzing installation logs

- setupAllAndRun.rex

  - make sure to honor "DARWIN" instead of "MACOSX"

- setupBSF.rex

  - corrected determining MacOSX

-------------------------------------- 2017-08-11 ----------------------------------

- BSF.CLS (2017-08-05 - 2017-08-11)

  - created classes "FxGuiThread" and "GUIMessage" (modelled after
    ooRexx class "Message") to allow dispatching Rexx messages on the JavaFX GUI
    thread to ease coding for Rexx programmers

-------------------------------------- 2017-07-25 ----------------------------------

- BSF4ooRexx.cc:

  - allow an array as Rexx-code argument for BsfCreateRexxProxy()

-------------------------------------- 2017-06-17 ----------------------------------

- ArrayWrapper.java:

  - throws an exception if no Java array object is supplied

- ProxiedJavaClassTool.java:

  - if the context class loader is null, make sure that the SimpleCompiler's parent class loader
    gets set; this version uses the class loader for ProxiedJavaClassTool.

- Supplier.java:

  - added BSFException to ArrayWrapper, need to declare it

-------------------------------------- 2017-06-06 ----------------------------------

- BSF4ooRexx.cc:

  - rename "rcoSlotArgument" to "rcoSlotArgumentClass" to indicate a Rexx class is referenced

-------------------------------------- 2017-06-09 ----------------------------------

- setupBSF.rex

  - add cmd.ePath2JavaDLL to info-output if set or on Windows or MacOSX

-------------------------------------- 2017-04-30 ----------------------------------

- BSF.CLS

  - make sure that all "d2x" messages have a length of 17 (such that negative
    values get appropriate leading "F"s)

-------------------------------------- 2017-04-15 ----------------------------------

- BSF4ooRexx.cc:

  - add a directory subclass named "SLOT.ARGUMENT" to .environment; all slot arguments,
    either from native or Java code must instantiate this class, such that Rexx programmers
    become able to unambiguously identify the slot arguments (appended arguments as a
    result of sending a message from Java)

- RexxCompiledScript.java:

  - use new .Slot.Argument (a subclass of .Directory) instead of a regular .directory,
    suggested by Jon Wolfers at the 2017 International Rexx symposium

- RexxScriptEngine.java:

  - use .slot.argument class (created by BSF4ooRexx.cc as subclass of .directory
    and stored in .environment ad load time of the library); this way
    Rexx programmers become able to unambiguously identify whether the last
    argument is a slot argument

-------------------------------------- 2017-04-04 ----------------------------------

- BSF4ooRexx.cc:

  - make return values after raising Rexx exceptions dependent on DEBUG_RAISE_CONDITION

- RexxAndJava.java:

  - removed debug-output in registerBean4JNI()

-------------------------------------- 2017-04-03 ----------------------------------

- RexxScriptEngine.java:

  - correct parsing of Rexx script annotations

-------------------------------------- 2017-03-13 ----------------------------------

- ProxiedJavaClassTool.java:

  - redo to allow full replacement of ASM, added functionality to create classes off interface(s) only
  - changed "bss" to the self documenting name "bShowSource"


-------------------------------------- 2017-03-12 ----------------------------------

- BSF.CLS: (2017-03-09 - 2017-03-12)

  - routine bsf.createProxyClass enhanced with the possibility to add any number
    of blank delimited Java interface class names after the Java class name that
    is to be extended (alternatively this can be an array with each item being
    a string denoting the fully qualified class name or a Java class object);
    ProxiedJavaClassTool.java got enhanced appropriately

    TODO: remove ASM from BSF4ooRexx); now possible to extend an interface
          class and implement its methods in Rexx without using a java.reflect.Proxy!

-------------------------------------- 2017-03-09 ----------------------------------

- ProxiedJavaClassTool.java:

  - added option to implement any number of interface classes to the extended Java class
    (cf. the changes to BSF.CLS' routine bsf.createProxyClass)

-------------------------------------- 2017-02-21 ----------------------------------

- RexxScriptEngine.java:

  - make sure that any NL character in a potential Rexx script annotation
    (between "/*" and "*/") causes the annotation to be ignored; this allows
    for leaving them in the code, by merely inserting a NL character after
    and/or before the block comment

-------------------------------------- 2017-02-19 ----------------------------------

- BSF4ooRexx.cc:

  - after invoking RaiseException() the return value will be ignored by Rexx; for debugging
    purposes a RexxStringObject in the form of "BSF4ooRexx.cc-RaiseException-FFF-xx" will
    be returned, where FFF denotes the function name and xx is a two digit number starting
    with 01 and incremented for each RaiseException in the same function

-------------------------------------- 2017-02-14 ----------------------------------

- BSF4ooRexx.cc:

  - BsfContextVariables(): if an operation succeeded (like SET or DROP) will return .true
    instead of NULL which indicates no return value!

- setupAllAndRun.rex

  - getRexxBitness(): compare casselessly with "Address Mode"

- setupBSF.rex

  - Linux: carry out a separate ldconfig with the directory to which
    /opt/BSF4ooRexx/libjvm.so points to

-------------------------------------- 2017-02-13 ----------------------------------

- BSF.CLS

  - finalizing implementation of .JSR223's set() and get() methods

-------------------------------------- 2017-02-12 ----------------------------------

- BSF.CLS

  - .JSR223' "get" and "set" methods: adjust logic to desired functionality:

    - honor: attribute names immediately followed by a colon and scope number

    - if an attribute is in fact a scope number than process the following
      attribute names only in that scope (otherwise all scopes are inspected)

- RexxScriptEngine.java:

  - use the Rexx annotation string as is: enclose in double-quotes after
    escaping double-quotes (adhering to the Rexx rules)

- setupBSF.rex

  - add quoted cmd.ePath2JavaDLL to "ldconfig" command; it seems that some
    Linuxes (possibly with multiple Java installations) otherwise do not
    find the libjvm.so that gets loaded with dlopen() by BSF4ooRexx

-------------------------------------- 2017-02-11 ----------------------------------

- BSF.CLS

  - made internal ("procedure") routine "escapeQuotes" a routine

  - methods and routines bsf.createArrayOf and bsf.createJavaArrayOf will
    now use "escapeQuotes" to escape Rexx strings as INTERPRET would
    otherwise cause unexpected results

-------------------------------------- 2017-02-07 ----------------------------------

- BSF.CLS

  - .JSR223::getBindings(): also handle a .context object

-------------------------------------- 2017-02-03 ----------------------------------

- setupAllAndRun.rex

  - when copying the entire tree to its destination, make sure that in Unix the timestamps
    get preserved

  - make sure that the libBSF4ooRexx* shared libraries get the x-bit set (despite new naming)

  - new routine sayWhetherInstallationWasSuccessful() to test whether setup was successful
    (using rexxj{.sh|.cmd})

- setupBSF.rex

  - adjust test for MacOSX for new operating system name "Darwin" (used to be "MacOSX")

  - if Java cannot be found, abort installation with appropriate message and usage

  - make sure that the libBSF4ooRexx* shared libraries get the x-bit set (despite new naming)

  - use "/sbin/ldconfig" instead of "ldconfig" to make sure that it is being found, if available

- wasInstallationSuccessful.rxj - new file

  - determine whether the installation of BSF4ooRexx was successful if using
    the generated script rexxj{.sh|.cmd} to invoke this script; the output
    to STDOUT: could be piped into the calling Rexx program using rxqueue.

-------------------------------------- 2017-01-22 ----------------------------------

- setupAllAndRun.rex

  - add file extension "frm" as a Rexx type of file

- setupFileAssociations.rex

  - add file extension ".frm" as a Rexx type

-------------------------------------- 2017-01-20 ----------------------------------

- BSF.CLS

  - renamed operating system name from "PARSE SOURCE opsys ." from "DARWIN" to "MACOSX",
    this quick fix should keep everything everywhere (in BSF4ooRexx) humming...;


-------------------------------------- 2017-01-09 ----------------------------------

- setupBSF.rex

  - adopting the installation of the lib/dll file to their new names and
    locations

  - on Unix: do not create a link to the libjvm.{so|dylib} to serve as
    the Java to use anymore; leaving the capability in BSF4ooRexx.cc

-------------------------------------- 2017-01-08 ----------------------------------

- BSF4ooRexx.cc:

  - fixed conversion warning where returning NULL instead of 0 (-Wconversion-null).

-------------------------------------- 2017-01-05 ----------------------------------

- setupBSF.rex

  - resolving <https://sourceforge.net/p/bsf4oorexx/bugs/26/>

  - getJavaProps(): now returns stem with Java properties

  - determinePath2JavaBinary(): on Windows will proceed searching, if
    a found java.exe does not match the bitness of ooRexx

-------------------------------------- 2016-12-21 ----------------------------------

- RexxScriptEngineFactory.java

  - getLanguageVersion() now gets the "parse version" string from the used
    ooRexx interpreter, saves it in LANGUAGE_VERSION (now package private)
    and returns that value

- RexxScriptEngine.java

  - if RexxScriptEngineFactory.LANGUAGE_VERSION is null in its constructor,
    then the "parse version" string is queried from the installed ooRexx
    interpreter and saved in that package private field, such that it gets
    used for supplying it via the script context's language Bindings

- samples/1-070_demoDoOver.rxj

  - make sure that "DO WITH" is run on ooRexx 5.0.0 or higher only

-------------------------------------- 2016-12-20 ----------------------------------

- BSF.CLS

  - on unregisterBean do not supply rii_id anymore (not needed anymore)

  - initialize.bsf.dir(): make sure that the pre-registered classes get
    their refCount increased (for multi Rexx-interpreter scenarios)

- BSF4ooRexx.cc

  - in _jniRexxSendMessageToRexxObject: do not do a bsf.wrap with .true as the second
    argument anymore; RexxEngine.java was changed to increase the refCount (on JavaObject
    or MethodObject), such that bsf.wrap returned .BSF object can safely run unregisterBean
    in its uninit method

    in J_jniUnregisterRexxObject: from now on, again execute the unregisterRexxObject, if
    Rexx started Java; on ooRexx 5.0 beta no problems have occurred in testing anymore

    new external Rexx function BsfDoUnregisterRexxObject([.true|.false]); default: .false;
    this controls whether RgfRemoveProxyObject(c_obj_ID) is carried out by the native function
    Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniUnregisterRexxObject in the case Java
    was loaded by Rexx.

- RexxAndJava.java

  - remove rii_id in unregisterBean, not needed anymore

- RexxCompiledScript.java

  - supply RexxScriptEngine instance via slotDir argument as well

- RexxEngine.java

  - methods that supply a Java methodObject or javaObject via jniRexxSendMessageToRexxObject,
    will now increase the respective bean's refCount by one as the native C++ method
    jniRexxSendMessageToRexxObject will use bsf.wrap to create a Rexx .BSF object which will
    use unregisterBean upon running its uninit method

- RexxScriptEngineFactory.java

  - changed version number to reflect that work in the javax.script
    support has taken place

-------------------------------------- 2016-12-19 ----------------------------------

- RexxAndJava.java

  - refactoring the new registry code such that we can save calls from the instance
    *Registry*() to the static *Registry*()-methods

-------------------------------------- 2016-12-18 ----------------------------------

- renamed directories 'samples/{Java|NetRexx}/jsr223' to 'samples/{Java|NetRexx}/javax.script'

  - this rename was done as probably not too many people might know what jsr223 means,
    "javax.script" is the name of the Java package that defines the Java scripting framework
    and that was introduced with Java 1.6/6 (the JSR-223 group created that standard)

  - updating all the NetRexx programs to match the Java siblings programs


- samples/Java/javax.script/nutshell_04d.rex

  - long standing "nutshell_04c.rex" got renamed to "nutshell_04d.rex"

- new samples/Java/javax.script/nutshell_04c.rex

  - the new Rexx-script "nutshell_04c.rex" uses and demonstrates Rexx script
    annotations and therefore does not need setting ARGV explicitly

- samples/Java/javax.script/Nutshell_04_Eval.java

  - adapted to the new script and the renamed script


- samples/NetRexx/javax.script/nrxRunScript.nrx

  - adopt the changes of its Java sibling (cf. "samples/Java/javax.script/RunScript.java")

- samples/NetRexx/javax.script/nutshell_04d.rex

  - long standing "nutshell_04c.rex" got renamed to "nutshell_04d.rex"

- new samples/NetRexx/javax.script/nutshell_04c.rex

  - the new Rexx-script "nutshell_04c.rex" uses and demonstrates Rexx script
    annotations and therefore does not need setting ARGV explicitly

- samples/NetRexx/javax.script/Nutshell_04_Eval.nrx

  - adapted to the new script and the renamed script

-------------------------------------- 2016-12-12 ----------------------------------

- BSF.CLS

  - make sure we return a BSF/BSF_REFERENCE object unchanged; allowing it
    to be wrapped up as a BSF_REFERENCE again, may cause runtime errors
    if the wrong number of uninits get executed (each decreases the refCount
    on the Java side)

-------------------------------------- 2016-12-11 ----------------------------------

- Janino (http://janino-compiler.github.io/janino/)

  - replaced Janino 2.6 (from 2010) with latest version (3.0.6, baseline is Java 6 and
    is able to compile up to Java 1.8/8 features, check feature list as not everything
    is implemented, although almost everything :) )

- BSF.CLS

  - removed public class "BSF_PROXY", which is not really safe to use, if
    programmers do not know what to do with it; this class was created to
    ease mixing BSF()-function style programming with ooRexx-style by
    creating BSF or BSF_REFERENCE proxy objects to which we send the names
    of the Java messages to invoke;

    rather, from now on, use the public routine bsf.wrap() to create
    BSF_REFERENCE proxy objects from Java objects returned from the Java
    side;

-------------------------------------- 2016-12-08 ----------------------------------

- samples/JavaFX

  - created "samples/JavaFX" directory, incorporated the following JavaFX sample files:

        F:\work\svn\bsf4oorexx\trunk\samples\JavaFX>dir /s
         Datenträger in Laufwerk F: ist root_f
         Volumeseriennummer: 7A10-C4A0

         Verzeichnis von F:\work\svn\bsf4oorexx\trunk\samples\JavaFX

        09.12.2016  15:25    <DIR>          .
        09.12.2016  15:25    <DIR>          ..
        09.12.2016  15:25    <DIR>          bkp.test
        21.11.2016  13:34    <DIR>          fxml_01
        06.12.2016  14:53    <DIR>          fxml_02
        20.12.2016  15:52    <DIR>          fxml_03
        06.12.2016  14:34             5.206 index.html
        06.12.2016  14:39             4.436 javafx_01.rex
        06.12.2016  14:39            12.852 javafx_02.rex
        06.12.2016  14:17             1.839 javafx_property_binding.rex
                       4 Datei(en),         24.333 Bytes

         Verzeichnis von F:\work\svn\bsf4oorexx\trunk\samples\JavaFX\bkp.test

        09.12.2016  15:25    <DIR>          .
        09.12.2016  15:25    <DIR>          ..
        07.12.2016  18:45             3.080 errorsIdeas.txt
        06.12.2016  14:44             3.069 fxml_01.rex
        21.11.2016  15:21             1.063 fxml_01_controller.rex
        07.12.2016  19:19             2.333 FXML_01_Document.fxml
        06.12.2016  14:53                96 helloWorld.js
        06.12.2016  14:54                81 helloWorld.rex
        06.12.2016  14:08             1.732 index.html
        08.12.2016  20:20               966 test.rex
                       8 Datei(en),         12.420 Bytes

         Verzeichnis von F:\work\svn\bsf4oorexx\trunk\samples\JavaFX\fxml_01

        21.11.2016  13:34    <DIR>          .
        21.11.2016  13:34    <DIR>          ..
        06.12.2016  14:44             3.069 fxml_01.rex
        21.11.2016  15:21             1.063 fxml_01_controller.rex
        21.11.2016  16:30             1.871 FXML_01_Document.fxml
        06.12.2016  14:08             1.732 index.html
                       4 Datei(en),          7.735 Bytes

         Verzeichnis von F:\work\svn\bsf4oorexx\trunk\samples\JavaFX\fxml_02

        06.12.2016  14:53    <DIR>          .
        06.12.2016  14:53    <DIR>          ..
        31.07.2010  17:57             2.785 bsf4oorexx_032.png
        24.11.2016  14:27             1.519 fxml_02.css
        06.12.2016  14:47             4.112 fxml_02.rex
        19.11.2016  14:36             4.071 fxml_02_controller.rex
        22.11.2016  13:43               374 FXML_02_de.properties
        24.11.2016  14:33             4.464 FXML_02_Document.fxml
        22.11.2016  13:43               372 FXML_02_en.properties
        06.12.2016  14:08             3.052 index.html
        31.07.2010  17:57             2.746 oorexx_032.png
                       9 Datei(en),         23.495 Bytes

         Verzeichnis von F:\work\svn\bsf4oorexx\trunk\samples\JavaFX\fxml_03

        20.12.2016  15:52    <DIR>          .
        20.12.2016  15:52    <DIR>          ..
        06.12.2016  10:13            35.704 address_book.odg
        06.12.2016  10:14            25.074 address_book_128.png
        04.12.2016  16:31             1.215 BirthdayStatistics.fxml
        05.12.2016  12:50             3.500 DarkTheme.css
        06.12.2016  14:08             4.994 index.html
        04.12.2016  17:30            34.489 json-rgf.cls
        20.12.2016  16:46            38.552 MainApp.rex
        06.12.2016  10:09               323 notices.txt
        04.12.2016  16:20             3.650 PersonEditDialog.fxml
        04.12.2016  16:25             5.693 PersonOverview.fxml
        06.12.2016  14:48             5.813 put_FXID_objects_into.my.app.rex
        06.12.2016  10:45             3.667 RootLayout.fxml
                      12 Datei(en),        162.674 Bytes

             Anzahl der angezeigten Dateien:
                      37 Datei(en),        230.657 Bytes


-------------------------------------- 2016-12-08 ----------------------------------

- BSF4ooRexx.cc

  - corrected comment: BSF_PROXY -> BSF_REFERENCE

- RexxAndJava.java

  - tidying up code, removing all code relating to the Java registry changes/additions
    of 2015-08-03, new central Java registry replaces it

-------------------------------------- 2016-12-07 ----------------------------------

- BSF.CLS

  - .JSR223::SET method: second argument defaults to the null string ""

- RexxScriptEngine.java

  - adapted logic for the injection code in the case that the
    Rexx script annotation does not contain a value (using explicitly empty string instead)

- samples/Java/javax.script/RunScript.java

  - reformat getProgram()-output such that line comments are replaced by
    block comments

-------------------------------------- 2016-12-06 ----------------------------------

- BSF.CLS

  - if Rexx started Java the unknown method of BSF if processing sendmessage
    messages would load its RexxAndJava object, but not garbage collect it;
    fixed by using bsf.wrap on the returned value

- samples/Java/javax.script/RunScript.java

  - if no argument is given, show the help after the list of
    currently available javax.script engines

-------------------------------------- 2016-12-04 ----------------------------------

- JavaFX (= powerful GUI) samples

  - work started on "fxml_03"


-------------------------------------- 2016-11-30 ----------------------------------

- BSF.CLS

  - make the UNKNOWN methods Unguarded; it is possible that a method invocation
    on the Java object is taking place, while from the Java side (e.g. for an
    event handler) a callback occurs (in a different RexxActivation) which from
    the Rexx side invokes another Java method in the UNKNOWN method, which will
    block; UNGUARDED solves this problem (and does not introduce a problem into
    Rexx)

-------------------------------------- 2016-11-29 ----------------------------------

- BSF.CLS

  - make sure that .UNO_PROXY and .UNO_ARRAY_PROXY are Rexx class objects
    before using them in isA-tests

-------------------------------------- 2016-11-28 ----------------------------------

- RexxAndJava.java

  - convFromRexx(): check that type string is not the empty string, change error message
    to be more meaningful

  - fixing a subtle bug where even invokestrict() may be fooled in method chosing: e.g.
    java.lang.List possesses two remove methods with the signature "Object remove(int)"
    and "boolean remove(Object)". The current algorithm in INVOKE_STRICT can be misled
    to choose the wrong method if checking the "remove(Object)" first (because an Integer
    object, to which the primitive int value was converted to already, could be used as
    an argument). Now checking if argument must be primitive, so not to accept a parameter
    of type Object.


-------------------------------------- 2016-11-27 ----------------------------------

- RexxAndJava.java

  - new central RAJRegistry with RAJBeans, global to all Rexx interpreter instances

  - make glob_tcr static

- RexxCompiledScript.java

  - created public getter method getRexxScriptEngine()

-------------------------------------- 2016-11-22 ----------------------------------

- JavaFX (= powerful GUI) samples

  - work started on "fxml_02"

-------------------------------------- 2016-11-21 ----------------------------------

- JavaFX (= powerful GUI) samples

  - work started on "fxml_01"

-------------------------------------- 2016-11-19 ----------------------------------

- BSF.CLS

  - updated major version number to 6 to indicate new base level Java 1.6/6

- BSF4ooRexx.cc

  - updated major version number to 6 to indicate new base level Java 1.6/6;
    JNI_VERSION_1_6 should only be used, if we need to use the new 1.6/6 JNI function
    "jobjectRefType GetObjectRefType(env,refObj)"

- RexxAndJava.java

  - updated major version number to 6 to indicate new base level Java 1.6/6

- RexxEngine.java

  - updated major version number to 6 to indicate new base level Java 1.6/6

-------------------------------------- 2016-11-12 ----------------------------------

- RexxAndJava.java

  - change from .isAssignableFrom() to .isInstance() when checking whether
    MAKEARRAY/SUPPLIER could be honored

-------------------------------------- 2016-11-10 ----------------------------------

- BSF.CLS

  - .jsr223: added class methods get and set to process the Rexx script
    annotations

-------------------------------------- 2016-11-09 ----------------------------------

- BSF.CLS

  - bsf.redirectTo(): if no monitored objects are supplied the current one
    gets removed (unless there would be no previous monitored object left),
    before a default one gets created and assigned

- RexxScriptEngine.java

  - added static boolean field "bRedirectStandardFiles" that controls whether
    the ScriptContext's Reader, Writer and ErrorWriter should replace the
    monitored objects of .input (.debugInput), .output or .error (.traceOutput)

-------------------------------------- 2016-11-08 ----------------------------------

- BSF.CLS

  - bsf.OutputStream: now also inserts the prefix after LF chars if the string to
    output contains contains any

  - bsf.OutputStream::charout() now has an optional third argument, if set to .true,
    the prefix gets skipped (used by bsf.InputStream::linein)

- RexxCompiledScript.java

  - add RexxCompiledScript object to slotDir, if available; supplied as new
    fourth argument to static method createArgV(...).

- RexxScriptEngine.java

  - supply null as new fourth argument to RexxCompiledScript.createArgV(...)
    as we have no RexxCompiledScript available in the case of invokeMethod()

- samples/Java/jsr223

  - changed (adapted) all Rexx scripts to not issue "Rexx" anymore as this is now
    automatically done by BSF.CLS for Rexx script (javax.script) programs

-------------------------------------- 2016-11-07 ----------------------------------

- BSF.CLS

  - added ability to output a prefix-string for BSF.InputStream and BSF.OutputStream objects

  - routine bsf.redirectTo now sets that prefix for the redirectred standard Rexx files
    monitored by .input, .output, .error, .debugInput, .traceOutput to
    "REXXin?>", "REXXout>", "REXXerr>", "REXXdbgIn?>", "REXXtrc>" respectively;
    in order to turn the redirected prefix on or off just set the "prefix" attribute to .nil,
    in order to change the string just change the "prefix" attribute

- ProxiedJavaClassTool.java

  - remove reflective usage of Method.isSynthetic() as we can now rely on it to be available
    (baseline is now Java 1.6/6.0)

- RexxScriptEngine.java

  - updateRexxEngine() method should be synchronized to make sure that
    re-assigning standard files does not get interrupted, if multithreaded
    usages

- new samples/1-070_demoDoOver.rxj

   Demonstrate how to use DO...OVER and (starting with ooRexx 5) DO WITH...OVER with

   - java.lang.Enum class objects
        - MAKEARRAY will supply all enum Java objects
        - SUPPLIER will supply as index the ordinal value and as item the enum Java object

   or with Java objects implementing one of the following interfaces:

   - java.lang.Iterable
   - java.util.Collection
   - java.util.Enumeration
   - java.util.Iterator
        - MAKEARRAY will supply the collected values
        - SUPPLIER will supply as index and item the collected value (as if they were ooRexx Bags)

   - java.util.Map
        - MAKEARRAY will supply the key values
        - SUPPLIER will supply as index the key and as item the value stored with the key

- org.oorexx.datergf.DateRgf.java

  - added a static main method that gives a brief overview of this class

- samples/9-010_ExecuteMainMethodInJavaClass.rxj

  - hint the user to test with the org.oorexx.datergf.DateRGF Java
    class which is supplied with BSF4ooRexx and got a static main method
    added for this hint text

-------------------------------------- 2016-11-06 ----------------------------------

- RexxAndJava.java

  - if non-existing MAKEARRAY or SUPPLIER methods should be invoked, then check, whether
    we have a Java collection in hand that has one of the following interfaces implemented:
    java.lang.Iterable, java.util.Collection, java.util.Enumeration, java.util.Iterator or
    java.util.Map. If so, then create and return a genuine Rexx object of type .Array or
    .Supplier wrapped as a RexxProxy which can be unwrapped on the ooRexx side using BsfRexxProxy(rp,"o")
    as will be done in BSF.CLS' class BSF.

    In addition treat a Java class object of type java.lang.Enum as a collection of enum values
    and return them for MAKEARRAY; in the case of SUPPLIER use the ordinal enum values for the index
    array and the enum values for the item array

-------------------------------------- 2016-11-05 ----------------------------------

- ProxiedJavaClassTool.java

  - basing on 1.6/6.0, get rid of generic warnings

- RexxDispatcher.java

  - basing on 1.6/6.0, get rid of generic warnings

- RexxExtendClass.java

  - basing on 1.6/6.0, get rid of generic warnings

- RexxProxy.java

  - oops, overlooked that the test program did it from Rexx, now we make sure we
    use Janino instead of ASM by setting to Janino in the static block

- RexxScriptEngine.java

  - basing on 1.6/6.0, get rid of generic warnings

-------------------------------------- 2016-11-04 ----------------------------------

- ProxiedJavaClassTool.java

  - fixed bug that did not extend an abstract class, if not methods to proxy were supplied
    (which will be the case when invoked by RexxProxy.newExtendedProxyInstance(...))

- RexxAndJava.java

  - basing on 1.6/6.0, get rid of generic warnings:

                    source_java>javac -Xlint:unchecked RexxAndJava.java
                    RexxAndJava.java:543: warning: [unchecked] unchecked call to put(K,V) as a member of the raw type java.util.HashMap
                            pendingUninits.put(new_rii_ID, new ArrayList(64));
                                              ^
                    RexxAndJava.java:711: warning: [unchecked] unchecked call to put(K,V) as a member of the raw type java.util.HashMap
                                    pendingUninits.put(rii_ID, new ArrayList(64));
                                                      ^
                    RexxAndJava.java:4070: warning: [unchecked] unchecked call to isAssignableFrom(java.lang.Class<?>) as a member of the raw type java.lang.Class
                                                                  bFound=(paramTypes[j].isAssignableFrom(funcArgs[j].getClass()));
                                                                                                        ^
                    RexxAndJava.java:5179: warning: [unchecked] unchecked call to add(E) as a member of the raw type java.util.ArrayList
                                                              al.add(args[1]);
                                                                    ^
                    RexxAndJava.java:5594: warning: [unchecked] unchecked call to put(K,V) as a member of the raw type java.util.Hashtable
                                           orxReferences.put(beanName, newRefCount); // remember refCount
                                                            ^
                    RexxAndJava.java:5911: warning: [unchecked] unchecked call to isAssignableFrom(java.lang.Class<?>) as a member of the raw type java.lang.Class
                                    if (!(paramTypes[k].isAssignableFrom (funcArgs[k].getClass()))) // not compatible, break
                                                                         ^
                    RexxAndJava.java:5957: warning: [unchecked] unchecked call to getConstructor(java.lang.Class<?>...) as a member of the raw type java.lang.Class
                                            Constructor constr=paramTypes[k].getConstructor( argClass );
                                                                                           ^
                    RexxAndJava.java:6167: warning: [unchecked] unchecked call to put(K,V) as a member of the raw type java.util.Hashtable
                                orxReferences.put(beanName, new Integer(refCount)); // remember refCount
                                                 ^
                    RexxAndJava.java:6173: warning: [unchecked] unchecked call to add(E) as a member of the raw type java.util.HashSet
                                        beansCreated.add(beanName);
                                                        ^
                    RexxAndJava.java:6236: warning: [unchecked] unchecked call to put(K,V) as a member of the raw type java.util.Hashtable
                                       orxReferences.put(beanName, new Integer(refCount));
                                                        ^
                    RexxAndJava.java:6597: warning: [unchecked] unchecked call to addElement(E) as a member of the raw type java.util.Vector
                                               eventTextVectorHigh.addElement(o);   // changed to addElement() for JRE 1.1.8, ---rgf
                                                                             ^
                    RexxAndJava.java:6601: warning: [unchecked] unchecked call to addElement(E) as a member of the raw type java.util.Vector
                                               eventTextVectorLow.addElement(o);    // changed to addElement() for JRE 1.1.8, ---rgf
                                                                            ^
                    RexxAndJava.java:6606: warning: [unchecked] unchecked call to addElement(E) as a member of the raw type java.util.Vector
                                               eventTextVector.addElement(o);       // changed to addElement() for JRE 1.1.8, ---rgf
                                                                         ^
                    RexxAndJava.java:6764: warning: [unchecked] unchecked call to <T>toArray(T[]) as a member of the raw type java.util.ArrayList
                                    entries=(String[]) al.toArray(entries);
                                                                 ^
                    14 warnings

- RexxCompiledScript.java

  - rebasing on Java 1.6/6.0; generics related warning cannot be circumvented
    (cf. comments in getInterface(Class<T> clasz) method)

- RexxConfiguration.java

  - rebasing on Java 1.6/6.0, fix generics related warnings:

                    RexxConfiguration.java:126: warning: [unchecked] unchecked call to add(E) as a member of the raw type java.util.ArrayList
                            load_required_library.add(libraryName);
                                                     ^
                    RexxConfiguration.java:195: warning: [unchecked] unchecked call to add(int,E) as a member of the raw type java.util.ArrayList
                                exitHandlers.add(i,null);
                                                ^
                    RexxConfiguration.java:402: warning: [unchecked] unchecked call to add(int,E) as a member of the raw type java.util.ArrayList
                            exitHandlers.add(function,exitHandler); // save exit handler wit
                                            ^
                    RexxConfiguration.java:428: warning: [unchecked] unchecked call to set(int,E) as a member of the raw type java.util.ArrayList
                                exitHandlers.set(function,exitHandler); // save exit handler wit
                                                ^
                    RexxConfiguration.java:478: warning: [unchecked] unchecked call to put(K,V) as a member of the raw type java.util.HashMap
                            commandHandlers.put(name,commandHandler); // save exit handler wit
                                               ^
                    RexxConfiguration.java:506: warning: [unchecked] unchecked call to put(K,V) as a member of the raw type java.util.HashMap
                                commandHandlers.put(name,commandHandler); // save exit handler with
                                                   ^


- RexxEngine.java

  - basing on Java 1.6/6.0, getting rid of "-Xlint:unchecked" warnings:

                    RexxEngine.java:517: warning: [unchecked] unchecked call to addElement(E) as a member of the raw type java.util.Vector
                                           beanVector.addElement(res[1]);        // remember beanName for later deregistering
                                                                ^
                    RexxEngine.java:662: warning: [unchecked] unchecked call to addElement(E) as a member of the raw type java.util.Vector
                                           beanVector.addElement(res[1]);       // remember beanName for later deregistering
                                                                ^
                    RexxEngine.java:842: warning: [unchecked] unchecked call to addElement(E) as a member of the raw type java.util.Vector
                                           beanVector.addElement(res[1]);       // remember beanName for later deregistering
                                                                ^
                    RexxEngine.java:1087: warning: [unchecked] unchecked call to addElement(E) as a member of the raw type java.util.Vector
                                              beanVector.addElement(res[1]);    // remember beanName for later deregistering

- RexxProxy.java

  - Use Janino instead of ASM for extending abstract classes (would need to add
    a default constructor in the case of an abstract class; however, Janino has
    been maintained nicely and has become fast enought to replace ASM, so
    contemplating of removing ASM for good eventually)

  - cast "null" to "(java.lang.Class<?>[]) null" in Object.class.getMethod(...) for
    "hashCode" and "toString" to get rid of the compiler warning

  - rebasing on Java 1.6/6.0, get rid of generics related warnings where possible:

                    source_java>javac -Xlint:unchecked RexxProxy.java
                    RexxProxy.java:118: warning: [unchecked] unchecked call to getDeclaredMethod(java.lang.String,java.lang.Class<?>...) asa member of the raw type java.lang.Class
                                    mCreateProxiedJavaClass=clzProxiedJavaClassTool.getDeclaredMethod(
                                                                                                     ^
                    RexxProxy.java:898: warning: [unchecked] unchecked call to add(E) as a member of the raw type java.util.ArrayList
                                        al.add(clz);        // add interface class object
                                              ^
                    RexxProxy.java:906: warning: [unchecked] unchecked call to add(E) as a member of the raw type java.util.ArrayList
                                            al.add(ifs[k]);         // add interface class object
                                                  ^
                    RexxProxy.java:1054: warning: [unchecked] unchecked call to add(E) as a member of the raw type java.util.ArrayList
                                    al.add( raj.convFromRexx((String) o));  // string a key into BSFRegistry; if so return Java object
                                          ^
                    RexxProxy.java:1059: warning: [unchecked] unchecked call to add(E) as a member of the raw type java.util.ArrayList
                                    al.add(o);
                                          ^
                    RexxProxy.java:1064: warning: [unchecked] unchecked call to set(int,E) as a member of the raw type java.util.ArrayList
                            al.set(0,clz);      // replace the very first element with the retrieved class object it stands for
                                  ^
                    RexxProxy.java:1178: warning: [unchecked] unchecked call to getMethod(java.lang.String,java.lang.Class<?>...) as a membe
                    r of the raw type java.lang.Class
                                    Method mSDH=extendedClz.getMethod("setDefaultHandler", new Class[]{org.rexxla.bsf.engines.rexx.RexxProxy.class});
                                                                     ^
                    RexxProxy.java:1262: warning: [unchecked] unchecked call to getMethod(java.lang.String,java.lang.Class<?>...) as a membe
                    r of the raw type java.lang.Class
                                Method mSetDH=extendedClz.getMethod("setDefaultHandler", new Class[]{org.rexxla.bsf.engines.rexx.RexxProxy.class});
                                                                   ^

-------------------------------------- 2016-11-03 ----------------------------------

- ProxiedJavaClassTool.java

  - if no methods given, but an abstract class, then proxy all abstract (public or protected) methods only


-------------------------------------- 2016-11-01 ----------------------------------

- ProxiedJavaClassTool.java

  - do not use the ClassLoader from the target's class (e.g. javafx.* classes in Java 1.8/8
    use their own class loaders which may confine them to see only javafx.*)


-------------------------------------- 2016-11-06 ----------------------------------

- BSF.CLS

  - if a BSF (Java) object gets a MAKEARRAY or SUPPLIER message sent to it which
   cannot be resolved, then RexxAndJava.java checks whether it is a collection type
   object (having one of the interfaces java.lang.Iterable, java.util.Collection,
   java.util.Enumeration, java.util.Iterator or java.util.Map implemented; or being
   a class object of type java.lang.Enum such that its values are regarded to be
   attributes and returned);

-------------------------------------- 2016-10-27 ----------------------------------

- BSF.CLS

  - public routine bsf.ScriptContext2rexx now uses .JSR223~ScriptContext2RexxDir(...)

-------------------------------------- 2016-10-26 ----------------------------------

- BSF.CLS

  - JSR223-support:

    - bsf.ScriptContext2rexx():

      - allow .context argument instead of ScriptContext to ease using this routine

      - make sure that the names (keys of SimpleBindings) are mapped to valid Rexx symbol names for
        using BSFContextVariables(...)

    - new public utility class "JSR223" for easying interfacing with "javax.script" invocations

      - defines constants "ENGINE_SCOPE", "GLOBAL_SCOPE"

      - defines class methods getBindings(), normalizedName(), ScriptContext2RexxDir();
        getAttribute(), getAttributes(), setAttribute()

- RexxCompiledScript.java

  - added a few additional debug statements (debugging instrumentation by JavaFX),
    in addition also conditionally allowing to display the Rexx source


- RexxScriptEngine.java

  - adjust to observed usage by JavaFX

    - added protected field "latestRexxPackage": stores latest created Rexx package
      (from last compile()) to be added to the package of the next to be compiled
      Rexx script

    - added protected field "bAddLatestPackageDynamically" and public
      methods setAddLatestPackageDynamically() and getAddLatestPackageDynamically():
      if set to true will add dynamically the last package to a new compiled Rexx
      script thereby allowing later Rexx scripts to access any public routines and
      public classes of any prior compiled Rexx scripts (includes access to package
      BSF.CLS)

    - change: public static field "bPrependDynamicRequiresStatement" (to inject a dynamic
      requires to package 'BSF.CLS') now honored only, if field "bAddLatestPackageDynamically"
      is false

    - changed method updateRexxEngine(): the very first time 'BSF.CLS' is dynamically
      required, the package of that Rexx code is stored in the protected field
      "latestRexxPackage", such that it can be added to new compiled Rexx scripts


====================================================================================
-------------------------------------- 2016-08-15 ----------------------------------

- information/installation

  - added Eva Gerger's and Julian Reindorf's installation documentation, which
    nicely explains 32-bit and 64-bit installation combinations of ooRexx and
    Java for Linux, Windows and MacOSX

- BSF.CLS

  - BSF.Dialog class: when fetching constants (static fields) use the
    imported javax.swing.JOptionsPane class

-------------------------------------- 2016-08-14 ----------------------------------

- recreated and added javadoc for the datergf package (org.oorexx.datergf) to the
  information folder

- added .NET/CLR (Common Language Runtime) package, which will be installed on
  Windows (thanks to Manuel Raffel, Adrian Baginski; and the jni4net package)

  - created "gacutilrgf.exe" to have an Apache licensed utiltity to add
    DLL-assemblies to the Windows GAC (global assembly cache) which is
    needed for the installation

- changed names of nutshell examples in the "samples/" directory (thanks to
  Eva Gerger, Julian Reindorf)

- recompiled BSF4ooRexx.cc on the Linux and Windows platforms to make sure that
  the latest version gets used in the distribution

- RexxAndJava.java:

        - added new entries in the kudos section
        - updated version date

-------------------------------------- 2016-04-17 ----------------------------------

- source_cc\Makefile.s390x

        - adapted Makefile to create 64-Bit s390x (Linux on z) libBSF4ooRexx-s390x.so
          by Paul Dunkley


-------------------------------------- 2016-03-28 ----------------------------------

- BSF4ooRexx.cc

        - Jean-Louis Faucher: "Fix bug 28 overflow under Ubuntu 14.04";
          cf. bug 28: <https://sourceforge.net/p/bsf4oorexx/bugs/28/>


-------------------------------------- 2015-08-24 ----------------------------------

- install\windows

        - change installation scripts "elevate.rex" and "uninstall.cmd" to allow
          removal of "BSF4ooRexx" directory

-------------------------------------- 2015-08-14 ----------------------------------
- install\windows\elevate.rex

        - now allows an optional trailing time in the "-w[ait][seconds2wait]" flag

        - makes sure that deleting the file serving as a semaphore for the waiting
          tickers even in the case that any of the previous commands failed (rc<>0)

-------------------------------------- 2015-08-14 ----------------------------------

- install\windows\elevate.rex

        - new Rexx script to employ elevation for all versions of Windows, kudos
          to Gil Barmwater

- install\windows\kickoff.rex

        - replacing dependency on an external package by 'elevate.rex'

- testUnits\

        - in general updated all test units to the 4.2.0 ooTest framework

          - files in ooRexxUnit\

                - OOREXXUNIT.CLS changed

                  - add logic to correctly identify a failure if carried out in
                    a separate Rexx interpreter instance via BSF4ooRexx

                  - added UNGUARDED to STRING and GETNAME methods to allow using
                    the string method concurrently in another activity (eg in another
                    Rexx interpreter instance)

- RexxAndJava.java

  - updated kudos-entries


-------------------------------------- 2015-08-11 ----------------------------------

- BSF4ooRexx.cc

        - javaObjectBean and javaMethodObjectBean will get deregistered in
          RexxAndJava.call(), hence increase refcounter in bsf.wrap, as the uninit-method
          of the BSF Rexx proxy will decrease it

- BSF.CLS

        - BSF.WRAP: also honor argument "increase reference counter" for Java array
          objects (was overlooked!)


-------------------------------------- 2015-08-04 ----------------------------------

- BSF.CLS

        - adjust for storing RII_ID in BSF instance to be able to indicate RII_ID to
          unregisterBean from when uninit runs (important, as BSF registry is always
          RII dependent)

- RexxScriptEngine.java

        - adjust to info that starting with ooRexx 5.0.0 the string argument to
          .routine~new must not contain CR/LF chars; prepare all Rexx ocde herein to
          allow replacing CR-LF with semi-colons by changing line comments to block
          comments; make sure that the Rexx code that creates .routine objects
          carries out a makearray for the code-part (allowing CR-LF as stored on
          file or in databases, but also giving much more meaningful line-based error
          information; Rexx, after all is meant to be an easy to use and to debug
          language!)

- Java4Rexx.java

        - split logic to allow Java4Rexx to sucessfully set the Rexx interpreter ids
          (rii_IDs) in RexxEngine and its companion RexxAndJava instance


-------------------------------------- 2015-08-03 ----------------------------------

- RexxAndJava.java

     - change code to only deregister bean, if running in the context of the same RII
       in which registering took place!

       - defining a class field "pendingUninits": a
         HashMap<String,HashSet> (RII_ID,Vector of beanNames to unregister)

       - case "UNREGISTER_BEAN" adopted accordingly

       - terminate: make sure all registered beans get deregistered (BSFManager may
                    initiate a new Rexx interpreter instance which should be able to
                    access any other registered Java object)


-------------------------------------- 2015-08-01 ----------------------------------

- RexxAndJava.java

        - change error message "method not found or error (exception) executing
          method!" to unambiguous message: "(exception) executing method!" to ease
          debugging for Rexx programmers

        - add subfunction "get_RII_ID", which returns the "Rexx interpreter instance
          ID" (a string)

-------------------------------------- 2015-07-21 ----------------------------------

- BSF4ooRexx.cc

        - RgfProcessJArgs(): now expects a new (trailing) argument that determines, whether
          Java object references in the BSF registry should be increased when wrapped as a
          BSF reference object;

- BSF.CLS

        - bsf.wrap: honor new argument "bIncr", if set to .true, then the reference counter
          in the BSF registry is increased (needed, if Java object is an argument
          to RexxEngine.call() [native code: ...jniRexxRunProgram(),
          ...jniRexxSendMessageToRexxObject(), both will supply .true as a new second arg]

        - methods and routines "*ArrayOf": changed to automatically create RexxProxy objects
          for Rexx objects that are neither .String, .BSF nor .nil


- RexxScriptEngine.java

        - no need to do a BsfCreateRexxProxy(), this will now be done by bsf.createArrayOf()
          (in BSF.CLS)



-------------------------------------- 2015-07-20 ----------------------------------

- BSF4ooRexx.cc

        - BsfRexxProxy(): give more detailed condition information to ease debugging


-------------------------------------- 2015-07-07 ----------------------------------

- testUnits\bsf4rexx\rgf\G_misc\07_rexx_JSR_223.testGroup

        - new: test the JSR-223 (javax.script) implementation for ooRexx

- testUnits\bsf4rexx\rgf\G_misc\o7_Test_JSR223.java

        - new: companion for 07_rexx_JSR_223.testGroup (starts with a little 'o',
          because older versions of Java do not accept a literal (number) as the first
          character of a Java class name);

        - allows testing the Invocable JSR-223 functionality (implementing a Java
          interface with routines and with methods)

-------------------------------------- 2015-07-05 ----------------------------------

- testUnits\bsf4rexx\rgf\G_misc\06_rexx_BSF_Redirect_To.testGroup

        - new: test BSF.CLS' routine BSF.RedirectTo

-------------------------------------- 2015-06-29 ----------------------------------

- testUnits\bsf4rexx\rgf\G_misc

- testUnits\bsf4rexx\rgf\G_misc\03_rexx_testInvokeJSO.testGroup

        - new: test BSF4ooRexx functions and methods that return a reference to a Java
          String object ("JSO") instead of transparently turning them into a Rexx string

- testUnits\bsf4rexx\rgf\G_misc\o3_Test_JSO.java

        - new: companion for 03_rexx_testInvokeJSO.testGroup (starts with a little 'o',
          because older versions of Java do not accept a literal (number) as the first
          character of a Java class name

- testUnits\bsf4rexx\rgf\G_misc\04_rexx_BsfContextVariables.testGroup

        - new: test BSF4ooRexx new external BsfContextVariablesõ() function

- testUnits\bsf4rexx\rgf\G_misc\05_rexx_BSF_Input_Output_Stream.testGroup

        - new: test BSF.CLS public classes "BSF.InputStream" and "BSF.OutputStream"


-------------------------------------- 2015-06-27 ----------------------------------

- RexxExtendClass.java

        - adjust behaviour to match documentation when array of method names is given:
          in this case also all concrete methods of that name should be proxied


- testUnits\bsf4rexx\rgf\D_abstractClasses\03_rexx_testAbstractCallback.testGroup

        - adapted the test to what is deocumented for supplying an array of
          method names to be proxied

- testUnits\bsf4rexx\rgf\E_extendNormalClasses\03_rexx_testExtendNormalCallbacck.testGroup

        - changed to adapt to new semantics when creating an extended class (array
          of method names must not be null now, but have a capacity of 0 instead)

-------------------------------------- 2015-06-26 ----------------------------------

- testUnits\bsf4rexx\rgf\F_multiThreading\80_test_MultiThreading_via_Java_threads.testGroup

        - adjust code for new (more versatile) support for BSFRexxProxy(), where supplying
          Rexx objects to Java will be automagically wrapped as BSFRexxProxy() and getting
          a BSFRexxProxy() from Java will automagically be unwrapped

        - added class RGF_WORKER to serve as a proxy for the assertable instance of the
          test method; otherwise leads to deadlocks if that object gets messages sent from
          different threads

- testUnits\bsf4rexx\rgf\F_multiThreading\90_test_Multithreading_via_Java_threads.rex

        - adjust code to new BsfRexxProxy() behaviour: if Java supplies a BSFRexxProxy() object
          BSF4ooRexx automatically unwraps it and submits it as an argument

-------------------------------------- 2015-06-08 ----------------------------------

- BSF4ooRexx.cc

        - report new external Rexx function BsfContextVariables() with BsfQueryRegisteredFunctions()

- new samples for demonstrating the JSR-223 support in "samples/Java/jsr223", files:

        - nutshell_04c.rex      ... uses Java objects directly via arguments (easiest
                                    for Rexx programmers)

- new samples for demonstrating the JSR-223 support in "samples/NetRexx/jsr223", files:

        - nutshell_04_eval.nrx  ... defines values to work whith in ScriptContext

        - nutshell_04a.rex      ... fetches entries from ScriptContext individually

        - nutshell_04b.rex      ... creates Rexx context variables from ScriptContext at once

        - nutshell_04c.rex      ... uses Java objects directly via arguments (easiest
                                    for Rexx programmers)

-------------------------------------- 2015-06-07 ----------------------------------

- BSF4ooRexx.cc

        - adding new external Rexx function "BSFContextVariables()" to allow getting,
          setting and dropping the variables in the context of the caller

- BSF.CLS

        - added public routine BSF.ScriptContext2Rexx(ScriptContext[,scopes]) which
          returns a Rexx directory that contains all ScriptContext values of the
          given scopes; meant to be used in conjunction with the new external Rexx
          function BSFContextVariables()

- new samples for demonstrating the JSR-223 support in "samples/Java/jsr223", files:

        - Nutshell_04_Eval.java ... defines values to work whith in ScriptContext

        - nutshell_04a.rex      ... fetches entries from ScriptContext individually

        - nutshell_04b.rex      ... creates Rexx context variables from ScriptContext at once

-------------------------------------- 2015-05-22 ----------------------------------

- utility for demonstrating the JSR-223 support in "samples/NetRexx/jsr223", files:

        - nrxRunScript.nrx ... a command line Java utility to query, test and evaluate javax.script
                               scripting engines and run any script in any installed script engine

         - nutshell_02_invoke.nrx

         - nutshell_02.rex

         - nutshell_03_interface.nrx

         - nutshell_03.rex

         - nutshell_04_eval.nrx

         - nutshell_04a.rex

         - nutshell_04b.rex

         - nutshell_04c.rex

-------------------------------------- 2015-05-22 ----------------------------------

- new samples for demonstrating the JSR-223 support in "samples/NetRexx/jsr223", files:

         - nutshell_01_eval.nrx

         - nutshell_01.rex

-------------------------------------- 2015-05-20 ----------------------------------

- utility for demonstrating the JSR-223 support in "samples/Java/jsr223", files:

        - RunScript.java ... a command line Java utility to query, test and evaluate javax.script
                               scripting engines and run any script in any installed script engine


-------------------------------------- 2015-05-12 ----------------------------------

- major addition: full implementation of JSR-223 (javax.script) support, package
  "org.rexxla.bsf.engines.rexx.jsr223", files:

        - RexxScriptEngineFactory.java

        - RexxScriptEngine.java

        - RexxCompiledScript.java

- new samples for demonstrating the JSR-223 support in "samples/Java/jsr223", files:

        - Nutshell_01_Eval.java

        - nutshell_01.rex

        - Nutshell_02_Invoke.java

        - nutshell_02.rex

        - Nutshell_03_Interface.java

        - nutshell_03.rex

- added "META_INF/services/javax.script.ScriptEngineFactory" to point to the ooRexx
  JSR-223 script engine factory

-------------------------------------- 2015-05-09 ----------------------------------

- BSF4ooRexx.cc, added JNI methods for RexxEngine.java

        - _RexxAndJava_jniGetGlobalEnvironment0 ... return .environment

        - _RexxAndJava_jniGetLocalEnvironment0  ... return .local

        - _RexxAndJava_jniNil0                  ... return .nil

        - _RexxAndJava_jniInterpreterVersion0   ... return  long, least signifant
                                                    three bytes encode this information

        - _RexxAndJava_jniLanguageVersion0      ... return  long, least signifant two
                                                    bytes encode this information

- RexxAndJava.java, added access to important Rexx objects and interpreter related information

        - protected native Object jniGetLocalEnvironment0

        - protected native Object jniGetGlobalEnvironment0

        - protected native Object jniNil0

        - protected native long   jniInterpreterVersion0

        - protected native long   jniLanguageLevel0

- RexxEngine.java, added public methods

        - getLocalEnvironment()   ... returns .local

        - getPublicEnvironment()  ... returns .environment

        - getNil()                ... returns .nil

        - getInterpreterVersion() ... returns long, where the least significant three bytes contain the version encoded

        - getLanguageVersion()    ... returns long, where the least significant two bytes contain the version encoded

-------------------------------------- 2015-05-10 ----------------------------------

- BSF.CLS

        - changed BSF_ARRAY_REFERENCE's MAKEARRAY and AT method such that RexxProxy
          entries in the Java array get replaced by their contained Rexx object

-------------------------------------- 2015-05-04 ----------------------------------

- BSF.CLS

        - corrected minimum ooRexx version to 4.1.0 (determined by BSF4ooRexx.cc)

-------------------------------------- 2015-05-02 ----------------------------------

- BSF.CLS

        - make sure in bsf.OutputStream that flush() is used to force the buffered
          chars to be displayed for Writers and PrintStreams


-------------------------------------- 2014-12-12 ----------------------------------

- install\windows\kickoff.rex
        - use fully qualified path to "install" directory as some versions of
          Windows will change the current directory after elevation

-------------------------------------- 2014-10-07 ----------------------------------

- BSF.CLS
        - JSOasUtf8string: render Java String as UTF-8 encoded Rexx string
        - utf8stringAsJSO: render UTF-8 Rexx encoded string as Java String

- utilities\ooRexxTry.rxj
        - bug fixed version by Geri Leitner

-------------------------------------- 2014-10-06 ----------------------------------

- BSF.CLS
        - utf8toString - render UTF-8 handle Java objects

- samples\demoJSO.rxj (return reference to java.lang.String or to NetRexx object)
        - demonstrate how to retrieve a reference to the Java string object ("JSO") that method
          invocations and read access to fields and properties might return, rather than
          having the default and transparent translation to a Rexx string
        - demonstrate how to handle different encodings of strings between Rexx and Java taking
          advantage of the JSO-functionality
        - demonstrate platform independent beeping ;)

- samples\info2html.rxj (new)
        - render ooRexx, BSF4ooRexx and Java infos as HTML, open file in browser

-------------------------------------- 2014-10-05 ----------------------------------

- BSF.CLS
        - removed the classes .bsf4rexx and .b4r that got introduced for pre-ooRexx 4.0
          interpreters that did share .local among different ooRexx interpreter instances;
          BSF4ooRexx mandates at least ooRexx 4.01 which manages a .local copy per
          ooRexx interpreter instance; therefore changing the logic back to store a
          directory named "BSF4Rexx" in .local and adding aliases for it to the .local
          environment named "B4R" and (new) "BSF4ooRexx"

-------------------------------------- 2014-10-04 ----------------------------------

- RexxAndJava.java

        - added the subfunctions
          - invokeJSO
          - invokeStrictJSO
          - getFieldValueJSO
          - getFieldValueStrictJSO
          - getStaticValueJSO
          - getStaticStrictValueJSO
          - getPropertyValueJSO

- BSF.CLS
        - added methods to existing BSF-methods, adding a trailing "JSO" (Java
          string object) to them, that will return a reference to a
          java.lang.String or Netrexx object instead of transparently turning
          it into a Rexx string; this may be helpful, if wishing to invoke
          the Java String methods on that (returned) Java string object.

          These are the added methods:

          - bsf.invokeJSO
          - bsf.invokeStrictJSO
          - bsf.getFieldValueJSO
          - bsf.getFieldValueStrictJSO
          - bsf.getStaticValueJSO
          - bsf.getStaticStrictValueJSO
          - bsf.getPropertyValueJSO

          These are the added routines:

          - bsf.getStaticValueJSO
          - bsf.getStaticStrictValueJSO
          - bsf.getConstantJSO

-------------------------------------- 2014-10-02 ----------------------------------

- RexxAndJava.java


-------------------------------------- 2014-09-21 ----------------------------------

- samples/info2thml.rxj (new)

        - new sample that demonstrates how to gather version information from ooRexx,
          BSF4ooRexx and Java and rendering and saving that information in a HTML file


-------------------------------------- 2014-09-15 ----------------------------------

- samples/ReneJansen/jdbc.jrexx

        - added DataSource access to RDBMS, which works also, when BSF4ooRexx
          is installed in java.ext.dirs directory, which would not work with
          the DriverManager variant in Java 1.7/7


-------------------------------------- 2014-09-09 ----------------------------------

- samples/clock.rxj
        - create a graphical clock that shows the current time
        - demonstrates how to extend a Java class to allow ooRexx to overwrite specific
          Java methods, in this example the Java method "javax.swing.JComponent paintComponent"


-------------------------------------- 2014-08-30 ----------------------------------

- org.rexxla.bsf.engines.rexx.RexxExtendClass.java (asm)

        - a subclass may invoke protected methods, cater for this

- org.rexxla.bsf.engines.rexx.ProxiedJavaClassTool.java (janino)

        - a subclass may invoke protected methods, cater for this


-------------------------------------- 2014-07-16 ----------------------------------

- samples\EuroCalcJava.rxj
        - added Lithuania Litas

-------------------------------------- 2014-07-16 ----------------------------------

- BSF.CLS

        - routine bsf.redirectTo(): default .debugInput to .input~current and
          .traceOutput to .error~current

-------------------------------------- 2014-07-15 ----------------------------------

- BSF.CLS

        - added code to BSF.InputStream to also work on java.io.Reader in addition to
          java.io.InputStream (e.g. java.lang.System.in)

        - renamed BSF.PrintStream to BSF.OutputStream, added code to also work on
          java.io.Writer in addition to java.io.PrintStream (e.g. java.lang.System.{out|err})

-------------------------------------- 2014-07-06 ----------------------------------

- BSF.CLS

        - added public routine BSF.redirectTo (allows to redirect the ooRexx standard
          monitors to Java's standard System streams and reset them to the standard
          ooRexx standard streams)

        - added public class BSF.InputStream (allows ooRexx to treat Java InputStream
          objects as Rexx input streams)

        - added public class BSF.PrintStream (allows ooRexx to treat Java PrintStream
          objects - specialisation of OutputStream - as Rexx output streams)



-------------------------------------- 2014-07-04 ----------------------------------

- new samples

        - samples/Java/JavaRunRexx_05.java
          samples/NetRexx/nrxRunRexx_05.nrx

                - Demonstrate how to setup a .host directory in Rexx from Java, which then
                  receives Java objects for use in Rexx programs; in addition a value is
                  saved in .host by Rexx under the index REXX.HEY that upon return is
                  fetched from Java.

        - samples/Java/JavaRunRexx_06.java
          samples/NetRexx/nrxRunRexx_06.nrx


                - Demonstrate how to use the context of a Rexx routine for another Rexx
                  routine.  The first routine requires BSF.CLS which adds public routines
                  and public classes which then are made available to Rexx routines that get
                  created and executed later via Java.  Then another Rexx routines gets
                  defined to use the first package, and in addition defines a public routine
                  named test.  Finally, the last Rexx routine demonstrates getting access to
                  the package of the second routine which makes its public routine named
                  test accessible.  In addition the last routine is called twice, once
                  without Java supplied arguments, once with Java supplied arguments.


-------------------------------------- 2014-07-03 ----------------------------------

- RexxEngine.java

        - make sure that RexxProxy objects are always passed as Java objects in arguments;
          adapt apply() as well to pass through RexxProxy objects in arguments


-------------------------------------- 2014-05-21 ----------------------------------

- BSFException.java

        - add getCause() method as synonym for getTargetException(), which makes it
          orthogonal with Throwable's getCause() that got introduced since defining
          BSFException

-------------------------------------- 2014-05-17 ----------------------------------

- BSF4ooRexx.cc

    - simplified attaching/detaching to the JVM, a side effect will be a slight performance
      improvement (appr. 5%)


- BSF.CLS

    - adjust public routine BSF.terminateRexxEngine() to new behaviour (will return .true,
      if termination was carried out already, such that message isTerminated cannot be
      carried out anymore, causing a Rexx condition)

-------------------------------------- 2014-05-15 ----------------------------------

- BSF4ooRexx.cc

        - do not report deprecated BSFAttachToTID() and BSFDetach() anymore

- BSF.CLS

        - moved MacOSX initialization code to public routine "makeBSF4ooRexxLookLikeMacOSX":
          ooRexx macros in AOO 4.x on MacOSX do not run, as this setup code uses
          an awt class which must nor run on the main thread on MacOSX. As a result
          ooRexx macros on AOO 4.x cause a runtime exception and do not run. Moving
          the initialization into a routine that needs to be explicitly called
          should solve the problem.

- ooRexxTry.rxj

        - make sure that on MacOSX the application looks like a Mac application by calling
          first the new BSF.CLS routine "makeBSF4ooRexxLookLikeMacOSX"

- RexxAndJava.java

        - correct new method lookup for INVOKE (did not find fields, nor was coercing
          the arguments rather used the INVOKE_STRICT logic)

-------------------------------------- 2014-05-14 ----------------------------------

- RexxAndJava.java

        - change method lookup for INVOKE to use Class.getMethods() instead of Class.getDeclaredMethods();
          getMethods() returns all public methods, which in Java 8 also includes default (interface) methods,
          if necessary

-------------------------------------- 2014-05-14 ----------------------------------

- samples/demo-j8-lambda.rxj (new)

        - demonstrate how to use ooRexx code to be used in Java 8's lambda-related
          functional programming patterns



-------------------------------------- 2014-04-03 ----------------------------------

- BSF4ooRexx.cc

        - make sure that BSFDetach() does not detach from the primodal thread

-------------------------------------- 2014-04-02 ----------------------------------

- RexxAndJava.java

        - move initialization of JNI library to RexxAndJava constructor to make
          sure that non-Rexx JNI functions are available to Java (like jniProcEnvironment())

- ScriptProviderForooRexx.java

        - add code in getBSFManager() to cater for a stupid error in MacOSX AOO 4.0.x and 4.1.
          (process environment not set, so PATH missing, such that ooRexx cannot be
          initialized at all)


-------------------------------------- 2014-03-31 ----------------------------------

- BSF4ooRexx.cc

        - rewrite all "const char*" types with "char*" types as the latest Clang
          on MacOSX creates bus errors, if forcing "char*" on "const char*" (which is fine);
          replacing:
              char bla[nnn]="";
          with
                 char *bla=new char[nnn];
              and
                 delete [] bla;

-------------------------------------- 2014-03-30 ----------------------------------

- BSF4ooRexx.cc

        - major addition, hence augmenting version to 4.5

        - save primodal TID as BSF.PRIMODALTID for each Rexx interpreter instance;
          this allows to do a BSFAttachToTID() without supplying a TID, added code
          to BSFLoadJava(...), jniCreateRexxInterpreterInstance(...)

        - now possible to do an "auto-attach" to the Java interface taking advantage
          of this new information, implemented for the RexxRoutines (sending messages
          from Java to Rexx will always occur on an established Java connection):

          - BSFAttachTo(): argument now optional, in order to remain backwardly
                 compatible, if a programmer uses this routine for an already
                 attached ooRexx thread, the same condition will be raised such
                 that Rexx code expecting this behaviour keeps on working as designed

          - BSFCreateRexxProxy()
          - BSFJavaException()
          - BSFRawBytes()
          - BSF()

- RexxEngine.java

          - add undocumented pass-thru method procEnvironment(...) to allow a last resort means
            (allow Java to set/get process environment variables via JNI using RexxAndJava)

-------------------------------------- 2014-03-29 ----------------------------------

- BSF4ooRexx.cc

        - add jniProcEnvironment(...): this allows to get, set and unset the
          process environment from Java; reason: AOO 4.x removes the PATH environment
          variable (seems to be unintended, hence an error), which inhibits the
          Rexx interpreter to initialize successfully; this jni function is intended
          to allow as a last resort to set the missing PATH environment variable;
          the subfunctions "getEnv" and "setEnv" will not be explicitly documented


- RexxAndJava.java

        - add jniProcEnvironment(...): this allows to get, set and unset the
          process environment from Java; reason: AOO 4.x removes the PATH environment
          variable (seems to be unintended, hence an error), which inhibits the
          Rexx interpreter to initialize successfully; this jni function is intended
          to allow as a last resort to set the missing PATH environment variable;
          the subfunctions "getEnv" and "setEnv" will not be explicitly documented

-------------------------------------- 2013-10-07 ----------------------------------

- BSF4ooRexx.cc

        - removing DeleteLocalReference(...) from:

          - Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniRexxRunProgram(...)
          - Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniRexxSendMessageToRexxObject(...)

          otherwise rtc->DetachThread() may cause an exception in native code,
          if a Rexx exception occurs (reason for bug19 <http://sourceforge.net/p/bsf4oorexx/bugs/19/>);
          as DetachThread() will remove local references anyway, there is no possible memory leak

-------------------------------------- 2013-07-14 ----------------------------------

- setupBSF.rex

        - Make output more verbose, such that logfile reflects environment at installation time
          (displays values for cmd.eSetBSF4REXX_HOME, cmd.eSetPath and cmd.eSetCP), will
          allow to analyze Java at hand

- setupOOo.rex

        - Make output more verbose, such that logfile reflects what was found about OOo/LO
          (displays values for cmd.eSetPath and cmd.eSetCP)

-------------------------------------- 2013-07-08 ----------------------------------

- setupAllAndRun.rex

        - add logfile ability, add appropriate logfile output statements
        - increase ooRexx minimum version to 4.1.0 as BSF4ooRexx.cc mandates it
        - add logfile statements, make sure logfile gets closed after each log message,
          such that redirecting commands to it works as well
        - log environment

-------------------------------------- 2013-06-29 ----------------------------------

- BSF4ooRexx.cc

        - applying ReleaseLocalReference() wherever a Rexx thread context may have returned
          a RexxObjectPtr for which the thread context creates a local reference to protect
          it to be garbage collected; a ReleaseLocalReference() therefore has to be issued to
          inhibit memory leaks

        - removed compiler warnings

- BSFManager.java

        - if terminating engines, make sure to remove engine as PropertyChange listener to
          inhibit memory leaks

- RexxEngine.java

        - get isTerminated() back into the code; was mistakingly deleted between rev 137 and 148

-------------------------------------- 2013-06-27 ----------------------------------

- BSF4ooRexx.cc

        - slight tidying up (removed an obsolete function)

-------------------------------------- 2013-06-25 ----------------------------------

- RexxAndJava.java

        - add a terminate() method which nullifies the peer BSFManager and RexxEngine
          object to allow a terminated BSFManager RexxEngine to be garbage collected

-------------------------------------- 2013-06-24 ----------------------------------

- RexxEngine.java

        - terminate() now invokes the new RexxAndJava.terminate() in order to allow it
          to release references to BSFManager and RexxEngine, afterwards releasing
          the reference to its RexxAndJava peer;
          experimental: if trying to terminate the primodal Rexx interpreter instance a
          warning will get issued on System.err that informs the reader, that Java cannot
          use the primodal Rexx interpreter instance anymore; in effect the primodal
          Rexx interpreter instance does never get terminated, such that the native code
          has it always available for its own purposes

        - added bJNITerminated which is set to true, if a Rexx interpreter instance
          got terminated via JNI; bTerminated logically terminates the usage of a
          RexxEngine (usually changed by the peer RexxAndJava object's "exit" subfunction

-------------------------------------- 2013-06-10 ----------------------------------

- BSF4ooRexx.cc

        - changed logic in Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniRexxTerminateInterpreterInstance
          to really terminate Rexx interpreter instances (RII) with the exception of the
          primodal RII, which needs to stay alive due to using it for maintaining RexxProxy
          objects with Rexx collection objects in native code

- RexxEngine.java

        - added public getter method isTerminated()

        - added "synchronized" keyword to terminate();
          note: the primodal Rexx interpreter instance is never terminated, use isTerminated()
          to check for that after terminating a Rexx engine

- BSF.CLS

        - make BSF.terminateRexxEngine() return .true, if RexxEngine got terminated, .false else

-------------------------------------- 2013-01-07 ----------------------------------

- RexxDispatcher.java

        - somehow a local copy of this file was wrong, introducing an error, reordering
          Rexx termination sequences

-------------------------------------- 2013-01-06 ----------------------------------

- samples\quiz1.rxj, samples\quiz2.rxj, samples\quiz3.rxj, samples\uscaps.txt

        - new examples to demonstrate various GUI features available with Java
          by creating a US capital quiz application with ooRexx

-------------------------------------- 2013-01-04 ----------------------------------

- RexxAndJava.java

        - fix bug "Bug in Class Method resolution for interface class objects ",
          using alternative code to fix bug, cf.
          https://sourceforge.net/tracker/?func=detail&aid=3599351&group_id=400586&atid=1660873

-------------------------------------- 2013-01-03 ----------------------------------

- RexxAndJava.java

        - fix bug "Bug in Class Method resolution for interface class objects ", cf.
          https://sourceforge.net/tracker/?func=detail&aid=3599351&group_id=400586&atid=1660873

-------------------------------------- 2013-01-03 ----------------------------------

- RexxExtendClass.java

        - fix bug "BsfCreateRexxProxy with abstract class missing abstract meth", cf.
          https://sourceforge.net/tracker/?func=detail&aid=3599340&group_id=400586&atid=1660873

                - fixed a bug when extending an abstract class that possesses unimplemented
                  interface methods like javax.swing.AbstractAction; the fix now correctly
                  implements any declared abstract methods from interfaces (including any
                  of its super interfaces) that are not implemented in the abstract class

                - fixed wrong setting that caused concrete methods to be created, although
                  the documentation explained that only abstract methods get created

-------------------------------------- 2012-12-30 ----------------------------------
- BSF4ooRexx.cc

        - serializing initializations of JVM-dependent structures to fix reported bug
          <https://sourceforge.net/tracker/?func=detail&atid=1660873&aid=3591015&group_id=400586>

-------------------------------------- 2012-11-17 ----------------------------------

- samples\demo.BSF.dialog.rxj

        - new sample to demonstrate the easy to use cross-platform .bsf.dialog class
          for creating and using dialog windows; it seems no one is aware of this
          helpful utility class

-------------------------------------- 2012-11-02 ----------------------------------

- utilities\ooRexxTry.rxj
        - fix bug "ooRexxTry in Mac OS X, filehandling", cf.
          https://sourceforge.net/tracker/index.php?func=detail&aid=3582365&group_id=400586&atid=1660873

-------------------------------------- 2012-11-01 ----------------------------------

- RexxAndJava.java

        - fix bug "BSF4ooRexx returns wrong values", cf.
          https://sourceforge.net/tracker/?func=detail&aid=3581957&group_id=400586&atid=1660873

-------------------------------------- 2012-06-09 ----------------------------------

- BSF.CLS

        - added public routine BSF.terminateRexxEngine(): this allows a Rexx program
          to stop callbacks from Java to Rexx; it also will inhibit the Java side
          to use this Rexx interpreter instance to execute new Rexx programs

-------------------------------------- 2012-06-05 ----------------------------------

- BSF.CLS

        - fix memory leak: added uninit method to BSF_ARRAY_REFERENCE class to remove
          the
array proxy for indexing from the BSF registry, if not needed
          anymore (i.e. when uninit runs)

-------------------------------------- 2012-06-07 ----------------------------------

- BSF4ooRexx.cc

        - changed logic in RgfAddRexxProxy() such that if the package object is NULL to
          not add it to the directory (it won't be removable in ooRexx 4.1.1)

-------------------------------------- 2012-06-06 ----------------------------------

- BSF4ooRexx.cc

        - added an external Rexx function named BsfGetRegistryObjects() for debugging
          purposes only; to compile the flag CONFIG_MAKE_OREXX_REGISTRY_ACCESSIBLE must
          be defined

-------------------------------------- 2012-05-26 ----------------------------------

- BSF4ooRexx.cc

        - fixed errors because of wrongly placed DeleteLocalRef() (and in one instance
          a GlobalRef'd Java object became illegal due to excercising DeleteLocalRef()
          on it

-------------------------------------- 2012-05-24 ----------------------------------

- BSF4ooRexx.cc

        - changed "JNU_GetStringNativeCharsReturningRexxObjectPtr" to
                  "JNU_GetStringNativeCharsReturningRexxStringObject"

        - memory leak: fixed OOM (out of memory) error reported by Erik Dujis by explicitly
          invoking DeleteLocalRef() on any jobject; bug report:
          <https://sourceforge.net/tracker/?func=detail&atid=1660873&aid=3525814&group_id=400586>

        - tidying up a little bit by deleting some outdated commented code

-------------------------------------- 2012-04-19 ----------------------------------

- BSF4ooRexx.cc

        - fixed a bug in free()ing options array in BsfLoadJava()-routine, reported
          by JLF, cf. <https://sourceforge.net/mailarchive/forum.php?thread_name=4F900B1A.8000104%40wu-wien.ac.at&forum_name=bsf4oorexx-devel>

-------------------------------------- 2012-03-12 ----------------------------------
- RexxAndJava.java

        - now first trying to load 'netrexx.lang.Rexx' and then loading BSF4ooRexx DLL/so
          such that the native library can access the static field "nlR_class" and fetch
          the netrexx.lang.Rexx class object, if it was found

        - change scope of "bsfPrefixReturnValue" from static to instance, such that
          the Rexx interpreter instances can run with different settings in parallel

- BSF4ooRexx.cc

        - added support for 'netrexx.lang.Rexx' class for return values from handlers
          (if NetRexx Rexx' value, return its string value to Rexx)

-------------------------------------- 2012-02-25 ----------------------------------

- new beta version, major new features

        - allow to configure a Rexx interpreter instance (RexxConfiguration), before
          creating it; cf. the ooRexx programming guide documentation in "rexxpg.pdf"

        - allow to configure and implement Rexx command handlers in Java

        - allow to configure and implement Rexx exit handlers in Java

        - fixed: issue # 3434228, "GUI Rexxtry - install with working directory ~"

        - fixed: issue # 3434226, "rpm is case sensitive - misses ooRexx installation"

- install/setupBSF.rex

        - Unix: changed logic to determine which target lib to copy libBSF4ooRexx.so to
                (using location of "librexx.so")

-------------------------------------- 2012-06-09 ----------------------------------

- Java4Rexx.java

        - need to use try-block for createRexxInterpreterInstance() as it now throws a BSFException

- samples/Greetings.rxj

        - inhibit callbacks from Java after Rexx ends (if Rexx loaded Java)

- samples/HelloWorld.rxj

        - inhibit callbacks from Java after Rexx ends (if Rexx loaded Java)

- samples/OOo/listPathSettings-pure-ooo.rxo

        - new sample to demonstrate using the URL-converter service of OOo, rather than BSF.CLS'

- samples/OOo/demoFileUriConvert.rxo

        - inhibit callbacks from Java after Rexx ends (if Rexx loaded Java)

- samples/PrintFile.rxj

        - inhibit callbacks from Java after Rexx ends (if Rexx loaded Java)

- samples/ShootOut.rxj

        - inhibit callbacks from Java after Rexx ends (if Rexx loaded Java)

- samples/ShootOut2.rxj

        - inhibit callbacks from Java after Rexx ends (if Rexx loaded Java)

- samples/ShowCount.rxj

        - inhibit callbacks from Java after Rexx ends (if Rexx loaded Java)

- samples/ShowSize.rxj

        - inhibit callbacks from Java after Rexx ends (if Rexx loaded Java)


-------------------------------------- 2012-04-17 ----------------------------------

- Java4Rexx.java

        - change logic as there is no need for creating and terminating another Rexx
          interpreter instance anymore (there was a bug too, that caused Terminate()
          to not be invoked at all

- RexxAndJava.java

        - fixed a bug in createRexxInterpreterInstance() where the new RII was
          not assigned to the RexxEngine if that had no RII assigned to it yet

        - added protected void set_rii_ID(String rii_ID) to allow Java4Rexx to
          set the reference to the Rexx interpreter instance that invoked it

        - tidying up the code a bit (removing comments and TODOs that are not actual anymore)

-------------------------------------- 2012-04-05 ----------------------------------

- utilities/ooRexxTry.rxj

        - Jean-Louis Faucher:
                - Convert the result to a string before displaying in returnsArea

                - Support empty arguments : arg(N, "o") returns 1 if line N is empty in argsArea.

                - The temporary file ooRexxTry_test was created with a path in home directory,
                  but then only the filename part was kept. Now keeps the whole path.

                - The path to ooRexxTry_test is surrounded by quotes to support whitespaces.

                - The file ooRexxTry.rc is saved in the home directory.

                - No longer accumulate text in say_stg and error_stg, better to use the method
                  append of JTextArea.

-------------------------------------- 2012-04-03 ----------------------------------

- utilities/ooRexxTry.rxj

        - fix bug ID: 3514658

        - Java classes are now stored in .local by there fully qualified name;
          this way there should be no interference with any other class (JLF
          reported a name clash with .file, which is defined as an ooRexx class
          and which was offset by java.io.File that was saved in .local as .file)

-------------------------------------- 2012-03-29 ----------------------------------

- utilities/ooRexxTry.rxj

        - make sure that .input, .output and .error GUI interface can be used,
          even if Rexx code is run on a separate thread; quick fix, experimental

-------------------------------------- 2012-03-27 ----------------------------------

- utilities/ooRexxTry.rxj

        - Jean-Louis Faucher:  Fix bug 3512053

-------------------------------------- 2012-03-12 ----------------------------------

- RexxAndJava.java

        - now loading BSF4ooRexx DLL/so after trying to fetch the netrexx.lang.Rexx class,
          such that native library can access static field "nlR_class" and fetch the class object,
          if Java found it

        - change scope of "bsfPrefixReturnValue" from static to instance, such that
          the Rexx interpreter instances can run with different settings

-------------------------------------- 2012-02-06 ----------------------------------

- RexxDispatcher.java

        - terminate() Rexx engine to inhibit callbacks from Java to Rexx

-------------------------------------- 2011-06-18 ----------------------------------
- install/images

        - added new icons created by Graham Wilson (for ooRexxTry.rxj and for the
          installation menus)

-------------------------------------- 2011-06-08 ----------------------------------
- bin/rgf_util.rex

        - new routine ppCondition2(co[,bShowPackage=.false [,indent1="09"x [,indent2="0909"x [,indent3="090909"x [,lf=.endOfLine]]]]]]):
          returns a string rendering of the supplied condition object "co"

        - new routine ppPackage2(package[,indent1=""[, indent2="09"x[, lf==.endOfLine]]):
          returns a string rendering of the supplied package object

- added bsf4oorexx.dev/ReferenceCards/rgf_util

        - source odt-files for "rgf_util2.rex" article and (updated) reference card
          which get copied to bsf4oorexx.dev/information

-------------------------------------- 2011-06-04 ----------------------------------
- RexxAndJava.java

        - make sure that BSFExceptions get the Java Throwable object assigned, if this
          intelligible from context, such that one can retrieve it by using the
          BSFException instance method getTargetException()

-------------------------------------- 2011-05-30 ----------------------------------
- bin/rgf_util.rex

        - fix error not allowing suppliers to be shown in dump2(); this
          follows Jean-Louis fix in his ooRexx sandbox as of 2011-05-30;
          also changed sequence of argument checking to follow sequence
          of arguments as seen in Jean-Louis' version of rgf_util2.rex

-------------------------------------- 2011-04-29 ----------------------------------
- orx2reg.rex
  linux/resources/menu/bsf4oorexx_home.desktop

  description.xml
  ScriptProviderForooRexx.author.htm
  ScriptProviderForooRexx.update.html
  ScriptProviderForooRexx.update.xml
  ScriptProviderForooRexx.release-notes_en.txt

        - changed download page URL to "http://sourceforge.net/projects/bsf4oorexx/files/"
        - change references to BSF4ooRexx WWW site to: "http://sourceforge.net/projects/bsf4oorexx/"

-------------------------------------- 2011-02-23 ----------------------------------
- RexxAndJava.java

        - as this class is not public, its public members cannot be accessed
          by non-package code; therefore added that a new subfunction
          "carryOutSystemExit": if no argument ("0"|.false or "1"|.true) is given,
          then the current setting will be returned, otherwise the boolean field
          will be set to the argument, which gets returned as well

- utilities/ooRexxTry.rxj

        - renamed class "CreateSocket" to "CreateServerSocket"
        - added logic to allow new ooRexxTry.rxj instances to be
          created, even if the port is already taken (ask user
          for another new portnumber)
        - use new BSF-subfunction "carryOutSystemExit"
        - use SysTempFileName() to create unique temporary filenames

-------------------------------------- 2011-02-21 ----------------------------------
- utilities/ooRexxTry.rxj

        - added new BSF4ooRexx program by Markus Moldaschl which implements
          Lee Peedin's Windows ooRexxTry.rex in a platform independent manner,
          plus a few new bells and whistles
        - MacOSX: make sure to act upon the Apple application quit event
        - MacOSX: adding icon image to JFrame
        - make sure that a bsf.exit() is not carried out, if the RexxAndJava
          version is capable of doing that

- bin/BSF.CLS

        - define new entries in .bsf4rexx
          - "OPSYS" ... operating system name from "PARSE SOURCE opsys ." plus
            "OPSYS1", "OPSYS2", "OPSYS3" with the first one, two, three letters in
            uppercase
          - MacOSX: "APPLE_APPLICATION" the Apple application object representing
            the running Rexx program
          - "BSF4OOREXX_{016|032|048|064|128|256}": if defined path to PNG-icon
          - "OOREXX4OOO_{016|032|048|064|128|256}": if defined path to PNG-icon

        - MacOSX: remove About and Preferences Apple menu entries
        - MacOSX: define Dock icon

- testUnits/ooRexxUnit/OOREXXUNIT.CLS

        - fixed a wrong statement in Assert::fail

-------------------------------------- 2011-02-20 ----------------------------------
- utilities/ooRexxTry.rxj

        - removed MacOSX-related change to name of menu "Exit"
          to "Quit" as MacOSX has its own application "Quit" menu at all times

        - also using "VK_E" instead of "VK_X" for "Exit" button

- bin/BSF.CLS

        - adding MacOSX related properties for the Rexx programs

-------------------------------------- 2011-02-15 ----------------------------------
- org.rexxla.bsf.RexxDispatcher.java

        - MacOSX: show Rexx' filename in Apple menu bar in the application title,
          which gets set to: "BSF4ooRexx [rexx-filename]"

-------------------------------------- 2011-02-12 ----------------------------------
- testUnits/bsf4rexx/lex/procedural/Bean.testGroup

        - allow this test to run in "java.awt.headless=true"-mode

- testUnits/bsf4rexx/lex/oo/Bean.testGroup

        - allow this test to run in "java.awt.headless=true"-mode

-------------------------------------- 2011-02-10 ----------------------------------
- testUnits/bsf4rexx/rgf/C_interfaceClasses/Test_ITest.java

        - added "bShowInfos" to control additional new debug output

-------------------------------------- 2011-02-09 ----------------------------------
- BSF4ooRexx.cc

        - forcing ooRexx minimum level 4.1.0 (used to be 4.0.0, which is no good as
          there were needed bug fixes, which materialized in 4.0.1; as more bug fixes
          were applied to the available ooRexx 4.1.0, that version is now mandated)

- infoBSF.rxj
  infoBSF-oo.rxj

        - now also querying values for "os.arch", "sun.arch.data.model" and
          "java.ext.dirs" properties

-------------------------------------- 2011-02-07 ----------------------------------
- BSF4ooRexx.cc

        - fixing error message to reflect platforms if [lib]jvm.{dll|so|dylib} not found

-------------------------------------- 2011-01-24 ----------------------------------
- setupAllAndRun.rex

        - correct BSF-message popup text to not claim that no errors occurred during
          install and reinstall

- setupBSF.rex

        - escape "%" with "[25x]" in path on Windows

- orx2reg.rex

        - cater for escaped "%" as "[25x]" on Windows

-------------------------------------- 2011-01-24 ----------------------------------
- RexxAndJava.java

        - added new credits to kudos

-------------------------------------- 2011-01-12 ----------------------------------
- BSF4ooRexx.cc

	- free VMArgs options (string and options array)
	- memset malloc'ated VMArgs option memory to 0x00

-------------------------------------- 2011-01-09 ----------------------------------
- BSF4ooRexx.cc

        - fixing MacOSX Java pecularity, using ["JAVA_STARTED_ON_FIRST_THREAD_%d", getpid()]
          as per <http://lists.apple.com/archives/java-dev/2009/Oct/msg00511.html>

-------------------------------------- 2011-01-08 ----------------------------------
- org.apache.bsf.BSFManager.java

        - static constructor: fixed logic error in fallback code for getResources()

-------------------------------------- 2011-01-02/07 -------------------------------
- BSF4ooRexx.cc

        - fixed up code to not produce warnings on MacOSX' g++
        - code makes it possible to successfully load JVM in first thread by rexx.exe,
          although only with "java.awt.headless=true" in effect; rexxj*.* works like
          on any platform
    	- fixing MacOSX g++ warnings and errors, allow loading JVM via Rexx as well on MacOSX

-------------------------------------- 2010-12-08 ----------------------------------
- installation:

        - changed mimetypes from "application/x-rexx*" to "text/x-rexx*"

-------------------------------------- 2010-11-30 ----------------------------------
- ProxiedJavaClassTool.java:

        - fixed bug in createConstructorsBase(...) which caused illegal class files to be created

- samples\OOo\ahammer\example01_swriter_openblank_2.rxo,
  samples\OOo\ahammer\example03a_swriter_print.rxo

        - changed "dispose()" to "close(.true)" to demonstrate the XCloseable interface, besides
          this is the preferred method to close an OOo component

-------------------------------------- 2010-08-14 ----------------------------------
- Installation

        - created new, one-click installation on Windows and Linux

        - added file-associations on Windows and Linux for BSF4ooRexx scripts/programs

-------------------------------------- 2010-08-14 ----------------------------------
- BSF4ooRexx.cc:

        - new stratety on Unix to load 'libjvm.so': first try '/opt/BSF4ooRexx/libjvm.so',
          if not successful, then look for 'libjvm.so' and let the system find it

-------------------------------------- 2010-07-12 ----------------------------------
- BSF.CLS

        - .bsf.dialog::inputBox: now accepting a Java Object array for options (an array of Strings)

-------------------------------------- 2010-06-10 ----------------------------------
- BSF.CLS

        - changed environment variable from 'BSF4Rexx.JavaStartupOptions' to
          'BSF4Rexx_JavaStartupOptions'; reason: bash cannot process environment variables
          that contain a dot

-------------------------------------- 2010-06-08 ----------------------------------
- BSF.CLS

        - corrected BsfLoadJava to supply Java startup arguments, if given
          in the environment variable named 'BSF4Rexx.JavaStartupOptions'

-------------------------------------- 2010-06-05 ----------------------------------
- BSF.CLS

         - added check for minimum version of ooRexx being "4.0.1"

-------------------------------------- 2010-05-22 ----------------------------------
- BSF4ooRexx.cc:
        - added optional second "lengthToUse" argument to BsfRawBytes(); "lenghToUse"
          determines the number of bytes to use for the conversion

-------------------------------------- 2010-05-22 ----------------------------------
- BSF4ooRexx.cc:

        - fixed potential errors in assuming that a Rexx string object is indeed
          a RexxStringObject in the native layer; could be an internal, optimized
          Integer object!
          Cf. <https://sourceforge.net/tracker/?func=detail&atid=684730&aid=3005462&group_id=119701>

- RexxAndJava.java
        - removed special handling of Character.class or char.class arguments because
          of changes in BSF4ooRexx.cc

-------------------------------------- 2010-05-20 ----------------------------------
- samples/

        - rewrote all samples/* samples/LeePeedin/* examples to now take advantage
          of the RexxProxy infrastructure; all programs therefore are not using
          bsf.addEventListener anymore

- BSF4ooRexx reference card

        - updating to reflect current set of functionalities

- RexxAndJava.java

        - fixed a bug in converting to a char or Character, if the value was "00"x

        - coerceArgs(): if matching wrapper objects are passed for primitive values
                        from Rexx, then accept them from now on

- BSF4ooRexx.cc:

        - added new JNU_GetStringNativeCharsReturningRexxObjectPtr(...) macro which
          returns a RexxObjectPtr (RexxString) that may contain embedded NUL chars

        - return values/arguments from the Java side now process strings that have
          NUL chars embedded;

          - hint: if in need of supplying a Rexx string with embedded NUL chars to Java use:
                     b=BsfRawBytes(RexxString)  -- turn Rexx string into Java byte array
                     s=.java.lang.String~new(b) -- use Java byte array to construct Java String

-------------------------------------- 2010-05-11 ----------------------------------
- BSF.CLS

        - added routine bsf.getSlotDir() which returns the last (slotDir) item

-------------------------------------- 2010-05-08 ----------------------------------
- BSF.CLS

        - BSF::UNKNOWN::CLASS - little optimization: forwarding directly to bsf.jco
        - create[Java]Array[Of] - forward all arguments verbatimely (let Java side optimize)
        - remove usage of bsf.getJavaClassObjectProxy(...)
        - removed method bsf.class, instead send "getClass" to Java object
        - removed class method bsf.getJavaClassObjectProxy
        - removed class attribute bsf.JavaClassObjectProxies
        - removed class attribute bsf.JavaClassObjects
        - added public routine "bsf.importClass" (matching "bsf.loadClass") to supercede "bsf.import"
        - added class method "bsf.importClass" to class "BSF" (matching "bsf.loadClass")
          to supercede "bsf.import"

-------------------------------------- 2010-04-20 ----------------------------------
- RexxAndJava.java

        - fixed a bug in INVOKE, if looking up and resolving a method in class-objects

-------------------------------------- 2010-04-18 ----------------------------------
- RexxAndJava.java

        - changed logic in REGISTER_BEAN | NEW (matching changed logic in BSF.CLS'
          ".BSF~bsf.import"): Java class object is already loaded, hence just look it up
          in the registry; will speed up creation of Java objects a little bit

- BSF.CLS

        - added public routine bsf.createProxyClass(), adapted .BSF~bsf.import accordingly

-------------------------------------- 2010-04-17 ----------------------------------
- RexxAndJava.java

        - fixed conversion error in setFieldValue[Strict], if assigning "1" or Boolean.TRUE
          to a boolean field

- RexxProxy.java

        - added ability to switch to using the new Janino-based dynamic extension
          of abstract Java classes on the fly

- ProxiedJavaClassTool.java

        - added to have an alternative (though by comparison to the default ASM
          solution quite slow) to extending abstract Java classes on the fly

-------------------------------------- 2010-03-27 ----------------------------------
- RexxAndJava.java

        - if processing an InvocationTargetException then first attempts to do a g
          etCauseAsString(), if not successful falls back to current getCause()

-------------------------------------- 2010-03-21 ----------------------------------
- New directory structure and installation

- new directory "install": this contains the

        - the DLLs and shared libraries in the subdirectories "32" or "64" depending
          on their bitnesses

          - setupBSF.rex will copy the approriate DLL/shared library to the BSF4ooRexx
            homedirectory (the directory in which the "install" directory resides)

        - setup scripts and their generated installation, uninstallation, environment
          scripts

- new directory "utilities"

        - contains utility classes programs which exploit and enhance BSF4ooRexx

          - new "bsfScreenShot.cls" allows to take full screen shots or screen shots
            of awt/swing container, allowing to save them as gif, jpg/jpeg or png files;
            examples to demonstrate usage of this package: "useBsfScreenshot_01.rxj",
            "useBsfScreenshot_02.rxj"


- setupBSF.rex:

        - changed the setup scripts to make it easier for users to install BSF4ooRexx,
          especially on Linux:

          - using /etc/profile to invoke the setEnvironment4BSF.sh

            - need to logoff/logon to make changes effective, unless one would add the
              following lines to ~/.bashrc

                 source fully-qualified-path-to/setEnvironment4BSF.sh

          - copying libBSF4ooRexx.so to /usr/lib, followed by running ldconfig

-------------------------------------- 2010-03-14 ----------------------------------
- BSF4ooRexx.cc:
        - applied Jean-Louis Faucher's fixes for debug-mode (e-mail 2010-03-14):
          "I got a crash with the debug version of bsf4oorex
          (bsf4oorexx-20091031-beta2_sources) It's because of the memory pattern
          stored by the heap manager when in debug version : 0xfeeefeee The next
          node must be read before the remove (I see you fixed already the code, but
          not everywhere).  Search for JLF in the attached file, you will see where
          I changed the code."

        - added ".rxo" (for OpenOffice scripts); if Rexx is started via Java it will now
          look for the additional Rexx extensions: ".rxj,.rxo,.rxjo,.jrexx"



-------------------------------------- 2010-02-20 ----------------------------------
- adding new samples:

         - samples/rgfScreenShot.cls

           a utility package containing public classes that allow taking screenshots
           (full, of any awtComponent, any arbitrary area) and saving the returned
           image in a file (allowing to determine the image type to use);
           these functionalities are available independent of operating systems

         - samples/useRgfScreenshot_01.rxj ... demonstrate usage of "rgfScreenShot.cls"
         - samples/useRgfScreenshot_02.rxj ... demonstrate usage of "rgfScreenShot.cls"


-------------------------------------- 2010-02-19 ----------------------------------
- RexxAndJava.java
          - added subfunction "isA" ("isInstance")

- BSF.CLS
        - added instance method bsf.isA(javaClass) to the class .BSF, returning .true or .false

        - added public routine bsf.isA(javaObject, javaClass)


-------------------------------------- 2010-02-10 ----------------------------------
- BSF4ooRexx.cc:
        - added external function BsfRawBytes(rexxString|javaByteArray), which allows
          for

          - submitting the bytes of a Rexx string without any codepage translations to Java,
            i.e. if a rexxString is given the appropriate Java byte array is returned as
            BSF proxy and can then be used as an argument for a Java method

          - turning a single-dimensioned Java byte array into a Rexx string without any
            codepage translations

-------------------------------------- 2009-10-31 ----------------------------------
- RexxAndJava.java
        - replaced European characters with their Unicode equivalent

        - gives additional error information in the BSF()-subfunction "NEW"/"REGISTERBEAN"


- setupBSF.rex
        - changed occurrences of "BSF4Rexx" to "BSF4ooRexx" in informative text as well

- testUnits
        - changed the run scripts to account for the relative position of the framework
          control script ("testOORexx.rex") in the filesystem, as that is is used as the
          script's base directory

-------------------------------------- 2009-10-20 ----------------------------------
- general work for preparing beta 1 release:

- completing nutshell examples to demonstrate new BSF4ooRexx features in "samples/version4"
        - using interfaces, abstract methods implemented in Rexx

        - using abstract classes, abstract methods implemented in Rexx

        - Java examples to demonstrate how to invoke Rexx programs using the same
          Rexx engine (the same Rexx interpreter instance) as well as interacting
          with Rexx objects by sending them messages from Java


-------------------------------------- 2009-10-19 ----------------------------------
- BSF4ooRexx.cc:
        - renaming from "BSF4Rexx" to "BSF4ooRexx"

- RexxAndJava.java:
        - renaming "BSF4Rexx" to "BSF4ooRexx"


-------------------------------------- 2009-10-18 ----------------------------------
- RexxAndJava.java:
        - added private methods "lookupBean4JNI" and "registerBean4JNI"

- BSF4ooRexx.cc:
        - if Rexx is started via Java it will now look for the Rexx extensions: ".rxj,.rxjo,.jrexx"

        - added "BsfJavaException(option[, arg)" to allow throwing Java exceptions (needed
          e.g. for some OpenOffice vetoing patterns)


-------------------------------------- 2009-10-12 ----------------------------------
- RexxAndJava.java:
        - allow "getRAJO" as synonym for "getRexxAndJava"

- BSF4Rexx.cc:
        - if Rexx is started via Java it will also look for the Rexx extensions ".jrexx,.jrexxo"


-------------------------------------- 2009-10-10 ----------------------------------
- RexxDispatcher.java:
        - removed rexxengine.halt(), which raises the HALT condition in all Rexx threads


-------------------------------------- 2009-10-07 ----------------------------------
- RexxAndJava.java:
        - allow retrieving this RexxEngine instance


-------------------------------------- 2009-10-06 ----------------------------------
- BSF4Rexx.cc:
        - using and testing the new thread infrastructure functions


-------------------------------------- 2009-10-03 ----------------------------------
- BSF4Rexx.cc:
        - finished creating new thread infrastructure functions;


-------------------------------------- 2009-10-01 ----------------------------------
- RexxAndJava.java:
        - allow retrieving this RexxAndJava instance


- BSF4Rexx.cc:
        - renamed RgfGetJRST_for_new_jniRexxStart(...) to RgfGetJRST_or_create_new

        - changed multithreading strategy: if a new program/routine or SendMessage, then
          force creation of a new JRST; if for a TID a JRST exists already, then ...

        - added RgfRemoveJRST_By_RIID(void *rii);


-------------------------------------- 2009-09-25 ----------------------------------
- BSF4Rexx.cc:
        - added BsfGetRIID(), returning the Rexx instance pointer as a string (using %p)

        - using snprintf(...) [C99-compilers] or sprintf_s(...) [MSC-compiler] instead
          of sprintf(...) to make the program fully buffer overrun safe in those corners;
          also replaced strcat(...) with SNPRINTF(...)


-------------------------------------- 2009-09-22 ----------------------------------
- RexxProxy.java:
        - added the methods sendMessage(msgName,arg[]), sendMessage0(msgName),
          sendMessage1(msgName,arg1), sendMessage2(msgName,arg1,arg2),
          sendMessage3(msgName,arg1,arg2,arg3), sendMessage4(msgName,arg1,arg2,arg3,arg4),
          sendMessage5(msgName,arg1,arg2,arg3,arg4,arg5) to ease sending messages
          to Rexx objects a little bit


-------------------------------------- 2009-09-12 ----------------------------------
- BSF4Rexx.cc:
        - list "BsfCreateRexxProxy" and "BsfRexxProxy" in "BsfQuery{All|Registered}Functions"

        - made sure no buffer-overruns in sprintf()


-------------------------------------- 2009-09-10 ----------------------------------
- BSF4Rexx.cc:
        - version string now contains the address mode, added as a third word in the form
          of bits"-bit", where "bits" is "32" or "64"

- Supplier.java:
        - adjust for change in ArrayWrappter, which now throws a ClassNotFound exception

- RexxAndJava.java:
        - added a synonym "createJavaArrayOf" for "createArrayOf" to make this self-documuntary
          clear that a Java array object is to be created and not an ooRexx one

        - added a synonmym "createJavaArray" for "createArray": this allows to make
          it clear that a Java array object is to be created and not an ooRexx one

- ArrayWrapper.java:
        - account for Thread context class loader not set


-------------------------------------- 2009-09-06 ----------------------------------
- RexxExtendClass.java:
        - supply class object in static method invocations for callbacks, such that
          invoked Rexx method can directly address the class object for "_forwardToSuper"
          static methods

- BSF4Rexx.cc:
        - added new external function: "BsfRexxProxy(proxy [, 'ooRexxObject' | 'userData' | 'refCount'])"

        - added new internal inline function:  "RgfGetProxyObjectRefCount(RexxThreadContext, RexxStringObject)"


-------------------------------------- 2009-09-03 ----------------------------------
- BSF4Rexx.cc:
        - adding "RgfRemoveAllProxyObjectsByRIID[2]()" to allow freeing cached Rexx proxy
          objects, if BSF4Rexx got invoked via Java and a terminate() is executed on the
          RexxEngine instance

        - _jniRexxTerminateInterpreterInstance(): will invoke "RgfRemvoeAllProxyObjectsByRIID(...)",
          but only, if BSF4Rexx was invoked by Java!

        - _jniRexxUnregisterRexxObject(): will not free cached Rexx objects, if BSF4Rexx
          was invoked by Rexx; this will avoid the potential (intermittent) occurrence of
          exceptions while running Java object finalizers, after the Rexx program has
          terminated and the Rexx interpreter removes the infrastructure without notice


-------------------------------------- 2009-09-01 ----------------------------------
- RexxExtendClass.java:
        - made sure that class version tests are not carried out against the
          source class version, but the desired new class version


-------------------------------------- 2009-08-27 ----------------------------------
- RexxAndJava.java:
        - added the argument "returnType" to rexxInterface.jniRexxSendMessageToRexxObject()

- BSF4Rexx.cc:
        - adding a j_resultType argument to  _jniRexxSendMessageToRexxObject

        - _jniRexxSendMessageToRexxObject(): now marshalling return value to given (primitive) return type

- RexxEngine.java:
        - added the argument "returnType" to rexxInterface.jniRexxSendMessageToRexxObject()


-------------------------------------- 2009-08-20 ----------------------------------
- BSF4Rexx.cc:
        - edit to remove gcc 64-Bit compiler warnings on Linux


-------------------------------------- 2009-08-01 ----------------------------------
- JPrintFile_for_v40.rex
        - added "samples/version40/JPrintFile_for_v40.rex" (supercedes "samples/JPrintFile.rex"):
          this sample demonstrates how can implement abstract Java methods in Rexx; there is no need
          anymore to create concrete java implementations of abstract Java classes, before they
          can be used from Rexx


-------------------------------------- 2009-07-31 ----------------------------------
- RexxProxy.java
        - added new method 'newExtendedProxyInstance(Object [])'

        - renamed private method 'newJavaProxyInstanceFromRexx' to
          'newJavaOrExtendedProxyInstanceFromRexx', which will invoke either
          'newJavaProxyInstance' or 'newExtendedProxyInstance"

- RexxExtendClass.java
        - added program to BSF4Rexx 4.0

- RexxExtendingClassLoader.java
        - added program to BSF4Rexx 4.0


-------------------------------------- 2009-07-30 ----------------------------------
- BSF.CLS
        - class "BSF": created class method "bsf.createArrayOf"

        - created public routine "bsf.createArrayOf"

- RexxAndJava.java
        - adding subfunction "createArrayOf": creates a single dimensioned
          Java array and returns it; the first argument determines the type of the
          array ("componentType"); all subsequent values in the array are then coerced
          to the "componentType" and stored. If no values are given (just the single
          "componentType") then the Java array will have a size of "0", but still being
          of the given "componentType"


-------------------------------------- 2009-07-14 ----------------------------------

- RexxAndJava.java
        - treat Boolean in "convFromRexx(typeIndicator,value)" string "true" as Boolean
          (so far only "1" = Rexx truth value was regarded as "true"); because of the
          typeIndicator it is clear that a Boolean (string) value is submitted; allowing
          the (caseless) string "true" will make transcriptions from Java programs easier


-------------------------------------- 2009-07-13 ----------------------------------
- RexxAndJava.java
        - corrected a bug in INVOKE and INVOKE_STRICT, if object was a class object

        - applying System.identityHashValue() for all Java objects, as we truly need
          uniquely identifiable peers


-------------------------------------- 2009-07-12 ----------------------------------
- RexxAndJava.java
        - renamed argument "methodDescription" to "methodDescriptor" for jniRexxSendMessageToRexxObject()

- RexxEngine.java
        - renamed argument "methodDescription" to "methodDescriptor" for jniRexxSendMessageToRexxObject()

-------------------------------------- 2009-07-11 ----------------------------------
- BSF4Rexx.cc
        - added ability to retrieve and pass on "javaObject" to _jniRexxSendMessageToRexxObject

- RexxAndJava.java
        - added arguments "javaObject" and "methodDescription" to jniRexxSendMessageToRexxObject()


- RexxEngine.java
        - added arguments "javaObject" and "methodDescription" to jniRexxSendMessageToRexxObject()

- RexxProxy.java
        - added additional invoke() method which is crafted for allowing callbacks for
          extended Java classes, accepting the javaObject that is the source of the callback,
          as well as the internal Java method description (denotes argument and return values)

-------------------------------------- 2009-07-10 ----------------------------------
- BSF4Rexx.cc
        - added ability to retrieve and pass on "messageDescription" in
          internal Java form to _jniRexxSendMessageToRexxObject

-------------------------------------- 2009-06-27 ----------------------------------
- BSF.CLS
        - now raises syntax errors in case too many arguments are supplied for the
          (class) methods or public routines:

           - bsf.postEventText
           - bsf.pollEventText
           - bsf.import
           - bsf.getFieldValueStrict
           - bsf.setRexxNullString
           - bsf.sleep

- BSF4Rexx.cc
        - to ease parsing, changed the 40.900 error message format to:

          fileName '/' { 'routine' | 'class' clzName } '/' { routineName | ['class'] 'method' methodName} ',' 'error' nr ':' errorMessage

        - jniRexxSendMessage: if Java method object is supplied, store it under
          'METHODOBJECT' in the callback directory

- RexxAndJava.java
        - changed signature of jniRexxSendMessageToRexxObject() to accept the
          beanname of an optional Java method object

- RexxEngine.java
        - added method call() expecting a method object, such that InvocationHandler usage
          allows to process (and forward) the supplied method object as well

- RexxProxy.java
        - added additional invoke() method which accepts a java.lang.reflect.Method object
          instead of just a method name

        - class made public, such that its type can be used in Java programs; however, instantiating
          this class is reserved for the JNI layer, due to it being intertwined with the Rexx object

-------------------------------------- 2009-06-25 ----------------------------------
- RexxAndJava.java
        - BSF subfunction "createArray" now also accepts a string fully qualifying a
          Java class for its component type argument (denoted: 'JavaClassObjectBeanName')

- BSF.CLS
        - added method "size" to class BSF_ARRAY_REFERENCE

-------------------------------------- 2009-06-23 ----------------------------------
- BSF4Rexx.cc
        - .._jniSendMessageToRexxObject(): now there will be always an argument added as the
          last argument which contains a Rexx directory  with the entry "METHODNAME"; if
          a user_data object was given as the second argument in BsfCreateRexxProxy(), then
          that object will be in the added callback argument under the name "USERDATA"

        - removed argument "creationTID" (from RexxProxy.java, not needed anymore)

        - removed external function "BsfProcessCallbackArgs()", it is not really needed and
          just clutters the list of external BSF4Rexx-functions

- RexxProxy.java
        - removed "creationTID" (not needed anymore)

- RexxEngine.java
        - removed usage of "creationTID" (not needed anymore)

- RexxAndJava.java
        - removed argument "creationTID" in jniRexxSendMessageToRexxObject (...)

-------------------------------------- 2009-06-22 ----------------------------------
- samples\version40\SAX
        - added a sample to demonstrate how to process an XML file and have the SAX parser
          ignore external DTDs

- samples\version40\DOM
        - added a sample to demonstrate how to process an XML file and have the DOM parser
          ignore external DTDs

-------------------------------------- 2009-06-21 ----------------------------------
- BSF.CLS
        - will set BsfShowErrorMessage() to .false as default

        - added XML-parsing examples using Java's SAX and DOM (needs Java 1.4.2 or higher)
          exploiting and demonstratign the new callback features of ooRexx 4.0 with BSF4Rexx 4.0

-------------------------------------- 2009-06-08 ----------------------------------
- BSF.CLS
        - BsfCreateRexxProxy(): removed method obsolete 'bsf.addEventListenerReturningEventInfos'

        - BsfCreateRexxProxy(): removed method obsolete 'bsf.getEventInfoObject'

        - BsfCreateRexxProxy(): removed obsolete private class "bsf_array_proxy.assure_BSFRegistry_Removal"

        - add bsf.wrap as a class method to .BSF; this way it becomes accessible on a callback from the
          4.0 API, if .bsf is placed in .local


- BSF4Rexx.cc
        - removed "Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniRexxStart()"

        - removed RXSIOSAY exit, as with the 4.0 APIs it has become possible to get at the
          Rexx error message via the API, hence no such hack necessary anymore

        - added "Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniRexxCreateInterpreterInstance"

        - added "Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniGetRexxInterpreterInstanceRoot"

        - added "Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniRexxHaltInterpreterInstance"

        - added "Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniRexxTerminateInterpreterInstance"

        - added "Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniUnregisterRexxObject"

        - added "Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniRexxRunProgram"

        - added "Java_org_rexxla_bsf_engines_rexx_RexxAndJava_jniRexxSendMessageToRexxObject"

        - added external Rexx function "BsfCreateRexxProxy()": creates a Java proxy for an
          ooRexx object, which allows sending or forwarding messages from Java to ooRexx; syntax:

                BsfCreateRexxProxy(code|object [, [userData] [, JavaInterface[name]...]), where

                code|object ... Rexx code to execute each time a Java message is sent (code will
                                be used for the UNKNOWN method); or a Rexx object to which the
                                Java message gets sent to
                userData ... any Rexx object (e.g. a directory); if given, then this will cause
                             an additional directory object to be created which will contain an
                             entry "USERDATA" referring to this user supplied object (this callback
                             argument will always be the last argument and contains in addition
                             the entires "METHODNAME", which preserves the exact case of the Java
                             method name, and "CREATIONID", the TID in which the proxy got created);
                             if userData is omitted, no such callback argument will be created
                JavaInterfaceName ... one or more, comma-separated, optional Java interface names
                             or Java interface class objects, or Java objects which classes implement
                             Java interfaces (then those interfaces are used as well), which
                             will cause an instance of java.lang.reflect.Proxy to be created;
                             if these arguments are given, then the Java Proxy object is returned
                             instead, which will forward all Java method invocations to the RexxProxy
                             object;
                             if this argument is not given, then the RexxProxy object is returned;
                             that RexxProxy possesses a public method "newJavaProxyInstance(Object[] interfaces)"
                             which can be invoked from Rexx as well; the Java Object[] array
                             elements may in this case be the same as the "JavaInterfaceName" above

        - added external Rexx function "BsfProcessCallbackArgs()": accepts either an argument array
                (e.g. Arg(1,"A)) or directly the callback directory and sets its elements in the
                caller with the stem defined by REXX_CALLBACK_ARG_STEM_NAME ("BSFARG."); at the
                time of this writing the defined entries are: "USERDATA", "METHODNAME", "CREATIONTID";
                returns .true, if callback directory could be found and processed, .false else

- BSF_OnTheFly.cls
        - new ooRexx module, stub ooRexx program which allows plain code to be submitted for
          creating an ooRexx object that has the code as the "unknown" method; code can be a
          string or a method object

          - if code is omitted, then .nil is returned

        - allows "setMethod" and "unsetMethod" to be used

- Java4Rexx.java
        - using the new ooRexx 4.0 APIs in the BSF4Rexx 4.0 support

- RexxAndJava.java
        - added getRexxEngine() accessor

        - added jniCreateInterpreterInstance

        - added jniGetRexxInterpreterInstanceRoot

        - added jniRexxHaltInterpreterInstance

        - added jniRexxRunProgram

        - added jniRexxSendMessageToRexxObject

        - added jniRexxTerminateInterpreterInstance

        - added jniUnregisterRexxObject

        - removed subfunction "addEventListenerReturningEventInfos", use BsfCreateRexxProxy() instead

- RexxDispatcher.java
        - using the new ooRexx 4.0 APIs in the BSF4Rexx 4.0 support

        - added explicit rexxengine.terminate()

        - checking, if file exists, aborting with a user friendly error message, if file does not exist

- RexxEngine.java
        - overall: adjusted to use the new BSF4Rexx 4.0 API based JNI functions

        - removed ThreadedJNIRexxStart(): too complicated, can always be (easily) done from Java

        - folded apply's invocations of Rexx script (depending whether args were given or not)
          into one common invocation

        - added fields "bTerminated" (indicates whether the Rexx interpreter instance
          has been terminated and is not accessible anymore), "rii_ID" (the Rexx interpreter
          instance pointer value as a string, as supplied by JNI)

        - implementation of "call()" now allows to invoke any Rexx method with any arguments,
          as long as a RexxProxy object is submitted; this implements the callback functionality
          with the help of the new ooRexx 4.0 APIs

- RexxException.java
        - new class, allows storing the Rexx condition object as a RexxProxy

- RexxProxy.java
        - new class, allows defining a RexxProxy for Java, slot available for userData to be sent with
          callback message

        - implements the interface java.lang.reflect.InvocationHandler

        - allows to create a java.lang.reflect.Proxy using "newJavaProxyInstance(Object[] interfaces)"

====================================================================================
- Changed BSF4Rexx.cc and the respective interfaces for the Java Rexx engine to use
  the new ooRexx 4.0 APIs. As a result this version of BSF4Rexx can only be used
  against ooRexx 4.0 and above!
====================================================================================

-------------------------------------- 2009-04-04 ----------------------------------
- BSF4Rexx.cc
        - added/changed defines such that this program can now be compiled on ooRexx 3.x
          and ooRexx 4.x

-------------------------------------- 2009-04-04 ----------------------------------
- RexxEngine.java
        - added methods terminate(), terminate(tid), terminateAllRexxThreads()

- RexxAndJava.java:
        - added BSF subfunction "haltThread": halts/terminates the supplied TID
          (received by "BSFGetTID()")

        - added 'jniRexxGetTID()', 'jniRexxSetHalt(tid)'

- BSF.CLS:
        - added public routine "bsf.haltThread(tid)"
        - added class method "bsf.haltThread(tid)" to .BSF

- BSF4Rexx.cc
        - removed deregistering the RXSIO exit as this is not necessary; this
          solves a problem, if nesting RexxStart()-invocations take place as upon
          return the RXSIO exit was deregistered (which does it globally)

        - added the implementations for 'jniRexxGetTID()', 'jniRexxSetHalt(tid)'

-------------------------------------- 2008-09-11 ----------------------------------
- BSF.CLS:
        - bsf.wrap() now caters for unprefixed argument strings that stem from RexxEngine
          by not raising an exception anymore, but returning the received string unaltered

-------------------------------------- 2008-09-11 ----------------------------------
- BSF.CLS:
        - boxing a Boolean: now strictly only accepts the Rexx values .true, "1",
          .false, "0", "true" or "false"

-------------------------------------- 2008-09-09 ----------------------------------
- BSF.CLS:
        - replaced subfunction "bsfRegister[Strict]" with "new[Strict]" such that
          error messages can be understood easier (it is self-evident what
          "new[Strict]" means)



-------------------------------------- 2008-09-02 ----------------------------------
- BSF4Rexx.cc:
        - if nested invocation (invoking a new Rexx interpreter in the same thread
          where an instance of a Rexx interpreter is already running) of the Rexx
          interpreter, do not wait for termination in the nested invocation (ooRexx
          3.2.0 waits forever)

-------------------------------------- 2008-09-01 ----------------------------------
- RexxAndJava.java
        - removed undocumented, experimental subfunction "getOrLoadClass(JavaClassName)"

- BSF4Rexx.cc:
        - removed superfluous variables in BsfUnloadJava()

-------------------------------------- 2008-08-31 ----------------------------------
- BSF.CLS:
        - removed "dir" class attribute from class "BSF"

        - new "BSF4REXX" public class now behaves as a directory by forwarding all
          unknown messages to its directory class attribute; created "B4R" public
          class which acts as a short-hand alias forwarding its unknown messages to
          the "BSF4REXX" class

-------------------------------------- 2008-08-28 ----------------------------------
- BSF.CLS:
        - moved ".bsf4rexx" directory object to the class attribute "dir" of class
          ".BSF" and have ".bsf4rexx" and ".b4r" just point to it; the code in here
          will be changed to use only the BSF class attribute such that multiple
          interpreter instances running in the same process do not influence that
          content unadvertently (.local is shared in ooRexx < 4.0!)

        - added "line.separator", "file.separator", "path.separator" to .bsf4rexx
          directory

-------------------------------------- 2008-08-20 ----------------------------------
- BSF4Rexx.cc:
        - ooRexx: using RexxDidRexxTerminate() and RexxWaitForTermination() to make
                  sure that threads can continue to run and shut down gracefully

-------------------------------------- 2008-08-06 ----------------------------------
- BSF4Rexx.cc:
        - overhauled the entire JNI logic and support
        - added a new external Rexx function, named "BSFDetach()"

-------------------------------------- 2008-07-20 ----------------------------------
- BSF.CLS:
        - class BSF_ARRAY_REFERENCE, methods AT, PUT, PUTSTRICT: added checks for
          asserting the correct number of subscripts (honoring dimension of the
          Java array object) gets supplied

- samples/demoJavaArrays.rex: added new sample to demonstrate how to create and use
          Java array objects

-------------------------------------- 2008-07-09 ----------------------------------
- BSF.CLS:
        - added public routine "bsf.version()" as pass-thru to BSF()-subfunction
          "version"

-------------------------------------- 2008-07-04 ----------------------------------
- org.apache.bsf.util.event.generator.AdapterClassLoader:
        - extended logic to employ a newly created inner class loader using the
          current thread's class loader as parent class loader

-------------------------------------- 2008-07-01 ----------------------------------
- BSF4Rexx.cc:
        - changed processing the Java exception: replaced "getMessage()" with
          "toString()" (uses "getLocalizedMessage()")

-------------------------------------- 2008-06-23 ----------------------------------
- BSF.CLS: fixed additional errors introduced by the quite massive changes on 2008-06-22

- Various examples: adopted all examples: if they use the BSF.CLS module, then no
          BSF()-function calls should be carried out, but only the public routines,
          classes and methods of the BSF.CLS.

          Reason: BSF.CLS activates the new feature of RexxAndJava to prepend the
                  returned strings with "<O>" (string is index into BSFRegistry to
                  address a Java object) or "<S>" (following is a plain string).
                  So, if BSF()-function calls are carried out, then one would need
                  to cut out this new type indicator string which is always three
                  characters long.

- ReflectionUtils.java:
        - addEventListener() now gives more information about available event set
          names (including the individual events), in case a given one was not found;
          *much* more user friendly!

-------------------------------------- 2008-06-22 ----------------------------------
- RexxAndJava.java
        - added a new BSF subfunction 'bsfPrefixReturnValue([0|1])' (default=0=.false)
          for controlling whether the string value returned should be prefixed with a
          three letter type indicator ("<O>": following string is an index into the
          BSFRegistry; "<S>": following string is a plain string);
          invoking without an argument returns the current setting, otherwise sets the
          behaviour accordingly and returns the new value

- BSF.CLS:
        - now forcing to prepend type information to the strings returned from
          RexxAndJava, thereby allowing to fix a very subtle bug (took me more than
          8 hrs of debugging and 4 hrs of fixing and testing!)

          *ATTENTION*! If you use BSF.CLS then from now direct BSF()-calls will return
                       strings that have the aforementioned "<O>" and "<S>" indicators
                       prepended. In such a case, either use the counter-routine and/or
                       method of BSF.CLS, or, just strip the first three bytes from the
                       return value
                       (classic Rexx programs are not affected by this, as they do not
                       use BSF.CLS which explicitly turns on this behaviour)

-------------------------------------- 2008-06-18 ----------------------------------
- BSF.CLS:
        - in case of a Java error upon calling the external function BSF() the Java
          error message will now be saved in the local environment as ".BSF_ERROR_MESSAGE"
          such that it is available for later inspection; this environment symbol will
          be removed from .local immediately before a new external BSF() call is made
          from within this module

-------------------------------------- 2008-06-15 ----------------------------------
- multiple places:
        - supply the given path to the script to Rexx, such that "PARSE SOURCE" will
          be able to retrieve it

- org.apache.bsf.util.EngineUtils:
        - loadClass() now raises a BSFException, if it would return null as the
          class object

- org.apache.bsf.util.BSFEventProcessor
- org.apache.bsf.util.BSFEventProcessorReturningEventInfos
        - processExceptionableEvent(): now checks for event name in filter in
          a caseless fashion; events to be filtered can now be given in a space
          or plus ('+') delimited form: if any of the words matches the event adapter
          will be activated/run

-------------------------------------- 2008-06-08 ----------------------------------
- RexxAndJava.java:
        -  if an InvocationTargetException()-exception, then show its contained
           exception message to ease identifying the cause of the exception

        - if EngineUtils.loadClass() in BSF 2.4 returns "null", then make sure that
          a class-not-found exception is thrown; BSF should take care of that in the
          future

-------------------------------------- 2008-05-23 ----------------------------------
- readmeBSF4Rexx.txt:
        - added explicit Unix samples for invoking "rexxj.sh"

-------------------------------------- 2008-05-18 ----------------------------------
- setupBSF.rex:
        - for Windows the created un/installBSF.cmd now also contains commands to
          add/remove path entries to the appropriate HKCU (user) or HKLM (system)
          environment variables PATH and CLASSPATH, depending in which hive OOo got
          installed to; for this the new utility program 'orx2reg.rex' got created;
          before applying the changes (adding/removing paths) a backup-file is
          created documenting the values of the PATH and CLASSPATH environment
          variables of both hives

-------------------------------------- 2007-09-21 ----------------------------------
- BSF-package
        - changed the way BSF employs class loaders, such that it does not depend
          on the Thread context class loader alone; rather it will employ also the
          defining class loader of BSFManager itself

        These changes make it possible to deploy the BSF library (and as a result
        BSF4Rexx) on OOo 2.3.0 (released: September 2007) again, which introduced
        a custom class loader for loading Java extensions (BSF4Rexx uses the Java
        scripting framework of OOo)


-------------------------------------- 2007-08-06 ----------------------------------
- BSF.CLS: - renamed "BSF" class method "attachNewStrict" to "bsf.attachNewStrict"

-------------------------------------- 2007-07-07 ----------------------------------
- BSF.CLS: - added ability to the BSF.DIALOG class to only supply the first character
             to determine the desired message type

- Supplier.java: - added allIndexes() and allItems() using the ooRexx 3.2.0beta semantics

-------------------------------------- 2007-01-09 ----------------------------------
- BSF.CLS: - added ability to set Java startup parameters via the operating system
             environment using the name 'BSF4Rexx.JavaStartupOptions', which needs
             to be set before calling/requiring BSF.CLS

-------------------------------------- 2006-12-17 ----------------------------------
- setupBSF.rex: catering for Java 6 (1.6) new ability to denote a second (system-wide)
             extension directory, which broke the setup script; the script will use
             the JRE's "lib/ext" (the first listed) directory

-------------------------------------- 2006-12-10 ----------------------------------
- RexxEngine.java: rgf, removed a stupid bug in apply() and eval(): now checking whether
             'source' argument is not null

- RexxAndJava.java: rgf, enhanced subfunction "version" to accept an argument optionally:
                 "AL[l]": will return a blank delimited list of org.rexxla.bsf.engines classes
                        with their version number in the form: version.YYYYMMDD
                 "AR[rayWrapper]"
                 "B[SFManager]"
                 "E[numerationWrapper]"
                 "J[ava4Rexx]"
                 "REXXA[ndJava]"
                 "REXXE[ngine]"
                 "S[upplier]"

-------------------------------------- 2006-12-08 ----------------------------------
- RexxAndJava.java: rgf, added subfunction "getBSFManager"; this allows retrieving the
             version of BSF itself, and also to employ scripts in other bSF languages,
             sharing the BSF registry with the running Rexx script

- Apache BSF package: now using a version of Apache's BSF that does not need commons-logging
             (org.apache.commons.logging) present anymore

-------------------------------------- 2006-11-19 ----------------------------------
- RexxAndJava.java: rgf, added behaviour to treat "netrexx.lang.Rexx" objects exactly the
             same as "java.lang.String"

- BSF4Rexx.cc: rgf, added function 'BsfShowErrorMessage(0|1)'; if set to '0' (.false), then
             in case of a Java exception no error message is printed automatically anymore;
             the Rexx variable 'BSF_ERROR_MESSAGE' will contain in either case the Java
             exception message for further inspection

-------------------------------------- 2006-10-17 ----------------------------------
- BSF.CLS: - rgf, renamed the BSF method "DISPATCH" to "BSF.DISPATCH" to avoid name-clashes
             with Java methods named "DISPATCH"

-------------------------------------- 2006-08-01 ----------------------------------
- BSF.CLS: - BSF.WRAP() adjusted to process beanNames that have two
             hexadecimal values after '@', delimited by '_': this has
             been added to 'RexxAndJava.java' to handle constructors
             for which Sun's Java produces identical (!) hashCode() values!

-------------------------------------- 2006-07-22 ----------------------------------
- BSF.CLS: - cleaned program from outdated code, that was already commented out

-------------------------------------- 2006-07-11 ----------------------------------
- BSF.CLS: - added method "DISPATCH" to class "BSF" (as in OLEObject starting with ooRexx 3.1),
             will be forwarded to method BSF.INVOKE

-------------------------------------- 2006-07-04 ----------------------------------
- BSF.CLS: - added method "ENTRY" to "JavaStaticFields.Directory"

          "Easter egg":

          2006-03-22, rgf: - added methods "[]", "AT", "[]=", "PUT" and making directory cache for retrieval
                             optionally to "JavaStaticFields.Directory"

          2006-03-21, rgf: - "JavaStaticFields.Directory:unknown": made sure that cached value is returned,
                             instead of looking up the Java side constantly

          2006-03-20, rgf: - removed a bug from "JavaStaticFields.Directory" reported by Lee Peedin
                             (Java class name was stored in an ooRexx class attribute instead of an
                             instance attribute); changed logic a bit, now that the Java calss name is
                             handled by an instance attribute (no need for dynamically setting the
                             unknown method)

          2006-02-05, rgf: - allowing assignments to static Fields if wrapped with 'bsf.wrapStaticFields'


-------------------------------------- 2006-05-29 ----------------------------------
- RexxAndJava.java: fixed a bug in coercing Rexx Boolean and Character arguments; was
             using the BSF type converters which in this case are too relaxed; now
             one needs to strictly supply the Rexx Boolean values (0=false, 1=true),
             and for char/Character exactly one character is allowed to be passed;
             this fixes the sometimes wrong behaviour for "java.io.PrintBuffer" where
             the wrong "println()" method was picked;

             in general: one can always use the "bsf.invokeStrict" subfunction or
                         BSF method to explicitly supply the type of the arguments
                         for determining the signature of the desired method

-------------------------------------- 2006-03-08 ----------------------------------
- BSF.CLS: - .bsf~bsf.import(): now allows storing references to already created Java class object
             proxies in .local

-------------------------------------- 2006-03-03 ----------------------------------
- BSF.CLS: - fixed BSF's class method and also the public routine named "bsf.postEventText"
             to use the optional priority value (0=low, 1=normal=default, 2=high)

-------------------------------------- 2006-03-03 ----------------------------------
- BSF.CLS: - added routine "bsf.import(...)", a wrapper for ".bsf~bsf.import(...)"

-------------------------------------- 2006-02-24 ----------------------------------
- BSF.CLS: - added method 'bsf.addEventListenerReturningEventInfos',

           - the private class "bsf_array_proxy.assure_BSFRegistry_Removal"
             which makes sure that the eventObject gets removed from the BSFRegistry by
             repeating "unregisterBean" until the Java object is removed from the registry

           - routine bsf.getEventInfoObject, must be called exactly once on eventText
             strings that are returned because of employing 'addEventListenerReturningEventInfos';
             this will create a BSF proxy object for the eventObject

- RexxAndJava.java: - added subfunction 'addEventListenerReturningEventInfos'

- org.apache.bsf.utils.EngineUtils.java: added method 'addEventListenerReturningEventInfos'

- org.apache.bsf.utils.BSFEventProcessorReturningEventInfos.java:
           - new class to process events such that BSFEngine.apply() is invoked with the
             event arguments and in addition gives the name of the event that gets processed

-------------------------------------- 2006-02-21 ----------------------------------
- RexxAndJava.java: fixed a bug in handling event text strings

-------------------------------------- 2006-02-15 ----------------------------------
- RexxAndJava.java: fixed a Java bug (not allowing invoking public methods of
        objects of non-public classes via reflection; e.g. Enumeration inner classes)

-------------------------------------- 2006-02-07 ----------------------------------
- RexxAndJava.java: fixed a bug in the new method lookup code (caused an eternal loop,
        if method not found)

- "setupBSF4Rexx.rex" on Linux: created shell script "installBSF4Rexx.sh" now blindly
        adds the invocation of 'setEnvironment4BSF4Rexx.sh' to the bash resource
        config file (~/.bashrc), decorating the entry with a self-explanatory comment;
        you need to remove the entry by hand from '/.bashrc' (if you have code that
        was able to remove the entry upon running 'uninstallBSF4Rexx.sh' and want to
        share it, please send it)

-------------------------------------- 2006-02-05 ----------------------------------
- RexxAndJava.java:
        - now invoking methods without BSF, added logic to refer to java.lang.Class
          methods from class objects; rigidly allows access to methods with modifier
          'public' only (for security reasons)
          logic: - find methods having sought for name, check whether Rexx args can
                   be coerced to the needed parameter types
                 - if a class object and method was not found: use Class' class object
                   to find method, and if found use original object to invoke method for

- org.oorexx.misc.RgfFilter:
        - added 'public' keyword to class to allow access to its members/methods

-------------------------------------- 2006-02-03 ----------------------------------
- BSF.CLS:
        - added routine 'bsf.wrapStaticFields' which returns an instance of
          "JavaStaticFields.Directory" (a subclass of the Object Rexx
          directory class), which allows easy access to the static fields of the
          given Java class/interface by merely sending the name of the static
          field as a message or using the AT method to access them
        - added entry "VERSION" in .BSF4REXX (returns "142.20060203", ie. version 1.43
          as of "2006-02-03"

- BSF core (BSF framework itself):
        - fixed a bug in generating event adapters dynamically;
        - added code to deal with OpenOffice.org EventListeners (they do not carry
          the information that java.util.EventListener is implemented, breaking standard
          reflection BSF uses), so now OOo event listeners can be employed as well

-------------------------------------- 2006-01-28 ----------------------------------
- BSF4Rexx.cc: now creates a Java exception, if a Rexx execution error occurs; the
        Java exception gets the Rexx error messages, which allows Java programs to
        retrieve the full Rexx error text and parse e.g. the line number in which the
        Rexx error occurred

- BSF4Rexx.cc: Java string arguments for invocating Rexx programs are now
        converted to native strings using the (Java's) current codepage setting

- org.rexxla.bsf.RexxDispatcher.java: removed last traces of (older) IBM BSF,
        fixed an error in argument passing, explicitly showing the Rexx error
        text supplied with a raised Java exception by BSF4Rexx


-------------------------------------- 2006-01-22 ----------------------------------
- BSF4Rexx.cc: fixed conversion from Java strings to local (single-character) strings,
        now umlauts etc. are converted using the codepage setting of the thread

-------------------------------------- 2006-01-17 ----------------------------------
- org.apache.bsf.BSFManager: added getVersion(), returning the version number of BSF
        as a string formatted as "abb.yyyymmdd", where "a" is the major version number,
        "bb" the minor versions number, "yyyy" the four digit year, "mm" the two digit
        month, and "dd" the two digit day

-------------------------------------- 2006-01-05 ----------------------------------
- BSF4Rexx.cc: fixed startup behavior for JVMs, now takes all Rexx startup arguments
  verbatimly (e.g. "-Djava.class.path=" some dirs); if no java.class.path is given
  in the startup values, then the value of the environment variable CLASSPATH is used,
  if available at all

- BSF.CLS: fixed bsf.import

-------------------------------------- 2006-01-05 ----------------------------------
- Changed in all BSF-Java, BSF4Rexx-Java and Rexx programs invocations of "Class.forName(name)"
  to "Thread.currentThread().getContextClassLoader().loadClass(name)"

- RexxAndJava.java: added subfunction "loadClass", preregisters now "java.lang.Thread"
  in the BSF registry

- BSF.CLS: added new class method and routine "bsf.loadClass", using that instead of
  the suboptimal "Class.forName()"

-------------------------------------- 2006-01-02 - 2006-01-05 ---------------------
- Added "setupBSF4.rex" to ease installing BSF4Rexx for users who have no working
  knowledge about Java whatsoever. The program creates three scripts:

        - bsf4rexx.sh (Linux) or bf4rexx.cmd (Windows):

          allows running BSF4Rexx scripts without installing BSF4Rexx as a Java extension;
          argument: name of Rexx file to execute and additionally, optional arguments for
          the Rexx program

        - installBSF4Rexx.sh (Linux) or installBSF4Rexx.cmd (Windows):

          installs BSF4Rexx as a Java extension; this will allow its usage from anyone
          and from any program;
          invoking Rexx programs will be possible via "rexxj.sh" (Linux) or
          "rexxj.cmd" (Windows)

        - uninstallBSF4Rexx.sh (Linux) or uninstallBSF4Rexx.cmd (Windows):

          these scripts allow removing BSF4Rexx as a Java extension from the system

  "setupBSF4.rex" allows for two optional arguments to be supplied:

        - fully-qualified path to the Java executable

        - fully-qualified path to a directory into which the Rexx-supporting scripts
          as well as the generated scripts should be copied to


- Added "setupOOo.rex" to create a script which sets the environment variable CLASSPATH to
  point to the OpenOffice.org/StarOffice Java archives. By doing so, one can fully script
  OpenOffice.org via BSF4Rexx.

- Added "setupJava.rex" to create the needed links to Java in /usr/bin and /usr/lib
  on some Unix systems

- Added additional ooRexx support modules to the distribution to ease interaction with
  OpenOffice.org considerably.

- Added the datergf-Java classes to ease date manipulation and formatting.


-------------------------------------- 2005-07-30 ----------------------------------
- Restructured distribution archives to make it easier on users

  - Adapted "readmeBSF4Rexx.txt" to reflect new distribution archives

- Re-built OS2-, Linux- and Windows-DLLs


-------------------------------------- 2005-07-30 ----------------------------------
- RexxAndJava.java: added pp() for formatting debug messages

- BSF.CLS: fixed a bug in the creation of Java arrays: now pre-registered names (entries in
           .bsf4rexx) and any other Java class object proxy can be used to indicate component
           type for the Java array

-------------------------------------- 2005-07-09 ----------------------------------
- BSF.CLS: added public routines for easing access to frequently needed functionality:

        - bsf.lookupBean(beanName)

        - bsf.unregisterBean(beanName)

        - bsf.pollEventText([timeout])

        - bsf.postEventText(text)

        - bsf.getStaticValue(className, fieldName)

        - bsf.getStaticValueStrict(className, fieldName)

           alias:

          bsf.getConstant(className, fieldName)

-------------------------------------- 2005-07-07 ----------------------------------
- RexxAndJava.java: fixed a bug in converting {b|B}oolean values

- BSF.CLS: renamed 'bsf.checkResult' to 'bsf.wrap'

-------------------------------------- 2005-06-18 ----------------------------------

- RexxAndJava.java: added "new" and "newStrict" as synonyms for "registerBean" and
           "registerBeanStrict"; fixed a bug (not checking for interfaces in class
           String); corrected SGML comments, such that FireFox will display or entries
           in the table of subfunctions in the javadocs

-------------------------------------- 2005-06-11 ----------------------------------
- BSF.CLS: now class object proxies allow for BSF-instance messages like "bsf.getFieldValue"

- Apache BSF: downloaded original Apache code, applied bug-fixes and changes and commited
           those with the Jakarta-BSF distribution at svn.apache.org; double-checked and
           had it reviewed with another Jakarta-BSF developer

- RexxAndJava.java: now handles case of interface classes for accessing static field
           values transparently (as if it was a normal Java class)

-------------------------------------- 2005-06-07 ----------------------------------
- BSF-packages: fixed 'EngineUtils.java' bug in IBM's and Apache's BSF-package

- RexxAndJava.java: made error (exception) messages from invoked Java methods easier ledgible
           to non-Java programmers (no Java stack-trace, instead exception message only shown)

- BSF.CLS: renamed BSF.BOX() to BOX() and BSF.UNBOX() to UNBOX() to make coding easier


-------------------------------------- 2005-06-05 ----------------------------------
changes of 2005-06-05, 2005-06-06 version, --rgf

- BSF.CLS: renamed all BSF-pass-through class methods to start with "BSF."; this
           way it is always clear that the BSF4Rexx interfaces are addressed

           BSF-class methods: name changes
           -------------------------------

           createArray          --> bsf.createArray
           exit                 --> bsf.exit
           getStaticValue       --> bsf.getStaticValue
           getStaticValueStrict --> bsf.getStaticValueStrict
           import               --> bsf.import
           lookupBean           --> bsf.lookupBean
           pollEventText        --> bsf.pollEventText
           postEventText        --> bsf.postEventText
           setRexxNullString    --> bsf.setRexxNullString
           sleep                --> bsf.sleep
           wrapArray            --> bsf.wrapArray
           wrapEnumeration      --> bsf.wrapEnumeration


- BSF.CLS: BSF-class method "bsf.import": change in the order of arguments!
           ----------------------------------------------------------------

           Arguments got switched, "RexxName" argument is now optional:

              import(RexxName, JavaFullClassName)

           was changed to:

              bsf.import(JavaFullClassName [, RexxName])

           If "RexxName" is not given, then the Java class name is used as the ooRexx
           class name for storing it in .local; if "RexxName" is .nil, then no entry
           in .local will be created

- BSF.CLS: all imported Java classes can be instantiated with "newStrict()", which
           allows indicating the datatype in front of every argument, if necessary

- BSF.CLS: sending messages to the BSF Java class object proxy now behaves the same
           as sending ooRexx messages to BSF Java object proxies: the (static) methods
           are resolved and dispatched; hence no need to instantiate a Java class just
           to get at its static methods (or static fields for that matter)

- The "test" and "sample" Rexx programs have been updated accordingly.


-------------------------------------- 2005-06-05 ----------------------------------
starting with 2005-06-05, brief infos about changes are recorded in here, ---rgf

