@devaloop/devalang 0.0.1-alpha.12 → 0.0.1-alpha.14

package/rust/core/audio/renderer.rs

@@ -1,5 +1,4 @@
 use std::collections::HashMap;
-
 use crate::{
     core::{
         audio::{ engine::AudioEngine, interpreter::driver::run_audio_program },
@@ -18,36 +17,36 @@ pub fn render_audio_with_modules(
 
     for (module_name, statements) in modules {
         let mut global_max_end_time: f32 = 0.0;
-        let mut initial_engine = AudioEngine::new(module_name.clone());
+        let mut audio_engine = AudioEngine::new(module_name.clone());
 
         // Apply global variables to the initial engine
         if let Some(module) = global_store.get_module(&module_name) {
-            initial_engine.set_variables(module.variable_table.clone());
-        }
-
-        // interprete statements to fill the audio buffer
-        let (mut updated_engine, _bpm, module_max_end_time) = run_audio_program(
-            &statements,
-            initial_engine,
-            module_name.clone(),
-            output_dir.to_string()
-        );
-
-        // Verify if the buffer is silent (all samples are zero)
-        if updated_engine.buffer.iter().all(|&s| s == 0) {
-            let logger = Logger::new();
-            logger.log_message(
-                LogLevel::Warning,
-                &format!("Module '{}' ignored: silent buffer (no non-zero samples)", module_name)
+            // interprete statements to fill the audio buffer
+            let (module_max_end_time, cursor_time) = run_audio_program(
+                &statements,
+                &mut audio_engine,
+                module_name.clone(),
+                output_dir.to_string(),
+                module.variable_table.clone(),
+                module.function_table.clone(),
+                global_store
             );
-            continue;
-        }
 
-        // Determines the maximum end time for the module
-        global_max_end_time = global_max_end_time.max(module_max_end_time);
-        updated_engine.set_duration(global_max_end_time);
+            // Verify if the buffer is silent (all samples are zero)
+            if audio_engine.buffer.iter().all(|&s| s == 0) {
+                let logger = Logger::new();
+                logger.log_message(
+                    LogLevel::Warning,
+                    &format!("Module '{}' ignored: silent buffer (no non-zero samples)", module_name)
+                );
+            }
+
+            // Determines the maximum end time for the module
+            global_max_end_time = global_max_end_time.max(module_max_end_time);
+            audio_engine.set_duration(global_max_end_time);
 
-        result.insert(module_name, updated_engine);
+            result.insert(module_name, audio_engine);
+        }
     }
 
     result

package/rust/core/builder/mod.rs

@@ -3,7 +3,6 @@ use crate::core::parser::statement::Statement;
 use crate::core::store::global::GlobalStore;
 use std::{ collections::HashMap, fs::create_dir_all };
 use std::io::Write;
-
 use crate::utils::logger::Logger;
 
 pub struct Builder {}
@@ -13,7 +12,12 @@ impl Builder {
         Builder {}
     }
 
-    pub fn build_ast(&self, modules: &HashMap<String, Vec<Statement>>, out_dir: &str) {
+    pub fn build_ast(
+        &self,
+        modules: &HashMap<String, Vec<Statement>>,
+        out_dir: &str,
+        compress: bool
+    ) {
         for (name, statements) in modules {
             let formatted_name = name.split("/").last().unwrap_or(name);
             let formatted_name = formatted_name.replace(".deva", "");
@@ -22,10 +26,11 @@ impl Builder {
 
             let file_path = format!("{}/ast/{}.json", out_dir, formatted_name);
             let mut file = std::fs::File::create(file_path).expect("Failed to create AST file");
-
-            let content = serde_json
-                ::to_string_pretty(&statements)
-                .expect("Failed to serialize AST");
+            let content = if compress {
+                serde_json::to_string(&statements).expect("Failed to serialize AST")
+            } else {
+                serde_json::to_string_pretty(&statements).expect("Failed to serialize AST")
+            };
 
             file.write_all(content.as_bytes()).expect("Failed to write AST to file");
         }

package/rust/core/debugger/mod.rs

@@ -1,6 +1,7 @@
 pub mod preprocessor;
 pub mod lexer;
 pub mod store;
+pub mod module;
 
 use std::io::Write;
 
@@ -13,6 +14,7 @@ impl Debugger {
 
     pub fn write_log_file(&self, path: &str, filename: &str, content: &str) {
         std::fs::create_dir_all(path).expect("Failed to create directory");
+
         let file_path = format!("{}/{}", path, filename);
         let mut file = std::fs::File::create(file_path).expect("Failed to create file");
 

package/rust/core/debugger/module.rs

@@ -0,0 +1,47 @@
+use std::{ fs::create_dir_all };
+use crate::core::{
+    debugger::Debugger,
+    store::{ function::FunctionTable, variable::VariableTable },
+};
+
+pub fn write_module_variable_log_file(
+    output_dir: &str,
+    module_path: &str,
+    variable_table: &VariableTable
+) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
+    let module_name = module_path.split('/').last().unwrap_or("index").replace(".deva", "");
+
+    let log_directory = format!("{}/logs/modules/{}", output_dir, module_name);
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (var_name, var_data) in &variable_table.variables {
+        content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
+    }
+
+    content.push_str("\n");
+
+    debugger.write_log_file(&log_directory, "variables.log", &content);
+}
+
+pub fn write_module_function_log_file(
+    output_dir: &str,
+    module_path: &str,
+    function_table: &FunctionTable
+) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
+    let module_name = module_path.split('/').last().unwrap_or("index").replace(".deva", "");
+
+    let log_directory = format!("{}/logs/modules/{}", output_dir, module_name);
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (func_name, func_data) in &function_table.functions {
+        content.push_str(&format!("{:?} = {:?}\n", func_name, func_data));
+    }
+
+    content.push_str("\n");
+
+    debugger.write_log_file(&log_directory, "functions.log", &content);
+}

package/rust/core/debugger/store.rs

@@ -1,25 +1,39 @@
-use std::{ collections::HashMap, fs::create_dir_all };
-use crate::core::{ debugger::Debugger, preprocessor::module::Module };
+use std::{ fs::create_dir_all };
+use crate::core::{
+    debugger::Debugger,
+    store::{ function::FunctionTable, variable::VariableTable },
+};
 
-pub fn write_store_log_file(output_dir: &str, file_name: &str, modules: HashMap<String, Module>) {
+pub fn write_variables_log_file(output_dir: &str, file_name: &str, variables: VariableTable) {
     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 (var_name, var_data) in variables.variables {
+        content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
+    }
+
+    content.push_str("\n");
+
+    debugger.write_log_file(&log_directory, file_name, &content);
+}
 
-        for (index, var_value) in module.variable_table.variables.iter().enumerate() {
-            let var_name = var_value.0.clone();
-            let var_data = var_value.1;
+pub fn write_function_log_file(output_dir: &str, file_name: &str, functions: FunctionTable) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
 
-            content.push_str(&format!("{}: {:?} = {:?}\n", index + 1, var_name, var_data));
-        }
+    let log_directory = format!("{}/logs", output_dir);
+    create_dir_all(&log_directory).expect("Failed to create log directory");
 
-        content.push_str("\n");
+    for (index, function) in functions.functions {
+        content.push_str(
+            &format!("'{}' = [{:?}] => {:?}\n", function.name, function.parameters, function.body)
+        );
     }
 
+    content.push_str("\n");
+
     debugger.write_log_file(&log_directory, file_name, &content);
 }

package/rust/core/error/mod.rs

@@ -4,6 +4,12 @@ pub struct ErrorHandler {
     errors: Vec<Error>,
 }
 
+pub struct ErrorResult {
+    pub message: String,
+    pub line: usize,
+    pub column: usize,
+}
+
 pub struct Error {
     pub message: String,
     pub line: usize,

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

@@ -1,6 +1,6 @@
 use crate::core::lexer::{
     handler::{
-        arrow::handle_arrow_lexer, 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, slash::handle_slash_lexer, string::handle_string_lexer
+        arrow::handle_arrow_lexer, 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, parenthesis::{handle_lparen_lexer, handle_rparen_lexer}, slash::handle_slash_lexer, string::handle_string_lexer
     },
     token::{ Token, TokenKind },
 };
@@ -145,6 +145,28 @@ pub fn handle_content_lexing(content: String) -> Result<Vec<Token>, String> {
                     &mut column
                 );
             }
+            '(' => {
+                handle_lparen_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            ')' => {
+                handle_rparen_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
             '.' => {
                 handle_dot_lexer(
                     ch,

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

@@ -28,6 +28,7 @@ pub fn handle_identifier_lexer(
         "bpm" => TokenKind::Tempo,
         "loop" => TokenKind::Loop,
         "synth" => TokenKind::Synth,
+        "fn" => TokenKind::Function,
         _ => TokenKind::Identifier,
     };
 

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

@@ -16,10 +16,24 @@ pub fn handle_indent_lexer(
             *current_indent += 1;
             chars.next();
             col += 1;
+            tokens.push(Token {
+                kind: TokenKind::Whitespace,
+                lexeme: " ".to_string(),
+                line: *line,
+                column: col,
+                indent: *current_indent,
+            });
         } else if c == '\t' {
             *current_indent += 4;
             chars.next();
             col += 4;
+            tokens.push(Token {
+                kind: TokenKind::Whitespace,
+                lexeme: "\t".to_string(),
+                line: *line,
+                column: col,
+                indent: *current_indent,
+            });
         } else {
             break;
         }
@@ -32,7 +46,7 @@ pub fn handle_indent_lexer(
         indent_stack.push(*current_indent);
         tokens.push(Token {
             kind: TokenKind::Indent,
-            lexeme: String::new(),
+            lexeme: String::from("<INDENT>"),
             line: *line,
             column: *column,
             indent: *current_indent,
@@ -42,7 +56,7 @@ pub fn handle_indent_lexer(
             indent_stack.pop();
             tokens.push(Token {
                 kind: TokenKind::Dedent,
-                lexeme: String::new(),
+                lexeme: String::from("<DEDENT>"),
                 line: *line,
                 column: *column,
                 indent: *current_indent,

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

@@ -13,3 +13,4 @@ pub mod indent;
 pub mod string;
 pub mod arrow;
 pub mod slash;
+pub mod parenthesis;

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

@@ -0,0 +1,41 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_rparen_lexer(
+    char: 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
+) {
+    tokens.push(Token {
+        kind: TokenKind::RParen,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}
+
+pub fn handle_lparen_lexer(
+    char: 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
+) {
+    tokens.push(Token {
+        kind: TokenKind::LParen,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}

package/rust/core/lexer/token.rs

@@ -29,6 +29,7 @@ pub enum TokenKind {
     Tempo,
     Bank,
     Loop,
+    Function,
 
     // ───── Instruments ─────
     Synth,
@@ -64,6 +65,8 @@ pub enum TokenKind {
     RBrace, // }
     LBracket, // [
     RBracket, // ]
+    LParen, // (
+    RParen, // )
 
     // ───── Quotes ─────
     Quote, // '
@@ -81,6 +84,7 @@ pub enum TokenKind {
     ElseIf,
 
     // ───── Special / Internal ─────
+    Whitespace,
     Unknown,
     Error(String),
     EOF,

package/rust/core/mod.rs

@@ -7,4 +7,5 @@ pub mod debugger;
 pub mod utils;
 pub mod builder;
 pub mod error;
-pub mod audio;
+pub mod audio;
+pub mod plugin;

package/rust/core/parser/driver.rs

@@ -7,7 +7,7 @@ use crate::core::{
             bank::parse_bank_token,
             condition::parse_condition_token,
             dot::parse_dot_token,
-            identifier::parse_identifier_token,
+            identifier::{ function::parse_function_token, parse_identifier_token },
             loop_::parse_loop_token,
             tempo::parse_tempo_token,
         },
@@ -107,7 +107,11 @@ impl Parser {
         tokens: Vec<Token>,
         global_store: &mut GlobalStore
     ) -> Vec<Statement> {
-        self.tokens = tokens;
+        // Filtrer les tokens Whitespace et Newline avant parsing
+        self.tokens = tokens
+            .into_iter()
+            .filter(|t| t.kind != TokenKind::Whitespace && t.kind != TokenKind::Newline)
+            .collect();
         self.token_index = 0;
 
         let mut statements = Vec::new();
@@ -120,6 +124,11 @@ impl Parser {
                 }
             };
 
+            if token.kind == TokenKind::Newline {
+                self.advance();
+                continue;
+            }
+
             let statement = match &token.kind {
                 TokenKind::At => parse_at_token(self, global_store),
                 TokenKind::Identifier => {
@@ -138,6 +147,7 @@ impl Parser {
                 TokenKind::Bank => parse_bank_token(self, global_store),
                 TokenKind::Loop => parse_loop_token(self, global_store),
                 TokenKind::If => parse_condition_token(self, global_store),
+                TokenKind::Function => parse_function_token(self, global_store),
 
                 | TokenKind::Else // Ignore else, already handled in `parse_condition_token`
                 | TokenKind::Comment
@@ -148,7 +158,6 @@ impl Parser {
                 | TokenKind::LBrace
                 | TokenKind::RBrace
                 | TokenKind::Comma
-                | TokenKind::Newline
                 | TokenKind::Dedent
                 | TokenKind::Indent => {
                     self.advance();
@@ -188,17 +197,50 @@ impl Parser {
         let mut map = std::collections::HashMap::new();
 
         while !self.check_token(TokenKind::RBrace) && !self.is_eof() {
+            // Skip newlines, whitespace, indent, dedent before the key
+            while
+                self.check_token(TokenKind::Newline) ||
+                self.check_token(TokenKind::Whitespace) ||
+                self.check_token(TokenKind::Indent) ||
+                self.check_token(TokenKind::Dedent)
+            {
+                self.advance();
+            }
+
+            // Check if we are at the closing brace of the map
+            if self.check_token(TokenKind::RBrace) {
+                break;
+            }
+
             let key = if let Some(token) = self.advance() {
-                token.lexeme.clone()
+                match token.kind {
+                    | TokenKind::Whitespace
+                    | TokenKind::Indent
+                    | TokenKind::Dedent
+                    | TokenKind::Newline => {
+                        continue;
+                    }
+                    _ => token.lexeme.clone(),
+                }
             } else {
                 break;
             };
 
+            // Skip newlines and whitespace before colon
+            while self.check_token(TokenKind::Newline) || self.check_token(TokenKind::Whitespace) {
+                self.advance();
+            }
+
             if !self.match_token(TokenKind::Colon) {
                 println!("Expected ':' after map key '{}'", key);
                 break;
             }
 
+            // Skip newlines and whitespace before value
+            while self.check_token(TokenKind::Newline) || self.check_token(TokenKind::Whitespace) {
+                self.advance();
+            }
+
             let value = if let Some(token) = self.peek_clone() {
                 match token.kind {
                     TokenKind::String => {
@@ -303,6 +345,7 @@ impl Parser {
             }
             collected.push(self.advance().unwrap().clone());
         }
+
         collected
     }
 

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

@@ -54,11 +54,43 @@ pub fn parse_arrow_call(parser: &mut Parser, global_store: &mut GlobalStore) ->
     parser.advance(); // method
 
     let mut args = Vec::new();
+    let mut paren_depth = 0;
+    let mut map_depth = 0;
 
     while let Some(token) = parser.peek_clone() {
         if token.kind == TokenKind::Newline || token.kind == TokenKind::EOF {
             break;
         }
+        if token.kind == TokenKind::LParen {
+            paren_depth += 1;
+        }
+        if token.kind == TokenKind::RParen {
+            if paren_depth > 0 {
+                paren_depth -= 1;
+                parser.advance();
+                if paren_depth == 0 {
+                    break;
+                }
+                continue;
+            } else {
+                break;
+            }
+        }
+        if token.kind == TokenKind::LBrace {
+            map_depth += 1;
+        }
+        if token.kind == TokenKind::RBrace {
+            if map_depth > 0 {
+                map_depth -= 1;
+                parser.advance();
+                if map_depth == 0 {
+                    continue;
+                }
+                continue;
+            } else {
+                break;
+            }
+        }
 
         parser.advance();
 
@@ -79,49 +111,68 @@ pub fn parse_arrow_call(parser: &mut Parser, global_store: &mut GlobalStore) ->
                     }
                     parser.advance(); // consume key token
                     let key = inner_token.lexeme.clone();
-
                     if let Some(colon_token) = parser.peek_clone() {
                         if colon_token.kind == TokenKind::Colon {
                             parser.advance(); // consume colon
                             if let Some(value_token) = parser.peek_clone() {
                                 parser.advance(); // consume value token
                                 let value = match value_token.kind {
-                                    TokenKind::Identifier =>
-                                        Value::Identifier(value_token.lexeme.clone()),
+                                    TokenKind::Identifier => {
+                                        // Interpret bare true/false as booleans
+                                        if value_token.lexeme == "true" {
+                                            Value::Boolean(true)
+                                        } else if value_token.lexeme == "false" {
+                                            Value::Boolean(false)
+                                        } else {
+                                            Value::Identifier(value_token.lexeme.clone())
+                                        }
+                                    },
                                     TokenKind::String => Value::String(value_token.lexeme.clone()),
                                     TokenKind::Number => {
+                                        // Support decimals (e.g., 0.8) and beats (e.g., 1/4)
                                         if let Some(TokenKind::Slash) = parser.peek_kind() {
-                                            parser.advance(); // consume slash
+                                            // Beat fraction
+                                            parser.advance(); // consume '/'
                                             if let Some(denominator_token) = parser.peek_clone() {
                                                 if denominator_token.kind == TokenKind::Number {
                                                     parser.advance(); // consume denominator
-                                                    let denominator =
-                                                        denominator_token.lexeme.clone();
-                                                    Value::Beat(
-                                                        format!(
-                                                            "{}/{}",
-                                                            value_token.lexeme,
-                                                            denominator
-                                                        )
-                                                    )
+                                                    let denominator = denominator_token.lexeme.clone();
+                                                    Value::Beat(format!("{}/{}", value_token.lexeme, denominator))
                                                 } else {
                                                     Value::Unknown
                                                 }
                                             } else {
                                                 Value::Unknown
                                             }
+                                        } else if let Some(next) = parser.peek_clone() {
+                                            // Decimal number handling: NUMBER '.' NUMBER -> f32
+                                            if next.kind == TokenKind::Dot {
+                                                // consume '.'
+                                                parser.advance();
+                                                if let Some(after_dot) = parser.peek_clone() {
+                                                    if after_dot.kind == TokenKind::Number {
+                                                        parser.advance(); // consume fractional digits
+                                                        let combined = format!("{}.{}", value_token.lexeme, after_dot.lexeme);
+                                                        Value::Number(combined.parse::<f32>().unwrap_or(0.0))
+                                                    } else {
+                                                        // Lone dot without number, fallback to integer part
+                                                        Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0))
+                                                    }
+                                                } else {
+                                                    Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0))
+                                                }
+                                            } else {
+                                                // Regular integer number
+                                                Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0))
+                                            }
                                         } else {
-                                            // Regular number without slash
-                                            Value::Number(
-                                                value_token.lexeme.parse::<f32>().unwrap_or(0.0)
-                                            )
+                                            Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0))
                                         }
                                     }
                                     TokenKind::Boolean =>
                                         Value::Boolean(
                                             value_token.lexeme.parse::<bool>().unwrap_or(false)
                                         ),
-
                                     _ => Value::Unknown,
                                 };
                                 map.insert(key, value);
@@ -135,6 +186,15 @@ pub fn parse_arrow_call(parser: &mut Parser, global_store: &mut GlobalStore) ->
         };
 
         args.push(value);
+
+        // Stop if we reach the end of the statement
+        if
+            paren_depth == 0 &&
+            map_depth == 0 &&
+            (token.kind == TokenKind::RParen || token.kind == TokenKind::RBrace)
+        {
+            break;
+        }
     }
 
     Statement {