@devaloop/devalang 0.0.1-alpha.7 → 0.0.1-alpha.9

package/rust/core/audio/evaluator.rs

@@ -0,0 +1,31 @@
+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,
+    }
+}

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

@@ -0,0 +1,129 @@
+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::Map(synth_map)) = variable_table.get(target) else {
+            println!("❌ Synth '{}' not found in variable table", 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);
+        };
+
+        let freq = extract_f32(params, "freq").unwrap_or(440.0);
+        let amp = extract_f32(params, "amp").unwrap_or(1.0);
+
+        if method == "note" {
+            let Some(Value::Identifier(note_name)) = args.get(0) else {
+                println!("❌ Invalid or missing argument for 'note' method on '{}'.", target);
+                return (*max_end_time, cursor_copy);
+            };
+
+            let mut final_note_params = HashMap::new();
+            if let Some(Value::Map(note_params)) = args.get(1) {
+                for (key, value) in note_params {
+                    final_note_params.insert(key.clone(), value.clone());
+                }
+            }
+
+            let duration_ms = extract_f32(&final_note_params, "duration").unwrap_or(base_duration);
+            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,
+                start_time * 1000.0,
+                duration_ms
+            );
+
+            *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) -> Option<f32> {
+    map.get(key).and_then(|v| {
+        match v {
+            Value::Number(n) => Some(*n),
+            _ => 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)
+}

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

@@ -0,0 +1,64 @@
+use crate::core::{
+    audio::{ engine::AudioEngine, interpreter::{ driver::execute_audio_block } },
+    parser::statement::{ Statement, StatementKind },
+    shared::{ duration::Duration, value::Value },
+    store::variable::VariableTable,
+};
+
+pub fn interprete_call_statement(
+    stmt: &Statement,
+    audio_engine: AudioEngine,
+    variable_table: VariableTable,
+    base_bpm: f32,
+    base_duration: f32,
+    max_end_time: f32,
+    cursor_time: f32
+) -> (AudioEngine, f32, f32) {
+    match &stmt.value {
+        Value::String(identifier) | Value::Identifier(identifier) => {
+            if let Some(Value::Map(map)) = variable_table.clone().get(identifier) {
+                if let Some(Value::Block(block)) = map.get("body") {
+                    let (eng, _, end_time) = execute_audio_block(
+                        audio_engine,
+                        variable_table,
+                        block.clone(),
+                        base_bpm,
+                        base_duration,
+                        max_end_time,
+                        cursor_time
+                    );
+
+                    return (eng, max_end_time.max(end_time), end_time);
+                } else {
+                    eprintln!("❌ Group '{}' has no 'body' block", identifier);
+                }
+            } else {
+                eprintln!("❌ Group '{}' not found or not a map", identifier);
+            }
+        }
+
+        Value::Map(map) => {
+            if let Some(Value::Block(block)) = map.get("body") {
+                let (eng, _, end_time) = execute_audio_block(
+                    audio_engine,
+                    variable_table,
+                    block.clone(),
+                    base_bpm,
+                    base_duration,
+                    max_end_time,
+                    cursor_time
+                );
+
+                return (eng, max_end_time.max(end_time), end_time);
+            } else {
+                eprintln!("❌ Call map has no 'body' block");
+            }
+        }
+
+        other => {
+            eprintln!("❌ Invalid call statement: expected identifier or map, found {:?}", other);
+        }
+    }
+
+    (audio_engine, max_end_time, cursor_time)
+}

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

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

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

@@ -0,0 +1,216 @@
+use crate::core::{
+    audio::{
+        engine::AudioEngine,
+        interpreter::{
+            arrow_call::interprete_call_arrow_statement,
+            call::interprete_call_statement,
+            condition::interprete_condition_statement,
+            let_::interprete_let_statement,
+            load::interprete_load_statement,
+            loop_::interprete_loop_statement,
+            sleep::interprete_sleep_statement,
+            spawn::interprete_spawn_statement,
+            tempo::interprete_tempo_statement,
+            trigger::interprete_trigger_statement,
+        },
+    },
+    parser::statement::{ Statement, StatementKind },
+    store::variable::VariableTable,
+};
+
+pub fn run_audio_program(
+    statements: &Vec<Statement>,
+    audio_engine: AudioEngine,
+    entry: String,
+    output: String
+) -> (AudioEngine, f32, f32) {
+    let mut base_bpm = 120.0;
+    let mut base_duration = 60.0 / base_bpm;
+
+    let variable_table = audio_engine.variables.clone();
+
+    let (updated_audio_engine, base_bpm, max_end_time) = execute_audio_block(
+        audio_engine,
+        variable_table.clone(),
+        statements.clone(),
+        base_bpm.clone(),
+        base_duration.clone(),
+        0.0,
+        0.0
+    );
+
+    (updated_audio_engine, base_bpm, max_end_time)
+}
+
+pub fn execute_audio_block(
+    mut audio_engine: AudioEngine,
+    mut variable_table: VariableTable,
+    mut 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;
+
+    for stmt in statements {
+        match &stmt.kind {
+            StatementKind::Load { .. } => {
+                if
+                    let Some(new_variable_table) = interprete_load_statement(
+                        &stmt,
+                        &mut variable_table
+                    )
+                {
+                    variable_table = new_variable_table;
+                } else {
+                    eprintln!("❌ Failed to interpret load statement: {:?}", stmt);
+                }
+            }
+
+            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);
+                }
+            }
+
+            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(
+                        &stmt,
+                        temp_engine,
+                        &variable_table,
+                        base_bpm,
+                        base_duration,
+                        initial_cursor_time,
+                        max_end_time
+                    )
+                {
+                    audio_engine.merge_with(updated_engine);
+                }
+            }
+
+            StatementKind::Call => {
+                let (call_engine, new_max, new_cursor) = interprete_call_statement(
+                    &stmt,
+                    audio_engine.clone(),
+                    variable_table.clone(),
+                    base_bpm,
+                    base_duration,
+                    max_end_time,
+                    cursor_time
+                );
+
+                audio_engine.merge_with(call_engine);
+            }
+
+            StatementKind::Sleep => {
+                let (new_cursor, new_max) = interprete_sleep_statement(
+                    &stmt,
+                    cursor_time,
+                    max_end_time
+                );
+                cursor_time = new_cursor;
+                max_end_time = new_max;
+            }
+
+            StatementKind::Loop => {
+                let (loop_engine, new_max, new_cursor) = interprete_loop_statement(
+                    &stmt,
+                    audio_engine.clone(),
+                    variable_table.clone(),
+                    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(
+                    &stmt,
+                    audio_engine.clone(),
+                    variable_table.clone(),
+                    base_bpm,
+                    base_duration,
+                    max_end_time,
+                    cursor_time
+                );
+
+                audio_engine = condition_engine;
+                cursor_time = new_cursor;
+                max_end_time = new_max;
+            }
+
+            StatementKind::ArrowCall { .. } => {
+                interprete_call_arrow_statement(
+                    &stmt,
+                    &mut audio_engine,
+                    &variable_table,
+                    base_bpm,
+                    base_duration,
+                    &mut max_end_time,
+                    Some(&mut cursor_time),
+                    true
+                );
+            }
+
+            | StatementKind::Bank
+            | StatementKind::Import { .. }
+            | StatementKind::Export { .. }
+            | StatementKind::Group
+            | StatementKind::Unknown => {
+                // NOTE: Ignoring unsupported statement kinds for now.
+            }
+
+            _ => {
+                eprintln!("Unsupported audio statement kind: {:?}", stmt);
+            }
+        }
+    }
+
+    audio_engine.set_variables(variable_table);
+
+    (audio_engine, base_bpm, max_end_time)
+}

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

@@ -0,0 +1,19 @@
+use crate::core::{
+    audio::engine::AudioEngine,
+    parser::statement::{ Statement, StatementKind },
+    shared::value::Value,
+    store::variable::VariableTable,
+};
+
+pub fn interprete_let_statement(
+    stmt: &Statement,
+    variable_table: &mut VariableTable
+) -> Option<VariableTable> {
+    if let StatementKind::Let { name } = &stmt.kind {
+        variable_table.set(name.to_string(), stmt.value.clone());
+
+        return Some(variable_table.clone())
+    } 
+    
+    None
+}

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

@@ -0,0 +1,18 @@
+use crate::core::{
+    parser::statement::{ Statement, StatementKind },
+    shared::value::Value,
+    store::variable::VariableTable,
+};
+
+pub fn interprete_load_statement(
+    stmt: &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()));
+
+        return Some(variable_table.clone());
+    }
+
+    None
+}

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

@@ -0,0 +1,67 @@
+use crate::core::{
+    audio::{ engine::AudioEngine, interpreter::driver::execute_audio_block },
+    parser::statement::{ Statement, StatementKind },
+    shared::{ duration::Duration, value::Value },
+    store::variable::VariableTable,
+};
+
+pub fn interprete_loop_statement(
+    stmt: &Statement,
+    audio_engine: AudioEngine,
+    variable_table: VariableTable,
+    base_bpm: f32,
+    base_duration: f32,
+    max_end_time: f32,
+    cursor_time: f32
+) -> (AudioEngine, 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,
+            Some(Value::Identifier(ident)) => {
+                if let Some(Value::Number(n)) = variable_table.get(ident) {
+                    *n as usize
+                } else {
+                    eprintln!("❌ Loop iterator must be a number, found: {:?}", ident);
+                    return (audio_engine, 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);
+            }
+        };
+
+        let loop_body = match loop_value.get("body") {
+            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);
+            }
+        };
+
+        let mut engine = audio_engine;
+        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,
+                variable_table.clone(),
+                loop_body.clone(),
+                base_bpm,
+                base_duration,
+                max_time,
+                cur_time
+            );
+
+            engine = eng;
+            cur_time = end_time;
+            max_time = max_time.max(end_time);
+        }
+
+        (engine, max_time, cur_time)
+    } else {
+        eprintln!("❌ Loop statement value is not a map");
+        (audio_engine, max_end_time, cursor_time)
+    }
+}

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

@@ -0,0 +1,12 @@
+pub mod driver;
+
+pub mod load;
+pub mod let_;
+pub mod tempo;
+pub mod trigger;
+pub mod spawn;
+pub mod sleep;
+pub mod loop_;
+pub mod call;
+pub mod condition;
+pub mod arrow_call;

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

@@ -0,0 +1,36 @@
+use crate::core::{
+    audio::{ engine::AudioEngine, loader::trigger::load_trigger },
+    parser::statement::{ Statement, StatementKind },
+    shared::{ duration::Duration, value::Value },
+    store::variable::VariableTable,
+};
+
+pub fn interprete_sleep_statement(
+    stmt: &Statement,
+    cursor_time: f32,
+    max_end_time: f32,
+) -> (f32, f32) {
+    let duration_secs = match &stmt.value {
+        Value::Number(ms) => *ms / 1000.0,
+        Value::String(s) if s.ends_with("ms") => {
+            s.trim_end_matches("ms").parse::<f32>().map(|ms| ms / 1000.0).unwrap_or_else(|_| {
+                eprintln!("❌ Invalid sleep value (ms): {}", s);
+                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
+        }
+    };
+
+    let new_cursor = cursor_time + duration_secs;
+    let new_max = max_end_time.max(new_cursor);
+    (new_cursor, new_max)
+}