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

基于链表解析方式更新

This commit is contained in:
codeboss 2024-06-18 22:59:41 +08:00
parent 856a81c2c9
commit c49c4c4230
2 changed files with 106 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

164
libSyntax/libsyntax.cpp
View File

@ -10,27 +10,27 @@ TokenMatch::TokenMatch(shared_ptr<const TokenDefine> define) : define_peer(defin
QList<std::shared_ptr<const BaseRule>> TokenMatch::children() const { return QList<std::shared_ptr<const BaseRule>>(); } QList<std::shared_ptr<const BaseRule>> TokenMatch::children() const { return QList<std::shared_ptr<const BaseRule>>(); }
std::tuple<BaseRule::MatchResult, uint> TokenMatch::match(const QList<std::shared_ptr<const Token>>& stream) const { std::tuple<BaseRule::MatchResult, uint, std::shared_ptr<const Token>> TokenMatch::match(std::shared_ptr<const Token> remains_head) const {
QString token_seqs = this->token_present(); QString token_seqs = this->token_present();
if (stream.size() && define_peer->name() == stream.first()->define()->name()) if (remains_head && remains_head->define()->name() == define_peer->name())
return std::make_tuple(MatchResult::Success, 1); return std::make_tuple(MatchResult::Success, 1, remains_head->nextToken());
return std::make_tuple(MatchResult::Fail, 0, nullptr);
// auto mis_match = define_peer->name(); // auto mis_match = define_peer->name();
// auto real_match = stream.first()->define()->name(); // auto real_match = stream.first()->define()->name();
return std::make_tuple(MatchResult::Fail, 0);
} }
// std::tuple<std::shared_ptr<const ast_basic::Expression>, std::shared_ptr<const lib_token::Token>>
std::tuple<std::shared_ptr<const Expression>, std::shared_ptr<const Token>> TokenMatch::parse(std::shared_ptr<ParseContext> rt_inst, std::shared_ptr<const Token> head) const {
if (!head)
throw new SyntaxException(u8"Syntax[0x0000]token流提前终止");
std::shared_ptr<const Expression> TokenMatch::parse(std::shared_ptr<ParseContext> rt_inst, const QList<std::shared_ptr<const lib_token::Token>>& stream) const { if (head->define()->name() == define_peer->name()) {
if (stream.size()) { rt_inst->currentInst()->addToken(head);
auto current = stream.first(); return std::make_tuple(nullptr, head->nextToken());
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流提前终止");
throw new SyntaxException(QString(u8"Syntax[0x00001]语法匹配错误，不能识别token：%1<%2,%3>")
.arg(head->content()).arg(head->row()).arg(head->column()));
} }
QString TokenMatch::token_present() const { QString TokenMatch::token_present() const {
@ -41,70 +41,67 @@ Rept::Rept(std::shared_ptr<const BaseRule> rule, int min, int max) : rule_peer(r
QList<std::shared_ptr<const BaseRule>> Rept::children() const { return QList<std::shared_ptr<const BaseRule>>() << rule_peer; } QList<std::shared_ptr<const BaseRule>> Rept::children() const { return QList<std::shared_ptr<const BaseRule>>() << rule_peer; }
std::tuple<BaseRule::MatchResult, uint> Rept::match(const QList<std::shared_ptr<const lib_token::Token>>& stream) const { std::tuple<BaseRule::MatchResult, uint, std::shared_ptr<const Token>> Rept::match(std::shared_ptr<const Token> list_head) const {
auto token_offset = 0; auto token_offset = 0;
QString token_seqs = this->token_present(); QString token_seqs = this->token_present();
auto temp_head = list_head;
// min-match // min-match
for (auto idx = 0; idx < min_match; ++idx) { for (auto idx = 0; idx < min_match; ++idx) {
auto result = rule_peer->match(stream.mid(token_offset)); auto result = rule_peer->match(temp_head);
token_offset += std::get<1>(result); token_offset += std::get<1>(result);
temp_head = std::get<2>(result);
if (std::get<0>(result) != MatchResult::Success) { if (std::get<0>(result) != MatchResult::Success) {
return std::make_tuple(token_offset ? MatchResult::Part : MatchResult::Fail, token_offset); return std::make_tuple(token_offset ? MatchResult::Part : MatchResult::Fail, token_offset, temp_head);
} }
} }
// max-match // max-match
for (auto idx = min_match; idx < max_match; ++idx) { for (auto idx = min_match; idx < max_match; ++idx) {
auto result = rule_peer->match(stream.mid(token_offset)); auto result = rule_peer->match(temp_head);
switch (std::get<0>(result)) { switch (std::get<0>(result)) {
case MatchResult::Fail: case MatchResult::Fail:
case MatchResult::Part: case MatchResult::Part:
return std::make_tuple(MatchResult::Success, token_offset); return std::make_tuple(MatchResult::Success, token_offset, temp_head);
default: default:
temp_head = std::get<2>(result);
token_offset += std::get<1>(result); token_offset += std::get<1>(result);
break; break;
} }
} }
return std::make_tuple(MatchResult::Success, token_offset); return std::make_tuple(MatchResult::Success, token_offset, temp_head);
} }
std::shared_ptr<const Expression> Rept::parse(std::shared_ptr<ParseContext> rt_inst, const QList<std::shared_ptr<const lib_token::Token>>& stream) const { std::tuple<std::shared_ptr<const Expression>, std::shared_ptr<const Token>> Rept::parse(std::shared_ptr<ParseContext> rt_inst, std::shared_ptr<const Token> head) const {
auto token_offset = 0; 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 = rule_peer->match(stream.mid(token_offset)); auto result_gen = rule_peer->parse(rt_inst, temp_head);
if (std::get<0>(result_gen))
rt_inst->currentInst()->addChild(std::get<0>(result_gen));
auto result_gen = rule_peer->parse(rt_inst, stream.mid(token_offset)); temp_head = std::get<1>(result_gen);
if(result_gen)
rt_inst->currentInst()->addChild(result_gen);
token_offset += std::get<1>(result);
} }
// max-match // max-match
for (auto idx = min_match; idx < max_match; ++idx) { for (auto idx = min_match; idx < max_match; ++idx) {
auto result = rule_peer->match(stream.mid(token_offset)); try {
auto result_gen = rule_peer->parse(rt_inst, temp_head);
if (std::get<0>(result_gen))
rt_inst->currentInst()->addChild(std::get<0>(result_gen));
switch (std::get<0>(result)) { temp_head = std::get<1>(result_gen);
case MatchResult::Fail: }
case MatchResult::Part: catch (...) {
return nullptr; return std::make_tuple(nullptr, temp_head);
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; return std::make_tuple(nullptr, temp_head);
} }
QString Rept::token_present() const QString Rept::token_present() const
@ -116,38 +113,41 @@ Seqs::Seqs(const QList<std::shared_ptr<const BaseRule>> mbrs) : mbrs_store(mbrs)
QList<std::shared_ptr<const BaseRule>> Seqs::children() const { return mbrs_store; } QList<std::shared_ptr<const BaseRule>> Seqs::children() const { return mbrs_store; }
std::tuple<BaseRule::MatchResult, uint> Seqs::match(const QList<std::shared_ptr<const lib_token::Token>>& stream) const { std::tuple<BaseRule::MatchResult, uint, std::shared_ptr<const Token>> Seqs::match(std::shared_ptr<const Token> list_head) const {
auto token_offset = 0; auto token_offset = 0;
QString token_seqs = this->token_present(); QString token_seqs = this->token_present();
auto temp_head = list_head;
for (auto& r : mbrs_store) { for (auto& r : mbrs_store) {
auto v_token_seqs = r->token_present(); auto v_token_seqs = r->token_present();
auto result = r->match(stream.mid(token_offset)); auto result = r->match(list_head);
token_offset += std::get<1>(result); token_offset += std::get<1>(result);
temp_head = std::get<2>(result);
switch (std::get<0>(result)) { switch (std::get<0>(result)) {
case MatchResult::Fail: case MatchResult::Fail:
case MatchResult::Part: case MatchResult::Part:
return std::make_tuple(token_offset ? MatchResult::Part : MatchResult::Fail, token_offset); return std::make_tuple(token_offset ? MatchResult::Part : MatchResult::Fail, token_offset, temp_head);
default: default:
break; break;
} }
} }
return std::make_tuple(MatchResult::Success, token_offset); return std::make_tuple(MatchResult::Success, token_offset, temp_head);
} }
std::shared_ptr<const Expression> Seqs::parse(std::shared_ptr<ParseContext> rt_inst,const QList<std::shared_ptr<const lib_token::Token>>& stream) const { std::tuple<std::shared_ptr<const Expression>, std::shared_ptr<const Token>> Seqs::parse(std::shared_ptr<ParseContext> rt_inst, std::shared_ptr<const Token> head) const {
auto token_offset = 0; auto temp_head = head;
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)); for (auto& r : mbrs_store) {
token_offset += std::get<1>(result); auto rst_gene = r->parse(rt_inst, temp_head);
temp_head = std::get<1>(rst_gene);
if (std::get<0>(rst_gene))
rt_inst->currentInst()->addChild(std::get<0>(rst_gene));
} }
return nullptr; return std::make_tuple(nullptr, temp_head);
} }
QString Seqs::token_present() const QString Seqs::token_present() const
@ -158,29 +158,29 @@ QString Seqs::token_present() const
return QString(u8"(%1)").arg(content); return QString(u8"(%1)").arg(content);
} }
std::tuple<BaseRule::MatchResult, uint, std::shared_ptr<const BaseRule>> std::tuple<BaseRule::MatchResult, uint, std::shared_ptr<const BaseRule>, std::shared_ptr<const Token>>
Any::rule_select(const QList<std::shared_ptr<const lib_token::Token>>& stream) const { Any::rule_select(std::shared_ptr<const Token> head) const {
QString token_seqs = this->token_present(); QString token_seqs = this->token_present();
std::tuple<MatchResult, uint, std::shared_ptr<const BaseRule>> temp = std::make_tuple(MatchResult::Fail, 0, nullptr); std::tuple<MatchResult, uint, std::shared_ptr<const BaseRule>, std::shared_ptr<const Token>> temp = std::make_tuple(MatchResult::Fail, 0, nullptr, nullptr);
for (auto& r : mbrs_store) { for (auto& r : mbrs_store) {
auto mbr_seqs = r->token_present(); auto mbr_seqs = r->token_present();
auto result = r->match(stream); auto result = r->match(head);
if (std::get<0>(result) == MatchResult::Success) if (std::get<0>(result) == MatchResult::Success)
return std::make_tuple(std::get<0>(result), std::get<1>(result), r); return std::make_tuple(std::get<0>(result), std::get<1>(result), r, std::get<2>(result));
else if (std::get<0>(result) == MatchResult::Part) { else if (std::get<0>(result) == MatchResult::Part) {
if (std::get<0>(temp) == MatchResult::Fail || std::get<1>(result) > std::get<1>(temp)) 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); temp = std::make_tuple(MatchResult::Part, std::get<1>(result), r, std::get<2>(result));
else else
temp = std::make_tuple(MatchResult::Part, std::get<1>(temp), std::get<2>(temp)); temp = std::make_tuple(MatchResult::Part, std::get<1>(temp), std::get<2>(temp), std::get<3>(temp));
} }
else if (std::get<0>(temp) == MatchResult::Fail) { else if (std::get<0>(temp) == MatchResult::Fail) {
if (!std::get<2>(temp) || std::get<1>(result) > std::get<1>(temp)) if (!std::get<2>(temp) || std::get<1>(result) > std::get<1>(temp))
temp = std::make_tuple(MatchResult::Fail, std::get<1>(result), r); temp = std::make_tuple(MatchResult::Fail, std::get<1>(result), r, std::get<2>(result));
else else
temp = std::make_tuple(MatchResult::Fail, std::get<1>(temp), std::get<2>(temp)); temp = std::make_tuple(MatchResult::Fail, std::get<1>(temp), std::get<2>(temp), std::get<3>(temp));
} }
} }
@ -191,14 +191,14 @@ Any::Any(const QList<std::shared_ptr<const BaseRule>> mbrs) : mbrs_store(mbrs) {
QList<std::shared_ptr<const BaseRule>> Any::children() const { return mbrs_store; } QList<std::shared_ptr<const BaseRule>> Any::children() const { return mbrs_store; }
std::tuple<BaseRule::MatchResult, uint> Any::match(const QList<std::shared_ptr<const lib_token::Token>>& stream) const { std::tuple<BaseRule::MatchResult, uint, std::shared_ptr<const Token>> Any::match(std::shared_ptr<const Token> list_head) const {
auto item = rule_select(stream); auto item = rule_select(list_head);
return std::make_tuple(std::get<0>(item), std::get<1>(item)); return std::make_tuple(std::get<0>(item), std::get<1>(item), std::get<3>(item));
} }
std::shared_ptr<const Expression> Any::parse(std::shared_ptr<ParseContext> rt_inst, const QList<std::shared_ptr<const lib_token::Token>>& stream) const { std::tuple<std::shared_ptr<const Expression>, std::shared_ptr<const Token>> Any::parse(std::shared_ptr<ParseContext> rt_inst, std::shared_ptr<const Token> head) const {
auto temp = rule_select(stream); auto temp = rule_select(head);
return std::get<2>(temp)->parse(rt_inst, stream); return std::get<2>(temp)->parse(rt_inst, head);
} }
QString Any::token_present() const QString Any::token_present() const
@ -215,44 +215,44 @@ SyntaxException::SyntaxException(const QString& message) { this->msg_store = mes
QString SyntaxException::message() const { return msg_store; } QString SyntaxException::message() const { return msg_store; }
lib_syntax::ExpressionRule::ExpressionRule(const QString& rule_name, int expr_mark) : name_store(rule_name) { ExpressionRule::ExpressionRule(const QString& rule_name, int expr_mark) : name_store(rule_name) {
this->filter_proc = [](const TokenSeqs& seqs) { return seqs; }; this->filter_proc = [](const TokenSeqs& seqs) { return seqs; };
this->mark_store = expr_mark; this->mark_store = expr_mark;
} }
std::shared_ptr<const ExpressionRule> lib_syntax::ExpressionRule::reloadRule(std::function<TokenSeqs(const TokenSeqs&)> filter, std::shared_ptr<const BaseRule> rule) { std::shared_ptr<const ExpressionRule> ExpressionRule::reloadRule(std::function<TokenSeqs(const TokenSeqs&)> filter, std::shared_ptr<const BaseRule> rule) {
auto ninst = makeCopy(); auto ninst = makeCopy();
ninst->child_store = rule; ninst->child_store = rule;
ninst->filter_proc = filter; ninst->filter_proc = filter;
return ninst; return ninst;
} }
QString lib_syntax::ExpressionRule::name() const { return name_store; } QString ExpressionRule::name() const { return name_store; }
int lib_syntax::ExpressionRule::typeMark() const { return this->mark_store; } int ExpressionRule::typeMark() const { return this->mark_store; }
QList<std::shared_ptr<const lib_syntax::BaseRule>> lib_syntax::ExpressionRule::children() const { QList<std::shared_ptr<const BaseRule>> ExpressionRule::children() const {
return QList<std::shared_ptr<const BaseRule>>() << this->child_store; return QList<std::shared_ptr<const BaseRule>>() << this->child_store;
} }
std::tuple<BaseRule::MatchResult, uint> lib_syntax::ExpressionRule::match(const QList<std::shared_ptr<const lib_token::Token>>& stream) const { std::tuple<BaseRule::MatchResult, uint, std::shared_ptr<const Token>> ExpressionRule::match(std::shared_ptr<const Token> list_head) const {
return child_store->match(stream); return child_store->match(list_head);
} }
std::shared_ptr<const ast_basic::Expression> lib_syntax::ExpressionRule::parse(std::shared_ptr<ParseContext> rt_inst, const QList<std::shared_ptr<const lib_token::Token>>& stream) const { std::tuple<std::shared_ptr<const Expression>, std::shared_ptr<const Token>> ExpressionRule::parse(std::shared_ptr<ParseContext> rt_inst, std::shared_ptr<const Token> head) const {
std::shared_ptr<ast_basic::Expression> elm_ast = this->newEmptyInstance(); std::shared_ptr<ast_basic::Expression> elm_ast = this->newEmptyInstance();
rt_inst->pushExpressionRule(this->shared_from_this()); rt_inst->pushExpressionRule(this->shared_from_this());
rt_inst->pushInst(elm_ast); rt_inst->pushInst(elm_ast);
child_store->parse(rt_inst, stream); auto rstg = child_store->parse(rt_inst, head);
auto tokens_decl = this->filter_proc(elm_ast->tokens()); auto tokens_decl = this->filter_proc(elm_ast->tokens());
elm_ast->tokensReset(tokens_decl); elm_ast->tokensReset(tokens_decl);
rt_inst->popExpressionRule(); rt_inst->popExpressionRule();
return rt_inst->popInst(); return std::make_tuple(rt_inst->popInst(), std::get<1>(rstg));
} }
QString lib_syntax::ExpressionRule::token_present() const { QString ExpressionRule::token_present() const {
return QString(u8"(%1)").arg(child_store->token_present()); return QString(u8"(%1)").arg(child_store->token_present());
} }

39
libSyntax/libsyntax.h
View File

@ -72,16 +72,18 @@ namespace lib_syntax {
/** /**
* @brief token流匹配 * @brief token流匹配
* @return Êײ¿ÔÆ룬ƥÅätoken¼¯ºÏ * @return 首部对齐，匹配token集合<匹配结果，匹配长度，剩余列表头指针>
*/ */
virtual std::tuple<MatchResult, uint> match(const QList<std::shared_ptr<const lib_token::Token>>& stream) const = 0; virtual std::tuple<MatchResult, uint, std::shared_ptr<const lib_token::Token>> match(std::shared_ptr<const lib_token::Token> remains_head) const = 0;
/** /**
* @brief 解析 * @brief 解析
* @param stream * @param rt_inst 解析上下文
* @return * @param head 列表头
* @return 返回结果<匹配完成新列表头,匹配长度>
*/ */
virtual std::shared_ptr<const ast_basic::Expression> parse(std::shared_ptr<ParseContext> rt_inst, const QList<std::shared_ptr<const lib_token::Token>>& stream) const = 0; virtual std::tuple<std::shared_ptr<const ast_basic::Expression>, std::shared_ptr<const lib_token::Token>>
parse(std::shared_ptr<ParseContext> rt_inst, std::shared_ptr<const lib_token::Token> head) const = 0;
/** /**
* 返回匹配语法规则的词法序列表达 * 返回匹配语法规则的词法序列表达
@ -105,8 +107,9 @@ namespace lib_syntax {
// BaseRule interface // BaseRule interface
public: public:
virtual QList<std::shared_ptr<const BaseRule>> children() const override; virtual QList<std::shared_ptr<const BaseRule>> children() const override;
virtual std::tuple<MatchResult, uint> match(const QList<std::shared_ptr<const lib_token::Token>>& stream) const override; virtual std::tuple<MatchResult, uint, std::shared_ptr<const lib_token::Token>> match(std::shared_ptr<const lib_token::Token> remains_head) const override;
virtual std::shared_ptr<const ast_basic::Expression> parse(std::shared_ptr<ParseContext> rt_inst, const QList<std::shared_ptr<const lib_token::Token>>& stream) const override; virtual std::tuple<std::shared_ptr<const ast_basic::Expression>, std::shared_ptr<const lib_token::Token>>
parse(std::shared_ptr<ParseContext> rt_inst, std::shared_ptr<const lib_token::Token> head) const override;
virtual QString token_present() const override; virtual QString token_present() const override;
}; };
@ -117,7 +120,7 @@ namespace lib_syntax {
private: private:
QList<std::shared_ptr<const BaseRule>> mbrs_store; QList<std::shared_ptr<const BaseRule>> mbrs_store;
std::tuple<MatchResult, uint, std::shared_ptr<const BaseRule>> rule_select(const QList<std::shared_ptr<const lib_token::Token>>& stream) const; std::tuple<MatchResult, uint, std::shared_ptr<const BaseRule>, std::shared_ptr<const lib_token::Token>> rule_select(std::shared_ptr<const lib_token::Token> head) const;
public: public:
Any(const QList<std::shared_ptr<const BaseRule>> mbrs); Any(const QList<std::shared_ptr<const BaseRule>> mbrs);
@ -125,8 +128,9 @@ namespace lib_syntax {
// BaseRule interface // BaseRule interface
public: public:
virtual QList<std::shared_ptr<const BaseRule>> children() const override; virtual QList<std::shared_ptr<const BaseRule>> children() const override;
virtual std::tuple<MatchResult, uint> match(const QList<std::shared_ptr<const lib_token::Token>>& stream) const override; virtual std::tuple<MatchResult, uint, std::shared_ptr<const lib_token::Token>> match(std::shared_ptr<const lib_token::Token> list_head) const override;
virtual std::shared_ptr<const ast_basic::Expression> parse(std::shared_ptr<ParseContext> rt_inst, const QList<std::shared_ptr<const lib_token::Token>>& stream) const override; virtual std::tuple<std::shared_ptr<const ast_basic::Expression>, std::shared_ptr<const lib_token::Token>>
parse(std::shared_ptr<ParseContext> rt_inst, std::shared_ptr<const lib_token::Token> head) const override;
virtual QString token_present() const override; virtual QString token_present() const override;
}; };
@ -143,8 +147,9 @@ namespace lib_syntax {
// BaseRule interface // BaseRule interface
public: public:
virtual QList<std::shared_ptr<const BaseRule>> children() const override; virtual QList<std::shared_ptr<const BaseRule>> children() const override;
virtual std::tuple<MatchResult, uint> match(const QList<std::shared_ptr<const lib_token::Token>>& stream) const override; virtual std::tuple<MatchResult, uint, std::shared_ptr<const lib_token::Token>> match(std::shared_ptr<const lib_token::Token> list_head) const override;
virtual std::shared_ptr<const ast_basic::Expression> parse(std::shared_ptr<ParseContext> rt_inst, const QList<std::shared_ptr<const lib_token::Token>>& stream) const override; virtual std::tuple<std::shared_ptr<const ast_basic::Expression>, std::shared_ptr<const lib_token::Token>>
parse(std::shared_ptr<ParseContext> rt_inst, std::shared_ptr<const lib_token::Token> head) const override;
virtual QString token_present() const override; virtual QString token_present() const override;
}; };
@ -162,8 +167,9 @@ namespace lib_syntax {
// BaseRule interface // BaseRule interface
public: public:
virtual QList<std::shared_ptr<const BaseRule>> children() const override; virtual QList<std::shared_ptr<const BaseRule>> children() const override;
virtual std::tuple<MatchResult, uint> match(const QList<std::shared_ptr<const lib_token::Token>>& stream) const override; virtual std::tuple<MatchResult, uint, std::shared_ptr<const lib_token::Token>> match(std::shared_ptr<const lib_token::Token> list_head) const override;
virtual std::shared_ptr<const ast_basic::Expression> parse(std::shared_ptr<ParseContext> rt_inst, const QList<std::shared_ptr<const lib_token::Token>>& stream) const override; virtual std::tuple<std::shared_ptr<const ast_basic::Expression>, std::shared_ptr<const lib_token::Token>>
parse(std::shared_ptr<ParseContext> rt_inst, std::shared_ptr<const lib_token::Token> head) const override;
virtual QString token_present() const override; virtual QString token_present() const override;
}; };
@ -186,8 +192,9 @@ namespace lib_syntax {
// BaseRule interface // BaseRule interface
public: public:
virtual QList<std::shared_ptr<const lib_syntax::BaseRule>> children() const override; virtual QList<std::shared_ptr<const lib_syntax::BaseRule>> children() const override;
virtual std::tuple<MatchResult, uint> match(const QList<std::shared_ptr<const lib_token::Token>>& stream) const override; virtual std::tuple<MatchResult, uint, std::shared_ptr<const lib_token::Token>> match(std::shared_ptr<const lib_token::Token> remains_head) const override;
virtual std::shared_ptr<const ast_basic::Expression> parse(std::shared_ptr<ParseContext> rt_inst, const QList<std::shared_ptr<const lib_token::Token>>& stream) const override; virtual std::tuple<std::shared_ptr<const ast_basic::Expression>, std::shared_ptr<const lib_token::Token>>
parse(std::shared_ptr<ParseContext> rt_inst, std::shared_ptr<const lib_token::Token> head) const override;
virtual QString token_present() const override; virtual QString token_present() const override;
private: private: