loom

1
/*
2
MIT License
3

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

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

9
#include "simodo/variable/convert/Ast.h"
10
#include "simodo/inout/convert/functions.h"
11

12
#include <algorithm>
13

14
namespace simodo::variable
15
{
16

17
    Value toValue(const ast::Tree & tree)
18
    {
19
        return std::make_shared<Object>(VariableSet_t {{
20
            {u"files",  toValue(tree.files())},
21
            {u"root",   toValue(tree.root())},
22
        }});
23
    }
24

25
    Value toValue(const inout::uri_set_t & files)
26
    {
27
        std::vector<Value> file_set;
28

29
        for(const std::string & s : files)
30
            file_set.push_back(inout::toU16(s));
31

32
        return std::make_shared<Array>( file_set );
33
    }
34

35
    Value toValue(const ast::Node & node)
36
    {
37
        return std::make_shared<Object>(VariableSet_t {{
38
            {u"host",       node.host()},
39
            {u"operation",  node.operation()},
40
            {u"token",      toValue(node.token())},
41
            {u"bound",      toValue(node.bound())},
42
            {u"branches",   toValue(node.branches())},
43
        }});
44
    }
45

46
    Value toValue(const inout::Token & token)
47
    {
48
        return std::make_shared<Object>(VariableSet_t {{
49
            {u"type",           static_cast<int64_t>(token.type())},
50
            {u"lexeme",         token.lexeme()},
51
            {u"token",          token.token()},
52
            {u"qualification",  static_cast<int64_t>(token.qualification())},
53
            {u"context",   static_cast<int64_t>(token.context())},
54
            {u"location",       toValue(token.location())},
55
        }});
56
    }
57

58
    Value toValue(const inout::TokenLocation & location)
59
    {
60
        return std::make_shared<Object>(VariableSet_t {{
61
            {u"uri_index",  location.uri_index()},
62
            {u"range",      toValue(location.range())},
63
        }});
64
    }
65

66
    Value toValue(const inout::Range & range)
67
    {
68
        return std::make_shared<Object>(VariableSet_t {{
69
            {u"start",  toValue(range.start())},
70
            {u"end",    toValue(range.end())},
71
        }});
72
    }
73
    
74
    Value toValue(const inout::Position & position)
75
    {
76
        return std::make_shared<Object>(VariableSet_t {{
77
            {u"line",       static_cast<int64_t>(position.line())},
78
            {u"character",  static_cast<int64_t>(position.character())},
79
        }});
80
    }
81

82
    Value toValue(const std::vector<ast::Node> & branches)
83
    {
84
        std::vector<Value> branch_values;
85

86
        for(const ast::Node & node : branches)
87
            branch_values.push_back(toValue(node));
88

89
        return std::make_shared<Array>( branch_values );
90
    }
91

92
}