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, int depth) 
20
{
21
    u16string str;
22

23
    depth -= 1;
24

25
    switch(value.type())
26
    {
27
    case ValueType::Null:
28
        str = u"null";
29
        break;
30
    case ValueType::String:
31
        if (!holds_alternative<u16string>(value.variant()))
32
            str = u"<"+inout::toU16(getValueTypeName(value.type()))+ u">";
33
        else {
34
            u16string text = get<u16string>(value.variant());
35

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

82
            for(const Variable & n : record) {
83
                const Variable & n_origin = n.origin();
84

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

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

91
                if (!first)
92
                    str += u", ";
93

94
                if (n.name().empty())
95
                    str += u"\"\":" + toString(n.origin().value(), need_whole_info, true, depth);
96
                else if (n_origin.type() == ValueType::Function && n.name().substr(0,4) == u"get_")
97
                    str += n.name().substr(4) + u":" + toString(n.origin().value(), need_whole_info, true, depth);
98
                else
99
                    str += n.name() + u":" + toString(n.origin().value(), need_whole_info, true, depth);
100

101
                first = false;
102
            }
103
            str += u"}";
104
        }
105
        break;
106
    case ValueType::Array:
107
        if (!holds_alternative<shared_ptr<Array>>(value.variant()))
108
            str = u"<"+inout::toU16(getValueTypeName(value.type()))+ u">";
109
        else if (depth < 0)
110
            str = u"[...]";
111
        else {
112
            str = u"[";
113
            const std::shared_ptr<Array> array = value.getArray();
114
            bool first = true;
115

116
            for(size_t i=0; i < array->values().size(); ++i)
117
            {
118
                if (!first) str += u", ";
119
                str += toString(array->values()[i], need_whole_info, true, depth);
120
                first = false;
121
            }
122
            str += u"]";
123
        }
124
        break;
125
    default:
126
        {
127
            str = u"<" + inout::toU16(getValueTypeName(value.type()));
128

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

133
            str+=u">";
134
        }
135
        break;
136
    }
137

138
    return str;
139
}
140