#include "libsyntax.h" #include "ast_basic.h" using namespace lib_syntax; using namespace std; using namespace lib_token; using namespace ast_basic; TokenMatch::TokenMatch(shared_ptr define) : define_peer(define) {} QList> TokenMatch::children() const { return QList>(); } std::tuple TokenMatch::match(const QList>& stream) const { QString token_seqs = this->token_present(); if (stream.size() && define_peer->name() == stream.first()->define()->name()) return std::make_tuple(MatchResult::Success, 1); // auto mis_match = define_peer->name(); // auto real_match = stream.first()->define()->name(); return std::make_tuple(MatchResult::Fail, 0); } std::shared_ptr TokenMatch::parse(std::shared_ptr rt_inst, const QList>& stream) const { if (stream.size()) { auto current = stream.first(); if (current->define()->name() == define_peer->name()){ rt_inst->currentInst()->addToken(current); return nullptr; } throw new SyntaxException(QString(u8"Syntax[0x00001]语法匹配错误,不能识别token:%1<%2,%3>") .arg(current->content()).arg(current->row()).arg(current->column())); } throw new SyntaxException(u8"Syntax[0x0000]token流提前终止"); } QString TokenMatch::token_present() const { return QString(u8"<%1>").arg(this->define_peer->name()); } Rept::Rept(std::shared_ptr rule, int min, int max) : rule_peer(rule), min_match(min), max_match(max) {} QList> Rept::children() const { return QList>() << rule_peer; } std::tuple Rept::match(const QList>& stream) const { auto token_offset = 0; QString token_seqs = this->token_present(); // min-match for (auto idx = 0; idx < min_match; ++idx) { auto result = rule_peer->match(stream.mid(token_offset)); token_offset += std::get<1>(result); if (std::get<0>(result) != MatchResult::Success) { return std::make_tuple(token_offset ? MatchResult::Part : MatchResult::Fail, token_offset); } } // max-match for (auto idx = min_match; idx < max_match; ++idx) { auto result = rule_peer->match(stream.mid(token_offset)); switch (std::get<0>(result)) { case MatchResult::Fail: case MatchResult::Part: return std::make_tuple(MatchResult::Success, token_offset); default: token_offset += std::get<1>(result); break; } } return std::make_tuple(MatchResult::Success, token_offset); } std::shared_ptr Rept::parse(std::shared_ptr rt_inst, const QList>& stream) const { auto token_offset = 0; // min-match for (auto idx = 0; idx < min_match; ++idx) { auto result = rule_peer->match(stream.mid(token_offset)); auto result_gen = rule_peer->parse(rt_inst, stream.mid(token_offset)); if(result_gen) rt_inst->currentInst()->addChild(result_gen); token_offset += std::get<1>(result); } // max-match for (auto idx = min_match; idx < max_match; ++idx) { auto result = rule_peer->match(stream.mid(token_offset)); switch (std::get<0>(result)) { case MatchResult::Fail: case MatchResult::Part: return nullptr; default: break; } auto result_gen = rule_peer->parse(rt_inst, stream.mid(token_offset)); if (result_gen) rt_inst->currentInst()->addChild(result_gen); token_offset += std::get<1>(result); } return nullptr; } QString Rept::token_present() const { return u8"(" + this->rule_peer->token_present() + QString(u8"{%1, %2}").arg(min_match).arg(max_match) + u8")"; } Seqs::Seqs(const QList> mbrs) : mbrs_store(mbrs) {} QList> Seqs::children() const { return mbrs_store; } std::tuple Seqs::match(const QList>& stream) const { auto token_offset = 0; QString token_seqs = this->token_present(); for (auto& r : mbrs_store) { auto v_token_seqs = r->token_present(); auto result = r->match(stream.mid(token_offset)); token_offset += std::get<1>(result); switch (std::get<0>(result)) { case MatchResult::Fail: case MatchResult::Part: return std::make_tuple(token_offset ? MatchResult::Part : MatchResult::Fail, token_offset); default: break; } } return std::make_tuple(MatchResult::Success, token_offset); } std::shared_ptr Seqs::parse(std::shared_ptr rt_inst,const QList>& stream) const { auto token_offset = 0; for (auto& r : mbrs_store) { auto rst_gene = r->parse(rt_inst, stream.mid(token_offset)); if(rst_gene) rt_inst->currentInst()->addChild(rst_gene); auto result = r->match(stream.mid(token_offset)); token_offset += std::get<1>(result); } return nullptr; } QString Seqs::token_present() const { QString content; for (auto& it : children()) content += it->token_present(); return QString(u8"(%1)").arg(content); } std::tuple> Any::rule_select(const QList>& stream) const { QString token_seqs = this->token_present(); std::tuple> temp = std::make_tuple(MatchResult::Fail, 0, nullptr); for (auto& r : mbrs_store) { auto mbr_seqs = r->token_present(); auto result = r->match(stream); if (std::get<0>(result) == MatchResult::Success) return std::make_tuple(std::get<0>(result), std::get<1>(result), r); else if (std::get<0>(result) == MatchResult::Part) { if (std::get<0>(temp) == MatchResult::Fail || std::get<1>(result) > std::get<1>(temp)) temp = std::make_tuple(MatchResult::Part, std::get<1>(result), r); else temp = std::make_tuple(MatchResult::Part, std::get<1>(temp), std::get<2>(temp)); } else if (std::get<0>(temp) == MatchResult::Fail) { if (!std::get<2>(temp) || std::get<1>(result) > std::get<1>(temp)) temp = std::make_tuple(MatchResult::Fail, std::get<1>(result), r); else temp = std::make_tuple(MatchResult::Fail, std::get<1>(temp), std::get<2>(temp)); } } return temp; } Any::Any(const QList> mbrs) : mbrs_store(mbrs) {} QList> Any::children() const { return mbrs_store; } std::tuple Any::match(const QList>& stream) const { auto item = rule_select(stream); return std::make_tuple(std::get<0>(item), std::get<1>(item)); } std::shared_ptr Any::parse(std::shared_ptr rt_inst, const QList>& stream) const { auto temp = rule_select(stream); return std::get<2>(temp)->parse(rt_inst, stream); } QString Any::token_present() const { QString members_content; for (auto& it : children()) { members_content += it->token_present() + u8"|"; } return u8"(" + members_content.mid(0, members_content.size() - 1) + u8")"; } SyntaxException::SyntaxException(const QString& message) { this->msg_store = message; } QString SyntaxException::message() const { return msg_store; } lib_syntax::ExpressionRule::ExpressionRule(const QString& rule_name, int expr_mark) : name_store(rule_name) { this->filter_proc = [](const TokenSeqs& seqs) { return seqs; }; this->mark_store = expr_mark; } std::shared_ptr lib_syntax::ExpressionRule::reloadRule(std::function filter, std::shared_ptr rule) { auto ninst = makeCopy(); ninst->child_store = rule; ninst->filter_proc = filter; return ninst; } QString lib_syntax::ExpressionRule::name() const { return name_store; } int lib_syntax::ExpressionRule::typeMark() const { return this->mark_store; } QList> lib_syntax::ExpressionRule::children() const { return QList>() << this->child_store; } std::tuple lib_syntax::ExpressionRule::match(const QList>& stream) const { return child_store->match(stream); } std::shared_ptr lib_syntax::ExpressionRule::parse(std::shared_ptr rt_inst, const QList>& stream) const { std::shared_ptr elm_ast = this->newEmptyInstance(); rt_inst->pushExpressionRule(this->shared_from_this()); rt_inst->pushInst(elm_ast); child_store->parse(rt_inst, stream); auto tokens_decl = this->filter_proc(elm_ast->tokens()); elm_ast->tokensReset(tokens_decl); rt_inst->popExpressionRule(); return rt_inst->popInst(); } QString lib_syntax::ExpressionRule::token_present() const { return QString(u8"(%1)").arg(child_store->token_present()); }