Tesla is the new TOM compiler, written in TOM. It is the compiler of choice and is actively developed and maintained.

How to build and install Tesla is explained in the Tesla install instructions. Note that you do not need TOM to boot Tesla the TOM compiler into existence. (Also note that when using Tesla to build TOM programs, TOM no longer depends on Objective-C or GNU CC.)

News

Sat Apr 14 2001

In the last year, many bugs have been fixed, in tesla and in the supporting libraries and utilities. Blocks are now much less likely to have compile-time errors. The 'obsolete' keyword has been added and is largely working. At this point, tesla should be the primary choice when looking for a TOM compiler.

Sat Feb 12 2000

I have found and fixed the problem with gp needing the :gc-pth 1000000 on the command line to prevent it from dumping core. The fixed bug was in the TOM run time library. There should now be no more problems with building the bootstrap. Test it! Without major problems, the current snapshot of Tesla will become version 0.94.

Thu Feb 11 2000

I have found and fixed the problem with TOM shared library units! Incidentally, I also removed the big hack that imposed a limit on the number of non-static class variables that extensions could introduce or was wasting memory in the absence of those extensions. Test it widely (wildly?)!

Sat Feb 5 2000

Status: Tesla bootstrap works on i386 and PPC, but shared libraries of TOM units do not. In addition, there is a garbage collection problem that pops up when running gp on mu/tom.tp. Add :gc-pth 1000000 on the command line for now - it effectively inhibits the program to do garbage collection.
Tesla can compile TOM/Gtk now, after fixing a bug reported by David Wallin.

Thu Jan 27 2000

The correct functioning of the Tesla bootstrap on PowerPC Linux has been verified (I had to add `:gc-pth 1000000' on the invocation of gp and use static libraries though; investigations are ongoing).

Thu Jan 20 2000

I have verified on a clean machine that the bootstrap install works, at least on my i386 Linux box, as described in installation instructions.
I've registered and mentioned Tesla on Freshmeat.net.

Sat Dec 18 1999

Many bug-fixes to the Tesla bootstrap and TOM standard libraries.

Thu Dec 16 1999

Tesla can be bootstrapped from stable snapshot sources! Read the step-by-step instructions here.

Tue Oct 19 1999

Released version 0.91! Experimental, but very usable. Besides, Tesla provides Blocks -- reason enough to start using it!

Sat Oct 2 1999

Implemented the garbage collection of blocks, or, to be precise: the proper protection of objects still referenced from a block. As very often with TOM, it was easy, given the solid software architecture already present.

Wed Sep 22 1999

Completed the implementation of TOM Blocks with the addition of block variables (ignoring, for the moment, garbage collection and block deactivation). A block variable maintains its value between successive evaluations of the block; compare them with static variables in a C function if you like. As an example, the following code will print the first ten powers of two:

int
  main Array arguments
{
  Block b = |{ /* no arguments */
	    | int a = 1;
	    | [[[stdio out] print a] nl];
	      a *= 2;
	    }|;

  int i;
  for (i = 0; i < 10; i++)
    [b eval];
}

Note that the assignment a = 1 is executed before the block is allocated and assigned to b.

Mon Sep 6 1999

Added a familiar do method to the Indexed collection class, making possible the following program (it prints its arguments and their count):

int
  main Array arguments
{
  int num_args;

  [arguments do |{All arg
                || [[[stdio out]
                     print ("argument: `", arg, "'")] nl];
                   num_args++;
                }|];

  [[[stdio out] print (num_args, " arguments")] nl];
}

This example is actually the first example that comes with Tesla, as examples/block1.t.

Sun Sep 5 1999

Implemented context references from a block to local variables and method arguments in the enclosing scope. Fixed the type mismatches of Block's eval methods up to a certain level: they now allow the invocation of blocks with a single-value return from a void context. All this means that the following works as expected (it will print 2 plus the number of arguments to the program):

int
  main Array arguments
{
  int i;

  [|{ (int, int) (j, k)
   || i = j + k + [arguments length];
   }|
   eval (1, 1)];

  [[[stdio out] print i] nl];
}

What's left to be done? Only block variables (those things between `||' in the examples up to now) and block invalidation. And a cleanup of the Tesla code after what I've hacked into it while getting blocks to work :-)

Mon Aug 30 1999

Implemented non-void return types (this will print `24 42'):

Block swap = |{ (int, int) (i, j)
             || (j, i);
             }|;
int j, k;
(j, k) = [swap eval (42, 24)];
[[[stdio out] print (j, " ", k)] nl];

Sun Aug 29 1999

Partially done with implementing blocks: only context references, non-void return types, partially mismatching return types, and block variables are left to be done. That means, the following works (it will print the number 66):

Block b = |{ (int, int) (i, j)
          || [[[stdio out] print i + j] nl];
             void;
          }|;
[b eval (42, 24)];

3 Mar 1999

Tesla as a plug-in replacement for tomc.

28 Jul 1998

First pre-alpha release of Tesla 0.1.

28 Jul 1998

Tesla is stable!

17 Jul 1998

Tesla boots!

16 Jul 1998

first results of tesla-built-tesla

2 Jun 1998

first real code