Website Summary Files Commits Branches @commit @diff @stats
path: root / homework / 81498 / Project / Wizard
diff options
context:
space:
mode:
Commit68964c78790c0eaf847fa0491f85d73566e4985d (patch)
Author
 Yasen Bonev <yabonev@gmail.com>
2018-10-25 12:52:15 +0300
Committer
 dtrendafilov <trendafilov.dn@gmail.com>
2018-10-25 12:52:15 +0300
Files6410e06a3f99cbe76626c75f843c636fcff3a7ce /homework/81498/Project/Wizard
IPL-68964c78790c0eaf847fa0491f85d73566e4985d.tar
IPL-68964c78790c0eaf847fa0491f85d73566e4985d.tar.gz
IPL-68964c78790c0eaf847fa0491f85d73566e4985d.zip
Parent087fc8804bc0d26f19cdcb2111877f2da90bf471 (diff)
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
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
+ }
+
+}