loom

1
/*
2
MIT License
3

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

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

9
#include "simodo/interpret/Interpret.h"
10
#include "simodo/interpret/AnalyzeException.h"
11

12
#include "simodo/loom/Loom_interface.h"
13
#include "simodo/bormental/DrBormental.h"
14
#include "simodo/inout/convert/functions.h"
15

16
#include <algorithm>
17
#include <cassert>
18

19
#define SemanticFiber_DEBUG_no
20

21
namespace simodo::interpret
22
{
23
    bool Interpret::wait(const variable::Variable & var)
24
    {
25
        const ChildFlowInfo * info = findChildFlowInfo(var);
26
        if (!info)
27
            return false;
28

29
        if (var.origin().type() != variable::ValueType::Object)
30
            return false;
31

32
        _waiting_for = info->child->fiber();
33

34
        return true;
35
    }
36

37
    bool Interpret::push(const variable::Variable & var)
38
    {
39
        const ChildFlowInfo * info = findChildFlowInfo(var);
40
        if (!info)
41
            return false;
42

43
        if (var.origin().type() != variable::ValueType::Object)
44
            return false;
45

46
        std::shared_ptr<variable::Object> source_object = var.origin().value().getObject();
47
        auto [begin,end] = info->child->stack().boundaryLowAndTop(info->child_bound);
48

49
        for(name_index_t i=begin; i < end; ++i) {
50
            variable::Variable & target_variable = info->child->stack().variable(i);
51
            if (!target_variable.value().isFunction()) {
52
                const variable::Variable & source_element = source_object->getVariableByName(target_variable.name());
53
                assert(!source_element.name().empty());
54
                target_variable.value() = source_element.value().copy();
55
            }
56
        }
57

58
        return true;
59
    }
60

61
    bool Interpret::pull(variable::Variable & var)
62
    {
63
        const ChildFlowInfo * info = findChildFlowInfo(var);
64
        if (!info)
65
            return false;
66

67
        if (var.origin().type() != variable::ValueType::Object)
68
            return false;
69

70
        // _loom.wait(info->child->fiber());
71

72
        std::shared_ptr<variable::Object> target_object = var.origin().value().getObject();
73
        auto [begin,end] = info->child->stack().boundaryLowAndTop(info->child_bound);
74

75
        for(name_index_t i=begin; i < end; ++i) {
76
            const variable::Variable & source_element = info->child->stack().variable(i);
77
            if (!source_element.value().isFunction()) {
78
                variable::Variable & target_variable = const_cast<variable::Variable &>(target_object->getVariableByName(source_element.name()));
79
                assert(!target_variable.name().empty());
80
                target_variable.value() = source_element.value().copy();
81
            }
82
        }
83

84
        return true;
85
    }
86

87
    // bool Interpret::cut()
88
    // {
89
    //     _loom.cut(this);
90
    //     return true;
91
    // }
92

93
    bool Interpret::addChildFiber(const variable::Variable & var)
94
    {
95
        const ChildFlowInfo * info = findChildFlowInfo(var);
96
        if (info)
97
            return false;
98

99
        if (var.origin().type() != variable::ValueType::Object)
100
            return false;
101

102
        std::shared_ptr<variable::Object> obj = var.origin().value().getObject();
103

104
        Interpret * child = new Interpret(_type, _m, _loom, _semantic_factories);
105

106
        boundary_index_t child_bound = child->copyBaseBounds(stack());
107

108
        child->stack().fillFromObject(obj);
109
        child->stack().startBoundary();
110

111
        /// \todo Это одноразовое копирование не годится для общего случая, особенно для итеративной отладки!
112
        /// >>>
113
        child->_files = _files;
114
        child->_breakpoints = _breakpoints;
115
        /// <<<
116

117
        const variable::Value & name_value = obj->find(u"name");
118
        std::string name;
119
        if (name_value.isString())
120
            name = inout::toU8(name_value.getString());
121
        else
122
            name = inout::toU8(var.origin().name());
123

124
        if (!_loom.dock(child,true,this,loom::FiberStatus::Delayed,name)) {
125
            delete child;
126
            return false;
127
        }
128

129
        _childs.push_back({obj,child,child_bound});
130
        return true;
131
    }
132

133
    const ChildFlowInfo * Interpret::findChildFlowInfo(const variable::Variable & var) const
134
    {
135
        if (var.origin().type() != variable::ValueType::Object)
136
            return nullptr;
137

138
        std::shared_ptr<variable::Object> obj = var.origin().value().getObject();
139

140
        auto it = std::find_if( _childs.begin(), _childs.end(),
141
                                [obj](const ChildFlowInfo & info)
142
                                {
143
                                    return info.our_object.get() == obj.get();
144
                                });
145

146
        if (it == _childs.end())
147
            return nullptr;
148

149
        return it.base();
150
    }
151

152

153
}