loom

1
/*
2
MIT License
3

4
Copyright (c) 2021 МГТУ им. Н.Э. Баумана, кафедра ИУ-6, Михаил Фетисов,
5

6
https://bmstu.codes/lsx/simodo/loom
7
*/
8

9
#include "simodo/interpret/builtins/AstFormationBuilder.h"
10
#include "simodo/bormental/DrBormental.h"
11

12
namespace simodo::interpret::builtins
13
{
14
    namespace
15
    {
16
        parser::SyntaxDataCollector_null    null_data_collector;
17
    }
18

19
    AstFormationBuilder::AstFormationBuilder(inout::Reporter_abstract & reporter,
20
                        BaseInterpret_abstract & sbl_host,
21
                        variable::VariableSet_t & hosts)
22
        : _m(reporter)
23
        , _sbl_host(sbl_host)
24
        , _hosts(hosts)
25
        , _syntax_data_collector(null_data_collector)
26
    {
27
        _ast_formation_module = std::make_shared<AstFormationModule>(_hosts);
28

29
        _sbl_host.importNamespace(u"ast", 
30
                                  _ast_formation_module->instantiate(_ast_formation_module), 
31
                                  inout::null_token_location);
32
    }
33

34
    AstFormationBuilder::AstFormationBuilder(inout::Reporter_abstract & reporter,
35
                        BaseInterpret_abstract & sbl_host,
36
                        variable::VariableSet_t & hosts,
37
                        parser::SyntaxDataCollector_interface & syntax_data_collector)
38
        : _m(reporter)
39
        , _sbl_host(sbl_host)
40
        , _hosts(hosts)
41
        , _syntax_data_collector(syntax_data_collector)
42
    {
43
        _ast_formation_module = std::make_shared<AstFormationModule>(_hosts);
44

45
        _sbl_host.importNamespace(u"ast", 
46
                                  _ast_formation_module->instantiate(_ast_formation_module), 
47
                                  inout::null_token_location);
48
    }
49

50
    AstFormationBuilder::~AstFormationBuilder()
51
    {
52
    }
53

54
    bool AstFormationBuilder::weave(const ast::Node & code)
55
    {
56
        _sbl_host.inter().addFlowLayer(code);
57

58
        loom::FiberStatus status;
59

60
        while((status=_sbl_host.inter().executeOperation()) == loom::FiberStatus::Flow)
61
            ;
62

63
        return loom::FiberStatus::Complete == status;
64
    }
65

66
    bool AstFormationBuilder::onStart(const std::map<std::u16string, ast::Node> &handlers)
67
    {
68
        if (InterpretState::Flow != _sbl_host.before_start())
69
            return false;;
70

71
        auto it = handlers.find(u"on_Start");
72

73
        if (it == handlers.end())
74
            return true;
75

76
        return weave(it->second);
77
    }
78

79
#ifdef AST_BUILDER_DEBUG
80
    bool AstFormationBuilder::onProduction(size_t ,
81
                                size_t ,
82
                                const inout::Token & production,
83
                                const std::vector<inout::Token> & pattern,
84
                                const ast::Node & action,
85
                                size_t ,
86
                                size_t )
87
#else
88
    bool AstFormationBuilder::onProduction(
89
                                const inout::Token & production,
90
                                const std::vector<inout::Token> & pattern,
91
                                const ast::Node & action)
92
#endif
93
    {
94
        if (action.branches().empty())
95
            return true;
96

97
        _ast_formation_module->setCurrentProduction(&production);
98
        _ast_formation_module->setCurrentPattern(&pattern);
99

100
        bool ok = weave(action);
101

102
        _ast_formation_module->setCurrentProduction(nullptr);
103
        _ast_formation_module->setCurrentPattern(nullptr);
104

105
        return ok;
106
    }
107

108
    void AstFormationBuilder::onTerminal(const inout::Token & token) 
109
    {
110
        _syntax_data_collector.collectToken(token);
111
    }
112

113
    bool AstFormationBuilder::onFinish(bool , const std::map<std::u16string, ast::Node> &handlers)
114
    {
115
        _sbl_host.before_finish(InterpretState::Flow);
116

117
        auto it = handlers.find(u"on_Finish");
118

119
        if (it != handlers.end())
120
            if (!weave(it->second))
121
                return false;
122

123
        ast().finalize();
124

125
        return true;
126
    }
127

128
}