Namespace cleanup, move some categories out of UI namespace

src/CSConsole/Lexers/CommentLexer.cs

@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace UnityExplorer.CSConsole.Lexers
+{
+    public class CommentLexer : Lexer
+    {
+        private enum CommentType
+        {
+            Line,
+            Block
+        }
+
+        // forest green
+        protected override Color HighlightColor => new Color(0.34f, 0.65f, 0.29f, 1.0f);
+
+        public override bool TryMatchCurrent(LexerBuilder lexer)
+        {
+            if (lexer.Current == '/')
+            {
+                lexer.PeekNext();
+                if (lexer.Current == '/')
+                {
+                    // line comment. read to end of line or file.
+                    do
+                    {
+                        lexer.Commit();
+                        lexer.PeekNext();
+                    }
+                    while (!lexer.EndOrNewLine);
+
+                    return true;
+                }
+                else if (lexer.Current == '*')
+                {
+                    // block comment, read until end of file or closing '*/'
+                    lexer.PeekNext();
+                    do
+                    {
+                        lexer.PeekNext();
+                        lexer.Commit();
+                    }
+                    while (!lexer.EndOfInput && !(lexer.Current == '/' && lexer.Previous == '*'));
+
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}

src/CSConsole/Lexers/KeywordLexer.cs

@@ -0,0 +1,63 @@
+using System.Collections.Generic;
+using System.Text;
+using UnityEngine;
+
+namespace UnityExplorer.CSConsole.Lexers
+{
+    public class KeywordLexer : Lexer
+    {
+        // system blue
+        protected override Color HighlightColor => new Color(0.33f, 0.61f, 0.83f, 1.0f);
+
+        public static readonly HashSet<string> keywords = new HashSet<string>
+        {
+// reserved keywords
+"abstract", "as", "base", "bool", "break", "byte", "case", "catch", "char", "checked", "class", "const", "continue",
+"decimal", "default", "delegate", "do", "double", "else", "enum", "event", "explicit", "extern", "false", "finally",
+"fixed", "float", "for", "foreach", "goto", "if", "implicit", "in", "int", "interface", "internal", "is", "lock",
+"long", "namespace", "new", "null", "object", "operator", "out", "override", "params", "private", "protected", "public",
+"readonly", "ref", "return", "sbyte", "sealed", "short", "sizeof", "stackalloc", "static", "string", "struct", "switch",
+"this", "throw", "true", "try", "typeof", "uint", "ulong", "unchecked", "unsafe", "ushort", "using", "virtual", "void",
+"volatile", "while",
+// contextual keywords
+"add", "and", "alias", "ascending", "async", "await", "by", "descending", "dynamic", "equals", "from", "get",
+"global", "group", "init", "into", "join", "let", "managed", "nameof",  "not", "notnull", "on",
+"or", "orderby", "partial", "record", "remove", "select", "set", "unmanaged", "value", "var", "when", "where",
+"where", "with", "yield", "nint", "nuint"
+        };
+
+        public override bool TryMatchCurrent(LexerBuilder lexer)
+        {
+            var prev = lexer.Previous;
+            var first = lexer.Current;
+
+            // check for keywords
+            if (lexer.IsDelimiter(prev, true) && char.IsLetter(first))
+            {
+                // can be a keyword...
+
+                var sb = new StringBuilder();
+                sb.Append(lexer.Current);
+                while (!lexer.EndOfInput && char.IsLetter(lexer.PeekNext()))
+                    sb.Append(lexer.Current);
+
+                // next must be whitespace or delimiter
+                if (!lexer.EndOfInput && !(char.IsWhiteSpace(lexer.Current) || lexer.IsDelimiter(lexer.Current)))
+                    return false;
+
+                if (keywords.Contains(sb.ToString()))
+                {
+                    if (!lexer.EndOfInput)
+                        lexer.RollbackBy(1);
+                    lexer.Commit();
+                    return true;
+                }
+
+                return false;
+
+            }
+            else
+                return false;
+        }
+    }
+}

src/CSConsole/Lexers/Lexer.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace UnityExplorer.CSConsole.Lexers
+{
+    public abstract class Lexer
+    {
+        public virtual IEnumerable<char> Delimiters => Enumerable.Empty<char>();
+
+        protected abstract Color HighlightColor { get; }
+
+        public string ColorTag => colorTag ?? (colorTag = "<color=#" + HighlightColor.ToHex() + ">");
+        private string colorTag;
+
+        public abstract bool TryMatchCurrent(LexerBuilder lexer);
+    }
+}

src/CSConsole/Lexers/NumberLexer.cs

@@ -0,0 +1,32 @@
+using UnityEngine;
+
+namespace UnityExplorer.CSConsole.Lexers
+{
+    public class NumberLexer : Lexer
+    {
+        // Maroon
+        protected override Color HighlightColor => new Color(0.58f, 0.33f, 0.33f, 1.0f);
+
+        private bool IsNumeric(char c) => char.IsNumber(c) || c == '.';
+
+        public override bool TryMatchCurrent(LexerBuilder lexer)
+        {
+            // previous character must be whitespace or delimiter
+            if (!lexer.IsDelimiter(lexer.Previous, true))
+                return false;
+
+            if (!IsNumeric(lexer.Current))
+                return false;
+
+            while (!lexer.EndOfInput)
+            {
+                lexer.Commit();
+                if (!IsNumeric(lexer.PeekNext()))
+                    break;
+            }
+
+            return true;
+        }
+    }
+
+}

src/CSConsole/Lexers/StringLexer.cs

@@ -0,0 +1,80 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityExplorer.CSConsole.Lexers
+{
+    public class StringLexer : Lexer
+    {
+        public override IEnumerable<char> Delimiters => new[] { '"', '\'', };
+
+        // orange
+        protected override Color HighlightColor => new Color(0.79f, 0.52f, 0.32f, 1.0f);
+
+        public override bool TryMatchCurrent(LexerBuilder lexer)
+        {
+            if (lexer.Current == '"')
+            {
+                if (lexer.Previous == '@')
+                {
+                    // verbatim string, continue until un-escaped quote.
+                    while (!lexer.EndOfInput)
+                    {
+                        lexer.Commit();
+                        if (lexer.PeekNext() == '"')
+                        {
+                            lexer.Commit();
+                            // possibly the end, check for escaped quotes.
+                            // commit the character and flip the escape bool for each quote.
+                            bool escaped = false;
+                            while (lexer.PeekNext() == '"')
+                            {
+                                lexer.Commit();
+                                escaped = !escaped;
+                            }
+                            // if the last quote wasnt escaped, that was the end of the string.
+                            if (!escaped)
+                                break;
+                        }
+                    }
+                }
+                else
+                {
+                    // normal string
+                    // continue until a quote which is not escaped, or end of input
+
+                    while (!lexer.EndOfInput)
+                    {
+                        lexer.Commit();
+                        lexer.PeekNext();
+                        if ((lexer.Current == '"') && lexer.Previous != '\\')
+                        {
+                            lexer.Commit();
+                            break;
+                        }
+                    }
+                }
+
+                return true;
+            }
+            else if (lexer.Current == '\'')
+            {
+                // char
+
+                while (!lexer.EndOfInput)
+                {
+                    lexer.Commit();
+                    lexer.PeekNext();
+                    if ((lexer.Current == '\'') && lexer.Previous != '\\')
+                    {
+                        lexer.Commit();
+                        break;
+                    }
+                }
+
+                return true;
+            }
+            else
+                return false;
+        }
+    }
+}

src/CSConsole/Lexers/SymbolLexer.cs

@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+
+namespace UnityExplorer.CSConsole.Lexers
+{
+    public class SymbolLexer : Lexer
+    {
+        // silver
+        protected override Color HighlightColor => new Color(0.6f, 0.6f, 0.6f);
+
+        // all symbols are delimiters
+        public override IEnumerable<char> Delimiters => symbols.Where(it => it != '.'); // '.' is not a delimiter, only a separator.
+
+        public static bool IsSymbol(char c) => symbols.Contains(c);
+
+        public static readonly HashSet<char> symbols = new HashSet<char>
+        {
+            '[', '{', '(',                  // open
+            ']', '}', ')',                  // close
+            '.', ',', ';', ':', '?', '@',   // special
+
+            // operators
+            '+', '-', '*', '/', '%', '&', '|', '^', '~', '=', '<', '>', '!',
+        };
+
+        public override bool TryMatchCurrent(LexerBuilder lexer)
+        {
+            // previous character must be delimiter, whitespace, or alphanumeric.
+            if (!lexer.IsDelimiter(lexer.Previous, true, true))
+                return false;
+
+            if (IsSymbol(lexer.Current))
+            {
+                do
+                {
+                    lexer.Commit();
+                    lexer.PeekNext();
+                }
+                while (IsSymbol(lexer.Current));
+
+                return true;
+            }
+
+            return false;
+        }
+    }
+}