@devaloop/devalang 0.0.1-alpha.1 → 0.0.1-alpha.10

package/rust/core/audio/renderer.rs

@@ -0,0 +1,54 @@
+use std::collections::HashMap;
+
+use crate::{
+    core::{
+        audio::{ engine::AudioEngine, interpreter::driver::run_audio_program },
+        parser::statement::Statement,
+        store::global::GlobalStore,
+    },
+    utils::logger::{ LogLevel, Logger },
+};
+
+pub fn render_audio_with_modules(
+    modules: HashMap<String, Vec<Statement>>,
+    output_dir: &str,
+    global_store: &mut GlobalStore
+) -> HashMap<String, AudioEngine> {
+    let mut result = HashMap::new();
+
+    for (module_name, statements) in modules {
+        let mut global_max_end_time: f32 = 0.0;
+        let mut initial_engine = AudioEngine::new(module_name.clone());
+
+        // Apply global variables to the initial engine
+        if let Some(module) = global_store.get_module(&module_name) {
+            initial_engine.set_variables(module.variable_table.clone());
+        }
+
+        // interprete statements to fill the audio buffer
+        let (mut updated_engine, _bpm, module_max_end_time) = run_audio_program(
+            &statements,
+            initial_engine,
+            module_name.clone(),
+            output_dir.to_string()
+        );
+
+        // Verify if the buffer is silent (all samples are zero)
+        if updated_engine.buffer.iter().all(|&s| s == 0) {
+            let logger = Logger::new();
+            logger.log_message(
+                LogLevel::Warning,
+                &format!("Module '{}' ignored: silent buffer (no non-zero samples)", module_name)
+            );
+            continue;
+        }
+
+        // Determines the maximum end time for the module
+        global_max_end_time = global_max_end_time.max(module_max_end_time);
+        updated_engine.set_duration(global_max_end_time);
+
+        result.insert(module_name, updated_engine);
+    }
+
+    result
+}

package/rust/core/builder/mod.rs

@@ -1,37 +1,80 @@
-use crate::core::types::statement::{ StatementResolved };
-use std::fs::File;
+use crate::core::audio::renderer::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;
 
-pub fn build_ast(statements: &Vec<StatementResolved>) -> String {
-    let mut ast_string = String::new();
+use crate::utils::logger::Logger;
 
-    serde_json
-        ::to_string_pretty(statements)
-        .map(|json| {
-            ast_string.push_str(&json);
-        })
-        .unwrap_or_else(|err| {
-            eprintln!("Error serializing AST: {}", err);
-            std::process::exit(1);
-        });
+pub struct Builder {}
 
-    ast_string
-}
+impl Builder {
+    pub fn new() -> Self {
+        Builder {}
+    }
 
-pub fn write_ast_to_file(ast: &str, file_path: &str) {
-    clear_json_directory(&file_path);
-    create_json_directory(&file_path);
+    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", "");
 
-    let file_path = format!("{}/ast.json", file_path);
+            create_dir_all(format!("{}/ast", out_dir)).expect("Failed to create AST directory");
 
-    let mut file = File::create(&file_path).expect("Unable to create AST file");
-    file.write_all(ast.as_bytes()).expect("Unable to write AST to file");
-}
+            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");
 
-fn clear_json_directory(path: &str) {
-    std::fs::remove_dir_all(path);
-}
+            let content = serde_json
+                ::to_string_pretty(&statements)
+                .expect("Failed to serialize AST");
+
+            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
+            );
 
-fn create_json_directory(path: &str) {
-    std::fs::create_dir_all(path);
+            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

@@ -0,0 +1,27 @@
+use std::{ collections::HashMap, fs::create_dir_all };
+use crate::core::{ debugger::Debugger, lexer::token::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();
+
+    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(&log_directory, file_name, &content);
+}

package/rust/core/debugger/mod.rs

@@ -1,57 +1,21 @@
-use crate::core::types::{ module::Module, statement::{ StatementResolved } };
+pub mod preprocessor;
+pub mod lexer;
+pub mod store;
 
-pub struct Debugger {
-    pub module: Module,
-}
+use std::io::Write;
+
+pub struct Debugger {}
 
 impl Debugger {
-    pub fn new(module: &Module) -> Self {
-        Debugger {
-            module: module.clone(),
-        }
+    pub fn new() -> Self {
+        Debugger {}
     }
 
-    pub fn write_files(&self, output_dir: &str, resolved_statements: Vec<StatementResolved>) {
-        const LEXER_FILENAME: &str = "debug_lexer.log";
-        const STATEMENTS_FILENAME: &str = "debug_statements.log";
-
-        let lexer_path = format!("{}{}", output_dir, LEXER_FILENAME);
-        let statements_path = format!("{}{}", output_dir, STATEMENTS_FILENAME);
-
-        // Collect debug information
-        let tokens = self.module.tokens
-            .iter()
-            .map(|token| format!("{:?}", token))
-            .collect::<Vec<String>>();
-        let statements = resolved_statements
-            .iter()
-            .map(|stmt| format!("{:?}", stmt))
-            .collect::<Vec<String>>();
+    pub fn write_log_file(&self, path: &str, filename: &str, content: &str) {
+        std::fs::create_dir_all(path).expect("Failed to create directory");
+        let file_path = format!("{}/{}", path, filename);
+        let mut file = std::fs::File::create(file_path).expect("Failed to create file");
 
-        // Ensure the debug directory exists and is cleared
-        clear_debug_directory(output_dir);
-        create_debug_directory(output_dir);
-
-        // Writing files
-        write_tokens_debug_to_file(&tokens, &lexer_path);
-        write_statements_debug_to_file(&statements, &statements_path);
+        file.write_all(content.as_bytes()).expect("Failed to write to file");
     }
 }
-
-fn clear_debug_directory(path: &str) {
-    std::fs::remove_dir_all(path);
-}
-
-fn create_debug_directory(path: &str) {
-    std::fs::create_dir_all(path);
-}
-
-fn write_statements_debug_to_file(statements: &Vec<String>, path: &str) {
-    let content = statements.join("\n");
-    std::fs::write(path, content).expect("Unable to write statements to file");
-}
-
-fn write_tokens_debug_to_file(tokens: &Vec<String>, path: &str) {
-    let content = tokens.join("\n");
-    std::fs::write(path, content).expect("Unable to write tokens to file");
-}

package/rust/core/debugger/preprocessor.rs

@@ -0,0 +1,27 @@
+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,
+    modules: HashMap<String, Vec<Statement>>
+) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
+
+    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));
+        }
+
+        content.push_str("\n");
+    }
+
+    debugger.write_log_file(&log_directory, file_name, &content);
+}

package/rust/core/debugger/store.rs

@@ -0,0 +1,25 @@
+use std::{ collections::HashMap, fs::create_dir_all };
+use crate::core::{ debugger::Debugger, preprocessor::module::Module };
+
+pub fn write_store_log_file(output_dir: &str, file_name: &str, modules: HashMap<String, Module>) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
+
+    let log_directory = format!("{}/logs", output_dir);
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (path, module) in modules {
+        content.push_str(&format!("--- Module: {} ---\n", path));
+
+        for (index, var_value) in module.variable_table.variables.iter().enumerate() {
+            let var_name = var_value.0.clone();
+            let var_data = var_value.1;
+
+            content.push_str(&format!("{}: {:?} = {:?}\n", index + 1, var_name, var_data));
+        }
+
+        content.push_str("\n");
+    }
+
+    debugger.write_log_file(&log_directory, file_name, &content);
+}

package/rust/core/error/mod.rs

@@ -0,0 +1,60 @@
+use crate::core::parser::{ statement::{ Statement, StatementKind }, driver::Parser };
+
+pub struct ErrorHandler {
+    errors: Vec<Error>,
+}
+
+pub struct Error {
+    pub message: String,
+    pub line: usize,
+    pub column: usize,
+}
+
+impl ErrorHandler {
+    pub fn new() -> Self {
+        Self { errors: Vec::new() }
+    }
+
+    pub fn add_error(&mut self, message: String, line: usize, column: usize) {
+        let error_statement = Error {
+            message,
+            line,
+            column,
+        };
+        self.errors.push(error_statement);
+    }
+
+    pub fn has_errors(&self) -> bool {
+        !self.errors.is_empty()
+    }
+
+    pub fn get_errors(&self) -> &Vec<Error> {
+        &self.errors
+    }
+
+    pub fn clear_errors(&mut self) {
+        self.errors.clear();
+    }
+
+    pub fn detect_from_statements(&mut self, parser: &mut Parser, statements: &[Statement]) {
+        for stmt in statements {
+            match &stmt.kind {
+                StatementKind::Unknown => {
+                    self.add_error(
+                        "Unknown statement".to_string(),
+                        stmt.line,
+                        stmt.column
+                    );
+                }
+                StatementKind::Error { message } => {
+                    self.add_error(
+                        message.clone(),
+                        stmt.line,
+                        stmt.column
+                    );
+                }
+                _ => {}
+            }
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_arrow_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
+) {
+    let mut arrow_call = char.to_string();
+
+    while let Some(&c) = chars.peek() {
+        if c == '>' {
+            chars.next();
+            arrow_call.push(c);
+            *column += 1;
+        } else {
+            break;
+        }
+    }
+
+    tokens.push(Token {
+        kind: TokenKind::Arrow,
+        lexeme: arrow_call,
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+}

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

@@ -0,0 +1,21 @@
+use crate::core::lexer::token::{Token, TokenKind};
+
+pub fn handle_at_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
+) {
+    tokens.push(Token {
+        kind: TokenKind::At,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}

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

@@ -0,0 +1,41 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_rbrace_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
+) {
+    tokens.push(Token {
+        kind: TokenKind::RBrace,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}
+
+pub fn handle_lbrace_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
+) {
+    tokens.push(Token {
+        kind: TokenKind::LBrace,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}

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

@@ -0,0 +1,21 @@
+use crate::core::lexer::token::{Token, TokenKind};
+
+pub fn handle_colon_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
+) {
+    tokens.push(Token {
+        kind: TokenKind::Colon,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}

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

@@ -0,0 +1,30 @@
+use crate::core::lexer::token::{Token, TokenKind};
+
+pub fn handle_comment_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
+) {
+    let mut comment = String::new();
+
+    while let Some(&c) = chars.peek() {
+        if c == '\n' {
+            break;
+        }
+        comment.push(c);
+        chars.next();
+        *column += 1;
+    }
+
+    tokens.push(Token {
+        kind: TokenKind::Comment,
+        lexeme: comment.trim().to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+}

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

@@ -0,0 +1,21 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_dot_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
+) {
+    tokens.push(Token {
+        kind: TokenKind::Dot,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}