@devaloop/devalang 0.0.1-alpha.4 → 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,10 +1,11 @@
-use crate::audio::render::render_audio_with_modules;
+use crate::core::audio::render::render_audio_with_modules;
 use crate::core::parser::statement::Statement;
 use crate::core::store::global::GlobalStore;
-use crate::utils::logger::Logger;
 use std::{ collections::HashMap, fs::create_dir_all };
 use std::io::Write;
 
+use crate::utils::logger::Logger;
+
 pub struct Builder {}
 
 impl Builder {
@@ -12,16 +13,14 @@ impl Builder {
         Builder {}
     }
 
-    pub fn build_ast(&self, modules: &HashMap<String, Vec<Statement>>) {
-        let output_path = "./output";
-
+    pub fn build_ast(&self, modules: &HashMap<String, Vec<Statement>>, out_dir: &str) {
         for (name, statements) in modules {
             let formatted_name = name.split("/").last().unwrap_or(name);
             let formatted_name = formatted_name.replace(".deva", "");
 
-            create_dir_all(format!("{}/ast", output_path)).expect("Failed to create AST directory");
+            create_dir_all(format!("{}/ast", out_dir)).expect("Failed to create AST directory");
 
-            let file_path = format!("{}/ast/{}.json", output_path, formatted_name);
+            let file_path = format!("{}/ast/{}.json", out_dir, formatted_name);
             let mut file = std::fs::File::create(file_path).expect("Failed to create AST file");
 
             let content = serde_json
@@ -46,7 +45,9 @@ impl Builder {
             global_store
         );
 
-        create_dir_all(format!("{}/audio", normalized_output_dir)).expect("Failed to create audio directory");
+        create_dir_all(format!("{}/audio", normalized_output_dir)).expect(
+            "Failed to create audio directory"
+        );
 
         for (module_name, mut audio_engine) in audio_engines {
             let formatted_module_name = module_name

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,15 +34,14 @@ 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;
     }
     Some(c)
 }
 
-pub fn handle_content_lexing(content: String) -> Vec<Token> {
+pub fn handle_content_lexing(content: String) -> Result<Vec<Token>, String> {
     let mut tokens = Vec::new();
 
     let mut line = 1;
@@ -234,5 +233,5 @@ pub fn handle_content_lexing(content: String) -> Vec<Token> {
     //     );
     // }
 
-    tokens
+    Ok(tokens)
 }

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

@@ -14,6 +14,10 @@ pub fn handle_newline_lexer(
         lexeme: ch.to_string(),
         line: *line,
         column: 0,
-        indent: 0,
+        indent: *current_indent,
     });
+
+    *line += 1;
+    *column = 1;
+    *at_line_start = true;
 }

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/lexer/mod.rs

@@ -2,7 +2,10 @@ pub mod handler;
 pub mod token;
 
 use std::fs;
-use crate::core::{ lexer::{ handler::handle_content_lexing, token::Token }, utils::path::normalize_path };
+use crate::core::{
+    lexer::{ handler::handle_content_lexing, token::Token },
+    utils::path::normalize_path,
+};
 
 pub struct Lexer {}
 
@@ -11,14 +14,16 @@ impl Lexer {
         Lexer {}
     }
 
+    pub fn lex_from_source(&self, source: &str) -> Result<Vec<Token>, String> {
+        handle_content_lexing(source.to_string())
+    }
+
     pub fn lex_tokens(&self, entrypoint: &str) -> Vec<Token> {
         let path = normalize_path(entrypoint);
 
-        let file_content = fs
-            ::read_to_string(&path)
-            .expect("Failed to read the entrypoint file");
+        let file_content = fs::read_to_string(&path).expect("Failed to read the entrypoint file");
 
-        let tokens = handle_content_lexing(file_content);
+        let tokens = handle_content_lexing(file_content).expect("Failed to lex the content");
 
         tokens
     }

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/handler/loop_.rs

@@ -40,6 +40,17 @@ pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) ->
     );
     let loop_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 loop body
+        }
+    } else {
+        // EOF or unexpected end of input
+    }
+
     let mut value_map = HashMap::new();
 
     value_map.insert("iterator".to_string(), Value::Identifier(iterator_name));

package/rust/core/parser/mod.rs

@@ -225,7 +225,6 @@ impl Parser {
                 break;
             }
             if condition(token) {
-                self.advance(); // Consume the token that matches the condition
                 break;
             }
             collected.push(self.advance().unwrap().clone());