Parser selection without enum

include/Parsodus/backend.h

@@ -46,7 +46,7 @@ namespace pds {
              * @return Can this backend generate this type of parser
              */
 
-            virtual bool canGenerateParser(util::ParserType parserType);
+            virtual bool canGenerateParser(std::string parserType);
 
             /**
              * The function that gets called to generate the actual parser

include/Parsodus/backendmanager.h

@@ -30,10 +30,10 @@ namespace pds {
 
             template<template<class > class T>
             void registerLR() {
-                registerBackend(std::make_unique<T<lr::Generator<lr::LR0Itemset>>>(util::ParserType::LR_0)); 
+                registerBackend(std::make_unique<T<lr::Generator<lr::LR0Itemset>>>("LR(0)"));
-                registerBackend(std::make_unique<T<lr::Generator<lr::SLR1Itemset>>>(util::ParserType::SLR_1)); 
+                registerBackend(std::make_unique<T<lr::Generator<lr::SLR1Itemset>>>("SLR(1)"));
-                registerBackend(std::make_unique<T<lr::Generator<lr::LR1Itemset>>>(util::ParserType::LR_1));
+                registerBackend(std::make_unique<T<lr::Generator<lr::LR1Itemset>>>("LR(1)"));
-                registerBackend(std::make_unique<T<lr::Generator<lr::LALR1Itemset>>>(util::ParserType::LALR_1));
+                registerBackend(std::make_unique<T<lr::Generator<lr::LALR1Itemset>>>("LALR(1)"));
             }
             
             /**
@@ -44,7 +44,7 @@ namespace pds {
              * @param parserType the type of parser it should be able to produce (e.g. LALR_1, LR_0, etc..)
              * @returns A pointer to a Backend if it can find one, nullptr otherwise
              */
-            Backend* findBackend(std::string lang, util::ParserType parserType);
+            Backend* findBackend(std::string lang, std::string parserType);
 
         private:
             std::vector<std::unique_ptr<Backend> > m_backends; ///< The list of registered backends

include/Parsodus/backends/cppLR.h

@@ -20,21 +20,27 @@ namespace backends {
 	 */
 	template<typename Generator>
 	class CppLRBackend : public Backend {
-		public:
+        public:
-			CppLRBackend(util::ParserType parserType): Backend(), m_parserType(parserType) {}
+            CppLRBackend(std::string parserType): Backend() {
+                for (char& c : parserType)
+                    c = std::tolower(c);
+                m_parserType = parserType;
+            }
 
-			~CppLRBackend() {}
+            ~CppLRBackend() {}
 
-			std::string getName() {
+            std::string getName() {
                 return "c++";
             }
-			bool canProcessLang(std::string lang) {
+            bool canProcessLang(std::string lang) {
                 for (char& c : lang)
                     c = std::tolower(c);
                 return lang == "c++" || lang == "cpp" || lang == "cxx";
             }
 
-            bool canGenerateParser(util::ParserType parserType) {
+            bool canGenerateParser(std::string parserType) {
+                for (char& c : parserType)
+                    c = std::tolower(c);
                 return parserType == m_parserType;
             }
             
@@ -134,7 +140,7 @@ namespace backends {
                 this->doTemplate(*implOut, "c++/lr.cpp", topLevel);
             }
         private:
-            util::ParserType m_parserType;
+            std::string m_parserType;
     };
 }
 }

include/Parsodus/config.h

@@ -8,7 +8,7 @@
 namespace pds {
 
     struct Config {
-        util::ParserType parserType;
+        std::string parserType;
         std::string lexesisFile;
         Grammar grammar;
     };

src/backend.cpp

@@ -12,7 +12,7 @@ namespace pds {
         return false;
     }
 
-    bool Backend::canGenerateParser(util::ParserType /*parserType*/) {
+    bool Backend::canGenerateParser(std::string /*parserType*/) {
         return false;
     }
 

src/backendmanager.cpp

@@ -6,7 +6,7 @@ namespace pds {
         m_backends.push_back(std::move(backend));
     }
     
-    Backend* BackendManager::findBackend(std::string lang, util::ParserType parserType) {
+    Backend* BackendManager::findBackend(std::string lang, std::string parserType) {
         for(std::unique_ptr<Backend> &backend: m_backends) {
             if(backend->canProcessLang(lang) && backend->canGenerateParser(parserType)) return backend.get();
         }

src/driver.cpp

@@ -36,7 +36,7 @@ namespace pds {
         if (!m_parsername.length()) throw DriverException("no valid parser name possible"); 
         Config config = InputParser::parseInput(m_inputfile);       
         Backend* back = m_backends->findBackend(m_language, config.parserType);
-        if (!back) throw DriverException("Could not find a valid backend for language " + m_language + " and the given type of parser");
+        if (!back) throw DriverException("Could not find a valid backend for language " + m_language + " and parser type: " + config.parserType);
 		back->generateParser([this](std::string filename) -> std::unique_ptr<std::ostream> {
                 struct stat sb;
 				if(stat(m_outputdir.c_str(), &sb) != 0) {

src/inputparser.cpp

@@ -32,14 +32,7 @@ namespace pds {
                     case ParsodusLexer::PARSER:
                         lexColon(lex, token);
                         if(token.type == ParsodusLexer::PARSERTYPE) {
-                            if(token.content == "lalr(1)") {
+                            config.parserType = token.content;
-                                config.parserType = util::ParserType::LALR_1;
-                            } else if(token.content == "SLR(1)") {
-                                config.parserType = util::ParserType::SLR_1;
-                            } else if(token.content == "LR(1)") {
-                                config.parserType = util::ParserType::LR_1;
-                            } else
-                                throw InputParserException("Unkown parser type");
                         } else {
                             throw InputParserException("inputfile malformed, no parser type found in parser section");
                         }