@devaloop/devalang 0.0.1-alpha.5 → 0.0.1-alpha.8

package/rust/core/debugger/store.rs

@@ -0,0 +1,25 @@
+use std::{ collections::HashMap, fs::create_dir_all };
+use crate::core::{ debugger::Debugger, preprocessor::module::Module };
+
+pub fn write_store_log_file(output_dir: &str, file_name: &str, modules: HashMap<String, Module>) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
+
+    let log_directory = format!("{}/logs", output_dir);
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (path, module) in modules {
+        content.push_str(&format!("--- Module: {} ---\n", path));
+
+        for (index, var_value) in module.variable_table.variables.iter().enumerate() {
+            let var_name = var_value.0.clone();
+            let var_data = var_value.1;
+
+            content.push_str(&format!("{}: {:?} = {:?}\n", index + 1, var_name, var_data));
+        }
+
+        content.push_str("\n");
+    }
+
+    debugger.write_log_file(&log_directory, file_name, &content);
+}

package/rust/core/error/mod.rs

@@ -1,4 +1,4 @@
-use crate::core::parser::{ statement::{ Statement, StatementKind }, Parser };
+use crate::core::parser::{ statement::{ Statement, StatementKind }, driver::Parser };
 
 pub struct ErrorHandler {
     errors: Vec<Error>,

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

@@ -0,0 +1,215 @@
+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, identifier::handle_identifier_lexer, indent::handle_indent_lexer, newline::handle_newline_lexer, number::handle_number_lexer, operator::handle_operator_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' {
+        // Do not increment column on newline here
+    } else {
+        *column += 1;
+    }
+    Some(c)
+}
+
+pub fn handle_content_lexing(content: String) -> Result<Vec<Token>, String> {
+    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_operator_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
+    //     );
+    // }
+
+    Ok(tokens)
+}

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

@@ -22,6 +22,8 @@ pub fn handle_identifier_lexer(
     }
 
     let kind = match ident.as_str() {
+        "if" => TokenKind::If,
+        "else" => TokenKind::Else,
         "bank" => TokenKind::Bank,
         "bpm" => TokenKind::Tempo,
         "loop" => TokenKind::Loop,

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

@@ -17,7 +17,7 @@ pub fn handle_indent_lexer(
             chars.next();
             col += 1;
         } else if c == '\t' {
-            *current_indent += 4; // tabulation = 4 espaces
+            *current_indent += 4;
             chars.next();
             col += 4;
         } else {

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

@@ -1,238 +1,13 @@
+pub mod driver;
+
 pub mod at;
 pub mod brace;
 pub mod colon;
 pub mod comment;
 pub mod dot;
-pub mod equal;
+pub mod operator;
 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) -> Result<Vec<Token>, String> {
-    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
-    //     );
-    // }
-
-    Ok(tokens)
-}

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

@@ -0,0 +1,44 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_operator_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 next = chars.peek().copied();
+
+    let (kind, len) = match (ch, next) {
+        ('=', Some('=')) => (TokenKind::DoubleEquals, 2),
+        ('!', Some('=')) => (TokenKind::NotEquals, 2),
+        ('>', Some('=')) => (TokenKind::GreaterEqual, 2),
+        ('<', Some('=')) => (TokenKind::LessEqual, 2),
+        ('=', _) => (TokenKind::Equals, 1),
+        ('>', _) => (TokenKind::Greater, 1),
+        ('<', _) => (TokenKind::Less, 1),
+        _ => {
+            return;
+        }
+    };
+
+    if len == 2 {
+        chars.next(); // consume second char
+    }
+
+    tokens.push(Token {
+        kind,
+        lexeme: if len == 2 {
+            format!("{}{}", ch, next.unwrap())
+        } else {
+            ch.to_string()
+        },
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += len;
+}

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

@@ -1,4 +1,4 @@
-use crate::core::lexer::token::{Token, TokenKind};
+use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_string_lexer(
     ch: char,
@@ -11,23 +11,20 @@ pub fn handle_string_lexer(
 ) {
     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
+            chars.next();
             *column += 1;
             break;
         } else if next_ch == '\\' {
-            chars.next(); // Consomme '\'
+            chars.next();
             *column += 1;
 
             if let Some(escaped) = chars.next() {

package/rust/core/lexer/mod.rs

@@ -3,7 +3,7 @@ pub mod token;
 
 use std::fs;
 use crate::core::{
-    lexer::{ handler::handle_content_lexing, token::Token },
+    lexer::{ handler::driver::handle_content_lexing, token::Token },
     utils::path::normalize_path,
 };
 

package/rust/core/lexer/token.rs

@@ -24,31 +24,58 @@ impl Token {
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub enum TokenKind {
+    // ───── Keywords ─────
     At,
     Tempo,
     Bank,
     Loop,
+
+    // ───── Literals ─────
     Identifier,
-    Map,
-    Array,
     Number,
     String,
     Boolean,
+
+    // ───── Structures ─────
+    Map,
+    Array,
+
+    // ───── Symbols ─────
     Colon,
     Comma,
     Equals,
-    DoubleEquals,
     Dot,
-    LBrace,
-    RBrace,
-    DbQuote,
-    Quote,
-    LBracket,
-    RBracket,
+
+    // ───── Operators ─────
+    DoubleEquals,
+    NotEquals,
+    GreaterEqual,
+    LessEqual,
+    Greater,
+    Less,
+
+    // ───── Brackets ─────
+    LBrace, // {
+    RBrace, // }
+    LBracket, // [
+    RBracket, // ]
+
+    // ───── Quotes ─────
+    Quote, // '
+    DbQuote, // "
+
+    // ───── Formatting ─────
     Newline,
     Indent,
     Dedent,
     Comment,
+
+    // ───── Conditions ─────
+    If,
+    Else,
+    ElseIf,
+
+    // ───── Special / Internal ─────
     Unknown,
     Error(String),
     EOF,

package/rust/core/mod.rs

@@ -6,4 +6,5 @@ pub mod shared;
 pub mod debugger;
 pub mod utils;
 pub mod builder;
-pub mod error;
+pub mod error;
+pub mod audio;