313 lines
8.7 KiB
C++
313 lines
8.7 KiB
C++
#include "libsyntax.h"
|
|
#include "ast_basic.h"
|
|
#include <QDebug>
|
|
|
|
using namespace lib_syntax;
|
|
using namespace std;
|
|
using namespace lib_token;
|
|
using namespace ast_basic;
|
|
|
|
TokenMatch::TokenMatch(shared_ptr<const ITokenDefine> define) : define_peer(define) {}
|
|
|
|
QList<shared_ptr<const IBasicRule>> TokenMatch::children() const { return QList<shared_ptr<const IBasicRule>>(); }
|
|
|
|
ParseResult TokenMatch::parse(shared_ptr<IContext> rt_inst, shared_ptr<const IWordBase> head, ErrDeals& fx_type) const
|
|
{
|
|
if (!head) {
|
|
rt_inst->appendParseError(rt_inst->currentFile(), -1, QString(u8"Syntax[0x0000]tokenÁ÷£¨%1£©ÌáÇ°ÖÕÖ¹").arg(rt_inst->currentFile()));
|
|
return ParseResult();
|
|
}
|
|
|
|
ParseResult result_ret;
|
|
auto match_result = define_peer->analysis(head);
|
|
if (get<0>(match_result)) {
|
|
rt_inst->currentExprInst()->addToken(get<0>(match_result));
|
|
|
|
decltype(result_ret.result_repair) v_result;
|
|
if (get<1>(match_result)) {
|
|
v_result = make_tuple(MatchResult::Success, make_shared<WordImpl>(get<1>(match_result), head->nextWord()));
|
|
}
|
|
else {
|
|
v_result = make_tuple(MatchResult::Success, head->nextWord());
|
|
}
|
|
|
|
if (fx_type == ErrDeals::None)
|
|
result_ret.result_straight = v_result;
|
|
else
|
|
result_ret.result_repair = v_result;
|
|
}
|
|
else {
|
|
switch (fx_type) {
|
|
case lib_syntax::ErrDeals::Replace:
|
|
fx_type = ErrDeals::None;
|
|
result_ret.result_repair = make_tuple(MatchResult::Success, head->nextWord());
|
|
break;
|
|
|
|
case lib_syntax::ErrDeals::Absence:
|
|
fx_type = ErrDeals::None;
|
|
result_ret.result_repair = make_tuple(MatchResult::Success, head);
|
|
break;
|
|
|
|
case lib_syntax::ErrDeals::Surplus:
|
|
fx_type = ErrDeals::None;
|
|
{
|
|
auto temp_head = head->nextWord();
|
|
auto match_result = define_peer->analysis(temp_head);
|
|
if (get<0>(match_result)) {
|
|
rt_inst->currentExprInst()->addToken(get<0>(match_result));
|
|
if (get<1>(match_result))
|
|
result_ret.result_repair = make_tuple(MatchResult::Success, make_shared<WordImpl>(get<1>(match_result), temp_head->nextWord()));
|
|
else
|
|
result_ret.result_repair = make_tuple(MatchResult::Success, temp_head->nextWord());
|
|
}
|
|
else {
|
|
result_ret.result_repair = make_tuple(MatchResult::Part, head);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
result_ret.result_straight = make_tuple(MatchResult::Part, head);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result_ret;
|
|
}
|
|
|
|
QString TokenMatch::token_present() const {
|
|
return QString(u8"%1 ").arg(this->define_peer->reviseWords());
|
|
}
|
|
|
|
Rept::Rept(shared_ptr<const IBasicRule> rule, int min, int max) : rule_peer(rule), min_match(min), max_match(max) {}
|
|
|
|
QList<shared_ptr<const IBasicRule>> Rept::children() const { return QList<shared_ptr<const IBasicRule>>() << rule_peer; }
|
|
|
|
ParseResult Rept::parse(shared_ptr<IContext> rt_inst, shared_ptr<const IWordBase> head, ErrDeals& fx_type) const {
|
|
ParseResult result_final;
|
|
|
|
bool straight_mark = fx_type == ErrDeals::None;
|
|
auto temp_head = head;
|
|
// min-match
|
|
for (auto idx = 0; idx < min_match; ++idx) {
|
|
auto result_gen = rule_peer->parse(rt_inst, temp_head, fx_type);
|
|
auto v_result = result_gen.result_straight;
|
|
if (std::get<0>(v_result) == MatchResult::None)
|
|
v_result = result_gen.result_repair;
|
|
|
|
switch (std::get<0>(v_result)) {
|
|
case MatchResult::Part:
|
|
if (straight_mark)
|
|
result_final.result_straight = make_tuple(MatchResult::Part, std::get<1>(v_result));
|
|
else
|
|
result_final.result_repair = make_tuple(MatchResult::Part, std::get<1>(v_result));
|
|
return result_final;
|
|
|
|
default:
|
|
temp_head = std::get<1>(v_result);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// max-match
|
|
for (auto idx = min_match; idx < max_match; ++idx) {
|
|
if (!temp_head)
|
|
break;
|
|
|
|
auto result_gen = rule_peer->parse(rt_inst, temp_head, fx_type);
|
|
auto v_result = result_gen.result_straight;
|
|
if (std::get<0>(v_result) == MatchResult::None)
|
|
v_result = result_gen.result_repair;
|
|
|
|
switch (get<0>(v_result)) {
|
|
case MatchResult::Part:
|
|
if(straight_mark)
|
|
result_final.result_straight = make_tuple(MatchResult::Success, temp_head);
|
|
else
|
|
result_final.result_repair = make_tuple(MatchResult::Success, temp_head);
|
|
return result_final;
|
|
|
|
default:
|
|
temp_head = get<1>(v_result);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(straight_mark)
|
|
result_final.result_straight = make_tuple(MatchResult::Success, temp_head);
|
|
else
|
|
result_final.result_repair = make_tuple(MatchResult::Success, temp_head);
|
|
return result_final;
|
|
}
|
|
|
|
QString Rept::token_present() const
|
|
{
|
|
return u8"(" + this->rule_peer->token_present() + QString(u8"){%1, %2}").arg(min_match).arg(max_match);
|
|
}
|
|
|
|
Seqs::Seqs(const QList<shared_ptr<const IBasicRule>> mbrs) : mbrs_store(mbrs) {}
|
|
|
|
QList<shared_ptr<const IBasicRule>> Seqs::children() const { return mbrs_store; }
|
|
|
|
ParseResult Seqs::parse(shared_ptr<IContext> rt_inst, shared_ptr<const IWordBase> head, ErrDeals& fx_type) const {
|
|
ParseResult result_final;
|
|
|
|
auto temp_head = head;
|
|
bool straight_mark = fx_type == ErrDeals::None;
|
|
for (auto& r : mbrs_store) {
|
|
auto rule_present = r->token_present();
|
|
auto rst_gene = r->parse(rt_inst, temp_head, fx_type);
|
|
|
|
auto v_result = rst_gene.result_straight;
|
|
if(std::get<0>(v_result) == MatchResult::None)
|
|
v_result = rst_gene.result_repair;
|
|
|
|
switch (get<0>(v_result)) {
|
|
case MatchResult::Part:
|
|
if(straight_mark)
|
|
result_final.result_straight = v_result;
|
|
else
|
|
result_final.result_repair = v_result;
|
|
return result_final;
|
|
|
|
case MatchResult::Success:
|
|
temp_head = get<1>(v_result);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (straight_mark)
|
|
result_final.result_straight = make_tuple(MatchResult::Success, temp_head);
|
|
else
|
|
result_final.result_repair = make_tuple(MatchResult::Success, temp_head);
|
|
return result_final;
|
|
}
|
|
|
|
QString Seqs::token_present() const
|
|
{
|
|
QString content;
|
|
for (auto& it : children())
|
|
content += it->token_present();
|
|
return content;
|
|
}
|
|
|
|
//tuple<MatchResult, uint, shared_ptr<const IBasicRule>, shared_ptr<const Token>>
|
|
Any::Any(const QList<shared_ptr<const IBasicRule>> mbrs) : mbrs_store(mbrs) {}
|
|
|
|
QList<shared_ptr<const IBasicRule>> Any::children() const { return mbrs_store; }
|
|
|
|
ParseResult Any::parse(shared_ptr<IContext> rt_inst, shared_ptr<const IWordBase> head, ErrDeals& fx_type) const {
|
|
auto rule_present = this->token_present();
|
|
|
|
ParseResult result_final;
|
|
bool straight_mark = fx_type == ErrDeals::None;
|
|
|
|
switch (fx_type) {
|
|
case ErrDeals::None: {
|
|
for (auto& fork : mbrs_store) {
|
|
auto gen = fork->parse(rt_inst, head, fx_type);
|
|
|
|
switch (get<0>(gen.result_straight)) {
|
|
// Óöµ½³É¹¦µÄÖ±½Ó·µ»Ø½âÎö½á¹û
|
|
case MatchResult::Success:
|
|
return gen;
|
|
|
|
case MatchResult::Part: {
|
|
auto span = get<1>(gen)->position() - head->position();
|
|
if (span >= get<1>(temp_result))
|
|
temp_result = make_tuple(fork, span);
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
// ·ÖÎö×îÆ¥ÅäµÄ·ÖÖ§
|
|
rt_inst->clearErrors(rt_inst->currentFile(), head->position());
|
|
auto temp = get<0>(temp_result)->parse(rt_inst, head, fx_type);
|
|
return make_tuple(MatchResult::Part, get<1>(temp));
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
QString Any::token_present() const
|
|
{
|
|
QString members_content;
|
|
for (auto& it : children()) {
|
|
members_content += it->token_present() + u8"|";
|
|
}
|
|
return members_content.mid(0, members_content.size() - 1);
|
|
}
|
|
|
|
|
|
SyntaxException::SyntaxException(const QString& message) { this->msg_store = message; }
|
|
|
|
QString SyntaxException::message() const { return msg_store; }
|
|
|
|
ExprRule::ExprRule(const QString& rule_name, int expr_mark) : name_store(rule_name) {
|
|
this->mark_store = expr_mark;
|
|
}
|
|
|
|
shared_ptr<const ExprRule> ExprRule::reloadRule(shared_ptr<const IBasicRule> rule) {
|
|
auto ninst = makeCopy();
|
|
ninst->child_store = rule;
|
|
return ninst;
|
|
}
|
|
|
|
QString ExprRule::name() const { return name_store; }
|
|
|
|
int ExprRule::typeMark() const { return this->mark_store; }
|
|
|
|
QList<shared_ptr<const IBasicRule>> ExprRule::children() const {
|
|
return QList<shared_ptr<const IBasicRule>>() << this->child_store;
|
|
}
|
|
|
|
#include <ast_novel.h>
|
|
tuple<MatchResult, shared_ptr<const IWordBase>>
|
|
ExprRule::parse(shared_ptr<IContext> rt_inst, shared_ptr<const IWordBase> head, ErrDeals& fx_type) const {
|
|
auto text_present = this->token_present();
|
|
shared_ptr<IExprInst> elm_ast = this->newEmptyInstance();
|
|
|
|
rt_inst->pushExprRule(this->shared_from_this());
|
|
rt_inst->pushExprInst(elm_ast);
|
|
|
|
auto ret_tuple = child_store->parse(rt_inst, head, fx_type);
|
|
switch (get<0>(ret_tuple)) {
|
|
case MatchResult::Success:
|
|
if (!dynamic_pointer_cast<example_novel::Document>(elm_ast) && fx_type == ErrDeals::None) {
|
|
rt_inst->clearErrors(rt_inst->currentFile(), head->position());
|
|
}
|
|
|
|
rt_inst->popExprInst();
|
|
rt_inst->popExprRule();
|
|
|
|
if (rt_inst->currentExprInst()) {
|
|
rt_inst->currentExprInst()->addChild(elm_ast);
|
|
}
|
|
else {
|
|
rt_inst->appendDocInst(elm_ast);
|
|
}
|
|
break;
|
|
|
|
case MatchResult::Part:
|
|
case MatchResult::Fail:
|
|
rt_inst->popExprInst();
|
|
rt_inst->popExprRule();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret_tuple;
|
|
}
|
|
|
|
QString ExprRule::token_present() const {
|
|
return child_store->token_present();
|
|
}
|