…and DWScript will likely enter RC phase before the year ends, as almost all of what I had in mind for 2.1 will be there!

Recent SVN additions since the last update:

• 75% of the DWScript core code is now covered by unit tests (this was a psychological milestone for 2.1!).
• class operators have been added, currently those are “+=”, “-=”, “*=” and “/=”, they follow a syntax similar to properties, in that a class operator isn’t defined as a special method, but as syntax sugar for a regular method (see below).
• Function call overhead has been reduced for in-script functions & methods, as well as TdwsUnit-based functions & methods.
• TProgramInfo now has ParamAsXxx[] properties, which allow accessing parameters by index and in a more efficient (is less-safe)  fashion.
• Sqr() became a special function, it will now return an integer and not a float when operating on an integer.
• Various fixes and error message clarifications (thanks Alexey Kasantsev).

Class operators in DWScript

The first class operators are now implemented in DWScript, though the syntax differs from Delphi, FreePascal & Prism in that they are not special methods/procedures, but syntax-sugar aliases, in a fashion similar to what properties achieve.

class operator <operator> <rightType> uses <method>

To illustrate this with TList f.i., you could declare have

class operator += TObject uses Add;
class operator -= TObject uses Remove;

and so “myList += item” would be equivalent to “myList.Add(item)”.

Note that class operators support type overloading, it is thus possible to declare

TMyClass = class
   procedure AddInteger(i : Integer);
   procedure AddString(s : String);

   class operator += Integer uses AddInteger;
   class operator += String uses AddString;
end;

The method will be selected depending on the right operand type

myObject += 10; // will use AddInteger
myObject += 'ten'; // will use AddString;

Only compound-operators can be overloaded, overloading of other operators is not planned for 2.1.

For 2.2 and beyond, the plan is currently to not allow overloading of non-compound-operators in the scripts (at least not without a switch to control that ability), this is to keep ambiguous uses of operator overloading out of the scripts.

Delphi-side overloading definition will however be supported for class and add-on base types, one of the first uses will likely be for upcoming (optional) vector, matrix & other algebra types.