WsParser_VS/libSyntax/tokens_novel.cpp

#include "tokens_novel.h"
#include <QtCore/QRegExp>
#include "tokens_impl.h"

using namespace example_novel;
using namespace lib_token;
using namespace lib_words;


QString LeftBracket::reviseWords() const { return "{"; }

int LeftBracket::typeMark() const
{
    return 0x01000000;
}

QString LeftBracket::regex() const { return "{"; }

std::tuple<std::shared_ptr<const IToken>, std::shared_ptr<const IPrimitiveWord>>
LeftBracket::analysis(std::shared_ptr<const IPrimitiveWord> content) const {
    auto text = content->content();
    if (!text.startsWith(regex()))
        return std::make_tuple(nullptr, content);

    auto token_inst = std::make_shared<TokenContent>(content->row(), content->column(), content->position(),
        content->content().mid(0, regex().length()), content->file(), shared_from_this());

    auto t_remains = content->content().mid(regex().length());
    if (t_remains.length() > 0) {
        auto remains = std::make_shared<WordContent>(content->row(), content->column() + regex().length(), 
            content->position() + regex().length(), t_remains, content->file());
        return std::make_tuple(token_inst, remains);
    }
    return std::make_tuple(token_inst, nullptr);
}

QString RightBracket::reviseWords() const { return "}"; }

int RightBracket::typeMark() const
{
    return 0x02000000;
}

QString RightBracket::regex() const { return "}"; }

QString ReferMark::reviseWords() const { return "@"; }

int ReferMark::typeMark() const
{
    return 0x03000000;
}

QString ReferMark::regex() const { return "@"; }

Keywords::Keywords(const QString& val, uint type_code) : means_store(val), type_code(type_code) {}

QString Keywords::reviseWords() const { return means_store; }

int Keywords::typeMark() const
{
    return 0x06000000 | (0x00ffffff & type_code);
}

QString Keywords::regex() const { return means_store; }

std::tuple<std::shared_ptr<const IToken>, std::shared_ptr<const IPrimitiveWord>>
Keywords::analysis(std::shared_ptr<const IPrimitiveWord> content) const {
    if (content->content() != regex()) {
        return std::make_tuple(nullptr, content);
    }

    auto token_inst = std::make_shared<TokenContent>(content->row(), content->column(), content->position(),
        content->content(), content->file(), shared_from_this());
    return std::make_tuple(token_inst, nullptr);
}

QString Numbers::reviseWords() const { return "正整数"; }

int Numbers::typeMark() const
{
    return 0x07000000;
}

QString Numbers::regex() const { return "^([0-9]+)$"; }

std::tuple<std::shared_ptr<const IToken>, std::shared_ptr<const IPrimitiveWord>>
Numbers::analysis(std::shared_ptr<const IPrimitiveWord> content) const {
    auto text = content->content();
    QRegExp regx(regex());
    if (regx.indexIn(text) == -1)
        return std::make_tuple(nullptr, content);

    auto tinst = std::make_shared<TokenContent>(content->row(), content->column(), content->position(),
        content->content(), content->file(), shared_from_this());
    return std::make_tuple(tinst, nullptr);
}

QString VTextSection::reviseWords() const { return "文本"; }

int VTextSection::typeMark() const
{
    return 0x09000000;
}

QString VTextSection::regex() const { return "^([^\\{\\}@&]+)"; }

std::tuple<std::shared_ptr<const IToken>, std::shared_ptr<const IPrimitiveWord>>
VTextSection::analysis(std::shared_ptr<const IPrimitiveWord> content) const {
    auto text = content->content();
    QRegExp regx(regex());
    if (regx.indexIn(text) == -1) {
        return std::make_tuple(nullptr, content);
    }

    auto match = regx.cap(1);
    auto remains = content->content().mid(match.length());

    auto tinst = std::make_shared<TokenContent>(content->row(), content->column(), content->position(),
        match, content->file(), shared_from_this());
    if (remains.length()) {
        auto t_remains = std::make_shared<WordContent>(content->row(), content->column(), 
            content->position() + match.length(), remains, content->file());
        return std::make_tuple(tinst, t_remains);
    }
    return std::make_tuple(tinst, nullptr);
}

QString Split::reviseWords() const { return "&"; }

int Split::typeMark() const
{
    return 0x05000000;
}

QString Split::regex() const { return "&"; }

QString NameSection::reviseWords() const { return "名称"; }

int NameSection::typeMark() const
{
    return 0x08000000;
}

QString NameSection::regex() const { return "^([^\\{\\}@&]+)"; }

std::tuple<std::shared_ptr<const IToken>, std::shared_ptr<const IPrimitiveWord> >
NameSection::analysis(std::shared_ptr<const IPrimitiveWord> content) const
{
    auto text = content->content();
    QRegExp regx(regex());
    if (regx.indexIn(text) == -1) {
        return std::make_tuple(nullptr, content);
    }

    auto match = regx.cap(1);
    auto remains = content->content().mid(match.length());

    auto tinst = std::make_shared<TokenContent>(content->row(), content->column(), content->position(),
        match, content->file(), shared_from_this());
    if (remains.length()) {
        auto t_remains = std::make_shared<WordContent>(content->row(), content->column(), 
            content->position() + match.length(), remains, content->file());
        return std::make_tuple(tinst, t_remains);
    }
    return std::make_tuple(tinst, nullptr);
}

QString DeclareSymbo::reviseWords() const {
    return "#";
}

int DeclareSymbo::typeMark() const
{
    return 0x0A000000;
}

QString DeclareSymbo::regex() const
{
    return "#";
}

std::tuple<std::shared_ptr<const IToken>, std::shared_ptr<const IPrimitiveWord>>
DeclareSymbo::analysis(std::shared_ptr<const IPrimitiveWord> content) const
{
    auto text = content->content();
    if (content->column() != 1 && !text.startsWith(regex())) {
        return std::make_tuple(nullptr, content);
    }

    auto remains = content->content().mid(regex().size());

    auto tinst = std::make_shared<TokenContent>(content->row(), content->column(), content->position(),
        "#", content->file(), shared_from_this());
    if (remains.length()) {
        auto t_remains = std::make_shared<WordContent>(content->row(), content->column()+1, 
            content->position() + regex().length(), remains, content->file());
        return std::make_tuple(tinst, t_remains);
    }
    return std::make_tuple(tinst, nullptr);
}