loom

AstFormationModule.cpp
237 строк · 9.6 Кб
Перенос по словам
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/modules/AstFormationModule.h"
10
#include "simodo/variable/VariableSetWrapper.h"
11
#include "simodo/parser/fuze/BaseOperationCode.h"
12

13
#include "simodo/bormental/DrBormental.h"
14

15
// #include "simodo/interpret/script/ScriptOperationCode.h"
16

17
#include <cassert>
18

19
#define LOGGER_no
20

21
namespace simodo::interpret::builtins
22
{
23
    namespace
24
    {
25
    #ifdef LOGGER
26
        AReporter *  logger_  = nullptr;
27
    #endif
28

29
        variable::Value addNode(variable::Module_interface * host, const variable::VariableSetWrapper & args)
30
        {
31
    #ifdef LOGGER
32
            if (logger_ != nullptr)
33
                logger_->reportInformation(u"/tAststb::addNode");
34
    #endif
35
            assert(host != nullptr);
36
            AstFormationModule & stb = *(static_cast<AstFormationModule *>(host));
37

38
            const variable::Variable & host_value  = args[0].origin();
39
            const variable::Variable & op_value    = args[1].origin();
40
            const variable::Variable & index_value = args[2].origin();
41

42
            if (index_value.type() == variable::ValueType::String)
43
            {
44
                std::u16string value { get<std::u16string>(index_value.variant()) };
45
                inout::Token   token { inout::LexemeType::Id, value, args[2].origin().location() };
46

47
                stb().addNode(get<std::u16string>(host_value.variant()),
48
                              static_cast<ast::OperationCode>(get<int64_t>(op_value.variant())),
49
                              token,
50
                              token
51
                              );
52
            }
53
            else if (index_value.type() == variable::ValueType::Int)
54
            {
55
                int64_t index = get<int64_t>(index_value.variant());
56

57
                assert((&stb.current_pattern()) != nullptr);
58
                assert((&stb.current_production()) != nullptr);
59

60
                if (index < 0 || index >= static_cast<int64_t>(stb.current_pattern().size()))
61
                    throw bormental::DrBormental("addNode", "Выход индекса за пределы массива");
62

63
                stb().addNode(get<std::u16string>(host_value.variant()),
64
                              static_cast<ast::OperationCode>(get<int64_t>(op_value.variant())),
65
                              stb.current_pattern()[static_cast<size_t>(index)],
66
                              stb.current_production()
67
                              );
68
            }
69
            else
70
                throw bormental::DrBormental("addNode", "Недопустимый тип индекса");
71

72
            return {};
73
        }
74

75
        variable::Value addNode_StepInto(variable::Module_interface * host, const variable::VariableSetWrapper & args)
76
        {
77
    #ifdef LOGGER
78
            if (logger_ != nullptr)
79
                logger_->reportInformation(u"/tAststb::addNode_StepInto");
80
    #endif
81
            assert(host != nullptr);
82
            AstFormationModule & stb = *(static_cast<AstFormationModule *>(host));
83

84
            const variable::Variable & host_value  = args[0].origin();
85
            const variable::Variable & op_value    = args[1].origin();
86
            const variable::Variable & index_value = args[2].origin();
87

88
            if (index_value.type() == variable::ValueType::String)
89
            {
90
                std::u16string value { get<std::u16string>(index_value.variant()) };
91
                inout::Token   token { inout::LexemeType::Id, value, args[2].origin().location() };
92

93
                stb().addNode_StepInto(get<std::u16string>(host_value.variant()),
94
                              static_cast<ast::OperationCode>(get<int64_t>(op_value.variant())),
95
                              token,
96
                              token
97
                              );
98
            }
99
            else if (index_value.type() == variable::ValueType::Int)
100
            {
101
                int64_t index = get<int64_t>(index_value.variant());
102

103
                assert((&stb.current_pattern()) != nullptr);
104
                assert((&stb.current_production()) != nullptr);
105

106
                if (index < 0 || index >= static_cast<int64_t>(stb.current_pattern().size()))
107
                    throw bormental::DrBormental("addNode_StepInto", "Выход индекса за пределы массива");
108

109
                stb().addNode_StepInto(get<std::u16string>(host_value.variant()),
110
                              static_cast<ast::OperationCode>(get<int64_t>(op_value.variant())),
111
                              stb.current_pattern()[static_cast<size_t>(index)],
112
                              stb.current_production()
113
                              );
114
            }
115
            else
116
                throw bormental::DrBormental("addNode_StepInto", "Недопустимый тип индекса");
117

118
            return {};
119
        }
120

121
        variable::Value goParent(variable::Module_interface * host, const variable::VariableSetWrapper & )
122
        {
123
    #ifdef LOGGER
124
            if (logger_ != nullptr)
125
                logger_->reportInformation(u"/tAststb::goParent");
126
    #endif
127
            assert(host != nullptr);
128
            AstFormationModule & stb = *(static_cast<AstFormationModule *>(host));
129

130
            bool ok = stb().goParent();
131

132
            if (!ok)
133
                throw bormental::DrBormental("goParent", "Недопустимое использование goParent");
134

135
            return {};
136
        }
137

138
    //     Variable setStreamNo(variable::Module_interface * host, const variable::VariableSetWrapper & args)
139
    //     {
140
    // #ifdef LOGGER
141
    //         if (logger_ != nullptr)
142
    //             logger_->reportInformation(u"/tAststb::setStreamNo");
143
    // #endif
144
    //         assert(host != nullptr);
145
    //         AstFormationModule & stb = *(static_cast<AstFormationModule *>(host));
146

147
    //         int64_t no = get<int64_t>(args[0].origin().variant());
148

149
    //         if (no < 0 || no > UINT16_MAX)
150
    //             throw Exception("setStreamNo", "Выход номера потока за лимиты");
151

152
    //         stb.setCurrentStreamNo(no);
153

154
    //         return error_variable();
155
    //     }
156

157
        // GrammarManagement_null gm_dummy;
158

159
        static variable::VariableSet_t hosts;
160
    }
161

162
    using namespace simodo::variable;
163

164
    AstFormationModule::AstFormationModule()
165
        : _hosts(hosts)
166
    {
167
    }
168

169
    AstFormationModule::AstFormationModule(variable::VariableSet_t & hosts)
170
        : _hosts(hosts)
171
    {
172
    }
173

174
    variable::Object AstFormationModule::instantiate(std::shared_ptr<variable::Module_interface> module_host)
175
    {
176
        variable::VariableSet_t ret {{
177
            {u"addNode", {ValueType::Function, variable::Object {{
178
                {u"@", ExternalFunction {{module_host}, addNode}},
179
                {u"", ValueType::Null},
180
                {u"host", ValueType::String},
181
                {u"op", ValueType::Int},
182
                // Неопределённый тип для индекса предполагает тип параметра 'any'
183
                {u"index", ValueType::Null},
184
            }}}},
185
            {u"addNode_StepInto", {ValueType::Function, variable::Object {{
186
                {u"@", ExternalFunction {{module_host}, addNode_StepInto}},
187
                {u"", ValueType::Null},
188
                {u"host", ValueType::String},
189
                {u"op", ValueType::Int},
190
                // Неопределённый тип для индекса предполагает тип параметра 'any'
191
                {u"index", ValueType::Null},
192
            }}}},
193
            {u"goParent", {ValueType::Function, variable::Object {{
194
                {u"@", ExternalFunction {{module_host}, goParent}},
195
                {u"", ValueType::Null},
196
                // {u"host", ValueType::String},
197
            }}}},
198
            // {u"setStream", ValueType::Function, variable::Object {
199
            //     {u"@", ValueType::ExtFunction, ExternalFunction {{}, setStreamNo}},
200
            //     {u"", ValueType::Error, {}},
201
            //     {u"no", ValueType::Int, {}},
202
            // }},
203
            // {u"Stream", ValueType::Enum, variable::Object {
204
            //     {u"Default", ValueType::Int, static_cast<int64_t>(DEFAULT_STREAM_NO)},
205
            //     {u"Equation", ValueType::Int, static_cast<int64_t>(EQUATION_STREAM_NO)},
206
            //     {u"Diff", ValueType::Int, static_cast<int64_t>(DIFF_STREAM_NO)},
207
            // }},
208
            {u"op", variable::Object {{
209
                {u"None", static_cast<int64_t>(parser::BaseOperationCode::None)},
210
                {u"PushConstant", static_cast<int64_t>(parser::BaseOperationCode::PushConstant)},
211
                {u"PushVariable", static_cast<int64_t>(parser::BaseOperationCode::PushVariable)},
212
                {u"ObjectElement", static_cast<int64_t>(parser::BaseOperationCode::ObjectElement)},
213
                {u"FunctionCall", static_cast<int64_t>(parser::BaseOperationCode::FunctionCall)},
214
                {u"ProcedureCheck", static_cast<int64_t>(parser::BaseOperationCode::ProcedureCheck)},
215
                {u"Print", static_cast<int64_t>(parser::BaseOperationCode::Print)},
216
                {u"Block", static_cast<int64_t>(parser::BaseOperationCode::Block)},
217
                {u"Pop", static_cast<int64_t>(parser::BaseOperationCode::Pop)},
218

219
            }}},
220
            {u"host", variable::Object {{
221
                {u"SBL", u""},
222
                {u"fuze", u"fuze"},
223
            }}},
224
        }};
225

226
        ret.insert(ret.end(), _hosts.begin(), _hosts.end());
227

228
        return ret;
229
    }
230

231
    // variable::ModuleFactory_interface* AstFormationModule::factory()
232
    // {
233
    //     // std::cout << "factory" << std::endl;
234

235
    //     return nullptr;
236
    // }
237
}
loom

Использование cookies
