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

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

@@ -0,0 +1,18 @@
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    store::variable::VariableTable,
+};
+
+// Store automation configuration into the variable table under a namespaced key
+// Key: "<target>__automation" => Value::Map({ target, params })
+pub fn interprete_automate_statement(
+    stmt: &Statement,
+    variable_table: &mut VariableTable,
+) -> Option<VariableTable> {
+    if let StatementKind::Automate { target } = &stmt.kind {
+        let key = format!("{}__automation", target);
+        variable_table.set(key, stmt.value.clone());
+        return Some(variable_table.clone());
+    }
+    None
+}

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

@@ -1,95 +1,98 @@
-use crate::core::{
-    audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
-    parser::statement::{Statement, StatementKind},
-    shared::value::Value,
-    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
-};
-
-pub fn interprete_call_statement(
-    stmt: &Statement,
-    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,
-) -> (f32, f32) {
-    match &stmt.kind {
-        StatementKind::Call { name, args } => {
-            // Classic function call case
-            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);
-                }
-
-                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());
-                }
-
-                return execute_audio_block(
-                    audio_engine,
-                    global_store,
-                    local_vars,
-                    functions.clone(),
-                    func.body.clone(),
-                    base_bpm,
-                    base_duration,
-                    max_end_time,
-                    cursor_time,
-                );
-            }
-
-            // Group case
-            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") {
-                        return execute_audio_block(
-                            audio_engine,
-                            global_store,
-                            variable_table.clone(),
-                            functions.clone(),
-                            body.clone(),
-                            base_bpm,
-                            base_duration,
-                            max_end_time,
-                            cursor_time,
-                        );
-                    }
-                }
-            }
-
-            eprintln!("❌ Function or group '{}' not found", name);
-        }
-
-        _ => eprintln!("❌ interprete_call_statement expected Call, got {:?}", stmt.kind),
-    }
-
-    (max_end_time, cursor_time)
-}
-
-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);
-        }
-    }
-    None
-}
+use crate::core::{
+    audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
+    parser::statement::{Statement, StatementKind},
+    shared::value::Value,
+    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
+};
+
+pub fn interprete_call_statement(
+    stmt: &Statement,
+    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,
+) -> (f32, f32) {
+    match &stmt.kind {
+        StatementKind::Call { name, args } => {
+            // Classic function call case
+            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);
+                }
+
+                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());
+                }
+
+                return execute_audio_block(
+                    audio_engine,
+                    global_store,
+                    local_vars,
+                    functions.clone(),
+                    &func.body,
+                    base_bpm,
+                    base_duration,
+                    max_end_time,
+                    cursor_time,
+                );
+            }
+
+            // Group case
+            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") {
+                        return execute_audio_block(
+                            audio_engine,
+                            global_store,
+                            variable_table.clone(),
+                            functions.clone(),
+                            &body,
+                            base_bpm,
+                            base_duration,
+                            max_end_time,
+                            cursor_time,
+                        );
+                    }
+                }
+            }
+
+            eprintln!("❌ Function or group '{}' not found", name);
+        }
+
+        _ => eprintln!(
+            "❌ interprete_call_statement expected Call, got {:?}",
+            stmt.kind
+        ),
+    }
+
+    (max_end_time, cursor_time)
+}
+
+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);
+        }
+    }
+    None
+}

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

@@ -1,71 +1,70 @@
-use crate::core::{
-    audio::{
-        engine::AudioEngine,
-        evaluator::evaluate_condition_string,
-        interpreter::driver::execute_audio_block,
-    },
-    parser::statement::Statement,
-    shared::value::Value,
-    store::{ function::FunctionTable, global::GlobalStore, variable::VariableTable },
-};
-
-pub fn interprete_condition_statement(
-    stmt: &Statement,
-    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
-) -> (f32, f32) {
-    let mut cur_time = cursor_time;
-    let mut max_time = max_end_time;
-
-    let mut current = stmt.value.clone();
-
-    loop {
-        let Value::Map(map) = current else {
-            break;
-        };
-
-        let should_execute = match map.get("condition") {
-            Some(Value::Boolean(b)) => *b,
-            Some(Value::String(expr)) => evaluate_condition_string(expr, &variable_table.clone()),
-            Some(_) => false,
-            None => true,
-        };
-
-        if should_execute {
-            if let Some(Value::Block(block)) = map.get("body") {
-                let (new_max, cursor_time) = execute_audio_block(
-                    audio_engine,
-                    global_store,
-                    variable_table.clone(),
-                    functions_table.clone(),
-                    block.clone(),
-                    base_bpm,
-                    base_duration,
-                    max_time,
-                    cur_time
-                );
-                return (new_max, cursor_time);
-            } else {
-                break;
-            }
-        }
-
-        // Advance to the next condition
-        match map.get("next") {
-            Some(Value::Map(next_map)) => {
-                current = Value::Map(next_map.clone());
-            }
-            _ => {
-                break;
-            }
-        }
-    }
-
-    (max_end_time, cursor_time)
-}
+use crate::core::{
+    audio::{
+        engine::AudioEngine, evaluator::evaluate_condition_string,
+        interpreter::driver::execute_audio_block,
+    },
+    parser::statement::Statement,
+    shared::value::Value,
+    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
+};
+
+pub fn interprete_condition_statement(
+    stmt: &Statement,
+    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,
+) -> (f32, f32) {
+    let cur_time = cursor_time;
+    let max_time = max_end_time;
+
+    let mut current = stmt.value.clone();
+
+    loop {
+        let Value::Map(map) = current else {
+            break;
+        };
+
+        let should_execute = match map.get("condition") {
+            Some(Value::Boolean(b)) => *b,
+            Some(Value::String(expr)) => evaluate_condition_string(expr, &variable_table.clone()),
+            Some(_) => false,
+            None => true,
+        };
+
+        if should_execute {
+            if let Some(Value::Block(block)) = map.get("body") {
+                let (new_max, cursor_time) = execute_audio_block(
+                    audio_engine,
+                    global_store,
+                    variable_table.clone(),
+                    functions_table.clone(),
+                    &block,
+                    base_bpm,
+                    base_duration,
+                    max_time,
+                    cur_time,
+                );
+                return (new_max, cursor_time);
+            } else {
+                break;
+            }
+        }
+
+        // Advance to the next condition
+        match map.get("next") {
+            Some(Value::Map(next_map)) => {
+                current = Value::Map(next_map.clone());
+            }
+            _ => {
+                break;
+            }
+        }
+    }
+
+    (max_end_time, cursor_time)
+}