Homework 1 (#21)

* Commiting .gitignore before real solution

* C# project implementing very basic functionality of the lexer, needs
refactoring.

* Added  most javascript reserved keywords

* Added logic for most js operators in Tokenizer.cs

* added lexemes for operator tokens
also created the PrettyPrint() function

* added a coloring logic to the parsed text

* Refactored Lexer class, added TokenHandler class
PrettyPrint colors require tweaking, Lexer needs more refactoring

* created TokenHandler to pretty print text to html

* Deleted project files

* Updated Program.cs

13 files changed, 1245 insertions, 0 deletions

diff --git a/homework/81498/.gitignore.txt b/homework/81498/.gitignore.txt
new file mode 100644
index 0000000..f00a0eb
--- /dev/null
+++ b/homework/81498/.gitignore.txt
@@ -0,0 +1,334 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
+
+# User-specific files
+*.rsuser
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+
+# Visual Studio 2015/2017 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# Visual Studio 2017 auto generated files
+Generated\ Files/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# Benchmark Results
+BenchmarkDotNet.Artifacts/
+
+# .NET Core
+project.lock.json
+project.fragment.lock.json
+artifacts/
+
+# StyleCop
+StyleCopReport.xml
+
+# Files built by Visual Studio
+*_i.c
+*_p.c
+*_h.h
+*.ilk
+*.meta
+*.obj
+*.iobj
+*.pch
+*.pdb
+*.ipdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*_wpftmp.csproj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# Visual Studio Trace Files
+*.e2e
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# AxoCover is a Code Coverage Tool
+.axoCover/*
+!.axoCover/settings.json
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# Note: Comment the next line if you want to checkin your web deploy settings,
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/[Pp]ackages/*
+# except build/, which is used as an MSBuild target.
+!**/[Pp]ackages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/[Pp]ackages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+*.appx
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+orleans.codegen.cs
+
+# Including strong name files can present a security risk
+# (https://github.com/github/gitignore/pull/2483#issue-259490424)
+#*.snk
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+ServiceFabricBackup/
+*.rptproj.bak
+
+# SQL Server files
+*.mdf
+*.ldf
+*.ndf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+*.rptproj.rsuser
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+node_modules/
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# JetBrains Rider
+.idea/
+*.sln.iml
+
+# CodeRush personal settings
+.cr/personal
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc
+
+# Cake - Uncomment if you are using it
+# tools/**
+# !tools/packages.config
+
+# Tabs Studio
+*.tss
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
+
+# OpenCover UI analysis results
+OpenCover/
+
+# Azure Stream Analytics local run output
+ASALocalRun/
+
+# MSBuild Binary and Structured Log
+*.binlog
+
+# NVidia Nsight GPU debugger configuration file
+*.nvuser
+
+# MFractors (Xamarin productivity tool) working folder
+.mfractor/
+
+# Local History for Visual Studio
+.localhistory/
\ No newline at end of file
diff --git a/homework/81498/Project/Wizard/Homeworks/WeekOne/BooleanOperatorsTokenTypes.cs b/homework/81498/Project/Wizard/Homeworks/WeekOne/BooleanOperatorsTokenTypes.cs
new file mode 100644
index 0000000..34eda75
--- /dev/null
+++ b/homework/81498/Project/Wizard/Homeworks/WeekOne/BooleanOperatorsTokenTypes.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Wizard.Homeworks.WeekOne
+{
+    public static class BooleanOperatorsTokenTypes
+    {
+        public static List<TokenType> AsList()
+        {
+            return new List<TokenType>()
+            {
+                TokenType.Bang,
+                TokenType.BangEqual,
+                TokenType.LogicalOr,
+                TokenType.LogicalAnd,
+                TokenType.EqualEqual,
+                TokenType.StrictEqual,
+                TokenType.StrictNotEqual,
+                TokenType.Greater,
+                TokenType.GreaterEqual,
+                TokenType.Less,
+                TokenType.LessEqual
+            };
+        }
+    }
+}
diff --git a/homework/81498/Project/Wizard/Homeworks/WeekOne/Colour.cs b/homework/81498/Project/Wizard/Homeworks/WeekOne/Colour.cs
new file mode 100644
index 0000000..06d4670
--- /dev/null
+++ b/homework/81498/Project/Wizard/Homeworks/WeekOne/Colour.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Wizard.Homeworks.WeekOne
+{
+   public static class Color
+    {
+        public const string ForBoolean = "#FF0000";
+        public const string ForBooleanOperator = "000000";
+        public const string ForKeyword = "#0B0AF6";
+        public const string ForString = "#F609F5";
+        public const string ForNumber = "#F66509";
+        public const string ForIdentifier = "222222";
+        public const string ForDefault = "000000";
+    }
+}
diff --git a/homework/81498/Project/Wizard/Homeworks/WeekOne/TokenHandler.cs b/homework/81498/Project/Wizard/Homeworks/WeekOne/TokenHandler.cs
new file mode 100644
index 0000000..9e25c6c
--- /dev/null
+++ b/homework/81498/Project/Wizard/Homeworks/WeekOne/TokenHandler.cs
@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Wizard.Homeworks.WeekOne;
+using Wizard.Misc;
+
+namespace Wizard.Homeworks
+{   // private or property?
+    public class TokenHandler
+    {
+        private List<Token> _tokens;
+        private List<TokenType> _operatorsAsTokenList;
+        private List<TokenType> _keywordsAsTokenTypes;
+
+        public string FileDestination { get; set; }
+
+        public TokenHandler(List<Token> tokens, string fileDestionation)
+        {
+            _tokens = tokens;
+            FileDestination = fileDestionation;
+
+            _operatorsAsTokenList = OperatorsToTokens.AsTokenList();
+            _keywordsAsTokenTypes = KeywordsToTokens.AsTokenList();
+        }
+
+        public void PrintTokens()
+        {
+            foreach (var token in _tokens)
+            {
+                Console.WriteLine(token.ToString());
+            }
+        }
+
+        public void PrettyPrint(string fileDestination)
+        {
+            using (var writer = new StreamWriter(fileDestination))
+            {
+                foreach (var token in _tokens)
+                {
+                    string coloredLexeme = "";
+                    if (token.Type is TokenType.True ||
+                       token.Type is TokenType.False)
+                    {
+                        coloredLexeme = "<span><font color=\"" + Color.ForBoolean + "\">" + token.Lexeme + "</font></span>";
+                        writer.Write(coloredLexeme);
+                        continue;
+                    }
+
+                    if (_operatorsAsTokenList.Contains(token.Type))
+                    {
+                        coloredLexeme = "<span><font color=\"" + Color.ForBooleanOperator + "\"><b>" + token.Lexeme + "</b></font></span>";
+                        writer.Write(coloredLexeme); // more
+                        continue;
+                    }
+
+                    if (_keywordsAsTokenTypes.Contains(token.Type))
+                    {
+                        coloredLexeme = "<span><font color=\"" + Color.ForKeyword + "\">" + token.Lexeme + "</font></span>";
+                        writer.Write(coloredLexeme); // more
+                        continue;
+                    }
+
+                    switch (token.Type)
+                    {
+                        case TokenType.Whitespace:
+                            writer.Write("&nbsp;");
+                            break;
+                        case TokenType.Newline: writer.Write("<br>"); break;
+                        case TokenType.String: // more
+                            coloredLexeme = "<span><font color=\"" + Color.ForString + "\">\"" + token.Lexeme + "\"</font></span>";
+                            writer.Write(coloredLexeme);
+                            break;
+                        case TokenType.Number:
+                            coloredLexeme = "<span><font color=\"" + Color.ForNumber + "\">" + token.Lexeme + "</font></span>";
+                            writer.Write(coloredLexeme);
+                            break;
+                        case TokenType.Identifier:
+                            coloredLexeme = "<span><font color=\"" + Color.ForIdentifier + "\">" + token.Lexeme + "</font></span>";
+                            writer.Write(coloredLexeme);
+                            break;
+                        default:
+                            coloredLexeme = "<span><font color=\"" + Color.ForDefault + "\">" + token.Lexeme + "</font></span>";
+                            writer.Write(coloredLexeme);
+                            break;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/homework/81498/Project/Wizard/Misc/ExactMatchSymbolsToTokensMap.cs b/homework/81498/Project/Wizard/Misc/ExactMatchSymbolsToTokensMap.cs
new file mode 100644
index 0000000..ecfeb92
--- /dev/null
+++ b/homework/81498/Project/Wizard/Misc/ExactMatchSymbolsToTokensMap.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Wizard.Misc
+{   // is this a good idea?
+    public static class ExactMatchSymbolsToTokens
+    {
+        public static Dictionary<char, TokenType> AsMap()
+        {
+            return new Dictionary<char, TokenType>()
+            {
+                {' ', TokenType.Whitespace },
+                {'\t', TokenType.Tab },
+                {':', TokenType.Colon },
+                {',', TokenType.Comma },
+                {'(', TokenType.LeftParenthesis },
+                {'{', TokenType.LeftBrace },
+                {'[', TokenType.LeftSquareBracket },
+                {']', TokenType.RightSquareBracket },
+                {'}', TokenType.RightBrace },
+                {')', TokenType.RightParenthesis },
+                {';', TokenType.Semicolon },
+                {'\'', TokenType.SingleQuote },
+                {'?', TokenType.SingleQuote },
+                {'.', TokenType.SingleQuote },
+            };
+        }
+    }
+}
diff --git a/homework/81498/Project/Wizard/Misc/KeywordsToTokensMap.cs b/homework/81498/Project/Wizard/Misc/KeywordsToTokensMap.cs
new file mode 100644
index 0000000..85783ab
--- /dev/null
+++ b/homework/81498/Project/Wizard/Misc/KeywordsToTokensMap.cs
@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Wizard.Misc
+{
+    public static class KeywordsToTokens
+    {
+        public static Dictionary<string, TokenType> AsMap()
+        {
+            return new Dictionary<string, TokenType>()
+            {
+                { "break", TokenType.Break },
+                { "case",TokenType.Case},
+                {"catch", TokenType.Catch },
+                {"class", TokenType.Class },
+                {"const", TokenType.Const },
+                {"continue", TokenType.Continue },
+                {"debugger", TokenType.Debugger },
+                {"default", TokenType.Default },
+                {"delete", TokenType.Delete },
+                {"do", TokenType.Do },
+                {"else", TokenType.Else },
+                {"export", TokenType.Export },
+                {"extends", TokenType.Extends },
+                {"false", TokenType.False },
+                {"finally", TokenType.Finally },
+                {"for", TokenType.For },
+                {"function", TokenType.Function },
+                {"if", TokenType.If },
+                {"import", TokenType.Import },
+                {"in", TokenType.In },
+                {"instanceof", TokenType.Instanceof },
+                {"let", TokenType.Let },
+                {"new", TokenType.New },
+                {"return", TokenType.Return },
+                {"super", TokenType.Super },
+                {"switch", TokenType.Switch },
+                {"this", TokenType.This },
+                {"throw", TokenType.Throw },
+                {"try", TokenType.Try },
+                {"true", TokenType.True },
+                {"typeof", TokenType.Typeof },
+                {"var", TokenType.Var },
+                {"void", TokenType.Void },
+                {"while", TokenType.While },
+                {"with", TokenType.With },
+                {"yield", TokenType.Yield }
+            };
+        }
+        public static List<TokenType> AsTokenList()
+        {
+            return AsMap().Values.ToList();
+        }
+    }
+}
diff --git a/homework/81498/Project/Wizard/Misc/OperatorsToTokensMap.cs b/homework/81498/Project/Wizard/Misc/OperatorsToTokensMap.cs
new file mode 100644
index 0000000..2468fec
--- /dev/null
+++ b/homework/81498/Project/Wizard/Misc/OperatorsToTokensMap.cs
@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Wizard.Misc
+{
+    public static class OperatorsToTokens
+    {
+        public static Dictionary<string, TokenType> AsMap()
+        {
+            return new Dictionary<string, TokenType>()
+            {
+                {"!" ,TokenType.Bang},
+                {"=" ,TokenType.Equal},
+                {"|" ,TokenType.BitwiseOr},
+                {"&" ,TokenType.BitwiseAnd},
+                {">" ,TokenType.Greater},
+                {"<" ,TokenType.Less},
+                {"+" ,TokenType.Plus},
+                {"-" ,TokenType.Minus},
+                {"*" ,TokenType.Star},
+                {"/" ,TokenType.Division},
+                {"%" ,TokenType.Modulo},
+
+                {"!=" ,TokenType.BangEqual},
+                {"/=" ,TokenType.DivideEqual},
+                {"!!" ,TokenType.DoubleBang},
+                {"**" ,TokenType.DoubleStar},
+                {"==" ,TokenType.EqualEqual},
+                {">=" ,TokenType.GreaterEqual},
+                {"+=" ,TokenType.PlusEqual},
+                {"++" ,TokenType.PlusPlus},
+                {"&&" ,TokenType.LogicalAnd},
+                {"||" ,TokenType.LogicalOr},
+                {"<=" ,TokenType.LessEqual},
+                {"*=" ,TokenType.StarEqual},
+                {"-=" ,TokenType.MinusEqual},
+                {"--" ,TokenType.MinusMinus},
+                {"%=" ,TokenType.ModuloEqual},
+
+                {"===" ,TokenType.StrictEqual},
+                {"!==" ,TokenType.StrictNotEqual},
+                {"**=" ,TokenType.DoubleStarEqual},
+            };
+        }
+
+        public static List<TokenType> AsTokenList()
+        {
+            return AsMap().Values.ToList();
+        }
+    }
+}
diff --git a/homework/81498/Project/Wizard/Program.cs b/homework/81498/Project/Wizard/Program.cs
new file mode 100644
index 0000000..a2722f5
--- /dev/null
+++ b/homework/81498/Project/Wizard/Program.cs
@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.IO;
+using Wizard.Homeworks;
+
+namespace Wizard
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            string programAsText = "";
+            string fileName = "";
+
+            Console.WriteLine("Please Enter absolute path for the text file(sorry): \n");
+            fileName = Console.ReadLine();
+
+            Console.WriteLine("The html will be generated with name semi_pretty.html");
+
+            using (var reader = new StreamReader(fileName))
+            {
+                while (!reader.EndOfStream)
+                {
+                    programAsText += reader.ReadLine();
+                    programAsText += "\n";
+                }
+            }
+
+            var tokenizer = new Lexer(programAsText, fileName);
+            var tokens = tokenizer.GenerateTokens();
+
+            var printToPath = "semi_pretty.html";
+            var tokenHandler = new TokenHandler(tokens, printToPath);
+            //tokenHandler.PrintTokens();
+            tokenHandler.PrettyPrint(printToPath);
+
+        }
+    }
+}
diff --git a/homework/81498/Project/Wizard/Text files/simpleFunction.html b/homework/81498/Project/Wizard/Text files/simpleFunction.html
new file mode 100644
index 0000000..d5bf508
--- /dev/null
+++ b/homework/81498/Project/Wizard/Text files/simpleFunction.html
@@ -0,0 +1 @@
+<span><font color="#0B0AF6">function</font></span>&nbsp;<span><font color="222222">sumOfSomeNumbers</font></span>&nbsp;<span><font color="000000">(</font></span>&nbsp;<span><font color="222222">number</font></span><span><font color="000000">,</font></span>&nbsp;<span><font color="222222">secondNumber</font></span><span><font color="000000">)</font></span>&nbsp;<span><font color="000000">{</font></span><br>&nbsp;&nbsp;&nbsp;&nbsp;<span><font color="222222">magicalThingsWithNumbersAndStrings</font></span><span><font color="000000">(</font></span><span><font color="#F609F5">"hello there my friend"</font></span><span><font color="000000">,</font></span>&nbsp;<span><font color="222222">a</font></span><span><font color="000000">,</font></span>&nbsp;<span><font color="222222">b</font></span><span><font color="000000">,</font></span>&nbsp;<span><font color="222222">c</font></span><span><font color="000000">)</font></span><span><font color="000000">;</font></span><br>&nbsp;&nbsp;&nbsp;&nbsp;<span><font color="222222">number</font></span>&nbsp;<span><font color="000000"><b>=</b></font></span>&nbsp;<span><font color="#F66509">1</font></span>&nbsp;<span><font color="000000"><b>+</b></font></span>&nbsp;<span><font color="#F66509">2</font></span>&nbsp;<span><font color="000000"><b>+</b></font></span>&nbsp;<span><font color="#F66509">3</font></span>&nbsp;<span><font color="000000"><b>/</b></font></span>&nbsp;<span><font color="#F66509">14</font></span>&nbsp;<span><font color="000000"><b>*</b></font></span>&nbsp;<span><font color="000000">(</font></span><span><font color="#F66509">16</font></span>&nbsp;<span><font color="000000"><b>**</b></font></span>&nbsp;<span><font color="#F66509">16</font></span><span><font color="000000">)</font></span><span><font color="000000">;</font></span><br>&nbsp;&nbsp;&nbsp;&nbsp;<span><font color="#0B0AF6">return</font></span>&nbsp;<span><font color="#FF0000">true</font></span>&nbsp;<span><font color="000000"><b>||</b></font></span>&nbsp;<span><font color="222222">number</font></span>&nbsp;<span><font color="000000"><b>&&</b></font></span>&nbsp;<span><font color="#F66509">3</font></span>&nbsp;<span><font color="000000"><b>+</b></font></span>&nbsp;<span><font color="#F66509">13</font></span><span><font color="000000">;</font></span><br><br><span><font color="000000">}</font></span><br>
\ No newline at end of file
diff --git a/homework/81498/Project/Wizard/Text files/simpleFunction.js b/homework/81498/Project/Wizard/Text files/simpleFunction.js
new file mode 100644
index 0000000..ac8d903
--- /dev/null
+++ b/homework/81498/Project/Wizard/Text files/simpleFunction.js
@@ -0,0 +1,6 @@
+function sumOfSomeNumbers ( number, secondNumber) {
+    magicalThingsWithNumbersAndStrings("hello there my friend", a, b, c);
+    number = 1 + 2 + 3 / 14 * (16 ** 16);
+    return true || number && 3 + 13;
+
+}
\ No newline at end of file
diff --git a/homework/81498/Project/Wizard/Tokenizing/Lexer.cs b/homework/81498/Project/Wizard/Tokenizing/Lexer.cs
new file mode 100644
index 0000000..69f011e
--- /dev/null
+++ b/homework/81498/Project/Wizard/Tokenizing/Lexer.cs
@@ -0,0 +1,428 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Wizard.Misc;
+
+namespace Wizard
+{
+    public class Lexer
+    {
+        public Lexer(string code, string location)
+        {
+            _code = code;
+            _location = location;
+
+            _currentLine = 1;
+            _indexInCode = 0;
+            _indexInCurrentLine = 0;
+
+            _keywordsToTokensMap = KeywordsToTokens.AsMap();
+            _complexOperatorsToTokensMap = OperatorsToTokens.AsMap(); // you didn't use this shithead
+            _exactMatchSymbolsToTokensMap = ExactMatchSymbolsToTokens.AsMap();
+        }
+
+        private const string _letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        private const string _digits = "0123456789";
+        private const string _identifiers = _letters + _digits + "_";
+        private const string _exactMatchSymbols = " \t:,({[]});'?.";
+        private const string _singleLetterOperators = "!|&/=><-%+*";
+
+        private string _code;
+        private string _location;
+        private int _currentLine;
+        private int _indexInCode;
+        private int _indexInCurrentLine;
+
+        private Dictionary<string, TokenType> _keywordsToTokensMap;
+        private Dictionary<string, TokenType> _complexOperatorsToTokensMap;
+        private Dictionary<char, TokenType> _exactMatchSymbolsToTokensMap;
+
+        public List<Token> GenerateTokens()
+        {
+            var tokens = new List<Token>();
+            do
+            {
+                tokens.Add(NextToken());
+            }
+            while (_indexInCode != _code.Length);
+
+            return tokens;
+        }
+
+        private Token NextToken()
+        {
+            char c = _code[_indexInCode];
+
+            if (_exactMatchSymbols.Contains(c))
+            {
+                AdvanceIndex();
+                return GenerateToken(_exactMatchSymbolsToTokensMap[c], c.ToString());
+            }
+
+            if (c is '\"')
+            {
+                return GenerateToken(TokenType.String, GetNextString());
+            }
+
+            if (c is '\n')
+            {
+                AdvanceIndexOnNewLine();
+                return GenerateToken(TokenType.Newline, "\n");
+            }
+            
+            // empty string parsed by Decimal.TryParse returns 0 but that's none of my business
+            if (_digits.Contains(c))
+            {
+                string nextNumber = GetNextNumber();
+                return GenerateToken(TokenType.Number, nextNumber);
+            }
+
+            if (_identifiers.Contains(c))
+            {
+                string nextWord = GetNextWord();
+
+                if (_keywordsToTokensMap.ContainsKey(nextWord))
+                {
+                    return GenerateToken(_keywordsToTokensMap[nextWord], nextWord);
+                }
+
+                return GenerateToken(TokenType.Identifier, nextWord);
+            }
+
+            if (_singleLetterOperators.Contains(c))
+            {
+                return GetOperatorToken();
+            }
+            return new Token(TokenType.Eof, _currentLine, "", _location, null);
+        }
+
+        private Token GenerateToken(TokenType type)
+        {
+            return new Token(type, _currentLine, "", _location, null);
+        }
+
+        private Token GenerateToken(TokenType type, string lexeme)
+        {
+            return new Token(type, _currentLine, lexeme, _location, null);
+        }
+
+        private void AdvanceIndex()
+        {
+            ++_indexInCode;
+            ++_indexInCurrentLine;
+        }
+
+        private void AdvanceIndexOnNewLine()
+        {
+            _indexInCode++;
+            _currentLine++;
+            _indexInCurrentLine = 0;
+        }
+
+        private char AdvanceAndGetNext()
+        {
+            AdvanceIndex();
+            return _code[_indexInCode];
+        }
+
+        private string GetNextString()
+        {   // advance once to ignore double quotes
+            AdvanceIndex();
+            try
+            {
+                char c = _code[_indexInCode];
+                string quoteTerminatedString = "";
+
+                while (c != '\"')
+                {
+                    quoteTerminatedString += c;
+
+                    c = AdvanceAndGetNext();
+                }
+
+                // advance again to ignore ending quotes
+                AdvanceIndex();
+
+                return quoteTerminatedString;
+            }
+            catch (ArgumentOutOfRangeException)
+            {
+                return "";
+            }
+        }
+
+        private string GetNextWord()
+        {
+            char c = _code[_indexInCode];
+            string identifiersOnlyString = "";
+
+            try
+            {
+                while (_identifiers.Contains(c))
+                {
+                    identifiersOnlyString += c;
+
+                    c = AdvanceAndGetNext();
+                }
+
+                return identifiersOnlyString;
+            }
+            catch (ArgumentOutOfRangeException)
+            {
+                return "";
+            }
+        }
+
+        private string GetNextNumber()
+        {
+            string nonDigitTerminatedString = "";
+
+            try
+            {
+                char c = _code[_indexInCode];
+
+                while (_digits.Contains(c))
+                {
+                    nonDigitTerminatedString += c;
+
+                    c = AdvanceAndGetNext();
+                }
+
+                return nonDigitTerminatedString;
+            }
+            catch (ArgumentOutOfRangeException)
+            {
+                return "";
+            }
+        }
+
+        // isn't there better way to do this? I mean structural way, like interface, another class or something? 
+        // Should I move handlers to another class?
+        // helper functions in an interface?
+        // what should be return in the catch of exceptions?
+        private Token GetOperatorToken()
+        {
+            try
+            {
+                char c = _code[_indexInCode];
+                switch (c)
+                {
+                    case '>': return HandleOperatorGreater();    // > >= 
+                    case '<': return HandleOperatorLess();       // < <= 
+                    case '/': return HandleOperatorDivision();   // / /=
+                    case '%': return HandleOperatorModulo();     // % %=
+                    case '+': return HandleOperatorPlus();       // + += ++
+                    case '-': return HandleOperatorMinus();      // - -= --
+                    case '&': return HandleOperatorBitwiseAnd(); // & &= &&
+                    case '|': return HandleOperatorBitwiseOr();  // | |= ||
+                    case '=': return HandleOperatorEquals();     // = == ===
+                    case '!': return HandleOperatorBang();       // ! != !! !==
+                    case '*': return HandleOperatorStar();       // * *= ** **=
+                    default:
+                        break;
+                }
+
+                return GenerateToken(TokenType.None); // throw exception?
+            }
+            catch (ArgumentOutOfRangeException)
+            {
+                return GenerateToken(TokenType.None);
+            }
+        }
+
+        private Token HandleOperatorStar()
+        {
+            char next = AdvanceAndGetNext();
+            if (next is '=')
+            {
+                AdvanceIndex();
+                return GenerateToken(TokenType.StarEqual, "*=");
+            }
+
+            if (next is '*')
+            {
+                next = AdvanceAndGetNext();
+                if (next is '=')
+                {
+                    AdvanceIndex();
+                    return GenerateToken(TokenType.DoubleStarEqual, "**=");
+                }
+
+                return GenerateToken(TokenType.DoubleStar, "**");
+            }
+
+            return GenerateToken(TokenType.Star, "*");
+        }
+
+        private Token HandleOperatorBang()
+        {
+            char next = AdvanceAndGetNext();
+
+            if (next is '!')
+            {
+                AdvanceIndex();
+                return GenerateToken(TokenType.DoubleBang, "!!");
+            }
+
+            if (next is '=')
+            {
+                next = AdvanceAndGetNext();
+                if (next is '=')
+                {
+                    AdvanceIndex();
+                    return GenerateToken(TokenType.StrictNotEqual, "!==");
+                }
+
+                return GenerateToken(TokenType.BangEqual, "!=");
+            }
+
+            return GenerateToken(TokenType.Bang, "!");
+        }
+
+        private Token HandleOperatorEquals()
+        {
+            char next = AdvanceAndGetNext();
+            if (next is '=')
+            {
+                next = AdvanceAndGetNext();
+                if (next is '=')
+                {
+                    AdvanceIndex();
+                    GenerateToken(TokenType.StrictEqual, "===");
+                }
+
+                return GenerateToken(TokenType.EqualEqual, "==");
+            }
+
+            return GenerateToken(TokenType.Equal, "=");
+        }
+
+        private Token HandleOperatorBitwiseOr()
+        {
+            char next = AdvanceAndGetNext();
+
+            if (next is '=')
+            {
+                AdvanceIndex();
+                return GenerateToken(TokenType.BitwiseOrEqual, "|=");
+            }
+
+            if (next is '|')
+            {
+                AdvanceIndex();
+                return GenerateToken(TokenType.LogicalOr, "||");
+            }
+
+            return GenerateToken(TokenType.BitwiseOr, "|");
+        }
+
+        private Token HandleOperatorBitwiseAnd()
+        {
+            char next = AdvanceAndGetNext();
+
+            if (next is '=')
+            {
+                AdvanceIndex();
+                return GenerateToken(TokenType.BitwiseAndEqual, "&=");
+            }
+
+            if (next is '&')
+            {
+                AdvanceIndex();
+                return GenerateToken(TokenType.LogicalAnd, "&&");
+            }
+
+            return GenerateToken(TokenType.BitwiseAnd, "&");
+        }
+
+        private Token HandleOperatorMinus()
+        {
+            char next = AdvanceAndGetNext();
+
+            if (next is '=')
+            {
+                AdvanceIndex();
+                return GenerateToken(TokenType.MinusEqual, "-=");
+            }
+
+            if (next is '-')
+            {
+                AdvanceIndex();
+                return GenerateToken(TokenType.MinusMinus, "--");
+            }
+
+            return GenerateToken(TokenType.Minus, "-");
+        }
+
+        private Token HandleOperatorPlus()
+        {
+            char next = AdvanceAndGetNext();
+
+            if (next is '=')
+            {
+                AdvanceIndex();
+                return GenerateToken(TokenType.PlusEqual, "+=");
+            }
+
+            if (next is '+')
+            {
+                AdvanceIndex();
+                return GenerateToken(TokenType.PlusPlus, "++");
+            }
+
+            return GenerateToken(TokenType.Plus, "+");
+        }
+
+        private Token HandleOperatorModulo()
+        {
+            char next = AdvanceAndGetNext();
+            if (next is '=')
+            {
+                AdvanceIndex();
+                return GenerateToken(TokenType.ModuloEqual, "%=");
+            }
+
+            return GenerateToken(TokenType.Modulo, "%");
+        }
+
+        private Token HandleOperatorDivision()
+        {
+            char next = AdvanceAndGetNext();
+
+            if (next is '=')
+            {
+                AdvanceIndex();
+                GenerateToken(TokenType.DivideEqual, "/=");
+            }
+
+            return GenerateToken(TokenType.Division, "/");
+
+        }
+
+        private Token HandleOperatorLess()
+        {
+            char next = AdvanceAndGetNext();
+
+            if (next == '=')
+            {
+                AdvanceIndex();
+                return GenerateToken(TokenType.LessEqual, "<=");
+            }
+
+            return GenerateToken(TokenType.Less, "<");
+        }
+
+        private Token HandleOperatorGreater()
+        {
+            char next = AdvanceAndGetNext();
+
+            if (next is '=')
+            {
+                AdvanceIndex();
+                return GenerateToken(TokenType.GreaterEqual, ">=");
+            }
+
+            return GenerateToken(TokenType.Greater, ">");
+        }
+    }
+}
\ No newline at end of file
diff --git a/homework/81498/Project/Wizard/Tokenizing/Token.cs b/homework/81498/Project/Wizard/Tokenizing/Token.cs
new file mode 100644
index 0000000..1d68e8e
--- /dev/null
+++ b/homework/81498/Project/Wizard/Tokenizing/Token.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Wizard
+{
+    public class Token
+    {
+        public Token(TokenType type, int line, string lexeme, string location, decimal? number)
+        {
+            Type = type;
+            Line = line;
+            Lexeme = lexeme;
+            Location = location;
+            Number = number;
+
+        }
+
+        public TokenType Type { get; private set; }
+        public int Line { get; private set; }
+        public string Lexeme { get; private set; }
+        public decimal? Number { get; private set; }
+        public string Location { get; private set; }
+
+        public override string ToString()
+        {
+            return Type.ToString() + " " + Lexeme + " " + Number;
+        }
+
+    }
+}
diff --git a/homework/81498/Project/Wizard/Tokenizing/TokenTypeEnumerator.cs b/homework/81498/Project/Wizard/Tokenizing/TokenTypeEnumerator.cs
new file mode 100644
index 0000000..78f5c0e
--- /dev/null
+++ b/homework/81498/Project/Wizard/Tokenizing/TokenTypeEnumerator.cs
@@ -0,0 +1,116 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Wizard
+{
+    public enum TokenType
+    {
+        // Whitespaces
+        Newline,
+        Tab,
+        Whitespace,
+
+        // Symbols
+        Colon,
+        Comma,
+        LeftBrace,
+        LeftParenthesis,
+        LeftSquareBracket,
+        RightBrace,
+        RightParenthesis,
+        RightSquareBracket,
+        Semicolon,
+        SingleQuote,
+
+        // One chararacter operators
+        Bang,
+        BitwiseAnd,
+        BitwiseOr,
+        Division,
+        Dot,
+        DoubleQuotes,
+        Equal,
+        Greater,
+        Less,
+        Minus,
+        Modulo,
+        Plus,
+        QuestionMark,
+        Star,
+
+        // Two character tokens
+        BangEqual,
+        BitwiseAndEqual,
+        BitwiseOrEqual,
+        DivideEqual,
+        DoubleBang,
+        DoubleStar,
+        EqualEqual,
+        GreaterEqual,
+        PlusEqual,
+        PlusPlus,
+        LogicalAnd,
+        LogicalOr,
+        LessEqual,
+        StarEqual,
+        MinusEqual,
+        MinusMinus,
+        ModuloEqual,
+
+        // Three character tokens
+        StrictEqual,
+        StrictNotEqual,
+        DoubleStarEqual,
+
+        Identifier,
+        Number,
+        String,
+
+        // Keywords. ECMAScript 2015
+        Break,
+        Case,
+        Catch,
+        Class,
+        Const,
+        Continue,
+        Debugger,
+        Default,
+        Delete,
+        Do,
+        Else,
+        Export,
+        Extends,
+        Finally,
+        For,
+        Function,
+        If,
+        Import,
+        In,
+        Instanceof,
+        Let,
+        New,
+        Return,
+        Super,
+        Switch,
+        This,
+        Throw,
+        Try,
+        Typeof,
+        Var,
+        Void,
+        While,
+        With,
+        Yield,
+        Null,
+        Undefined,
+        True,
+        False,
+
+        Eof,
+        None
+    }
+
+}