@devaloop/devalang 0.0.1-alpha.12 → 0.0.1-alpha.13

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

@@ -15,105 +15,192 @@ pub fn interprete_trigger_statement(
     cursor_time: f32,
     max_end_time: f32
 ) -> Option<(f32, f32, AudioEngine)> {
-    if let StatementKind::Trigger { entity, duration } = &stmt.kind {
-        if let Some(trigger_val) = resolve_namespaced_variable(entity, variable_table) {
-            let duration_secs = match duration {
-                Duration::Number(n) => *n,
-
-                Duration::Identifier(id) => {
-                    if id == "auto" {
-                        1.0
+    if let StatementKind::Trigger { entity, duration, effects } = &stmt.kind {
+        let mut trigger_val = Value::String(entity.clone());
+        let mut trigger_src = String::new();
+
+        match variable_table.variables.get(entity) {
+            Some(Value::Identifier(id)) => {
+                // Get real value from global variable table
+                if let Some(global_table) = &variable_table.parent {
+                    if let Some(val) = global_table.get(id) {
+                        trigger_val = val.clone();
                     } 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;
-                            }
-                        }
+                        eprintln!("❌ Trigger entity '{}' not found in global variable table", id);
+                        return None;
                     }
+                } else if let Some(val) = variable_table.get(id) {
+                    trigger_val = val.clone();
+                } else {
+                    eprintln!("❌ Trigger entity '{}' not found in variable table", id);
+                    return None;
                 }
+            }
+            Some(Value::Sample(sample_src)) => {
+                // If the entity is a sample, we use its path directly
+                trigger_src = sample_src.clone();
+            }
+            Some(Value::Map(map)) => {
+                // If the entity is a map, we assume it contains an "entity" key
+                if let Some(Value::String(src)) = map.get("entity") {
+                    trigger_val = Value::String(src.clone());
+                } else if let Some(Value::Identifier(src)) = map.get("entity") {
+                    trigger_val = Value::Identifier(src.clone());
+                } else {
+                    eprintln!(
+                        "❌ Trigger map must contain an 'entity' key with a string or identifier value."
+                    );
+                    return None;
+                }
+            }
+            _ => {
+                trigger_val = Value::String(entity.clone());
+            }
+        }
 
-                Duration::Beat(beat_str) => {
-                    // Assuming beat_str is in the format "numerator/denominator"
-                    let parts: Vec<&str> = beat_str.split('/').collect();
-
-                    if parts.len() != 2 {
-                        eprintln!("❌ Invalid beat duration format: {}", beat_str);
-                        return None;
+        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;
+                        }
                     }
-
-                    let numerator: f32 = parts[0].parse().unwrap_or(1.0);
-                    let denominator: f32 = parts[1].parse().unwrap_or(1.0);
-                    numerator / denominator
                 }
+            }
 
-                Duration::Auto => 1.0,
-            };
+            Duration::Beat(beat_str) => {
+                let parts: Vec<&str> = beat_str.split('/').collect();
+                if parts.len() != 2 {
+                    eprintln!("❌ Invalid beat duration format: {}", beat_str);
+                    return None;
+                }
 
-            let duration_final = duration_secs * base_duration;
+                let numerator: f32 = parts[0].parse().unwrap_or(1.0);
+                let denominator: f32 = parts[1].parse().unwrap_or(4.0);
 
-            let (src, _) = load_trigger(
-                trigger_val,
-                duration,
-                base_duration,
-                variable_table.clone()
-            );
+                let beats = (numerator / denominator) * 4.0;
 
-            if let Some(effects) = extract_effects(stmt.value.clone()) {
-                audio_engine.insert_sample(&src, cursor_time, duration_final, Some(effects));
-            } else {
-                audio_engine.insert_sample(&src, cursor_time, duration_final, None);
+                beats * base_duration
             }
 
-            let mut updated_engine = audio_engine.clone();
+            Duration::Auto => base_duration,
+        };
 
-            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));
+        let final_variable_table = if let Some(parent) = &variable_table.parent {
+            VariableTable {
+                variables: parent.variables.clone(),
+                parent: None,
+            }
         } else {
-            eprintln!("❌ Unknown trigger entity: {}", entity);
+            variable_table.clone()
+        };
+
+        let (src, sample_length) = load_trigger(
+            &trigger_val,
+            duration,
+            effects,
+            base_duration,
+            final_variable_table.clone()
+        );
+
+        if trigger_src.is_empty() {
+            trigger_src = src;
         }
-    }
-
-    None
-}
 
-fn resolve_namespaced_variable<'a>(path: &str, variables: &'a VariableTable) -> Option<&'a Value> {
-    let mut current: Option<&Value> = None;
+        let effects = extract_effects(stmt.value.clone());
+        let one_shot = effects
+            .as_ref()
+            .and_then(|map| map.get("one_shot"))
+            .and_then(|v| {
+                match v {
+                    Value::Identifier(id) if id == "true" => Some(true),
+                    Value::String(s) if s == "true" => Some(true),
+                    _ => None,
+                }
+            })
+            .unwrap_or(false);
 
-    for (i, part) in path.split('.').enumerate() {
-        if i == 0 {
-            current = variables.get(part);
+        let play_length = if one_shot {
+            sample_length // play entire sample
         } else {
-            current = match current {
-                Some(Value::Map(map)) => map.get(part),
-                _ => {
+            duration_secs.min(sample_length)
+        };
+
+        let trigger_src = match trigger_val.get("entity") {
+            Some(Value::String(src)) => src.clone(),
+            Some(Value::Identifier(id)) => id.clone(),
+            Some(Value::Statement(stmt)) => {
+                if let StatementKind::Trigger { entity, .. } = &stmt.kind {
+                    entity.clone()
+                } else {
+                    eprintln!("❌ Invalid trigger statement in map: expected 'Trigger' kind");
                     return None;
                 }
-            };
+            }
+            _ => trigger_src,
+        };
+
+        if let Some(effects_map) = effects {
+            audio_engine.insert_sample(
+                &trigger_src,
+                cursor_time,
+                play_length,
+                Some(effects_map),
+                &final_variable_table
+            );
+        } else {
+            audio_engine.insert_sample(
+                &trigger_src,
+                cursor_time,
+                play_length,
+                None,
+                &final_variable_table
+            );
         }
+
+        let new_cursor_time = cursor_time + duration_secs; // advance by beat duration
+        let new_max_end_time = (cursor_time + play_length).max(max_end_time);
+
+        let updated_engine = audio_engine.clone();
+
+        return Some((new_cursor_time, new_max_end_time, updated_engine));
     }
 
-    current
+    None
 }
 
 fn extract_effects(value: Value) -> Option<HashMap<String, Value>> {
-    if let Value::Map(map) = value.clone() {
+    if let Value::Map(map) = value {
         let mut effects = HashMap::new();
 
         for (key, val) in map {
-            effects.insert(key.clone(), val);
+            if key == "effects" {
+                if let Value::Map(effect_map) = val {
+                    for (effect_key, effect_val) in effect_map {
+                        effects.insert(effect_key, effect_val);
+                    }
+                } else {
+                    return None; // effects must be a map
+                }
+            } else {
+                return Some(effects);
+            }
         }
 
         Some(effects)

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

@@ -1,8 +1,13 @@
-use crate::core::{ shared::{ duration::Duration, value::Value }, store::variable::VariableTable };
+use crate::core::{
+    parser::statement::StatementKind,
+    shared::{ duration::Duration, value::Value },
+    store::variable::VariableTable,
+};
 
 pub fn load_trigger(
     trigger: &Value,
     duration: &Duration,
+    effects: &Option<Value>,
     base_duration: f32,
     variable_table: VariableTable
 ) -> (String, f32) {
@@ -13,8 +18,36 @@ pub fn load_trigger(
         Value::String(src) => {
             trigger_path = src.to_string();
         }
+        Value::Identifier(src) => {
+            trigger_path = src.to_string();
+        }
+
+        Value::Map(map) => {
+            if let Some(Value::String(src)) = map.get("entity") {
+                trigger_path = format!("devalang://bank/{}", src.to_string());
+            } else if let Some(Value::Identifier(src)) = map.get("entity") {
+                trigger_path = format!("devalang://bank/{}", src.to_string());
+            } else {
+                eprintln!(
+                    "❌ Trigger map must contain an 'entity' key with a string or identifier value."
+                );
+            }
+        }
+        Value::Sample(src) => {
+            trigger_path = src.to_string();
+        }
+        Value::Statement(stmt) => {
+            if let StatementKind::Trigger { entity, duration, effects } = &stmt.kind {
+                trigger_path = entity.clone();
+            } else {
+                eprintln!("❌ Trigger statement must be of type 'Trigger', found: {:?}", stmt.kind);
+            }
+        }
         _ => {
-            eprintln!("❌ Invalid trigger type. Expected a text variable.");
+            eprintln!(
+                "❌ Invalid trigger type. Expected a string or identifier variable, found: {:?}",
+                trigger
+            );
         }
     }
 
@@ -45,11 +78,11 @@ pub fn load_trigger(
 
         Duration::Beat(beat_str) => {
             let parts: Vec<&str> = beat_str.split('/').collect();
-            
+
             if parts.len() == 2 {
                 let numerator: f32 = parts[0].parse().unwrap_or(1.0);
                 let denominator: f32 = parts[1].parse().unwrap_or(1.0);
-                duration_as_secs = numerator / denominator * base_duration;
+                duration_as_secs = (numerator / denominator) * base_duration;
             } else {
                 eprintln!("❌ Invalid beat duration format: {}", beat_str);
             }

package/rust/core/audio/player.rs

@@ -21,23 +21,33 @@ impl AudioPlayer {
         }
     }
 
-    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()
+    fn load_source(&self, path: &str) -> Option<impl Source<Item = f32> + Send + 'static> {
+        if let Ok(file) = File::open(path) {
+            let reader = BufReader::new(file);
+            match Decoder::new(reader) {
+                Ok(decoder) => Some(decoder.convert_samples()),
+                Err(e) => {
+                    eprintln!("❌ Failed to decode audio file '{}': {}", path, e);
+                    None
+                }
+            }
+        } else {
+            eprintln!("❌ Could not open audio file: {}", path);
+            None
+        }
     }
 
     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());
+        if let Some(source) = self.load_source(path) {
+            self.sink.append(source);
+            self.last_path = Some(path.to_string());
+        } else {
+            eprintln!("⚠️ Skipping playback: failed to load '{}'", path);
+        }
     }
 
     pub fn replay_last(&mut self) {

package/rust/core/audio/renderer.rs

@@ -1,5 +1,4 @@
 use std::collections::HashMap;
-
 use crate::{
     core::{
         audio::{ engine::AudioEngine, interpreter::driver::run_audio_program },
@@ -18,36 +17,36 @@ pub fn render_audio_with_modules(
 
     for (module_name, statements) in modules {
         let mut global_max_end_time: f32 = 0.0;
-        let mut initial_engine = AudioEngine::new(module_name.clone());
+        let mut audio_engine = AudioEngine::new(module_name.clone());
 
         // Apply global variables to the initial engine
         if let Some(module) = global_store.get_module(&module_name) {
-            initial_engine.set_variables(module.variable_table.clone());
-        }
-
-        // interprete statements to fill the audio buffer
-        let (mut updated_engine, _bpm, module_max_end_time) = run_audio_program(
-            &statements,
-            initial_engine,
-            module_name.clone(),
-            output_dir.to_string()
-        );
-
-        // Verify if the buffer is silent (all samples are zero)
-        if updated_engine.buffer.iter().all(|&s| s == 0) {
-            let logger = Logger::new();
-            logger.log_message(
-                LogLevel::Warning,
-                &format!("Module '{}' ignored: silent buffer (no non-zero samples)", module_name)
+            // interprete statements to fill the audio buffer
+            let (module_max_end_time, cursor_time) = run_audio_program(
+                &statements,
+                &mut audio_engine,
+                module_name.clone(),
+                output_dir.to_string(),
+                module.variable_table.clone(),
+                module.function_table.clone(),
+                global_store
             );
-            continue;
-        }
 
-        // Determines the maximum end time for the module
-        global_max_end_time = global_max_end_time.max(module_max_end_time);
-        updated_engine.set_duration(global_max_end_time);
+            // Verify if the buffer is silent (all samples are zero)
+            if audio_engine.buffer.iter().all(|&s| s == 0) {
+                let logger = Logger::new();
+                logger.log_message(
+                    LogLevel::Warning,
+                    &format!("Module '{}' ignored: silent buffer (no non-zero samples)", module_name)
+                );
+            }
+
+            // Determines the maximum end time for the module
+            global_max_end_time = global_max_end_time.max(module_max_end_time);
+            audio_engine.set_duration(global_max_end_time);
 
-        result.insert(module_name, updated_engine);
+            result.insert(module_name, audio_engine);
+        }
     }
 
     result

package/rust/core/debugger/mod.rs

@@ -1,6 +1,7 @@
 pub mod preprocessor;
 pub mod lexer;
 pub mod store;
+pub mod module;
 
 use std::io::Write;
 
@@ -13,6 +14,7 @@ impl 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");
 

package/rust/core/debugger/module.rs

@@ -0,0 +1,47 @@
+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);
+}

package/rust/core/debugger/store.rs

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

package/rust/core/error/mod.rs

@@ -4,6 +4,12 @@ pub struct ErrorHandler {
     errors: Vec<Error>,
 }
 
+pub struct ErrorResult {
+    pub message: String,
+    pub line: usize,
+    pub column: usize,
+}
+
 pub struct Error {
     pub message: String,
     pub line: usize,

package/rust/core/lexer/handler/driver.rs

@@ -1,6 +1,6 @@
 use crate::core::lexer::{
     handler::{
-        arrow::handle_arrow_lexer, at::handle_at_lexer, brace::{ handle_lbrace_lexer, handle_rbrace_lexer }, colon::handle_colon_lexer, comment::handle_comment_lexer, dot::handle_dot_lexer, identifier::handle_identifier_lexer, indent::handle_indent_lexer, newline::handle_newline_lexer, number::handle_number_lexer, operator::handle_operator_lexer, slash::handle_slash_lexer, string::handle_string_lexer
+        arrow::handle_arrow_lexer, at::handle_at_lexer, brace::{ handle_lbrace_lexer, handle_rbrace_lexer }, colon::handle_colon_lexer, comment::handle_comment_lexer, dot::handle_dot_lexer, identifier::handle_identifier_lexer, indent::handle_indent_lexer, newline::handle_newline_lexer, number::handle_number_lexer, operator::handle_operator_lexer, parenthesis::{handle_lparen_lexer, handle_rparen_lexer}, slash::handle_slash_lexer, string::handle_string_lexer
     },
     token::{ Token, TokenKind },
 };
@@ -145,6 +145,28 @@ pub fn handle_content_lexing(content: String) -> Result<Vec<Token>, String> {
                     &mut column
                 );
             }
+            '(' => {
+                handle_lparen_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            ')' => {
+                handle_rparen_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
             '.' => {
                 handle_dot_lexer(
                     ch,

package/rust/core/lexer/handler/identifier.rs

@@ -28,6 +28,7 @@ pub fn handle_identifier_lexer(
         "bpm" => TokenKind::Tempo,
         "loop" => TokenKind::Loop,
         "synth" => TokenKind::Synth,
+        "fn" => TokenKind::Function,
         _ => TokenKind::Identifier,
     };
 

package/rust/core/lexer/handler/mod.rs

@@ -13,3 +13,4 @@ pub mod indent;
 pub mod string;
 pub mod arrow;
 pub mod slash;
+pub mod parenthesis;

package/rust/core/lexer/handler/parenthesis.rs

@@ -0,0 +1,41 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_rparen_lexer(
+    char: char,
+    chars: &mut std::iter::Peekable<std::str::Chars>,
+    current_indent: &mut usize,
+    indent_stack: &mut Vec<usize>,
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize
+) {
+    tokens.push(Token {
+        kind: TokenKind::RParen,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}
+
+pub fn handle_lparen_lexer(
+    char: char,
+    chars: &mut std::iter::Peekable<std::str::Chars>,
+    current_indent: &mut usize,
+    indent_stack: &mut Vec<usize>,
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize
+) {
+    tokens.push(Token {
+        kind: TokenKind::LParen,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}