WsParser_VS/libSyntax/libsyntax.h

#pragma once

#include "libsyntax_global.h"
#include "libtokens.h"
#include "tokens_impl.h"
#include <memory>
#include <QtCore/QList>
#include <tuple>
#include <functional>
#include "ast_basic.h"

namespace lib_syntax {
	/**
	 * @brief <EFBFBD>﷨<EFBFBD>쳣
	 */
	class  LIBSYNTAX_EXPORT SyntaxException {
	private:
		QString msg_store;

	public:
		SyntaxException(const QString& message);
		virtual ~SyntaxException() = default;

		virtual QString message() const;
	};





	// <20><><EFBFBD><EFBFBD><EFBFBD>﷨<EFBFBD><EFB7A8><EFBFBD><EFBFBD><EFBFBD>ӿ<EFBFBD> ====================================================================================
	/**
	 * @brief <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ľӿ<EFBFBD>
	 */
	class LIBSYNTAX_EXPORT MatchCursor {
	public:
		class ErrsPack {
		public:
			void addError(const QString& msg);
			QList<QString> errors() const;
			uint64_t errorCount() const;

		private:
			QList<QString> _error_collection;
		};

		MatchCursor();
		MatchCursor(std::shared_ptr<const MatchCursor> other_ptr);
		virtual ~MatchCursor() = default;

		virtual std::shared_ptr<const MatchCursor> previous() const;

		virtual void enterExprs();
		virtual void logExprsError(const QString& msg);
		virtual void quitExprs();

		virtual bool mustStop() const;
		virtual int exprsErrorCount() const;
		virtual int totalErrorCount() const;
		virtual QList<QString> totalErrors() const;

		virtual void setCurrent(std::shared_ptr<const lib_token::IActionToken> t, std::shared_ptr<const lib_words::IPrimitiveWord> remains);
		virtual std::shared_ptr<const lib_token::IActionToken> currentToken() const;
		virtual std::shared_ptr<const lib_words::IPrimitiveWord> currentWords() const;

	private:
		std::shared_ptr<const MatchCursor> _prev_cursor = nullptr;

		QList<QString> _total_errors; // <20><><EFBFBD>н<EFBFBD><D0BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		QList<std::shared_ptr<ErrsPack>> _exprs_errors; // <20><>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		std::shared_ptr<const lib_token::IActionToken> _current_token = nullptr;			// <20><>ǰToken
		std::shared_ptr<const lib_words::IPrimitiveWord> _remains_word = nullptr;		// ʣ<><CAA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	};

	/**
	 * @brief <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>﷨ƥ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿ<EFBFBD>
	 */
	class IBasicRule {
	public:
		/**
		 * <EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƥ<EFBFBD><EFBFBD><EFBFBD>﷨<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ĵʷ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD><EFBFBD><EFBFBD>
		 *
		 * \return <EFBFBD>ʷ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		 */
		virtual QString present() const = 0;

		/**
		 * @brief <EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		 * @param rt_inst <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		 * @param head <EFBFBD>б<EFBFBD>ͷ
		 * @return <EFBFBD><EFBFBD><EFBFBD>ؽ<EFBFBD><EFBFBD><EFBFBD><ƥ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD>ͷ,ƥ<EFBFBD>䳤<EFBFBD><EFBFBD>>
		 */
		virtual QList<std::shared_ptr<const MatchCursor>> parse(std::shared_ptr<const MatchCursor> cursor) const = 0;

		/**
		 * @brief <EFBFBD>ӹ<EFBFBD><EFBFBD><EFBFBD>
		 * @return
		 */
		virtual QList<std::shared_ptr<const IBasicRule>> children() const = 0;
	};

	// <20><><EFBFBD><EFBFBD><EFBFBD>﷨ʵ<EFB7A8><CAB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD> =====================================================================================
	/**
	 * @brief <EFBFBD>﷨<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƥ<EFBFBD><EFBFBD>
	 */
	class LIBSYNTAX_EXPORT Any : public IBasicRule, public std::enable_shared_from_this<Any> {
	private:
		QList<std::shared_ptr<const IBasicRule>> mbrs_store;

	public:
		Any(const QList<std::shared_ptr<const IBasicRule>> mbrs);

		// IBasicRule interface
	public:
		virtual QList<std::shared_ptr<const IBasicRule>> children() const override;
		virtual QList<std::shared_ptr<const MatchCursor>> parse(std::shared_ptr<const MatchCursor> cursor) const override;
		virtual QString present() const override;
	};

	/**
	 * @brief <EFBFBD>﷨<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƥ<EFBFBD><EFBFBD>
	 */
	class LIBSYNTAX_EXPORT Seqs : public IBasicRule, public std::enable_shared_from_this<Seqs> {
	private:
		QList<std::shared_ptr<const IBasicRule>> mbrs_store;

	public:
		Seqs(const QList<std::shared_ptr<const IBasicRule>> mbrs);

		// IBasicRule interface
	public:
		virtual QList<std::shared_ptr<const IBasicRule>> children() const override;
		virtual QList<std::shared_ptr<const MatchCursor>> parse(std::shared_ptr<const MatchCursor> cursor) const override;
		virtual QString present() const override;
	};

	/**
	 * @brief <EFBFBD>﷨<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ظ<EFBFBD>ƥ<EFBFBD><EFBFBD>
	 */
	class LIBSYNTAX_EXPORT Rept : public IBasicRule, public std::enable_shared_from_this<Rept> {
	private:
		std::shared_ptr<const IBasicRule> rule_peer;
		int min_match, max_match;

	public:
		Rept(std::shared_ptr<const IBasicRule> rule, int min, int max);

		// IBasicRule interface
	public:
		virtual QList<std::shared_ptr<const IBasicRule>> children() const override;
		virtual QList<std::shared_ptr<const MatchCursor>> parse(std::shared_ptr<const MatchCursor> cursor) const override;
		virtual QString present() const override;
	};
	
	/**
	 * @brief <EFBFBD><EFBFBD>Ӧ<EFBFBD>﷨<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	 */
	class LIBSYNTAX_EXPORT ExprRule : public IBasicRule, public std::enable_shared_from_this<ExprRule> {
	public:
		ExprRule(const QString& rule_name, int expr_mark);

		virtual QString name() const;
		virtual int typeMark() const;
		virtual std::shared_ptr<const ExprRule> reloadRule(std::shared_ptr<const IBasicRule> rule) const;

		// IBasicRule interface
	public:
		virtual QList<std::shared_ptr<const IBasicRule>> children() const override;
		virtual QString present() const override;

	protected:
		std::shared_ptr<const IBasicRule> child_store;
		virtual std::shared_ptr<ExprRule> make_copy() const = 0;

	private:
		QString name_store;
		int mark_store;
	};



	/**
	 * @brief tokenƥ<EFBFBD><EFBFBD>
	 */
	template<typename T, lib_token::TokenProcs<T> XProc = nullptr>
	class TokenMatch : public IBasicRule, public std::enable_shared_from_this<TokenMatch<T, XProc>> {
	private:
		std::shared_ptr<const lib_token::ITokenProcess> _define_peers;

	public:
		TokenMatch(std::shared_ptr<const lib_token::ITokenProcess> define) : _define_peers(define) { }

		// IBasicRule interface
	public:
		virtual QString present() const override {
			return QString(u8"%1").arg(this->_define_peers->reviseWords());
		}
		virtual QList<std::shared_ptr<const MatchCursor>> parse(std::shared_ptr<const MatchCursor> current) const override {
			auto w_this = current->currentWords();
			auto t_this = current->currentToken();

			auto match_result = _define_peers->analysis(w_this);
			if (std::get<0>(match_result)) {
				auto chain = std::make_shared<lib_token::ActionToken<T, XProc>>(std::get<0>(match_result), t_this);
				auto remains = w_this->nextWord();
				if (std::get<1>(match_result)) {
					remains = std::make_shared<lib_words::WordImpl>(std::get<1>(match_result), remains);
				}

				auto clone_ins = std::make_shared<MatchCursor>(current);
				clone_ins->setCurrent(chain, remains);
				return QList<std::shared_ptr<const MatchCursor>>() << clone_ins;
			}
			else {
				QList<std::shared_ptr<const MatchCursor>> retvals;
				// <20><>һ<EFBFBD><D2BB>
				{
					auto short_one = std::make_shared<MatchCursor>(current);
					short_one->logExprsError(QString(u8"Syntax[0x00001]<5D>﷨ƥ<EFB7A8><C6A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȱʧ\"%1\"<row:%2,col:%3,file:%4>")
						.arg(this->_define_peers->reviseWords())
						.arg(w_this->row()).arg(w_this->column()).arg(w_this->file()));
					retvals << short_one;
				}

				// <20><>һ<EFBFBD><D2BB>
				{
					auto error_one = std::make_shared<MatchCursor>(current);
					error_one->logExprsError(QString(u8"Syntax[0x00001]<5D>﷨ƥ<EFB7A8><C6A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>\"%1\"<row:%2,col:%3,file:%4>")
						.arg(w_this->content()).arg(w_this->row()).arg(w_this->column()).arg(w_this->file()));
					auto tkins = std::make_shared<lib_token::TokenContent>(
						w_this->row(), w_this->column(), w_this->position(),
						QString(u8"<EFBFBD><EFBFBD><EFBFBD>ƴ<EFBFBD><EFBFBD><EFBFBD>_%1").arg((uint64_t)error_one.get()), w_this->file(), this->_define_peers);
					auto tkchain = std::make_shared<lib_token::ActionToken<T, XProc>>(tkins, t_this);
					error_one->setCurrent(tkchain, w_this->nextWord());
					retvals << error_one;
				}

				// <20><>һ<EFBFBD><D2BB>
				{
					auto nx_word = w_this->nextWord();
					auto nx_result = this->_define_peers->analysis(nx_word);
					if (std::get<0>(nx_result)) {
						auto chain = std::make_shared<lib_token::ActionToken<T, XProc>>(std::get<0>(nx_result), t_this);
						auto remains = nx_word->nextWord();
						if (std::get<1>(nx_result)) {
							remains = std::make_shared<lib_words::WordImpl>(std::get<1>(nx_result), remains);
						}

						auto clone_ins = std::make_shared<MatchCursor>(current);
						clone_ins->setCurrent(chain, remains);
						retvals << clone_ins;
					}
				}

				return retvals;
			}
		}
		virtual QList<std::shared_ptr<const IBasicRule>> children() const override {
			return QList<std::shared_ptr<const IBasicRule>>();
		}
	};

	/**
	 * <EFBFBD>﷨Ԫ<EFBFBD>ؽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
	 */
	template<class ExprType> class ElementRule : public ExprRule {
	public:
		ElementRule(const QString& rule_name, int expr_mark)
			:ExprRule(rule_name, expr_mark) { }

		virtual QList<std::shared_ptr<const MatchCursor>> parse(std::shared_ptr<const MatchCursor> cursor) const override {
			if (cursor->mustStop())
				return QList<std::shared_ptr<const MatchCursor>>() << cursor;

			auto t_this = cursor->currentToken();
			auto w_this = cursor->currentWords();
			auto split_begin = std::make_shared<lib_token::ExprBeginToken<ExprType>>(shared_from_this(), t_this);

			auto ncursor = std::make_shared<MatchCursor>(cursor);
			ncursor->setCurrent(split_begin, w_this);
			ncursor->enterExprs();

			auto nbranch = this->child_store->parse(ncursor);
			decltype(nbranch) branch_procs;
			std::for_each(nbranch.begin(), nbranch.end(), [&](std::shared_ptr<const MatchCursor> curs) {
				if (curs->mustStop()) {
					branch_procs.append(curs);
				}
				else {
					auto t_end = curs->currentToken();
					auto w_end = curs->currentWords();

					auto ecursor = std::make_shared<MatchCursor>(curs);
					ecursor->quitExprs();

					auto split_end = std::make_shared<lib_token::ExprEndToken<ExprType>>(split_begin, t_end);
					ecursor->setCurrent(split_end, w_end);
					branch_procs.append(ecursor);
				}
			});

			return branch_procs;
		}
	
	protected:
		virtual std::shared_ptr<ExprRule> make_copy() const {
			return std::make_shared<ElementRule<ExprType>>(this->name(), this->typeMark());
		}
	};
} // namespace lib_syntax