NetRexx Changes

| NetRexx Change History

### NetRexx 2.01

This release is the reference implementation for NetRexx 2, and requires Java 1.1.2 (or later) to run. NetRexx 2 releases are a superset of NetRexx 1.00, as published in The NetRexx Language. New language features since NetRexx 1.00 are documented in the NetRexx Supplement.

Updates: |
2.02 [22 May 2001] | This is a maintenance release; `loop i=a to b until x` incorrectly optimized the control variable test in some circumstances. No other changes are included.
2.01 [1 Apr 2001] | This is a maintenance release which corrects excessive memory usage when large numbers of files are imported and the -prompt option is used. No other changes are included.
2.00 [26 Aug 2000] | This is a major new release, which consolidates the changes of NetRexx 1.1 and adds the NetRexx interpreter and improved documentation. The enhancements are: The various installation and user documents have been consolidated into a new expanded and indexed User's Guide, available in both HTML and PDF (Acrobat) formats. The reference implementation now includes the NetRexx interpreter, which allows programs and classes to be run without being compiled, together with a new API which makes it easy to use the interpreter from NetRexx or Java applications. The new -prompt option, which lets the translator be used repeatedly without requiring re-loading. This allows sub-second compilation and interpretation of NetRexx programs. The structure of the NetRexx package has been revised to make installation and maintenance simpler. Shell scripts for Linux have been added. Please see the new User's Guide for details. The Language Overview (quick start) has been updated and is now also available in PDF (Acrobat) format for viewing or printing. A warning is now given if a private method in a class is not referenced. The compact option for compact error messages has now been documented (see the NetRexx Supplement for details). The documentation was inconsistent as regards the file name generated when -nocompile was specified; the intent was that NetRexx should never leave a plain `.java` file on disk, as this prevents the next compilation if unprocessed. The documentation and code have been fixed to ensure that -nocompile exactly implies -keep. Several performance optimizations have been added.

### NetRexx 1.1xx

The following changes are those which were made in NetRexx 1.1xx releases. NetRexx 1.1xx releases require Java 1.1.0 (or later).

Updates: |
- 1.160 [10 Feb 2000] | This release has some language enhancements, along with some problem fixes and other improvements: The if clause in the if instruction and the when clause in the select instruction have both been enhanced to accept multiple expressions, separated by commas. These are evaluated in turn from left to right, and if the result of any evaluation is 1 (or equals the case expression for a when clause in a select case instruction) then the test has succeeded and the instruction following the associated then clause is executed. Note that once an expression evaluation has resulted in a successful test, no further expressions in the clause are evaluated. So, for example, in:
      -- assume name is a string
      if name=null, name='' then say 'Empty'
  then if `name` does not refer to an object it will compare equal to null and the say instruction will be executed without evaluating the second expression in the if clause. Here is an example in a select case instruction:
      select case i
        when 1 then say 'one'
        when 2 then say 'two'
        when 3, 4, 5 then say 'many'
      end
The select case instruction will now generate a Java `switch` instruction under the right conditions. See the NetRexx Supplement for details. The new nojava option allows Java code generation to be inhibited. This can be used to speed up a syntax checking run, when no compilation or Java source code is required. Invoking NetRexxC with no arguments will now display all options, not just the 'outer level' options. The class `Exception` is now treated as a Checked exception (as Java does). Calls to `super()` in dependent classes may now be qualified by `parent.` as well as by constructor arguments, if appropriate. `.jar` files in the `/lib/ext` (automatic extensions in Java 2 [1.2]) are automatically added to the classpath. Classpaths containing multiple quoted segments are now handled correctly, and various other minor problems have been fixed. Several optimizations and improvements to formatting have been added.
1.151 [3 Sep 1999] | This refresh has some minor enhancements: The 'direct call from Java' entry points have been enhanced to allow paths with embedded blanks to be specified. See the User's Guide (Using the translator as a Compiler). Several improvements in code generation when incrementing and decrementing integers. This release has been tested under the first Java 1.3 beta; no problems were found and no changes from earlier NetRexx 1.1 releases were necessary.
- 1.150 [23 Jul 1999] | This release is a maintenance update with some minor enhancements: New unused modifier on the properties instruction may be used (in conjunction with private only) to indicate that a private property is not used. This keyword will stop the compiler warning that a property is not used. For example:
        properties private constant unused
          copyright="Copyright (C) Speleo Corp., 1999"
New strictprops compiler option requires that references to properties, even from within the same class as the property, be qualified (either by `this.` or the name of the class). This can be useful for large and complex classes. Several improvements in code generation, mostly for testing of equality. Calls to `this()` and `super()` in minor classes will no longer attempt to refer to generated constants.
- 1.148 [21 Dec 1998] | This release makes significant improvements in importing classes and in the select instruction: The select instruction now adds a case keyword, which lets an expression be evaluated once and then tested in each when clause. For example:
      i=1
      select case i+1
        when 1 then say 'one'
        when 2 then say 'two'
        when 3 then say 'three'
      end
See the NetRexx Supplement for details. An explicit class import will now disambiguate short references. For example, after `import java.awt.List` a reference to the class `List` would refer to that class, not the class `java.util.List` introduced in Java 1.2. Several improvements in code generation, including the treatment of small integers as, for example, `byte` without need for explicit casts. The format method in the `Rexx` class has been corrected to completely follow the ANSI X3-274 definition and the NetRexx specification.
1.144 [21 Oct 1998] | This maintenance release primarily allows more explicit control over the compiler, for working with 'minimal' virual machines. New strictimport compiler option prevents any automatic class imports (even java.lang.Object). This can be useful when compiling programs for reduced-function JVMs for embedded systems and palm-sized devices. The package `java.math` is no longer imported automatically. Occasional incorrect loop termination when trace is in use has been corrected.
1.142 [1 Sep 1998] | This version is a maintenance release, primarily to support changes in the Java Development Kit (JDK) introduced for Java 1.2. Please see the User's Guide for details for additions to the class path needed to run under Java 1.2. The other changes are: A type on the left hand side of an operator that could be a prefix operator (`+`, `-`, or `\`) is now assumed to imply a cast, rather than being an error. For example: `x=int -1` Improved code generation for for and to loops. The euro character ('\u20ac') is now treated in the same way as the dollar character (that is, it may be used in the names of variables and other identifiers). Note that only UTF8-encoded source files can currently use the euro character, and a 1.1.7 (or later) version of a Java compiler is needed to generate the class files. The arithmetic routines have slightly improved performance, and provide accurate binary floating point conversions for constants. More robust handling of import, and import from classpath root segments generalized. Improved error messages when an indirect property is initialized with a forward reference.
- 1. 1.140 [26 May 1998] | Three enhancements have been made to tracing: The new var option on trace lets changes to named variables be traced selectively. For example:
         trace var a b c
requests that whenever the variables a, b, or c are changed (either directly or using an index), the line changing them and their new values should be traced. Variables may be added to or removed from the list as required. The trace instruction may now be used before the first class instruction; it then applies to all classes in a program. Context is now shown while tracing – if a trace line is produced from a different program or thread than the preceding trace line, then an indicator line (prefixed with `---`) is displayed. See the NetRexx Supplement for details. The numeric instruction may now be used before the first class instruction; it then applies to all classes in a program. The new -savelog NetRexxC option requests that compiler messages be written to the file NetRexxC.log in the current directory. The messages are also displayed on the console, unless -noconsole is specified. The new -noconsole NetRexxC option requests that compiler messages not be written to the console. When calling the compiler directly from NetRexx or Java, a PrintWriter can now be provided; messages are then written to that stream (see the User's Guide for details). A catch clause may now specify an exception that is a subclass of an exception signalled in the body of its construct. The leave and iterate instructions may now be used in the catch and finally clauses of nested loops. Many improvements to the formatting of generated Java code have been made (plain-name labels, fewer braces, better comments handling, etc.). A constant indirect property may now be changed by methods in its class, though no `set` method for it is generated or permitted. Several performance improvements and optimizations have been added, improving both run time and compilation time. If you have a long CLASSPATH or many files in directories, you may see a 20% or better reduction in compile time. The NetRexxC.cmd and .bat files now add the value of the NETREXX_JAVA environment variable to the options passed to java.exe. For example, `SET NETREXX_JAVA=-mx24M` changes the maximum Java heap size to 24 MegaBytes. Try this if you see a java.lang.OutOfMemoryError while running the compiler. Several related problems with loading minor classes from directories and zip files have been corrected. Parentheses around sub-expressions were incorrectly optimized out in some situations; they are now preserved. A work-around for a problem caused by empty directories on the CLASSPATH in Linux has been added.
1.132 [15 Apr 1998] | This version includes one major enhancement: support for Minor and Dependent classes - Java's Nested and Member (inner) classes, using simplified syntax and concepts.
1.130 [8 Mar 1998] | The new copyIndexed method on the Rexx class allows the sub-values (indexed strings) of one Rexx object to be merged into the sub-value collection of another Rexx object [available in runtime since NetRexx 1.120]. The '$' character is now permitted in variable and other names. It is now an error to attempt to use a concatenate operator on an array (unless the array is of type char[]). The methods generated for indirect properties are no longer inhibited by methods of the same name in superclasses. The NetRexx Supplement has been updated to document changes since August 1997.
1.128 [14 Feb 1998] | The new linecomment example is a small command-line application that processes a text file. It demonstrates the use of Readers and Writers, and exception handling. A workaround for a bug in `javac` in JDK1.2b2 has been included. Retry of a failing do instruction as a loop instruction now works. '\1a' (EOF) characters no longer need to follow line-end sequences in order to be ignored. Import of package hierarchies from .zip or .jar files now works correctly (previously it only worked for the standard imports).
1.125 [10 Jan 1998] | The new sourcedir option requests that all .class files be placed in the same directory as the source file from which they are compiled. Other output files are already placed in that directory. Note that using this option will prevent -run from working unless the source directory is the current directory. The new explicit option indicates that all local variables must be explicitly declared (by assigning them a type but no value) before assigning any value to them. Indexed strings are now serializable (can be made persistent). Minor improvements to generated code.
1.122 [27 Nov 1997] | A workaround for a JIT bug in Java 1.1.4 (showing as an exception in an `optioncheck` method during compilation) has been included. Formatting for the Java code when the comments option is used has been improved. strictcase and nostrictcase programs can now be safely mixed in a single compilation. Minor improvements to generated code and performance.
1.121 [21 Oct 1997] | The new experimental comments option copies comments from the NetRexx source program through to the .java output file, which may be saved using the keep command option. Decimal addition has been updated to conform to ANSI X3-274 arithmetic and the NetRexx documentation (this is a very minor change: an addition such as 77+1E-999 now pads with zeros). An abstract method in an abstract class was incorrectly reported as error. Minor improvements to error messages, formatting, and performance.
1.120 [1 Sep 1997] | Minor improvements to error messages, signals handling, and performance. Redesigned web pages and improved documentation.
1.113 [3 Aug 1997] | Multiple .java files are compiled using a single call to javac, giving improved performance and interdependency resolution. Individual methods may be designated as binary, using the binary keyword. Numerous 'cosmetic' improvements in error messages, formatting, etc.
1.104 [22 Jul 1997] | Whole numbers may now be expressed in a hexadecimal or binary notation, for example: `0xbeef 2x81 8b10101010` - see the Supplement for details. Conversions from `String` to `Rexx` (etc.) now 'pass through' nulls, rather than raising `NullPointerException`. options symbols may be used to include debugging information (a symbol table) in the generated `.class` files. Numerous 'cosmetic' improvements in error messages, formatting, etc.
1.103 [3 Jul 1997] | A new modifier, adapter, for classes has been introduced. This makes it easy to use Java 1.1 events, without the complexity and extra nesting of Java Inner Classes. Please see the Supplement for details, and the new Scribble sample for a simple example. Compressed Zip files as produced by the Java 1.1 `jar` utility ('jar files') can now be used for class file collections. The current NetRexxC.zip file is such a file. The NetRexx string class, `netrexx.lang.Rexx`, is now serializable. The compiler now uses the Java 1.1 Writer and Reader classes for reading and writing text files; this means that the text code page in use on your machine will be automatically translated to and from Unicode for use by the compiler. Associated with the previous change, options utf8 must now be consistent with the options passed to the compiler (see the Supplement for details). The `NetRexxC.properties` (error messages) file is now included as a resource in the NetRexxC.zip file. The copy in the \lib directory is no longer needed, nor is the NETREXX_HOME environment variable (if you needed to use that before). The Pinger and Spectrum sample applications have been updated to use the Java 1.1 event model; Pinger has also had some other minor improvements. Performance improvements reduce start-up time when compiling with a long CLASSPATH or with class directories with large numbers of files.

### NetRexx 1.0x

This release is the reference implementation for NetRexx 1.00, as published in The NetRexx Language, and later updates. NetRexx 1.0x updates will run on Java 1.0.1 or any later releases, though certain new features may require a Java 1.1 compiler to compile the generated Java code.

A change list for earlier releases of NetRexx is also available.

Updates: |
1.02 [25 Jun 1997] | You can now add the shared keyword to the method or properties instructions to indicate that the method or a following property has shared access (that is, is accessible to other classes in the same package, but not to other classes). This corresponds to the Java 1.1 'default access' visibility. Please see the NetRexx Supplement for details. The new sourceline special name may be used to return the line number of the current clause in the program. Please see the NetRexx Supplement for details. Array initializers have ben added. These allow arrays to be created and assigned an initial value, for example: `x=['one','two','three']` Note that Java 1.1 is needed to use this enhancement. Please see the NetRexx Supplement for details. The property and method access rules have been enforced according to the current Java specification, along with enhanced error messages when the rules are infringed.
1.01 [15 Jun 1997] | The NetRexx Supplement has been added. This documents language enhancements and the `netrexx.lang` package. NetRexxC now displays a warning when it encounters any deprecated (out-of-date or no longer recommended) class, method, or property for the first time in a program. Note that under Java 1.1, the javac compiler always displays at least one message if any deprecated fields or classes are encountered. The invitation to 'Recompile with "-deprecation" for details' can be ignored. You can now add the deprecated keyword to the class, method, or properties instructions to indicate that the following class, method, or properties are deprecated. You have to run with a Java 1.1 compiler for this to be reflected in the `.class` file. Methods and properties with the same name are now permitted (and can be accessed). An import of one of the standard packages (for example, `java.io`) no longer causes the classpath to be searched. This makes redundant standard imports much faster.
1.00 [24 May 1997] | Cosmetic changes: Methods listed during compilation now have their argument types listed (if any) Methods generated from Indirect Properties are now listed. The installation instructions now include instructions for using NetRexx with Visual J++. A reference to java.awt.image.ImageObserver treated java.awt.image as a class reference rather than as a package name; it will now correctly refer to the ImageObserver class.
[6 May 1997] | Multiple file concurrent compilation: when two or more programs are specifed on the NetRexxC command, they are all compiled with the same class context: that is, they can 'see' the classes, properties, and methods of the other programs being compiled, much as though they were all in one file. This allows mutually interdependent programs and classes to be compiled in a single operation, while maintaining their independence (the programs may have different options, import, and package instructions). Compiling programs together in this way also gives substantial performance improvements, as the classes for NetRexxC and the javac compiler are only loaded once for all the files being compiled. See Using the translator as a Compiler in the NetRexx User's Guide for full details. The warning 'Method argument not used' will now only be given if the strictargs option is specified. The '.crossref' and '.java.keep' files resulting from a compilation now are placed in the same directory as the source file (instead of the current directory). The multiple compilation support also requires that the source directory be writeable. import of a package (with no trailing period) was not accepted by the compiler; this should now work correctly.
[15 Apr 1997] | Preliminary, experimental, support for JavaBeans is now available in the NetRexxC compiler. It is described in the NetRexx Supplement. Checking has been added for the use of Java reserved words as externally visible names (such properties, method, and class names cannot be accessed by people writing in the Java language). The translator phase of the compiler has numerous performance improvements, and now runs 35% faster than the first (January) 1.00 release. Forward references from property initialization expressions to methods in the current class are now permitted, providing they are not circular. Several improvements have been made to error and progress messages.
[13 Mar 1997] | The source and documentation for the Tablet (navigation tabs) applet have been added to the package. Forward references involving default constructors now work correctly. The `.equals` method was not being used for '=' and '\=' comparisons of subclassed objects. options nodecimal may be used to report the use of decimal arithmetic as an error, for performance-critical applications.
[18 Feb 1997] | Minor improvements to the compiler for error messages, localization, and Java 1.1. The Say instruction can now handle all expressions that evaluate to `null`.
[6 Feb 1997] | LOOP OVER did not correctly snapshot indexed strings with 'hidden' elements. Some unused method arguments were not being reported as unused. Minor improvements to error messages, progress messages, and code generation.
[3 Jan 1997] | Minor cosmetic and performance improvements over 0.90. NetRexxC.bat and nrc.bat have been added to the NetRexx package.

[ IBM | Help | Legal | Privacy ]