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

package/rust/core/audio/interpreter.rs

@@ -1,317 +0,0 @@
-use crate::{
-    core::{
-        audio::{ engine::AudioEngine, loader::load_trigger },
-        parser::statement::{ Statement, StatementKind },
-        shared::{ duration::Duration, value::Value },
-        store::variable::VariableTable,
-    },
-};
-
-pub fn interprete_statements(
-    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_statements(
-        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_statements(
-    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 { source, alias } => {
-                variable_table.set(alias.to_string(), Value::String(source.clone()));
-            }
-
-            StatementKind::Let { name } => {
-                variable_table.set(name.to_string(), stmt.value.clone());
-            }
-
-            StatementKind::Tempo => {
-                if let Value::Number(bpm_) = &stmt.value {
-                    base_bpm = *bpm_ as f32;
-                    base_duration = 60.0 / base_bpm;
-                } else {
-                    eprintln!("❌ Invalid tempo value: {:?}", stmt.value);
-                }
-            }
-
-            StatementKind::Trigger { entity, duration } => {
-                if let Some(trigger_val) = variable_table.get(entity) {
-                    // Étape 1 : Résolution de duration
-                    let duration_secs = match duration {
-                        Duration::Number(n) => *n,
-
-                        Duration::Identifier(id) => {
-                            if id == "auto" {
-                                1.0 // Valeur par défaut pour "auto"
-                            } else {
-                                match variable_table.get(id) {
-                                    Some(Value::Number(n)) => *n,
-                                    Some(Value::Identifier(other)) => {
-                                        if other == "auto" {
-                                            1.0 // Valeur par défaut pour "auto"
-                                        } else {
-                                            eprintln!("❌ Invalid duration identifier '{}': expected number or string, got identifier", id);
-                                            continue;
-                                        }
-                                    }
-                                    Some(other) => {
-                                        eprintln!(
-                                            "❌ Invalid duration reference '{}': expected number or string, got {:?}",
-                                            id,
-                                            other
-                                        );
-                                        continue;
-                                    }
-                                    None => {
-                                        eprintln!("❌ Duration identifier '{}' not found in variable table", id);
-                                        continue;
-                                    }
-                                }
-                            }
-                        }
-
-                        Duration::Auto => {
-                            // Si "auto", tu choisis une valeur par défaut ou duration du sample ?
-                            1.0 // ← par exemple 1.0 beat
-                        }
-                    };
-
-                    // Durée réelle en secondes selon tempo
-                    let duration_final = duration_secs * base_duration;
-
-                    // Chargement de l'audio
-                    let (src, _) = load_trigger(
-                        trigger_val,
-                        duration,
-                        base_duration,
-                        variable_table.clone()
-                    );
-
-                    audio_engine.insert(&src, cursor_time, duration_final, None);
-
-                    cursor_time += duration_final;
-                    if cursor_time > max_end_time {
-                        max_end_time = cursor_time;
-                    }
-                } else {
-                    eprintln!("❌ Unknown trigger entity: {}", entity);
-                }
-            }
-
-            StatementKind::Spawn => {
-                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;
-
-                                for inner_stmt in block {
-                                    let (inner_engine, _, inner_end_time) =
-                                        execute_audio_statements(
-                                            audio_engine.clone(),
-                                            variable_table.clone(),
-                                            vec![inner_stmt.clone()],
-                                            base_bpm,
-                                            base_duration,
-                                            max_end_time,
-                                            cursor_time // <- important: same cursor time
-                                        );
-                                    audio_engine = inner_engine;
-                                    if inner_end_time > local_max {
-                                        local_max = inner_end_time;
-                                    }
-                                }
-
-                                // Update cursor once all done
-                                if local_max > max_end_time {
-                                    max_end_time = local_max;
-                                }
-                                cursor_time = local_max;
-                            }
-                        }
-                        _ => eprintln!("❌ Cannot spawn '{}'", identifier),
-                    }
-                }
-            }
-
-            StatementKind::Sleep => {
-                let duration_secs = match &stmt.value {
-                    Value::Number(ms) => *ms / 1000.0,
-
-                    Value::String(s) if s.ends_with("ms") => {
-                        let ms = s.trim_end_matches("ms").parse::<f32>();
-                        match ms {
-                            Ok(ms) => ms / 1000.0,
-                            Err(_) => {
-                                eprintln!("❌ Invalid sleep value (ms): {}", s);
-                                continue;
-                            }
-                        }
-                    }
-
-                    Value::String(s) if s.ends_with("s") => {
-                        let s_ = s.trim_end_matches("s").parse::<f32>();
-                        match s_ {
-                            Ok(secs) => secs,
-                            Err(_) => {
-                                eprintln!("❌ Invalid sleep value (s): {}", s);
-                                continue;
-                            }
-                        }
-                    }
-
-                    other => {
-                        eprintln!("❌ Invalid sleep value: {:?}", other);
-                        continue;
-                    }
-                };
-
-                cursor_time += duration_secs;
-
-                if cursor_time > max_end_time {
-                    max_end_time = cursor_time;
-                }
-            }
-
-            StatementKind::Loop => {
-                if let Value::Map(loop_value) = &stmt.value {
-                    let iterator = loop_value.get("iterator");
-                    let body = loop_value.get("body");
-
-                    let loop_count = if let Some(Value::Number(n)) = iterator {
-                        *n as usize
-                    } else {
-                        eprintln!("❌ Loop iterator must be a number: {:?}", iterator);
-                        continue;
-                    };
-
-                    let loop_body = if let Some(Value::Block(body)) = body {
-                        body.clone()
-                    } else {
-                        eprintln!("❌ Loop body must be a block: {:?}", body);
-                        continue;
-                    };
-
-                    for _ in 0..loop_count {
-                        let (loop_engine, _, loop_end_time) = execute_audio_statements(
-                            audio_engine.clone(),
-                            variable_table.clone(),
-                            loop_body.clone(),
-                            base_bpm,
-                            base_duration,
-                            max_end_time,
-                            cursor_time
-                        );
-
-                        audio_engine = loop_engine;
-
-                        // Update time and max_end_time after each loop iteration
-                        cursor_time = loop_end_time;
-                        if loop_end_time > max_end_time {
-                            max_end_time = loop_end_time;
-                        }
-                    }
-                }
-            }
-
-            StatementKind::Call => {
-                if let Value::String(identifier) = &stmt.value {
-                    match variable_table.get(identifier) {
-                        Some(Value::Map(map)) => {
-                            match map.get("body") {
-                                Some(Value::Block(block)) => {
-                                    let (called_engine, _, called_end_time) =
-                                        execute_audio_statements(
-                                            audio_engine.clone(),
-                                            variable_table.clone(),
-                                            block.clone(),
-                                            base_bpm,
-                                            base_duration,
-                                            max_end_time,
-                                            cursor_time
-                                        );
-
-                                    audio_engine = called_engine;
-                                    cursor_time = called_end_time;
-                                    if called_end_time > max_end_time {
-                                        max_end_time = called_end_time;
-                                    }
-                                }
-                                Some(other) => {
-                                    eprintln!(
-                                        "❌ Cannot call '{}': expected 'body' to be a block, got {:?}",
-                                        identifier,
-                                        other
-                                    );
-                                }
-                                None => {
-                                    eprintln!("❌ Cannot call '{}': missing 'body' in group map", identifier);
-                                }
-                            }
-                        }
-                        Some(other) => {
-                            eprintln!(
-                                "❌ Cannot call '{}': expected a Map with 'body', got {:?}",
-                                identifier,
-                                other
-                            );
-                        }
-                        None => {
-                            eprintln!("❌ Cannot call '{}': not found in variable table", identifier);
-                        }
-                    }
-                } else {
-                    eprintln!(
-                        "❌ Invalid call statement: expected a string identifier, got {:?}",
-                        stmt.value
-                    );
-                }
-            }
-
-            StatementKind::Bank => {}
-
-            StatementKind::Import { names, source } => {}
-
-            StatementKind::Export { names, source } => {}
-
-            StatementKind::Group => {}
-
-            StatementKind::Unknown => {
-                // Ignore unknown statements
-            }
-
-            _ => {
-                eprintln!("Unsupported statement kind: {:?}", stmt);
-            }
-        }
-    }
-
-    audio_engine.set_variables(variable_table);
-
-    (audio_engine, base_bpm, max_end_time)
-}

package/rust/core/audio/render.rs

@@ -1,53 +0,0 @@
-use std::collections::HashMap;
-
-use crate::{
-    core::{ audio::{engine::AudioEngine, interpreter::interprete_statements}, 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 = 0.0;
-        let mut audio_engine = AudioEngine::new();
-
-        // Apply the module's variable table if it exists
-        if let Some(module) = global_store.get_module(&module_name) {
-            audio_engine.set_variables(module.variable_table.clone());
-        }
-
-        // Interpret the statements to fill the audio buffer
-        let (mut audio_engine, module_base_bpm, module_max_end_time) = interprete_statements(
-            &statements,
-            audio_engine,
-            module_name.clone(),
-            output_dir.to_string()
-        );
-
-        // Calculate the module's maximum duration
-        global_max_end_time = module_max_end_time.max(global_max_end_time);
-        audio_engine.set_duration(global_max_end_time);
-
-        // Check if the buffer contains at least one non-zero sample
-        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).as_str()
-            );
-
-            continue;
-        }
-
-        // Insert only if the module produces sound
-        result.insert(module_name, audio_engine);
-    }
-
-    result
-}

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

@@ -1,32 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_equal_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
-) {
-    if let Some('=') = chars.peek() {
-        chars.next();
-        tokens.push(Token {
-            kind: TokenKind::DoubleEquals,
-            lexeme: char.to_string(),
-            line: *line,
-            column: *column,
-            indent: *current_indent,
-        });
-        *column += 2;
-    } else {
-        tokens.push(Token {
-            kind: TokenKind::Equals,
-            lexeme: char.to_string(),
-            line: *line,
-            column: *column,
-            indent: *current_indent,
-        });
-        *column += 1;
-    }
-}

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

@@ -1,260 +0,0 @@
-use crate::core::{
-    lexer::token::{ Token, TokenKind },
-    parser::{ statement::{ Statement, StatementKind }, Parser },
-    shared::value::Value,
-    store::global::GlobalStore,
-};
-use std::collections::HashMap;
-
-pub fn parse_identifier_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
-    let Some(current_token) = parser.peek_clone() else {
-        return Statement::unknown();
-    };
-
-    if current_token.lexeme == "let" {
-        parser.advance(); // consume "let"
-
-        let identifier = if let Some(token) = parser.peek_clone() {
-            if token.kind == TokenKind::Identifier {
-                parser.advance();
-                token.lexeme.clone()
-            } else {
-                return Statement::error(token, "Expected identifier after 'let'".to_string());
-            }
-        } else {
-            return Statement::error(current_token, "Expected identifier after 'let'".to_string());
-        };
-
-        if !parser.match_token(TokenKind::Equals) {
-            return Statement::error(current_token, "Expected '=' after identifier".to_string());
-        }
-
-        let value = match parser.peek_clone() {
-            Some(token) if token.kind == TokenKind::Identifier => {
-                parser.advance();
-                Value::Identifier(token.lexeme.clone())
-            }
-            Some(token) if token.kind == TokenKind::String => {
-                parser.advance();
-                Value::String(token.lexeme.clone())
-            }
-            Some(token) if token.kind == TokenKind::Number => {
-                parser.advance();
-                Value::Number(token.lexeme.parse().unwrap_or(0.0))
-            }
-            Some(token) if token.kind == TokenKind::LBrace => {
-                parser.advance(); // consume '{'
-                let mut map = HashMap::new();
-
-                while let Some(key_token) = parser.peek_clone() {
-                    if key_token.kind == TokenKind::RBrace {
-                        parser.advance(); // consume '}'
-                        break;
-                    }
-
-                    if key_token.kind != TokenKind::Identifier {
-                        return Statement::error(
-                            token,
-                            "Expected key identifier in map".to_string()
-                        );
-                    }
-                    parser.advance();
-                    let key = key_token.lexeme.clone();
-
-                    if !parser.match_token(TokenKind::Colon) {
-                        let message = format!("Expected ':' after key '{}'", key);
-                        return Statement::error(token, message);
-                    }
-
-                    let val = match parser.peek_clone() {
-                        Some(t) if t.kind == TokenKind::Number => {
-                            parser.advance();
-                            Value::Number(t.lexeme.parse().unwrap_or(0.0))
-                        }
-                        Some(t) if t.kind == TokenKind::String => {
-                            parser.advance();
-                            Value::String(t.lexeme.clone())
-                        }
-                        Some(t) if t.kind == TokenKind::Identifier => {
-                            parser.advance();
-                            Value::Identifier(t.lexeme.clone())
-                        }
-                        _ => { Value::Null }
-                    };
-
-                    if val == Value::Null {
-                        let message = format!("Invalid value for key '{}'", key);
-                        return Statement::error(token, message);
-                    }
-
-                    map.insert(key, val);
-
-                    if let Some(t) = parser.peek() {
-                        if t.kind == TokenKind::Comma {
-                            parser.advance(); // skip comma
-                        }
-                    }
-                }
-
-                Value::Map(map)
-            }
-            other => {
-                let message = format!("Unexpected value token in let: {:?}", other);
-                return Statement::error(current_token, message);
-            }
-        };
-
-        return Statement {
-            kind: StatementKind::Let { name: identifier },
-            value,
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    } else if current_token.lexeme == "group" {
-        parser.advance(); // consume "group"
-
-        let identifier = if let Some(token) = parser.peek_clone() {
-            if token.kind == TokenKind::String {
-                parser.advance();
-                token.lexeme.clone()
-            } else if token.kind == TokenKind::Identifier {
-                parser.advance();
-                token.lexeme.clone()
-            } else {
-                return Statement::error(
-                    token,
-                    "Expected string or identifier after 'group'".to_string()
-                );
-            }
-        } else {
-            return Statement::error(current_token, "Expected string after 'group'".to_string());
-        };
-
-        let Some(colon_token) = parser.peek_clone() else {
-            return Statement::error(
-                current_token,
-                "Expected ':' after group identifier".to_string()
-            );
-        };
-
-        if colon_token.kind != TokenKind::Colon {
-            let message = format!(
-                "Expected ':' after group identifier, got {:?}",
-                colon_token.kind
-            );
-            return Statement::error(colon_token.clone(), message);
-        }
-
-        let tokens = parser.collect_until(
-            |t| (t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF)
-        );
-        let group_body = parser.parse_block(tokens.clone(), global_store);
-
-        // Peek for dedent
-        if let Some(token) = parser.peek() {
-            if token.kind == TokenKind::Dedent {
-                parser.advance();
-            } else {
-                // Unexpected token after group body
-            }
-        } else {
-            // EOF or unexpected end of input
-        }
-
-        let mut value_map = HashMap::new();
-
-        value_map.insert("identifier".to_string(), Value::String(identifier));
-        value_map.insert("body".to_string(), Value::Block(group_body.clone()));
-
-        return Statement {
-            kind: StatementKind::Group,
-            value: Value::Map(value_map),
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    } else if current_token.lexeme == "call" {
-        parser.advance(); // consume "call"
-
-        let identifier = if let Some(token) = parser.peek_clone() {
-            if token.kind == TokenKind::Identifier {
-                parser.advance();
-                token.lexeme.clone()
-            } else {
-                return Statement::error(token, "Expected identifier after 'call'".to_string());
-            }
-        } else {
-            return Statement::error(current_token, "Expected identifier after 'call'".to_string());
-        };
-
-        return Statement {
-            kind: StatementKind::Call,
-            value: Value::String(identifier),
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    } else if current_token.lexeme == "spawn" {
-        parser.advance(); // consume "spawn"
-
-        let identifier = if let Some(token) = parser.peek_clone() {
-            if token.kind == TokenKind::Identifier {
-                parser.advance();
-                token.lexeme.clone()
-            } else {
-                return Statement::error(token, "Expected identifier after 'spawn'".to_string());
-            }
-        } else {
-            return Statement::error(current_token, "Expected identifier after 'spawn'".to_string());
-        };
-
-        return Statement {
-            kind: StatementKind::Spawn,
-            value: Value::String(identifier),
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    } else if current_token.lexeme == "sleep" {
-        parser.advance(); // consume "sleep"
-
-        let duration = if let Some(token) = parser.peek_clone() {
-            if token.kind == TokenKind::Number {
-                parser.advance();
-                token.lexeme.parse().unwrap_or(0.0)
-            } else {
-                return Statement::error(token, "Expected number after 'sleep'".to_string());
-            }
-        } else {
-            return Statement::error(current_token, "Expected number after 'sleep'".to_string());
-        };
-
-        return Statement {
-            kind: StatementKind::Sleep,
-            value: Value::Number(duration),
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    } else {
-        // Unknown identifier handling
-        Statement {
-            kind: StatementKind::Unknown,
-            value: Value::String(current_token.lexeme.clone()),
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    }
-
-    parser.advance(); // unknown identifier fallback
-
-    Statement {
-        kind: StatementKind::Unknown,
-        value: Value::String(current_token.lexeme.clone()),
-        indent: current_token.indent,
-        line: current_token.line,
-        column: current_token.column,
-    }
-}