codeboss
/
WsParser_VS
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: codeboss:e84bb426f511fc9e6b5e5abb5c38e13b0b2bbf92
Branches Tags
codeboss:master
codeboss:dev
..
compare: codeboss:16f89a2ee7ba5605eb8ad208ba122ed060c7674e
Branches Tags
codeboss:master
codeboss:dev

No commits in common. "e84bb426f511fc9e6b5e5abb5c38e13b0b2bbf92" and "16f89a2ee7ba5605eb8ad208ba122ed060c7674e" have entirely different histories.
e84bb426f5 ... 16f89a2ee7

3 changed files with 286 additions and 181 deletions
Show Stats Expand all files Collapse all files

2
WsNovelParser/novelparser.cpp
View File

@ -12,7 +12,7 @@ NovelParser::NovelParser()
{ {
this->syntax_defines = example_novel::NovalSyntax::getParseTree(); this->syntax_defines = example_novel::NovalSyntax::getParseTree();
checker_list << std::make_shared<example_novel::FragmentExistsCheck>(); checker_list << std::make_shared<example_novel::FragmentExistsCheck>();
checker_list << std::make_shared<example_novel::FragmentGraphCheck>(); checker_list << std::make_shared<example_novel::FragmentOrdersCheck>();
analyzer_ref = std::make_shared<lib_parse::Analyzer>(checker_list); analyzer_ref = std::make_shared<lib_parse::Analyzer>(checker_list);
} }

383
libParse/parse_novel.cpp
View File

@ -12,10 +12,10 @@ using namespace example_novel;
void FragmentExistsCheck::exists_check(std::shared_ptr<const ast_gen::GlobalElement> root, void FragmentExistsCheck::exists_check(std::shared_ptr<const ast_gen::GlobalElement> root,
std::shared_ptr<const ast_gen::ElementAccess> target) const { std::shared_ptr<const ast_gen::ElementAccess> target) const {
if (target->element()->typeMark() == (int)NovelNode::FragmentRefer) { if (target->element()->typeMark() == (int)example_novel::NovelNode::FragmentRefer) {
auto refer = std::dynamic_pointer_cast<const FragmentRefers>(target->element()); auto refer = std::dynamic_pointer_cast<const example_novel::FragmentRefers>(target->element());
auto signature = refer->storyRefer() + u8"&" + refer->fragmentRefer(); auto signature = refer->storyRefer() + u8"&" + refer->fragmentRefer();
root->getNamedNodeBy((int)NovelNode::FragmentDefine, signature); root->getNamedNodeBy((int)example_novel::NovelNode::FragmentDefine, signature);
} }
for (auto& xit : target->children()) { for (auto& xit : target->children()) {
@ -27,199 +27,268 @@ void FragmentExistsCheck::validCheck(std::shared_ptr<const ast_gen::ElementAcces
this->exists_check(std::dynamic_pointer_cast<const ast_gen::GlobalElement>(root->element()), root); this->exists_check(std::dynamic_pointer_cast<const ast_gen::GlobalElement>(root->element()), root);
} }
QString FragmentExistsCheck::name() const { FragmentSortHelper::FragmentSortHelper(std::shared_ptr<const ast_gen::ElementAccess> node_bind, int story_sort) {
return u8"FragmentExistsCheck"; if (node_bind->element()->typeMark() == (int)example_novel::NovelNode::FragmentDefine) {
} type_marks = Type::ELEMENT;
}
QList<std::shared_ptr<FragmentGraphHelper>> example_novel::FragmentGraphCheck::refers_cycle_check( else {
std::shared_ptr<FragmentGraphHelper> item, QList<std::shared_ptr<FragmentGraphHelper>> prevs) const { type_marks = Type::REFER;
if (prevs.contains(item)) {
return prevs << item;
} }
auto next_list = item->nextList(); element_bind = node_bind;
if (next_list.size()) { next_attachment = nullptr;
prevs << item; this->story_sort = story_sort;
for (auto next : next_list) {
auto ref_link = refers_cycle_check(next, prevs);
if (ref_link.size())
return ref_link;
}
}
return QList<std::shared_ptr<FragmentGraphHelper>>();
} }
void FragmentGraphCheck::setElement(std::shared_ptr<FragmentGraphHelper> inst) FragmentSortHelper::Type FragmentSortHelper::nodeType() const { return type_marks; }
std::shared_ptr<const ast_gen::ElementAccess> FragmentSortHelper::nodeBind() const { return element_bind; }
int FragmentSortHelper::storySort() const
{ {
elements_store[inst->nodePeer()->signature()] = inst; return story_sort;
} }
std::shared_ptr<FragmentGraphHelper> FragmentGraphCheck::getElement(const QString& signature) const std::shared_ptr<FragmentSortHelper> FragmentSortHelper::next() const {
return next_attachment;
}
void FragmentSortHelper::attachNext(std::shared_ptr<FragmentSortHelper> fragment) {
this->next_attachment = fragment;
}
void FragmentSortHelper::assignSibling(std::shared_ptr<FragmentSortHelper> other)
{ {
return elements_store[signature]; auto temp_list = this->siblings_store;
} temp_list.append(other->siblings_store);
temp_list.append(other);
temp_list.append(shared_from_this());
QList<std::shared_ptr<FragmentGraphHelper>> example_novel::FragmentGraphCheck::getHangoutNodes() { QHash<QString, std::shared_ptr<FragmentSortHelper>> helpers;
QList<std::shared_ptr<FragmentGraphHelper>> values; for (auto& it : temp_list) {
helpers[it->element_bind->element()->signature()] = it;
for (auto node_item : elements_store) {
if (!node_item->inDegree())
values.append(node_item);
} }
for (auto inst : values) { temp_list = helpers.values();
auto name = inst->nodePeer()->signature(); for (auto& it : temp_list) {
elements_store.remove(name); auto vlist = temp_list;
} vlist.removeAll(it);
return values; it->siblings_store = vlist;
}
} }
bool example_novel::FragmentGraphCheck::nodeDismantle(std::shared_ptr<FragmentGraphHelper> inst) { QList<std::shared_ptr<FragmentSortHelper> > FragmentSortHelper::siblings() const
bool flag = false;
for (auto item : inst->nextList()) {
item->inDegree()--;
flag = true;
}
return flag;
}
void FragmentGraphCheck::validCheck(std::shared_ptr<const ast_gen::ElementAccess> root) const
{ {
std::function<QList<std::shared_ptr<const ast_gen::ElementAccess>>(std::shared_ptr<const ast_gen::ElementAccess>)> story_peak return siblings_store;
= [&](std::shared_ptr<const ast_gen::ElementAccess> root)->QList<std::shared_ptr<const ast_gen::ElementAccess>> { }
QList<std::shared_ptr<const ast_gen::ElementAccess>> return_temp;
auto type_mark = (NovelNode)root->element()->typeMark();
if (type_mark == NovelNode::StoryDefine) { void FragmentOrdersCheck::elements_link_build(const QList<std::shared_ptr<StorySortHelper> >& stories)
return_temp << root; {
QHash<QString, std::shared_ptr<StorySortHelper>> helper;
for (auto& i : stories)
helper[i->storyName()] = i;
auto auto_refer = [&](std::shared_ptr<StorySortHelper> story) {
auto fragment_head = story->fragmentSort();
while (fragment_head) {
switch (fragment_head->nodeType()) {
case FragmentSortHelper::Type::REFER:
{
auto access = fragment_head->nodeBind();
auto elm = std::dynamic_pointer_cast<const example_novel::FragmentRefers>(access->element());
if (!helper.contains(elm->storyRefer())) {
throw new lib_parse::CheckException(QString(u8"Parse[0x0001]故事线“%1”不存在！").arg(elm->storyRefer()));
}
auto story_target = helper[elm->storyRefer()];
auto fragm_target = story_target->fragment(elm->fragmentRefer());
if (!fragm_target) {
throw new lib_parse::CheckException(
QString(u8"Parse[0x0002]故事线“%1”的情节“%2”不存在！").arg(elm->storyRefer()).arg(elm->fragmentRefer()));
}
fragment_head->assignSibling(fragm_target);
}break;
default:
break;
}
fragment_head = fragment_head->next();
} }
for (auto child : root->children()) {
return_temp.append(story_peak(child));
}
return return_temp;
}; };
auto self = std::const_pointer_cast<FragmentGraphCheck>(this->shared_from_this()); for (auto& vit : stories) {
auto_refer(vit);
}
}
// 获取所有故事线 template<class InputIt, class OutputIt, class Operate>
auto all_story = story_peak(root); void cast(InputIt Begin, InputIt End, OutputIt Dst, Operate fn) {
// 注册图节点 while (Begin != End) {
for (auto story : all_story) { *Dst++ = fn(*Begin++);
auto fragment_items = story->children(); }
}
// 构建情节节点列表
for (auto frag_primitive : fragment_items) {
switch (frag_primitive->element()->typeMark()) {
case (int)NovelNode::FragmentDefine: {
auto target_node = std::dynamic_pointer_cast<const FragmentDefine>(frag_primitive->element());
auto finst = std::make_shared<FragmentGraphHelper>(target_node);
self->setElement(finst); void FragmentOrdersCheck::sort_cycle_check(const QList<std::shared_ptr<FragmentSortHelper>>& tracks, std::shared_ptr<FragmentSortHelper> _current, int story_sort_source)
}break; {
default: break; if (!_current || !_current->next())
} return;
auto target = _current->next();
if (tracks.contains(peaks_appoint_element(target))) {
QString error_cycle;
for (auto& it : tracks)
error_cycle += u8"->" + it->nodeBind()->element()->signature() + u8"\n";
error_cycle += u8"->" + target->nodeBind()->element()->signature() + u8"。";
throw new lib_parse::CheckException(u8"Parse[0x0003]排序异常：\n" + error_cycle);
}
auto nlist = tracks;
nlist.append(peaks_appoint_element(target));
if (target->nodeType() == example_novel::FragmentSortHelper::Type::REFER) {
decltype (target->siblings()) sibling_forks;
auto siblings = target->siblings();
for (auto& vit : siblings) {
if (vit->storySort() <= story_sort_source)
sibling_forks << vit;
}
for (auto& fork : sibling_forks) {
sort_cycle_check(nlist, fork, story_sort_source);
} }
} }
// 构建图连接 sort_cycle_check(nlist, target, story_sort_source);
for (auto story : all_story) { }
auto fragment_items = story->children();
// 过滤获取情节节点 std::shared_ptr<FragmentSortHelper> example_novel::FragmentOrdersCheck::peaks_appoint_element(std::shared_ptr<FragmentSortHelper> refer_n) const
for (auto idx = 0; idx < fragment_items.size(); idx++) { {
auto fragment_inst = fragment_items[idx]; if (refer_n->nodeType() == example_novel::FragmentSortHelper::Type::ELEMENT)
switch (fragment_inst->element()->typeMark()) return refer_n;
{
case (int)NovelNode::FragmentDefine: auto sibs = refer_n->siblings();
case (int)NovelNode::FragmentRefer: for (auto ptr : sibs) {
break; if (ptr->nodeType() == example_novel::FragmentSortHelper::Type::ELEMENT)
return ptr;
}
return nullptr;
}
void FragmentOrdersCheck::validCheck(std::shared_ptr<const ast_gen::ElementAccess> root) const {
std::function<QList<std::shared_ptr<const ast_gen::ElementAccess>>(std::shared_ptr<const ast_gen::ElementAccess>)> peak_story =
[&](std::shared_ptr<const ast_gen::ElementAccess> pnode) -> QList<std::shared_ptr<const ast_gen::ElementAccess>> {
QList<std::shared_ptr<const ast_gen::ElementAccess>> listret;
if (pnode->element()->typeMark() == (int)example_novel::NovelNode::StoryDefine)
listret << pnode;
for (auto& vit : pnode->children())
listret.append(peak_story(vit));
return listret;
};
auto stories = peak_story(root);
std::sort(std::begin(stories), std::end(stories),
[](std::shared_ptr<const ast_gen::ElementAccess> itema, std::shared_ptr<const ast_gen::ElementAccess> itemb) -> bool {
auto storya = std::dynamic_pointer_cast<const example_novel::StoryDefine>(itema->element());
auto storyb = std::dynamic_pointer_cast<const example_novel::StoryDefine>(itemb->element());
return storya->sort() < storyb->sort();
});
for (auto& sit : stories) {
auto story_sort = std::make_shared<StorySortHelper>(sit);
const_cast<FragmentOrdersCheck*>(this)->stories_list << story_sort;
auto children = sit->children();
std::shared_ptr<FragmentSortHelper> temp_ptr = nullptr;
for (auto& nf : children) {
switch ((example_novel::NovelNode)nf->element()->typeMark()) {
case example_novel::NovelNode::FragmentDefine:
case example_novel::NovelNode::FragmentRefer: {
auto frag_sort = std::make_shared<FragmentSortHelper>(nf, story_sort->sortValue());
if (!temp_ptr) {
story_sort->attachFragmentSort(frag_sort);
}
else {
temp_ptr->attachNext(frag_sort);
}
temp_ptr = frag_sort;
} break;
default: default:
fragment_items.removeAt(idx);
idx--;
break; break;
} }
} }
}
auto get_name = [](std::shared_ptr<const ast_gen::ElementAccess> node)->QString { // 重复排序检查
switch (node->element()->typeMark()) { int prev_sort = 0;
case (int)NovelNode::FragmentDefine: { for (auto& s : stories_list) {
auto def_node = std::dynamic_pointer_cast<const example_novel::FragmentDefine>(node->element()); if (s->sortValue() < 1)
return def_node->signature(); throw new lib_parse::CheckException(u8"Parse[0x0006]故事“%1”的排序<1。");
}break; if (prev_sort >= s->sortValue()) {
case (int)NovelNode::FragmentRefer: { auto idx = stories_list.indexOf(s);
auto ref_node = std::dynamic_pointer_cast<const example_novel::FragmentRefers>(node->element()); auto prev = stories_list[idx - 1];
return ref_node->referSignature(); throw new lib_parse::CheckException(QString(u8"Parse[0x0007]故事“%1”与故事“%2”排序重复。").arg(s->storyName()).arg(prev->storyName()));
}break;
}
return QString();
};
// 构建完整图结构
for (auto fidx = 1; fidx < fragment_items.size(); fidx++) {
auto tail_name = get_name(fragment_items[fidx - 1]);
auto head_name = get_name(fragment_items[fidx]);
auto tail_helper = getElement(tail_name);
auto head_helper = getElement(head_name);
tail_helper->appendNext(head_helper);
head_helper->inDegree()++;
} }
} }
// 获取拓扑排序序列 const_cast<FragmentOrdersCheck*>(this)->elements_link_build(this->stories_list);
auto values = self->getHangoutNodes();
for (auto idx = 0; idx < values.size(); ++idx) {
auto target = values[idx];
self->nodeDismantle(target); for (auto& s : this->stories_list) {
auto x_values = self->getHangoutNodes(); if(!s->fragmentSort())
values.append(x_values); continue;
QList<std::shared_ptr<FragmentSortHelper>> tracks;
tracks << peaks_appoint_element(s->fragmentSort());
const_cast<FragmentOrdersCheck*>(this)->sort_cycle_check(tracks, s->fragmentSort(), s->sortValue());
} }
}
// 理论上不应该有残余 StorySortHelper::StorySortHelper(std::shared_ptr<const ast_gen::ElementAccess> story_bind) {
if (elements_store.size()) { this->story_bind = story_bind;
for (auto node : elements_store.values()) { this->fragments_bind = nullptr;
auto cycle_link = refers_cycle_check(node); }
QString error_msg = u8"Parse[0x0006]情节图存在环形结构：\n"; std::shared_ptr<const example_novel::StoryDefine> StorySortHelper::storyElement() const {
for (auto n : cycle_link) { return std::dynamic_pointer_cast<const example_novel::StoryDefine>(story_bind->element());
error_msg += QString(u8"%1->").arg(n->nodePeer()->signature()); }
}
if (cycle_link.size()) QString StorySortHelper::storyName() const { return storyElement()->name(); }
throw new lib_parse::CheckException(error_msg);
int StorySortHelper::sortValue() const
{
return storyElement()->sort();
}
std::shared_ptr<FragmentSortHelper> StorySortHelper::fragmentSort() const {
return this->fragments_bind;
}
void StorySortHelper::attachFragmentSort(std::shared_ptr<FragmentSortHelper> refer) {
this->fragments_bind = refer;
}
std::shared_ptr<FragmentSortHelper> StorySortHelper::fragment(const QString& name) const {
auto temp_ptr = fragments_bind;
do {
if (temp_ptr->nodeType() == FragmentSortHelper::Type::ELEMENT) {
auto node = std::dynamic_pointer_cast<const example_novel::FragmentDefine>(temp_ptr->nodeBind()->element());
if (node->name() == name)
return temp_ptr;
} }
} temp_ptr = temp_ptr->next();
} while (temp_ptr);
return nullptr;
} }
QString example_novel::FragmentGraphCheck::name() const {
return u8"FragmentGraphCheck";
}
FragmentGraphHelper::FragmentGraphHelper(std::shared_ptr<const FragmentDefine> node) : node_peer(node) {}
std::shared_ptr<const FragmentDefine> FragmentGraphHelper::nodePeer() const
{
return this->node_peer;
}
void FragmentGraphHelper::appendNext(std::shared_ptr<FragmentGraphHelper> node) {
this->next_nodes.append(node);
}
QList<std::shared_ptr<FragmentGraphHelper>> FragmentGraphHelper::nextList() const
{
return next_nodes;
}
uint& FragmentGraphHelper::inDegree()
{
return this->indegree;
}

82
libParse/parse_novel.h
View File

@ -12,45 +12,81 @@ namespace example_novel {
public: public:
// ͨ¹ý CheckProvider ¼Ì³Ð // ͨ¹ý CheckProvider ¼Ì³Ð
virtual void validCheck(std::shared_ptr<const ast_gen::ElementAccess> root) const override; virtual void validCheck(std::shared_ptr<const ast_gen::ElementAccess> root) const override;
virtual QString name() const override; virtual QString name() const override {
return u8"FragmentExistsCheck";
}
}; };
class FragmentGraphHelper;
class LIBPARSE_EXPORT FragmentGraphCheck : public std::enable_shared_from_this<FragmentGraphCheck>, public lib_parse::CheckProvider {
private:
QHash<QString, std::shared_ptr<FragmentGraphHelper>> elements_store;
QList<std::shared_ptr<FragmentGraphHelper>> refers_cycle_check( class StorySortHelper;
std::shared_ptr<FragmentGraphHelper> item, QList<std::shared_ptr<FragmentGraphHelper>> prevs = QList<std::shared_ptr<FragmentGraphHelper>>()) const; class FragmentSortHelper;
class LIBPARSE_EXPORT FragmentOrdersCheck : public lib_parse::CheckProvider {
protected:
QList<std::shared_ptr<StorySortHelper>> stories_list;
public: void elements_link_build(const QList<std::shared_ptr<StorySortHelper>>& stories);
void setElement(std::shared_ptr<FragmentGraphHelper> inst); void sort_cycle_check(const QList<std::shared_ptr<FragmentSortHelper>>& tracks, std::shared_ptr<FragmentSortHelper> current,
std::shared_ptr<FragmentGraphHelper> getElement(const QString &signature) const; int story_sort_source);
QList<std::shared_ptr<FragmentGraphHelper>> getHangoutNodes(); std::shared_ptr<FragmentSortHelper> peaks_appoint_element(std::shared_ptr<FragmentSortHelper> refer_n) const;
bool nodeDismantle(std::shared_ptr<FragmentGraphHelper> inst);
// CheckProvider interface // CheckProvider interface
public: public:
virtual void validCheck(std::shared_ptr<const ast_gen::ElementAccess> root) const override; virtual void validCheck(std::shared_ptr<const ast_gen::ElementAccess> root) const override;
virtual QString name() const override; virtual QString name() const override {
return u8"FragmentOrdersCheck";
}
}; };
class FragmentGraphHelper : public std::enable_shared_from_this<FragmentGraphHelper> { /**
* @brief Çé½ÚÅÅÐò¸¨ÖúÀà
*/
class LIBPARSE_EXPORT FragmentSortHelper : public std::enable_shared_from_this<FragmentSortHelper> {
public:
enum class Type {
REFER, ELEMENT
};
FragmentSortHelper(std::shared_ptr<const ast_gen::ElementAccess> node_bind, int story_sort);
Type nodeType() const;
std::shared_ptr<const ast_gen::ElementAccess> nodeBind() const;
int storySort() const;
std::shared_ptr<FragmentSortHelper> next() const;
void attachNext(std::shared_ptr<FragmentSortHelper> fragment);
void assignSibling(std::shared_ptr<FragmentSortHelper> other);
QList<std::shared_ptr<FragmentSortHelper>> siblings() const;
private: private:
std::shared_ptr<const example_novel::FragmentDefine> node_peer; Type type_marks;
QList<std::shared_ptr<FragmentGraphHelper>> next_nodes; int story_sort;
uint indegree = 0; std::shared_ptr<const ast_gen::ElementAccess> element_bind;
std::shared_ptr<FragmentSortHelper> next_attachment;
QList<std::shared_ptr<FragmentSortHelper>> siblings_store;
};
/**
* @brief ¹ÊÊÂÅÅÐò¸¨ÖúÀà
*/
class LIBPARSE_EXPORT StorySortHelper {
private:
std::shared_ptr<const ast_gen::ElementAccess> story_bind;
std::shared_ptr<FragmentSortHelper> fragments_bind;
public: public:
FragmentGraphHelper(std::shared_ptr<const example_novel::FragmentDefine> node); StorySortHelper(std::shared_ptr<const ast_gen::ElementAccess> story_bind);
std::shared_ptr<const example_novel::FragmentDefine> nodePeer() const;
void appendNext(std::shared_ptr<FragmentGraphHelper> node); std::shared_ptr<const example_novel::StoryDefine> storyElement() const;
QList<std::shared_ptr<FragmentGraphHelper>> nextList() const; QString storyName() const;
int sortValue() const;
uint& inDegree(); std::shared_ptr<FragmentSortHelper> fragmentSort() const;
void attachFragmentSort(std::shared_ptr<FragmentSortHelper> refer);
std::shared_ptr<FragmentSortHelper> fragment(const QString& name) const;
}; };