Add code

2026-09-11 22:44:59 -04:00 · 2019-01-23 22:52:45 -05:00
parent 3f69ec7987
commit ad50a19057
103 changed files with 5734 additions and 1 deletions
@@ -0,0 +1,24 @@
+using System;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Declarations
+{
+    abstract class Declaration
+    {
+        public readonly ScriptToken Start;
+        public readonly ScriptToken End;
+
+        protected Declaration(ScriptToken start, ScriptToken end = null)
+        {
+            if (start == null)
+                throw new ArgumentNullException("start");
+
+            Start = start;
+            End = end ?? start;
+        }
+
+        public abstract TDecl Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor);
+
+        public abstract void SetParent();
+    }
+}
@@ -0,0 +1,34 @@
+using ScriptConverter.Ast.Expressions;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Declarations
+{
+    class FieldDeclaration : Declaration
+    {
+        public ScriptType Type { get; private set; }
+        public string Name { get; private set; }
+        public Expression Value { get; private set; }
+        public bool IsConstant { get; private set; }
+        public bool IsPublic { get; private set; }
+
+        public FieldDeclaration(ScriptToken start, ScriptToken end, ScriptType type, string name, Expression value, bool isConst, bool isPublic)
+            : base(start, end)
+        {
+            Type = type;
+            Name = name;
+            Value = value;
+            IsConstant = isConst;
+            IsPublic = isPublic;
+        }
+
+        public override TDecl Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent()
+        {
+            Value.SetParent(null);
+        }
+    }
+}
@@ -0,0 +1,25 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Declarations
+{
+    class IncludeDeclaration : Declaration
+    {
+        public string Name { get; private set; }
+
+        public IncludeDeclaration(ScriptToken start, ScriptToken end, string name)
+            : base(start, end)
+        {
+            Name = name;
+        }
+
+        public override TDecl Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent()
+        {
+
+        }
+    }
+}
@@ -0,0 +1,25 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Declarations
+{
+    class InheritsDeclaration : Declaration
+    {
+        public string Name { get; private set; }
+
+        public InheritsDeclaration(ScriptToken start, ScriptToken end, string name)
+            : base(start, end)
+        {
+            Name = name;
+        }
+
+        public override TDecl Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent()
+        {
+
+        }
+    }
+}
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using ScriptConverter.Ast.Statements;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Declarations
+{
+    class MethodDeclaration : Declaration
+    {
+        public class Parameter
+        {
+            public ScriptType Type { get; private set; }
+            public string Name { get; private set; }
+
+            public Parameter(ScriptType type, string name)
+            {
+                Type = type;
+                Name = name;
+            }
+        }
+
+        public ScriptType ReturnType { get; private set; }
+        public string Name { get; private set; }
+        public ReadOnlyCollection<Parameter> Parameters { get; private set; }
+        public BlockStatement Block { get; private set; }
+
+        public MethodDeclaration(ScriptToken start, ScriptToken end, ScriptType returnType, string name, List<Parameter> parameters, BlockStatement block)
+            : base(start, end)
+        {
+            ReturnType = returnType;
+            Name = name;
+            Parameters = parameters.AsReadOnly();
+            Block = block;
+        }
+
+        public override TDecl Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent()
+        {
+            Block.SetParent(null);
+        }
+    }
+}
@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using ScriptConverter.Ast.Declarations;
+
+namespace ScriptConverter.Ast
+{
+    class Document
+    {
+        public ReadOnlyCollection<Declaration> Declarations { get; private set; }
+
+        public Document(IEnumerable<Declaration> declarations)
+        {
+            Declarations = declarations
+                .ToList()
+                .AsReadOnly();
+        }
+    }
+}
@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    class ArrayInitializerExpression : Expression
+    {
+        public ReadOnlyCollection<Expression> Values { get; private set; }
+
+        public ArrayInitializerExpression(ScriptToken start, ScriptToken end, List<Expression> values)
+            : base(start, end)
+        {
+            Values = values.AsReadOnly();
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+
+            foreach (var expression in Values)
+            {
+                expression.SetParent(this);
+            }
+        }
+    }
+}
@@ -0,0 +1,32 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    class BinaryOperatorExpression : Expression
+    {
+        public ScriptTokenType Operation { get; private set; }
+        public Expression Left { get; private set; }
+        public Expression Right { get; private set; }
+
+        public BinaryOperatorExpression(ScriptTokenType op, Expression left, Expression right)
+            : base(left.Start, right.End)
+        {
+            Operation = op;
+            Left = left;
+            Right = right;
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+
+            Left.SetParent(this);
+            Right.SetParent(this);
+        }
+    }
+}
@@ -0,0 +1,25 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    class BoolExpression : Expression
+    {
+        public bool Value { get; private set; }
+
+        public BoolExpression(ScriptToken token, bool value)
+            : base(token)
+        {
+            Value = value;
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+        }
+    }
+}
@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    class CallExpression : Expression
+    {
+        public Expression Left { get; private set; }
+        public ReadOnlyCollection<Expression> Parameters { get; private set; }
+         
+        public CallExpression(ScriptToken end, Expression left, List<Expression> parameters) 
+            : base(left.Start, end)
+        {
+            Left = left;
+            Parameters = parameters.AsReadOnly();
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+
+            Left.SetParent(this);
+
+            foreach (var expression in Parameters)
+            {
+                expression.SetParent(this);
+            }
+        }
+    }
+}
@@ -0,0 +1,29 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    class CastExpression : Expression
+    {
+        public ScriptType Type { get; private set; }
+        public Expression Value { get; private set; }
+
+        public CastExpression(ScriptToken start, ScriptType type, Expression value)
+            : base(start, value.End)
+        {
+            Type = type;
+            Value = value;
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+
+            Value.SetParent(this);
+        }
+    }
+}
@@ -0,0 +1,25 @@
+using System;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    abstract class Expression
+    {
+        public readonly ScriptToken Start;
+        public readonly ScriptToken End;
+        public Expression Parent { get; protected set; }
+
+        protected Expression(ScriptToken start, ScriptToken end = null)
+        {
+            if (start == null)
+                throw new ArgumentNullException("start");
+
+            Start = start;
+            End = end ?? start;
+        }
+
+        public abstract TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor);
+
+        public abstract void SetParent(Expression parent);
+    }
+}
@@ -0,0 +1,29 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    class FieldExpression : Expression
+    {
+        public Expression Left { get; private set; }
+        public string Name { get; private set; }
+
+        public FieldExpression(Expression left, ScriptToken name)
+            : base(left.Start, name)
+        {
+            Left = left;
+            Name = name.Contents;
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+
+            Left.SetParent(this);
+        }
+    }
+}
@@ -0,0 +1,25 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    class IdentifierExpression : Expression
+    {
+        public string Name { get; private set; }
+
+        public IdentifierExpression(ScriptToken token)
+            : base(token)
+        {
+            Name = token.Contents;
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+        }
+    }
+}
@@ -0,0 +1,30 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    class IndexerExpression : Expression
+    {
+        public Expression Left { get; private set; }
+        public Expression Index { get; private set; }
+
+        public IndexerExpression(ScriptToken end, Expression left, Expression index)
+            : base(left.Start, end)
+        {
+            Left = left;
+            Index = index;
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+
+            Left.SetParent(this);
+            Index.SetParent(this);
+        }
+    }
+}
@@ -0,0 +1,29 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    class InstanceOfExpression : Expression
+    {
+        public Expression Left { get; private set; }
+        public ScriptType Type { get; private set; }
+
+        public InstanceOfExpression(ScriptToken end, Expression left, ScriptType type)
+            : base(left.Start, end)
+        {
+            Left = left;
+            Type = type;
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+
+            Left.SetParent(this);
+        }
+    }
+}
@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    class NewExpression : Expression
+    {
+        public string Type { get; private set; }
+        public bool IsArray { get { return ArrayDimensions > 0; } }
+        public int ArrayDimensions { get; private set; }
+        public ReadOnlyCollection<Expression> Parameters { get; private set; }
+        public ReadOnlyCollection<Expression> Initializer { get; private set; }
+         
+        public NewExpression(ScriptToken start, ScriptToken end, string type, int arrayDimensions, List<Expression> parameters, List<Expression> initializer = null)
+            : base(start, end)
+        {
+            Type = type;
+            ArrayDimensions = arrayDimensions;
+            Parameters = parameters.AsReadOnly();
+            Initializer = initializer != null ? initializer.AsReadOnly() : null;
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+
+            foreach (var expression in Parameters)
+            {
+                expression.SetParent(this);
+            }
+
+            if (Initializer != null)
+            {
+                foreach (var expression in Initializer)
+                {
+                    expression.SetParent(this);
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,23 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    class NullExpression : Expression
+    {
+        public NullExpression(ScriptToken token)
+            : base(token)
+        {
+            
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+        }
+    }
+}
@@ -0,0 +1,25 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    class NumberExpression : Expression
+    {
+        public string Value { get; private set; }
+
+        public NumberExpression(ScriptToken token)
+            : base(token)
+        {
+            Value = token.Contents;
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+        }
+    }
+}
@@ -0,0 +1,29 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    class PostfixOperatorExpression : Expression
+    {
+        public ScriptTokenType Operation { get; private set; }
+        public Expression Left { get; private set; }
+
+        public PostfixOperatorExpression(ScriptToken end, Expression left)
+            : base(left.Start, end)
+        {
+            Operation = end.Type;
+            Left = left;
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+
+            Left.SetParent(this);
+        }
+    }
+}
@@ -0,0 +1,29 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    class PrefixOperatorExpression : Expression
+    {
+        public ScriptTokenType Operation { get; private set; }
+        public Expression Right { get; private set; }
+
+        public PrefixOperatorExpression(ScriptToken start, Expression right)
+            : base(start, right.End)
+        {
+            Operation = start.Type;
+            Right = right;
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+
+            Right.SetParent(this);
+        }
+    }
+}
@@ -0,0 +1,27 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Expressions
+{
+    class StringExpression : Expression
+    {
+        public string Value { get; private set; }
+        public bool IsSingleQuote { get; private set; }
+
+        public StringExpression(ScriptToken token, bool singleQuote)
+            : base(token)
+        {
+            Value = token.Contents;
+            IsSingleQuote = singleQuote;
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+        }
+    }
+}
@@ -0,0 +1,31 @@
+namespace ScriptConverter.Ast.Expressions
+{
+    class TernaryExpression : Expression
+    {
+        public Expression Condition { get; private set; }
+        public Expression TrueExpression { get; private set; }
+        public Expression FalseExpression { get; private set; }
+
+        public TernaryExpression(Expression condition, Expression trueExpression, Expression falseExpression)
+            : base(condition.Start, falseExpression.End)
+        {
+            Condition = condition;
+            TrueExpression = trueExpression;
+            FalseExpression = falseExpression;
+        }
+
+        public override TExpr Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Expression parent)
+        {
+            Parent = parent;
+        
+            Condition.SetParent(this);
+            TrueExpression.SetParent(this);
+            FalseExpression.SetParent(this);
+        }
+    }
+}
@@ -0,0 +1,48 @@
+using ScriptConverter.Ast.Declarations;
+using ScriptConverter.Ast.Expressions;
+using ScriptConverter.Ast.Statements;
+
+namespace ScriptConverter.Ast
+{
+    interface IAstVisitor<out TDoc, out TDecl, out TStmt, out TExpr>
+    {
+        TDoc Visit(Document document);
+
+        TDecl Visit(FieldDeclaration declaration);
+        TDecl Visit(IncludeDeclaration declaration);
+        TDecl Visit(InheritsDeclaration declaration);
+        TDecl Visit(MethodDeclaration declaration);
+
+        TStmt Visit(BlockStatement statement);
+        TStmt Visit(BreakStatement statement);
+        TStmt Visit(ContinueStatement statement);
+        TStmt Visit(DoStatement statement);
+        TStmt Visit(EmptyStatement statement);
+        TStmt Visit(ForStatement statement);
+        TStmt Visit(IfStatement statement);
+        TStmt Visit(NakedStatement statement);
+        TStmt Visit(ReturnStatement statement);
+        TStmt Visit(SwitchStatement statement);
+        TStmt Visit(ThrowStatement statement);
+        TStmt Visit(TryStatement statement);
+        TStmt Visit(VariableStatement statement);
+        TStmt Visit(WhileStatement statement);
+
+        TExpr Visit(ArrayInitializerExpression expression);
+        TExpr Visit(BinaryOperatorExpression expression);
+        TExpr Visit(BoolExpression expression);
+        TExpr Visit(CallExpression expression);
+        TExpr Visit(CastExpression expression);
+        TExpr Visit(FieldExpression expression);
+        TExpr Visit(IdentifierExpression expression);
+        TExpr Visit(IndexerExpression expression);
+        TExpr Visit(InstanceOfExpression expression);
+        TExpr Visit(NewExpression expression);
+        TExpr Visit(NullExpression expression);
+        TExpr Visit(NumberExpression expression);
+        TExpr Visit(PostfixOperatorExpression expression);
+        TExpr Visit(PrefixOperatorExpression expression);
+        TExpr Visit(StringExpression expression);
+        TExpr Visit(TernaryExpression expression);
+    }
+}
@@ -0,0 +1,48 @@
+using System.Linq;
+
+namespace ScriptConverter.Ast
+{
+    class ScriptType
+    {
+        public string Name { get; private set; }
+        public bool IsArray { get { return ArrayDimensions > 0; } }
+        public bool IsResizable { get; private set; }
+        public int ArrayDimensions { get; private set; }
+
+        public ScriptType(string name, int arrayDimensions = 0, bool isResizable = false)
+        {
+            if (name == "unknown")
+                name = "Object";
+
+            if (name == "string")
+                name = "String";
+
+            if (name == "modifyable_int")
+                name = "modifiable_int";
+
+            if (name == "modifyable _float")
+                name = "modifiable_float";
+
+            if (name == "modifyable_string_id")
+                name = "modifiable_string_id";
+
+            if (isResizable)
+                arrayDimensions = 1;
+
+            Name = name;
+            IsResizable = isResizable;
+            ArrayDimensions = arrayDimensions;
+        }
+
+        public override string ToString()
+        {
+            if (IsResizable)
+                return "Vector";
+
+            if (!IsArray)
+                return Name;
+
+            return Name + string.Join("", Enumerable.Repeat("[]", ArrayDimensions));
+        }
+    }
+}
@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Statements
+{
+    class BlockStatement : Statement
+    {
+        public ReadOnlyCollection<Statement> Statements { get; private set; }
+        public bool IsSwitch { get; private set; }
+
+        public BlockStatement(ScriptToken start, ScriptToken end, List<Statement> statements, bool isSwitch = false)
+            : base(start, end)
+        {
+            if (statements == null)
+                throw new ArgumentNullException("statements");
+
+            Statements = statements.AsReadOnly();
+            IsSwitch = isSwitch;
+        }
+
+        public override TStmt Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Statement parent)
+        {
+            Parent = parent;
+
+            foreach (var statement in Statements)
+            {
+                statement.SetParent(this);
+            }
+        }
+    }
+}
@@ -0,0 +1,23 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Statements
+{
+    class BreakStatement : Statement
+    {
+        public BreakStatement(ScriptToken token)
+            : base(token)
+        {
+            
+        }
+
+        public override TStmt Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Statement parent)
+        {
+            Parent = parent;
+        }
+    }
+}
@@ -0,0 +1,23 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Statements
+{
+    class ContinueStatement : Statement
+    {
+        public ContinueStatement(ScriptToken token)
+            : base(token)
+        {
+
+        }
+
+        public override TStmt Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Statement parent)
+        {
+            Parent = parent;
+        }
+    }
+}
@@ -0,0 +1,31 @@
+using ScriptConverter.Ast.Expressions;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Statements
+{
+    class DoStatement : Statement
+    {
+        public Expression Condition { get; private set; }
+        public BlockStatement Block { get; private set; }
+
+        public DoStatement(ScriptToken start, ScriptToken end, Expression condition, BlockStatement block)
+            : base(start, end)
+        {
+            Condition = condition;
+            Block = block;
+        }
+
+        public override TStmt Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Statement parent)
+        {
+            Parent = parent;
+
+            Condition.SetParent(null);
+            Block.SetParent(this);
+        }
+    }
+}
@@ -0,0 +1,23 @@
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Statements
+{
+    class EmptyStatement : Statement
+    {
+        public EmptyStatement(ScriptToken token)
+            : base(token)
+        {
+            
+        }
+
+        public override TStmt Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Statement parent)
+        {
+            Parent = parent;
+        }
+    }
+}
@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using ScriptConverter.Ast.Expressions;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Statements
+{
+    class ForStatement : Statement
+    {
+        public ReadOnlyCollection<Statement> Initializers { get; private set; }
+        public Expression Condition { get; private set; }
+        public ReadOnlyCollection<Expression> Increment { get; private set; }
+        public BlockStatement Block { get; private set; }
+
+        public ForStatement(ScriptToken start, ScriptToken end, List<Statement> initializers, Expression condition, List<Expression> increment, BlockStatement block)
+            : base(start, end)
+        {
+            Initializers = initializers != null ? initializers.AsReadOnly() : null;
+            Condition = condition;
+            Increment = increment != null ? increment.AsReadOnly() : null;
+            Block = block;
+        }
+
+        public override TStmt Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Statement parent)
+        {
+            Parent = parent;
+
+            if (Initializers != null)
+            {
+                foreach (var statement in Initializers)
+                {
+                    statement.SetParent(this);
+                }
+            }
+
+            if (Condition != null)
+                Condition.SetParent(null);
+
+            if (Increment != null)
+            {
+                foreach (var expression in Increment)
+                {
+                    expression.SetParent(null);
+                }
+            }
+
+            Block.SetParent(this);
+        }
+    }
+}
@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using ScriptConverter.Ast.Expressions;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Statements
+{
+    class IfStatement : Statement
+    {
+        public class Branch
+        {
+            public Expression Condition { get; private set; }
+            public BlockStatement Block { get; private set; }
+
+            public Branch(Expression condition, BlockStatement block)
+            {
+                Condition = condition;
+                Block = block;
+            }
+        }
+
+        public ReadOnlyCollection<Branch> Branches { get; private set; }
+        public Branch DefaultBranch { get; private set; }
+
+        public IfStatement(ScriptToken start, ScriptToken end, List<Branch> branches, Branch defaultBranch)
+            : base(start, end)
+        {
+            Branches = branches.AsReadOnly();
+            DefaultBranch = defaultBranch;
+        }
+
+        public override TStmt Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Statement parent)
+        {
+            Parent = parent;
+
+            foreach (var branch in Branches)
+            {
+                branch.Condition.SetParent(null);
+                branch.Block.SetParent(this);
+            }
+
+            if (DefaultBranch != null)
+            {
+                DefaultBranch.Block.SetParent(this);
+            }
+        }
+    }
+}
@@ -0,0 +1,27 @@
+using ScriptConverter.Ast.Expressions;
+
+namespace ScriptConverter.Ast.Statements
+{
+    class NakedStatement : Statement
+    {
+        public Expression Expression { get; private set; }
+
+        public NakedStatement(Expression expression)
+            : base(expression.Start, expression.End)
+        {
+            Expression = expression;
+        }
+
+        public override TStmt Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Statement parent)
+        {
+            Parent = parent;
+
+            Expression.SetParent(null);
+        }
+    }
+}
@@ -0,0 +1,29 @@
+using ScriptConverter.Ast.Expressions;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Statements
+{
+    class ReturnStatement : Statement
+    {
+        public Expression Value { get; private set; }
+
+        public ReturnStatement(ScriptToken start, ScriptToken end, Expression value)
+            : base(start, end)
+        {
+            Value = value;
+        }
+
+        public override TStmt Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Statement parent)
+        {
+            Parent = parent;
+
+            if (Value != null)
+                Value.SetParent(null);
+        }
+    }
+}
@@ -0,0 +1,25 @@
+using System;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Statements
+{
+    abstract class Statement
+    {
+        public readonly ScriptToken Start;
+        public readonly ScriptToken End;
+        public Statement Parent { get; protected set; }
+
+        protected Statement(ScriptToken start, ScriptToken end = null)
+        {
+            if (start == null)
+                throw new ArgumentNullException("start");
+
+            Start = start;
+            End = end ?? start;
+        }
+
+        public abstract TStmt Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor);
+
+        public abstract void SetParent(Statement parent);
+    }
+}
@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using ScriptConverter.Ast.Expressions;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Statements
+{
+    class SwitchStatement : Statement
+    {
+        public class Branch
+        {
+            public ReadOnlyCollection<Expression> Conditions { get; private set; }
+            public BlockStatement Block { get; private set; }
+
+            public Branch(List<Expression> conditions, BlockStatement block)
+            {
+                Conditions = conditions.AsReadOnly();
+                Block = block;
+            }
+        }
+
+        public Expression Expression { get; private set; }
+        public ReadOnlyCollection<Branch> Branches { get; private set; } 
+
+        public SwitchStatement(ScriptToken start, ScriptToken end, Expression expression, List<Branch> branches)
+            : base(start, end)
+        {
+            Expression = expression;
+            Branches = branches.AsReadOnly();
+        }
+
+        public override TStmt Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Statement parent)
+        {
+            Parent = parent;
+
+            Expression.SetParent(null);
+
+            foreach (var branch in Branches)
+            {
+                foreach (var expression in branch.Conditions)
+                {
+                    if (expression != null)
+                        expression.SetParent(null);
+                }
+
+                branch.Block.SetParent(this);
+            }
+        }
+    }
+}
@@ -0,0 +1,28 @@
+using ScriptConverter.Ast.Expressions;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Statements
+{
+    class ThrowStatement : Statement
+    {
+        public Expression Value { get; private set; }
+        
+        public ThrowStatement(ScriptToken start, Expression value)
+            : base(start, value.End)
+        {
+            Value = value;
+        }
+
+        public override TStmt Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Statement parent)
+        {
+            Parent = parent;
+
+            Value.SetParent(null);
+        }
+    }
+}
@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Statements
+{
+    class TryStatement : Statement
+    {
+        public class Branch
+        {
+            public ScriptType Type { get; private set; }
+            public string Name { get; private set; }
+            public BlockStatement Block { get; private set; }
+
+            public Branch(ScriptType type, string name, BlockStatement block)
+            {
+                Type = type;
+                Name = name;
+                Block = block;
+            }
+        }
+
+        public BlockStatement Block { get; private set; }
+        public ReadOnlyCollection<Branch> Branches { get; private set; }
+
+        public TryStatement(ScriptToken start, ScriptToken end, BlockStatement block, List<Branch> branches) : base(start, end)
+        {
+            if (branches.Count < 1)
+                throw new ArgumentException("need at least 1 branch", "branches");
+
+            Block = block;
+            Branches = branches.AsReadOnly();
+        }
+
+        public override TStmt Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Statement parent)
+        {
+            Parent = parent;
+
+            Block.SetParent(this);
+
+            foreach (var branch in Branches)
+            {
+                branch.Block.SetParent(this);
+            }
+        }
+    }
+}
@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using ScriptConverter.Ast.Expressions;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Statements
+{
+    class VariableStatement : Statement
+    {
+        public class Definition
+        {
+            public ScriptType Type { get; private set; }
+            public string Name { get; private set; }
+            public Expression Value { get; private set; }
+
+            public Definition(ScriptType type, string name, Expression value)
+            {
+                Type = type;
+                Name = name;
+                Value = value;
+            }
+        }
+
+        public ScriptType BaseType { get; private set; }
+        public bool Final { get; private set; }
+        public ReadOnlyCollection<Definition> Definitions { get; private set; } 
+
+        public VariableStatement(ScriptToken start, ScriptToken end, ScriptType baseType, bool final, List<Definition> definitions)
+            : base(start, end)
+        {
+            if (definitions.Count < 1)
+                throw new ArgumentException("need at least 1 definition", "definitions");
+
+            BaseType = baseType;
+            Final = final;
+            Definitions = definitions.AsReadOnly();
+        }
+
+        public override TStmt Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Statement parent)
+        {
+            Parent = parent;
+
+            foreach (var definition in Definitions)
+            {
+                if (definition.Value != null)
+                    definition.Value.SetParent(null);
+            }
+        }
+    }
+}
@@ -0,0 +1,31 @@
+using ScriptConverter.Ast.Expressions;
+using ScriptConverter.Parser;
+
+namespace ScriptConverter.Ast.Statements
+{
+    class WhileStatement : Statement
+    {
+        public Expression Condition { get; private set; }
+        public BlockStatement Block { get; private set; }
+
+        public WhileStatement(ScriptToken start, ScriptToken end, Expression condition, BlockStatement block)
+            : base(start, end)
+        {
+            Condition = condition;
+            Block = block;
+        }
+
+        public override TStmt Accept<TDoc, TDecl, TStmt, TExpr>(IAstVisitor<TDoc, TDecl, TStmt, TExpr> visitor)
+        {
+            return visitor.Visit(this);
+        }
+
+        public override void SetParent(Statement parent)
+        {
+            Parent = parent;
+
+            Condition.SetParent(null);
+            Block.SetParent(this);
+        }
+    }
+}