Шаблоны третьего порядка, или как я портировал Jinja2 на C++

void Enum2StringGenerator::WriteHeaderContent(CppSourceStream &hdrOs)
{
    std::vector<reflection::EnumInfoPtr> enums;
    WriteNamespaceContents(hdrOs, m_namespaces.GetRootNamespace(), [this, &enums](CppSourceStream &os, reflection::NamespaceInfoPtr ns) {
        for (auto& enumInfo : ns->enums)
        {
            WriteEnumToStringConversion(os, enumInfo);
            WriteEnumFromStringConversion(os, enumInfo);
            enums.push_back(enumInfo);
        }
    });

    hdrOs << "\n\n";

    {
        out::BracedStreamScope flNs("\nnamespace flex_lib", "\n\n", 0);
        hdrOs << out::new_line(1) << flNs;

        for (reflection::EnumInfoPtr enumInfo : enums)
        {
            auto scopedParams = MakeScopedParams(hdrOs, enumInfo);
        
            {
                hdrOs << out::new_line(1) << "template<>";
                out::BracedStreamScope body("inline const char* Enum2String($enumFullQualifiedName$ e)", "\n");
                hdrOs << out::new_line(1) << body;
                hdrOs << out::new_line(1) << "return $namespaceQual$::$enumName$ToString(e);";
            }
            {
                hdrOs << out::new_line(1) << "template<>";
                out::BracedStreamScope body("inline $enumFullQualifiedName$ String2Enum<$enumFullQualifiedName$>(const char* itemName)", "\n");
                hdrOs << out::new_line(1) << body;
                hdrOs << out::new_line(1) << "return $namespaceQual$::StringTo$enumName$(itemName);";
            }
        }        
    }
    {
        out::BracedStreamScope flNs("\nnamespace std", "\n\n", 0);
        hdrOs << out::new_line(1) << flNs;

        for (reflection::EnumInfoPtr enumInfo : enums)
        {
            auto scopedParams = MakeScopedParams(hdrOs, enumInfo);

            out::BracedStreamScope body("inline std::string to_string($enumFullQualifiedName$ e)", "\n");
            hdrOs << out::new_line(1) << body;
            hdrOs << out::new_line(1) << "return $namespaceQual$::$enumName$ToString(e);";
        }
    }
}

// Enum item to string conversion writer
void Enum2StringGenerator::WriteEnumToStringConversion(CppSourceStream &hdrOs, const reflection::EnumInfoPtr &enumDescr)
{
    auto scopedParams = MakeScopedParams(hdrOs, enumDescr);

    out::BracedStreamScope fnScope("inline const char* $enumName$ToString($enumScopedName$ e)", "\n");
    hdrOs << out::new_line(1) << fnScope;
    {
        out::BracedStreamScope switchScope("switch (e)", "\n");
        hdrOs << out::new_line(1) << switchScope;
        out::OutParams innerParams;
        for (auto& i : enumDescr->items)
        {
            innerParams["itemName"] = i.itemName;
            hdrOs << out::with_params(innerParams)
                  << out::new_line(-1) << "case $prefix$$itemName$:"
                  << out::new_line(1) << "return \"$itemName$\";";
        }
    }
    hdrOs << out::new_line(1) << "return \"Unknown Item\";";
}

// String to enum conversion writer
void Enum2StringGenerator::WriteEnumFromStringConversion(CppSourceStream &hdrOs, const reflection::EnumInfoPtr &enumDescr)
{
    auto params = MakeScopedParams(hdrOs, enumDescr);

    out::BracedStreamScope fnScope("inline $enumScopedName$ StringTo$enumName$(const char* itemName)", "\n");
    hdrOs << out::new_line(1) << fnScope;
    {
        out::BracedStreamScope itemsScope("static std::pair<const char*, $enumScopedName$> items[] = ", ";\n");
        hdrOs << out::new_line(1) << itemsScope;

        out::OutParams& innerParams = params.GetParams();
        auto items = enumDescr->items;
        std::sort(begin(items), end(items), [](auto& i1, auto& i2) {return i1.itemName < i2.itemName;});
        for (auto& i : items)
        {
            innerParams["itemName"] = i.itemName;
            hdrOs << out::with_params(innerParams) << out::new_line(1) << "{\"$itemName$\", $prefix$$itemName$},";
        }
    }

    hdrOs << out::with_params(params.GetParams()) << R"(
     $enumScopedName$ result;
     if (!flex_lib::detail::String2Enum(itemName, items, result))
         flex_lib::bad_enum_name::Throw(itemName, "$enumName$");
     return result;)";
}

ExpressionEvaluatorPtr<FullExpressionEvaluator> ExpressionParser::ParseFullExpression(LexScanner &lexer, bool includeIfPart)
{
    ExpressionEvaluatorPtr<FullExpressionEvaluator> result;
    LexScanner::StateSaver saver(lexer);

    ExpressionEvaluatorPtr<FullExpressionEvaluator> evaluator = std::make_shared<FullExpressionEvaluator>();
    auto value = ParseLogicalOr(lexer);
    if (!value)
        return result;

    evaluator->SetExpression(value);
    ExpressionEvaluatorPtr<ExpressionFilter> filter;
    if (lexer.PeekNextToken() == '|')
    {
        lexer.EatToken();
        filter = ParseFilterExpression(lexer);
        if (!filter)
            return result;
        evaluator->SetFilter(filter);
    }

    ExpressionEvaluatorPtr<IfExpression> ifExpr;
    if (lexer.PeekNextToken() == Token::If)
    {
        if (includeIfPart)
        {
            lexer.EatToken();
            ifExpr = ParseIfExpression(lexer);
            if (!ifExpr)
                return result;
            evaluator->SetTester(ifExpr);
        }
    }

    saver.Commit();

    return evaluator;
}

ExpressionEvaluatorPtr<Expression> ExpressionParser::ParseLogicalOr(LexScanner& lexer)
{
    auto left = ParseLogicalAnd(lexer);
    if (!left)
        return ExpressionEvaluatorPtr<Expression>();

    if (lexer.NextToken() != Token::LogicalOr)
    {
        lexer.ReturnToken();
        return left;
    }
    auto right = ParseLogicalOr(lexer);
    if (!right)
        return ExpressionEvaluatorPtr<Expression>();

    return std::make_shared<BinaryExpression>(BinaryExpression::LogicalOr, left, right);
}

ExpressionEvaluatorPtr<Expression> ExpressionParser::ParseLogicalAnd(LexScanner& lexer)
{
    auto left = ParseLogicalCompare(lexer);
    if (!left)
        return ExpressionEvaluatorPtr<Expression>();

    if (lexer.NextToken() != Token::LogicalAnd)
    {
        lexer.ReturnToken();
        return left;
    }
    auto right = ParseLogicalAnd(lexer);
    if (!right)
        return ExpressionEvaluatorPtr<Expression>();

    return std::make_shared<BinaryExpression>(BinaryExpression::LogicalAnd, left, right);
}

ExpressionEvaluatorPtr<Expression> ExpressionParser::ParseLogicalCompare(LexScanner& lexer)
{
    auto left = ParseStringConcat(lexer);
    if (!left)
        return ExpressionEvaluatorPtr<Expression>();

    auto tok = lexer.NextToken();
    BinaryExpression::Operation operation;
    switch (tok.type)
    {
    case Token::Equal:
        operation = BinaryExpression::LogicalEq;
        break;
    case Token::NotEqual:
        operation = BinaryExpression::LogicalNe;
        break;
    case '<':
        operation = BinaryExpression::LogicalLt;
        break;
    case '>':
        operation = BinaryExpression::LogicalGt;
        break;
    case Token::GreaterEqual:
        operation = BinaryExpression::LogicalGe;
        break;
    case Token::LessEqual:
        operation = BinaryExpression::LogicalLe;
        break;
    case Token::In:
        operation = BinaryExpression::In;
        break;
    case Token::Is:
    {
        Token nextTok = lexer.NextToken();
        if (nextTok != Token::Identifier)
            return ExpressionEvaluatorPtr<Expression>();

        std::string name = AsString(nextTok.value);
        bool valid = true;
        CallParams params;

        if (lexer.NextToken() == '(')
            params = ParseCallParams(lexer, valid);
        else
            lexer.ReturnToken();

        if (!valid)
            return ExpressionEvaluatorPtr<Expression>();

        return std::make_shared<IsExpression>(left, std::move(name), std::move(params));
    }
    default:
        lexer.ReturnToken();
        return left;
    }

    auto right = ParseStringConcat(lexer);
    if (!right)
        return ExpressionEvaluatorPtr<Expression>();

    return std::make_shared<BinaryExpression>(operation, left, right);
}

class ExpressionFilter;
class IfExpression;

class FullExpressionEvaluator : public ExpressionEvaluatorBase
{
public:
    void SetExpression(ExpressionEvaluatorPtr<Expression> expr)
    {
        m_expression = expr;
    }
    void SetFilter(ExpressionEvaluatorPtr<ExpressionFilter> expr)
    {
        m_filter = expr;
    }
    void SetTester(ExpressionEvaluatorPtr<IfExpression> expr)
    {
        m_tester = expr;
    }
    InternalValue Evaluate(RenderContext& values) override;
    void Render(OutStream &stream, RenderContext &values) override;
private:
    ExpressionEvaluatorPtr<Expression> m_expression;
    ExpressionEvaluatorPtr<ExpressionFilter> m_filter;
    ExpressionEvaluatorPtr<IfExpression> m_tester;
};

class ValueRefExpression : public Expression
{
public:
    ValueRefExpression(std::string valueName)
        : m_valueName(valueName)
    {
    }
    InternalValue Evaluate(RenderContext& values) override;
private:
    std::string m_valueName;
};

class SubscriptExpression : public Expression
{
public:
    SubscriptExpression(ExpressionEvaluatorPtr<Expression> value, ExpressionEvaluatorPtr<Expression> subscriptExpr)
        : m_value(value)
        , m_subscriptExpr(subscriptExpr)
    {
    }
    InternalValue Evaluate(RenderContext& values) override;
private:
    ExpressionEvaluatorPtr<Expression> m_value;
    ExpressionEvaluatorPtr<Expression> m_subscriptExpr;
};

class ConstantExpression : public Expression
{
public:
    ConstantExpression(InternalValue constant)
        : m_constant(constant)
    {}
    InternalValue Evaluate(RenderContext&) override
    {
        return m_constant;
    }
private:
    InternalValue m_constant;
};

class TupleCreator : public Expression
{
public:
    TupleCreator(std::vector<ExpressionEvaluatorPtr<>> exprs)
        : m_exprs(std::move(exprs))
    {
    }

    InternalValue Evaluate(RenderContext&) override;

private:
    std::vector<ExpressionEvaluatorPtr<>> m_exprs;
};

struct Statement : public RendererBase
{
};

template<typename T = Statement>
using StatementPtr = std::shared_ptr<T>;

template<typename CharT>
class TemplateImpl;

class ForStatement : public Statement
{
public:
    ForStatement(std::vector<std::string> vars, ExpressionEvaluatorPtr<> expr, ExpressionEvaluatorPtr<> ifExpr, bool isRecursive)
        : m_vars(std::move(vars))
        , m_value(expr)
        , m_ifExpr(ifExpr)
        , m_isRecursive(isRecursive)
    {
    }

    void SetMainBody(RendererPtr renderer)
    {
        m_mainBody = renderer;
    }

    void SetElseBody(RendererPtr renderer)
    {
        m_elseBody = renderer;
    }

    void Render(OutStream& os, RenderContext& values) override;
    
private:
    void RenderLoop(const InternalValue& val, OutStream& os, RenderContext& values);

private:
    std::vector<std::string> m_vars;
    ExpressionEvaluatorPtr<> m_value;
    ExpressionEvaluatorPtr<> m_ifExpr;
    bool m_isRecursive;
    RendererPtr m_mainBody;
    RendererPtr m_elseBody;
};

class ElseBranchStatement;

class IfStatement : public Statement
{
public:
    IfStatement(ExpressionEvaluatorPtr<> expr)
        : m_expr(expr)
    {
    }

    void SetMainBody(RendererPtr renderer)
    {
        m_mainBody = renderer;
    }

    void AddElseBranch(StatementPtr<ElseBranchStatement> branch)
    {
        m_elseBranches.push_back(branch);
    }

    void Render(OutStream& os, RenderContext& values) override;

private:
    ExpressionEvaluatorPtr<> m_expr;
    RendererPtr m_mainBody;
    std::vector<StatementPtr<ElseBranchStatement>> m_elseBranches;
};


class ElseBranchStatement : public Statement
{
public:
    ElseBranchStatement(ExpressionEvaluatorPtr<> expr)
        : m_expr(expr)
    {
    }

    bool ShouldRender(RenderContext& values) const;
    void SetMainBody(RendererPtr renderer)
    {
        m_mainBody = renderer;
    }
    void Render(OutStream& os, RenderContext& values) override;

private:
    ExpressionEvaluatorPtr<> m_expr;
    RendererPtr m_mainBody;
};

class LexScanner
{
public:
    struct State
    {
        Lexer::TokensList::const_iterator m_begin;
        Lexer::TokensList::const_iterator m_end;
        Lexer::TokensList::const_iterator m_cur;
    };

    struct StateSaver
    {
        StateSaver(LexScanner& scanner)
            : m_state(scanner.m_state)
            , m_scanner(scanner)
        {
        }

        ~StateSaver()
        {
            if (!m_commited)
                m_scanner.m_state = m_state;
        }

        void Commit()
        {
            m_commited = true;
        }

        State m_state;
        LexScanner& m_scanner;
        bool m_commited = false;
    };

    LexScanner(const Lexer& lexer)
    {
        m_state.m_begin = lexer.GetTokens().begin();
        m_state.m_end = lexer.GetTokens().end();
        Reset();
    }

    void Reset()
    {
        m_state.m_cur = m_state.m_begin;
    }

    auto GetState() const
    {
        return m_state;
    }

    void RestoreState(const State& state)
    {
        m_state = state;
    }

    const Token& NextToken()
    {
        if (m_state.m_cur == m_state.m_end)
            return EofToken();

        return *m_state.m_cur ++;
    }

    void EatToken()
    {
        if (m_state.m_cur != m_state.m_end)
            ++ m_state.m_cur;
    }

    void ReturnToken()
    {
        if (m_state.m_cur != m_state.m_begin)
            -- m_state.m_cur;
    }

    const Token& PeekNextToken() const
    {
        if (m_state.m_cur == m_state.m_end)
            return EofToken();

        return *m_state.m_cur;
    }

    bool EatIfEqual(char type, Token* tok = nullptr)
    {
        return EatIfEqual(static_cast<Token::Type>(type), tok);
    }

    bool EatIfEqual(Token::Type type, Token* tok = nullptr)
    {
        if (m_state.m_cur == m_state.m_end)
        {
            if(type == Token::Type::Eof && tok)
                *tok = EofToken();

            return type == Token::Type::Eof;
        }

        if (m_state.m_cur->type == type)
        {
            if (tok)
                *tok = *m_state.m_cur;
            ++ m_state.m_cur;
            return true;
        }

        return false;
    }

private:
    State m_state;
    static const Token& EofToken()
    {
        static Token eof;
        eof.type = Token::Eof;
        return eof;
    }
};