337 lines
12 KiB
C++
337 lines
12 KiB
C++
#include "syntax_novel.h"
|
||
#include <tokens_novel.h>
|
||
#include "ast_novel.h"
|
||
|
||
using namespace lib_syntax;
|
||
using namespace example_novel;
|
||
using namespace lib_token;
|
||
using namespace ast_basic;
|
||
|
||
// token-avaliable ==========================================================================
|
||
auto leftb = std::make_shared<LBracket>(); // {
|
||
auto rightb = std::make_shared<RBracket>(); // }
|
||
auto refers = std::make_shared<ReferMk>(); // @
|
||
auto declare = std::make_shared<DeclareSymbo>(); // #
|
||
auto split_mark = std::make_shared<SplitMk>(); // &
|
||
|
||
auto rank_key = std::make_shared<RankWord>(); // 排序
|
||
auto story_key = std::make_shared<StoryWord>(); // 故事
|
||
auto numbers = std::make_shared<Numbers>(); // [0-9]+
|
||
auto slice_key = std::make_shared<SliceWord>(); // 剧情
|
||
auto point_key = std::make_shared<PointWord>(); // 节点
|
||
auto volume_key = std::make_shared<VolumeWord>(); // 分卷
|
||
auto article_key = std::make_shared<ArticleWord>(); // 章节
|
||
auto vtext = std::make_shared<NormalText>(); // ^([^\\{\\}@&]+)
|
||
auto name_text = std::make_shared<NameSection>(); // ^([^\\{\\}@&]+)
|
||
|
||
|
||
|
||
// rule-parts ===============================================================================
|
||
template<typename ExprT>
|
||
void apntk(std::shared_ptr<ExprT> expr, std::shared_ptr<const lib_token::IToken> t) {
|
||
expr->addToken(t);
|
||
}
|
||
|
||
// MakeRule
|
||
#define MK(type) std::make_shared<const type>()
|
||
// MatchRule
|
||
#define MER(E, XProc, t) std::make_shared<const TokenMatch<E, XProc>>(t)
|
||
#define MR(E, t) MER(E, apntk<E>, t)
|
||
// Buffer
|
||
#define Rules QList<std::shared_ptr<const IBasicRule>>
|
||
// Option
|
||
#define OptMulT(token) std::make_shared<const Rept>(MR(token), 0, INT_MAX)
|
||
#define OptMulR(rule) std::make_shared<const Rept>(rule, 0, INT_MAX)
|
||
// multi+
|
||
#define MultiR(rule) std::make_shared<const Rept>(rule, 1, INT_MAX)
|
||
// opt?
|
||
#define OptR(rule) std::make_shared<const Rept>(rule, 0, 1)
|
||
|
||
|
||
|
||
class DeclExpr : public ElementRule<TextSection, (int) NovelNode::TextSection> {
|
||
public:
|
||
DeclExpr() : ElementRule<TextSection, (int) NovelNode::TextSection>(
|
||
"decl_section",
|
||
MultiR(std::make_shared<const Any>(Rules{
|
||
MR(TextSection, numbers), MR(TextSection, vtext), MR(TextSection, refers), MR(TextSection, split_mark)
|
||
}))) { }
|
||
|
||
// 通过 ElementRule 继承
|
||
QList<std::shared_ptr<const MatchCursor>> expr_rule_parse(std::shared_ptr<const MatchCursor> cursor) const override {
|
||
return _children_store->parse(cursor);
|
||
}
|
||
};
|
||
|
||
|
||
|
||
void point_nmset(std::shared_ptr<PointDefines> inst, std::shared_ptr<const lib_token::IToken> token) {
|
||
inst->addToken(token);
|
||
inst->setName(token->content());
|
||
}
|
||
class PointSyntax : public ElementRule<PointDefines, (int) NovelNode::PointDefines> {
|
||
public:
|
||
PointSyntax() : ElementRule<PointDefines, (int) NovelNode::PointDefines>(
|
||
"point_define", std::make_shared<const Seqs>(Rules{
|
||
MR(PointDefines, leftb), MR(PointDefines, point_key), MER(PointDefines, point_nmset, name_text) } <<
|
||
OptR(MK(DeclExpr)) <<
|
||
MR(PointDefines, rightb)
|
||
)) { }
|
||
|
||
// 通过 ElementRule 继承
|
||
QList<std::shared_ptr<const MatchCursor>> expr_rule_parse(std::shared_ptr<const MatchCursor> cursor) const override {
|
||
return _children_store->parse(cursor);
|
||
}
|
||
};
|
||
|
||
|
||
|
||
void point_ref_story_set(std::shared_ptr<PointRefers> inst, std::shared_ptr<const lib_token::IToken> token) {
|
||
inst->addToken(token);
|
||
inst->setStoryRefer(token->content());
|
||
}
|
||
void point_ref_slice_set(std::shared_ptr<PointRefers> inst, std::shared_ptr<const lib_token::IToken> token) {
|
||
inst->addToken(token);
|
||
inst->setSliceRefer(token->content());
|
||
}
|
||
void point_ref_point_set(std::shared_ptr<PointRefers> inst, std::shared_ptr<const lib_token::IToken> token) {
|
||
inst->addToken(token);
|
||
inst->setPointRefer(token->content());
|
||
}
|
||
class ReferSyntax : public ElementRule<PointRefers, (int) NovelNode::PointRefers> {
|
||
public:
|
||
ReferSyntax() : ElementRule < PointRefers, (int) NovelNode::PointRefers>(
|
||
"point_refer", std::make_shared<const Seqs>(Rules{
|
||
MR(PointRefers, leftb), MR(PointRefers, refers), MR(PointRefers, point_key),
|
||
MER(PointRefers, point_ref_story_set, name_text),
|
||
MR(PointRefers, split_mark),
|
||
MER(PointRefers, point_ref_slice_set, name_text),
|
||
MR(PointRefers, split_mark),
|
||
MER(PointRefers, point_ref_point_set, name_text) } <<
|
||
OptR(MK(DeclExpr)) <<
|
||
MR(PointRefers, rightb))) { }
|
||
|
||
// 通过 ElementRule 继承
|
||
QList<std::shared_ptr<const MatchCursor>> expr_rule_parse(std::shared_ptr<const MatchCursor> cursor) const override {
|
||
return _children_store->parse(cursor);
|
||
}
|
||
};
|
||
|
||
|
||
|
||
void slice_nm_set(std::shared_ptr<FragmentSlice> inst, std::shared_ptr<const lib_token::IToken> token) {
|
||
inst->addToken(token);
|
||
inst->setName(token->content());
|
||
}
|
||
class SliceSyntax : public ElementRule<FragmentSlice, (int) NovelNode::FragmentSlice> {
|
||
public:
|
||
SliceSyntax() : ElementRule<FragmentSlice, (int) NovelNode::FragmentSlice>(
|
||
"slice_define", std::make_shared<const Seqs>(Rules{
|
||
MR(FragmentSlice, leftb), MR(FragmentSlice, slice_key), MER(FragmentSlice, slice_nm_set, name_text) } <<
|
||
OptMulR(std::make_shared<const Any>(Rules{ MK(PointSyntax), MK(ReferSyntax), MK(DeclExpr) })) <<
|
||
MR(FragmentSlice, rightb))) { }
|
||
|
||
// 通过 ElementRule 继承
|
||
QList<std::shared_ptr<const MatchCursor>> expr_rule_parse(std::shared_ptr<const MatchCursor> cursor) const override {
|
||
return _children_store->parse(cursor);
|
||
}
|
||
};
|
||
|
||
|
||
|
||
void story_nmset(std::shared_ptr<StoryDefine> inst, std::shared_ptr<const lib_token::IToken> token) {
|
||
inst->addToken(token);
|
||
inst->setName(token->content());
|
||
}
|
||
class StorySyntax : public ElementRule<StoryDefine, (int) NovelNode::StoryDefine> {
|
||
public:
|
||
StorySyntax() : ElementRule<StoryDefine, (int) NovelNode::StoryDefine>(
|
||
"story_define",
|
||
std::make_shared<const Seqs>(Rules{
|
||
MR(StoryDefine, leftb), MR(StoryDefine, story_key), MER(StoryDefine, story_nmset, name_text) } <<
|
||
OptMulR(std::make_shared<const Any>(Rules{ MK(SliceSyntax), MK(DeclExpr) })) <<
|
||
MR(StoryDefine, rightb)
|
||
)) { }
|
||
|
||
// 通过 ElementRule 继承
|
||
QList<std::shared_ptr<const MatchCursor>> expr_rule_parse(std::shared_ptr<const MatchCursor> cursor) const override {
|
||
return _children_store->parse(cursor);
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
void article_nset(std::shared_ptr<ArticleDefine>inst, std::shared_ptr<const lib_token::IToken> token) {
|
||
inst->addToken(token);
|
||
inst->setName(token->content());
|
||
}
|
||
class ArticleSyntax : public ElementRule<ArticleDefine, (int) NovelNode::ArticleDefine> {
|
||
public:
|
||
ArticleSyntax() : ElementRule<ArticleDefine, (int) NovelNode::ArticleDefine>(
|
||
"article_define", std::make_shared<const Seqs>(Rules{
|
||
MR(ArticleDefine, leftb), MR(ArticleDefine, article_key), MER(ArticleDefine, article_nset, name_text) } <<
|
||
OptMulR(std::make_shared<const Any>(Rules{ MK(ReferSyntax), MK(DeclExpr) })) <<
|
||
MR(ArticleDefine, rightb)
|
||
)) { }
|
||
|
||
// 通过 ElementRule 继承
|
||
QList<std::shared_ptr<const MatchCursor>> expr_rule_parse(std::shared_ptr<const MatchCursor> cursor) const override {
|
||
return _children_store->parse(cursor);
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
void volume_nset(std::shared_ptr<VolumeDefine> inst, std::shared_ptr<const lib_token::IToken> token) {
|
||
inst->addToken(token);
|
||
inst->setName(token->content());
|
||
}
|
||
class VolumeSyntax : public ElementRule<VolumeDefine, (int) NovelNode::VolumeDefine> {
|
||
public:
|
||
VolumeSyntax() : ElementRule<VolumeDefine, (int) NovelNode::VolumeDefine>(
|
||
"volume_define", std::make_shared<const Seqs>(Rules{
|
||
MR(VolumeDefine, leftb), MR(VolumeDefine, volume_key), MER(VolumeDefine, volume_nset, name_text) } <<
|
||
OptMulR(std::make_shared<const Any>(Rules{ MK(DeclExpr), MK(ArticleSyntax) })) <<
|
||
MR(VolumeDefine, rightb)
|
||
)) { }
|
||
|
||
// 通过 ElementRule 继承
|
||
QList<std::shared_ptr<const MatchCursor>> expr_rule_parse(std::shared_ptr<const MatchCursor> cursor) const override {
|
||
return _children_store->parse(cursor);
|
||
}
|
||
};
|
||
|
||
|
||
|
||
|
||
void rank_set(std::shared_ptr<RankDeclare> inst, std::shared_ptr<const lib_token::IToken> token) {
|
||
inst->addToken(token);
|
||
inst->setRank(token->content().toInt());
|
||
}
|
||
class RankSyntax : public ElementRule<RankDeclare, (int) NovelNode::RankDeclaration> {
|
||
public:
|
||
RankSyntax() : ElementRule<RankDeclare, (int) NovelNode::RankDeclaration>(
|
||
"rank_define", std::make_shared<const Seqs>(Rules{
|
||
MR(RankDeclare, declare), MR(RankDeclare, rank_key), MER(RankDeclare, rank_set, numbers) }
|
||
)) { }
|
||
|
||
// 通过 ElementRule 继承
|
||
QList<std::shared_ptr<const MatchCursor>> expr_rule_parse(std::shared_ptr<const MatchCursor> cursor) const override {
|
||
return _children_store->parse(cursor);
|
||
}
|
||
};
|
||
|
||
|
||
|
||
class DocumentSyntax : public ElementRule<Document, (int) NovelNode::Document> {
|
||
public:
|
||
DocumentSyntax() : ElementRule<Document, (int) NovelNode::Document>(
|
||
"decls-doc", std::make_shared<const Seqs>(Rules{
|
||
OptR(MK(RankSyntax)), MultiR(std::make_shared<const Any>(Rules{ MK(StorySyntax), MK(VolumeSyntax) }))
|
||
})) { }
|
||
|
||
// 通过 ElementRule 继承
|
||
QList<std::shared_ptr<const MatchCursor>> expr_rule_parse(std::shared_ptr<const MatchCursor> cursor) const override {
|
||
return _children_store->parse(cursor);
|
||
}
|
||
};
|
||
|
||
class MM : public lib_syntax::IBasicRule {
|
||
// 通过 IBasicRule 继承
|
||
QList<std::shared_ptr<const IBasicRule>> children() const override {
|
||
return QList<std::shared_ptr<const IBasicRule>>();
|
||
}
|
||
QString present() const override {
|
||
return QString();
|
||
}
|
||
QList<std::shared_ptr<const MatchCursor>> parse(std::shared_ptr<const MatchCursor> cursor) const override {
|
||
return QList<std::shared_ptr<const MatchCursor>>();
|
||
}
|
||
};
|
||
|
||
#include "syntax_templets.h"
|
||
std::shared_ptr<const ExprRule> NovalSyntax::getSyntaxTree() {
|
||
lib_composit::TypeList<MM, MM> vv;
|
||
|
||
return std::make_shared<DocumentSyntax>();
|
||
}
|
||
|
||
//std::shared_ptr<const ast_gen::SyntaxElement> NovalSyntax::tidy(std::shared_ptr<ast_gen::SyntaxElement> root, QList<std::shared_ptr<ast_gen::SyntaxElement>> children)
|
||
//{
|
||
// build_objecttree(root, children);
|
||
// node_register(root, children);
|
||
// return root;
|
||
//}
|
||
//void NovalSyntax::build_objecttree(std::shared_ptr<ast_gen::SyntaxElement> root, QList<std::shared_ptr<ast_gen::SyntaxElement>> children)
|
||
//{
|
||
// for (auto& cinst : children) {
|
||
// cinst->setParent(root);
|
||
//
|
||
// QList<std::shared_ptr<ast_gen::SyntaxElement>> child_items;
|
||
// for (auto& it : cinst->bindExpression()->children()) {
|
||
// auto const_it = std::dynamic_pointer_cast<const ast_gen::SyntaxElement>(it);
|
||
// child_items.append(std::const_pointer_cast<ast_gen::SyntaxElement>(const_it));
|
||
// }
|
||
//
|
||
// build_objecttree(cinst, child_items);
|
||
// }
|
||
//}
|
||
//void NovalSyntax::node_register(std::shared_ptr<const ast_gen::SyntaxElement> root, QList<std::shared_ptr<ast_gen::SyntaxElement>> children)
|
||
//{
|
||
// for (auto& child : children) {
|
||
// if (!child->isAnonymous()) {
|
||
// auto check_result = ast_gen::GlobalElement::UniquePtr->appendToCache(child);
|
||
// if (check_result)
|
||
// throw new SyntaxException(QString("SyntaxError[0x0004]系统中包含同类型重名命名节点：%1<type：%2>(%3,%4)")
|
||
// .arg(child->signature()).arg(child->typeMark()).arg(child->path()).arg(check_result->path()));
|
||
// }
|
||
//
|
||
// QList<std::shared_ptr<ast_gen::SyntaxElement>> next_child_items;
|
||
// for (auto& it : child->bindExpression()->children()) {
|
||
// auto const_it = std::dynamic_pointer_cast<const ast_gen::SyntaxElement>(it);
|
||
// next_child_items.append(std::const_pointer_cast<ast_gen::SyntaxElement>(const_it));
|
||
// }
|
||
//
|
||
// node_register(child, next_child_items);
|
||
// }
|
||
//}
|
||
|
||
|
||
|
||
#include "syntax_templets.h"
|
||
|
||
/**
|
||
* class DeclExpr : public ElementRule<TextSection, (int) NovelNode::TextSection> {
|
||
public:
|
||
DeclExpr() : ElementRule<TextSection, (int) NovelNode::TextSection>(
|
||
"decl_section",
|
||
MultiR(std::make_shared<const Any>(Rules{
|
||
MR(TextSection, numbers), MR(TextSection, vtext), MR(TextSection, refers), MR(TextSection, split_mark)
|
||
}))) { }
|
||
|
||
// 通过 ElementRule 继承
|
||
QList<std::shared_ptr<const MatchCursor>> expr_rule_parse(std::shared_ptr<const MatchCursor> cursor) const override {
|
||
return _children_store->parse(cursor);
|
||
}
|
||
};
|
||
*/
|
||
|
||
using namespace lib_composit;
|
||
|
||
template<typename E, typename T> class TokenRn : public TokenR<E, T, apntk> { };
|
||
template<typename R> class MultiRx : public ReptR<R, 1, INT_MAX> { };
|
||
|
||
void rules() {
|
||
MultiRx<AnyR<
|
||
TokenRn<TextSection, Numbers>,
|
||
TokenRn<TextSection, NormalText>,
|
||
TokenRn<TextSection, ReferMk>,
|
||
TokenRn<TextSection, SplitMk>
|
||
>> dcc;
|
||
|
||
AnyR<TokenRn<TextSection, Numbers>, TokenRn<TextSection, NormalText>, TokenRn<TextSection, ReferMk>, TokenRn<TextSection, SplitMk>> mmm;
|
||
ReptR<decltype(mmm), 1, INT_MAX> decl;
|
||
}
|