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

package/rust/core/audio/special/modulator.rs

@@ -0,0 +1,143 @@
+use crate::core::store::variable::VariableTable;
+
+fn lfo_sine(rate_per_beat: f32, beat: f32) -> f32 {
+    // Output in [-1,1]
+    (2.0 * std::f32::consts::PI * rate_per_beat * beat).sin()
+}
+
+fn lfo_triangle(rate_per_beat: f32, beat: f32) -> f32 {
+    // Triangle in [-1,1]
+    let phase = (rate_per_beat * beat).fract();
+    // Map [0,1]->[-1,1] tri
+    4.0 * (phase - 0.5).abs() - 1.0
+}
+
+fn adsr_envelope_value_t(attack: f32, decay: f32, sustain: f32, release: f32, t: f32) -> f32 {
+    let a = attack.max(0.0);
+    let d = decay.max(0.0);
+    let r = release.max(0.0);
+    let s = sustain.clamp(0.0, 1.0);
+
+    // Normalize phases so that the whole ADSR spans t in [0,1]
+    let total = (a + d + r).max(1e-6);
+    let ap = a / total;
+    let dp = d / total;
+    let rp = r / total;
+
+    if t < ap {
+        // attack (0->1)
+        if ap > 0.0 { t / ap } else { 1.0 }
+    } else if t < ap + dp {
+        // decay (1->sustain)
+        let u = (t - ap) / dp.max(1e-6);
+        1.0 - (1.0 - s) * u
+    } else if t < 1.0 - rp {
+        // sustain
+        s
+    } else {
+        // release (sustain->0)
+        let u = (t - (1.0 - rp)) / rp.max(1e-6);
+        s * (1.0 - u)
+    }
+}
+
+fn eval_mod_func(func: &str, args: &[f32], beat: f32) -> Option<f32> {
+    match func {
+        "lfo.sine" => {
+            let rate = args.get(0).copied().unwrap_or(1.0);
+            Some(lfo_sine(rate, beat))
+        }
+        "lfo.tri" | "lfo.triangle" => {
+            let rate = args.get(0).copied().unwrap_or(1.0);
+            Some(lfo_triangle(rate, beat))
+        }
+        // ADSR envelope normalized over t in [0,1]
+        // $mod.envelope(attack, decay, sustain, release, t)
+        "envelope" | "mod.envelope" => {
+            if args.len() >= 5 {
+                Some(adsr_envelope_value_t(
+                    args[0],
+                    args[1],
+                    args[2],
+                    args[3],
+                    args[4].clamp(0.0, 1.0),
+                ))
+            } else {
+                None
+            }
+        }
+        _ => None,
+    }
+}
+
+fn parse_top_level_args(s: &str) -> Vec<&str> {
+    let mut args = Vec::new();
+    let mut depth = 0i32;
+    let mut start = 0usize;
+    for (i, ch) in s.char_indices() {
+        match ch {
+            '(' => depth += 1,
+            ')' => depth -= 1,
+            ',' if depth == 0 => {
+                args.push(s[start..i].trim());
+                start = i + 1;
+            }
+            _ => {}
+        }
+    }
+    let last = s[start..].trim();
+    if !last.is_empty() {
+        args.push(last);
+    }
+    args
+}
+
+// Find and evaluate the first $mod.<fn>(...) occurrence in the string.
+pub fn find_and_eval_first_mod_call<EvalFn>(
+    s: &str,
+    eval: EvalFn,
+    vars: &VariableTable,
+    bpm: f32,
+    beat: f32,
+) -> Option<String>
+where
+    EvalFn: Fn(&str, &VariableTable, f32, f32) -> Option<f32>,
+{
+    let start = s.find("$mod.")?;
+    let open_rel = s[start..].find('(')?;
+    let open = start + open_rel;
+    let func = &s[start + 5..open];
+
+    // matching close
+    let mut depth: i32 = 0;
+    let mut close_abs: Option<usize> = None;
+    for (i, ch) in s[open..].char_indices() {
+        match ch {
+            '(' => depth += 1,
+            ')' => {
+                depth -= 1;
+                if depth == 0 {
+                    close_abs = Some(open + i);
+                    break;
+                }
+            }
+            _ => {}
+        }
+    }
+    let close = close_abs?;
+
+    let inner = &s[open + 1..close];
+    let raw_args = parse_top_level_args(inner);
+    let mut args: Vec<f32> = Vec::with_capacity(raw_args.len());
+    for a in raw_args {
+        args.push(eval(a, vars, bpm, beat)?);
+    }
+
+    let result = eval_mod_func(func, &args, beat)?;
+
+    let mut replaced = String::new();
+    replaced.push_str(&s[..start]);
+    replaced.push_str(&result.to_string());
+    replaced.push_str(&s[close + 1..]);
+    Some(replaced)
+}

package/rust/core/builder/mod.rs

@@ -1,85 +1,80 @@
-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 };
-use std::io::Write;
-use crate::utils::logger::Logger;
-
-pub struct Builder {}
-
-impl Builder {
-    pub fn new() -> Self {
-        Builder {}
-    }
-
-    pub fn build_ast(
-        &self,
-        modules: &HashMap<String, Vec<Statement>>,
-        out_dir: &str,
-        compress: bool
-    ) {
-        for (name, statements) in modules {
-            let formatted_name = name.split("/").last().unwrap_or(name);
-            let formatted_name = formatted_name.replace(".deva", "");
-
-            create_dir_all(format!("{}/ast", out_dir)).expect("Failed to create AST directory");
-
-            let file_path = format!("{}/ast/{}.json", out_dir, formatted_name);
-            let mut file = std::fs::File::create(file_path).expect("Failed to create AST file");
-            let content = if compress {
-                serde_json::to_string(&statements).expect("Failed to serialize AST")
-            } else {
-                serde_json::to_string_pretty(&statements).expect("Failed to serialize AST")
-            };
-
-            file.write_all(content.as_bytes()).expect("Failed to write AST to file");
-        }
-    }
-
-    pub fn build_audio(
-        &self,
-        modules: &HashMap<String, Vec<Statement>>,
-        normalized_output_dir: &str,
-        global_store: &mut GlobalStore
-    ) {
-        let logger = Logger::new();
-
-        let audio_engines = render_audio_with_modules(
-            modules.clone(),
-            &normalized_output_dir,
-            global_store
-        );
-
-        create_dir_all(format!("{}/audio", normalized_output_dir)).expect(
-            "Failed to create audio directory"
-        );
-
-        for (module_name, mut audio_engine) in audio_engines {
-            let formatted_module_name = module_name
-                .split('/')
-                .last()
-                .unwrap_or(&module_name)
-                .replace(".deva", "");
-
-            let output_path = format!(
-                "{}/audio/{}.wav",
-                normalized_output_dir,
-                formatted_module_name
-            );
-
-            match audio_engine.generate_wav_file(&output_path) {
-                Ok(_) => {}
-                Err(msg) => {
-                    logger.log_error_with_stacktrace(
-                        &format!(
-                            "Unable to generate WAV file for module '{}': {}",
-                            formatted_module_name,
-                            msg
-                        ),
-                        &module_name
-                    );
-                }
-            }
-        }
-    }
-}
+use crate::core::audio::renderer::render_audio_with_modules;
+use crate::core::parser::statement::Statement;
+use crate::core::store::global::GlobalStore;
+use crate::utils::logger::Logger;
+use std::io::Write;
+use std::{collections::HashMap, fs::create_dir_all};
+
+pub struct Builder {}
+
+impl Builder {
+    pub fn new() -> Self {
+        Builder {}
+    }
+
+    pub fn build_ast(
+        &self,
+        modules: &HashMap<String, Vec<Statement>>,
+        out_dir: &str,
+        compress: bool,
+    ) {
+        for (name, statements) in modules {
+            let formatted_name = name.split("/").last().unwrap_or(name);
+            let formatted_name = formatted_name.replace(".deva", "");
+
+            create_dir_all(format!("{}/ast", out_dir)).expect("Failed to create AST directory");
+
+            let file_path = format!("{}/ast/{}.json", out_dir, formatted_name);
+            let mut file = std::fs::File::create(file_path).expect("Failed to create AST file");
+            let content = if compress {
+                serde_json::to_string(&statements).expect("Failed to serialize AST")
+            } else {
+                serde_json::to_string_pretty(&statements).expect("Failed to serialize AST")
+            };
+
+            file.write_all(content.as_bytes())
+                .expect("Failed to write AST to file");
+        }
+    }
+
+    pub fn build_audio(
+        &self,
+        modules: &HashMap<String, Vec<Statement>>,
+        normalized_output_dir: &str,
+        global_store: &mut GlobalStore,
+    ) {
+        let logger = Logger::new();
+
+        let audio_engines =
+            render_audio_with_modules(modules.clone(), &normalized_output_dir, global_store);
+
+        create_dir_all(format!("{}/audio", normalized_output_dir))
+            .expect("Failed to create audio directory");
+
+        for (module_name, mut audio_engine) in audio_engines {
+            let formatted_module_name = module_name
+                .split('/')
+                .last()
+                .unwrap_or(&module_name)
+                .replace(".deva", "");
+
+            let output_path = format!(
+                "{}/audio/{}.wav",
+                normalized_output_dir, formatted_module_name
+            );
+
+            match audio_engine.generate_wav_file(&output_path) {
+                Ok(_) => {}
+                Err(msg) => {
+                    logger.log_error_with_stacktrace(
+                        &format!(
+                            "Unable to generate WAV file for module '{}': {}",
+                            formatted_module_name, msg
+                        ),
+                        &module_name,
+                    );
+                }
+            }
+        }
+    }
+}

package/rust/core/debugger/lexer.rs

@@ -1,27 +1,27 @@
-use std::{ collections::HashMap, fs::create_dir_all };
-use crate::core::{ debugger::Debugger, lexer::token::Token };
-
-pub fn write_lexer_log_file(
-    output_dir: &str,
-    file_name: &str,
-    modules: HashMap<String, Vec<Token>>
-) {
-    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, tokens) in modules {
-        content.push_str(&format!("--- Resolved Tokens for {} ---\n", path));
-
-        for token in tokens {
-            content.push_str(&format!("{:?}\n", token));
-        }
-
-        content.push_str("\n");
-    }
-
-    debugger.write_log_file(&log_directory, file_name, &content);
-}
+use crate::core::{debugger::Debugger, lexer::token::Token};
+use std::{collections::HashMap, fs::create_dir_all};
+
+pub fn write_lexer_log_file(
+    output_dir: &str,
+    file_name: &str,
+    modules: HashMap<String, Vec<Token>>,
+) {
+    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, tokens) in modules {
+        content.push_str(&format!("--- Resolved Tokens for {} ---\n", path));
+
+        for token in tokens {
+            content.push_str(&format!("{:?}\n", token));
+        }
+
+        content.push_str("\n");
+    }
+
+    debugger.write_log_file(&log_directory, file_name, &content);
+}

package/rust/core/debugger/mod.rs

@@ -1,23 +1,24 @@
-pub mod preprocessor;
-pub mod lexer;
-pub mod store;
-pub mod module;
-
-use std::io::Write;
-
-pub struct Debugger {}
-
-impl Debugger {
-    pub fn new() -> Self {
-        Debugger {}
-    }
-
-    pub fn write_log_file(&self, path: &str, filename: &str, content: &str) {
-        std::fs::create_dir_all(path).expect("Failed to create directory");
-
-        let file_path = format!("{}/{}", path, filename);
-        let mut file = std::fs::File::create(file_path).expect("Failed to create file");
-
-        file.write_all(content.as_bytes()).expect("Failed to write to file");
-    }
-}
+pub mod lexer;
+pub mod module;
+pub mod preprocessor;
+pub mod store;
+
+use std::io::Write;
+
+pub struct Debugger {}
+
+impl Debugger {
+    pub fn new() -> Self {
+        Debugger {}
+    }
+
+    pub fn write_log_file(&self, path: &str, filename: &str, content: &str) {
+        std::fs::create_dir_all(path).expect("Failed to create directory");
+
+        let file_path = format!("{}/{}", path, filename);
+        let mut file = std::fs::File::create(file_path).expect("Failed to create file");
+
+        file.write_all(content.as_bytes())
+            .expect("Failed to write to file");
+    }
+}

package/rust/core/debugger/module.rs

@@ -1,47 +1,55 @@
-use std::{ fs::create_dir_all };
-use crate::core::{
-    debugger::Debugger,
-    store::{ function::FunctionTable, variable::VariableTable },
-};
-
-pub fn write_module_variable_log_file(
-    output_dir: &str,
-    module_path: &str,
-    variable_table: &VariableTable
-) {
-    let debugger = Debugger::new();
-    let mut content = String::new();
-    let module_name = module_path.split('/').last().unwrap_or("index").replace(".deva", "");
-
-    let log_directory = format!("{}/logs/modules/{}", output_dir, module_name);
-    create_dir_all(&log_directory).expect("Failed to create log directory");
-
-    for (var_name, var_data) in &variable_table.variables {
-        content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
-    }
-
-    content.push_str("\n");
-
-    debugger.write_log_file(&log_directory, "variables.log", &content);
-}
-
-pub fn write_module_function_log_file(
-    output_dir: &str,
-    module_path: &str,
-    function_table: &FunctionTable
-) {
-    let debugger = Debugger::new();
-    let mut content = String::new();
-    let module_name = module_path.split('/').last().unwrap_or("index").replace(".deva", "");
-
-    let log_directory = format!("{}/logs/modules/{}", output_dir, module_name);
-    create_dir_all(&log_directory).expect("Failed to create log directory");
-
-    for (func_name, func_data) in &function_table.functions {
-        content.push_str(&format!("{:?} = {:?}\n", func_name, func_data));
-    }
-
-    content.push_str("\n");
-
-    debugger.write_log_file(&log_directory, "functions.log", &content);
-}
+use crate::core::{
+    debugger::Debugger,
+    store::{function::FunctionTable, variable::VariableTable},
+};
+use std::fs::create_dir_all;
+
+pub fn write_module_variable_log_file(
+    output_dir: &str,
+    module_path: &str,
+    variable_table: &VariableTable,
+) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
+    let module_name = module_path
+        .split('/')
+        .last()
+        .unwrap_or("index")
+        .replace(".deva", "");
+
+    let log_directory = format!("{}/logs/modules/{}", output_dir, module_name);
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (var_name, var_data) in &variable_table.variables {
+        content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
+    }
+
+    content.push_str("\n");
+
+    debugger.write_log_file(&log_directory, "variables.log", &content);
+}
+
+pub fn write_module_function_log_file(
+    output_dir: &str,
+    module_path: &str,
+    function_table: &FunctionTable,
+) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
+    let module_name = module_path
+        .split('/')
+        .last()
+        .unwrap_or("index")
+        .replace(".deva", "");
+
+    let log_directory = format!("{}/logs/modules/{}", output_dir, module_name);
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (func_name, func_data) in &function_table.functions {
+        content.push_str(&format!("{:?} = {:?}\n", func_name, func_data));
+    }
+
+    content.push_str("\n");
+
+    debugger.write_log_file(&log_directory, "functions.log", &content);
+}

package/rust/core/debugger/preprocessor.rs

@@ -1,27 +1,27 @@
-use std::{ collections::HashMap, fs::create_dir_all };
-use crate::core::{ debugger::Debugger, parser::statement::Statement };
-
-pub fn write_preprocessor_log_file(
-    output_dir: &str,
-    file_name: &str,
-    modules: HashMap<String, Vec<Statement>>
-) {
-    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, stmts) in modules {
-        content.push_str(&format!("--- Resolved Statements for {} ---\n", path));
-
-        for stmt in stmts {
-            content.push_str(&format!("{:?}\n", stmt));
-        }
-
-        content.push_str("\n");
-    }
-
-    debugger.write_log_file(&log_directory, file_name, &content);
-}
+use crate::core::{debugger::Debugger, parser::statement::Statement};
+use std::{collections::HashMap, fs::create_dir_all};
+
+pub fn write_preprocessor_log_file(
+    output_dir: &str,
+    file_name: &str,
+    modules: HashMap<String, Vec<Statement>>,
+) {
+    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, stmts) in modules {
+        content.push_str(&format!("--- Resolved Statements for {} ---\n", path));
+
+        for stmt in stmts {
+            content.push_str(&format!("{:?}\n", stmt));
+        }
+
+        content.push_str("\n");
+    }
+
+    debugger.write_log_file(&log_directory, file_name, &content);
+}

package/rust/core/debugger/store.rs

@@ -1,39 +1,40 @@
-use std::{ fs::create_dir_all };
-use crate::core::{
-    debugger::Debugger,
-    store::{ function::FunctionTable, variable::VariableTable },
-};
-
-pub fn write_variables_log_file(output_dir: &str, file_name: &str, variables: VariableTable) {
-    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 (var_name, var_data) in variables.variables {
-        content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
-    }
-
-    content.push_str("\n");
-
-    debugger.write_log_file(&log_directory, file_name, &content);
-}
-
-pub fn write_function_log_file(output_dir: &str, file_name: &str, functions: FunctionTable) {
-    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 (index, function) in functions.functions {
-        content.push_str(
-            &format!("'{}' = [{:?}] => {:?}\n", function.name, function.parameters, function.body)
-        );
-    }
-
-    content.push_str("\n");
-
-    debugger.write_log_file(&log_directory, file_name, &content);
-}
+use crate::core::{
+    debugger::Debugger,
+    store::{function::FunctionTable, variable::VariableTable},
+};
+use std::fs::create_dir_all;
+
+pub fn write_variables_log_file(output_dir: &str, file_name: &str, variables: VariableTable) {
+    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 (var_name, var_data) in variables.variables {
+        content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
+    }
+
+    content.push_str("\n");
+
+    debugger.write_log_file(&log_directory, file_name, &content);
+}
+
+pub fn write_function_log_file(output_dir: &str, file_name: &str, functions: FunctionTable) {
+    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 (_index, function) in functions.functions {
+        content.push_str(&format!(
+            "'{}' = [{:?}] => {:?}\n",
+            function.name, function.parameters, function.body
+        ));
+    }
+
+    content.push_str("\n");
+
+    debugger.write_log_file(&log_directory, file_name, &content);
+}