1 files changed, 999 insertions, 94 deletions

diff --git a/packages/fcl-js/src/jstree.pp b/packages/fcl-js/src/jstree.pp
index 65914a4e7a..74b58c8e19 100644
--- a/packages/fcl-js/src/jstree.pp
+++ b/packages/fcl-js/src/jstree.pp
@@ -1,13 +1,68 @@
 unit jstree;
 
 {$mode objfpc}{$H+}
+{ $DEFINE NOCLASSES}
 
 interface
 
 uses
-  Classes, SysUtils, jsbase;
+{$IFNDEF NOCLASSES}  Classes, {$ENDIF} SysUtils, jsbase, jstoken;
 
 Type
+{$IFDEF NOCLASSES}
+
+  { TStrings }
+{$M+}
+  TStrings = Class(TObject)
+  private
+    FCount: Integer;
+    FStrings : Array of String;
+    function GetCount: Integer;
+    function GetS(AIndex : Integer): String;
+    procedure SetS(AIndex : Integer; AValue: String);
+  Public
+    Function Add(Const S : String) : Integer;
+    Procedure Assign(Source : TStrings);
+    Property Strings[AIndex : Integer] : String Read GetS Write SetS; default;
+    Property Count : Integer Read GetCount;
+  end;
+  TStringList = TStrings;
+  EListError = Class(Exception);
+
+  TCollection = Class;
+
+  { TCollectionItem }
+
+  TCollectionItem = Class
+  Private
+    FCollection : TCollection;
+  Public
+    Constructor Create(ACollection : TCollection);
+    Destructor Destroy; override;
+  end;
+  TCollectionItemClass = Class of TCollectionItem;
+
+  { TCollection }
+
+  TCollection = Class
+  private
+    FCount: Integer;
+    FItems : Array of TCollectionItem;
+    FItemClass : TCollectionItemClass;
+    function GetCount: Integer;
+    function GetI(AIndex : Integer): TCollectionItem;
+  public
+    Constructor Create(AItemClass : TCollectionItemClass);
+    Destructor Destroy; override;
+    Procedure Clear;
+    Procedure Remove(AItem : TCollectionItem);
+    Function Add : TCollectionItem;
+    Property Items[AIndex : Integer] : TCollectionItem Read GetI;default;
+    Property Count : Integer Read GetCount;
+  end;
+
+{$M-}
+{$ENDIF}
   TJSElementFlag = (elIsConst,elIsConstValid);
   TJSElementFlags = set of TJSElementFlag;
 
@@ -17,18 +72,47 @@ Type
 
   TJSObject = Class(TObject);
 
+
+    { TJSLabelSet }
+
+    TJSLabelSet = Class(TJSObject)
+    private
+      FCOnt: Boolean;
+      FNext: TJSLabelSet;
+      FTarget: Cardinal;
+    Public
+      Property Target : Cardinal Read FTarget Write FTarget;
+      Property Next : TJSLabelSet Read FNext Write FNext; // Linked list
+      Property Continuable : Boolean Read FCOnt Write FCont;
+    end;
+
+    { TJSLabel }
+
+    TJSLabel = Class(TJSObject)
+    private
+      FLabelSet: TJSLabelSet;
+      FLocationLine: Integer;
+      FLocationPos: Integer;
+      FLocationSource: String;
+      FName: String;
+      FNext: TJSLabel;
+    Public
+      Property Name : String Read FName Write FName;
+      Property LabelSet : TJSLabelSet Read FLabelSet Write FLabelSet;
+      Property LocationSource : String Read FLocationSource Write FLocationSource;
+      Property LocationLine : Integer Read FLocationLine Write FLocationLine;
+      Property LocationPos : Integer Read FLocationPos Write FLocationPos;
+      Property Next : TJSLabel Read FNext Write FNext;
+    end;
+
   { TJSFuncDef }
 
   TJSFuncDef = Class(TJSObject)
   private
     FBody: TJSFunctionBody;
-    FCache: TJSObject;
-    FCommon: TJSObject;
     FIsEmpty: Boolean;
     FName: String;
-    FNext: TJSFuncDef;
     FParams: TStrings;
-    FSec: TObject;
     procedure SetParams(const AValue: TStrings);
   Public
     Constructor Create;
@@ -36,11 +120,7 @@ Type
     Property Params : TStrings Read FParams Write SetParams;
     Property Body : TJSFunctionBody Read FBody Write FBody;
     Property Name : String Read FName Write FName;
-    Property Common : TJSObject Read FCommon Write FCommon;
-    Property Cache : TJSObject Read FCache write FCache;
-    Property Next : TJSFuncDef Read FNext Write FNext;
     Property IsEmpty : Boolean Read FIsEmpty Write FIsEmpty;
-    Property SecurityDomain : TObject Read FSec Write FSec;
   end;
 
   TJSString = WideString;
@@ -130,10 +210,9 @@ Type
   TJSArrayLiteralElements = Class(TCollection)
   private
     function GetE(AIndex : Integer): TJSArrayLiteralElement;
-    procedure SetE(AIndex : Integer; const AValue: TJSArrayLiteralElement);
   Public
     Function AddElement : TJSArrayLiteralElement;
-    Property Elements[AIndex : Integer] : TJSArrayLiteralElement Read GetE Write SetE; default;
+    Property Elements[AIndex : Integer] : TJSArrayLiteralElement Read GetE ; default;
   end;
 
   { TJSArrayLiteral }
@@ -164,10 +243,9 @@ Type
   TJSObjectLiteralElements = Class(TCollection)
   private
     function GetE(AIndex : Integer): TJSObjectLiteralElement;
-    procedure SetE(AIndex : Integer; const AValue: TJSObjectLiteralElement);
   Public
     Function AddElement : TJSObjectLiteralElement;
-    Property Elements[AIndex : Integer] : TJSObjectLiteralElement Read GetE Write SetE; default;
+    Property Elements[AIndex : Integer] : TJSObjectLiteralElement Read GetE ; default;
   end;
 
   { TJSObjectLiteral }
@@ -242,26 +320,92 @@ Type
   private
     FA: TJSElement;
   Public
+    Class function PrefixOperatorToken : tjsToken; virtual;
+    Class function PostFixOperatorToken : tjsToken; virtual;
+    Class function PrefixOperator : String;
+    Class function PostFixOperator : String;
     Destructor Destroy; override;
     Property A : TJSElement Read FA Write FA;
   end;
+  TJSUnaryClass = class of TJSUnary;
 
   { TJSVariableStatement }
   TJSVariableStatement = Class(TJSUnary);
   TJSExpressionStatement = Class(TJSUnary);
-  TJSThrowStatement = Class(TJSUnary);
+
+  { TJSThrowStatement }
+
+  TJSThrowStatement = Class(TJSUnary)
+    Class function PrefixOperatorToken : tjsToken; Override;
+  end;
+
   TJSUnaryExpression = Class(TJSUnary);
-  TJSUnaryDeleteExpression = Class(TJSUnaryExpression);
-  TJSUnaryVoidExpression = Class(TJSUnaryExpression);
-  TJSUnaryTypeOfExpression = Class(TJSUnaryExpression);
-  TJSUnaryPrePlusPlusExpression = Class(TJSUnaryExpression);
-  TJSUnaryPreMinusMinusExpression = Class(TJSUnaryExpression);
-  TJSUnaryPlusExpression = Class(TJSUnaryExpression);
-  TJSUnaryMinusExpression = Class(TJSUnaryExpression);
-  TJSUnaryInvExpression = Class(TJSUnaryExpression);
-  TJSUnaryNotExpression = Class(TJSUnaryExpression);
-  TJSUnaryPostPlusPlusExpression = Class(TJSUnaryExpression);
-  TJSUnaryPostMinusMinusExpression = Class(TJSUnaryExpression);
+
+  { TJSUnaryDeleteExpression }
+
+  TJSUnaryDeleteExpression = Class(TJSUnaryExpression)
+    Class function PrefixOperatorToken : tjsToken; override;
+  end;
+
+  { TJSUnaryVoidExpression }
+
+  TJSUnaryVoidExpression = Class(TJSUnaryExpression)
+    Class function PrefixOperatorToken : tjsToken; override;
+  end;
+
+  { TJSUnaryTypeOfExpression }
+
+  TJSUnaryTypeOfExpression = Class(TJSUnaryExpression)
+    Class function PrefixOperatorToken : tjsToken; override;
+  end;
+
+  { TJSUnaryPrePlusPlusExpression }
+
+  TJSUnaryPrePlusPlusExpression = Class(TJSUnaryExpression)
+    Class function PrefixOperatorToken : tjsToken; override;
+  end;
+
+  { TJSUnaryPreMinusMinusExpression }
+
+  TJSUnaryPreMinusMinusExpression = Class(TJSUnaryExpression)
+    Class function PrefixOperatorToken : tjsToken; override;
+  end;
+
+  { TJSUnaryPlusExpression }
+
+  TJSUnaryPlusExpression = Class(TJSUnaryExpression)
+    Class function PrefixOperatorToken : tjsToken; override;
+  end;
+
+  { TJSUnaryMinusExpression }
+
+  TJSUnaryMinusExpression = Class(TJSUnaryExpression)
+    Class function PrefixOperatorToken : tjsToken; override;
+  end;
+
+  { TJSUnaryInvExpression }
+
+  TJSUnaryInvExpression = Class(TJSUnaryExpression)
+    Class function PrefixOperatorToken : tjsToken; override;
+  end;
+
+  { TJSUnaryNotExpression }
+
+  TJSUnaryNotExpression = Class(TJSUnaryExpression)
+    Class function PrefixOperatorToken : tjsToken; override;
+  end;
+
+  { TJSUnaryPostPlusPlusExpression }
+
+  TJSUnaryPostPlusPlusExpression = Class(TJSUnaryExpression)
+    Class function PostFixOperatorToken : tjsToken; override;
+  end;
+
+  { TJSUnaryPostMinusMinusExpression }
+
+  TJSUnaryPostMinusMinusExpression = Class(TJSUnaryExpression)
+    Class function PostFixOperatorToken : tjsToken; override;
+  end;
 
 
 
@@ -276,41 +420,177 @@ Type
     Property A : TJSElement Read FA Write FA;
     Property B : TJSElement Read FB Write FB;
   end;
+  TJSBinaryClass = Class of TJSBinary;
 
   { TJSStatementList }
 
   TJSStatementList = Class(TJSBinary); // A->first statement, B->next in list, chained.
   TJSVariableDeclarationList = Class(TJSBinary);
   TJSWithStatement = Class(TJSBinary); // A-> with expression, B->statement(s)
-  TJSLogicalOrExpression = Class (TJSBinary);
-  TJSLogicalAndExpression = Class (TJSBinary);
-  TJSBitwiseAndExpression = Class (TJSBinary);
-  TJSBitwiseOrExpression = Class (TJSBinary);
-  TJSBitwiseXOrExpression = Class (TJSBinary);
-  TJSEqualityExpression = Class (TJSBinary);
-  TJSEqualityExpressionEQ = Class(TJSEqualityExpression);
-  TJSEqualityExpressionNE = Class(TJSEqualityExpression);
-  TJSEqualityExpressionSEQ = Class(TJSEqualityExpression);
-  TJSEqualityExpressionSNE = Class(TJSEqualityExpression);
-  TJSRelationalExpression = Class(TJSBinary);
-  TJSRelationalExpressionLT = Class(TJSRelationalExpression);
-  TJSRelationalExpressionGT = Class(TJSRelationalExpression);
-  TJSRelationalExpressionLE = Class(TJSRelationalExpression);
-  TJSRelationalExpressionGE = Class(TJSRelationalExpression);
-  TJSRelationalExpressionIn = Class(TJSRelationalExpression);
-  TJSRelationalExpressionInstanceOf = Class(TJSRelationalExpression);
-  TJSShiftExpression = Class(TJSBinary);
-  TJSLShiftExpression = Class(TJSShiftExpression);
-  TJSRShiftExpression = Class(TJSShiftExpression);
-  TJSURShiftExpression = Class(TJSShiftExpression);
-  TJSAdditiveExpression = Class(TJSBinary);
-  TJSAdditiveExpressionPlus = Class(TJSAdditiveExpression);
-  TJSAdditiveExpressionMinus = Class(TJSAdditiveExpression);
-  TJSMultiplicativeExpression = Class(TJSBinary);
-  TJSMultiplicativeExpressionMul = Class(TJSMultiplicativeExpression);
-  TJSMultiplicativeExpressionDiv = Class(TJSMultiplicativeExpression);
-  TJSMultiplicativeExpressionMod = Class(TJSMultiplicativeExpression);
-  TJSCommaExpression = Class(TJSBinary);
+
+  { TJSBinaryExpression }
+
+  TJSBinaryExpression = Class(TJSBinary)
+    Class function OperatorToken : tjsToken; virtual;
+    Class function OperatorString : string;
+    Class Function AllowCompact : Boolean; virtual;
+  end;
+
+  { TJSLogicalOrExpression }
+
+  TJSLogicalOrExpression = Class (TJSBinaryExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSLogicalAndExpression }
+
+  TJSLogicalAndExpression = Class (TJSBinaryExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSBitwiseAndExpression }
+
+  TJSBitwiseAndExpression = Class (TJSBinaryExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSBitwiseOrExpression }
+
+  TJSBitwiseOrExpression = Class (TJSBinaryExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSBitwiseXOrExpression }
+
+  TJSBitwiseXOrExpression = Class (TJSBinaryExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  TJSEqualityExpression = Class (TJSBinaryExpression);
+
+  { TJSEqualityExpressionEQ }
+
+  TJSEqualityExpressionEQ = Class(TJSEqualityExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSEqualityExpressionNE }
+
+  TJSEqualityExpressionNE = Class(TJSEqualityExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSEqualityExpressionSEQ }
+
+  TJSEqualityExpressionSEQ = Class(TJSEqualityExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSEqualityExpressionSNE }
+
+  TJSEqualityExpressionSNE = Class(TJSEqualityExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  TJSRelationalExpression = Class(TJSBinaryExpression);
+
+  { TJSRelationalExpressionLT }
+
+  TJSRelationalExpressionLT = Class(TJSRelationalExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSRelationalExpressionGT }
+
+  TJSRelationalExpressionGT = Class(TJSRelationalExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSRelationalExpressionLE }
+
+  TJSRelationalExpressionLE = Class(TJSRelationalExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSRelationalExpressionGE }
+
+  TJSRelationalExpressionGE = Class(TJSRelationalExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSRelationalExpressionIn }
+
+  TJSRelationalExpressionIn = Class(TJSRelationalExpression)
+    Class function OperatorToken : tjsToken; override;
+    Class Function AllowCompact : Boolean; override;
+  end;
+
+  { TJSRelationalExpressionInstanceOf }
+
+  TJSRelationalExpressionInstanceOf = Class(TJSRelationalExpression)
+    Class function OperatorToken : tjsToken; override;
+    Class Function AllowCompact : Boolean; override;
+  end;
+
+  TJSShiftExpression = Class(TJSBinaryExpression);
+
+  { TJSLShiftExpression }
+
+  TJSLShiftExpression = Class(TJSShiftExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSRShiftExpression }
+
+  TJSRShiftExpression = Class(TJSShiftExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSURShiftExpression }
+
+  TJSURShiftExpression = Class(TJSShiftExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  TJSAdditiveExpression = Class(TJSBinaryExpression);
+
+  { TJSAdditiveExpressionPlus }
+
+  TJSAdditiveExpressionPlus = Class(TJSAdditiveExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSAdditiveExpressionMinus }
+
+  TJSAdditiveExpressionMinus = Class(TJSAdditiveExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  TJSMultiplicativeExpression = Class(TJSBinaryExpression);
+
+  { TJSMultiplicativeExpressionMul }
+
+  TJSMultiplicativeExpressionMul = Class(TJSMultiplicativeExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSMultiplicativeExpressionDiv }
+
+  TJSMultiplicativeExpressionDiv = Class(TJSMultiplicativeExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSMultiplicativeExpressionMod }
+
+  TJSMultiplicativeExpressionMod = Class(TJSMultiplicativeExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSCommaExpression }
+
+  TJSCommaExpression = Class(TJSBinaryExpression)
+    Class function OperatorToken : tjsToken; override;
+  end;
 
   { TJSConditionalExpression }
 
@@ -334,22 +614,85 @@ Type
     FLHS: TJSElement;
   Public
     Destructor Destroy; override;
+    Class function OperatorToken : tjsToken; virtual;
+    Class function OperatorString : String;
     Property Expr : TJSElement Read FExpr Write FExpr;
     Property LHS : TJSElement Read FLHS Write FLHS;
   end;
 
-  TJSSimpleAssignStatement = Class(TJSAssignStatement);
-  TJSMulEqAssignStatement = Class(TJSAssignStatement);
-  TJSDivEqAssignStatement = Class(TJSAssignStatement);
-  TJSModEqAssignStatement = Class(TJSAssignStatement);
-  TJSAddEqAssignStatement = Class(TJSAssignStatement);
-  TJSSubEqAssignStatement = Class(TJSAssignStatement);
-  TJSLShiftEqAssignStatement = Class(TJSAssignStatement);
-  TJSRShiftEqAssignStatement = Class(TJSAssignStatement);
-  TJSURShiftEqAssignStatement = Class(TJSAssignStatement);
-  TJSANDEqAssignStatement = Class(TJSAssignStatement);
-  TJSOREqAssignStatement = Class(TJSAssignStatement);
-  TJSXOREqAssignStatement = Class(TJSAssignStatement);
+  TJSAssignStatementClass = Class of TJSAssignStatement;
+
+  { TJSSimpleAssignStatement }
+
+  TJSSimpleAssignStatement = Class(TJSAssignStatement)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSMulEqAssignStatement }
+
+  TJSMulEqAssignStatement = Class(TJSAssignStatement)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSDivEqAssignStatement }
+
+  TJSDivEqAssignStatement = Class(TJSAssignStatement)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSModEqAssignStatement }
+
+  TJSModEqAssignStatement = Class(TJSAssignStatement)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSAddEqAssignStatement }
+
+  TJSAddEqAssignStatement = Class(TJSAssignStatement)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSSubEqAssignStatement }
+
+  TJSSubEqAssignStatement = Class(TJSAssignStatement)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSLShiftEqAssignStatement }
+
+  TJSLShiftEqAssignStatement = Class(TJSAssignStatement)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSRShiftEqAssignStatement }
+
+  TJSRShiftEqAssignStatement = Class(TJSAssignStatement)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSURShiftEqAssignStatement }
+
+  TJSURShiftEqAssignStatement = Class(TJSAssignStatement)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSANDEqAssignStatement }
+
+  TJSANDEqAssignStatement = Class(TJSAssignStatement)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSOREqAssignStatement }
+
+  TJSOREqAssignStatement = Class(TJSAssignStatement)
+    Class function OperatorToken : tjsToken; override;
+  end;
+
+  { TJSXOREqAssignStatement }
+
+  TJSXOREqAssignStatement = Class(TJSAssignStatement)
+    Class function OperatorToken : tjsToken; override;
+  end;
 
   { TJSVarDeclaration }
 
@@ -384,8 +727,10 @@ Type
   TJSTargetStatement = Class(TJSElement)
   private
     FTarget: Cardinal;
+    FTargetName: TJSString;
   Public
     Property Target : Cardinal Read FTarget Write FTarget;
+    Property TargetName : TJSString Read FTargetName Write FTargetName;
   end;
 
   { TJSBodyStatement }
@@ -408,8 +753,8 @@ Type
     Property Cond : TJSElement Read FCond Write FCond;
   end;
 
-  TJSWhileStatement = Class(TJSCondLoopStatement)
-  end;
+  TJSWhileStatement = Class(TJSCondLoopStatement);
+  TJSDoWhileStatement = Class(TJSWhileStatement);
 
   { TJSForStatement }
 
@@ -466,10 +811,9 @@ Type
   TJSCaseElements = Class(TCollection)
   private
     function GetC(AIndex : Integer): TJSCaseElement;
-    procedure SetC(AIndex : Integer; const AValue: TJSCaseElement);
   Public
     Function AddCase : TJSCaseElement;
-    Property Cases[AIndex : Integer] : TJSCaseElement Read GetC Write SetC;
+    Property Cases[AIndex : Integer] : TJSCaseElement Read GetC ;default;
   end;
 
   { TJSSwitch }
@@ -491,9 +835,12 @@ Type
 
   TJSLabeledStatement = Class(TJSUnary)
   private
+    FLabel: TJSLabel;
     FTarget: Integer;
   Public
+    Destructor Destroy; override;
     Property target: Integer Read FTarget Write FTarget;
+    Property TheLabel : TJSLabel Read FLabel Write Flabel;
   end;
 
   { TJSTryStatement }
@@ -551,10 +898,9 @@ Type
   TJSElementNodes = Class(TCollection)
   private
     function GetN(AIndex : Integer): TJSElementNode;
-    procedure SetN(AIndex : Integer; const AValue: TJSElementNode);
   Public
     Function AddNode : TJSElementNode;
-    Property Nodes[AIndex : Integer] : TJSElementNode Read GetN Write SetN; default;
+    Property Nodes[AIndex : Integer] : TJSElementNode Read GetN ; default;
   end;
 
   { TJSSourceElements }
@@ -574,6 +920,528 @@ Type
 
 implementation
 
+{$IFDEF NOCLASSES}
+{ TCollectionItem }
+
+Constructor TCollectionItem.Create(ACollection: TCollection);
+begin
+  FCollection:=ACollection;
+end;
+
+Destructor TCollectionItem.Destroy;
+begin
+  if Assigned(FCollection) then
+    FCollection.Remove(Self);
+  inherited Destroy;
+end;
+
+{ TCollection }
+
+function TCollection.GetI(AIndex : Integer): TCollectionItem;
+begin
+  if (AIndex>=0) and (AIndex<FCount) then
+    Result:=FItems[AIndex]
+  else
+    Raise EListError.CreateFmt('Collection index (%d) out of bounds.',[AIndex]);
+end;
+
+function TCollection.GetCount: Integer;
+begin
+  Result:=FCount;
+end;
+
+Procedure TCollection.Remove(AItem: TCollectionItem);
+
+Var
+  I,J : Integer;
+
+begin
+  if (AItem=Nil)  then exit;
+  I:=Count-1;
+  While (I>=0) and (FItems[I]<>AItem) do
+    Dec(i);
+  For J:=I to Count-2 do
+    FItems[I]:=FItems[i+1];
+  Dec(FCount);
+end;
+
+Constructor TCollection.Create(AItemClass: TCollectionItemClass);
+begin
+  FItemClass:=AItemClass;
+end;
+
+Destructor TCollection.Destroy;
+begin
+  Clear;
+  inherited Destroy;
+end;
+
+Procedure TCollection.Clear;
+
+Var
+  I : Integer;
+
+begin
+  For I:=0 to Count-1 do
+    begin
+    FItems[i].FCollection:=Nil;
+    FItems[i].Destroy;
+    end;
+  FCount:=0;
+  SetLength(Fitems,0);
+end;
+
+Function TCollection.Add: TCollectionItem;
+Var
+  NL : Integer;
+begin
+  If FCount=Length(FItems) then
+    begin
+    NL:=Length(FItems)*3 div 2;
+    if NL=0 then NL:=10;
+    SetLength(FItems,NL);
+    end;
+  Result:=FItemClass.Create(Self);
+  FItems[FCount]:=Result;
+  Inc(FCount);
+end;
+
+{ TStrings }
+
+function TStrings.GetCount: Integer;
+begin
+  Result:=FCount;
+end;
+
+function TStrings.GetS(AIndex : Integer): String;
+begin
+  if (AIndex>=0) and (AIndex<FCount) then
+    Result:=FStrings[AIndex]
+  else
+    Raise EListError.CreateFmt('List index (%d) out of bounds.',[AIndex]);
+end;
+
+procedure TStrings.SetS(AIndex : Integer; AValue: String);
+begin
+  if (AIndex>=0) and (AIndex<=FCount) then
+    begin
+    if (AIndex=FCount) then
+      Add(AValue)
+    else
+      FStrings[AIndex]:=AValue;
+    end
+  else
+    Raise EListError.CreateFmt('List index (%d) out of bounds.',[AIndex]);
+end;
+
+Function TStrings.Add(Const S: String): Integer;
+
+Var
+  NL : Integer;
+begin
+  If FCount=Length(FStrings) then
+    begin
+    NL:=Length(FStrings)*3 div 2;
+    if NL=0 then NL:=10;
+    SetLength(FStrings,NL);
+    end;
+  FStrings[FCount]:=S;
+  Inc(FCount);
+end;
+
+Procedure TStrings.Assign(Source: TStrings);
+
+Var
+  I : Integer;
+
+begin
+  SetLength(FStrings,Length(Source.FStrings));
+  FCount:=Source.FCount;
+  For I:=0 to FCount-1 do
+    FStrings[i]:=Source.FStrings[i];
+end;
+{$ENDIF NOCLASSES}
+
+{ TJSXOREqAssignStatement }
+
+Class function TJSXOREqAssignStatement.OperatorToken: tjsToken;
+begin
+  Result:=tjsXOREq;
+end;
+
+{ TJSOREqAssignStatement }
+
+Class function TJSOREqAssignStatement.OperatorToken: tjsToken;
+begin
+  Result:=tjsOREQ;
+end;
+
+{ TJSANDEqAssignStatement }
+
+Class function TJSANDEqAssignStatement.OperatorToken: tjsToken;
+begin
+  Result:=tjsAndEq;
+end;
+
+{ TJSURShiftEqAssignStatement }
+
+Class function TJSURShiftEqAssignStatement.OperatorToken: tjsToken;
+begin
+  Result:=tjsURSHIFTEQ;
+end;
+
+{ TJSRShiftEqAssignStatement }
+
+Class function TJSRShiftEqAssignStatement.OperatorToken: tjsToken;
+begin
+  Result:=tjsRSHIFTEQ;
+end;
+
+{ TJSLShiftEqAssignStatement }
+
+Class function TJSLShiftEqAssignStatement.OperatorToken: tjsToken;
+begin
+   Result:=tjsLSHIFTEQ;
+end;
+
+{ TJSSubEqAssignStatement }
+
+Class function TJSSubEqAssignStatement.OperatorToken: tjsToken;
+begin
+  Result:=tjsMINUSEQ;
+end;
+
+{ TJSAddEqAssignStatement }
+
+Class function TJSAddEqAssignStatement.OperatorToken: tjsToken;
+begin
+  Result:=tjsPLUSEQ;
+end;
+
+{ TJSModEqAssignStatement }
+
+Class function TJSModEqAssignStatement.OperatorToken: tjsToken;
+begin
+  Result:=tjsMODEQ;
+end;
+
+{ TJSDivEqAssignStatement }
+
+Class function TJSDivEqAssignStatement.OperatorToken: tjsToken;
+begin
+  Result:=tjsDIVEQ;
+end;
+
+{ TJSMulEqAssignStatement }
+
+Class function TJSMulEqAssignStatement.OperatorToken: tjsToken;
+begin
+  Result:=tjsMULEQ;
+end;
+
+{ TJSSimpleAssignStatement }
+
+Class function TJSSimpleAssignStatement.OperatorToken: tjsToken;
+begin
+  Result:=tjsAssign;
+end;
+
+{ TJSLabeledStatement }
+
+Destructor TJSLabeledStatement.Destroy;
+begin
+  FreeAndNil(Flabel);
+  inherited Destroy;
+end;
+
+{ TJSCommaExpression }
+
+Class function TJSCommaExpression.OperatorToken: tjsToken;
+begin
+  Result:=tjsComma;
+end;
+
+{ TJSMultiplicativeExpressionMod }
+
+Class function TJSMultiplicativeExpressionMod.OperatorToken: tjsToken;
+begin
+  Result:=tjsMod;
+end;
+
+{ TJSMultiplicativeExpressionDiv }
+
+Class function TJSMultiplicativeExpressionDiv.OperatorToken: tjsToken;
+begin
+  Result:=tjsDiv;
+end;
+
+{ TJSMultiplicativeExpressionMul }
+
+Class function TJSMultiplicativeExpressionMul.OperatorToken: tjsToken;
+begin
+  Result:=tjsMul;
+end;
+
+{ TJSAdditiveExpressionMinus }
+
+Class function TJSAdditiveExpressionMinus.OperatorToken: tjsToken;
+begin
+  Result:=tjsMinus;
+end;
+
+{ TJSAdditiveExpressionPlus }
+
+Class function TJSAdditiveExpressionPlus.OperatorToken: tjsToken;
+begin
+  Result:=tjsPlus;
+end;
+
+{ TJSURShiftExpression }
+
+Class function TJSURShiftExpression.OperatorToken: tjsToken;
+begin
+  Result:=tjsURshift;
+end;
+
+{ TJSRShiftExpression }
+
+Class function TJSRShiftExpression.OperatorToken: tjsToken;
+begin
+  Result:=tjsRSHIFT;
+end;
+
+{ TJSLShiftExpression }
+
+Class function TJSLShiftExpression.OperatorToken: tjsToken;
+begin
+  Result:=tjsLSHIFT;
+end;
+
+{ TJSRelationalExpressionInstanceOf }
+
+Class function TJSRelationalExpressionInstanceOf.OperatorToken: tjsToken;
+begin
+  Result:=tjsInstanceOf;
+end;
+
+Class Function TJSRelationalExpressionInstanceOf.AllowCompact: Boolean;
+begin
+  Result:=False;
+end;
+
+{ TJSRelationalExpressionIn }
+
+Class function TJSRelationalExpressionIn.OperatorToken: tjsToken;
+begin
+  Result:=tjsIn;
+end;
+
+Class Function TJSRelationalExpressionIn.AllowCompact: Boolean;
+begin
+  Result:=False;
+end;
+
+{ TJSRelationalExpressionGE }
+
+Class function TJSRelationalExpressionGE.OperatorToken: tjsToken;
+begin
+  Result:=tjsGE;
+end;
+
+{ TJSRelationalExpressionLE }
+
+Class function TJSRelationalExpressionLE.OperatorToken: tjsToken;
+begin
+  Result:=tjsLE;
+end;
+
+{ TJSRelationalExpressionGT }
+
+Class function TJSRelationalExpressionGT.OperatorToken: tjsToken;
+begin
+  Result:=tjsGT;
+end;
+
+{ TJSRelationalExpressionLT }
+
+Class function TJSRelationalExpressionLT.OperatorToken: tjsToken;
+begin
+  Result:=tjsLT;
+end;
+
+{ TJSEqualityExpressionSNE }
+
+Class function TJSEqualityExpressionSNE.OperatorToken: tjsToken;
+begin
+  Result:=tjsSNE;
+end;
+
+{ TJSEqualityExpressionSEQ }
+
+Class function TJSEqualityExpressionSEQ.OperatorToken: tjsToken;
+begin
+  Result:=tjsSEQ;
+end;
+
+{ TJSEqualityExpressionNE }
+
+Class function TJSEqualityExpressionNE.OperatorToken: tjsToken;
+begin
+  Result:=tjsNE;
+end;
+
+{ TJSEqualityExpressionEQ }
+
+Class function TJSEqualityExpressionEQ.OperatorToken: tjsToken;
+begin
+  Result:=tjsEQ;
+end;
+
+{ TJSBinaryExpression }
+
+Class function TJSBinaryExpression.OperatorToken: tjsToken;
+begin
+  Result:=tjsUnknown
+end;
+
+Class function TJSBinaryExpression.OperatorString: string;
+
+Var
+  T : TJSToken;
+begin
+  T:=OperatorToken;
+  if (T<>tjsUnknown) then
+    begin
+    Result:=TokenInfos[T]
+    end
+  else
+    Result:='';
+end;
+
+Class Function TJSBinaryExpression.AllowCompact: Boolean;
+begin
+  Result:=True
+end;
+
+{ TJSBitwiseXOrExpression }
+
+Class function TJSBitwiseXOrExpression.OperatorToken : tjsToken;
+begin
+  Result:=tjsXor
+end;
+
+{ TJSBitwiseOrExpression }
+
+Class function TJSBitwiseOrExpression.OperatorToken : tjsToken;
+begin
+  Result:=tjsOr
+end;
+
+{ TJSBitwiseAndExpression }
+
+Class function TJSBitwiseAndExpression.OperatorToken : tjsToken;
+begin
+  Result:=tjsAnd
+end;
+
+{ TJSLogicalAndExpression }
+
+Class function TJSLogicalAndExpression.OperatorToken : tjsToken;
+begin
+  Result:=tjsAndAnd
+end;
+
+{ TJSLogicalOrExpression }
+
+Class function TJSLogicalOrExpression.OperatorToken : tjsToken;
+begin
+  Result:=tjsOrOr
+end;
+
+{ TJSUnaryVoidExpression }
+
+Class function TJSUnaryVoidExpression.PrefixOperatorToken : tjsToken;
+begin
+  Result:=tjsvoid;
+end;
+
+{ TJSThrowStatement }
+
+Class function TJSThrowStatement.PrefixOperatorToken: tjsToken;
+begin
+  Result:=tjsThrow;
+end;
+
+{ TJSUnaryPostMinusMinusExpression }
+
+Class function TJSUnaryPostMinusMinusExpression.PostFixOperatorToken : tjsToken;
+begin
+  Result:=tjsMinusMinus;
+end;
+
+{ TJSUnaryPostPlusPlusExpression }
+
+Class function TJSUnaryPostPlusPlusExpression.PostFixOperatorToken : tjsToken;
+begin
+  Result:=tjsPlusPlus;
+end;
+
+{ TJSUnaryNotExpression }
+
+Class function TJSUnaryNotExpression.PrefixOperatorToken : tjsToken;
+begin
+  Result:=tjsNot;
+end;
+
+{ TJSUnaryInvExpression }
+
+Class function TJSUnaryInvExpression.PrefixOperatorToken : tjsToken;
+begin
+  Result:=tjsinv;
+end;
+
+{ TJSUnaryMinusExpression }
+
+Class function TJSUnaryMinusExpression.PrefixOperatorToken : tjsToken;
+begin
+  Result:=tjsMinus;
+end;
+
+{ TJSUnaryPlusExpression }
+
+Class function TJSUnaryPlusExpression.PrefixOperatorToken : tjsToken;
+begin
+  Result:=tjsPlus;
+end;
+
+{ TJSUnaryPreMinusMinusExpression }
+
+Class function TJSUnaryPreMinusMinusExpression.PrefixOperatorToken : tjsToken;
+begin
+  Result:=tjsMinusMinus;
+end;
+
+{ TJSUnaryPrePlusPlusExpression }
+
+Class function TJSUnaryPrePlusPlusExpression.PrefixOperatorToken : tjsToken;
+begin
+  Result:=tjsPlusPlus;
+end;
+
+{ TJSUnaryTypeOfExpression }
+
+Class function TJSUnaryTypeOfExpression.PrefixOperatorToken : tjsToken;
+begin
+  Result:=tjsTypeOf;
+end;
+
+{ TJSUnaryDeleteExpression }
+
+Class function TJSUnaryDeleteExpression.PrefixOperatorToken : tjsToken;
+begin
+  Result:=tjsdelete;
+end;
+
 { TJSElement }
 
 constructor TJSElement.Create(ALine, ARow: Integer; Const ASource: String = '');
@@ -618,12 +1486,6 @@ begin
   Result:=TJSArrayLiteralElement(Items[AIndex]);
 end;
 
-procedure TJSArrayLiteralElements.SetE(AIndex : Integer;
-  const AValue: TJSArrayLiteralElement);
-begin
-  Items[AIndex]:=AValue;
-end;
-
 function TJSArrayLiteralElements.AddElement: TJSArrayLiteralElement;
 begin
   Result:=TJSArrayLiteralElement(Add);
@@ -651,11 +1513,6 @@ begin
   Result:=TJSObjectLiteralElement(Items[AIndex]);
 end;
 
-procedure TJSObjectLiteralElements.SetE(AIndex : Integer;
-  const AValue: TJSObjectLiteralElement);
-begin
-  Items[AIndex]:=AValue;
-end;
 
 function TJSObjectLiteralElements.AddElement: TJSObjectLiteralElement;
 begin
@@ -719,7 +1576,47 @@ end;
 
 { TJSUnary }
 
-destructor TJSUnary.Destroy;
+Class function TJSUnary.PrefixOperatorToken: tjsToken;
+begin
+  Result:=tjsUnknown;
+end;
+
+Class function TJSUnary.PostFixOperatorToken: tjsToken;
+begin
+  Result:=tjsUnknown;
+end;
+
+Class function TJSUnary.PrefixOperator: String;
+
+Var
+  T : TJSToken;
+
+begin
+  T:=PrefixOperatorToken;
+  if (T=tjsUnknown) then
+    Result:=''
+  else
+    begin
+    Result:=TokenInfos[t];
+    if t in [tjsTypeOf,tjsVoid,tjsDelete,tjsThrow] then
+      Result:=Result+' ';
+    end;
+end;
+
+Class function TJSUnary.PostFixOperator: String;
+
+Var
+  T : TJSToken;
+
+begin
+  T:=PostFixOperatorToken;
+  if (T=tjsUnknown) then
+    Result:=''
+  else
+    Result:=TokenInfos[t];
+end;
+
+Destructor TJSUnary.Destroy;
 begin
   FreeAndNil(FA);
   inherited Destroy;
@@ -746,13 +1643,30 @@ end;
 
 { TJSAssign }
 
-destructor TJSAssignStatement.Destroy;
+Destructor TJSAssignStatement.Destroy;
 begin
   FreeAndNil(FLHS);
   FreeAndNil(FExpr);
   inherited Destroy;
 end;
 
+Class function TJSAssignStatement.OperatorToken: tjsToken;
+begin
+  Result:=tjsUNknown;
+end;
+
+Class function TJSAssignStatement.OperatorString: String;
+
+Var
+  t :  TJSToken;
+begin
+  T:=OperatorToken;
+  if (tjsUNknown<>t) then
+    Result:=TokenInfos[t]
+  else
+    Result:='';
+end;
+
 { TJSVarDeclaration }
 
 
@@ -835,7 +1749,6 @@ end;
 destructor TJSSwitchStatement.Destroy;
 begin
   FreeAndNil(FCases);
-  FreeAndNil(FDefault);
   FreeAndNil(FCond);
   inherited Destroy;
 end;
@@ -847,10 +1760,6 @@ begin
   Result:=TJSCaseElement(Items[AIndex]);
 end;
 
-procedure TJSCaseElements.SetC(AIndex : Integer; const AValue: TJSCaseElement);
-begin
-  Items[AIndex]:=AValue;
-end;
 
 function TJSCaseElements.AddCase: TJSCaseElement;
 begin
@@ -900,10 +1809,6 @@ begin
   Result:=TJSElementNode(Items[Aindex])
 end;
 
-procedure TJSElementNodes.SetN(AIndex : Integer; const AValue: TJSElementNode);
-begin
-  Items[AIndex]:=Avalue;
-end;
 
 function TJSElementNodes.AddNode: TJSElementNode;
 begin