StrategoXT 0.9.3

StrategoXT 0.9.3 is released on September 1, 2003.



Source tar.gz

Source RPM

Redhat Linux RPM

Redhat 8.0:

Redhat 9.0:

SuSE Linux RPM

SuSE 8.2:

Development Snapshot

See Latest Sources? for information on how to obtain the latest developments (at your own risk).


StrategoXT is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This software is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.


Please report any problems with installation or bugs in the implementation to the stratego-bugs mailing list. Please check the archive of the list to see if a report about the problem was already submitted.


Besides the dependence on the aterm-2.0 and sdf2-1.6, StrategoXT has the following dependencies:

The Stratego Compiler depends on

  • gcc (the extension of C with nested functions)

The build of the source distribution depends on the following software packages

  • gmake

Developers who need to rebuild Makefiles and the configure scripts will need

  • automake 1.6
  • autoconf 2.53



The StrategoXT distribution consists of the following

Previous Releases


From the NEWS file

StrategoXT 0.9.3 -- released September 1, 2003

This release is dedicated to refactoring and improving the Stratego

The name of the Stratego compiler was changed to strc. In this release
sc is still available as a redirection to strc, but will no longer be
available in the next release. The Stratego interpreter has been
renamed to stri.  These changes where necessary because of name
clashes with other programs on some platforms. Packages based on
autoxt do not need to make any changes; the renaming is reflected in

Large parts of the Stratego Standard Library have been adapted to make
use of the xDoc comment convention such that better documentation can
be generated. Documentation for the SSL generated with xDoc will be
distributed separately such that improvements in xDoc can be reflected
in the generated documentation. An online version of the documentation
is available via the stratego website.

The syntax of primitive calls has been extended to allow passing
strategies to primitives. Thus, in the call prim("foo", s1, s2 | t1,
t2), primitive foo is called with strategy arguments s1 and s2 and
term arguments t1 and t2.  Similarly, terms can be passed to strategy
operators using the same syntax.  Thus, bar(s1, s2 | t1, t2) passes
strategies s1 and s2 and terms t1 and t2 to strategy bar. Note the
difference between foobar(!t), which passes a strategy that will build
t, and foobar(|t), which will pass term t. The first can be considered
as call be name, the second as call by value. The distinction becomes
clear when considering side-effects; foobar(new), will generate a new
unique string on each invocation of its argument strategy, while
foobar(|<new>), will copy the same unique string to each use of its 
term argument.

Related to this extension is a change in the calling convention of
generated C code. The current term is now the last argument of
generated C functions, rather than the first. This has no effect on
most Stratego programs, except for strategies with higher-order
arguments which explicitly declare the type of those arguments. 
Definitions of the form

  foo(f : a * (b -> c) -> d) =  ... f(s) ...

should be changed into

  foo(f : (b -> c) * a -> d) =  ... f(s) ...

Thus, the argument corresponding to the current term becomes the last
argument of f. Currently the compiler automatically detects and
repairs this in the internal representation, and emits a warning
indicating the definitions that are effected; no programs should break
because of the change. It is advised, however, to make the change in
the source.

The Stratego Compiler has been refactored to make use of the official
signature from stratego-front. The Stratego Optimizer has been
extended with a bunch of new optimizations, and now includes the
following optimizatoins:

   * Stratego simplifier
   * Build match fusion
   * Innermost fusion
   * Pattern match compilation
   * Worker wrapper splitting
   * Strategy inlining
   * Dead definition elimination
   * Constant and copy propagation 
   * Bound unbound variable analysis
   * Dead variable elimination
   * Avoid run time checks on variables
   * Lift definitions to top level

Although, a few preliminary tests suggest that the optimizations
reduce code size and increase performance, more thorough benchmarking
is needed to establish the precise effects of the optimizations. Also
further tuning, particularly of the inliner is needed to get better
results. Application of all optimizations may slow down
compilation. Therefore, strc provides several optimization levels. No
optimizations are performed at -O 0 increasing to all optimizations at
-O 6. If compile time is more important than run-time of the generated
code, then -O 1 is the prefferred setting. -O 2 corresponds to the
optimization level of 0.9.2. By default all optimizations are turned


  The release page contains the source distributions, binary RPMs, and
  detailed instructions on how to install the distributions:



  All the bugs and known problems for StrategXT distributions have
  been solved in this release.

  For a more detailed overview of problems and missing features please

  * ReleasePlan:
  * Todo:

  Please report any problems with installation or bugs in the
  implementation to the mailing list. Please
  check the archive of the list to see if a report about the problem 
  was already submitted.


  * Beta tests carried out by:
    Martin Bravenboer, Rob Vermaaas, Arthur van Dam

  * Major developments were carried out by:
    Eelco Visser, Martin Bravenboer, Rob Vermaas