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

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

@@ -0,0 +1,204 @@
+use crate::core::{
+    audio::{
+        engine::AudioEngine,
+        interpreter::{
+            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.clone(),
+        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) {
+    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 => {
+                if
+                    let Some((new_cursor_time, new_max_end_time, updated_engine)) =
+                        interprete_spawn_statement(
+                            &stmt,
+                            &mut audio_engine,
+                            &variable_table,
+                            base_bpm,
+                            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 spawn statement: {:?}", stmt);
+                }
+            }
+
+            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::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 = call_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::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,59 @@
+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,
+            _ => {
+                eprintln!("❌ Loop iterator must be a number");
+                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");
+                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.clone(),
+                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,11 @@
+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;

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,65 @@
+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: &mut AudioEngine,
+    variable_table: &VariableTable,
+    base_bpm: f32,
+    base_duration: f32,
+    cursor_time: f32,
+    max_end_time: f32
+) -> Option<(f32, f32, AudioEngine)> {
+    if let Value::String(identifier) = &stmt.value {
+        match variable_table.get(identifier) {
+            Some(Value::Map(map)) => {
+                if let Some(Value::Block(block)) = map.get("body") {
+                    let mut local_max = cursor_time;
+                    let mut updated_engine = audio_engine.clone();
+
+                    for inner_stmt in block {
+                        let (inner_engine, _, inner_end_time) = execute_audio_block(
+                            updated_engine.clone(),
+                            variable_table.clone(),
+                            vec![inner_stmt.clone()],
+                            base_bpm,
+                            base_duration,
+                            max_end_time,
+                            cursor_time
+                        );
+
+                        updated_engine = inner_engine;
+
+                        if inner_end_time > local_max {
+                            local_max = inner_end_time;
+                        }
+                    }
+
+                    let new_max_end_time = local_max.max(max_end_time);
+
+                    return Some((local_max, new_max_end_time, updated_engine));
+                } else {
+                    eprintln!("❌ Cannot spawn '{}': no valid body block", identifier);
+                }
+            }
+            Some(other) => {
+                eprintln!(
+                    "❌ Cannot spawn '{}': expected map with block, got {:?}",
+                    identifier,
+                    other
+                );
+            }
+            None => {
+                eprintln!("❌ Cannot spawn '{}': not found in variable table", identifier);
+            }
+        }
+    } else {
+        eprintln!("❌ Invalid spawn statement: expected a string identifier, got {:?}", stmt.value);
+    }
+
+    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(&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.rs → loader/trigger.rs}

@@ -26,7 +26,9 @@ pub fn load_trigger(
                 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) {
+            } 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);

package/rust/core/audio/mod.rs

@@ -2,4 +2,5 @@ pub mod engine;
 pub mod interpreter;
 pub mod loader;
 pub mod player;
-pub mod render;
+pub mod renderer;
+pub mod evaluator;

package/rust/core/audio/{render.rs → renderer.rs}

@@ -1,7 +1,11 @@
 use std::collections::HashMap;
 
 use crate::{
-    core::{ audio::{engine::AudioEngine, interpreter::interprete_statements}, parser::statement::Statement, store::global::GlobalStore },
+    core::{
+        audio::{ engine::AudioEngine, interpreter::driver::run_audio_program },
+        parser::statement::Statement,
+        store::global::GlobalStore,
+    },
     utils::logger::{ LogLevel, Logger },
 };
 
@@ -22,7 +26,7 @@ pub fn render_audio_with_modules(
         }
 
         // Interpret the statements to fill the audio buffer
-        let (mut audio_engine, module_base_bpm, module_max_end_time) = interprete_statements(
+        let (mut audio_engine, module_base_bpm, module_max_end_time) = run_audio_program(
             &statements,
             audio_engine,
             module_name.clone(),

package/rust/core/builder/mod.rs

@@ -1,4 +1,4 @@
-use crate::core::audio::render::render_audio_with_modules;
+use crate::core::audio::renderer::render_audio_with_modules;
 use crate::core::parser::statement::Statement;
 use crate::core::store::global::GlobalStore;
 use std::{ collections::HashMap, fs::create_dir_all };

package/rust/core/debugger/lexer.rs

@@ -1,5 +1,5 @@
 use std::{ collections::HashMap, fs::create_dir_all };
-use crate::core::{ debugger::Debugger, lexer::token::Token, parser::statement::Statement };
+use crate::core::{ debugger::Debugger, lexer::token::Token };
 
 pub fn write_lexer_log_file(
     output_dir: &str,

package/rust/core/debugger/mod.rs

@@ -1,5 +1,6 @@
 pub mod preprocessor;
 pub mod lexer;
+pub mod store;
 
 use std::io::Write;
 

package/rust/core/debugger/store.rs

@@ -0,0 +1,25 @@
+use std::{ collections::HashMap, fs::create_dir_all };
+use crate::core::{ debugger::Debugger, preprocessor::module::Module };
+
+pub fn write_store_log_file(output_dir: &str, file_name: &str, modules: HashMap<String, Module>) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
+
+    let log_directory = format!("{}/logs", output_dir);
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (path, module) in modules {
+        content.push_str(&format!("--- Module: {} ---\n", path));
+
+        for (index, var_value) in module.variable_table.variables.iter().enumerate() {
+            let var_name = var_value.0.clone();
+            let var_data = var_value.1;
+
+            content.push_str(&format!("{}: {:?} = {:?}\n", index + 1, var_name, var_data));
+        }
+
+        content.push_str("\n");
+    }
+
+    debugger.write_log_file(&log_directory, file_name, &content);
+}

package/rust/core/error/mod.rs

@@ -1,4 +1,4 @@
-use crate::core::parser::{ statement::{ Statement, StatementKind }, Parser };
+use crate::core::parser::{ statement::{ Statement, StatementKind }, driver::Parser };
 
 pub struct ErrorHandler {
     errors: Vec<Error>,