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

package/rust/core/audio/evaluator.rs

@@ -1,31 +1,263 @@
-use crate::core::{ shared::value::Value, store::variable::VariableTable };
-
-pub fn evaluate_condition_string(expr: &str, vars: &VariableTable) -> bool {
-    let tokens: Vec<&str> = expr.split_whitespace().collect();
-    if tokens.len() != 3 {
-        return false;
-    }
-
-    let left = tokens[0];
-    let op = tokens[1];
-    let right = tokens[2];
-
-    let left_val = match vars.get(left) {
-        Some(Value::Number(n)) => *n,
-        _ => {
-            return false;
-        }
-    };
-
-    let right_val: f32 = right.parse().unwrap_or(0.0);
-
-    match op {
-        ">" => left_val > right_val,
-        "<" => left_val < right_val,
-        ">=" => left_val >= right_val,
-        "<=" => left_val <= right_val,
-        "==" => (left_val - right_val).abs() < f32::EPSILON,
-        "!=" => (left_val - right_val).abs() > f32::EPSILON,
-        _ => false,
-    }
-}
+use crate::core::audio::special::{
+    find_and_eval_first_easing_call, find_and_eval_first_math_call, find_and_eval_first_mod_call,
+    resolve_env_atom,
+};
+use crate::core::{shared::value::Value, store::variable::VariableTable};
+
+pub fn evaluate_condition_string(expr: &str, vars: &VariableTable) -> bool {
+    let tokens: Vec<&str> = expr.split_whitespace().collect();
+    if tokens.len() != 3 {
+        return false;
+    }
+
+    let left = tokens[0];
+    let op = tokens[1];
+    let right = tokens[2];
+
+    let left_val = match vars.get(left) {
+        Some(Value::Number(n)) => *n,
+        _ => {
+            return false;
+        }
+    };
+
+    let right_val: f32 = right.parse().unwrap_or(0.0);
+
+    match op {
+        ">" => left_val > right_val,
+        "<" => left_val < right_val,
+        ">=" => left_val >= right_val,
+        "<=" => left_val <= right_val,
+        "==" => (left_val - right_val).abs() < f32::EPSILON,
+        "!=" => (left_val - right_val).abs() > f32::EPSILON,
+        _ => false,
+    }
+}
+
+// Very small expression evaluator for `$env.*`, `$math.*` and variables.
+// Supports: +, -, *, / and simple parentheses, left-to-right (no precedence), and $math.(sin|cos)(expr)
+pub fn evaluate_numeric_expression(
+    expr: &str,
+    vars: &VariableTable,
+    env_bpm: f32,
+    env_beat: f32,
+) -> Option<f32> {
+    let expr = expr.replace(" ", "");
+
+    // Helper to resolve an atom to a number
+    fn resolve_atom(atom: &str, vars: &VariableTable, bpm: f32, beat: f32) -> Option<f32> {
+        if let Some(v) = resolve_env_atom(atom, bpm, beat) {
+            return Some(v);
+        }
+        if let Ok(n) = atom.parse::<f32>() {
+            return Some(n);
+        }
+        if let Some(Value::Number(n)) = vars.get(atom) {
+            return Some(*n);
+        }
+        None
+    }
+
+    // Shunting-like, simplified: first evaluate any $math.func(...) calls anywhere in the expression,
+    // then fold remaining parentheses and evaluate left-to-right.
+    fn eval(expr: &str, vars: &VariableTable, bpm: f32, beat: f32) -> Option<f32> {
+        // 1) Replace $math.* calls progressively
+        let mut s = expr.to_string();
+        // Evaluate modulators first (they may feed easing/math)
+        while let Some(next) =
+            find_and_eval_first_mod_call(&s, evaluate_numeric_expression, vars, bpm, beat)
+        {
+            s = next;
+        }
+        // Then easing functions
+        while let Some(next) =
+            find_and_eval_first_easing_call(&s, evaluate_numeric_expression, vars, bpm, beat)
+        {
+            s = next;
+        }
+        // Finally math transforms
+        while let Some(next) =
+            find_and_eval_first_math_call(&s, evaluate_numeric_expression, vars, bpm, beat)
+        {
+            s = next;
+        }
+
+        // 2) Evaluate remaining (pure) parentheses starting from innermost
+        if let Some(open) = s.rfind('(') {
+            if let Some(close_rel) = s[open..].find(')') {
+                // index relatif
+                let close = open + close_rel;
+                let inner = &s[open + 1..close];
+                let val = eval(inner, vars, bpm, beat)?;
+                let mut replaced = String::new();
+                replaced.push_str(&s[..open]);
+                replaced.push_str(&val.to_string());
+                replaced.push_str(&s[close + 1..]);
+                return eval(&replaced, vars, bpm, beat);
+            }
+        }
+
+        // Tokenize by operators left-to-right
+        let mut parts: Vec<String> = Vec::new();
+        let mut cur = String::new();
+        for ch in s.chars() {
+            if "+-*/".contains(ch) {
+                if !cur.is_empty() {
+                    parts.push(cur.clone());
+                    cur.clear();
+                }
+                parts.push(ch.to_string());
+            } else {
+                cur.push(ch);
+            }
+        }
+        if !cur.is_empty() {
+            parts.push(cur);
+        }
+        if parts.is_empty() {
+            return None;
+        }
+
+        // Resolve atoms and compute
+        let mut acc: Option<f32> = None;
+        let mut op: Option<char> = None;
+        for part in parts {
+            if part.len() == 1 && "+-*/".contains(part.chars().next().unwrap()) {
+                op = part.chars().next();
+                continue;
+            }
+            let val = if let Some(v) = resolve_atom(&part, vars, bpm, beat) {
+                v
+            } else if part.starts_with("$env.") {
+                // $env atom not handled by resolve_atom (when composed), try recursive eval
+                eval(&part, vars, bpm, beat)?
+            } else {
+                return None;
+            };
+
+            acc = Some(match (acc, op) {
+                (None, _) => val,
+                (Some(a), Some('+')) => a + val,
+                (Some(a), Some('-')) => a - val,
+                (Some(a), Some('*')) => a * val,
+                (Some(a), Some('/')) => {
+                    if val != 0.0 {
+                        a / val
+                    } else {
+                        return Some(f32::INFINITY);
+                    }
+                }
+                (Some(_), None) => val,
+                _ => return None,
+            });
+        }
+
+        acc
+    }
+
+    eval(&expr, vars, env_bpm, env_beat)
+}
+
+pub fn evaluate_rhs_into_value(
+    raw: &str,
+    vars: &VariableTable,
+    env_bpm: f32,
+    env_beat: f32,
+) -> Value {
+    if let Some(num) = evaluate_numeric_expression(raw, vars, env_bpm, env_beat) {
+        Value::Number(num)
+    } else {
+        Value::String(raw.to_string())
+    }
+}
+
+// Evaluate a simple string concatenation expression like: "hello " + name + "!" + $env.beat
+// - Splits on + outside quotes
+// - Terms can be string literals (double quotes), variables (Number/String/Boolean), or numeric env/math expressions
+// Returns None if parsing fails (fallback to raw print)
+pub fn evaluate_string_expression(
+    expr: &str,
+    vars: &VariableTable,
+    env_bpm: f32,
+    env_beat: f32,
+) -> Option<String> {
+    // Quick reject if no '+' present
+    if !expr.contains('+') {
+        return None;
+    }
+
+    // Split by '+' outside of quotes
+    let mut parts: Vec<String> = Vec::new();
+    let mut cur = String::new();
+    let mut in_quotes = false;
+    let mut escape = false;
+    for ch in expr.chars() {
+        if escape {
+            cur.push(ch);
+            escape = false;
+            continue;
+        }
+        if ch == '\\' {
+            // escape next char
+            escape = true;
+            continue;
+        }
+        if ch == '"' {
+            in_quotes = !in_quotes;
+            cur.push(ch);
+            continue;
+        }
+        if ch == '+' && !in_quotes {
+            parts.push(cur.to_string());
+            cur.clear();
+            continue;
+        }
+        cur.push(ch);
+    }
+    if !cur.is_empty() {
+        parts.push(cur.to_string());
+    }
+    if parts.is_empty() {
+        return None;
+    }
+
+    // Resolve each part into a string
+    fn strip_quotes(s: &str) -> Option<String> {
+        let st = s.trim();
+        if st.len() >= 2 && st.starts_with('"') && st.ends_with('"') {
+            Some(st[1..st.len() - 1].to_string())
+        } else {
+            None
+        }
+    }
+
+    let mut out = String::new();
+    for p in parts {
+        if p.is_empty() {
+            continue;
+        }
+        if let Some(lit) = strip_quotes(&p) {
+            out.push_str(&lit);
+            continue;
+        }
+        // Try variables first
+        if let Some(val) = vars.get(&p) {
+            match val {
+                crate::core::shared::value::Value::String(s) => out.push_str(s),
+                crate::core::shared::value::Value::Number(n) => out.push_str(&format!("{}", n)),
+                crate::core::shared::value::Value::Boolean(b) => out.push_str(&format!("{}", b)),
+                other => out.push_str(&format!("{:?}", other)),
+            }
+            continue;
+        }
+        // Try env/math/numeric expression for this term
+        if let Some(n) = evaluate_numeric_expression(&p, vars, env_bpm, env_beat) {
+            out.push_str(&format!("{}", n));
+            continue;
+        }
+        // Bareword not resolved: include as-is (safe fallback)
+        out.push_str(&p);
+    }
+
+    Some(out)
+}

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

@@ -1,161 +1,198 @@
-use crate::core::{
-    audio::engine::AudioEngine,
-    parser::statement::{ Statement, StatementKind },
-    shared::value::Value,
-    store::variable::VariableTable,
-};
-
-use std::collections::HashMap;
-
-pub fn interprete_call_arrow_statement(
-    stmt: &Statement,
-    audio_engine: &mut AudioEngine,
-    variable_table: &VariableTable,
-    base_bpm: f32,
-    base_duration: f32,
-    max_end_time: &mut f32,
-    mut cursor_time: Option<&mut f32>,
-    update_cursor: bool
-) -> (f32, f32) {
-    let cursor_copy = cursor_time
-        .as_ref()
-        .map(|c| **c)
-        .unwrap_or(0.0);
-
-    if let StatementKind::ArrowCall { target, method, args } = &stmt.kind {
-        let Some(Value::Statement(synth_stmt)) = variable_table.get(target) else {
-            println!("❌ Synth '{}' not found in variable table", target);
-            return (*max_end_time, cursor_copy);
-        };
-
-        let Value::Map(synth_map) = &synth_stmt.value else {
-            println!("❌ Invalid synth statement for '{}', expected a map.", target);
-            return (*max_end_time, cursor_copy);
-        };
-
-        let Some(Value::String(entity)) = synth_map.get("entity") else {
-            println!("❌ Missing 'entity' key in synth '{}'.", target);
-            return (*max_end_time, cursor_copy);
-        };
-
-        if entity != "synth" {
-            println!("❌ '{}' is not a synth, entity is '{}'.", target, entity);
-            return (*max_end_time, cursor_copy);
-        }
-
-        let Some(Value::Map(value_map)) = synth_map.get("value") else {
-            println!("❌ Missing 'value' map in synth '{}'.", target);
-            return (*max_end_time, cursor_copy);
-        };
-
-        let Some(Value::String(waveform)) = value_map.get("waveform") else {
-            println!("❌ Missing or invalid 'waveform' in synth '{}'.", target);
-            return (*max_end_time, cursor_copy);
-        };
-
-        let Some(Value::Map(params)) = value_map.get("parameters") else {
-            println!("❌ Missing or invalid 'parameters' in synth '{}'.", target);
-            return (*max_end_time, cursor_copy);
-        };
-
-        // Synth parameters
-    let synth_params = params.clone();
-    let amp = extract_f32(&synth_params, "amp", base_bpm).unwrap_or(1.0);
-
-        if method == "note" {
-            let filtered_args: Vec<_> = args
-                .iter()
-                .filter(|arg| !matches!(arg, Value::Unknown))
-                .collect();
-
-            let Some(Value::Identifier(note_name)) = filtered_args.get(0).map(|v| (*v).clone()) else {
-                println!("❌ Invalid or missing argument for 'note' method on '{}'.", target);
-                return (*max_end_time, cursor_copy);
-            };
-
-            let mut note_params = HashMap::new();
-            if let Some(arg1) = filtered_args.get(1) {
-                match (*arg1).clone() {
-                    Value::Map(map) => {
-                        for (key, value) in map {
-                            note_params.insert(key, value);
-                        }
-                    }
-                    _ => {}
-                }
-            }
-
-            // Note parameters and calculations
-            let amp_note = extract_f32(&note_params, "amp", base_bpm).unwrap_or(amp);
-            let duration_ms = extract_f32(&note_params, "duration", base_bpm)
-                .unwrap_or(base_duration * 1000.0);
-            
-            let duration_secs = duration_ms / 1000.0;
-            let final_freq = note_to_freq(&note_name);
-            let start_time = cursor_copy;
-            let end_time = start_time + duration_secs;
-
-            audio_engine.insert_note(
-                waveform.clone(),
-                final_freq,
-                amp_note,
-                start_time * 1000.0,
-                duration_ms,
-                synth_params,
-                note_params
-            );
-
-            *max_end_time = (*max_end_time).max(end_time);
-
-            if update_cursor {
-                if let Some(c) = cursor_time.as_mut() {
-                    **c = end_time;
-                }
-            }
-
-            return (*max_end_time, end_time);
-        } else {
-            println!("❌ Unknown method '{}' on synth '{}'.", method, target);
-        }
-    }
-
-    (*max_end_time, cursor_copy)
-}
-
-fn extract_f32(map: &HashMap<String, Value>, key: &str, base_bpm: f32) -> Option<f32> {
-    map.get(key).and_then(|v| {
-        match v {
-            Value::Number(n) => Some(*n),
-            Value::Beat(beat_str) => {
-                let parts: Vec<&str> = beat_str.split('/').collect();
-                if parts.len() == 2 {
-                    let numerator = parts[0].parse::<f32>().ok()?;
-                    let denominator = parts[1].parse::<f32>().ok()?;
-
-                    Some((numerator / denominator) * ((60.0 / base_bpm) * 1000.0))
-                } else {
-                    None
-                }
-            }
-            _ => None,
-        }
-    })
-}
-
-fn note_to_freq(note: &str) -> f32 {
-    let notes = vec!["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
-
-    if note.len() < 2 || note.len() > 3 {
-        return 440.0;
-    }
-
-    let (name, octave_str) = note.split_at(note.len() - 1);
-    let semitone = notes
-        .iter()
-        .position(|&n| n == name)
-        .unwrap_or(9) as i32;
-    let octave = octave_str.parse::<i32>().unwrap_or(4);
-    let midi_note = (octave + 1) * 12 + semitone;
-
-    440.0 * (2.0_f32).powf(((midi_note as f32) - 69.0) / 12.0)
-}
+use crate::core::{
+    audio::engine::AudioEngine,
+    parser::statement::{Statement, StatementKind},
+    shared::value::Value,
+    store::variable::VariableTable,
+};
+
+use std::collections::HashMap;
+
+pub fn interprete_call_arrow_statement(
+    stmt: &Statement,
+    audio_engine: &mut AudioEngine,
+    variable_table: &VariableTable,
+    base_bpm: f32,
+    base_duration: f32,
+    max_end_time: &mut f32,
+    mut cursor_time: Option<&mut f32>,
+    update_cursor: bool,
+) -> (f32, f32) {
+    let cursor_copy = cursor_time.as_ref().map(|c| **c).unwrap_or(0.0);
+
+    if let StatementKind::ArrowCall {
+        target,
+        method,
+        args,
+    } = &stmt.kind
+    {
+        let Some(Value::Statement(synth_stmt)) = variable_table.get(target) else {
+            println!("❌ Synth '{}' not found in variable table", target);
+            return (*max_end_time, cursor_copy);
+        };
+
+        let Value::Map(synth_map) = &synth_stmt.value else {
+            println!(
+                "❌ Invalid synth statement for '{}', expected a map.",
+                target
+            );
+            return (*max_end_time, cursor_copy);
+        };
+
+        let Some(Value::String(entity)) = synth_map.get("entity") else {
+            println!("❌ Missing 'entity' key in synth '{}'.", target);
+            return (*max_end_time, cursor_copy);
+        };
+
+        if entity != "synth" {
+            println!("❌ '{}' is not a synth, entity is '{}'.", target, entity);
+            return (*max_end_time, cursor_copy);
+        }
+
+        let Some(Value::Map(value_map)) = synth_map.get("value") else {
+            println!("❌ Missing 'value' map in synth '{}'.", target);
+            return (*max_end_time, cursor_copy);
+        };
+
+        let Some(Value::String(waveform)) = value_map.get("waveform") else {
+            println!("❌ Missing or invalid 'waveform' in synth '{}'.", target);
+            return (*max_end_time, cursor_copy);
+        };
+
+        let Some(Value::Map(params)) = value_map.get("parameters") else {
+            println!("❌ Missing or invalid 'parameters' in synth '{}'.", target);
+            return (*max_end_time, cursor_copy);
+        };
+
+        // Synth parameters
+        let synth_params = params.clone();
+        let amp = extract_f32(&synth_params, "amp", base_bpm).unwrap_or(1.0);
+
+        if method == "note" {
+            let filtered_args: Vec<_> = args
+                .iter()
+                .filter(|arg| !matches!(arg, Value::Unknown))
+                .collect();
+
+            let Some(Value::Identifier(note_name)) = filtered_args.get(0).map(|v| (*v).clone())
+            else {
+                println!(
+                    "❌ Invalid or missing argument for 'note' method on '{}'.",
+                    target
+                );
+                return (*max_end_time, cursor_copy);
+            };
+
+            let mut note_params = HashMap::new();
+            if let Some(arg1) = filtered_args.get(1) {
+                match (*arg1).clone() {
+                    Value::Map(map) => {
+                        for (key, value) in map {
+                            note_params.insert(key, value);
+                        }
+                    }
+                    _ => {}
+                }
+            }
+
+            // Note parameters and calculations
+            let amp_note = extract_f32(&note_params, "amp", base_bpm).unwrap_or(amp);
+            let duration_ms =
+                extract_f32(&note_params, "duration", base_bpm).unwrap_or(base_duration * 1000.0);
+
+            let duration_secs = duration_ms / 1000.0;
+            let final_freq = note_to_freq(&note_name);
+            let start_time = cursor_copy;
+            let end_time = start_time + duration_secs;
+
+            // Fetch automation map if present:
+            // - Global (per-synth): key "<target>__automation" => map with key "params"
+            // - Per-note: note parameter "automate" => map
+            let auto_key = format!("{}__automation", target);
+            let synth_automation = match variable_table.get(&auto_key) {
+                Some(Value::Map(map)) => match map.get("params") {
+                    Some(Value::Map(p)) => Some(p.clone()),
+                    _ => None,
+                },
+                _ => None,
+            };
+
+            let note_automation = match note_params.get("automate") {
+                Some(Value::Map(m)) => Some(m.clone()),
+                _ => None,
+            };
+
+            // Merge: per-note overrides synth automation per key (volume/pan/pitch)
+            let automation = match (synth_automation, note_automation) {
+                (Some(mut a), Some(n)) => {
+                    for (k, v) in n {
+                        a.insert(k, v);
+                    }
+                    Some(a)
+                }
+                (None, Some(n)) => Some(n),
+                (Some(a), None) => Some(a),
+                _ => None,
+            };
+
+            audio_engine.insert_note(
+                waveform.clone(),
+                final_freq,
+                amp_note,
+                start_time * 1000.0,
+                duration_ms,
+                synth_params,
+                note_params,
+                automation,
+            );
+
+            *max_end_time = (*max_end_time).max(end_time);
+
+            if update_cursor {
+                if let Some(c) = cursor_time.as_mut() {
+                    **c = end_time;
+                }
+            }
+
+            return (*max_end_time, end_time);
+        } else {
+            println!("❌ Unknown method '{}' on synth '{}'.", method, target);
+        }
+    }
+
+    (*max_end_time, cursor_copy)
+}
+
+fn extract_f32(map: &HashMap<String, Value>, key: &str, base_bpm: f32) -> Option<f32> {
+    map.get(key).and_then(|v| match v {
+        Value::Number(n) => Some(*n),
+        Value::Beat(beat_str) => {
+            let parts: Vec<&str> = beat_str.split('/').collect();
+            if parts.len() == 2 {
+                let numerator = parts[0].parse::<f32>().ok()?;
+                let denominator = parts[1].parse::<f32>().ok()?;
+
+                Some((numerator / denominator) * ((60.0 / base_bpm) * 1000.0))
+            } else {
+                None
+            }
+        }
+        _ => None,
+    })
+}
+
+fn note_to_freq(note: &str) -> f32 {
+    let notes = vec![
+        "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B",
+    ];
+
+    if note.len() < 2 || note.len() > 3 {
+        return 440.0;
+    }
+
+    let (name, octave_str) = note.split_at(note.len() - 1);
+    let semitone = notes.iter().position(|&n| n == name).unwrap_or(9) as i32;
+    let octave = octave_str.parse::<i32>().unwrap_or(4);
+    let midi_note = (octave + 1) * 12 + semitone;
+
+    440.0 * (2.0_f32).powf(((midi_note as f32) - 69.0) / 12.0)
+}