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

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

@@ -0,0 +1,66 @@
+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
+            )
+        }
+
+        _ => {
+            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.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/renderer.rs

@@ -0,0 +1,54 @@
+use std::collections::HashMap;
+
+use crate::{
+    core::{
+        audio::{ engine::AudioEngine, interpreter::driver::run_audio_program },
+        parser::statement::Statement,
+        store::global::GlobalStore,
+    },
+    utils::logger::{ LogLevel, Logger },
+};
+
+pub fn render_audio_with_modules(
+    modules: HashMap<String, Vec<Statement>>,
+    output_dir: &str,
+    global_store: &mut GlobalStore
+) -> HashMap<String, AudioEngine> {
+    let mut result = HashMap::new();
+
+    for (module_name, statements) in modules {
+        let mut global_max_end_time: f32 = 0.0;
+        let mut initial_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)
+            );
+            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);
+
+        result.insert(module_name, updated_engine);
+    }
+
+    result
+}

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>,

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

@@ -0,0 +1,31 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_arrow_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
+) {
+    let mut arrow_call = char.to_string();
+
+    while let Some(&c) = chars.peek() {
+        if c == '>' {
+            chars.next();
+            arrow_call.push(c);
+            *column += 1;
+        } else {
+            break;
+        }
+    }
+
+    tokens.push(Token {
+        kind: TokenKind::Arrow,
+        lexeme: arrow_call,
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+}

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

@@ -0,0 +1,226 @@
+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, string::handle_string_lexer
+    },
+    token::{ Token, TokenKind },
+};
+
+fn advance_char<I: Iterator<Item = char>>(
+    chars: &mut std::iter::Peekable<I>,
+    line: &mut usize,
+    column: &mut usize
+) -> Option<char> {
+    let c = chars.next()?;
+    if c == '\n' {
+        // Do not increment column on newline here
+    } else {
+        *column += 1;
+    }
+    Some(c)
+}
+
+pub fn handle_content_lexing(content: String) -> Result<Vec<Token>, String> {
+    let mut tokens = Vec::new();
+
+    let mut line = 1;
+    let mut column = 1;
+
+    let mut indent_stack: Vec<usize> = vec![0];
+    let mut current_indent = 0;
+    let mut at_line_start = true;
+
+    let mut chars = content.chars().peekable();
+
+    while chars.peek().is_some() {
+        if at_line_start {
+            handle_indent_lexer(
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            at_line_start = false;
+        }
+
+        let Some(ch) = advance_char(&mut chars, &mut line, &mut column) else {
+            break;
+        };
+
+        match ch {
+            '\n' => {
+                handle_newline_lexer(
+                    ch,
+                    &mut chars,
+                    &mut tokens,
+                    &mut line,
+                    &mut column,
+                    &mut at_line_start,
+                    &mut current_indent
+                );
+            }
+            ' ' | '\t' => {
+                // Already handled by indent_lexer
+            }
+            '#' => {
+                handle_comment_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            ':' => {
+                handle_colon_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '=' | '!' | '<' | '>' => {
+                handle_operator_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '-' => {
+                handle_arrow_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '{' => {
+                handle_lbrace_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '}' => {
+                handle_rbrace_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '.' => {
+                handle_dot_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '@' => {
+                handle_at_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '\"' | '\'' => {
+                handle_string_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            c if c.is_ascii_digit() => {
+                handle_number_lexer(
+                    c,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            c if c.is_ascii_alphabetic() => {
+                handle_identifier_lexer(
+                    c,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            _ => {
+                // Ignore unknown char
+            }
+        }
+    }
+
+    while indent_stack.len() > 1 {
+        indent_stack.pop();
+        current_indent = *indent_stack.last().unwrap();
+        tokens.push(Token {
+            kind: TokenKind::Dedent,
+            lexeme: String::new(),
+            line,
+            column,
+            indent: current_indent,
+        });
+    }
+
+    tokens.push(Token {
+        kind: TokenKind::EOF,
+        lexeme: String::new(),
+        line: line + 1,
+        column: 0,
+        indent: 0,
+    });
+
+    // NOTE: Debug only
+    // for token in &tokens {
+    //     println!(
+    //         "{:?} @ line {}, col {}, indent {}",
+    //         token.kind,
+    //         token.line,
+    //         token.column,
+    //         token.indent
+    //     );
+    // }
+
+    Ok(tokens)
+}

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

@@ -22,9 +22,12 @@ pub fn handle_identifier_lexer(
     }
 
     let kind = match ident.as_str() {
+        "if" => TokenKind::If,
+        "else" => TokenKind::Else,
         "bank" => TokenKind::Bank,
         "bpm" => TokenKind::Tempo,
         "loop" => TokenKind::Loop,
+        "synth" => TokenKind::Synth,
         _ => TokenKind::Identifier,
     };