@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.2

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

@@ -1,67 +0,0 @@
-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/sleep.rs

@@ -1,36 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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/renderer.rs

@@ -1,54 +0,0 @@
-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/parser/driver.rs

@@ -1,331 +0,0 @@
-use crate::core::{
-    lexer::token::{ Token, TokenKind },
-    parser::{
-        handler::{
-            arrow_call::parse_arrow_call,
-            at::parse_at_token,
-            bank::parse_bank_token,
-            condition::parse_condition_token,
-            dot::parse_dot_token,
-            identifier::parse_identifier_token,
-            loop_::parse_loop_token,
-            tempo::parse_tempo_token,
-        },
-        statement::Statement,
-    },
-    shared::value::Value,
-    store::global::GlobalStore,
-};
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Parser {
-    pub resolve_modules: bool,
-    pub tokens: Vec<Token>,
-    pub token_index: usize,
-    pub current_module: String,
-    pub previous: Option<Token>,
-}
-
-impl Parser {
-    pub fn new() -> Self {
-        Parser {
-            resolve_modules: false,
-            tokens: Vec::new(),
-            token_index: 0,
-            current_module: String::new(),
-            previous: None,
-        }
-    }
-
-    pub fn set_current_module(&mut self, module_path: String) {
-        self.current_module = module_path;
-    }
-
-    pub fn advance(&mut self) -> Option<&Token> {
-        if self.is_eof() {
-            return None;
-        }
-
-        self.previous = self.tokens.get(self.token_index).cloned();
-        self.token_index += 1;
-
-        self.tokens.get(self.token_index - 1)
-    }
-
-    pub fn peek_is(&self, expected: &str) -> bool {
-        self.peek().map_or(false, |t| t.lexeme == expected)
-    }
-
-    pub fn peek_nth(&self, n: usize) -> Option<&Token> {
-        if self.token_index + n < self.tokens.len() {
-            self.tokens.get(self.token_index + n)
-        } else {
-            None
-        }
-    }
-
-    pub fn advance_if(&mut self, kind: TokenKind) -> bool {
-        if self.match_token(kind) { true } else { false }
-    }
-
-    pub fn match_token(&mut self, kind: TokenKind) -> bool {
-        if let Some(tok) = self.peek() {
-            if tok.kind == kind {
-                self.advance();
-                return true;
-            }
-        }
-        false
-    }
-
-    pub fn previous_clone(&self) -> Option<Token> {
-        self.previous.clone()
-    }
-
-    pub fn parse_block(
-        &self,
-        tokens: Vec<Token>,
-        global_store: &mut GlobalStore
-    ) -> Vec<Statement> {
-        let mut inner_parser = Parser {
-            resolve_modules: self.resolve_modules,
-            tokens,
-            token_index: 0,
-            current_module: self.current_module.clone(),
-            previous: None,
-        };
-
-        inner_parser.parse_tokens(inner_parser.tokens.clone(), global_store)
-    }
-
-    pub fn parse_tokens(
-        &mut self,
-        tokens: Vec<Token>,
-        global_store: &mut GlobalStore
-    ) -> Vec<Statement> {
-        self.tokens = tokens;
-        self.token_index = 0;
-
-        let mut statements = Vec::new();
-
-        while !self.is_eof() {
-            let token = match self.peek() {
-                Some(t) => t.clone(),
-                None => {
-                    break;
-                }
-            };
-
-            let statement = match &token.kind {
-                TokenKind::At => parse_at_token(self, global_store),
-                TokenKind::Identifier => {
-                    if let Some(next) = self.peek_nth(1).cloned() {
-                        if next.kind == TokenKind::Arrow {
-                            parse_arrow_call(self, global_store)
-                        } else {
-                            parse_identifier_token(self, global_store)
-                        }
-                    } else {
-                        parse_identifier_token(self, global_store)
-                    }
-                }
-                TokenKind::Dot => parse_dot_token(self, global_store),
-                TokenKind::Tempo => parse_tempo_token(self, global_store),
-                TokenKind::Bank => parse_bank_token(self, global_store),
-                TokenKind::Loop => parse_loop_token(self, global_store),
-                TokenKind::If => parse_condition_token(self, global_store),
-
-                | TokenKind::Else // Ignore else, already handled in `parse_condition_token`
-                | TokenKind::Comment
-                | TokenKind::Equals
-                | TokenKind::Colon
-                | TokenKind::Number
-                | TokenKind::String
-                | TokenKind::LBrace
-                | TokenKind::RBrace
-                | TokenKind::Comma
-                | TokenKind::Newline
-                | TokenKind::Dedent
-                | TokenKind::Indent => {
-                    self.advance();
-                    continue;
-                }
-
-                TokenKind::EOF => {
-                    break;
-                }
-
-                _ => {
-                    println!("Unhandled token: {:?}", token);
-                    self.advance();
-                    Statement::unknown()
-                }
-            };
-
-            statements.push(statement);
-        }
-
-        statements
-    }
-
-    pub fn check_token(&self, kind: TokenKind) -> bool {
-        self.peek().map_or(false, |t| t.kind == kind)
-    }
-
-    pub fn parse_map_value(&mut self) -> Option<Value> {
-        if !self.match_token(TokenKind::LBrace) {
-            return None;
-        }
-
-        let mut map = std::collections::HashMap::new();
-
-        while !self.check_token(TokenKind::RBrace) && !self.is_eof() {
-            let key = if let Some(token) = self.advance() {
-                token.lexeme.clone()
-            } else {
-                break;
-            };
-
-            if !self.match_token(TokenKind::Colon) {
-                println!("Expected ':' after map key '{}'", key);
-                break;
-            }
-
-            let value = if let Some(token) = self.peek_clone() {
-                match token.kind {
-                    TokenKind::String => {
-                        self.advance();
-                        Value::String(token.lexeme.clone())
-                    }
-                    TokenKind::Number => {
-                        self.advance();
-                        Value::Number(token.lexeme.parse().unwrap_or(0.0))
-                    }
-                    TokenKind::Identifier => {
-                        self.advance();
-                        Value::Identifier(token.lexeme.clone())
-                    }
-                    _ => {
-                        println!("Unexpected token in map value: {:?}", token);
-                        Value::Null
-                    }
-                }
-            } else {
-                Value::Null
-            };
-
-            map.insert(key, value);
-        }
-
-        if !self.match_token(TokenKind::RBrace) {
-            println!("Expected '}}' at end of map");
-        }
-
-        Some(Value::Map(map))
-    }
-
-    pub fn peek(&self) -> Option<&Token> {
-        self.tokens.get(self.token_index)
-    }
-
-    pub fn peek_clone(&self) -> Option<Token> {
-        self.tokens.get(self.token_index).cloned()
-    }
-
-    pub fn expect(&mut self, kind: TokenKind) -> Result<&Token, String> {
-        let tok = self.advance().ok_or("Unexpected end of input")?;
-        if tok.kind == kind {
-            Ok(tok)
-        } else {
-            Err(format!("Expected {:?}, got {:?}", kind, tok.kind))
-        }
-    }
-
-    pub fn collect_block_tokens(&mut self, base_indent: usize) -> Vec<Token> {
-        let mut tokens = Vec::new();
-
-        while let Some(tok) = self.peek() {
-            if tok.indent <= base_indent && tok.kind != TokenKind::Newline {
-                break;
-            }
-            tokens.push(self.advance().unwrap().clone());
-        }
-
-        tokens
-    }
-
-    pub fn collect_until<F>(&mut self, condition: F) -> Vec<Token> where F: Fn(&Token) -> bool {
-        let mut collected = Vec::new();
-        while let Some(token) = self.peek() {
-            if token.kind == TokenKind::Newline || token.kind == TokenKind::Indent {
-                self.advance(); // Skip newlines and indents
-                continue;
-            }
-            if token.kind == TokenKind::EOF {
-                break;
-            }
-            if condition(token) {
-                break;
-            }
-            collected.push(self.advance().unwrap().clone());
-        }
-        collected
-    }
-
-    pub fn is_eof(&self) -> bool {
-        self.token_index >= self.tokens.len()
-    }
-
-    pub fn parse_block_until_next_else(
-        &mut self,
-        base_indent: usize,
-        global_store: &mut GlobalStore
-    ) -> Vec<Statement> {
-        let mut block_tokens = Vec::new();
-
-        while let Some(tok) = self.peek() {
-            // Stop if we encounter an 'else' at same indent level
-            if tok.lexeme == "else" && tok.indent == base_indent {
-                break;
-            }
-            block_tokens.push(self.advance().unwrap().clone());
-        }
-
-        self.parse_block(block_tokens, global_store)
-    }
-
-    pub fn parse_condition_until_colon(&mut self) -> Option<Value> {
-        let tokens = self.collect_until(|t| t.kind == TokenKind::Colon);
-        if tokens.is_empty() {
-            return None;
-        }
-
-        let condition = tokens
-            .iter()
-            .map(|t| t.lexeme.clone())
-            .collect::<Vec<_>>()
-            .join(" ");
-
-        Some(Value::String(condition))
-    }
-
-    pub fn parse_block_until_else_or_dedent(
-        &mut self,
-        base_indent: usize,
-        global_store: &mut GlobalStore
-    ) -> Vec<Statement> {
-        let mut tokens = Vec::new();
-
-        while let Some(tok) = self.peek() {
-            if tok.lexeme == "else" && tok.indent == base_indent {
-                break;
-            }
-            if tok.indent < base_indent && tok.kind != TokenKind::Newline {
-                break;
-            }
-            tokens.push(self.advance().unwrap().clone());
-        }
-
-        self.parse_block(tokens, global_store)
-    }
-}