loom

1
/*
2
MIT License
3

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

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

9
#include "simodo/variable/Module_interface.h"
10
#include "simodo/variable/VariableSetWrapper.h"
11
#include "simodo/interpret/Interpret_interface.h"
12

13
#include <memory>
14
#include <exception>
15
#include <cassert>
16

17
#ifdef CROSS_WIN
18
// MinGW related workaround
19
#define BOOST_DLL_FORCE_ALIAS_INSTANTIATION
20
#endif
21

22
#include <boost/dll/alias.hpp>
23

24
using namespace simodo;
25
using namespace simodo::variable;
26

27
namespace
28
{
29
    Value createInt(Module_interface * host, const VariableSetWrapper & args);
30
    Value createIntOne(Module_interface * host, const VariableSetWrapper & args);
31
    Value createAny(Module_interface * host, const VariableSetWrapper & args);
32
}
33

34
class Array_module : public Module_interface
35
{
36
public:
37
    virtual version_t version() const override { return lib_version(); }
38

39
    virtual Value instantiate(std::shared_ptr<Module_interface> module_object) override 
40
    {
41
        return {{
42
            {u"int", {ValueType::Function, Object {{
43
                {u"@", ExternalFunction {module_object, ::createInt}},
44
                {{}, ValueType::Array},
45
                {u"size", ValueType::Int},
46
            }}}},
47
            {u"int1", {ValueType::Function, Object {{
48
                {u"@", ExternalFunction {module_object, ::createIntOne}},
49
                {{}, ValueType::Array},
50
            }}}},
51
            {u"any", {ValueType::Function, Object {{
52
                {u"@", ExternalFunction {module_object, ::createAny}},
53
                {{}, ValueType::Array},
54
                {u"size", ValueType::Int},
55
                {u"type", ValueType::Null},
56
            }}}},
57
        }};
58
    }
59

60
    // Factory method
61
    static std::shared_ptr<Module_interface> create(interpret::Interpret_interface * ) {
62
        return std::make_shared<Array_module>();
63
    }
64
};
65

66
BOOST_DLL_ALIAS(
67
    Array_module::create,    // <-- this function is exported with...
68
    create_simodo_module        // <-- ...this alias name
69
)
70

71
namespace
72
{
73
    Value createInt(Module_interface * host, const VariableSetWrapper & args)
74
    {
75
        if (host == nullptr)
76
            return {};
77

78
        assert(args.size() == 1);
79

80
        int64_t size = args[0].origin().value().getInt();
81

82
        if (size <= 0 || size > 32654)
83
            throw std::invalid_argument("Invalid argument");
84

85
        std::vector<Value> array(size, 0);
86

87
        return array;
88
    }
89

90
    Value createIntOne(Module_interface * host, const VariableSetWrapper & args)
91
    {
92
        if (host == nullptr)
93
            return {};
94

95
        assert(args.size() == 0);
96

97
        std::vector<Value> array {{0}};
98

99
        return array;
100
    }
101

102
    Value createAny(Module_interface * host, const VariableSetWrapper & args)
103
    {
104
        if (host == nullptr)
105
            return {};
106

107
        assert(args.size() == 2);
108

109
        int64_t size       = args[0].origin().value().getInt();
110
        const Value & type = args[1].origin().value();
111

112
        if (size <= 0 || size > 32654)
113
            throw std::invalid_argument("Invalid argument");
114

115
        std::vector<Value> array;
116

117
        array.reserve(size);
118

119
        for(int64_t i=0; i < size; ++i)
120
            array.push_back(type.copy());
121

122
        // std::cerr << "*** module.init out" << std::endl;
123

124
        return array;
125
    }
126

127
}
128

129