loom

1
/*
2
MIT License
3

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

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

9
#include "simodo/variable/Variable.h"
10

11
#include "simodo/inout/convert/functions.h"
12

13
#include <cassert>
14

15
using namespace std;
16
using namespace simodo::variable;
17

18

19
u16string simodo::variable::toString(const Value & value, bool need_whole_info, bool quote_strings) 
20
{
21
    u16string str;
22

23
    switch(value.type())
24
    {
25
    case ValueType::String:
26
        if (!holds_alternative<u16string>(value.variant()))
27
            str = u"<"+inout::toU16(getValueTypeName(value.type()))+ u">";
28
        else {
29
            u16string text = get<u16string>(value.variant());
30

31
            if (quote_strings) {
32
                inout::replaceAll(text, u"\\", u"\\\\");
33
                inout::replaceAll(text, u"\"", u"\\\"");
34
                text = u"\""+text+u"\"";
35
            }
36
            str = text;
37
        }
38
        break;
39
    case ValueType::Bool:
40
        str = holds_alternative<bool>(value.variant())
41
                ? (get<bool>(value.variant()) ? u"true"s : u"false"s)
42
                : u"<"+inout::toU16(getValueTypeName(value.type()))+ u">";
43
        break;
44
    case ValueType::Int:
45
        str = holds_alternative<int64_t>(value.variant())
46
                ? inout::toU16(to_string(get<int64_t>(value.variant())))
47
                : u"<"+inout::toU16(getValueTypeName(value.type()))+ u">";
48
        break;
49
    case ValueType::Float:
50
        str = holds_alternative<double>(value.variant())
51
                ? inout::toU16(inout::clearNumberFractionalPart(to_string(get<double>(value.variant()))))
52
                : u"<"+inout::toU16(getValueTypeName(value.type()))+ u">";
53
        break;
54
    // case ValueType::Undefined:
55
    //     str = u"undef";
56
    //     break;
57
    // case ValueType::Function:
58
    //     if (name.substr(0,4) == u"get_") {
59
    //         const VariableSet_t & params = get<shared_ptr<Record>>(value.variant())->variables();
60
    //         assert(params.size() >= 2);
61
    //         if(params.size() == 2 && params[1].declared != DeclaredType::Error) {
62
    //             callFunction(var,{},InterpreterMode::FullExecution);
63
    //             return toString(_return_value, need_whole_info, true);
64
    //         }
65
    //     }
66
    //     [[fallthrough]];
67
    case ValueType::Object:
68
        if (!holds_alternative<shared_ptr<Object>>(value.variant()))
69
            str = u"<" + inout::toU16(getValueTypeName(value.type())) + u">";
70
        else {
71
            str   = u"{";
72
            const VariableSet_t & record = get<shared_ptr<Object>>(value.variant())->variables();
73
            bool                  first = true;
74

75
            for(const Variable & n : record) {
76
                const Variable & n_origin = n.origin();
77

78
                if (n_origin.type() == ValueType::Function && n.name().substr(0,4) == u"set_" && !need_whole_info)
79
                    continue;
80

81
                if (n_origin.type() == ValueType::Function && n.name().substr(0,4) != u"get_" && !need_whole_info)
82
                    continue;
83

84
                if (!first)
85
                    str += u", ";
86

87
                if (n.name().empty())
88
                    str += u"\"\":" + toString(n.origin().value(), need_whole_info);
89
                else if (n_origin.type() == ValueType::Function && n.name().substr(0,4) == u"get_")
90
                    str += n.name().substr(4) + u":" + toString(n.origin().value(), need_whole_info);
91
                else
92
                    str += n.name() + u":" + toString(n.origin().value(), need_whole_info, true);
93

94
                first = false;
95
            }
96
            str += u"}";
97
        }
98
        break;
99
    case ValueType::Array:
100
        if (!holds_alternative<shared_ptr<Array>>(value.variant()))
101
            str = u"<"+inout::toU16(getValueTypeName(value.type()))+ u">";
102
        else {
103
            str = u"[";
104
            const Array & array = *value.getArray();
105
            bool first = true;
106

107
            for(size_t i=0; i < array.values().size(); ++i)
108
            {
109
                if (!first) str += u", ";
110
                str += toString(array.values()[i], need_whole_info, true);
111
                first = false;
112
            }
113
            str += u"]";
114
        }
115
        break;
116
    default:
117
        {
118
            str = u"<" + inout::toU16(getValueTypeName(value.type()));
119

120
            if ((value.type() == ValueType::IntFunction && holds_alternative<InternalFunction>(value.variant()))
121
            || (value.type() == ValueType::ExtFunction && holds_alternative<ExternalFunction>(value.variant())))
122
                str += u"{}"; // Обозначаем непустую (определённую) функцию
123

124
            str+=u">";
125
        }
126
        break;
127
    }
128

129
    return str;
130
}
131