New features in the Timber compiler

New features in Timber 2.0.1 compared to 2.0

Timber 2.0.1 was released 13 December 2002.

• The elements of an array are no longer stored in a separately allocated block, but start immediately after the array descriptor.
• When a program never catches a null pointer or bounds violation exception, generate a special handler that does an exit() instead of throwing an exception, and take this into account in in the program analysis.
• Other optimizations to generated code.
• Improved language compatibility.
• Added an 'uninstall' make rule.
• Added support for MacOS X.

New features in Timber 2.0 compared to 1.6

Timber 2.0 was released 28 March 2002.

• Compilation of parallel programs is now officially supported. The communication libraries PVM, MPI-lam and MPI-mpich are supported. There are some limitations; see the README in the distribution.
• Further modifications to the compiler to improve language compliance.

New features in Timber 1.6 compared to 1.5

Timber 1.6 was released 21 November 2001.

• Some modifications to the compiler to improve language compliance.
• Some performance improvements.

New features in Timber 1.5 compared to 1.4

Timber 1.5 was released 23 October 2001.

• A lot of tuning has been done to improve the analyzer, resulting in better performance for a larger set of programs. For example, an attempt is made to do static garbage collection, by letting the compiler insert __delete statements for objects that are known to be garbage. This currently almost never works for class objects, but for arrays it works better. In many cases, significantly more efficient programs are generated.
• This version of the compiler uses the new analyzer treewalkers in Tm version 2.0.8. It may be necessary to get a new version of Tm from the Tm website.
• The Jacks compiler validation suite has been applied, and a lot of small details have been modified to be more conformant with Java. The current score is comparable to that of the Sun Java compiler.
• The compiler now contains parallelization engines (in the directory 'engines'). The portability and documentation of these engines does not yet meet our quality requirements, so for now these engines must be considered experimental. We plan to release a working parallelizing compiler in the near future.

New features in Timber 1.4 compared to 1.3

Timber 1.4 was released 22 March 2001.

• Inner classes, as described in the Java Language Specification version 2, are now supported.
• The Spar language extensions are now only supported in files ending with .spar. For files ending with .java the compiler behaves as much as possible like an ordinary Java compiler.
• Timber 1.4 works with (and requires) version 1.0.6 of the Kaffe runtime library.
• Various bug fixes and performance improvements.

New features in Timber 1.3 compared to 1.2

Timber 1.3 was released 24 Jan 2001.

• The compiler is now called the 'timber' compiler, to stress that there is a difference between the language name Spar/Java and the compiler that implements it. The command to compile Spar/Java programs is still 'spar'.

  (And yes, we're not yet fully consistent in this.)

• The Timber downloading page now also allows subscribing and unsubscribing to the Timber announcements mailing list with one button click.
• Vnus now also does analysis and optimizations. In particular, it does optimization and elemination on null pointer checks and bound checks.
• Added the --nogc and a --strictanalysis flags.
• Added a more efficient nullednewarray construct to Vnus for arrays that are supposed to be initialized to null.
• The rank of an array can now also be specified as a compile-time constant. That is, type declarations like `int a[*^2]' are now also allowed.
• When new-ing an array, the shape can now also be specified as a vector expression, by using an explicit '@'. Thus:

   
    [int^2] v = [10,20];
    int a[*^2] = new int@v;

  is now supported.
• Spar no longer supports the methods setSize, setRoom, and fitRoom on arrays.

• Added a spar.util.Vector type that is similar to java.util.Vector, but parameterized with the element type of the vector. This replaces the setSize methods on normal arrays for the 1-dimensional case (which is by far the most common).

  This spar.util.Vector is used internally to represent the pool of internalized Strings, and thereby serves as a (used) example of a user-defined array representation.

New features in Spar 1.2 compared to Spar 1.1

Spar 1.2 was released 20 Nov 2000.

• The Spar compiler and its documentation now use the second edition of the Java Language Specification (JLS2 for short) as reference. Inner interfaces work, but inner classes do not work.
• Improved checking of programs, including checking of the 'throws' clauses of methods.
• A lot more agressive analysis of code is done, including 'final' analysis of formal parameters and local variables. This often results in significantly more efficient code.
• Inline methods no longer allow type parameters. This feature was of dubious value, and caused considerable implementation problems. A workaround is to use generic types, since generic types still support type parameters.
• Preparations have been started to support garbage collection. The run-time administration that is needed is already generated, and it is good enough to allow garbage collection on some programs. Unfortunately it is not good enough to work on all programs. Nevertheless, the run-time adminstration is there, and should give a very accurate indication of the eventual garbage-collection administration overhead.
• Lots of bug fixes.

New features in Spar 1.1 compared to 1.0.4

• Added support for the do-it-yourself infix operator. That is, anywhere you write add(a,b) it is now also allowed to write a \add b.
• Spar is now available for downloading from the Spar website.
• Tuple widening conversion and tuple narrowing conversion are now defined and implemented.
• Lots of minor changes to make the software more portable.
• The compiler now requires at least Tm version 2.0.7 (Use 'tm -h' see which version you have).
• The macro keyword has been renamed to inline, and is now officially supported. There are at the moment some restrictions, though.
• Subscript operations on objects are now transformed to calls to getElement or setElement.
• Fixed a bug that caused incorrect code for a continue statement in classical for() loops and while(){} loops.
• continue is now also supported for cardinality loops.
• Null pointer exceptions are now thrown in all cases.
• Class and interface parameters must be surrounded with (| and |), both for formal and actual parameters.
• More strict error checking:
  • Local declarations cannot hide other locals or formal parameters.
  • No type formal parameters in normal functions and constructors.

Spar 1.0.4 was an internal release that has never been available for downloading.

Last modified Sat May 13 15:50:56 2017 UT by Kees van Reeuwijk.