thomasave
/
Parsodus
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Parser selection without enum

This commit is contained in:
Thomas Avé 2017-01-19 17:37:35 +01:00
parent f373b73aa1
commit cd39f64659
8 changed files with 24 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/Parsodus/backend.h
View File

@ -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

10
include/Parsodus/backendmanager.h
View File

@ -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::SLR1Itemset>>>(util::ParserType::SLR_1));
registerBackend(std::make_unique<T<lr::Generator<lr::LR1Itemset>>>(util::ParserType::LR_1));
registerBackend(std::make_unique<T<lr::Generator<lr::LALR1Itemset>>>(util::ParserType::LALR_1));
registerBackend(std::make_unique<T<lr::Generator<lr::LR0Itemset>>>("LR(0)"));
registerBackend(std::make_unique<T<lr::Generator<lr::SLR1Itemset>>>("SLR(1)"));
registerBackend(std::make_unique<T<lr::Generator<lr::LR1Itemset>>>("LR(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

20
include/Parsodus/backends/cppLR.h
View File

@ -20,21 +20,27 @@ namespace backends {
*/
template<typename Generator>
class CppLRBackend : public Backend {
public:
CppLRBackend(util::ParserType parserType): Backend(), m_parserType(parserType) {}
public:
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;
};
}
}

2
include/Parsodus/config.h
View File

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

2
src/backend.cpp
View File

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

2
src/backendmanager.cpp
View File

@ -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();
}

2
src/driver.cpp
View File

@ -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) {

9
src/inputparser.cpp
View File

@ -32,14 +32,7 @@ namespace pds {
case ParsodusLexer::PARSER:
lexColon(lex, token);
if(token.type == ParsodusLexer::PARSERTYPE) {
if(token.content == "lalr(1)") {
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");
config.parserType = token.content;
} else {
throw InputParserException("inputfile malformed, no parser type found in parser section");
}