WsParser_VS/libSyntax/libsyntax.cpp

#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<65><6E><EFBFBD><EFBFBD>%1<><31><EFBFBD><EFBFBD>ǰ<EFBFBD><C7B0>ֹ").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)) {
				// <20><><EFBFBD><EFBFBD><EFBFBD>ɹ<EFBFBD><C9B9><EFBFBD>ֱ<EFBFBD>ӷ<EFBFBD><D3B7>ؽ<EFBFBD><D8BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
			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;
			}
		}
		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƥ<EFBFBD><C6A5><EFBFBD>ķ<EFBFBD>֧
		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();
}