* Functions to aid in writing

git-svn-id: trunk@27031 -

packages/fcl-js/src/jstree.pp

@@ -5,7 +5,7 @@ unit jstree;
 interface
 
 uses
-  Classes, SysUtils, jsbase;
+  Classes, SysUtils, jsbase, jstoken;
 
 Type
   TJSElementFlag = (elIsConst,elIsConstValid);
@@ -17,18 +17,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 +65,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;
@@ -242,26 +267,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 +367,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 +561,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 +674,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 +700,8 @@ Type
     Property Cond : TJSElement Read FCond Write FCond;
   end;
 
-  TJSWhileStatement = Class(TJSCondLoopStatement)
-  end;
+  TJSWhileStatement = Class(TJSCondLoopStatement);
+  TJSDoWhileStatement = Class(TJSWhileStatement);
 
   { TJSForStatement }
 
@@ -469,7 +761,7 @@ Type
     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 Write SetC;default;
   end;
 
   { TJSSwitch }
@@ -491,9 +783,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 }
@@ -574,6 +869,386 @@ Type
 
 implementation
 
+{ 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 = '');
@@ -719,7 +1394,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 +1461,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 +1567,6 @@ end;
 destructor TJSSwitchStatement.Destroy;
 begin
   FreeAndNil(FCases);
-  FreeAndNil(FDefault);
   FreeAndNil(FCond);
   inherited Destroy;
 end;