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

package/rust/core/builder/mod.rs

@@ -1,7 +1,10 @@
-use crate::core::parser::statement::Statement;
+use crate::{ audio::render::render_audio_with_modules, core::parser::statement::Statement };
+use crate::core::store::global::GlobalStore;
 use std::{ collections::HashMap, fs::create_dir_all };
 use std::io::Write;
 
+use crate::utils::logger::Logger;
+
 pub struct Builder {}
 
 impl Builder {
@@ -9,16 +12,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
@@ -28,4 +29,51 @@ impl Builder {
             file.write_all(content.as_bytes()).expect("Failed to write AST to file");
         }
     }
+
+    pub fn build_audio(
+        &self,
+        modules: &HashMap<String, Vec<Statement>>,
+        normalized_output_dir: &str,
+        global_store: &mut GlobalStore
+    ) {
+        let logger = Logger::new();
+
+        let audio_engines = render_audio_with_modules(
+            modules.clone(),
+            &normalized_output_dir,
+            global_store
+        );
+
+        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
+                .split('/')
+                .last()
+                .unwrap_or(&module_name)
+                .replace(".deva", "");
+
+            let output_path = format!(
+                "{}/audio/{}.wav",
+                normalized_output_dir,
+                formatted_module_name
+            );
+
+            match audio_engine.generate_wav_file(&output_path) {
+                Ok(_) => {}
+                Err(msg) => {
+                    logger.log_error_with_stacktrace(
+                        &format!(
+                            "Unable to generate WAV file for module '{}': {}",
+                            formatted_module_name,
+                            msg
+                        ),
+                        &module_name
+                    );
+                }
+            }
+        }
+    }
 }

package/rust/core/debugger/lexer.rs

@@ -1,12 +1,27 @@
-use crate::core::{ debugger::Debugger, lexer::token::Token };
+use std::{ collections::HashMap, fs::create_dir_all };
+use crate::core::{ debugger::Debugger, lexer::token::Token, parser::statement::Statement };
 
-pub fn write_lexer_log_file(output_dir: &str, file_name: &str, tokens: Vec<Token>) {
+pub fn write_lexer_log_file(
+    output_dir: &str,
+    file_name: &str,
+    modules: HashMap<String, Vec<Token>>
+) {
     let debugger = Debugger::new();
     let mut content = String::new();
 
-    for token in tokens {
-        content.push_str(&format!("{:?}\n", token));
+    let log_directory = format!("{}/logs", output_dir);
+
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (path, tokens) in modules {
+        content.push_str(&format!("--- Resolved Tokens for {} ---\n", path));
+
+        for token in tokens {
+            content.push_str(&format!("{:?}\n", token));
+        }
+
+        content.push_str("\n");
     }
 
-    debugger.write_log_file(output_dir, file_name, &content);
+    debugger.write_log_file(&log_directory, file_name, &content);
 }

package/rust/core/debugger/preprocessor.rs

@@ -1,17 +1,21 @@
-use std::collections::HashMap;
+use std::{ collections::HashMap, fs::create_dir_all };
 use crate::core::{ debugger::Debugger, parser::statement::Statement };
 
 pub fn write_preprocessor_log_file(
     output_dir: &str,
     file_name: &str,
-    statements: HashMap<String, Vec<Statement>>
+    modules: HashMap<String, Vec<Statement>>
 ) {
     let debugger = Debugger::new();
     let mut content = String::new();
 
-    for (path, stmts) in statements {
+    let log_directory = format!("{}/logs", output_dir);
+
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (path, stmts) in modules {
         content.push_str(&format!("--- Resolved Statements for {} ---\n", path));
-        
+
         for stmt in stmts {
             content.push_str(&format!("{:?}\n", stmt));
         }
@@ -19,5 +23,5 @@ pub fn write_preprocessor_log_file(
         content.push_str("\n");
     }
 
-    debugger.write_log_file(output_dir, file_name, &content);
+    debugger.write_log_file(&log_directory, file_name, &content);
 }

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

@@ -42,7 +42,7 @@ fn advance_char<I: Iterator<Item = char>>(
     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 +234,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/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/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());

package/rust/core/preprocessor/loader.rs

@@ -1,10 +1,8 @@
 use std::collections::HashMap;
-
 use crate::{
     core::{
-        debugger::{ lexer::write_lexer_log_file, preprocessor::write_preprocessor_log_file },
         error::ErrorHandler,
-        lexer::Lexer,
+        lexer::{ token::Token, Lexer },
         parser::{ statement::{ Statement, StatementKind }, Parser },
         preprocessor::{
             module::Module,
@@ -12,8 +10,9 @@ use crate::{
             resolver::{ resolve_all_modules, resolve_and_flatten_all_modules },
         },
         store::global::GlobalStore,
+        utils::path::normalize_path,
     },
-    utils::logger::{ LogLevel, Logger },
+    utils::logger::Logger,
 };
 
 pub struct ModuleLoader {
@@ -29,26 +28,90 @@ impl ModuleLoader {
         }
     }
 
-    pub fn load_all(&self, global_store: &mut GlobalStore) -> HashMap<String, Vec<Statement>> {
+    pub fn from_raw_source(
+        entry_path: &str,
+        output_path: &str,
+        content: &str,
+        global_store: &mut GlobalStore
+    ) -> Self {
+        let normalized_entry_path = normalize_path(entry_path);
+
+        let mut module = Module::new(&entry_path);
+        module.content = content.to_string();
+
+        println!("Loading module from raw source: {}", normalized_entry_path);
+
+        global_store.insert_module(normalized_entry_path.to_string(), module);
+
+        Self {
+            entry: normalized_entry_path.to_string(),
+            output: output_path.to_string(),
+        }
+    }
+
+    pub fn extract_statements_map(
+        &self,
+        global_store: &GlobalStore
+    ) -> HashMap<String, Vec<Statement>> {
+        global_store.modules
+            .iter()
+            .map(|(path, module)| (path.clone(), module.statements.clone()))
+            .collect()
+    }
+
+    pub fn load_single_module(&self, global_store: &mut GlobalStore) -> Result<Module, String> {
+        let mut module = global_store.modules
+            .remove(&self.entry)
+            .ok_or_else(|| format!("Module not found in store for path: {}", self.entry))?;
+
+        // SECTION Lexing the module content
+        let lexer = Lexer::new();
+        let tokens = lexer
+            .lex_from_source(&module.content)
+            .map_err(|e| format!("Lexer failed: {}", e))?;
+
+        module.tokens = tokens.clone();
+
+        // SECTION Parsing tokens into statements
+        let mut parser = Parser::new();
+        parser.set_current_module(self.entry.clone());
+        let statements = parser.parse_tokens(tokens, global_store);
+        module.statements = statements;
+
+        // SECTION Error handling
+        let mut error_handler = ErrorHandler::new();
+        error_handler.detect_from_statements(&mut parser, &module.statements);
+
+        global_store.modules.insert(self.entry.clone(), module.clone());
+
+        Ok(module)
+    }
+
+    #[cfg(feature = "cli")]
+    pub fn load_all_modules(
+        &self,
+        global_store: &mut GlobalStore
+    ) -> (HashMap<String, Vec<Token>>, HashMap<String, Vec<Statement>>) {
         // SECTION Load the entry module and its dependencies
-        self.load_module_recursively(&self.entry, global_store);
+        let tokens_by_module = self.load_module_recursively(&self.entry, global_store);
 
         // SECTION Process and resolve modules
         process_modules(self, global_store);
         resolve_all_modules(self, global_store);
 
-        let resolved = resolve_and_flatten_all_modules(global_store);
-
-        // SECTION Write resolved statements to log file
-        write_preprocessor_log_file(&self.output, "resolved_statements.log", resolved.clone());
+        let statemnts_by_module = resolve_and_flatten_all_modules(global_store);
 
-        // Return the resolved statements
-        resolved
+        (tokens_by_module, statemnts_by_module)
     }
 
-    fn load_module_recursively(&self, path: &str, global_store: &mut GlobalStore) {
+    #[cfg(feature = "cli")]
+    fn load_module_recursively(
+        &self,
+        path: &str,
+        global_store: &mut GlobalStore
+    ) -> HashMap<String, Vec<Token>> {
         if global_store.modules.contains_key(path) {
-            return;
+            return HashMap::new();
         }
 
         let lexer = Lexer::new();
@@ -75,15 +138,25 @@ impl ModuleLoader {
 
         // SECTION Module creation
         let mut module = Module::new(path);
-        module.tokens = tokens;
-        module.statements = statements;
+        module.tokens = tokens.clone();
+        module.statements = statements.clone();
 
         global_store.insert_module(path.to_string(), module);
 
         // Then load the imports recursively
         self.load_module_imports(&path.to_string(), global_store);
+
+        // Return all tokens by module
+        let mut tokens_by_module = HashMap::new();
+
+        global_store.modules.iter().for_each(|(path, module)| {
+            tokens_by_module.insert(path.clone(), module.tokens.clone());
+        });
+
+        tokens_by_module
     }
 
+    #[cfg(feature = "cli")]
     fn load_module_imports(&self, path: &String, global_store: &mut GlobalStore) {
         let imports = global_store.modules
             .get(path)

package/rust/core/preprocessor/module.rs

@@ -18,6 +18,7 @@ pub struct Module {
     pub variable_table: VariableTable,
     pub export_table: ExportTable,
     pub import_table: ImportTable,
+    pub content: String,
 }
 
 impl Module {
@@ -30,6 +31,7 @@ impl Module {
             export_table: ExportTable::new(),
             import_table: ImportTable::new(),
             resolved: false,
+            content: String::new(),
         }
     }
 

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

@@ -0,0 +1,46 @@
+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,
+    module: &Module,
+    path: &str,
+    _global_store: &GlobalStore
+) -> Statement {
+    let mut new_stmt = stmt.clone();
+    let logger = Logger::new();
+
+    match &stmt.value {
+        Value::Identifier(ident) => {
+            if let Some(val) = module.variable_table.get(ident) {
+                new_stmt.value = val.clone();
+            } else {
+                let message = format!("Bank identifier '{ident}' not found in variable table");
+                logger.log_error_with_stacktrace(&message, &module.path);
+                new_stmt.kind = StatementKind::Error {
+                    message: message.clone(),
+                };
+                new_stmt.value = Value::Null;
+            }
+        }
+
+        Value::String(_) => {
+            // Pas de résolution nécessaire
+        }
+
+        other => {
+            let message = format!("Expected a string or identifier for bank, found {:?}", other);
+            logger.log_error_with_stacktrace(&message, &module.path);
+            new_stmt.kind = StatementKind::Error {
+                message: "Expected a string or identifier for bank".to_string(),
+            };
+            new_stmt.value = Value::Null;
+        }
+    }
+
+    new_stmt
+}

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

@@ -0,0 +1,148 @@
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{ module::Module, resolver::trigger::resolve_trigger },
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::Logger,
+};
+
+pub fn resolve_loop(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &GlobalStore
+) -> Statement {
+    let logger = Logger::new();
+
+    // Vérifie que stmt.value est bien une Map
+    if let Value::Map(value_map) = &stmt.value {
+        // Résolution de l'iterator
+        let iterator_value = match value_map.get("iterator") {
+            Some(Value::Identifier(ident)) => {
+                match module.variable_table.get(ident) {
+                    Some(Value::Number(n)) => Value::Number(*n),
+                    Some(_) => {
+                        log_type_error(
+                            &logger,
+                            module,
+                            stmt,
+                            format!("Loop iterator '{ident}' must resolve to a number")
+                        );
+                        Value::Null
+                    }
+                    None => {
+                        // Value is not a variable so we assume it's a number
+                        if let Ok(n) = ident.parse::<f32>() {
+                            Value::Number(n)
+                        } else {
+                            log_type_error(
+                                &logger,
+                                module,
+                                stmt,
+                                format!("Loop iterator '{ident}' is not a valid number")
+                            );
+                            Value::Null
+                        }
+                    }
+                }
+            }
+            Some(Value::Number(n)) => Value::Number(*n),
+            Some(other) => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    format!("Unexpected value for loop iterator: {:?}", other)
+                );
+                Value::Null
+            }
+            None => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    "Missing 'iterator' key in loop statement map".to_string()
+                );
+                Value::Null
+            }
+        };
+
+        // Résolution du body
+        let body_value = match value_map.get("body") {
+            Some(Value::Block(block)) => {
+                let mut resolved_block = Vec::new();
+                for ref statement in block.clone() {
+                    match &statement.kind {
+                        StatementKind::Trigger { entity, duration } => {
+                            let resolved = resolve_trigger(
+                                &mut statement.clone(),
+                                &entity,
+                                &mut duration.clone(),
+                                module,
+                                path,
+                                global_store
+                            );
+                            resolved_block.push(resolved);
+                        }
+                        _ => {
+                            println!("Unhandled loop body statement: {:?}", statement);
+                        }
+                    }
+                }
+                Value::Block(resolved_block)
+            }
+            Some(other) => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    format!("Unexpected value for loop body: {:?}", other)
+                );
+                Value::Null
+            }
+            None => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    "Missing 'body' key in loop statement map".to_string()
+                );
+                Value::Null
+            }
+        };
+
+        // ✅ Reconstruit proprement la valeur résolue
+        let mut resolved_map = std::collections::HashMap::new();
+        resolved_map.insert("iterator".to_string(), iterator_value);
+        resolved_map.insert("body".to_string(), body_value);
+
+        // ✅ Reconstruit le StatementLoop à partir des éléments résolus
+        Statement {
+            kind: StatementKind::Loop,
+            value: Value::Map(resolved_map),
+            ..stmt.clone()
+        }
+    } else {
+        log_type_error(
+            &logger,
+            module,
+            stmt,
+            format!("Expected a map for loop value, found {:?}", stmt.value)
+        );
+
+        Statement {
+            kind: StatementKind::Error {
+                message: "Expected a map for loop value".to_string(),
+            },
+            value: Value::Null,
+            ..stmt.clone()
+        }
+    }
+}
+
+fn log_type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) {
+    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+    logger.log_error_with_stacktrace(&message, &stacktrace);
+}