NetRexx Changes - 0.xx

| NetRexx Change History - 0.xx

This document lists the changes in NetRexx prior to NetRexx 1.00.
[ 1.00 | 0.90 | 0.88 | 0.86 | 0.84 | 0.82 | 0.81 | 0.77 | 0.76 | 0.75 | 0.67 | 0.54 | 0.50 ]

### NetRexx 1.00 [3 Jan 1997]

This release is the reference implementation for NetRexx 1.00, as published in The NetRexx Language.

- Minor cosmetic and performance improvements over 0.90.
- NetRexxC.bat and nrc.bat have been added to the NetRexx package.

### NetRexx 0.90 [17 Dec 1996]

This release is the 'gamma' release prior to NetRexx 1.00. The main changes are in packaging and installation.

- The compiler name and classes have been moved from the netrexx.process package to the COM.ibm.netrexx.process package, to comply with the Java language recommendations. The compiler name is therefore now `COM.ibm.netrexx.process.NetRexxC`.
- The compiler and runtime classes are now packaged in a Zip file that lets them be used directly by Java without unzipping the individual classes. To use the Zip file in this way, it must be included in the CLASSPATH setting – see the User's Guide.
- A similar Zip file, with just the runtime classes, is also included, for those who need to distribute these with some other program.
- The cross-reference listing is now written to a separate file (xxx.crossref) instead of to the standard output stream. This makes it easier to see errors and warnings.
- Reports of variables that are set but not used are now reported as Warnings, rather than as incidental information at the end of the cross-reference listing.
- A defined entry-point in NetRexxC allows the compiler to be invoked directly from NetRexx or Java programs.
- Several cosmetic improvements, notably to tracing of loop instructions.

### NetRexx 0.88 [1 Dec 1996]

With this release the full function intended for NetRexx 1.00 is available.

- The power operator (for both the `Rexx` class and primitive types) is now implemented.
- The `format`, `insert`, `overlay`, and `trunc` methods of the `Rexx` class are now implemented.
- Conversion from `double` to a string now provides 15 digits of precision instead of the 6 digits supplied by Java.
- Tracing of loop instructions has been improved, and other cosmetic changes have been made to messages and other compiler output.
- Forward references from the class instruction to other classes in a program are now permitted.
- The generated Java source code no longer includes import instructions (i.e., all class references are now qualified).
- options compact may be used to request compact warnings and error messages, intended for use by editing environments. Please consider this an 'experimental' option; the format may change.

### NetRexx 0.86 [14 Nov 1996]

The major change in this release is the new error message processing.

- The NetRexx compiler now has the completely new error message processing that has been 'in the works' for some time. Error messages should now be much more helpful, and (where useful) more than one error message may be produced during a compilation.
- Error messages are held in a separate file (NetRexxC.properties), which allows for translation. This file will be installed automatically in the Java 'lib' directory when the NetRexx compiler is installed (if you don't have access to the Java 'lib' directory, an alternative path can be identified – see the NetRexx installation document).
- Interface classes should now use the implements keyword for extending other interface classes, because in the .class files, all interface classes must extend java.lang.Object. This change also allows interface classes to extend more than one other interface class. The extends keyword will continue to work for a single class (for the time being), with a warning.
- Various problems with import and qualified class references have been resolved; in particular, you should now be warned about ambiguous class references again.
- options trace1 may be used to redirect trace output to stdout instead of stderr. Please consider this an 'experimental' option.

### NetRexx 0.84 [29 Oct 1996]

- Local variables now have a defined initial value, consistent with properties (variables of primitive type are initialized to 0, all others to `null`).
- The `Rexx` class now has a new `sequence(final)` method for generating a sequence of characters. This serves the same purpose as the Rexx and Object Rexx `xrange` function.
- The `compare`, `delstr`, `delword`, `d2x`, `translate`, and `x2d` methods of the `Rexx` class are now implemented.
- The values of method arguments are now traced, for trace all and trace methods.
- The numeric instruction is now allowed in binary classes.
- Terms may now start with numeric symbols (for example, `12.max(i)`).
- Interface classes may now be extended, and methods in Interface classes may now have Signals lists.
- The `source` and `version` special words now always return strings of class `Rexx`.
- Many improvements and clarifications in the documentation.

### NetRexx 0.82 [26 Sep 1996]

- Unicode characters (accented characters, non-arabic numerals, etc.) are now allowed for identifiers (variable and other names) and numeric symbols (numbers in programs). By default, characters in the source file are assumed to be in the "Latin-1" character set (the first 256 Unicode characters).
- The new utf8 option indicates that the source file is encoded with UTF-8 encoding. This allows the full range of up to 65536 Unicode characters to be used in NetRexx programs (including in literal strings and comments). To make best use of this you'll need an editor or utility that can produce files in UTF-8 format.
- The `upper` and `lower` methods of the `Rexx` class have been extended to allow uppercasing or lowercasing of substrings.
- The `Rexx` class has now got a new `exists(name)` method for testing whether an indexed variable called name exists. Also, an indexed variable can be 'reset' (or 'dropped') by assigning `null` to it, for example:

        fred='?'      -- fred.exists('3') is now 0
        fred[3]='abc' -- fred.exists('3') is now 1
        fred[3]=null  -- fred.exists('3') is now 0

- Improved error messages.

### NetRexx 0.81 [7 Sep 1996]

- The translator now parses `.class` files directly, so no longer uses the `Agent` debugging class. This gives the translator full information about classes and methods, and has allowed the removal of several restrictions.
- The translator can now track 'checked exceptions', and will automatically add those that are not caught to the signals list for each method. When this is done, the added exceptions are listed by the translator.
- options strictsignal causes checked exceptions that are not caught to be treated as an error (as in Java).
- The following methods in the `Rexx` class are now implemented:

      b2x, x2b, x2c, c2x, max, min

- The `abs` method in the `Rexx` class no longer rounds to nine digits.
- The verbose settings have been reworked to reduce the amount of output that the translator produces (though all the previously generated information is still available at verbose4 or verbose5).
- Methods that override methods in superclasses or interfaces now list the overridden or implemented methods. Additional checking, as required for Java, reports mismatches of the return types of overridden methods, etc.
- Using a variable name that matches (hides) the name of a Type that has previously been referenced as a type by a short name now gives a warning (this will probably change to be an error, later).
- Attempts to subclass (extend) private or final classes are now reported as errors.
- 'Unreachable' statements are now reported, as in Java.
- A method called '`main`' with argument type '`String[]`' is assumed static. This now produces a warning.
- When '=' or '\=' are used to compare two objects that are unknown to NetRexx (i.e., not strings), the Java '`equals`' method is used for the comparison. '==' and '\==' check for identical objects, as before.
- The translator now exits with a return value of 2 if an error was detected, 1 if a warning was displayed, and 0 otherwise.

### NetRexx 0.77 [26 Aug 1996]

- New uses keyword on the class instruction lets you specify one or more classes that will be used as a source for static methods and properties. For example, if your class is called Fred, then after

      class Fred uses Math

  you can refer to the properties and methods in the class `java.lang.Math` simply by name, without qualifying them by the class name. For example:

      say sin(PI/4)

- Case-insensitivity is now fully implemented. It is no longer necessary to use the exact case for external classes and methods (unless you want to, see below). For example you can invoke the `reverse()` method in the `Rexx` class using any of:

      'data'.reverse
      'data'.Reverse
      'data'.ReVerse

- Options strictcase can be used to enforce strict case checking (for local variables, methods, and properties as well as for external methods and properties), for those that prefer it. When in effect, all name matches must be exact.
- Improvements to Trace: for example, all assignments are traced, with changed trace tags to indicate the type of variable being set.
- New methods in the Rexx class: `d2c()` and `c2d`.

### NetRexx 0.76 [13 Aug 1996]

Changes:

- Three-pass processing allows forward references from properties and methods to later classes in the same program.
- New 'Methods for Rexx strings' section in the Language Specification
- Minor improvements to and tuning of Trace.

### NetRexx 0.75 [7 Aug 1996]

- The first draft of the NetRexx Language Specification is now available in online (HTML) format and in printable (PDF) format.

  This specification will be published by Prentice-Hall as part of a new book, "The NetRexx Language", later this year.

- NetRexx now has a new trace instruction for tracing method arguments, clauses, and results (including arguments passed to methods) during execution. Associated with this are options notrace and the trace special word.
- numeric form engineeering is now implemented.
- The static option has been added to the properties instruction, to allow for static properties that are not constant.
- The unpopular constant keyword on the method instruction has been renamed static, to align with the properties instruction. constant will continue to be accepted (with a warning) for a few months.

### NetRexx 0.67 [27 Jun 1996]

- The compiler is now entirely written in NetRexx, and so should run on all platforms that support the Java toolkit. It calls the javac compiler by direct method invocation, and typically runs about ten times faster than before (the current slow spots are (a) reading large classes.zip files and (b) loading classes).

  This level of NetRexx (0.67) should be a functional superset of the final 0.62 OS/2 translator, though there is one small language change.

- There is one language change: items of type '`char`' are now treated as a single-character string, rather than as a number representing the encoding of the character. This avoids anomalies between binary and non-binary classes.

  For those programs that do need to get at the bit representation of numbers, primitive constructors are introduced, for example:

      c=char 'M'    -- c is the character 'M'
      i=int(c)      -- i has the value 77
      d=char(i)     -- d is now 'M'

- the for keywords on loop are now implemented, as in

      loop for 3000; say 'hi'; end
      loop i=n by for 10 while j<10; j=n+i; end

- the over keyword on loop is now implemented; this allows easy traversal through the contents of NetRexx indexed variables. For example:

      /* display the contents of myvar indexed Rexx variable */
      do tail over myvar
        say myvar[tail]
        end

  loop over can be used with any subclass of `Rexx` or of `Dictionary` (for example, `Hashtable`).
- Invalid do syntax is re-tried as a loop instruction, after a warning.
- A list highlighting variables that are referenced only once is included in the variables cross-reference.

### NetRexx 0.54 [30 Apr 1996]

- This release is a minor update to the translator, except for the addition of a fairly substantial example of a Java application written in NetRexx. See:

      http://www2.hursley.ibm.com/netrexx/pinger.html

  for a picture of how it looks. You can use this application without downloading the whole NetRexx package.

### NetRexx 0.50 [22 Apr 1996]

The first non-IBM release of NetRexx – the OS/2 Rexx prototype.

[ IBM | Help | Legal | Privacy ]