oak_ini/parser/
mod.rs

1/// Element types and categories for the INI language.
2pub mod element_type;
3
4use crate::{
5    language::IniLanguage,
6    lexer::{IniLexer, token_type::IniTokenType},
7};
8use oak_core::{
9    TextEdit,
10    parser::{ParseCache, ParseOutput, Parser, parse_with_lexer},
11    source::Source,
12};
13
14/// INI parser state.
15pub(crate) type State<'a, S> = oak_core::parser::ParserState<'a, IniLanguage, S>;
16
17/// INI parser implementation.
18pub struct IniParser<'config> {
19    /// The INI language configuration.
20    pub(crate) config: &'config IniLanguage,
21}
22
23impl<'config> IniParser<'config> {
24    /// Creates a new `IniParser` with the given configuration.
25    pub fn new(config: &'config IniLanguage) -> Self {
26        Self { config }
27    }
28
29    /// Parses an INI table or array of tables.
30    pub(crate) fn parse_table<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), oak_core::errors::OakError> {
31        let checkpoint = state.checkpoint();
32        let kind = if state.at(IniTokenType::DoubleLeftBracket) {
33            state.expect(IniTokenType::DoubleLeftBracket)?;
34            self.parse_key(state)?;
35            state.expect(IniTokenType::DoubleRightBracket)?;
36            element_type::IniElementType::ArrayOfTables
37        }
38        else {
39            state.expect(IniTokenType::LeftBracket)?;
40            self.parse_key(state)?;
41            state.expect(IniTokenType::RightBracket)?;
42            element_type::IniElementType::Table
43        };
44
45        // Sections can have key-values following them
46        while state.not_at_end() && !state.at(IniTokenType::LeftBracket) && !state.at(IniTokenType::DoubleLeftBracket) {
47            self.skip_trivia(state);
48            if !state.not_at_end() || state.at(IniTokenType::LeftBracket) || state.at(IniTokenType::DoubleLeftBracket) {
49                break;
50            }
51            self.parse_key_value(state)?;
52        }
53
54        state.finish_at(checkpoint, kind);
55        Ok(())
56    }
57
58    /// Parses an INI key-value pair.
59    pub(crate) fn parse_key_value<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), oak_core::errors::OakError> {
60        let checkpoint = state.checkpoint();
61        self.parse_key(state)?;
62
63        self.skip_trivia(state);
64        state.expect(IniTokenType::Equal)?;
65        self.skip_trivia(state);
66
67        self.parse_value(state)?;
68
69        state.finish_at(checkpoint, element_type::IniElementType::KeyValue);
70        Ok(())
71    }
72
73    /// Parses an INI key.
74    fn parse_key<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), oak_core::errors::OakError> {
75        let checkpoint = state.checkpoint();
76        // Support dotted keys: a.b.c
77        loop {
78            if state.at(IniTokenType::Identifier) {
79                state.bump();
80            }
81            else if state.at(IniTokenType::String) {
82                state.bump();
83            }
84            else {
85                let err = oak_core::errors::OakError::expected_token("identifier or string", state.tokens.index(), state.source_id());
86                state.errors.push(err);
87                return Err(state.errors.last().unwrap().clone());
88            }
89
90            self.skip_trivia(state);
91            if state.at(IniTokenType::Dot) {
92                state.bump();
93                self.skip_trivia(state);
94            }
95            else {
96                break;
97            }
98        }
99        state.finish_at(checkpoint, element_type::IniElementType::Key);
100        Ok(())
101    }
102
103    /// Parses an INI value.
104    fn parse_value<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), oak_core::errors::OakError> {
105        let checkpoint = state.checkpoint();
106        let kind = state.peek_kind().ok_or_else(|| {
107            let err = oak_core::errors::OakError::unexpected_eof(state.tokens.index(), state.source_id());
108            state.errors.push(err);
109            state.errors.last().unwrap().clone()
110        })?;
111
112        match kind {
113            IniTokenType::Identifier | IniTokenType::String | IniTokenType::Integer | IniTokenType::Float | IniTokenType::Boolean | IniTokenType::DateTime => {
114                state.bump();
115            }
116            IniTokenType::LeftBracket => {
117                self.parse_array(state)?;
118            }
119            IniTokenType::LeftBrace => {
120                self.parse_inline_table(state)?;
121            }
122            _ => {
123                let err = oak_core::errors::OakError::expected_token("value", state.tokens.index(), state.source_id());
124                state.errors.push(err);
125                return Err(state.errors.last().unwrap().clone());
126            }
127        }
128
129        state.finish_at(checkpoint, element_type::IniElementType::Value);
130        Ok(())
131    }
132
133    /// Parses an INI array.
134    fn parse_array<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), oak_core::errors::OakError> {
135        let checkpoint = state.checkpoint();
136        state.expect(IniTokenType::LeftBracket)?;
137        self.skip_trivia(state);
138
139        while state.not_at_end() && !state.at(IniTokenType::RightBracket) {
140            self.parse_value(state)?;
141            self.skip_trivia(state);
142            if state.at(IniTokenType::Comma) {
143                state.bump();
144                self.skip_trivia(state);
145            }
146        }
147
148        state.expect(IniTokenType::RightBracket)?;
149        state.finish_at(checkpoint, element_type::IniElementType::Array);
150        Ok(())
151    }
152
153    /// Parses an INI inline table.
154    fn parse_inline_table<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), oak_core::errors::OakError> {
155        let checkpoint = state.checkpoint();
156        state.expect(IniTokenType::LeftBrace)?;
157        self.skip_trivia(state);
158
159        while state.not_at_end() && !state.at(IniTokenType::RightBrace) {
160            self.parse_key_value(state)?;
161            self.skip_trivia(state);
162            if state.at(IniTokenType::Comma) {
163                state.bump();
164                self.skip_trivia(state);
165            }
166        }
167
168        state.expect(IniTokenType::RightBrace)?;
169        state.finish_at(checkpoint, element_type::IniElementType::InlineTable);
170        Ok(())
171    }
172
173    /// Skips trivia (whitespace, newlines, comments).
174    fn skip_trivia<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) {
175        while state.not_at_end() {
176            let kind = match state.peek_kind() {
177                Some(k) => k,
178                None => break,
179            };
180
181            if kind == IniTokenType::Whitespace || kind == IniTokenType::Newline || kind == IniTokenType::Comment {
182                state.bump();
183            }
184            else {
185                break;
186            }
187        }
188    }
189}
190
191impl<'config> Parser<IniLanguage> for IniParser<'config> {
192    fn parse<'a, S: Source + ?Sized>(&self, text: &'a S, edits: &[TextEdit], cache: &'a mut impl ParseCache<IniLanguage>) -> ParseOutput<'a, IniLanguage> {
193        let lexer = IniLexer::new(self.config);
194        parse_with_lexer(&lexer, text, edits, cache, |state| {
195            let checkpoint = state.checkpoint();
196            while state.not_at_end() {
197                self.skip_trivia(state);
198                if !state.not_at_end() {
199                    break;
200                }
201
202                if state.at(IniTokenType::LeftBracket) || state.at(IniTokenType::DoubleLeftBracket) { self.parse_table(state)? } else { self.parse_key_value(state)? }
203            }
204
205            Ok(state.finish_at(checkpoint, element_type::IniElementType::Root))
206        })
207    }
208}
oak_ini/parser/mod.rs

oak_ini/parser/
mod.rs
