Fixing folder capitlisation [1/2]

temp/inc/Token.h

@@ -0,0 +1,136 @@
+#pragma once
+
+#include <Util.h>
+
+namespace PashaBibko::LXC::Lexer
+{
+    namespace TokenClass
+    {
+        // Bitmask for different token classes //
+        enum ClassMask : unsigned short
+        {
+            // Mathematical and logic operators //
+            Operator		= 1 << (1 + 8),
+
+            // Special words defined by the compiler //
+            Keyword			= 1 << (2 + 8),
+
+            // Words such as literals and identifiers //
+            UserDefined		= 1 << (3 + 8),
+
+            // Symbols in the source like (? , . ! <) //
+            Symbols			= 1 << (4 + 8),
+
+            // Tokens not defined by previous classes //
+            Misc			= 1 << (5 + 8)
+        };
+    };
+
+    struct LexerContext;
+    
+    // Data type for storing the output of the lexer //
+    class Token final
+    {
+        public:
+            // Enum of token type organised by their token class //
+            enum TokenType : unsigned short
+            {
+                // === Operators === //
+
+                Add				= TokenClass::Operator,
+                Sub,
+                Mul,
+                Div,
+                Mod,
+
+                Eql,
+
+                // === Keywords === //
+
+                For				= TokenClass::Keyword,
+                While,
+                If,
+                ElseIf,
+                Else,
+                Return,
+
+                FunctionDef,
+
+                // === User defined === //
+
+                StringLiteral	= TokenClass::UserDefined,
+                NumLiteral,
+                Identifier,
+
+                // === Symbols === //
+
+                Assign			= TokenClass::Symbols,
+                Colon,
+
+                CloseBracket,
+                OpenBracket,
+
+                CloseBrace,
+                OpenBrace,
+
+                CloseParen,
+                OpenParen,
+
+                CloseCrocodile,
+                OpenCrocodile,
+
+                Comma,
+
+                // === Misc === //
+
+                End_of_file		= TokenClass::Misc,
+
+                UNDEFINED = 65535 // Invalid token type (max number)
+            };
+
+            // Util function calculating wether a token is of a given class //
+            template<TokenClass::ClassMask mask> static constexpr bool IsTypeClass(TokenType type) 
+	        {
+		        using T = std::underlying_type_t<TokenType>;
+	            return static_cast<T>(type) & static_cast<T>(mask);
+	        }
+
+            // Constructor to set the data of the token for more complex token types //
+            Token(const LexerContext& ctx, uint32_t start, unsigned short len, TokenType _type);
+
+            // Copy constructor //
+            Token(const Token& other);
+
+            // Move constructor (transfers memory allocated) //
+            Token(Token&& other) noexcept;
+
+            // Cannot use these as members are const //
+            Token& operator=(const Token&) = delete;
+            Token& operator=(Token&&) = delete;
+
+            // Deconstructor to clean up the allocated memory //
+            ~Token();
+
+            // Getters for the c-string to stop it being reassigned (or deleted) //
+            inline const char* const Str() const { return contents; }
+
+            // Outputs all the relevant infomration in a string for logging purposes //
+            std::string LogStr() const;
+
+            // The type of the token //
+            const TokenType type;
+
+            // The length of the token //
+            const unsigned short length;
+
+            // Start index of the token //
+            const uint32_t index;
+
+        private:
+            // The data of the token //
+            char* contents;
+    };
+
+    // Typedef for the output type of how the Lexer outputs //
+    typedef std::vector<Token> LexerOutput;
+}