@devaloop/devalang 0.0.1-alpha.1 → 0.0.1-alpha.10

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

@@ -0,0 +1,236 @@
+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>,
+    mut 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 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(
+        audio_engine,
+        variable_table,
+        statements.clone(),
+        base_bpm,
+        base_duration,
+        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.clone() {
+        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, 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,
+                    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 { .. } => {
+                let (new_max_end_time, new_cursor_time) = interprete_call_arrow_statement(
+                    &stmt,
+                    &mut audio_engine,
+                    &variable_table,
+                    base_bpm,
+                    base_duration,
+                    &mut max_end_time,
+                    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);
+            }
+        }
+    }
+
+    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)
+}

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

@@ -0,0 +1,84 @@
+use crate::core::{
+    audio::{ engine::AudioEngine, interpreter::driver::execute_audio_block },
+    parser::statement::Statement,
+    shared::value::Value,
+    store::variable::VariableTable,
+};
+
+pub fn interprete_spawn_statement(
+    stmt: &Statement,
+    audio_engine: AudioEngine,
+    variable_table: &VariableTable,
+    base_bpm: f32,
+    base_duration: 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
+            )
+        }
+
+        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(),
+                    base_bpm,
+                    base_duration,
+                    max_end_time,
+                    cursor_time
+                );
+                return Some((max_end_time.max(end_time), end_time, eng));
+            } else {
+                eprintln!("❌ Spawn map has no 'body' block");
+            }
+            None
+        }
+
+        _ => {
+            eprintln!("❌ Invalid spawn statement: expected identifier, found {:?}", stmt.value);
+            None
+        }
+    }
+}
+
+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);
+        }
+    } else {
+        eprintln!("❌ Spawn group '{}' not found or not a map", identifier);
+    }
+
+    None
+}

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

@@ -0,0 +1,16 @@
+use crate::core::{ parser::statement::{ Statement, StatementKind }, shared::value::Value };
+
+pub fn interprete_tempo_statement(stmt: &Statement) -> Option<(f32, f32)> {
+    if let StatementKind::Tempo = &stmt.kind {
+        if let Value::Number(bpm) = &stmt.value {
+            let bpm = *bpm as f32;
+            let duration = 60.0 / bpm;
+
+            return Some((bpm, duration));
+        } else {
+            eprintln!("❌ Invalid tempo value: {:?}", stmt.value);
+        }
+    }
+
+    None
+}

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

@@ -0,0 +1,69 @@
+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_trigger_statement(
+    stmt: &Statement,
+    audio_engine: &mut AudioEngine,
+    variable_table: &VariableTable,
+    base_duration: f32,
+    cursor_time: f32,
+    max_end_time: f32
+) -> Option<(f32, f32, AudioEngine)> {
+    if let StatementKind::Trigger { entity, duration } = &stmt.kind {
+        if let Some(trigger_val) = variable_table.get(entity) {
+            let duration_secs = match duration {
+                Duration::Number(n) => *n,
+
+                Duration::Identifier(id) => {
+                    if id == "auto" {
+                        1.0
+                    } else {
+                        match variable_table.get(id) {
+                            Some(Value::Number(n)) => *n,
+                            Some(Value::Identifier(other)) if other == "auto" => 1.0,
+                            Some(other) => {
+                                eprintln!(
+                                    "❌ Invalid duration reference '{}': expected number, got {:?}",
+                                    id,
+                                    other
+                                );
+                                return None;
+                            }
+                            None => {
+                                eprintln!("❌ Duration identifier '{}' not found", id);
+                                return None;
+                            }
+                        }
+                    }
+                }
+
+                Duration::Auto => 1.0,
+            };
+
+            let duration_final = duration_secs * base_duration;
+
+            let (src, _) = load_trigger(
+                trigger_val,
+                duration,
+                base_duration,
+                variable_table.clone()
+            );
+
+            let mut updated_engine = audio_engine.clone();
+            updated_engine.insert_sample(&src, cursor_time, duration_final, None);
+
+            let new_cursor_time = cursor_time + duration_final;
+            let new_max_end_time = new_cursor_time.max(max_end_time);
+
+            return Some((new_cursor_time, new_max_end_time, updated_engine));
+        } else {
+            eprintln!("❌ Unknown trigger entity: {}", entity);
+        }
+    }
+
+    None
+}

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

@@ -0,0 +1 @@
+pub mod trigger;

package/rust/core/audio/loader/trigger.rs

@@ -0,0 +1,52 @@
+use crate::core::{ shared::{ duration::Duration, value::Value }, store::variable::VariableTable };
+
+pub fn load_trigger(
+    trigger: &Value,
+    duration: &Duration,
+    base_duration: f32,
+    variable_table: VariableTable
+) -> (String, f32) {
+    let mut trigger_path = String::new();
+    let mut duration_as_secs = 0.0;
+
+    match trigger {
+        Value::String(src) => {
+            trigger_path = src.to_string();
+        }
+        _ => {
+            eprintln!("❌ Invalid trigger type. Expected a text variable.");
+        }
+    }
+
+    match duration {
+        Duration::Identifier(duration_identifier) => {
+            if duration_identifier == "auto" {
+                duration_as_secs = base_duration;
+            } else if let Some(Value::Number(num)) = variable_table.get(duration_identifier) {
+                duration_as_secs = *num;
+            } else if let Some(Value::String(num_str)) = variable_table.get(duration_identifier) {
+                duration_as_secs = num_str.parse::<f32>().unwrap_or(base_duration);
+            } else if
+                let Some(Value::Identifier(num_str)) = variable_table.get(duration_identifier)
+            {
+                duration_as_secs = num_str.parse::<f32>().unwrap_or(base_duration);
+            } else {
+                eprintln!("❌ Invalid duration identifier: {}", duration_identifier);
+            }
+        }
+
+        Duration::Number(num) => {
+            duration_as_secs = *num;
+        }
+
+        Duration::Auto => {
+            duration_as_secs = base_duration;
+        }
+
+        _ => {
+            eprintln!("❌ Invalid duration type. Expected an identifier.");
+        }
+    }
+
+    (trigger_path, duration_as_secs)
+}

package/rust/core/audio/mod.rs

@@ -0,0 +1,6 @@
+pub mod engine;
+pub mod interpreter;
+pub mod loader;
+pub mod player;
+pub mod renderer;
+pub mod evaluator;

package/rust/core/audio/player.rs

@@ -0,0 +1,54 @@
+use rodio::{ Decoder, OutputStream, OutputStreamHandle, Sink, Source };
+use std::{ fs::File, io::BufReader };
+
+pub struct AudioPlayer {
+    _stream: OutputStream,
+    handle: OutputStreamHandle,
+    sink: Sink,
+    last_path: Option<String>,
+}
+
+impl AudioPlayer {
+    pub fn new() -> Self {
+        let (stream, handle) = OutputStream::try_default().unwrap();
+        let sink = Sink::try_new(&handle).unwrap();
+
+        Self {
+            _stream: stream,
+            handle,
+            sink,
+            last_path: None,
+        }
+    }
+
+    fn load_source(&self, path: &str) -> impl Source<Item = f32> + Send + 'static {
+        let file = File::open(path).unwrap();
+        let reader = BufReader::new(file);
+
+        Decoder::new(reader).unwrap().convert_samples()
+    }
+
+    pub fn play_file_once(&mut self, path: &str) {
+        self.sink.stop();
+        self.sink = Sink::try_new(&self.handle).unwrap();
+
+        self.sink.set_volume(1.0);
+
+        let source = self.load_source(path);
+
+        self.sink.append(source);
+        self.last_path = Some(path.to_string());
+    }
+
+    pub fn replay_last(&mut self) {
+        if let Some(path) = self.last_path.clone() {
+            self.play_file_once(&path);
+        } else {
+            eprintln!("⚠️ No previous audio to replay.");
+        }
+    }
+
+    pub fn wait_until_end(&self) {
+        self.sink.sleep_until_end();
+    }
+}