move interesting projects to the root

JackCompiler/JackAnalyzer/Constants.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace JackAnalyzer
+{
+    class Constants
+    {
+        public const string inExt = ".jack";
+
+        public static readonly char[] symbols = { '{', '}', '(', ')', '[', ']', '.', ',', ';', '+', '-', '*', '/', '&', '|', '<', '>', '=', '~' };
+        public static readonly string[] keywords = { "class", "constructor", "function", "method", "field", "static", "var", "int", "char", "boolean", "void", "true", "false", "null", "this", "let", "do", "if", "else", "while", "return" };
+        public static readonly char[] op = { '+', '-', '*', '/', '&', '|', '<', '>', '=' };
+        public static readonly char[] unaryOp = { '-', '~' };
+
+        public const int indentLevel = 2;
+    }
+}

JackCompiler/JackAnalyzer/JackAnalyzer.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+</Project>

JackCompiler/JackAnalyzer/MetaSymbolTable.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace JackAnalyzer
+{
+    public class MetaSymbolTable
+    {
+        private SymbolTable ClassSymbolTable = new SymbolTable();
+        private SymbolTable FunctionSymbolTable = new SymbolTable();
+
+        public MetaSymbolTable()
+        {
+
+        }
+
+        public void Define(string name, string type, SymbolKind kind)
+        {
+            if (kind == SymbolKind.Field || kind == SymbolKind.Static)
+            {
+                ClassSymbolTable.Define(name, type, kind);
+            }
+            else
+            {
+                FunctionSymbolTable.Define(name, type, kind);
+            }
+        }
+
+        internal void ResetFieldTable()
+        {
+            ClassSymbolTable.ResetFields();
+        }
+
+        public int VarCount(SymbolKind kind)
+        {
+            if (kind == SymbolKind.Field || kind == SymbolKind.Static)
+            {
+                return ClassSymbolTable.VarCount(kind);
+            }
+            else
+            {
+                return FunctionSymbolTable.VarCount(kind);
+            }
+        }
+
+        public SymbolKind KindOf(string name)
+        {
+            try
+            {
+                return FunctionSymbolTable.KindOf(name);
+            }
+            catch
+            {
+                return ClassSymbolTable.KindOf(name);
+            }
+        }
+
+        public string TypeOf(string name)
+        {
+            try
+            {
+                return FunctionSymbolTable.TypeOf(name);
+            }
+            catch
+            {
+                return ClassSymbolTable.TypeOf(name);
+            }
+        }
+
+        public int IndexOf(string name)
+        {
+            try
+            {
+                return FunctionSymbolTable.IndexOf(name);
+            }
+            catch
+            {
+                return ClassSymbolTable.IndexOf(name);
+            }
+        }
+
+        public void ResetFunctionTable()
+        {
+            FunctionSymbolTable = new SymbolTable();
+        }
+    }
+}

JackCompiler/JackAnalyzer/Program.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace JackAnalyzer
+{
+    class Program
+    {
+
+        static int Main(string[] args)
+        {
+            if (args.Length < 1)
+            {
+                Console.WriteLine("Not enough arguments");
+                return 1;
+            }
+
+            string inPath = args[0];
+
+            List<string> inFiles = new List<string>();
+
+            if (Directory.Exists(inPath))
+            {
+                string[] files = Directory.GetFiles(inPath);
+                foreach(string file in files)
+                {
+                    if(Path.GetExtension(file) == Constants.inExt)
+                    {
+                        inFiles.Add(file);
+                    }
+                }
+            }
+            else if (File.Exists(inPath))
+            {
+                if (Path.GetExtension(inPath) == Constants.inExt)
+                {
+                    inFiles.Add(inPath);
+                }
+            }
+            else
+            {
+                Console.WriteLine("No input files");
+                return 2;
+            }
+
+            foreach(string file in inFiles)
+            {
+                Tokenizer tokenizer = new Tokenizer(file);
+                tokenizer.WriteTokens(file);
+                var tokens = tokenizer.Tokens;
+                Writer writer = new Writer(file, tokens);
+            }
+
+            return 0;
+        }
+    }
+}

JackCompiler/JackAnalyzer/SymbolTable.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace JackAnalyzer
+{
+    public enum SymbolKind
+    {
+        Static,
+        Field,
+        Arg,
+        Var,
+        None
+    }
+    public class SymbolTable
+    {
+        Dictionary<string, ValueTuple<string, SymbolKind, int>> table = new Dictionary<string, (string, SymbolKind, int)>();
+        Dictionary<SymbolKind, int> kindCounter = new Dictionary<SymbolKind, int>();
+
+        public SymbolTable()
+        {
+        }
+
+        public void Define(string name, string type, SymbolKind kind)
+        {
+            int count;
+            kindCounter.TryGetValue(kind, out count);
+            kindCounter[kind] = count + 1;
+
+            table.Add(name, (type, kind, count));
+        }
+
+        public int VarCount(SymbolKind kind)
+        {
+            try
+            {
+            return kindCounter[kind];
+            } catch
+            {
+                return 0;
+            }
+        }
+
+        public SymbolKind KindOf(string name)
+        {
+            return table[name].Item2;
+        }
+
+        public string TypeOf(string name)
+        {
+            return table[name].Item1;
+        }
+
+        public int IndexOf(string name)
+        {
+            return table[name].Item3;
+        }
+
+        public void ResetFields()
+        {
+            kindCounter[SymbolKind.Field] = 0;
+            var itemsToRemove = table.Where(f => f.Value.Item2 == SymbolKind.Field).ToArray();
+            foreach (var item in itemsToRemove)
+            {
+                table.Remove(item.Key);
+            }
+        }
+    }
+}

JackCompiler/JackAnalyzer/Token.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace JackAnalyzer
+{
+    enum TokenType
+    {
+        keyword,
+        identifier,
+        symbol,
+        integerConstant,
+        stringConstant
+    }
+}

JackCompiler/JackAnalyzer/Tokenizer.cs

@@ -0,0 +1,179 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Linq;
+using System.Security;
+
+namespace JackAnalyzer
+{
+    class Tokenizer
+    {
+        public List<KeyValuePair<TokenType, string>> Tokens { get; }
+
+        public Tokenizer(string file)
+        {
+            Tokens = new List<KeyValuePair<TokenType, string>>();
+
+            string[] text = File.ReadAllLines(file);
+
+            string word = "";
+
+            bool readingComment = false;
+
+            foreach (string line in text)
+            {
+                // Ignore comments and empty lines
+                if (line.Length > 0)
+                {
+                    bool readingString = false;
+
+                    // This is used for comment detection
+                    char prevSymbol = '\0';
+
+                    foreach (char c in line)
+                    {
+                        if (readingComment)
+                        {
+                            if (c == '/' && prevSymbol == '*')
+                            {
+                                readingComment = false;
+                                continue;
+                            }
+                            else
+                            {
+                                prevSymbol = c;
+                                continue;
+                            }
+                        }
+                        if (c == '"')
+                        {
+                            if (readingString)
+                            {
+                                readingString = false;
+
+                                PutStringConst(word);
+                                word = "";
+                                continue;
+                            }
+                            else
+                            {
+                                readingString = true;
+                                continue;
+                            }
+                        }
+
+                        if (readingString)
+                        {
+                            word += c;
+                            continue;
+                        }
+
+                        if (Constants.symbols.Contains(c))
+                        {
+                            // Detect comments
+                            if (prevSymbol == '/' && c == '/')
+                            {
+                                // If we're looking at a comment, that means
+                                // we need to remove the previous symbol and
+                                // discard the rest of the string
+                                if (Tokens.Count > 0)
+                                {
+                                    Tokens.RemoveAt(Tokens.Count - 1);
+                                }
+                                break;
+                            }
+                            if (prevSymbol == '/' && c == '*')
+                            {
+                                // If we're looking at a multi-line, that means
+                                // we need to remove the previous symbol and
+                                // discard the rest of the comment
+                                if (Tokens.Count > 0)
+                                {
+                                    Tokens.RemoveAt(Tokens.Count - 1);
+                                }
+                                readingComment = true;
+                                continue;
+                            }
+
+                            prevSymbol = c;
+
+                            PutString(word);
+                            PutString(char.ToString(c));
+                            word = "";
+                            continue;
+                        }
+
+                        word += c;
+
+                        if (c == ' ')
+                        {
+                            PutString(word);
+                            word = "";
+                        }
+                    }
+
+                }
+
+            }
+        }
+
+        public void WriteTokens(string path)
+        {
+            string filename = Path.GetDirectoryName(path) + '/' + Path.GetFileNameWithoutExtension(path) + "T.xml";
+            using (StreamWriter file = new StreamWriter(filename))
+            {
+                file.WriteLine("<tokens>");
+                foreach (var token in Tokens)
+                {
+                    var name = Enum.GetName(typeof(TokenType), token.Key);
+                    var value = token.Value;
+                    file.WriteLine('<' + name + "> " + SecurityElement.Escape(value) + " </" + name + '>');
+                }
+                file.WriteLine("</tokens>");
+            }
+        }
+
+        private void PutStringConst(string token)
+        {
+            var str = new KeyValuePair<TokenType, string>(TokenType.stringConstant, token);
+            Tokens.Add(str);
+            return;
+        }
+
+        private void PutString(string token)
+        {
+            var trimmed = token.Trim();
+
+            if (trimmed.Length == 1 && Constants.symbols.Contains(trimmed[0]))
+            {
+                var symbol = new KeyValuePair<TokenType, string>(TokenType.symbol, trimmed);
+                Tokens.Add(symbol);
+                return;
+            }
+
+            if (Constants.keywords.Contains(trimmed))
+            {
+                var keyword = new KeyValuePair<TokenType, string>(TokenType.keyword, trimmed);
+                Tokens.Add(keyword);
+                return;
+            }
+
+            if (int.TryParse(trimmed, out _))
+            {
+                var integerConstant = new KeyValuePair<TokenType, string>(TokenType.integerConstant, trimmed);
+                Tokens.Add(integerConstant);
+                return;
+            }
+
+            if (trimmed.Length > 0)
+            {
+                var identifier = new KeyValuePair<TokenType, string>(TokenType.identifier, trimmed);
+                Tokens.Add(identifier);
+                return;
+            }
+
+        }
+
+    }
+}

JackCompiler/JackAnalyzer/VMWriter.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace JackAnalyzer
+{
+    enum Segment
+    {
+        Constant, Argument, Local, Static, This, That, Pointer, Temp
+    }
+
+    enum ArithmeticOp
+    {
+        Add, Sub, Neg, Eq, Gt, Lt, And, Or, Not
+    }
+    class VMWriter
+    {
+        StreamWriter file;
+        List<string> cache = new List<string>();
+        int funcDef = 0;
+
+        public VMWriter(string path)
+        {
+            string filename = Path.ChangeExtension(path, ".vm");
+            file = new StreamWriter(filename);
+            file.AutoFlush = true;
+        }
+
+        public void Dispose()
+        {       
+            foreach (string l in cache)
+            {
+                file.WriteLine(l);
+            }
+            file.Close();
+            file.Dispose();
+        }
+
+        public void WritePush(Segment segment, int index)
+        {
+            cache.Add($"push {Enum.GetName(typeof(Segment),segment).ToLower()} {index}");
+        }
+
+        public void WritePop(Segment segment, int index)
+        {
+            cache.Add($"pop {Enum.GetName(typeof(Segment), segment).ToLower()} {index}");
+        }
+
+        public void WriteArithmetic(ArithmeticOp op)
+        {
+            cache.Add(Enum.GetName(typeof(ArithmeticOp), op).ToLower());
+        }
+
+        public void WriteLabel(string label)
+        {
+            cache.Add($"label {label}");
+        }
+
+        public void WriteGoto(string label)
+        {
+            cache.Add($"goto {label}");
+        }
+
+        public void WriteIf(string label)
+        {
+            cache.Add($"if-goto {label}");
+        }
+
+        public void WriteCall(string name, int nargs)
+        {
+            cache.Add($"call {name} {nargs}");
+        }
+
+        public void WriteFunction(string name, int nlocal)
+        {
+            cache.Add($"function {name} {nlocal}");
+            funcDef = cache.Count - 1;
+        }
+
+        public void RewriteFunctionLocals(string name, int nlocal)
+        {
+            cache[funcDef]=($"function {name} {nlocal}");
+        }
+
+        public void WriteReturn()
+        {
+            cache.Add("return");
+        }
+
+    }
+}

JackCompiler/JackAnalyzer/Writer.cs

@@ -0,0 +1,914 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Security;
+using System.Linq;
+
+namespace JackAnalyzer
+{
+    class Writer
+    {
+        private Queue<KeyValuePair<TokenType, string>> tokenQueue;
+        private static MetaSymbolTable MetaSymbolTable;
+        VMWriter VMWriter;
+        string ClassName;
+        int LabelCounter = 0;
+        public Writer(string path, List<KeyValuePair<TokenType, string>> tokens)
+        {
+            if(MetaSymbolTable == null)
+            {
+                MetaSymbolTable = new MetaSymbolTable();
+            } else
+            {
+                MetaSymbolTable.ResetFieldTable();
+            }
+            VMWriter = new VMWriter(path);
+            string filename = Path.ChangeExtension(path, ".xml");
+            ClassName = Path.GetFileNameWithoutExtension(filename);
+            tokenQueue = new Queue<KeyValuePair<TokenType, string>>(tokens);
+            using (StreamWriter file = new StreamWriter(filename))
+            {
+                var token = tokenQueue.Peek();
+
+                if (token.Key == TokenType.keyword)
+                {
+                    string keyword = token.Value;
+                    if (keyword == "class")
+                    {
+                        string[] classLines = CompileClass();
+                        foreach (string line in classLines)
+                        {
+                            file.WriteLine(line);
+                        }
+                    }
+                }
+            }
+            VMWriter.Dispose();
+        }
+
+        // 'class' className '{' classVarDec* subroutineDec* '}'
+        private string[] CompileClass()
+        {
+            List<string> output = new List<string>();
+
+            output.Add(PutOpenTag(0, "class"));
+
+            output.Add(PutToken(1));
+            var token = tokenQueue.Dequeue();
+            output.Add(PutLineTag(1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "class, defined"));
+            output.Add(PutToken(1));
+
+            // classVarDec*
+            token = tokenQueue.Peek();
+            while (token.Value == "static" || token.Value == "field")
+            {
+                output.AddRange(CompileClassVarDec(1));
+                token = tokenQueue.Peek();
+            }
+
+            // subroutineDec*
+            token = tokenQueue.Peek();
+            while (token.Value == "function" || token.Value == "constructor" || token.Value == "method" || token.Value == "void")
+            {
+                output.AddRange(CompileSubroutine(1));
+                token = tokenQueue.Peek();
+            }
+
+            // } 
+            output.Add(PutToken(1));
+
+            output.Add(PutCloseTag(0, "class"));
+
+            return output.ToArray();
+        }
+
+        // ('static' | 'field') type varName (',' varName)* ';'
+        private string[] CompileClassVarDec(int indent)
+        {
+            List<string> output = new List<string>();
+
+            output.Add(PutOpenTag(indent, "classVarDec"));
+
+            var token = tokenQueue.Dequeue();
+            SymbolKind kind;
+            switch (token.Value)
+            {
+                case "field":
+                    kind = SymbolKind.Field;
+                    break;
+                case "static":
+                    kind = SymbolKind.Static;
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+            output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value));
+
+            token = tokenQueue.Dequeue();
+            string type = token.Value;
+            output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value));
+
+            token = tokenQueue.Dequeue();
+            string name = token.Value;
+            MetaSymbolTable.Define(name, type, kind);
+            output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "name=" + name + " " + "type=" + type + " " + "kind=" + Enum.GetName(typeof(SymbolKind), kind) + " " + "index=" + MetaSymbolTable.IndexOf(name) + " " + "declared"));
+
+
+            token = tokenQueue.Peek();
+            while (token.Value == ",")
+            {
+                output.Add(PutToken(indent + 1));
+                token = tokenQueue.Dequeue();
+                name = token.Value;
+                MetaSymbolTable.Define(name, type, kind);
+                output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "name=" + name + " " + "type=" + type + " " + "kind=" + Enum.GetName(typeof(SymbolKind), kind) + " " + "index=" + MetaSymbolTable.IndexOf(name) + " " + "declared"));
+                token = tokenQueue.Peek();
+            }
+
+            output.Add(PutToken(indent + 1));
+
+            output.Add(PutCloseTag(indent, "classVarDec"));
+
+            return output.ToArray();
+        }
+
+        // ('constructor' | 'function' | 'method')
+        // ('void' | type) subroutineName '(' parameterList ')' subroutineBody
+        private string[] CompileSubroutine(int indent)
+        {
+            List<string> output = new List<string>();
+
+            output.Add(PutOpenTag(indent, "subroutineDec"));
+            MetaSymbolTable.ResetFunctionTable();
+            var token = tokenQueue.Dequeue();
+            string type = token.Value;
+            output.Add(PutToken(indent + 1));
+            token = tokenQueue.Dequeue();
+            string name = token.Value;
+            output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "subroutine, defined"));
+            output.Add(PutToken(indent + 1));
+
+            // parameterList
+            if(type == "method")
+            {
+                MetaSymbolTable.Define("this", ClassName, SymbolKind.Arg);
+            }
+            output.AddRange(CompileParameterList(indent + 1));
+            VMWriter.WriteFunction(ClassName + "." + name, MetaSymbolTable.VarCount(SymbolKind.Var));
+            output.Add(PutToken(indent + 1));
+            switch(type)
+            {
+                case "constructor":
+                    VMWriter.WritePush(Segment.Constant, MetaSymbolTable.VarCount(SymbolKind.Field));
+                    VMWriter.WriteCall("Memory.alloc", 1);
+                    VMWriter.WritePop(Segment.Pointer, 0);
+                    break;
+                case "function":
+                    break;
+                case "method":
+                    VMWriter.WritePush(Segment.Argument, 0);
+                    VMWriter.WritePop(Segment.Pointer, 0);
+                    break;
+            }
+            output.AddRange(CompileSubroutineBody(indent + 1));
+            VMWriter.RewriteFunctionLocals(ClassName + "." + name, MetaSymbolTable.VarCount(SymbolKind.Var));
+            output.Add(PutCloseTag(indent, "subroutineDec"));
+
+            return output.ToArray();
+        }
+
+        // '{' varDec* statements '}'
+        private string[] CompileSubroutineBody(int indent)
+        {
+            List<string> output = new List<string>();
+
+            output.Add(PutOpenTag(indent, "subroutineBody"));
+
+            output.Add(PutToken(indent + 1));
+
+            // varDec*
+            var token = tokenQueue.Peek();
+            while (token.Value == "var")
+            {
+                output.AddRange(CompileVarDec(indent + 1));
+                token = tokenQueue.Peek();
+            }
+
+            output.AddRange(CompileStatements(indent + 1));
+
+            // } 
+            output.Add(PutToken(indent + 1));
+
+            output.Add(PutCloseTag(indent, "subroutineBody"));
+
+            return output.ToArray();
+        }
+
+        // statement*
+        private string[] CompileStatements(int indent)
+        {
+            List<string> output = new List<string>();
+
+            output.Add(PutOpenTag(indent, "statements"));
+
+            bool finished = false;
+
+            var token = tokenQueue.Peek();
+
+            while (!finished)
+            {
+                switch (token.Value)
+                {
+                    case "do":
+                        output.AddRange(CompileDoStatement(indent + 1));
+                        break;
+                    case "let":
+                        output.AddRange(CompileLetStatement(indent + 1));
+                        break;
+                    case "while":
+                        output.AddRange(CompileWhileStatement(indent + 1));
+                        break;
+                    case "return":
+                        output.AddRange(CompileReturnStatement(indent + 1));
+                        break;
+                    case "if":
+                        output.AddRange(CompileIfStatement(indent + 1));
+                        break;
+                    default:
+                        finished = true;
+                        break;
+                }
+                token = tokenQueue.Peek();
+            }
+
+
+            output.Add(PutCloseTag(indent, "statements"));
+
+            return output.ToArray();
+        }
+
+        // 'do' subroutineCall ';'
+        private string[] CompileDoStatement(int indent)
+        {
+            List<string> output = new List<string>();
+
+            output.Add(PutOpenTag(indent, "doStatement"));
+
+            output.Add(PutToken(indent + 1));
+
+            var queueEnumerator = tokenQueue.GetEnumerator();
+            queueEnumerator.MoveNext();
+            queueEnumerator.MoveNext();
+            var nextToken = queueEnumerator.Current;
+            string name = "";
+
+            int ellen = 0;
+
+            // subroutineName '(' expressionList ')' | (className |
+            // varName) '.' subroutineName '(' expressionList ')'
+            if (nextToken.Value == ".")
+            {
+
+                var token = tokenQueue.Dequeue();
+                string classname = token.Value;
+                output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "class, used"));
+                output.Add(PutToken(indent + 1));
+                token = tokenQueue.Dequeue();
+                string fname = token.Value;
+                output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "function, used"));
+                output.Add(PutToken(indent + 1));
+                try
+                {
+                    MetaSymbolTable.KindOf(classname);
+                    Segment seg = Segment.Local;
+                    switch (MetaSymbolTable.KindOf(classname))
+                    {
+                        case SymbolKind.Static:
+                            seg = Segment.Static;
+                            break;
+                        case SymbolKind.Field:
+                            seg = Segment.This;
+                            break;
+                        case SymbolKind.Arg:
+                            seg = Segment.Argument;
+                            break;
+                        case SymbolKind.Var:
+                            seg = Segment.Local;
+                            break;
+                        case SymbolKind.None:
+                            break;
+                        default:
+                            break;
+                    }
+                    VMWriter.WritePush(seg, MetaSymbolTable.IndexOf(classname));
+                    ellen += 1;
+                }
+                catch
+                {
+
+                }
+
+                ellen += CompileExpressionList(indent + 1);
+                output.Add(PutToken(indent + 1));
+
+                try
+                {
+                    name = MetaSymbolTable.TypeOf(classname) + "." + fname;
+
+                } catch
+                {
+                    name = classname + "." + fname;
+                }
+            }
+            else if (nextToken.Value == "(")
+            {
+                VMWriter.WritePush(Segment.Pointer, 0);
+                var token = tokenQueue.Dequeue();
+                name = ClassName + "." + token.Value;
+                output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "function, used"));
+                output.Add(PutToken(indent + 1));
+                ellen += CompileExpressionList(indent + 1);
+                ellen += 1;
+                output.Add(PutToken(indent + 1));
+            }
+            // ;
+            output.Add(PutToken(indent + 1));
+
+            VMWriter.WriteCall(name, ellen);
+            VMWriter.WritePop(Segment.Temp, 0);
+            output.Add(PutCloseTag(indent, "doStatement"));
+
+            return output.ToArray();
+        }
+
+        // 'let' varName ('[' expression ']')? '=' expression ';'
+        private string[] CompileLetStatement(int indent)
+        {
+            List<string> output = new List<string>();
+
+            output.Add(PutOpenTag(indent, "letStatement"));
+
+            output.Add(PutToken(indent + 1));
+            var token = tokenQueue.Dequeue();
+            string name = token.Value;
+            output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "name=" + name + " " + "type=" + MetaSymbolTable.TypeOf(name) + " " + "kind=" + Enum.GetName(typeof(SymbolKind), MetaSymbolTable.KindOf(name)) + " " + "index=" + MetaSymbolTable.IndexOf(name) + " " + "used"));
+
+            token = tokenQueue.Peek();
+            if (token.Value == "[")
+            {
+                output.Add(PutToken(indent + 1));
+                Segment sega = Segment.Local;
+                switch (MetaSymbolTable.KindOf(name))
+                {
+                    case SymbolKind.Static:
+                        sega = Segment.Static;
+                        break;
+                    case SymbolKind.Field:
+                        sega = Segment.This;
+                        break;
+                    case SymbolKind.Arg:
+                        sega = Segment.Argument;
+                        break;
+                    case SymbolKind.Var:
+                        sega = Segment.Local;
+                        break;
+                    case SymbolKind.None:
+                        break;
+                    default:
+                        break;
+                }
+                VMWriter.WritePush(sega, MetaSymbolTable.IndexOf(name));
+                output.AddRange(CompileExpression(indent + 1));
+                VMWriter.WriteArithmetic(ArithmeticOp.Add);
+                output.Add(PutToken(indent + 1));
+
+                output.Add(PutToken(indent + 1));
+                output.AddRange(CompileExpression(indent + 1));
+                output.Add(PutToken(indent + 1));
+
+                VMWriter.WritePop(Segment.Temp, 0);
+                VMWriter.WritePop(Segment.Pointer, 1);
+                VMWriter.WritePush(Segment.Temp, 0);
+                VMWriter.WritePop(Segment.That, 0);
+
+            }
+            else
+            {
+                output.Add(PutToken(indent + 1));
+                output.AddRange(CompileExpression(indent + 1));
+                output.Add(PutToken(indent + 1));
+
+                Segment seg = Segment.Local;
+                switch (MetaSymbolTable.KindOf(name))
+                {
+                    case SymbolKind.Static:
+                        seg = Segment.Static;
+                        break;
+                    case SymbolKind.Field:
+                        seg = Segment.This;
+                        break;
+                    case SymbolKind.Arg:
+                        seg = Segment.Argument;
+                        break;
+                    case SymbolKind.Var:
+                        seg = Segment.Local;
+                        break;
+                    case SymbolKind.None:
+                        break;
+                    default:
+                        break;
+                }
+                VMWriter.WritePop(seg, MetaSymbolTable.IndexOf(name));
+            }
+
+            output.Add(PutCloseTag(indent, "letStatement"));
+
+            return output.ToArray();
+        }
+
+        // 'while' '(' expression ')' '{' statements '}'
+        private string[] CompileWhileStatement(int indent)
+        {
+            List<string> output = new List<string>();
+            LabelCounter++;
+            int localcounter = LabelCounter;
+            output.Add(PutOpenTag(indent, "whileStatement"));
+            VMWriter.WriteLabel("WHILE" + localcounter + 0);
+            output.Add(PutToken(indent + 1));
+            output.Add(PutToken(indent + 1));
+            output.AddRange(CompileExpression(indent + 1));
+            VMWriter.WriteArithmetic(ArithmeticOp.Not);
+            VMWriter.WriteIf("WHILE" + localcounter + 1);
+            output.Add(PutToken(indent + 1));
+            output.Add(PutToken(indent + 1));
+            output.AddRange(CompileStatements(indent + 1));
+            VMWriter.WriteGoto("WHILE" + localcounter + 0);
+            output.Add(PutToken(indent + 1));
+            VMWriter.WriteLabel("WHILE" + localcounter + 1);
+
+            output.Add(PutCloseTag(indent, "whileStatement"));
+
+            return output.ToArray();
+        }
+
+        // 'return' expression? ';'
+        private string[] CompileReturnStatement(int indent)
+        {
+            List<string> output = new List<string>();
+
+            output.Add(PutOpenTag(indent, "returnStatement"));
+
+            output.Add(PutToken(indent + 1));
+
+            var token = tokenQueue.Peek();
+            if (token.Value != ";")
+            {
+                output.AddRange(CompileExpression(indent + 1));
+            } else
+            {
+                VMWriter.WritePush(Segment.Constant, 0);
+            }
+
+            output.Add(PutToken(indent + 1));
+
+            VMWriter.WriteReturn();
+            output.Add(PutCloseTag(indent, "returnStatement"));
+
+            return output.ToArray();
+        }
+
+        // 'if' '(' expression ')' '{' statements '}' ('else' '{' statements '}')?
+        private string[] CompileIfStatement(int indent)
+        {
+            List<string> output = new List<string>();
+            LabelCounter++;
+            int localcounter = LabelCounter;
+
+            output.Add(PutOpenTag(indent, "ifStatement"));
+
+            output.Add(PutToken(indent + 1));
+            output.Add(PutToken(indent + 1));
+            output.AddRange(CompileExpression(indent + 1));
+            VMWriter.WriteArithmetic(ArithmeticOp.Not);
+            VMWriter.WriteIf("IF" + localcounter + 0);
+
+            output.Add(PutToken(indent + 1));
+            output.Add(PutToken(indent + 1));
+            output.AddRange(CompileStatements(indent + 1));
+            output.Add(PutToken(indent + 1));
+            VMWriter.WriteGoto("IF" + localcounter + 1);
+            VMWriter.WriteLabel("IF" + localcounter + 0);
+            var token = tokenQueue.Peek();
+            if (token.Value == "else")
+            {
+                output.Add(PutToken(indent + 1));
+                output.Add(PutToken(indent + 1));
+                output.AddRange(CompileStatements(indent + 1));
+                output.Add(PutToken(indent + 1));
+            }
+            VMWriter.WriteLabel("IF" + localcounter + 1);
+
+            output.Add(PutCloseTag(indent, "ifStatement"));
+
+            return output.ToArray();
+        }
+
+        // 'var' type varName (',' varName)* ';'
+        private string[] CompileVarDec(int indent)
+        {
+            List<string> output = new List<string>();
+
+            output.Add(PutOpenTag(indent, "varDec"));
+
+            var token = tokenQueue.Dequeue();
+            SymbolKind kind = SymbolKind.Var;
+            output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value));
+
+            token = tokenQueue.Dequeue();
+            string type = token.Value;
+            output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value));
+
+            token = tokenQueue.Dequeue();
+            string name = token.Value;
+            MetaSymbolTable.Define(name, type, kind);
+            output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "name=" + name + " " + "type=" + type + " " + "kind=" + Enum.GetName(typeof(SymbolKind), kind) + " " + "index=" + MetaSymbolTable.IndexOf(name) + " " + "declared"));
+
+            token = tokenQueue.Peek();
+            while (token.Value == ",")
+            {
+                output.Add(PutToken(indent + 1));
+
+                token = tokenQueue.Dequeue();
+                name = token.Value;
+                MetaSymbolTable.Define(name, type, kind);
+                output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "name=" + name + " " + "type=" + type + " " + "kind=" + Enum.GetName(typeof(SymbolKind), kind) + " " + "index=" + MetaSymbolTable.IndexOf(name) + " " + "declared"));
+                token = tokenQueue.Peek();
+            }
+
+            output.Add(PutToken(indent + 1));
+
+            output.Add(PutCloseTag(indent, "varDec"));
+
+            return output.ToArray();
+        }
+
+        // ((type varName) (',' type varName)*)?
+        private string[] CompileParameterList(int indent)
+        {
+            List<string> output = new List<string>();
+
+            output.Add(PutOpenTag(indent, "parameterList"));
+
+            var token = tokenQueue.Peek();
+            if (token.Key == TokenType.keyword || token.Key == TokenType.identifier)
+            {
+                token = tokenQueue.Dequeue();
+                string type = token.Value;
+                output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value));
+
+                token = tokenQueue.Dequeue();
+                string name = token.Value;
+                SymbolKind kind = SymbolKind.Arg;
+                MetaSymbolTable.Define(name, type, kind);
+                output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "name=" + name + " " + "type=" + type + " " + "kind=" + Enum.GetName(typeof(SymbolKind), kind) + " " + "index=" + MetaSymbolTable.IndexOf(name) + " " + "declared"));
+
+                token = tokenQueue.Peek();
+                while (token.Value == ",")
+                {
+                    output.Add(PutToken(indent + 1));
+                    token = tokenQueue.Dequeue();
+                    type = token.Value;
+                    output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value));
+
+                    token = tokenQueue.Dequeue();
+                    name = token.Value;
+                    kind = SymbolKind.Arg;
+                    MetaSymbolTable.Define(name, type, kind);
+                    output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "name=" + name + " " + "type=" + type + " " + "kind=" + Enum.GetName(typeof(SymbolKind), kind) + " " + "index=" + MetaSymbolTable.IndexOf(name) + " " + "declared"));
+                    token = tokenQueue.Peek();
+                }
+            }
+
+            output.Add(PutCloseTag(indent, "parameterList"));
+
+            return output.ToArray();
+        }
+
+        // term (op term)*
+        private string[] CompileExpression(int indent)
+        {
+            List<string> output = new List<string>();
+
+            output.Add(PutOpenTag(indent, "expression"));
+
+            output.AddRange(CompileTerm(indent + 1));
+
+            var token = tokenQueue.Peek();
+            while (Constants.op.Contains(token.Value[0]))
+            {
+                string op = token.Value;
+                output.Add(PutToken(indent + 1));
+                output.AddRange(CompileTerm(indent + 1));
+                switch (op)
+                {
+                    case "+":
+                        VMWriter.WriteArithmetic(ArithmeticOp.Add);
+                        break;
+                    case "-":
+                        VMWriter.WriteArithmetic(ArithmeticOp.Sub);
+                        break;
+                    case "*":
+                        VMWriter.WriteCall("Math.multiply", 2);
+                        break;
+                    case "/":
+                        VMWriter.WriteCall("Math.divide", 2);
+                        break;
+                    case "&":
+                        VMWriter.WriteArithmetic(ArithmeticOp.And);
+                        break;
+                    case "|":
+                        VMWriter.WriteArithmetic(ArithmeticOp.Or);
+                        break;
+                    case "<":
+                        VMWriter.WriteArithmetic(ArithmeticOp.Lt);
+                        break;
+                    case ">":
+                        VMWriter.WriteArithmetic(ArithmeticOp.Gt);
+                        break;
+                    case "=":
+                        VMWriter.WriteArithmetic(ArithmeticOp.Eq);
+                        break;
+                    default:
+                        break;
+                }
+                token = tokenQueue.Peek();
+            }
+
+            output.Add(PutCloseTag(indent, "expression"));
+
+            return output.ToArray();
+        }
+
+        // integerConstant | stringConstant | keywordConstant |
+        // varName | varName '[' expression ']' | subroutineCall |
+        // '(' expression ')' | unaryOp term
+        private string[] CompileTerm(int indent)
+        {
+            List<string> output = new List<string>();
+
+            output.Add(PutOpenTag(indent, "term"));
+
+            var token = tokenQueue.Peek();
+
+            var queueEnumerator = tokenQueue.GetEnumerator();
+
+            queueEnumerator.MoveNext();
+            queueEnumerator.MoveNext();
+
+            var nextToken = queueEnumerator.Current;
+
+            if (Constants.unaryOp.Contains(token.Value[0]))
+            {
+                string unaryOp = token.Value;
+                output.Add(PutToken(indent + 1));
+                output.AddRange(CompileTerm(indent + 1));
+                switch (unaryOp)
+                {
+                    case "-":
+                        VMWriter.WriteArithmetic(ArithmeticOp.Neg);
+                        break;
+                    case "~":
+                        VMWriter.WriteArithmetic(ArithmeticOp.Not);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            else if (token.Key == TokenType.identifier && nextToken.Value == ".")
+            {
+                // subroutineName '(' expressionList ')' | (className |
+                // varName) '.' subroutineName '(' expressionList ')'
+
+                token = tokenQueue.Dequeue();
+                string classname = token.Value;
+                output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "class, used"));
+                output.Add(PutToken(indent + 1));
+                token = tokenQueue.Dequeue();
+                string funcname = token.Value;
+                output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "function, used"));
+                output.Add(PutToken(indent + 1));
+                int ellen = CompileExpressionList(indent + 1);
+                try
+                {
+                    MetaSymbolTable.KindOf(classname);
+                    Segment seg = Segment.Local;
+                    switch (MetaSymbolTable.KindOf(classname))
+                    {
+                        case SymbolKind.Static:
+                            seg = Segment.Static;
+                            break;
+                        case SymbolKind.Field:
+                            seg = Segment.This;
+                            break;
+                        case SymbolKind.Arg:
+                            seg = Segment.Argument;
+                            break;
+                        case SymbolKind.Var:
+                            seg = Segment.Local;
+                            break;
+                        case SymbolKind.None:
+                            break;
+                        default:
+                            break;
+                    }
+                    VMWriter.WritePush(seg, MetaSymbolTable.IndexOf(classname));
+                    ellen += 1;
+                }
+                catch
+                {
+
+                }
+                try
+                {
+                    VMWriter.WriteCall(MetaSymbolTable.TypeOf(classname) + "." + funcname, ellen);
+                } catch
+                {
+                    VMWriter.WriteCall(classname + "." + funcname, ellen);
+                }
+                output.Add(PutToken(indent + 1));
+            }
+            else if (token.Key == TokenType.identifier && nextToken.Value == "(")
+            {
+                token = tokenQueue.Dequeue();
+                string funcname = token.Value;
+                output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "function, used"));
+                output.Add(PutToken(indent + 1));
+                int ellen = CompileExpressionList(indent + 1);
+                VMWriter.WritePush(Segment.Pointer, 0);
+                VMWriter.WriteCall(ClassName + "." + funcname, ellen + 1);
+                output.Add(PutToken(indent + 1));
+            }
+            else if (nextToken.Value == "[")
+            {
+                token = tokenQueue.Dequeue();
+                string name = token.Value;
+
+                Segment sega = Segment.Local;
+                switch (MetaSymbolTable.KindOf(name))
+                {
+                    case SymbolKind.Static:
+                        sega = Segment.Static;
+                        break;
+                    case SymbolKind.Field:
+                        sega = Segment.This;
+                        break;
+                    case SymbolKind.Arg:
+                        sega = Segment.Argument;
+                        break;
+                    case SymbolKind.Var:
+                        sega = Segment.Local;
+                        break;
+                    case SymbolKind.None:
+                        break;
+                    default:
+                        break;
+                }
+                VMWriter.WritePush(sega, MetaSymbolTable.IndexOf(name));
+                output.Add(PutToken(indent + 1));
+                output.AddRange(CompileExpression(indent + 1));
+                VMWriter.WriteArithmetic(ArithmeticOp.Add);
+                output.Add(PutToken(indent + 1));
+
+                VMWriter.WritePop(Segment.Pointer, 1);
+                VMWriter.WritePush(Segment.That, 0);
+            }
+            else if (token.Value == "(")
+            {
+                output.Add(PutToken(indent + 1));
+                output.AddRange(CompileExpression(indent + 1));
+                output.Add(PutToken(indent + 1));
+            }
+            else if (token.Key == TokenType.identifier)
+            {
+                token = tokenQueue.Dequeue();
+                string name = token.Value;
+                output.Add(PutLineTag(indent + 1, Enum.GetName(typeof(TokenType), token.Key), token.Value, "name=" + name + " " + "type=" + MetaSymbolTable.TypeOf(name) + " " + "kind=" + Enum.GetName(typeof(SymbolKind), MetaSymbolTable.KindOf(name)) + " " + "index=" + MetaSymbolTable.IndexOf(name) + " " + "used"));
+                Segment seg = Segment.Local;
+                switch (MetaSymbolTable.KindOf(name))
+                {
+                    case SymbolKind.Static:
+                        seg = Segment.Static;
+                        break;
+                    case SymbolKind.Field:
+                        seg = Segment.This;
+                        break;
+                    case SymbolKind.Arg:
+                        seg = Segment.Argument;
+                        break;
+                    case SymbolKind.Var:
+                        seg = Segment.Local;
+                        break;
+                    case SymbolKind.None:
+                        break;
+                    default:
+                        break;
+                }
+                VMWriter.WritePush(seg, MetaSymbolTable.IndexOf(name));
+            }
+            else
+            {
+                switch (token.Key)
+                {
+                    case TokenType.keyword:
+                        switch(token.Value)
+                        {
+                            case "this":
+                                VMWriter.WritePush(Segment.Pointer, 0);
+                                break;
+                            case "false":
+                            case "null":
+                                VMWriter.WritePush(Segment.Constant, 0);
+                                break;
+                            case "true":
+                                VMWriter.WritePush(Segment.Constant, 0);
+                                VMWriter.WriteArithmetic(ArithmeticOp.Not);
+                                break;
+                        }
+                        break;
+                    case TokenType.symbol:
+                        break;
+                    case TokenType.integerConstant:
+                        VMWriter.WritePush(Segment.Constant, int.Parse(token.Value));
+                        break;
+                    case TokenType.stringConstant:
+                        string str = token.Value;
+                        VMWriter.WritePush(Segment.Constant, str.Length);
+                        VMWriter.WriteCall("String.new", 1);
+                        foreach(char c in str)
+                        {
+                            VMWriter.WritePush(Segment.Constant, c);
+                            VMWriter.WriteCall("String.appendChar", 2);
+                        }
+                        break;
+                    default:
+                        break;
+                }
+                output.Add(PutToken(indent + 1));
+            }
+
+            output.Add(PutCloseTag(indent, "term"));
+
+            return output.ToArray();
+        }
+
+        // (expression (',' expression)* )?
+        private int CompileExpressionList(int indent)
+        {
+            List<string> output = new List<string>();
+
+            int ExpressionListLength = 0;
+            output.Add(PutOpenTag(indent, "expressionList"));
+
+            var token = tokenQueue.Peek();
+            if (token.Value != ")")
+            {
+                ExpressionListLength = 1;
+                output.AddRange(CompileExpression(indent + 1));
+                token = tokenQueue.Peek();
+                while (token.Value == ",")
+                {
+                    ExpressionListLength++;
+                    output.Add(PutToken(indent + 1));
+                    output.AddRange(CompileExpression(indent + 1));
+                    token = tokenQueue.Peek();
+                }
+            }
+
+            output.Add(PutCloseTag(indent, "expressionList"));
+
+            return ExpressionListLength;
+        }
+
+        private string PutToken(int indent)
+        {
+            var token = tokenQueue.Dequeue();
+            return PutLineTag(indent, Enum.GetName(typeof(TokenType), token.Key), token.Value);
+        }
+
+        private string PutOpenTag(int indent, string name)
+        {
+            return new string(' ', indent * Constants.indentLevel) + '<' + name + '>';
+        }
+
+        private string PutCloseTag(int indent, string name)
+        {
+            return new string(' ', indent * Constants.indentLevel) + "</" + name + '>';
+        }
+
+        private string PutLineTag(int indent, string name, string value, string add = "")
+        {
+            return new string(' ', indent * Constants.indentLevel) + '<' + name + " " + add + "> " + SecurityElement.Escape(value) + " </" + name + '>';
+        }
+    }
+}