devalang_core/core/parser/driver/
driver_impl.rs

1use crate::core::lexer::token::TokenKind;
2use crate::core::store::global::GlobalStore;
3use devalang_types::Value;
4
5pub fn parse_tokens_impl(
6    parser: &mut crate::core::parser::driver::parser::Parser,
7    tokens: Vec<crate::core::lexer::token::Token>,
8    global_store: &mut GlobalStore,
9) -> Vec<crate::core::parser::statement::Statement> {
10    // Filter out Whitespace tokens but keep Newline tokens because some constructs (e.g., print ...)
11    // rely on end-of-line semantics.
12    parser.tokens = tokens
13        .into_iter()
14        .filter(|t| t.kind != TokenKind::Whitespace)
15        .collect();
16    parser.token_index = 0;
17
18    let mut statements = Vec::new();
19
20    while !crate::core::parser::driver::cursor::is_eof_impl(parser) {
21        let token = match crate::core::parser::driver::cursor::peek_impl(parser) {
22            Some(t) => t.clone(),
23            None => {
24                break;
25            }
26        };
27
28        if token.kind == TokenKind::Newline {
29            crate::core::parser::driver::cursor::advance_impl(parser);
30            continue;
31        }
32
33        let statement = match &token.kind {
34            TokenKind::At => crate::core::parser::handler::at::parse_at_token(parser, global_store),
35            TokenKind::Identifier => {
36                if
37                    let Some(next) = crate::core::parser::driver::cursor
38                        ::peek_nth_impl(parser, 1)
39                        .cloned()
40                {
41                    if next.kind == TokenKind::Arrow {
42                        crate::core::parser::handler::arrow_call::parse_arrow_call(
43                            parser,
44                            global_store
45                        )
46                    } else {
47                        crate::core::parser::handler::identifier::parse_identifier_token(
48                            parser,
49                            global_store
50                        )
51                    }
52                } else {
53                    crate::core::parser::handler::identifier::parse_identifier_token(
54                        parser,
55                        global_store
56                    )
57                }
58            }
59            TokenKind::Dot =>
60                crate::core::parser::handler::dot::parse_dot_token(parser, global_store),
61            TokenKind::Tempo =>
62                crate::core::parser::handler::tempo::parse_tempo_token(parser, global_store),
63            TokenKind::Bank =>
64                crate::core::parser::handler::bank::parse_bank_token(parser, global_store),
65            TokenKind::Pattern =>
66                crate::core::parser::handler::pattern::parse_pattern_token(parser, global_store),
67            TokenKind::Loop =>
68                crate::core::parser::handler::loop_::parse_loop_token(parser, global_store),
69            TokenKind::If =>
70                crate::core::parser::handler::condition::parse_condition_token(
71                    parser,
72                    global_store
73                ),
74            TokenKind::Function =>
75                crate::core::parser::handler::identifier::function::parse_function_token(
76                    parser,
77                    global_store
78                ),
79            TokenKind::On =>
80                crate::core::parser::handler::identifier::on::parse_on_token(parser, global_store),
81            TokenKind::Emit =>
82                crate::core::parser::handler::identifier::emit::parse_emit_token(
83                    parser,
84                    token.clone(),
85                    global_store
86                ),
87
88            | TokenKind::Else // Ignore else, already handled in `parse_condition_token`
89            | TokenKind::Comment
90            | TokenKind::Equals
91            | TokenKind::Colon
92            | TokenKind::Number
93            | TokenKind::String
94            | TokenKind::LBrace
95            | TokenKind::RBrace
96            | TokenKind::Comma
97            | TokenKind::Dedent
98            | TokenKind::Indent => {
99                crate::core::parser::driver::cursor::advance_impl(parser);
100                continue;
101            }
102
103            TokenKind::EOF => {
104                break;
105            }
106
107            _ => {
108                crate::core::parser::driver::cursor::advance_impl(parser);
109                crate::core::parser::statement::Statement::unknown_with_pos(
110                    token.indent,
111                    token.line,
112                    token.column
113                )
114            }
115        };
116
117        statements.push(statement);
118    }
119
120    statements
121}
122
123pub fn parse_condition_until_colon_impl(
124    parser: &mut crate::core::parser::driver::parser::Parser,
125) -> Option<Value> {
126    let tokens =
127        crate::core::parser::driver::block::collect_until(parser, |t| t.kind == TokenKind::Colon);
128    if tokens.is_empty() {
129        return None;
130    }
131
132    let condition = tokens
133        .iter()
134        .map(|t| t.lexeme.clone())
135        .collect::<Vec<_>>()
136        .join(" ");
137
138    Some(Value::String(condition))
139}