@devaloop/devalang 0.0.1-alpha.2 → 0.0.1-alpha.4

package/rust/core/builder/mod.rs

@@ -1,37 +1,79 @@
-use crate::core::types::statement::{ StatementResolved };
-use std::fs::File;
+use crate::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;
 
-pub fn build_ast(statements: &Vec<StatementResolved>) -> String {
-    let mut ast_string = String::new();
+pub struct Builder {}
 
-    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);
-        });
+impl Builder {
+    pub fn new() -> Self {
+        Builder {}
+    }
 
-    ast_string
-}
+    pub fn build_ast(&self, modules: &HashMap<String, Vec<Statement>>) {
+        let output_path = "./output";
 
-pub fn write_ast_to_file(ast: &str, file_path: &str) {
-    clear_json_directory(&file_path);
-    create_json_directory(&file_path);
+        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", output_path)).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", output_path, 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, parser::statement::Statement };
+
+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,20 @@
-use crate::core::types::{ module::Module, statement::{ StatementResolved } };
+pub mod preprocessor;
+pub mod lexer;
 
-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/error/mod.rs

@@ -0,0 +1,60 @@
+use crate::core::parser::{ statement::{ Statement, StatementKind }, 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/{at.rs → handler/at.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{ Token, TokenKind };
+use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_at_lexer(
     char: char,

package/rust/core/lexer/{brace.rs → handler/brace.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{ Token, TokenKind };
+use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_rbrace_lexer(
     char: char,

package/rust/core/lexer/{colon.rs → handler/colon.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{Token, TokenKind};
+use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_colon_lexer(
     char: char,

package/rust/core/lexer/{comment.rs → handler/comment.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{ Token, TokenKind };
+use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_comment_lexer(
     char: char,
@@ -21,8 +21,8 @@ pub fn handle_comment_lexer(
     }
 
     tokens.push(Token {
-        kind: TokenKind::Comment(comment.trim().to_string()),
-        lexeme: char.to_string(),
+        kind: TokenKind::Comment,
+        lexeme: comment.trim().to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,

package/rust/core/lexer/{dot.rs → handler/dot.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{Token, TokenKind};
+use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_dot_lexer(
     char: char,

package/rust/core/lexer/{equal.rs → handler/equal.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{Token, TokenKind};
+use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_equal_lexer(
     char: char,

package/rust/core/lexer/{identifier.rs → handler/identifier.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{ Token, TokenKind };
+use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_identifier_lexer(
     char: char,

package/rust/core/lexer/{indent.rs → handler/indent.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{ Token, TokenKind };
+use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_indent_lexer(
     chars: &mut std::iter::Peekable<std::str::Chars>,
@@ -7,19 +7,26 @@ pub fn handle_indent_lexer(
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
-) -> (Vec<Token>, Vec<usize>, usize, usize) {
+) {
     *current_indent = 0;
+    let mut col = *column;
 
     while let Some(&c) = chars.peek() {
         if c == ' ' {
             *current_indent += 1;
             chars.next();
-            *column += 1;
+            col += 1;
+        } else if c == '\t' {
+            *current_indent += 4; // tabulation = 4 espaces
+            chars.next();
+            col += 4;
         } else {
             break;
         }
     }
 
+    *column = col;
+
     let last_indent = *indent_stack.last().unwrap();
     if *current_indent > last_indent {
         indent_stack.push(*current_indent);
@@ -42,6 +49,4 @@ pub fn handle_indent_lexer(
             });
         }
     }
-
-    (tokens.clone(), indent_stack.clone(), *line, *column)
 }

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

@@ -0,0 +1,238 @@
+pub mod at;
+pub mod brace;
+pub mod colon;
+pub mod comment;
+pub mod dot;
+pub mod equal;
+pub mod identifier;
+pub mod newline;
+pub mod number;
+pub mod indent;
+pub mod string;
+
+use crate::core::lexer::{
+    handler::{
+        at::handle_at_lexer,
+        brace::{ handle_lbrace_lexer, handle_rbrace_lexer },
+        colon::handle_colon_lexer,
+        comment::handle_comment_lexer,
+        dot::handle_dot_lexer,
+        equal::handle_equal_lexer,
+        identifier::handle_identifier_lexer,
+        indent::handle_indent_lexer,
+        newline::handle_newline_lexer,
+        number::handle_number_lexer,
+        string::handle_string_lexer,
+    },
+    token::{ Token, TokenKind },
+};
+
+fn advance_char<I: Iterator<Item = char>>(
+    chars: &mut std::iter::Peekable<I>,
+    line: &mut usize,
+    column: &mut usize
+) -> Option<char> {
+    let c = chars.next()?;
+    if c == '\n' {
+        *line += 1;
+        *column = 1;
+    } else {
+        *column += 1;
+    }
+    Some(c)
+}
+
+pub fn handle_content_lexing(content: String) -> Vec<Token> {
+    let mut tokens = Vec::new();
+
+    let mut line = 1;
+    let mut column = 1;
+
+    let mut indent_stack: Vec<usize> = vec![0];
+    let mut current_indent = 0;
+    let mut at_line_start = true;
+
+    let mut chars = content.chars().peekable();
+
+    while chars.peek().is_some() {
+        if at_line_start {
+            handle_indent_lexer(
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            at_line_start = false;
+        }
+
+        let Some(ch) = advance_char(&mut chars, &mut line, &mut column) else {
+            break;
+        };
+
+        match ch {
+            '\n' => {
+                handle_newline_lexer(
+                    ch,
+                    &mut chars,
+                    &mut tokens,
+                    &mut line,
+                    &mut column,
+                    &mut at_line_start,
+                    &mut current_indent
+                );
+            }
+            ' ' | '\t' => {
+                // Already handled by indent_lexer
+            }
+            '#' => {
+                handle_comment_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            ':' => {
+                handle_colon_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '=' => {
+                handle_equal_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '{' => {
+                handle_lbrace_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '}' => {
+                handle_rbrace_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '.' => {
+                handle_dot_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '@' => {
+                handle_at_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '\"' | '\'' => {
+                handle_string_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            c if c.is_ascii_digit() => {
+                handle_number_lexer(
+                    c,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            c if c.is_ascii_alphabetic() => {
+                handle_identifier_lexer(
+                    c,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            _ => {
+                // Ignore unknown char
+            }
+        }
+    }
+
+    while indent_stack.len() > 1 {
+        indent_stack.pop();
+        current_indent = *indent_stack.last().unwrap();
+        tokens.push(Token {
+            kind: TokenKind::Dedent,
+            lexeme: String::new(),
+            line,
+            column,
+            indent: current_indent,
+        });
+    }
+
+    tokens.push(Token {
+        kind: TokenKind::EOF,
+        lexeme: String::new(),
+        line: line + 1,
+        column: 0,
+        indent: 0,
+    });
+
+    // NOTE: Debug only
+    // for token in &tokens {
+    //     println!(
+    //         "{:?} @ line {}, col {}, indent {}",
+    //         token.kind,
+    //         token.line,
+    //         token.column,
+    //         token.indent
+    //     );
+    // }
+
+    tokens
+}

package/rust/core/lexer/{newline.rs → handler/newline.rs}

@@ -1,23 +1,19 @@
-use crate::core::types::token::{Token, TokenKind};
+use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_newline_lexer(
-    char: char,
+    ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,
     at_line_start: &mut bool,
-    current_indent: &mut usize,
+    current_indent: &mut usize
 ) {
     tokens.push(Token {
         kind: TokenKind::Newline,
-        lexeme: char.to_string(),
+        lexeme: ch.to_string(),
         line: *line,
-        column: *column,
-        indent: *current_indent,
+        column: 0,
+        indent: 0,
     });
-
-    *line += 1;
-    *column = 1;
-    *at_line_start = true;
 }

package/rust/core/lexer/{number.rs → handler/number.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{Token, TokenKind};
+use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_number_lexer(
     char: char,