slash-version

libSyntax/libsyntax.cpp

@@ -41,11 +41,15 @@ ParseResult TokenMatch::parse(shared_ptr<IContext> rt_inst, shared_ptr<const IWo
 		case lib_syntax::ErrDeals::Replace:
 			fx_type = ErrDeals::None;
 			result_ret.result_repair = make_tuple(MatchResult::Success, head->nextWord());
+			rt_inst->appendParseError(rt_inst->currentFile(), head->position(), QString(u8"指定Token<row:%3,col:%4>“%1”匹配错误，应为“%2”。")
+				.arg(head->content()).arg(this->define_peer->reviseWords()).arg(head->row()).arg(head->column()));
 			break;
 
 		case lib_syntax::ErrDeals::Absence:
 			fx_type = ErrDeals::None;
 			result_ret.result_repair = make_tuple(MatchResult::Success, head);
+			rt_inst->appendParseError(rt_inst->currentFile(), head->position(), QString(u8"指定位置缺失Token<row:%2,col:%3>，应为“%1”。")
+				.arg(this->define_peer->reviseWords()).arg(head->row()).arg(head->column()));
 			break;
 
 		case lib_syntax::ErrDeals::Surplus:
@@ -54,6 +58,9 @@ ParseResult TokenMatch::parse(shared_ptr<IContext> rt_inst, shared_ptr<const IWo
 				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"发现冗余Token<row:%2,col:%3>，内容为“%1”。")
+						.arg(head->content()).arg(head->row()).arg(head->column()));
+
 					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()));
@@ -84,27 +91,35 @@ Rept::Rept(shared_ptr<const IBasicRule> rule, int min, int max) : rule_peer(rule
 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;
+	ParseResult fnl_result;
 
-	bool straight_mark = fx_type == ErrDeals::None;
 	auto temp_head = head;
+	auto initial_fxtype = ErrDeals::None;
+
+retry_entry:
+	switch (initial_fxtype) {
+	case lib_syntax::ErrDeals::Surplus:
+	case lib_syntax::ErrDeals::Absence:
+	case lib_syntax::ErrDeals::Replace:
+
+
+		break;
+	case lib_syntax::ErrDeals::None:
 		// min-match
 		for (auto idx = 0; idx < min_match; ++idx) {
-		auto result_gen = rule_peer->parse(rt_inst, temp_head, fx_type);
+			auto result_genx = rule_peer->parse(rt_inst, temp_head, initial_fxtype);
-		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)) {
+			switch (std::get<0>(result_genx.result_straight)) {
 			case MatchResult::Part:
-			if (straight_mark)
+				if(fx_type == ErrDeals::None)
-				result_final.result_straight = make_tuple(MatchResult::Part, std::get<1>(v_result));
+					return result_genx;
-			else
+
-				result_final.result_repair = make_tuple(MatchResult::Part, std::get<1>(v_result));
+				initial_fxtype = fx_type;
-			return result_final;
+				temp_head = head;
+				goto retry_entry;
 
 			default:
-			temp_head = std::get<1>(v_result);
+				temp_head = std::get<1>(result_genx.result_straight);
 				break;
 			}
 		}
@@ -114,18 +129,19 @@ ParseResult Rept::parse(shared_ptr<IContext> rt_inst, shared_ptr<const IWordBase
 			if (!temp_head)
 				break;
 
-		auto result_gen = rule_peer->parse(rt_inst, temp_head, fx_type);
+			auto result_genx = rule_peer->parse(rt_inst, temp_head, initial_fxtype);
-		auto v_result = result_gen.result_straight;
+			auto v_result = result_genx.result_straight;
-		if (std::get<0>(v_result) == MatchResult::None)
+			if (std::get<0>(v_result) == MatchResult::None) {
-			v_result = result_gen.result_repair;
+				v_result = result_genx.result_repair;
+			}
 
 			switch (get<0>(v_result)) {
 			case MatchResult::Part:
-			if(straight_mark)
+				if (straight_flags)
-				result_final.result_straight = make_tuple(MatchResult::Success, temp_head);
+					fnl_result.result_straight = v_result;
 				else
-				result_final.result_repair = make_tuple(MatchResult::Success, temp_head);
+					fnl_result.result_repair = v_result;
-			return result_final;
+				return fnl_result;
 
 			default:
 				temp_head = get<1>(v_result);
@@ -133,11 +149,19 @@ ParseResult Rept::parse(shared_ptr<IContext> rt_inst, shared_ptr<const IWordBase
 			}
 		}
 
-	if(straight_mark)
+		break;
-		result_final.result_straight = make_tuple(MatchResult::Success, temp_head);
+	default:
+		break;
+	}
+
+
+	if(straight_flags)
+		fnl_result.result_straight = make_tuple(MatchResult::Success, temp_head);
 	else 
-		result_final.result_repair = make_tuple(MatchResult::Success, temp_head);
+		fnl_result.result_repair = make_tuple(MatchResult::Success, temp_head);
-	return result_final;
+
+	fx_type = initial_fxtype;
+	return fnl_result;
 }
 
 QString Rept::token_present() const
@@ -201,21 +225,26 @@ 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;
+	std::tuple<std::shared_ptr<const IBasicRule>, uint64_t> temp_result = std::make_tuple(nullptr, 0);
-	bool straight_mark = fx_type == ErrDeals::None;
+	bool straight_mark = fx_type ==
 
 		switch (fx_type) {
 		case ErrDeals::None: {
+			ParseResult result_final;
 			for (auto& fork : mbrs_store) {
-			auto gen = fork->parse(rt_inst, head, fx_type);
+				auto xgen = fork->parse(rt_inst, head, fx_type);
 
-			switch (get<0>(gen.result_straight)) {
+				auto v_result = xgen.result_straight;
+				if (std::get<0>(v_result) == MatchResult::None)
+					v_result = xgen.result_repair;
+
+				switch (get<0>(v_result)) {
 					// 遇到成功的直接返回解析结果
 				case MatchResult::Success:
 					return gen;
 
 				case MatchResult::Part: {
-				auto span = get<1>(gen)->position() - head->position();
+					auto span = get<1>(gen.result_straight)->position() - head->position();
 					if (span >= get<1>(temp_result))
 						temp_result = make_tuple(fork, span);
 				}
@@ -223,16 +252,58 @@ ParseResult Any::parse(shared_ptr<IContext> rt_inst, shared_ptr<const IWordBase>
 					break;
 				}
 			}
-		// ·ÖÎö×îÆ¥ÅäµÄ·ÖÖ§
+
-		rt_inst->clearErrors(rt_inst->currentFile(), head->position());
+			for (auto& itfx : QList<ErrDeals>{ ErrDeals::Surplus, ErrDeals::Absence, ErrDeals::Replace }) {
-		auto temp = get<0>(temp_result)->parse(rt_inst, head, fx_type);
+				auto fix_current = itfx;
-		return make_tuple(MatchResult::Part, get<1>(temp));
+				auto repair_result = this->parse(rt_inst, head, fix_current);
-	}
+
+				auto v_result = repair_result.result_straight;
+				if (std::get<0>(v_result) == MatchResult::None)
+					v_result = repair_result.result_repair;
+
+				switch (std::get<0>(v_result)) {
+				case MatchResult::Success:
+
 
 				default:
 					break;
 				}
+			}
 
+		}break;
+
+		default: {
+			ParseResult inst;
+
+			for (auto& fork : mbrs_store) {
+				auto fx_init = fx_type;
+
+				auto gen = fork->parse(rt_inst, head, fx_init);
+				auto v_result = gen.result_straight;
+				if (std::get<0>(v_result) == MatchResult::None)
+					v_result = gen.result_repair;
+
+				switch (std::get<0>(v_result)) {
+				case MatchResult::Success:
+					inst.result_repair = v_result;
+					fx_type = fx_init;
+					return inst;
+
+				default: {
+					auto span = std::get<1>(v_result)->position() - head->position();
+					if (span >= std::get<1>(temp_result))
+						temp_result = std::make_tuple(fork, span);
+				}break;
+				}
+			}
+
+		}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));
 }
 
 QString Any::token_present() const