loom

1
/*
2
MIT License
3

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

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

9
#include "simodo/ast/generator/FormationWrapper.h"
10

11
#include <cassert>
12

13
namespace simodo::ast
14
{
15
    void FormationWrapper::addNode(const std::u16string & host, 
16
                                OperationCode op, 
17
                                const inout::Token & op_symbol, 
18
                                const inout::Token & bound)
19
    {
20
        FormationFlow & stream = getStream_mutable(_current_stream_no);
21

22
        stream.addNode(host, op, op_symbol, bound);
23
    }
24

25
    void FormationWrapper::addNode_StepInto(const std::u16string & host, 
26
                                OperationCode op, 
27
                                const inout::Token & op_symbol, 
28
                                const inout::Token & bound)
29
    {
30
        FormationFlow & stream = getStream_mutable(_current_stream_no);
31

32
        stream.addNode_StepInto(host, op, op_symbol, bound);
33
    }
34

35
    bool FormationWrapper::goParent()
36
    {
37
        FormationFlow & stream = getStream_mutable(_current_stream_no);
38

39
        return stream.goParent();
40
    }
41

42
    void FormationWrapper::addFile(const std::string & file_path)
43
    {
44
        auto it = _ast_streams.find(_current_stream_no);
45

46
        if (it == _ast_streams.end()) 
47
            return;
48

49
        it->second.addFile(file_path);
50
    }
51

52
    const ast::Tree & FormationWrapper::tree() const  
53
    {
54
        if (!_tree.root().branches().empty())
55
            return _tree;
56

57
        auto it = _ast_streams.find(_current_stream_no);
58

59
        if (it == _ast_streams.end()) {
60
            static Tree static_ast;
61
            return static_ast;
62
        }
63

64
        return it->second.tree(); 
65
    }
66

67
    void FormationWrapper::finalize()
68
    {
69
        _tree._root._branches.swap(_main_stream._tree._root._branches);
70
        _tree._files.swap(_main_stream._tree._files);
71
        
72
        auto & wb = _tree._root._branches;
73

74
        for(auto & [no,s] : _ast_streams) {
75
            assert(no != DEFAULT_STREAM_NO);
76

77
            auto & sb = s._tree._root.branches();
78

79
            wb.insert(wb.end(), sb.begin(), sb.end());
80
        }
81
    }
82

83
    const FormationFlow &FormationWrapper::getStream(uint16_t no)
84
    {
85
        static FormationFlow dummy;
86

87
        auto it = _ast_streams.find(no);
88

89
        if (it == _ast_streams.end())
90
            return dummy;
91

92
        return it->second;
93
    }
94

95
    void FormationWrapper::removeStream(uint16_t no)
96
    {
97
        _ast_streams.erase(no);
98
    }
99

100
    FormationFlow &FormationWrapper::getStream_mutable(uint16_t stream_no)
101
    {
102
        if (stream_no == DEFAULT_STREAM_NO)
103
            return _main_stream;
104

105
        /// \todo Нужно оптимизировать из соображений, что чаще всего будет работать один номер потока
106

107
        auto it = _ast_streams.find(stream_no);
108

109
        if (it != _ast_streams.end())
110
            return it->second;
111

112
        auto [it_new, ok] = _ast_streams.emplace(stream_no,FormationFlow());
113

114
        assert(ok);
115

116
        return it_new->second;
117
    }
118

119
}