codeboss
/
WsParser_VS
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update-slash

This commit is contained in:
codeboss 2024-07-19 20:48:36 +08:00
parent da598a5ba6
commit d41427a3a3
2 changed files with 155 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

224
libSyntax/libsyntax.cpp
View File

@ -9,30 +9,69 @@ using namespace ast_basic;
TokenMatch::TokenMatch(shared_ptr<const ITokenDefine> define) : define_peer(define) {} TokenMatch::TokenMatch(shared_ptr<const ITokenDefine> define) : define_peer(define) {}
QList<std::shared_ptr<const IBasicRule>> TokenMatch::children() const { return QList<std::shared_ptr<const IBasicRule>>(); } QList<shared_ptr<const IBasicRule>> TokenMatch::children() const { return QList<shared_ptr<const IBasicRule>>(); }
std::tuple<IBasicRule::MatchResult, std::shared_ptr<const IWordBase>> TokenMatch::parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const IWordBase> head) const { tuple<IBasicRule::MatchResult, shared_ptr<const IWordBase>>
TokenMatch::parse(shared_ptr<IContext> rt_inst, shared_ptr<const IWordBase> head, ErrOccurs& fx_type) const
{
if (!head) { if (!head) {
rt_inst->appendParseErrors(rt_inst->currentFile(), - 1, QString(u8"Syntax[0x0000]token流（%1）提前终止").arg(rt_inst->currentFile())); rt_inst->appendParseError(rt_inst->currentFile(), -1, QString(u8"Syntax[0x0000]token流（%1）提前终止").arg(rt_inst->currentFile()));
return std::make_tuple(IBasicRule::MatchResult::Fail, head); return make_tuple(IBasicRule::MatchResult::Fail, head);
} }
auto match_result = define_peer->analysis(head); auto match_result = define_peer->analysis(head);
if (std::get<0>(match_result)) { if (get<0>(match_result)) {
rt_inst->currentExprInst()->addToken(std::get<0>(match_result)); rt_inst->currentExprInst()->addToken(get<0>(match_result));
}
else {
rt_inst->appendParseErrors(rt_inst->currentFile(), head->position(),
QString(u8"Syntax[0x00001]语法匹配错误，不能识别token\"%1\"<row:%2,col:%3>(应该为：%4)")
.arg(head->content()).arg(head->row()).arg(head->column()).arg(this->define_peer->reviseWords()));
return std::make_tuple(IBasicRule::MatchResult::Part, head);
}
if (std::get<1>(match_result)) { if (get<1>(match_result)) {
return std::make_tuple(IBasicRule::MatchResult::Success, std::make_shared<WordImpl>(std::get<1>(match_result), head->nextWord())); return make_tuple(IBasicRule::MatchResult::Success, make_shared<WordImpl>(get<1>(match_result), head->nextWord()));
}
else {
return make_tuple(IBasicRule::MatchResult::Success, head->nextWord());
}
} }
else { else {
return std::make_tuple(IBasicRule::MatchResult::Success, head->nextWord()); switch (fx_type) {
case lib_syntax::IBasicRule::ErrOccurs::None:
return make_tuple(IBasicRule::MatchResult::Part, head);
case lib_syntax::IBasicRule::ErrOccurs::Replace:
fx_type = IBasicRule::ErrOccurs::None;
rt_inst->appendParseError(rt_inst->currentFile(), head->position(),
QString(u8"Syntax[0x00001]语法匹配错误，不能识别token：\"%1\"<row:%2,col:%3>(应该为：%4)")
.arg(head->content()).arg(head->row()).arg(head->column()).arg(this->define_peer->reviseWords()));
return make_tuple(IBasicRule::MatchResult::Success, head->nextWord());
case lib_syntax::IBasicRule::ErrOccurs::Absence:
fx_type = IBasicRule::ErrOccurs::None;
rt_inst->appendParseError(rt_inst->currentFile(), head->position(),
QString(u8"Syntax[0x00001]语法匹配错误，缺少token：\"%1\"<row: % 2, col : % 3>")
.arg(this->define_peer->reviseWords()).arg(head->row()).arg(head->column()));
return make_tuple(IBasicRule::MatchResult::Success, head);
case lib_syntax::IBasicRule::ErrOccurs::Surplus:
fx_type = IBasicRule::ErrOccurs::None;
{
auto temp_head = head->nextWord();
auto match_result = define_peer->analysis(temp_head);
if (get<0>(match_result)) {
rt_inst->appendParseError(rt_inst->currentFile(), head->position(),
QString(u8"Syntax[0x00001]语法匹配错误，多余token：\"%1\"<row: % 2, col : % 3>")
.arg(head->content()).arg(head->row()).arg(head->column()));
rt_inst->currentExprInst()->addToken(get<0>(match_result));
if (get<1>(match_result)) {
return make_tuple(IBasicRule::MatchResult::Success, make_shared<WordImpl>(get<1>(match_result), temp_head->nextWord()));
}
else {
return make_tuple(IBasicRule::MatchResult::Success, temp_head->nextWord());
}
}
else {
return make_tuple(IBasicRule::MatchResult::Part, head);
}
}
break;
default:
break;
}
} }
} }
@ -40,23 +79,24 @@ QString TokenMatch::token_present() const {
return QString(u8"<%1>").arg(this->define_peer->reviseWords()); return QString(u8"<%1>").arg(this->define_peer->reviseWords());
} }
Rept::Rept(std::shared_ptr<const IBasicRule> rule, int min, int max) : rule_peer(rule), min_match(min), max_match(max) {} Rept::Rept(shared_ptr<const IBasicRule> rule, int min, int max) : rule_peer(rule), min_match(min), max_match(max) {}
QList<std::shared_ptr<const IBasicRule>> Rept::children() const { return QList<std::shared_ptr<const IBasicRule>>() << rule_peer; } QList<shared_ptr<const IBasicRule>> Rept::children() const { return QList<shared_ptr<const IBasicRule>>() << rule_peer; }
std::tuple<IBasicRule::MatchResult, std::shared_ptr<const IWordBase>> Rept::parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const IWordBase> head) const { tuple<IBasicRule::MatchResult, shared_ptr<const IWordBase>>
Rept::parse(shared_ptr<IContext> rt_inst, shared_ptr<const IWordBase> head, IBasicRule::ErrOccurs& fx_type) const {
auto temp_head = head; auto temp_head = head;
// min-match // min-match
for (auto idx = 0; idx < min_match; ++idx) { for (auto idx = 0; idx < min_match; ++idx) {
auto result_gen = rule_peer->parse(rt_inst, temp_head); auto result_gen = rule_peer->parse(rt_inst, temp_head, fx_type);
switch (std::get<0>(result_gen)) { switch (get<0>(result_gen)) {
case IBasicRule::MatchResult::Fail: case IBasicRule::MatchResult::Fail:
return std::make_tuple(IBasicRule::MatchResult::Part, temp_head); return make_tuple(IBasicRule::MatchResult::Part, temp_head);
case IBasicRule::MatchResult::Part: case IBasicRule::MatchResult::Part:
return std::make_tuple(IBasicRule::MatchResult::Part, std::get<1>(result_gen)); return make_tuple(IBasicRule::MatchResult::Part, get<1>(result_gen));
default: default:
temp_head = std::get<1>(result_gen); temp_head = get<1>(result_gen);
break; break;
} }
} }
@ -66,18 +106,18 @@ std::tuple<IBasicRule::MatchResult, std::shared_ptr<const IWordBase>> Rept::pars
if (!temp_head) if (!temp_head)
break; break;
auto result_gen = rule_peer->parse(rt_inst, temp_head); auto result_gen = rule_peer->parse(rt_inst, temp_head, fx_type);
switch (std::get<0>(result_gen)) { switch (get<0>(result_gen)) {
case IBasicRule::MatchResult::Fail: case IBasicRule::MatchResult::Fail:
case IBasicRule::MatchResult::Part: case IBasicRule::MatchResult::Part:
return std::make_tuple(IBasicRule::MatchResult::Success, temp_head); return make_tuple(IBasicRule::MatchResult::Success, temp_head);
default: default:
temp_head = std::get<1>(result_gen); temp_head = get<1>(result_gen);
break; break;
} }
} }
return std::make_tuple(IBasicRule::MatchResult::Success, temp_head); return make_tuple(IBasicRule::MatchResult::Success, temp_head);
} }
QString Rept::token_present() const QString Rept::token_present() const
@ -85,29 +125,30 @@ QString Rept::token_present() const
return u8"(" + this->rule_peer->token_present() + QString(u8"{%1, %2}").arg(min_match).arg(max_match) + u8")"; return u8"(" + this->rule_peer->token_present() + QString(u8"{%1, %2}").arg(min_match).arg(max_match) + u8")";
} }
Seqs::Seqs(const QList<std::shared_ptr<const IBasicRule>> mbrs) : mbrs_store(mbrs) {} Seqs::Seqs(const QList<shared_ptr<const IBasicRule>> mbrs) : mbrs_store(mbrs) {}
QList<std::shared_ptr<const IBasicRule>> Seqs::children() const { return mbrs_store; } QList<shared_ptr<const IBasicRule>> Seqs::children() const { return mbrs_store; }
std::tuple<IBasicRule::MatchResult, std::shared_ptr<const IWordBase>> Seqs::parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const IWordBase> head) const { tuple<IBasicRule::MatchResult, shared_ptr<const IWordBase>>
Seqs::parse(shared_ptr<IContext> rt_inst, shared_ptr<const IWordBase> head, IBasicRule::ErrOccurs& fx_type) const {
auto temp_head = head; auto temp_head = head;
for (auto& r : mbrs_store) { for (auto& r : mbrs_store) {
auto rst_gene = r->parse(rt_inst, temp_head); auto rst_gene = r->parse(rt_inst, temp_head, fx_type);
switch (std::get<0>(rst_gene)) { switch (get<0>(rst_gene)) {
case IBasicRule::MatchResult::Fail: case IBasicRule::MatchResult::Fail:
return std::make_tuple(IBasicRule::MatchResult::Part, temp_head); return make_tuple(IBasicRule::MatchResult::Part, temp_head);
case IBasicRule::MatchResult::Part: case IBasicRule::MatchResult::Part:
return rst_gene; return rst_gene;
case IBasicRule::MatchResult::Success: case IBasicRule::MatchResult::Success:
temp_head = std::get<1>(rst_gene); temp_head = get<1>(rst_gene);
break; break;
default: default:
break; break;
} }
} }
return std::make_tuple(IBasicRule::MatchResult::Success, temp_head); return make_tuple(IBasicRule::MatchResult::Success, temp_head);
} }
QString Seqs::token_present() const QString Seqs::token_present() const
@ -118,10 +159,10 @@ QString Seqs::token_present() const
return QString(u8"(%1)").arg(content); return QString(u8"(%1)").arg(content);
} }
//std::tuple<IBasicRule::MatchResult, uint, std::shared_ptr<const IBasicRule>, std::shared_ptr<const Token>> //tuple<IBasicRule::MatchResult, uint, shared_ptr<const IBasicRule>, shared_ptr<const Token>>
Any::Any(const QList<std::shared_ptr<const IBasicRule>> mbrs) : mbrs_store(mbrs) {} Any::Any(const QList<shared_ptr<const IBasicRule>> mbrs) : mbrs_store(mbrs) {}
QList<std::shared_ptr<const IBasicRule>> Any::children() const { return mbrs_store; } QList<shared_ptr<const IBasicRule>> Any::children() const { return mbrs_store; }
class words_span { class words_span {
public: public:
@ -135,24 +176,25 @@ public:
return false; return false;
} }
}; };
std::tuple<IBasicRule::MatchResult, std::shared_ptr<const IWordBase>> Any::parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const IWordBase> head) const { tuple<IBasicRule::MatchResult, shared_ptr<const IWordBase>>
std::tuple<std::shared_ptr<const IBasicRule>, uint64_t> temp_result = std::make_tuple(nullptr, 0); Any::parse(shared_ptr<IContext> rt_inst, shared_ptr<const IWordBase> head, IBasicRule::ErrOccurs& fx_type) const {
tuple<shared_ptr<const IBasicRule>, uint64_t> temp_result = make_tuple(nullptr, 0);
auto rule_present = this->token_present(); auto rule_present = this->token_present();
for (auto& fork : mbrs_store) { for (auto& fork : mbrs_store) {
auto gen = fork->parse(rt_inst, head); auto gen = fork->parse(rt_inst, head, fx_type);
switch (std::get<0>(gen)) { switch (get<0>(gen)) {
// 遇到成功的直接返回解析结果 // 遇到成功的直接返回解析结果
case IBasicRule::MatchResult::Success: case IBasicRule::MatchResult::Success:
return gen; return gen;
case IBasicRule::MatchResult::Fail: { case IBasicRule::MatchResult::Fail: {
if (!std::get<0>(temp_result)) if (!get<0>(temp_result))
temp_result = std::make_tuple(fork, 0); temp_result = make_tuple(fork, 0);
}break; }break;
case IBasicRule::MatchResult::Part: { case IBasicRule::MatchResult::Part: {
auto span = std::get<1>(gen)->position() - head->position(); auto span = get<1>(gen)->position() - head->position();
if (span >= std::get<1>(temp_result)) if (span >= get<1>(temp_result))
temp_result = std::make_tuple(fork, span); temp_result = make_tuple(fork, span);
} }
default: default:
break; break;
@ -161,8 +203,8 @@ std::tuple<IBasicRule::MatchResult, std::shared_ptr<const IWordBase>> Any::parse
// 分析最匹配的分支 // 分析最匹配的分支
rt_inst->clearErrors(rt_inst->currentFile(), head->position()); rt_inst->clearErrors(rt_inst->currentFile(), head->position());
auto temp = std::get<0>(temp_result)->parse(rt_inst, head); auto temp = get<0>(temp_result)->parse(rt_inst, head, fx_type);
return std::make_tuple(IBasicRule::MatchResult::Part, std::get<1>(temp)); return make_tuple(IBasicRule::MatchResult::Part, get<1>(temp));
} }
QString Any::token_present() const QString Any::token_present() const
@ -183,7 +225,7 @@ ExprRule::ExprRule(const QString& rule_name, int expr_mark) : name_store(rule_na
this->mark_store = expr_mark; this->mark_store = expr_mark;
} }
std::shared_ptr<const ExprRule> ExprRule::reloadRule(std::shared_ptr<const IBasicRule> rule) { shared_ptr<const ExprRule> ExprRule::reloadRule(shared_ptr<const IBasicRule> rule) {
auto ninst = makeCopy(); auto ninst = makeCopy();
ninst->child_store = rule; ninst->child_store = rule;
return ninst; return ninst;
@ -193,49 +235,59 @@ QString ExprRule::name() const { return name_store; }
int ExprRule::typeMark() const { return this->mark_store; } int ExprRule::typeMark() const { return this->mark_store; }
QList<std::shared_ptr<const IBasicRule>> ExprRule::children() const { QList<shared_ptr<const IBasicRule>> ExprRule::children() const {
return QList<std::shared_ptr<const IBasicRule>>() << this->child_store; return QList<shared_ptr<const IBasicRule>>() << this->child_store;
} }
#include <ast_novel.h> #include <ast_novel.h>
std::tuple<IBasicRule::MatchResult, std::shared_ptr<const IWordBase>> tuple<IBasicRule::MatchResult, shared_ptr<const IWordBase>>
ExprRule::parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const IWordBase> head) const { ExprRule::parse(shared_ptr<IContext> rt_inst, shared_ptr<const IWordBase> head, IBasicRule::ErrOccurs& fx_type) const {
std::shared_ptr<IExprInst> elm_ast = this->newEmptyInstance(); QList<IBasicRule::ErrOccurs> opts_list = {
auto text_present = this->token_present(); IBasicRule::ErrOccurs::None, IBasicRule::ErrOccurs::Surplus, IBasicRule::ErrOccurs::Absence, IBasicRule::ErrOccurs::Replace };
rt_inst->pushExprRule(this->shared_from_this()); auto opt_current_itor = opts_list.cbegin();
rt_inst->pushExprInst(elm_ast); tuple<IBasicRule::MatchResult, shared_ptr<const IWordBase>> ret_tuple;
do {
auto opt_val = *opt_current_itor;
shared_ptr<IExprInst> elm_ast = this->newEmptyInstance();
auto text_present = this->token_present();
auto rstg = child_store->parse(rt_inst, head); rt_inst->pushExprRule(this->shared_from_this());
auto tokens_decl = elm_ast->tokens(); rt_inst->pushExprInst(elm_ast);
switch (std::get<0>(rstg)) { ret_tuple = child_store->parse(rt_inst, head, opt_val);
case IBasicRule::MatchResult::Fail: auto tokens_decl = elm_ast->tokens();
case IBasicRule::MatchResult::Part:
rt_inst->popExprInst(); switch (get<0>(ret_tuple)) {
rt_inst->popExprRule(); case IBasicRule::MatchResult::Fail:
break; case IBasicRule::MatchResult::Part:
case IBasicRule::MatchResult::Success: { rt_inst->popExprInst();
if (!std::dynamic_pointer_cast<example_novel::Document>(elm_ast)) { rt_inst->popExprRule();
auto start_pos = tokens_decl.first()->position(); break;
rt_inst->clearErrors(rt_inst->currentFile(), start_pos); case IBasicRule::MatchResult::Success: {
if (!dynamic_pointer_cast<example_novel::Document>(elm_ast) && opt_val == IBasicRule::ErrOccurs::None) {
auto start_pos = head->position();
rt_inst->clearErrors(rt_inst->currentFile(), start_pos);
}
rt_inst->popExprInst();
rt_inst->popExprRule();
if (rt_inst->currentExprInst()) {
rt_inst->currentExprInst()->addChild(elm_ast);
}
else {
rt_inst->appendDocInst(elm_ast);
}
}break;
default:
break;
} }
rt_inst->popExprInst(); opt_current_itor++;
rt_inst->popExprRule(); } while (fx_type != IBasicRule::ErrOccurs::None && opt_current_itor != opts_list.cend());
if (rt_inst->currentExprInst()) { return ret_tuple;
rt_inst->currentExprInst()->addChild(elm_ast);
}
else {
rt_inst->appendDocInst(elm_ast);
}
}break;
default:
break;
}
return rstg;
} }
QString ExprRule::token_present() const { QString ExprRule::token_present() const {

23
libSyntax/libsyntax.h
View File

@ -81,14 +81,25 @@ namespace lib_syntax {
Fail // 从第一个词起完全不匹配 Fail // 从第一个词起完全不匹配
}; };
/**
* @brief 修正类型
*/
enum class ErrOccurs {
None, // 无
Replace, // 错一个词
Absence, // 少一个词
Surplus // 多一个词
};
/** /**
* @brief 解析 * @brief 解析
* @param rt_inst 解析上下文 * @param rt_inst 解析上下文
* @param head 列表头 * @param head 列表头
* @param fx_type 修正措施
* @return 返回结果<匹配完成新列表头,匹配长度> * @return 返回结果<匹配完成新列表头,匹配长度>
*/ */
virtual std::tuple<IBasicRule::MatchResult, std::shared_ptr<const lib_token::IWordBase>> virtual std::tuple<IBasicRule::MatchResult, std::shared_ptr<const lib_token::IWordBase>>
parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const lib_token::IWordBase> head) const = 0; parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const lib_token::IWordBase> head, ErrOccurs &fx_type) const = 0;
/** /**
* 返回匹配语法规则的词法序列表达 * 返回匹配语法规则的词法序列表达
@ -113,7 +124,7 @@ namespace lib_syntax {
public: public:
virtual QList<std::shared_ptr<const IBasicRule>> children() const override; virtual QList<std::shared_ptr<const IBasicRule>> children() const override;
virtual std::tuple<IBasicRule::MatchResult, std::shared_ptr<const lib_token::IWordBase>> virtual std::tuple<IBasicRule::MatchResult, std::shared_ptr<const lib_token::IWordBase>>
parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const lib_token::IWordBase> head) const override; parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const lib_token::IWordBase> head, ErrOccurs &fx_type) const override;
virtual QString token_present() const override; virtual QString token_present() const override;
}; };
@ -133,7 +144,7 @@ namespace lib_syntax {
public: public:
virtual QList<std::shared_ptr<const IBasicRule>> children() const override; virtual QList<std::shared_ptr<const IBasicRule>> children() const override;
virtual std::tuple<IBasicRule::MatchResult, std::shared_ptr<const lib_token::IWordBase>> virtual std::tuple<IBasicRule::MatchResult, std::shared_ptr<const lib_token::IWordBase>>
parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const lib_token::IWordBase> head) const override; parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const lib_token::IWordBase> head, ErrOccurs &fx_type) const override;
virtual QString token_present() const override; virtual QString token_present() const override;
}; };
@ -151,7 +162,7 @@ namespace lib_syntax {
public: public:
virtual QList<std::shared_ptr<const IBasicRule>> children() const override; virtual QList<std::shared_ptr<const IBasicRule>> children() const override;
virtual std::tuple<IBasicRule::MatchResult, std::shared_ptr<const lib_token::IWordBase>> virtual std::tuple<IBasicRule::MatchResult, std::shared_ptr<const lib_token::IWordBase>>
parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const lib_token::IWordBase> head) const override; parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const lib_token::IWordBase> head, ErrOccurs &fx_type) const override;
virtual QString token_present() const override; virtual QString token_present() const override;
}; };
@ -170,7 +181,7 @@ namespace lib_syntax {
public: public:
virtual QList<std::shared_ptr<const IBasicRule>> children() const override; virtual QList<std::shared_ptr<const IBasicRule>> children() const override;
virtual std::tuple<IBasicRule::MatchResult, std::shared_ptr<const lib_token::IWordBase>> virtual std::tuple<IBasicRule::MatchResult, std::shared_ptr<const lib_token::IWordBase>>
parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const lib_token::IWordBase> head) const override; parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const lib_token::IWordBase> head, ErrOccurs &fixed_type) const override;
virtual QString token_present() const override; virtual QString token_present() const override;
}; };
@ -194,7 +205,7 @@ namespace lib_syntax {
public: public:
virtual QList<std::shared_ptr<const lib_syntax::IBasicRule>> children() const override; virtual QList<std::shared_ptr<const lib_syntax::IBasicRule>> children() const override;
virtual std::tuple<IBasicRule::MatchResult, std::shared_ptr<const lib_token::IWordBase>> virtual std::tuple<IBasicRule::MatchResult, std::shared_ptr<const lib_token::IWordBase>>
parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const lib_token::IWordBase> head) const override; parse(std::shared_ptr<IContext> rt_inst, std::shared_ptr<const lib_token::IWordBase> head, ErrOccurs &fx_type) const override;
virtual QString token_present() const override; virtual QString token_present() const override;
protected: protected: