loom

1
/*
2
MIT License
3

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

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

9
#include "simodo/engine/utility/common_functions.h" 
10
#include "simodo/inout/convert/functions.h"
11
#include "simodo/inout/reporter/Reporter_abstract.h"
12

13
#include <iostream>
14
#include <fstream>
15

16
namespace simodo::engine
17
{
18
    std::string getMnemonic(const inout::Lexeme &lex, bool abstract_lexeme)
19
    {
20
        std::string mnemonic;
21

22
        switch(lex.type())
23
        {
24
        case inout::LexemeType::Empty:
25
            mnemonic = "$";
26
            break;
27
        case inout::LexemeType::Compound:
28
            mnemonic = inout::toU8(lex.lexeme());
29
            break;
30
        case inout::LexemeType::Punctuation:
31
            mnemonic = "'" + inout::toU8(lex.lexeme()) + "'";
32
            break;
33
        case inout::LexemeType::Id:
34
            mnemonic = abstract_lexeme ? "ID" : inout::toU8(lex.lexeme());
35
            break;
36
        case inout::LexemeType::Annotation:
37
            mnemonic = abstract_lexeme ? "ANNOTATION" : ("\"" + inout::toU8(lex.lexeme()) + "\"");
38
            break;
39
        case inout::LexemeType::Number:
40
            mnemonic = abstract_lexeme ? "NUMBER" : inout::toU8(lex.lexeme());
41
            break;
42
        case inout::LexemeType::Comment:
43
            mnemonic = "COMMENT";
44
            break;
45
        case inout::LexemeType::Error:
46
            mnemonic = "ERROR";
47
            break;
48
        default:
49
            mnemonic = "***";
50
            break;
51
        }
52

53
        return mnemonic;
54
    }
55

56
    namespace
57
    {
58
        void shiftString(int level, int shift, std::string str)
59
        {
60
            for(int i=0; i < shift; ++i)
61
                std::cout << "\t";
62

63
            for(int i=0; i < level; ++i)
64
                std::cout << "\t";
65

66
            if (!str.empty())
67
                std::cout << str << std::endl;
68
        }
69
    }
70

71
    void printSemanticTree(const ast::Node & ast, const inout::uri_set_t & files, int level, int shift)
72
    {
73
        shiftString(level, shift, "{");
74

75
        for(const ast::Node & n : ast.branches())
76
        {
77
            shiftString(level, shift, "");
78

79
            std::cout << "\t"
80
                << n.operation() << " \""
81
                << inout::toU8(n.token().lexeme()) << "\"";
82

83
            std::cout << "\t// " << getLocationString(n.bound().makeLocation(files),true) << std::endl;
84

85
            if (!n.branches().empty())
86
                printSemanticTree(n,files, level+1,shift);
87
        }
88

89
        shiftString(level, shift, "}");
90
    }
91

92
    void replaceAll(std::string &str, const std::string &from, const std::string &to)
93
    {
94
        if(from.empty())
95
            return;
96

97
        size_t start_pos = 0;
98
        while((start_pos = str.find(from, start_pos)) != std::string::npos)
99
        {
100
            str.replace(start_pos, from.length(), to);
101
            start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
102
        }
103
    }
104

105
    std::string toHtml(std::string text)
106
    {
107
        replaceAll(text, "&", "&amp;");
108
        replaceAll(text, "<", "&lt;");
109
        replaceAll(text, ">", "&gt;");
110

111
        return text;
112
    }
113

114
}