loom

1
/*
2
MIT License
3

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

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

9
#include "simodo/interpret/SemanticOperationsEnumsLoader.h" 
10

11
#include "simodo/variable/json/LexicalParametersLoader.h"
12
#include "simodo/inout/token/Tokenizer.h"
13
#include "simodo/inout/token/FileStream.h"
14
#include "simodo/inout/convert/functions.h"
15

16
#if __cplusplus >= __cpp_2017
17
#include <filesystem>
18
namespace fs = std::filesystem;
19
#else
20
#include <experimental/filesystem>
21
namespace fs = std::filesystem::experimental;
22
#endif
23

24

25
namespace simodo::interpret
26
{
27
    variable::VariableSet_t readSemanticModuleOperations(const std::string & file_path, inout::LexicalParameters & lex)
28
    {
29
        variable::VariableSet_t res;
30

31
        inout::FileStream in(file_path);
32

33
        if (!in.good())
34
            return res;
35

36
        inout::Tokenizer tokenizer(0, in, lex);
37
        inout::Token     t = tokenizer.getToken();
38

39
        while(t.type() != inout::LexemeType::Empty) {
40
            if (t.type() != inout::LexemeType::Id)
41
                break;
42

43
            std::u16string id = t.lexeme();
44

45
            t = tokenizer.getToken();
46

47
            if (t.type() != inout::LexemeType::Punctuation || t.lexeme() != u"=")
48
                break;
49

50
            t = tokenizer.getToken();
51

52
            if (t.type() != inout::LexemeType::Number
53
             || t.qualification() != inout::TokenQualification::Integer)
54
                break;
55

56
            int64_t number = std::stol(inout::toU8(t.lexeme()));
57

58
            t = tokenizer.getToken();
59

60
            if (t.type() != inout::LexemeType::Punctuation || t.lexeme() != u",")
61
                break;
62

63
            res.push_back({id, number});
64

65
            t = tokenizer.getToken();
66
        }
67

68
        return res;
69
    }
70

71
    variable::VariableSet_t loadSemanticOperationsEnums(const std::string & grammar_dir)
72
    {
73
        variable::VariableSet_t res;
74
        const fs::path path_to_grammar {grammar_dir};
75

76
        if (!fs::exists(path_to_grammar))
77
            return res;
78

79
        inout::LexicalParameters lex;
80

81
        bool ok = variable::loadLexicalParameters((path_to_grammar/"lex"/"cpp.json").string(), lex);
82

83
        if (!ok)
84
            return res;
85

86
        const fs::path path_to_ops { path_to_grammar / "ops"};
87

88
        for (auto const & f : fs::directory_iterator{path_to_ops}) {
89
            std::u16string extension = f.path().extension().u16string();
90
            std::u16string host_name = extension.empty() ? u"" : extension.substr(1);
91
            variable::VariableSet_t ops = readSemanticModuleOperations(f.path().string(), lex);
92
            variable::VariableSet_t host {{
93
                {u"host", host_name},
94
                {u"op", variable::Object {ops}},
95
            }};
96

97
            res.push_back({f.path().stem().u16string(), variable::Object {host}});
98
        }
99

100
        return res;
101
    }
102

103
}