-------------------------------------- 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 - 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 "" (string is index into BSFRegistry to address a Java object) or "" (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 ("": following string is an index into the BSFRegistry; "": 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 "" and "" 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