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

package/rust/core/audio/interpreter.rs

@@ -0,0 +1,317 @@
+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/{audio → core/audio}/loader.rs

@@ -24,6 +24,10 @@ pub fn load_trigger(
                 duration_as_secs = base_duration;
             } else if let Some(Value::Number(num)) = variable_table.get(duration_identifier) {
                 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) {
+                duration_as_secs = num_str.parse::<f32>().unwrap_or(base_duration);
             } else {
                 eprintln!("❌ Invalid duration identifier: {}", duration_identifier);
             }

package/rust/{audio → core/audio}/render.rs

@@ -1,11 +1,7 @@
 use std::collections::HashMap;
 
 use crate::{
-    audio::{ engine::AudioEngine, interpreter::interprete_statements },
-    core::{
-        parser::statement::Statement,
-        store::global::GlobalStore,
-    },
+    core::{ audio::{engine::AudioEngine, interpreter::interprete_statements}, parser::statement::Statement, store::global::GlobalStore },
     utils::logger::{ LogLevel, Logger },
 };
 

package/rust/core/builder/mod.rs

@@ -1,4 +1,5 @@
-use crate::{ audio::render::render_audio_with_modules, core::parser::statement::Statement };
+use crate::core::audio::render::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;

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

@@ -17,7 +17,7 @@ pub fn handle_indent_lexer(
             chars.next();
             col += 1;
         } else if c == '\t' {
-            *current_indent += 4; // tabulation = 4 espaces
+            *current_indent += 4;
             chars.next();
             col += 4;
         } else {

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

@@ -34,8 +34,7 @@ fn advance_char<I: Iterator<Item = char>>(
 ) -> Option<char> {
     let c = chars.next()?;
     if c == '\n' {
-        *line += 1;
-        *column = 1;
+        // Do not increment column on newline here
     } else {
         *column += 1;
     }

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

@@ -1,4 +1,4 @@
-use crate::core::lexer::token::{Token, TokenKind};
+use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_string_lexer(
     ch: char,
@@ -11,23 +11,20 @@ pub fn handle_string_lexer(
 ) {
     let quote_char = ch;
 
-    // Position de départ du token
     let start_column = *column;
     let start_line = *line;
 
-    // Consommer le guillemet ouvrant
-    chars.next();
     *column += 1;
 
     let mut string_content = String::new();
 
     while let Some(&next_ch) = chars.peek() {
         if next_ch == quote_char {
-            chars.next(); // Consomme le guillemet fermant
+            chars.next();
             *column += 1;
             break;
         } else if next_ch == '\\' {
-            chars.next(); // Consomme '\'
+            chars.next();
             *column += 1;
 
             if let Some(escaped) = chars.next() {

package/rust/core/mod.rs

@@ -6,4 +6,5 @@ pub mod shared;
 pub mod debugger;
 pub mod utils;
 pub mod builder;
-pub mod error;
+pub mod error;
+pub mod audio;

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

@@ -6,7 +6,7 @@ use crate::core::{
 };
 use std::collections::HashMap;
 
-pub fn parse_identifier_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+pub fn parse_identifier_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
     let Some(current_token) = parser.peek_clone() else {
         return Statement::unknown();
     };
@@ -111,6 +111,132 @@ pub fn parse_identifier_token(parser: &mut Parser, _global_store: &mut GlobalSto
             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 {

package/rust/core/parser/statement.rs

@@ -51,12 +51,16 @@ pub enum StatementKind {
     // Loop statements
     Loop,
 
+    // Group statements
+    Group,
+
+    // Special statements
+    Call,
+    Spawn,
+    Sleep,
+
     // Conditional statements
-    // If {
-    //     // condition: ConditionParts,
-    //     condition_state: bool,
-    //     body: Vec<Statement>,
-    // },
+    // If
 
     // Keyword statements
     Tempo,

package/rust/core/preprocessor/processor.rs

@@ -1,6 +1,8 @@
+use std::collections::HashMap;
+
 use crate::core::{
     parser::{ statement::StatementKind, Parser },
-    preprocessor::loader::ModuleLoader,
+    preprocessor::{ loader::ModuleLoader, resolver::group },
     shared::value::Value,
     store::global::GlobalStore,
 };
@@ -33,7 +35,31 @@ pub fn process_modules(module_loader: &ModuleLoader, global_store: &mut GlobalSt
                         module.import_table.add_import(name.clone(), Value::String(source.clone()));
                     }
                 }
-                
+
+                StatementKind::Group => {
+                    if let Value::Map(map) = &stmt.value {
+                        if
+                            let (Some(Value::String(name)), Some(Value::Block(body))) = (
+                                map.get("identifier"),
+                                map.get("body"),
+                            )
+                        {
+                            let mut stored_map = HashMap::new();
+
+                            stored_map.insert(
+                                "identifier".to_string(),
+                                Value::String(name.clone())
+                            );
+
+                            stored_map.insert("body".to_string(), Value::Block(body.clone()));
+
+                            module.variable_table.set(name.to_string(), Value::Map(stored_map));
+                        } else {
+                            eprintln!("❌ Invalid group definition: {:?}", stmt.value);
+                        }
+                    }
+                }
+
                 _ => {}
             }
         }

package/rust/core/preprocessor/resolver/bank.rs

@@ -1,9 +1,12 @@
-use crate::{core::{
-    parser::statement::{Statement, StatementKind},
-    preprocessor::module::Module,
-    shared::value::Value,
-    store::global::GlobalStore,
-}, utils::logger::Logger};
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::module::Module,
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::Logger,
+};
 
 pub fn resolve_bank(
     stmt: &Statement,
@@ -28,9 +31,7 @@ pub fn resolve_bank(
             }
         }
 
-        Value::String(_) => {
-            // Pas de résolution nécessaire
-        }
+        Value::String(_) => {}
 
         other => {
             let message = format!("Expected a string or identifier for bank, found {:?}", other);