shiru 0.1.7

Extensible syntax highlighting engine, Rust implementation of ShiC++
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

// MIT License
//
// Copyright (c) 2021 Ferhat Geçdoğan All Rights Reserved.
// Distributed under the terms of the MIT License.
//
//

use crate::{
    highlight::Highlight,

    Builtins::{ VariableData, SingleLineComment }
};

pub struct Parse {
    pub highlight : Highlight,

    pub tokens    : Vec<String>,

    pub is_data   : bool       ,
    pub is_comment: bool
}

pub mod parse {
    pub static TOKENS: &'static [char] = &[
        '<',
        '>',
        '(',
        ')',
        '*',
        '[',
        ']'
    ];

    pub static GLOBAL_OPERATORS: &'static [char] = &[
        '+', // GlobalOperators::Addition
        '-', // GlobalOperators::Subtraction
        '/', // GlobalOperators::Division
        '*', // GlobalOperators::Multiplication
        '%', // GlobalOperators::Modulo

        '>', // GlobalOperators::GreaterThan
        '<', // GlobalOperators::LessThan

        '!', // GlobalOperators::Not

        '&', // GlobalOperators::AndBit
        '|', // GlobalOperators::OrBit
        '^', // GlobalOperators::XorBit
        '~', // GlobalOperators::NotBit

        '='  // GlobalOperators::Assignment
    ];
}

impl Parse {
    pub fn init(&mut self, data: Highlight) {
        self.highlight = data;
    }

    pub fn parse(&mut self, data: String) -> String {
        let mut generated = String::new();

        for line in data.split('\n').map(|s| s.to_string()).collect::<Vec<String>>() {
            let keep = self.tokenize(&self.make_alpha(&line));

            for token in keep {
                self.tokens.push(token);
            }

            self.tokens.push("\n".to_string());
        }

        for token in &self.tokens {
            if token.is_empty() { continue; }

            if self.is_comment {
                if !token.ends_with('\n') {
                    generated.push_str(&self.highlight.comment(token));

                    continue;
                }

                self.is_comment = false;
            }

            if self.is_data {
                generated.push_str(&self.highlight.var_data(token));

                if !token.ends_with(self.highlight.data.builtins[VariableData as usize]
                    .chars().next().unwrap()) {
                    continue;
                }

                self.is_data = false;

                continue;
            }

            if token == &self.highlight.data.builtins[SingleLineComment as usize] {
                self.is_comment = true;

                generated.push_str(&self.highlight.comment(token));

                continue;
            }

            if token.starts_with(self.highlight.data.builtins[VariableData as usize]
                .chars().next().unwrap())
                || token.ends_with(self.highlight.data.builtins[VariableData as usize]
                .chars().next().unwrap()) {
                self.is_data = true;

                generated.push_str(format!("{} ", self.highlight.var_data(token)).as_str());

                continue;
            }

            generated.push_str(self.highlight.colorize(&token).as_str());
        }

        generated
    }

    pub fn tokenize(&self, data: &String) -> Vec<String> {
        data.split(' ').map(|s| s.to_string()).collect()
    }

    pub fn make_alpha(&self, data: &String) -> String {
        let mut temporary = String::from(data);

        for character in parse::TOKENS {
            temporary = self.replace_with(&temporary, *character);
        }

        temporary
    }

    pub fn replace_with(&self, token: &String, character: char) -> String {
        token.replace(character, format!(" {} ", character).as_str()).to_string()
    }
}