loom

1
/*
2
MIT License
3

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

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

9
/*! \file Интерпретация текста
10
 *
11
 *  Утилита интерпретации текста на любом языке, заданном грамматикой на языке SIMODO fuze.
12
 *
13
 *  Проект SIMODO.
14
*/
15

16
#include "simodo/engine/FrameBody.h"
17
#include "simodo/inout/token/RegularInputStreamSupplier.h"
18
#include "simodo/inout/reporter/ConsoleReporter.h"
19
#include "simodo/loom/Loom.h"
20
#include "simodo/module/ModuleManagement.h"
21
#include "simodo/interpret/InterpretFactory.h"
22
#include "simodo/inout/convert/functions.h"
23
#include "simodo/LibVersion.h"
24

25
#include <chrono>
26

27
#if __cplusplus >= __cpp_2017
28
#include <filesystem>
29
namespace fs = std::filesystem;
30
#else
31
#include <experimental/filesystem>
32
namespace fs = std::filesystem::experimental;
33
#endif
34

35
using namespace simodo;
36

37
static const std::string DIGITS = "0123456789";
38

39
int main(int argc, char *argv[])
40
{
41
    std::vector<std::string> arguments(argv + 1, argv + argc);
42

43
    std::string                 file_name           = "";
44
    std::string                 simodo_root_path    = ".";
45
    std::vector<std::string>    preload_module_names;
46
    bool                        need_time_intervals = false;
47
    bool	                    error               = false;
48
    bool	                    help                = false;
49
    bool	                    version             = false;
50
    bool                        need_silence        = false;
51
    std::string                 type_string         = "";
52
    std::string                 initial_contracts_file = engine::INITIAL_CONTRACTS_FILE;
53

54
    for(size_t i=0; i < arguments.size(); ++i)
55
    {
56
        const std::string & arg = arguments[i];
57

58
        if (arg[0] == '-')
59
        {
60
            if (arg == "--help" || arg == "-h")
61
                help = true;
62
            else if (arg == "--version" || arg == "-v")
63
                version = true;
64
            else if (arg == "--type" || arg == "-p")
65
            {
66
                if (i == arguments.size()-1 || !type_string.empty())
67
                    error = true;
68
                else
69
                    type_string = arguments[++i];
70
            }
71
            else if (arg == "--simodo-dir" || arg == "-s")
72
            {
73
                if (i == arguments.size()-1)
74
                    error = true;
75
                else
76
                    simodo_root_path = arguments[++i];
77
            }
78
            else if (arg == "--preload-module" || arg == "-m")
79
            {
80
                if (i == arguments.size()-1)
81
                    error = true;
82
                else
83
                    preload_module_names.push_back(arguments[++i]);
84
            }
85
            else if (arg == "--initial-contracts-file" || arg == "-c")
86
            {
87
                if (i == arguments.size()-1)
88
                    error = true;
89
                else
90
                    initial_contracts_file = arguments[++i];
91
            }
92
            else if (arg == "--time-intervals" || arg == "-t")
93
                need_time_intervals = true;
94
            else if (arg == "--silence" || arg == "-S")
95
                need_silence = true;
96
            else
97
                error = true;
98
        }
99
        else if (file_name.empty())
100
            file_name = arg;
101
        else
102
            error = true;
103
    }
104

105
    interpret::InterpretType interpret_type = interpret::InterpretType::Preview;
106

107
    if (type_string == "analyze" || type_string == "a")
108
        interpret_type = interpret::InterpretType::Analyzer;
109
    else if (type_string == "preview" || type_string == "v")
110
        interpret_type = interpret::InterpretType::Preview;
111
    else if (!type_string.empty()) {
112
        std::cout << "Задан недопустимый тип интерпретации" << std::endl;
113
        error = true;
114
    }
115

116
    if (file_name.empty() && !version && !help)
117
        error = true;
118

119
    if (error) {
120
        std::cout << "Ошибка в параметрах запуска" << std::endl;
121
        help = true;
122
    }
123

124
    const std::string logo = "Утилита интерпретации. Проект SIMODO.";
125

126
    {
127
        using namespace std;
128

129
        if (help)
130
            cout	<< logo << endl
131
                    << "Формат запуска:" << endl
132
                    << "    simodo-interpret [<параметры>] <файл>" << endl
133
                    << "Параметры:" << endl
134
                    << "    -h | --help                       - отображение подсказки по запуску программы" << endl
135
                    << "    -v | --version                    - отображение версии программы" << endl
136
                    << "    -p | --type {a|v|analyze|preview} - тип интерпретации (по умолчанию: run)" << endl
137
                    << "    -s | --simodo-dir <путь>          - путь к папке установки simodo" << endl
138
                    << "    -c | --initial-contracts-file <путь> - путь к файлу обязательных контрактов" << endl
139
                    << "                                           (по умолчанию: initial-contracts.simodo-script)," << endl
140
                    << "                                           должен находиться в каталоге: data/grammar/contracts" << endl
141
                    << "    -m | --preload-module <имя>       - имя модуля для предварительно загрузки (можно указать несколько раз)" << endl
142
                    << "    -t | --time-intervals             - отображать интервалы времени разбора" << endl
143
                    << "    -S | --silence                    - не выводить диагностику утилиты" << endl
144
                    ;
145
    }
146

147
    if (error)
148
        return 1;
149

150
    if (version)
151
        std::cout << logo << std::endl
152
             << "Версия: " << lib_version().major() << "." << lib_version().minor() << std::endl;
153

154
    if (file_name.empty())
155
        return 0;
156

157
    if (!initial_contracts_file.empty()) {
158
        fs::path initial_contracts_path = fs::path(simodo_root_path)
159
                                / fs::path(engine::INITIAL_CONTRACTS_DIR) 
160
                                / initial_contracts_file;
161
        initial_contracts_file = initial_contracts_path.string();
162
    }
163

164
    inout::ConsoleReporter              r;
165
    inout::RegularInputStreamSupplier   file_supplier;
166
    interpret::SemanticDataCollector_null semantic_data;
167
    loom::Loom                          loom;
168
    interpret::InterpretFactory         interpret_factory(
169
                                            interpret_type,
170
                                            r,
171
                                            loom
172
                                        );
173
    module::ModuleManagement            mm( r, 
174
                                            file_supplier, 
175
                                            // semantic_places,
176
                                            // hard_module_places, 
177
                                            // grammar_places, 
178
                                            simodo_root_path,
179
                                            interpret_factory,
180
                                            semantic_data
181
                                        );
182
    engine::FrameBody                   engine(
183
                                            r, 
184
                                            mm, 
185
                                            preload_module_names, 
186
                                            initial_contracts_file,
187
                                            file_name
188
                                        );
189
    
190
    bool ok = engine.prepare();
191

192
    if (!ok) {
193
        std::cout << "Не удалось завести движок" << std::endl;
194
        return 1;
195
    }
196

197
    auto start_of_interpret = std::chrono::high_resolution_clock::now();
198

199
    loom::FiberStatus status = engine.run();
200

201
    if (status != loom::FiberStatus::Complete || engine.causer()) {
202
        if (!need_silence)
203
            std::cout << "Интерпретация прервана" << std::endl;
204

205
        return 1;
206
    }
207
    
208
    loom.wait();
209

210
    if (need_time_intervals) {
211
        auto elapsed = std::chrono::duration<float>(std::chrono::high_resolution_clock::now() - start_of_interpret);
212

213
        std::cout << "Интерпретация выполнена за " << elapsed.count() << " с" << std::endl;
214
    }
215
    else if (!need_silence)
216
        std::cout << "Интерпретация выполнена успешно" << std::endl;
217

218
    return 0;
219
}
220