@devaloop/devalang 0.0.1-alpha.2 → 0.0.1-alpha.3

package/rust/core/lexer/handler/mod.rs

@@ -0,0 +1,238 @@
+pub mod at;
+pub mod brace;
+pub mod colon;
+pub mod comment;
+pub mod dot;
+pub mod equal;
+pub mod identifier;
+pub mod newline;
+pub mod number;
+pub mod indent;
+pub mod string;
+
+use crate::core::lexer::{
+    handler::{
+        at::handle_at_lexer,
+        brace::{ handle_lbrace_lexer, handle_rbrace_lexer },
+        colon::handle_colon_lexer,
+        comment::handle_comment_lexer,
+        dot::handle_dot_lexer,
+        equal::handle_equal_lexer,
+        identifier::handle_identifier_lexer,
+        indent::handle_indent_lexer,
+        newline::handle_newline_lexer,
+        number::handle_number_lexer,
+        string::handle_string_lexer,
+    },
+    token::{ Token, TokenKind },
+};
+
+fn advance_char<I: Iterator<Item = char>>(
+    chars: &mut std::iter::Peekable<I>,
+    line: &mut usize,
+    column: &mut usize
+) -> Option<char> {
+    let c = chars.next()?;
+    if c == '\n' {
+        *line += 1;
+        *column = 1;
+    } else {
+        *column += 1;
+    }
+    Some(c)
+}
+
+pub fn handle_content_lexing(content: String) -> Vec<Token> {
+    let mut tokens = Vec::new();
+
+    let mut line = 1;
+    let mut column = 1;
+
+    let mut indent_stack: Vec<usize> = vec![0];
+    let mut current_indent = 0;
+    let mut at_line_start = true;
+
+    let mut chars = content.chars().peekable();
+
+    while chars.peek().is_some() {
+        if at_line_start {
+            handle_indent_lexer(
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            at_line_start = false;
+        }
+
+        let Some(ch) = advance_char(&mut chars, &mut line, &mut column) else {
+            break;
+        };
+
+        match ch {
+            '\n' => {
+                handle_newline_lexer(
+                    ch,
+                    &mut chars,
+                    &mut tokens,
+                    &mut line,
+                    &mut column,
+                    &mut at_line_start,
+                    &mut current_indent
+                );
+            }
+            ' ' | '\t' => {
+                // Already handled by indent_lexer
+            }
+            '#' => {
+                handle_comment_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            ':' => {
+                handle_colon_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '=' => {
+                handle_equal_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '{' => {
+                handle_lbrace_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '}' => {
+                handle_rbrace_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '.' => {
+                handle_dot_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '@' => {
+                handle_at_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '\"' | '\'' => {
+                handle_string_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            c if c.is_ascii_digit() => {
+                handle_number_lexer(
+                    c,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            c if c.is_ascii_alphabetic() => {
+                handle_identifier_lexer(
+                    c,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            _ => {
+                // Ignore unknown char
+            }
+        }
+    }
+
+    while indent_stack.len() > 1 {
+        indent_stack.pop();
+        current_indent = *indent_stack.last().unwrap();
+        tokens.push(Token {
+            kind: TokenKind::Dedent,
+            lexeme: String::new(),
+            line,
+            column,
+            indent: current_indent,
+        });
+    }
+
+    tokens.push(Token {
+        kind: TokenKind::EOF,
+        lexeme: String::new(),
+        line: line + 1,
+        column: 0,
+        indent: 0,
+    });
+
+    // NOTE: Debug only
+    // for token in &tokens {
+    //     println!(
+    //         "{:?} @ line {}, col {}, indent {}",
+    //         token.kind,
+    //         token.line,
+    //         token.column,
+    //         token.indent
+    //     );
+    // }
+
+    tokens
+}

package/rust/core/lexer/{newline.rs → handler/newline.rs}

@@ -1,23 +1,19 @@
-use crate::core::types::token::{Token, TokenKind};
+use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_newline_lexer(
-    char: char,
+    ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,
     at_line_start: &mut bool,
-    current_indent: &mut usize,
+    current_indent: &mut usize
 ) {
     tokens.push(Token {
         kind: TokenKind::Newline,
-        lexeme: char.to_string(),
+        lexeme: ch.to_string(),
         line: *line,
-        column: *column,
-        indent: *current_indent,
+        column: 0,
+        indent: 0,
     });
-
-    *line += 1;
-    *column = 1;
-    *at_line_start = true;
 }

package/rust/core/lexer/{number.rs → handler/number.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{Token, TokenKind};
+use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_number_lexer(
     char: char,

package/rust/core/lexer/handler/string.rs

@@ -0,0 +1,66 @@
+use crate::core::lexer::token::{Token, TokenKind};
+
+pub fn handle_string_lexer(
+    ch: char,
+    chars: &mut std::iter::Peekable<std::str::Chars>,
+    current_indent: &mut usize,
+    indent_stack: &mut Vec<usize>,
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize
+) {
+    let quote_char = ch;
+
+    // Position de départ du token
+    let start_column = *column;
+    let start_line = *line;
+
+    // Consommer le guillemet ouvrant
+    chars.next();
+    *column += 1;
+
+    let mut string_content = String::new();
+
+    while let Some(&next_ch) = chars.peek() {
+        if next_ch == quote_char {
+            chars.next(); // Consomme le guillemet fermant
+            *column += 1;
+            break;
+        } else if next_ch == '\\' {
+            chars.next(); // Consomme '\'
+            *column += 1;
+
+            if let Some(escaped) = chars.next() {
+                match escaped {
+                    'n' => string_content.push('\n'),
+                    't' => string_content.push('\t'),
+                    '\\' => string_content.push('\\'),
+                    '"' => string_content.push('"'),
+                    '\'' => string_content.push('\''),
+                    other => {
+                        string_content.push('\\');
+                        string_content.push(other);
+                    }
+                }
+                *column += 1;
+            }
+        } else {
+            chars.next();
+            if next_ch == '\n' {
+                *line += 1;
+                *column = 1;
+            } else {
+                *column += 1;
+            }
+            string_content.push(next_ch);
+        }
+    }
+
+    tokens.push(Token {
+        kind: TokenKind::String,
+        lexeme: string_content,
+        indent: *current_indent,
+        line: start_line,
+        column: start_column,
+    });
+}

package/rust/core/lexer/mod.rs

@@ -1,14 +1,25 @@
-pub mod indent;
-pub mod identifier;
-pub mod number;
-pub mod at;
-pub mod dot;
-pub mod quote;
-pub mod brace;
-pub mod newline;
-pub mod comment;
-pub mod bracket;
-pub mod colon;
-pub mod equal;
-
-pub mod driver;
+pub mod handler;
+pub mod token;
+
+use std::fs;
+use crate::core::{ lexer::{ handler::handle_content_lexing, token::Token }, utils::path::normalize_path };
+
+pub struct Lexer {}
+
+impl Lexer {
+    pub fn new() -> Self {
+        Lexer {}
+    }
+
+    pub fn lex_tokens(&self, entrypoint: &str) -> Vec<Token> {
+        let path = normalize_path(entrypoint);
+
+        let file_content = fs
+            ::read_to_string(&path)
+            .expect("Failed to read the entrypoint file");
+
+        let tokens = handle_content_lexing(file_content);
+
+        tokens
+    }
+}

package/rust/core/lexer/token.rs

@@ -0,0 +1,55 @@
+use serde::{ Deserialize, Serialize };
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Token {
+    pub kind: TokenKind,
+    pub lexeme: String,
+    pub indent: usize,
+    pub line: usize,
+    pub column: usize,
+}
+
+impl Token {
+    pub fn is_error(&self) -> bool {
+        match &self.kind {
+            TokenKind::Error(_) => {
+                return true;
+            }
+            _ => {
+                return false;
+            }
+        };
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum TokenKind {
+    At,
+    Tempo,
+    Bank,
+    Loop,
+    Identifier,
+    Map,
+    Array,
+    Number,
+    String,
+    Boolean,
+    Colon,
+    Comma,
+    Equals,
+    DoubleEquals,
+    Dot,
+    LBrace,
+    RBrace,
+    DbQuote,
+    Quote,
+    LBracket,
+    RBracket,
+    Newline,
+    Indent,
+    Dedent,
+    Comment,
+    Unknown,
+    Error(String),
+    EOF,
+}

package/rust/core/mod.rs

@@ -1,6 +1,9 @@
 pub mod lexer;
-pub mod parser;
 pub mod preprocessor;
+pub mod store;
+pub mod parser;
+pub mod shared;
 pub mod debugger;
+pub mod utils;
 pub mod builder;
-pub mod types;
+pub mod error;

package/rust/core/parser/handler/at.rs

@@ -0,0 +1,166 @@
+use crate::core::{
+    lexer::token::{ Token, TokenKind },
+    parser::{
+        handler::identifier::parse_identifier_token,
+        statement::{ Statement, StatementKind },
+        Parser,
+    },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+    parser.advance(); // consume '@'
+
+    let Some(token) = parser.peek_clone() else {
+        return Statement::unknown();
+    };
+
+    let keyword = token.lexeme.as_str();
+
+    match keyword {
+        "import" => {
+            parser.advance(); // consume 'import'
+
+            if !parser.match_token(TokenKind::LBrace) {
+                return Statement::error(token, "Expected '{{' after 'import'".to_string());
+            }
+
+            let mut names = Vec::new();
+            while let Some(token) = parser.peek() {
+                match &token.kind {
+                    TokenKind::Identifier => {
+                        names.push(token.lexeme.clone());
+                        parser.advance();
+                    }
+                    TokenKind::Comma => {
+                        parser.advance();
+                    }
+                    TokenKind::RBrace => {
+                        parser.advance();
+                        break;
+                    }
+                    _ => {
+                        let message = format!(
+                            "Unexpected token in import list: {:?}",
+                            token.kind.clone()
+                        );
+                        return Statement::error(token.clone(), message);
+                    }
+                }
+            }
+
+            let Some(from_token) = parser.peek_clone() else {
+                return Statement::error(token, "Expected 'from' after import list".to_string());
+            };
+
+            if from_token.lexeme != "from" {
+                return Statement::error(token, "Expected keyword 'from'".to_string());
+            }
+
+            parser.advance(); // consume 'from'
+
+            let Some(source_token) = parser.peek() else {
+                return Statement::error(token, "Expected string after 'from'".to_string());
+            };
+
+            if source_token.kind != TokenKind::String {
+                return Statement::error(token, "Expected string after 'from'".to_string());
+            }
+
+            let source = source_token.lexeme.clone();
+            parser.advance(); // consume string
+
+            Statement {
+                kind: StatementKind::Import { names, source },
+                value: Value::Null,
+                indent: token.indent,
+                line: token.line,
+                column: token.column,
+            }
+        }
+
+        "export" => {
+            parser.advance(); // consume 'export'
+
+            parser.advance(); // consume '{'
+
+            let names_tokens = parser.collect_until(|t| TokenKind::RBrace == t.kind);
+            let mut names: Vec<String> = Vec::new();
+
+            for token in names_tokens {
+                if token.kind == TokenKind::Identifier {
+                    names.push(token.lexeme.clone());
+                } else if token.kind == TokenKind::Comma {
+                    continue; // Ignore commas
+                } else if token.kind == TokenKind::RBrace {
+                    break; // Stop at the closing brace
+                } else {
+                    return Statement::error(token, "Unexpected token in export list".to_string());
+                }
+            }
+
+            Statement {
+                kind: StatementKind::Export {
+                    names: names.clone(),
+                    source: parser.current_module.clone(),
+                },
+                value: Value::Null,
+                indent: token.indent,
+                line: token.line,
+                column: token.column,
+            }
+        }
+
+        "load" => {
+            parser.advance(); // consume 'load'
+
+            // Exemple : @load "preset.mydeva"
+            let Some(path_token) = parser.peek() else {
+                return Statement::error(token, "Expected string after 'load'".to_string());
+            };
+
+            if path_token.kind != TokenKind::String {
+                return Statement::error(token, "Expected string after 'load'".to_string());
+            }
+
+            let path = path_token.lexeme.clone();
+
+            parser.advance(); // consume string
+            parser.advance(); // consume 'as'
+
+            let Some(as_token) = parser.peek_clone() else {
+                return Statement::error(
+                    token,
+                    "Expected 'as' after path in load statement".to_string()
+                );
+            };
+
+            if as_token.kind != TokenKind::Identifier {
+                return Statement::error(
+                    token,
+                    "Expected identifier after 'as' in load statement".to_string()
+                );
+            }
+
+            let alias = as_token.lexeme.clone();
+
+            parser.advance(); // consume identifier
+
+            Statement {
+                kind: StatementKind::Load {
+                    source: path,
+                    alias,
+                },
+                value: Value::Null,
+                indent: token.indent,
+                line: token.line,
+                column: token.column,
+            }
+        }
+
+        _ => {
+            let message = format!("Unknown keyword after '@' : {}", keyword);
+            Statement::error(token, message)
+        }
+    }
+}

package/rust/core/parser/handler/bank.rs

@@ -0,0 +1,38 @@
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{ statement::{ Statement, StatementKind }, Parser },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_bank_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+    parser.advance(); // consume 'bank'
+
+    let Some(bank_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    let bank_value = if let Some(token) = parser.peek_clone() {
+        match token.kind {
+            TokenKind::Identifier => {
+                parser.advance();
+                Value::Identifier(token.lexeme.clone())
+            }
+            TokenKind::Number => {
+                parser.advance();
+                Value::Number(token.lexeme.parse::<f32>().unwrap_or(0.0))
+            }
+            _ => Value::Unknown,
+        }
+    } else {
+        return Statement::error(bank_token, "Expected identifier or number after 'bank'".to_string());
+    };
+
+    Statement {
+        kind: StatementKind::Bank,
+        value: bank_value,
+        indent: bank_token.indent,
+        line: bank_token.line,
+        column: bank_token.column,
+    }
+}