Here is a summary of recent changes for DWScript, available in the SVN version:

• faster: compilation is now about 30% faster in situations like that benchmark, thanks to a few bug fixes (typechecks were performed multiple times) and a couple tokenizer enhancements.
• smaller: reduced memory usage for compiled scripts (about 15% in the infamous benchmark, which translates in an execution speedup of around 5% once a few hundred lines are involved).
• safer: fixed an old issue with object reference cycles, which weren’t covered by the reference counting and thus could be leaked.
• basic support for “for..in”, at the moment limited to the case of enumerations (for <element> in <enumeration>).
• fixed compile error source locations for some issues, plus various minor fixes and enhancements.

Last DWS preview zip was already a while back, so I posted a new preview zip of Delphi Web Script for the SVN-averse.
For the changes since the previous zip, you may want to check here, here and here), as while you’re at it, you may as well check the following:

• reactivated the COM Connector, which allows to connect to arbitrary COM/OLE objects from within a script. More tests are required.
• introduced initial support for the “in” operator, at the moment, it merely allows use of the “case..of” syntax in boolean expressions, with no specific optimizations f.i.

  if (n in [4, 6..8, 10]) then ...
  if (s in ['abc', 'def']) then ...

• open arrays can now be declared in script functions, as “const someName : array of const” parameters. They behave like arrays of variants from a type-checking point of view.
• added basic support for default values in the shorthand notation used to register internal functions, this is used for Inc and Dec at the moment.
• introduced constant unification, this is both a memory and performance optimization, it’s still largely experimental at the moment.
• various other optimizations and bug fixes.

Thanks go to Alexey Kazantsev for the testing efforts!

Here is a quick summary of what changed in the SVN since the last update:

• array variables can now be initialized (with [] to enclose values), ie. the code below is now supported:

  var abc : array [1..3] of String = ['a', 'b', 'c'];
  abc := [ 'hello', 'world', '!'];

• dwsClassesLibModule now exposes a minimalistic TStringBuilder.
• added dwsRunner to the demos, a simple command-line runner for DWScript.
• fixes to const parameters and constant arrays, though  those don’t benefit from optimizations at this point.
• trivial infinite loops are detected and warned about (repeat or while loops with an empty body and a constant condition).
• upgraded dwsResult and dwsHTMLFilter to use TStringBuilder internally.
• added MaxRecursionDepth to TdwsConfig, allows limiting the maximum number of recursive calls a script is allowed to perform.
• various fixes and minor additions.

A quick update on recent changes in the SVN:

• introduced support for Prism-like ‘method‘ keyword, which can be used as an alternative for ‘procedure‘ and ‘function‘ for class methods.

  procedure TMyClass.MyMethodWithNoResult;
  function TMyClass.ReturnsAString : String;

  can now alternatively be written as

  method TMyClass.MyMethodWithNoResult;
  method TMyClass.ReturnsAString : String;

  both forms are supported, though if you declared as a ‘method‘ in the class, you’ll have to implement as a ‘method‘.

• local ‘const‘ sections are now accepted in a procedure body, and you can have multiple ‘const‘ and ‘var‘ sections before ‘begin‘.
• type inference now accepted for variables in the ‘var‘ section of a procedure body.
• minor compiler optimization and fixes

The DWScript SVN version introduced a file system abstraction (via the dwsFileSystem unit). This is a both a security fix (restrict what scripts see and what the compiler can include) and an enhancement. You can f.i. run your scripts within a virtualized file system limited to a directory, a database, or whatever. At the moment this is still quite experimental and subject to change.

In other news, only in the SVN:

• format() function: it is seen as taking an array of variant from the script side, but on the Delphi side that array can be seen as a TVarRec array (Delphi’s array of const).
• multiple fixes for mis-detected or improper compile-time error messages (thanks Alexey Kazantsev!)
• unit tests coverage for the core compiler and runtime units is now around 70%, still some way to go, but improving.

A DWS 2.1 preview 3 7z archive is available at googlecode Delphi Web Script page, you can also get the same code via SVN of course.

This versions fixes several reported and unreported  issues, and adds support for type inference and Delphi Prism variable initialization syntax. Before you could write code like:

var myInteger : Integer = 1234;
var myObj : TSomeObject = TSomeObject.Create;

where ‘=‘ was used as assignment operator (using the same syntax as for constant declaration or default parameter values), you can now write the above using ‘:=‘ as well

var myInteger : Integer := 1234;
var myObj : TSomeObject := TSomeObject.Create;

and you additionally can make use of type inference and write just

var myInteger := 1234;
var myObj = TSomeObject.Create;

Type inference is currently limited to the variable declaration, this will probably stay for code clarity (opinions?). The inferred type isn’t restricted at the moment, but that will probably change (so you can disallow to inferring to a Variant type f.i.).

DWScript has supported several extensions to the Delphi language since the beginning. Here are a few you may wish the Delphi compiler supported too (and not just Delphi Prism…):

• generalized case of, which supports non-ordinal type, for instance you can write

  case myString of
    'hello': PrintLn('Hello!');
    'goodbye': PrintLn('See you!');
  end;

• variables can be declared in-line anywhere in the script, allowing code like

  for i:=1 to 10 do begin
     var k : Integer;
     ...
  end;

• variables are always initialized, not just global or managed variables

  procedure MyProc;
  var
     k : Integer;
  begin
     ...k is guaranteed to be zero here (unlike in Delphi)

• variables can be initialized to custom values upon declaration

  var obj : TMyObject = TMyObject.Create;

A DWS 2.1 preview 2 7z archive is available at googlecode DWScript page, you can also get the same code via SVN of course.

• added support for the Delphi “Exit” syntax, which allows passing a return value as in Exit(“my return value”)
• TConfiguration renamed to TdwsConfiguration, some DFM persistence tweaks (less verbose by default, should be backward compatible)
• improved unit test coverage
• minor tweaks to runtime or compile-time error messages

As the unit tests “safety net” spreads, I’ll add support for more modern-era Delphi language additions.