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

package/rust/core/audio/interpreter/driver.rs

@@ -1,3 +1,6 @@
+use rayon::prelude::*;
+use std::sync::{ Arc, Mutex };
+
 use crate::core::{
     audio::{
         engine::AudioEngine,
@@ -5,6 +8,7 @@ use crate::core::{
             arrow_call::interprete_call_arrow_statement,
             call::interprete_call_statement,
             condition::interprete_condition_statement,
+            function::interprete_function_statement,
             let_::interprete_let_statement,
             load::interprete_load_statement,
             loop_::interprete_loop_statement,
@@ -15,37 +19,26 @@ use crate::core::{
         },
     },
     parser::statement::{ Statement, StatementKind },
-    store::variable::VariableTable,
+    store::{ function::FunctionTable, global::GlobalStore, variable::VariableTable },
 };
 
 pub fn run_audio_program(
     statements: &Vec<Statement>,
-    mut audio_engine: AudioEngine,
+    audio_engine: &mut AudioEngine,
     entry: String,
-    output: String
-) -> (AudioEngine, f32, f32) {
+    output: String,
+    mut module_variables: VariableTable,
+    mut module_functions: FunctionTable,
+    global_store: &mut GlobalStore
+) -> (f32, f32) {
     let mut base_bpm = 120.0;
     let mut base_duration = 60.0 / base_bpm;
 
-    let mut variable_table = audio_engine.variables.clone();
-
-    for stmt in statements {
-        if let StatementKind::Let { .. } = stmt.kind {
-            if
-                let Some(new_table) =
-                    interprete_let_statement(
-                        stmt,
-                        &mut variable_table
-                    )
-            {
-                variable_table = new_table;
-            }
-        }
-    }
-
-    let (updated_audio_engine, base_bpm, max_end_time) = execute_audio_block(
+    let (max_end_time, cursor_time) = execute_audio_block(
         audio_engine,
-        variable_table,
+        global_store,
+        global_store.variables.clone(),
+        global_store.functions.clone(),
         statements.clone(),
         base_bpm,
         base_duration,
@@ -53,112 +46,64 @@ pub fn run_audio_program(
         0.0
     );
 
-    (updated_audio_engine, base_bpm, max_end_time)
+    (max_end_time, cursor_time)
 }
 
 pub fn execute_audio_block(
-    mut audio_engine: AudioEngine,
-    mut variable_table: VariableTable,
-    mut statements: Vec<Statement>,
+    audio_engine: &mut AudioEngine,
+    global_store: &GlobalStore,
+    variable_table: VariableTable,
+    functions_table: FunctionTable,
+    statements: Vec<Statement>,
     mut base_bpm: f32,
     mut base_duration: f32,
     mut max_end_time: f32,
     mut cursor_time: f32
-) -> (AudioEngine, f32, f32) {
-    let initial_cursor_time = cursor_time;
+) -> (f32, f32) {
+    let (spawns, others): (Vec<_>, Vec<_>) = statements
+        .into_iter()
+        .partition(|stmt| matches!(stmt.kind, StatementKind::Spawn { .. }));
 
-    for stmt in statements.clone() {
+    // Execute sequential statements first
+    for stmt in others {
         match &stmt.kind {
             StatementKind::Load { .. } => {
                 if
-                    let Some(new_variable_table) = interprete_load_statement(
+                    let Some(new_table) = interprete_load_statement(
                         &stmt,
-                        &mut variable_table
+                        &mut variable_table.clone()
                     )
                 {
-                    variable_table = new_variable_table;
-                } else {
-                    eprintln!("❌ Failed to interpret load statement: {:?}", stmt);
+                    // Extend the variable_table if necessary
                 }
             }
-
             StatementKind::Let { .. } => {
-                if
-                    let Some(new_variable_table) = interprete_let_statement(
-                        &stmt,
-                        &mut variable_table
-                    )
-                {
-                    variable_table = new_variable_table;
-                } else {
-                    eprintln!("❌ Failed to interpret let statement: {:?}", stmt);
-                }
+                interprete_let_statement(&stmt, &mut variable_table.clone());
+            }
+            StatementKind::Function { .. } => {
+                interprete_function_statement(&stmt, &mut functions_table.clone());
             }
-
             StatementKind::Tempo => {
                 if let Some((new_bpm, new_duration)) = interprete_tempo_statement(&stmt) {
                     base_bpm = new_bpm;
                     base_duration = new_duration;
-                } else {
-                    eprintln!("❌ Failed to interpret tempo statement: {:?}", stmt);
                 }
             }
-
             StatementKind::Trigger { .. } => {
                 if
-                    let Some((new_cursor_time, new_max_end_time, updated_engine)) =
-                        interprete_trigger_statement(
-                            &stmt,
-                            &mut audio_engine,
-                            &variable_table,
-                            base_duration,
-                            cursor_time,
-                            max_end_time
-                        )
-                {
-                    cursor_time = new_cursor_time;
-                    max_end_time = new_max_end_time;
-                    audio_engine = updated_engine;
-                } else {
-                    eprintln!("❌ Failed to interpret trigger statement: {:?}", stmt);
-                }
-            }
-
-            StatementKind::Spawn => {
-                let mut temp_engine = AudioEngine::new(audio_engine.module_name.clone());
-
-                if
-                    let Some((_cur, _max, updated_engine)) = interprete_spawn_statement(
+                    let Some((new_cursor, new_max, _)) = interprete_trigger_statement(
                         &stmt,
-                        temp_engine,
+                        audio_engine,
                         &variable_table,
-                        base_bpm,
                         base_duration,
-                        initial_cursor_time,
+                        cursor_time,
                         max_end_time
                     )
                 {
-                    audio_engine.merge_with(updated_engine);
+                    cursor_time = new_cursor;
+                    max_end_time = new_max;
                 }
             }
-
-            StatementKind::Call => {
-                let (call_engine, new_max, end_time, new_cursor) = interprete_call_statement(
-                    &stmt,
-                    audio_engine.clone(),
-                    variable_table.clone(),
-                    base_bpm,
-                    base_duration,
-                    max_end_time,
-                    cursor_time,
-                    &statements 
-                );
-
-                audio_engine.merge_with(call_engine);
-                cursor_time = new_cursor;
-                max_end_time = new_max;
-            }
-
             StatementKind::Sleep => {
                 let (new_cursor, new_max) = interprete_sleep_statement(
                     &stmt,
@@ -168,42 +113,40 @@ pub fn execute_audio_block(
                 cursor_time = new_cursor;
                 max_end_time = new_max;
             }
-
             StatementKind::Loop => {
-                let (loop_engine, new_max, new_cursor) = interprete_loop_statement(
+                let (new_max, new_cursor) = interprete_loop_statement(
                     &stmt,
-                    audio_engine.clone(),
-                    variable_table.clone(),
+                    audio_engine,
+                    global_store,
+                    &variable_table,
+                    &functions_table,
                     base_bpm,
                     base_duration,
                     max_end_time,
                     cursor_time
                 );
-                audio_engine = loop_engine;
                 cursor_time = new_cursor;
                 max_end_time = new_max;
             }
-
-            StatementKind::If | StatementKind::ElseIf | StatementKind::Else => {
-                let (condition_engine, new_max, new_cursor) = interprete_condition_statement(
+            StatementKind::Call { .. } => {
+                let (new_max, new_cursor) = interprete_call_statement(
                     &stmt,
-                    audio_engine.clone(),
-                    variable_table.clone(),
+                    audio_engine,
+                    &variable_table,
+                    &functions_table,
+                    global_store,
                     base_bpm,
                     base_duration,
                     max_end_time,
-                    cursor_time
+                    cursor_time,
                 );
-
-                audio_engine = condition_engine;
                 cursor_time = new_cursor;
                 max_end_time = new_max;
             }
-
             StatementKind::ArrowCall { .. } => {
-                let (new_max_end_time, new_cursor_time) = interprete_call_arrow_statement(
+                let (new_max, new_cursor) = interprete_call_arrow_statement(
                     &stmt,
-                    &mut audio_engine,
+                    audio_engine,
                     &variable_table,
                     base_bpm,
                     base_duration,
@@ -211,26 +154,40 @@ pub fn execute_audio_block(
                     Some(&mut cursor_time),
                     true
                 );
-
-                cursor_time = new_cursor_time;
-                max_end_time = new_max_end_time;
-            }
-
-            | StatementKind::Bank
-            | StatementKind::Import { .. }
-            | StatementKind::Export { .. }
-            | StatementKind::Group
-            | StatementKind::Unknown => {
-                // NOTE: Ignoring unsupported statement kinds for now.
-            }
-
-            _ => {
-                eprintln!("Unsupported audio statement kind: {:?}", stmt);
+                cursor_time = new_cursor;
+                max_end_time = new_max;
             }
+            _ => {}
         }
     }
 
-    audio_engine.set_variables(variable_table);
+    // Execute parallel spawns (collect results)
+    let spawn_results: Vec<(AudioEngine, f32)> = spawns
+        .par_iter()
+        .map(|stmt| {
+            let mut local_engine = AudioEngine::new(audio_engine.module_name.clone());
+            let (spawn_max, _) = interprete_spawn_statement(
+                stmt,
+                &mut local_engine,
+                &variable_table,
+                &functions_table,
+                global_store,
+                base_bpm,
+                base_duration,
+                0.0,
+                0.0
+            );
+            (local_engine, spawn_max)
+        })
+        .collect();
+
+    // Finally, merge results from all spawns
+    for (local_engine, spawn_max) in spawn_results {
+        audio_engine.merge_with(local_engine);
+        if spawn_max > max_end_time {
+            max_end_time = spawn_max;
+        }
+    }
 
-    (audio_engine, base_bpm, max_end_time)
+    (max_end_time.max(cursor_time), cursor_time)
 }

package/rust/core/audio/interpreter/function.rs

@@ -0,0 +1,21 @@
+use crate::core::{
+    parser::statement::{ Statement, StatementKind },
+    store::function::{ FunctionDef, FunctionTable },
+};
+
+pub fn interprete_function_statement(
+    stmt: &Statement,
+    functions_table: &mut FunctionTable
+) -> Option<FunctionTable> {
+    if let StatementKind::Function { name, parameters, body } = &stmt.kind {
+        functions_table.add_function(FunctionDef {
+            name: name.clone(),
+            parameters: parameters.clone(),
+            body: body.clone(),
+        });
+
+        return Some(functions_table.clone());
+    }
+
+    None
+}

package/rust/core/audio/interpreter/load.rs

@@ -9,7 +9,7 @@ pub fn interprete_load_statement(
     variable_table: &mut VariableTable
 ) -> Option<VariableTable> {
     if let StatementKind::Load { source, alias } = &stmt.kind {
-        variable_table.set(alias.to_string(), Value::String(source.clone()));
+        variable_table.set(alias.to_string(), Value::Sample(source.clone()));
 
         return Some(variable_table.clone());
     }

package/rust/core/audio/interpreter/loop_.rs

@@ -2,18 +2,20 @@ use crate::core::{
     audio::{ engine::AudioEngine, interpreter::driver::execute_audio_block },
     parser::statement::{ Statement, StatementKind },
     shared::{ duration::Duration, value::Value },
-    store::variable::VariableTable,
+    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
 };
 
 pub fn interprete_loop_statement(
     stmt: &Statement,
-    audio_engine: AudioEngine,
-    variable_table: VariableTable,
+    audio_engine: &mut AudioEngine,
+    global_store: &GlobalStore,
+    variable_table: &VariableTable,
+    functions_table: &FunctionTable,
     base_bpm: f32,
     base_duration: f32,
     max_end_time: f32,
     cursor_time: f32
-) -> (AudioEngine, f32, f32) {
+) -> (f32, f32) {
     if let Value::Map(loop_value) = &stmt.value {
         let loop_count = match loop_value.get("iterator") {
             Some(Value::Number(n)) => *n as usize,
@@ -22,12 +24,15 @@ pub fn interprete_loop_statement(
                     *n as usize
                 } else {
                     eprintln!("❌ Loop iterator must be a number, found: {:?}", ident);
-                    return (audio_engine, max_end_time, cursor_time);
+                    return (max_end_time, cursor_time);
                 }
             }
             _ => {
-                eprintln!("❌ Loop iterator must be a number, found: {:?}", loop_value.get("iterator"));
-                return (audio_engine, max_end_time, cursor_time);
+                eprintln!(
+                    "❌ Loop iterator must be a number, found: {:?}",
+                    loop_value.get("iterator")
+                );
+                return (max_end_time, cursor_time);
             }
         };
 
@@ -35,7 +40,7 @@ pub fn interprete_loop_statement(
             Some(Value::Block(body)) => body.clone(),
             _ => {
                 eprintln!("❌ Loop body must be a block, found: {:?}", loop_value.get("body"));
-                return (audio_engine, max_end_time, cursor_time);
+                return (max_end_time, cursor_time);
             }
         };
 
@@ -43,10 +48,12 @@ pub fn interprete_loop_statement(
         let mut cur_time = cursor_time;
         let mut max_time = max_end_time;
 
-        for _ in 0..loop_count {
-            let (eng, _, end_time) = execute_audio_block(
-                engine,
+        for i in 0..loop_count {
+            let (block_end_time, cursor_time) = execute_audio_block(
+                &mut engine,
+                global_store,
                 variable_table.clone(),
+                functions_table.clone(),
                 loop_body.clone(),
                 base_bpm,
                 base_duration,
@@ -54,14 +61,13 @@ pub fn interprete_loop_statement(
                 cur_time
             );
 
-            engine = eng;
-            cur_time = end_time;
-            max_time = max_time.max(end_time);
+            cur_time = block_end_time;
+            max_time = max_time.max(cur_time);
         }
 
-        (engine, max_time, cur_time)
-    } else {
-        eprintln!("❌ Loop statement value is not a map");
-        (audio_engine, max_end_time, cursor_time)
+        return (max_time, cur_time);
     }
+
+    eprintln!("❌ Loop statement value is not a map");
+    (max_end_time, cursor_time)
 }

package/rust/core/audio/interpreter/mod.rs

@@ -9,4 +9,5 @@ pub mod sleep;
 pub mod loop_;
 pub mod call;
 pub mod condition;
-pub mod arrow_call;
+pub mod arrow_call;
+pub mod function;

package/rust/core/audio/interpreter/sleep.rs

@@ -18,12 +18,6 @@ pub fn interprete_sleep_statement(
                 0.0
             })
         }
-        Value::String(s) if s.ends_with("s") => {
-            s.trim_end_matches("s").parse::<f32>().unwrap_or_else(|_| {
-                eprintln!("❌ Invalid sleep value (s): {}", s);
-                0.0
-            })
-        }
         other => {
             eprintln!("❌ Invalid sleep value: {:?}", other);
             0.0

package/rust/core/audio/interpreter/spawn.rs

@@ -1,84 +1,102 @@
 use crate::core::{
-    audio::{ engine::AudioEngine, interpreter::driver::execute_audio_block },
-    parser::statement::Statement,
+    audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
+    parser::statement::{Statement, StatementKind},
     shared::value::Value,
-    store::variable::VariableTable,
+    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
 };
 
 pub fn interprete_spawn_statement(
     stmt: &Statement,
-    audio_engine: AudioEngine,
+    audio_engine: &mut AudioEngine,
     variable_table: &VariableTable,
+    functions: &FunctionTable,
+    global_store: &GlobalStore,
     base_bpm: f32,
     base_duration: f32,
+    max_end_time: f32,
     cursor_time: f32,
-    max_end_time: f32
-) -> Option<(f32, f32, AudioEngine)> {
-    match &stmt.value {
-        Value::String(identifier) | Value::Identifier(identifier) => {
-            handle_spawn_identifier(
-                identifier,
-                audio_engine,
-                variable_table,
-                base_bpm,
-                base_duration,
-                cursor_time,
-                max_end_time
-            )
-        }
+) -> (f32, f32) {
+    match &stmt.kind {
+        StatementKind::Spawn { name, args } => {
+            let mut local_engine = AudioEngine::new(audio_engine.module_name.clone());
+
+            // ✅ 1. Cas : fonction
+            if let Some(func) = functions.functions.get(name) {
+                if func.parameters.len() != args.len() {
+                    eprintln!(
+                        "❌ Function '{}' expects {} args, got {}",
+                        name,
+                        func.parameters.len(),
+                        args.len()
+                    );
+                    return (max_end_time, cursor_time);
+                }
 
-        Value::Map(map) => {
-            if let Some(Value::Block(block)) = map.get("body") {
-                let (eng, _, end_time) = execute_audio_block(
-                    audio_engine.clone(),
-                    variable_table.clone(),
-                    block.clone(),
+                let mut local_vars = VariableTable::with_parent(variable_table.clone());
+                for (param, arg) in func.parameters.iter().zip(args) {
+                    local_vars.set(param.clone(), arg.clone());
+                }
+
+                let (spawn_max, _) = execute_audio_block(
+                    &mut local_engine,
+                    global_store,
+                    local_vars,
+                    functions.clone(),
+                    func.body.clone(),
                     base_bpm,
                     base_duration,
-                    max_end_time,
-                    cursor_time
+                    0.0,
+                    0.0,
                 );
-                return Some((max_end_time.max(end_time), end_time, eng));
-            } else {
-                eprintln!("❌ Spawn map has no 'body' block");
+
+                audio_engine.merge_with(local_engine);
+                return (spawn_max.max(max_end_time), cursor_time);
+            }
+
+            // ✅ 2. Cas : group dans variable_table ou global_store
+            if let Some(group_stmt) = find_group(name, variable_table, global_store) {
+                if let Value::Map(map) = &group_stmt.value {
+                    if let Some(Value::Block(body)) = map.get("body") {
+                        let (spawn_max, _) = execute_audio_block(
+                            &mut local_engine,
+                            global_store,
+                            variable_table.clone(),
+                            functions.clone(),
+                            body.clone(),
+                            base_bpm,
+                            base_duration,
+                            0.0,
+                            0.0,
+                        );
+                        audio_engine.merge_with(local_engine);
+                        return (spawn_max.max(max_end_time), cursor_time);
+                    }
+                }
             }
-            None
-        }
 
-        _ => {
-            eprintln!("❌ Invalid spawn statement: expected identifier, found {:?}", stmt.value);
-            None
+            eprintln!("❌ Function or group '{}' not found", name);
         }
+
+        _ => eprintln!("❌ interprete_spawn_statement expected Spawn, got {:?}", stmt.kind),
     }
+
+    (max_end_time, cursor_time)
 }
 
-fn handle_spawn_identifier(
-    identifier: &str,
-    audio_engine: AudioEngine,
-    variable_table: &VariableTable,
-    base_bpm: f32,
-    base_duration: f32,
-    cursor_time: f32,
-    max_end_time: f32
-) -> Option<(f32, f32, AudioEngine)> {
-    if let Some(Value::Map(map)) = variable_table.get(identifier) {
-        if let Some(Value::Block(block)) = map.get("body") {
-            let (eng, _, end_time) = execute_audio_block(
-                audio_engine.clone(),
-                variable_table.clone(),
-                block.clone(),
-                base_bpm,
-                base_duration,
-                max_end_time,
-                cursor_time
-            );
-            return Some((max_end_time.max(end_time), end_time, eng));
-        } else {
-            eprintln!("❌ Spawn group '{}' has no 'body' block", identifier);
+fn find_group<'a>(
+    name: &str,
+    variable_table: &'a VariableTable,
+    global_store: &'a GlobalStore,
+) -> Option<&'a Statement> {
+    if let Some(Value::Statement(stmt_box)) = variable_table.get(name) {
+        if let StatementKind::Group = stmt_box.kind {
+            return Some(stmt_box);
+        }
+    }
+    if let Some(Value::Statement(stmt_box)) = global_store.variables.variables.get(name) {
+        if let StatementKind::Group = stmt_box.kind {
+            return Some(stmt_box);
         }
-    } else {
-        eprintln!("❌ Spawn group '{}' not found or not a map", identifier);
     }
-
     None
 }