Make parser template class

Language/public/Parser.hpp

@@ -3,16 +3,17 @@
 
 #include "AST.hpp"
 #include "GrammarCompiler.hpp"
-#include "Sentence.hpp"
 
 namespace tp {
+
+	template <typename tAlphabetType>
 	class Parser {
 	public:
 		Parser() = default;
 
 	public:
-		void compileTables(const ContextFreeGrammar& cfGrammar, const RegularGrammar& reGrammar);
-		void parse(const Sentence& sentence, AST& out);
+		void compileTables(const ContextFreeGrammar& cfGrammar, const RegularGrammar<tAlphabetType, ualni>& reGrammar) {}
+		void parse(const tAlphabetType* sentence, ualni sentenceLength, AST& out) {}
 
 	public:
 		// save load compiled tables

Language/public/Sentence.hpp

@@ -1,13 +0,0 @@
-
-#pragma once
-
-#include "LanguageCommon.hpp"
-
-namespace tp {
-	struct Sentence {
-		const int1* buffer = nullptr;
-		alni symbolSize = 1;
-
-		explicit Sentence(const char* buff) { buffer = buff; }
-	};
-}

Language/public/SimpleParser.hpp

@@ -5,16 +5,53 @@
 namespace tp {
 
 	// Gives ability to express grammar in the Unified Format as sentence
+	template <typename tAlphabetType>
 	class SimpleParser {
 	public:
-		SimpleParser();
+		SimpleParser() {
+			// Grammar for unified grammar format sentence that tables compiled from
+
+			// Define Context-Free grammar
+			ContextFreeGrammar contextFreeGrammar;
+			{
+				// use existing CF grammar interface
+				contextFreeGrammar.addRule("a", { ContextFreeGrammar::Arg("") });
+				contextFreeGrammar.setStart("a");
+			}
+
+			// Define Regular grammar
+			RegularGrammar<tAlphabetType, ualni> rg;
+			{
+				// this is basically ast from existing tokenizer
+				rg.addRule(rg.seq({ rg.val('a'), rg.val('b') }), 0);
+			}
+
+			mUnifiedGrammarParser.compileTables(contextFreeGrammar, rg);
+		}
 
 	public:
-		void compileTables(const Sentence& grammar);
-		void parse(const Sentence& sentence, AST& out);
+		void compileTables(const tAlphabetType* grammar, ualni grammarLength) {
+			AST unifiedGrammarAst;
+			mUnifiedGrammarParser.parse(grammar, grammarLength, unifiedGrammarAst);
+
+			// compile each ast into RegularGrammar and ContextFree Grammar api instructions
+			ContextFreeGrammar userContextFreeGrammar;
+			RegularGrammar<tAlphabetType, ualni> userRegularGrammar;
+
+			// ...
+			// split ast into RE and CF part
+			// generate and execute grammar api commands
+			// use existing tokenizer code to create RE transition matrix
+			// ...
+			// compile tables from user grammar
+
+			mUserParser.compileTables(userContextFreeGrammar, userRegularGrammar);
+		}
+
+		void parse(const tAlphabetType* grammar, ualni grammarLength, AST& out) { mUserParser.parse(grammar, grammarLength, out); }
 
 	private:
-		Parser mUnifiedGrammarParser;
-		Parser mUserParser;
+		Parser<tAlphabetType> mUnifiedGrammarParser;
+		Parser<tAlphabetType> mUserParser;
 	};
 }