oak-lua 0.0.11

High-performance incremental Lua parser for the oak ecosystem with flexible configuration, supporting lightweight scripting and embedded development.
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

#![doc = include_str!("readme.md")]
/// Local definition of highlight kinds
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HighlightKind {
    /// Keyword
    Keyword,
    /// String
    String,
    /// Number
    Number,
    /// Comment
    Comment,
    /// Macro
    Macro,
    /// Identifier
    Identifier,
    /// Operator
    Operator,
}

/// Highlighter trait
pub trait Highlighter {
    /// Highlight the given text
    fn highlight(&self, text: &str) -> Vec<(usize, usize, HighlightKind)>;
}

/// Lua syntax highlighter
pub struct LuaHighlighter;

impl LuaHighlighter {
    /// Creates a new `LuaHighlighter`.
    pub fn new() -> Self {
        Self
    }
}

impl Highlighter for LuaHighlighter {
    fn highlight(&self, text: &str) -> Vec<(usize, usize, HighlightKind)> {
        let mut highlights = Vec::new();

        // Simple regex or lexer-based highlighting implementation
        // Here we can reuse LuaLexer to get Tokens
        use crate::lexer::{LuaLexer, token_type::LuaTokenType};
        use oak_core::{LexOutput, Lexer, LexerCache, SourceText, Token};

        struct SimpleCache {
            tokens: Vec<Token<LuaTokenType>>,
        }

        impl LexerCache<crate::language::LuaLanguage> for SimpleCache {
            fn set_lex_output(&mut self, output: LexOutput<crate::language::LuaLanguage>) {
                if let Ok(tokens) = output.result {
                    self.tokens = tokens.to_vec()
                }
            }
            fn get_token(&self, index: usize) -> Option<Token<LuaTokenType>> {
                self.tokens.get(index).cloned()
            }
            fn count_tokens(&self) -> usize {
                self.tokens.len()
            }
            fn has_tokens(&self) -> bool {
                !self.tokens.is_empty()
            }
        }

        let config = crate::language::LuaLanguage::default();
        let lexer = LuaLexer::new(&config);
        let mut cache = SimpleCache { tokens: Vec::new() };
        let source = SourceText::new(text);
        let output = lexer.lex(&source, &[], &mut cache);

        if let Ok(tokens) = output.result {
            for token in tokens.iter() {
                let kind = match token.kind {
                    LuaTokenType::And
                    | LuaTokenType::Break
                    | LuaTokenType::Do
                    | LuaTokenType::Else
                    | LuaTokenType::Elseif
                    | LuaTokenType::End
                    | LuaTokenType::False
                    | LuaTokenType::For
                    | LuaTokenType::Function
                    | LuaTokenType::Goto
                    | LuaTokenType::If
                    | LuaTokenType::In
                    | LuaTokenType::Local
                    | LuaTokenType::Nil
                    | LuaTokenType::Not
                    | LuaTokenType::Or
                    | LuaTokenType::Repeat
                    | LuaTokenType::Return
                    | LuaTokenType::Then
                    | LuaTokenType::True
                    | LuaTokenType::Until
                    | LuaTokenType::While => Some(HighlightKind::Keyword),
                    LuaTokenType::String => Some(HighlightKind::String),
                    LuaTokenType::Number => Some(HighlightKind::Number),
                    LuaTokenType::Comment => Some(HighlightKind::Comment),
                    LuaTokenType::Identifier => Some(HighlightKind::Identifier),
                    LuaTokenType::Plus
                    | LuaTokenType::Minus
                    | LuaTokenType::Star
                    | LuaTokenType::Slash
                    | LuaTokenType::Percent
                    | LuaTokenType::Caret
                    | LuaTokenType::Hash
                    | LuaTokenType::EqEq
                    | LuaTokenType::TildeEq
                    | LuaTokenType::LtEq
                    | LuaTokenType::GtEq
                    | LuaTokenType::Lt
                    | LuaTokenType::Gt
                    | LuaTokenType::Eq => Some(HighlightKind::Operator),
                    _ => None,
                };

                if let Some(h_kind) = kind {
                    highlights.push((token.span.start, token.span.end, h_kind))
                }
            }
        }

        highlights
    }
}