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
#include "simodo/inout/format/fmt.h"
16

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

20
#define SemanticFiber_DEBUG_no
21

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

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

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

35
        return true;
36
    }
37

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

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

47
        if (info->child->ready())
48
            throw bormental::DrBormental("ScriptSemantics_abstract::executeFunctionCall", 
49
                        inout::fmt("Unacceptable use of an already working fiber"));
50

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

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

63
        return true;
64
    }
65

66
    bool Interpret::pull(variable::Variable & var)
67
    {
68
        const ChildFlowInfo * info = findChildFlowInfo(var);
69
        if (!info)
70
            return false;
71

72
        if (var.origin().type() != variable::ValueType::Object)
73
            return false;
74

75
        if (info->child->ready())
76
            throw bormental::DrBormental("ScriptSemantics_abstract::executeFunctionCall", 
77
                        inout::fmt("Unacceptable use of an already working fiber"));
78

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

82
        for(name_index_t i=begin; i < end; ++i) {
83
            const variable::Variable & source_element = info->child->stack().variable(i);
84
            if (!source_element.value().isFunction()) {
85
                variable::Variable & target_variable = const_cast<variable::Variable &>(target_object->getVariableByName(source_element.name()));
86
                assert(!target_variable.name().empty());
87
                target_variable.value().setValueRecursively(source_element.value());
88
            }
89
        }
90

91
        return true;
92
    }
93

94
    // bool Interpret::cut()
95
    // {
96
    //     _loom.cut(this);
97
    //     return true;
98
    // }
99

100
    bool Interpret::addChildFiber(const variable::Variable & var)
101
    {
102
        const ChildFlowInfo * info = findChildFlowInfo(var);
103
        if (info)
104
            return false;
105

106
        if (var.origin().type() != variable::ValueType::Object)
107
            return false;
108

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

111
        Interpret * child = new Interpret(_type, _m, _loom, _semantic_factories);
112

113
        boundary_index_t child_bound = child->copyBaseBounds(stack());
114

115
        child->stack().fillFromObject(obj);
116
        child->stack().startBoundary();
117

118
        /// \todo Это одноразовое копирование не годится для общего случая, особенно для итеративной отладки!
119
        /// >>>
120
        child->_files = _files;
121
        // child->_breakpoints = _breakpoints;
122
        /// <<<
123

124
        const variable::Value & name_value = obj->find(u"name");
125
        std::string name;
126
        if (name_value.isString())
127
            name = inout::toU8(name_value.getString());
128
        else
129
            name = inout::toU8(var.origin().name());
130

131
        if (!_loom.dock(child,true,this,loom::FiberStatus::Delayed,name)) {
132
            delete child;
133
            return false;
134
        }
135

136
        _childs.push_back({obj,child,child_bound});
137
        return true;
138
    }
139

140
    const ChildFlowInfo * Interpret::findChildFlowInfo(const variable::Variable & var) const
141
    {
142
        if (var.origin().type() != variable::ValueType::Object)
143
            return nullptr;
144

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

147
        auto it = std::find_if( _childs.begin(), _childs.end(),
148
                                [obj](const ChildFlowInfo & info)
149
                                {
150
                                    return info.our_object.get() == obj.get();
151
                                });
152

153
        if (it == _childs.end())
154
            return nullptr;
155

156
        return it.base();
157
    }
158

159

160
}