-------------------------------------- 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


