Parser Initial

Parser/CMakeLists.txt

@@ -0,0 +1,22 @@
+
+cmake_minimum_required(VERSION 3.2)
+
+set(CMAKE_CXX_STANDARD 23)
+
+project(Parser)
+
+### ---------------------- Static Library  ---------------------  ###
+file(GLOB SOURCES "./private/*.cpp")
+file(GLOB HEADERS "./public/*.hpp")
+add_library(${PROJECT_NAME} STATIC ${SOURCES} ${HEADERS})
+target_include_directories(${PROJECT_NAME} PUBLIC ./public/)
+target_link_libraries(${PROJECT_NAME} PUBLIC Strings)
+
+### -------------------------- Tests  --------------------------  ###
+enable_testing()
+file(GLOB TEST_SOURCES "./tests/*.cpp")
+add_executable(${PROJECT_NAME}Tests ${TEST_SOURCES})
+target_link_libraries(${PROJECT_NAME}Tests  ${PROJECT_NAME} Utils)
+add_test(NAME ${PROJECT_NAME}Tests COMMAND ${PROJECT_NAME}Tests)
+
+install(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/${PROJECT_NAME}/lib)

Parser/public/Parser.hpp

@@ -0,0 +1,105 @@
+#pragma once
+
+#include "Strings.hpp"
+#include "Map.hpp"
+#include "List.hpp"
+
+namespace tp {
+
+	template <typename tAlphabetType>
+	class ContextFreeGrammar {
+	public:
+		class NonTerminalSymbol;
+
+		class RHSArg {
+			tAlphabetType terminal;
+			const NonTerminalSymbol* nonTerminal = nullptr;
+		public:
+			RHSArg(const NonTerminalSymbol* aNonTerminal) : nonTerminal(aNonTerminal) {}
+			RHSArg(tAlphabetType terminal) : terminal(terminal) {}
+		};
+
+		class NonTerminalSymbol {
+			String name;
+			String description;
+
+			struct Rule {
+				List<RHSArg> mArgs;
+			};
+
+			List<Rule> mRules;
+
+			Rule* newRule() {
+				mRules.pushBack();
+				return mRules.last()->data;
+			}
+		};
+
+	private:
+		Map<String, NonTerminalSymbol> mNonTerminals;
+		NonTerminalSymbol* mStart;
+
+	public:
+		ContextFreeGrammar() = default;
+
+		void setStartNonTerminal(const NonTerminalSymbol* start) {
+			mStart = start;
+		}
+
+		const NonTerminalSymbol* addRule(const String& LHS, const InitialierList<RHSArg> RHS) {
+			NonTerminalSymbol* nonTerminal = nullptr;
+			auto idx = mNonTerminals.presents(LHS);
+			if (idx) {
+				nonTerminal = mNonTerminals.get(idx);
+			} else {
+				nonTerminal = new NonTerminalSymbol(LHS, "None");
+				mNonTerminals.put(LHS, nonTerminal);
+			}
+
+			auto* rule = nonTerminal->newRule();
+			for (auto arg : RHS) {
+				rule->pushBack(arg);
+			}
+
+			return nonTerminal;
+		}
+
+		bool checkSemantic() {
+			return false;
+		}
+
+		bool checkNonAmbiguous() {
+			return false;
+		}
+	};
+
+	template <typename tAlphabetType>
+	class Parser {
+		typedef ContextFreeGrammar<tAlphabetType> Grammar;
+
+	public:
+		class ASTNode {
+			const Grammar::NonTerminalSymbol* mNonTerminal;
+			List<const ASTNode*> mLeafs;
+		};
+
+	private:
+		class InputTape {
+		};
+
+		class StateStack {
+		};
+
+	private:
+		Grammar mGrammar;
+
+	public:
+		Parser() = default;
+
+		Grammar& getGrammar() { return mGrammar; }
+
+		void buildTables() {}
+
+		const ASTNode* parse() {}
+	};
+}

Parser/tests/Tests.cpp

@@ -0,0 +1,4 @@
+
+int main() {
+
+}