@devaloop/devalang 0.0.1-alpha.1

package/rust/core/mod.rs

@@ -0,0 +1,6 @@
+pub mod lexer;
+pub mod parser;
+pub mod preprocessor;
+pub mod debugger;
+pub mod builder;
+pub mod types;

package/rust/core/parser/at.rs

@@ -0,0 +1,142 @@
+use crate::core::types::{
+    parser::Parser,
+    statement::{ Statement, StatementKind },
+    token::TokenKind,
+    variable::VariableValue,
+};
+
+pub fn parse_at(parser: &mut Parser) -> Result<Statement, String> {
+    let token = parser.peek().ok_or("Unexpected EOF")?.clone();
+
+    if token.kind != TokenKind::At {
+        return Err(format!("Expected '@', found {:?}", token.kind));
+    }
+
+    parser.next();
+
+    let identifier_token = parser.peek().ok_or("Expected identifier after '@'")?.clone();
+    if identifier_token.kind != TokenKind::Identifier {
+        return Err(format!("Expected Identifier, found {:?}", identifier_token.kind));
+    }
+
+    match identifier_token.lexeme.as_str() {
+        "export" => {
+            parser.next();
+
+            if let Some(next_token) = parser.peek() {
+                if next_token.kind == TokenKind::LBrace {
+                    parser.next(); // Consomme le LBrace
+                }
+            }
+
+            let exportable_tokens = parser.collect_until(|t| { t.kind == TokenKind::RBrace });
+
+            exportable_tokens.iter().for_each(|t| {
+                let variable_value = parser.variable_table
+                    .get(&t.lexeme)
+                    .cloned()
+                    .unwrap_or_else(|| VariableValue::Text(t.lexeme.clone()));
+
+                parser.export_table.exports.insert(t.lexeme.clone(), variable_value);
+            });
+
+            return Ok(Statement {
+                kind: StatementKind::Export,
+                value: VariableValue::Array(exportable_tokens),
+                indent: token.indent,
+                line: token.line,
+                column: token.column,
+            });
+        }
+        "import" => {
+            parser.next();
+
+            if let Some(next_token) = parser.peek() {
+                if next_token.kind == TokenKind::LBrace {
+                    parser.next();
+                }
+            }
+
+            let importable_tokens = parser.collect_until(|t| { t.kind == TokenKind::RBrace });
+
+            parser.next();
+
+            if let Some(from_token) = parser.peek() {
+                if from_token.kind == TokenKind::Identifier && from_token.lexeme == "from" {
+                    parser.next();
+                } else {
+                    return Err(format!("Expected 'from', found {:?}", from_token.kind));
+                }
+            } else {
+                return Err("Expected 'from' after import declaration".into());
+            }
+
+            let source_token = parser.peek().ok_or("Expected source after 'from'")?.clone();
+            if source_token.kind != TokenKind::String {
+                return Err(format!("Expected String, found {:?}", source_token.kind));
+            }
+
+            let statement = Statement {
+                kind: StatementKind::Import {
+                    names: importable_tokens
+                        .iter()
+                        .map(|t| t.lexeme.clone())
+                        .collect(),
+                    source: source_token.lexeme.clone(),
+                },
+                value: VariableValue::Array(importable_tokens),
+                indent: token.indent,
+                line: token.line,
+                column: token.column,
+            };
+
+            return Ok(statement);
+        }
+        "load" => {
+            parser.next();
+
+            let source_token = parser.peek().ok_or("Expected source after load")?.clone();
+            if source_token.kind != TokenKind::String {
+                return Err(format!("Expected String, found {:?}", source_token.kind));
+            }
+
+            parser.next();
+
+            let as_token = parser.peek().ok_or("Expected 'as' after load")?.clone();
+            if as_token.kind != TokenKind::Identifier || as_token.lexeme != "as" {
+                return Err(format!("Expected 'as', found {:?}", as_token.kind));
+            }
+
+            parser.next();
+
+            let alias_token = parser.peek().ok_or("Expected alias after load")?.clone();
+            if alias_token.kind != TokenKind::Identifier {
+                return Err(format!("Expected Identifier, found {:?}", alias_token.kind));
+            }
+
+            parser.next();
+
+            let statement = Statement {
+                kind: StatementKind::Load {
+                    source: source_token.lexeme.clone(),
+                    alias: alias_token.lexeme.clone(),
+                },
+                value: VariableValue::Text(alias_token.lexeme.clone()),
+                indent: token.indent,
+                line: token.line,
+                column: token.column,
+            };
+
+            return Ok(statement);
+        }
+
+        _ => {
+            return Err(
+                format!(
+                    "Expected 'export', 'import' or 'load', found '{}'",
+                    identifier_token.lexeme
+                )
+            );
+        }
+    }
+}

package/rust/core/parser/bank.rs

@@ -0,0 +1,42 @@
+use crate::core::types::{
+    parser::Parser,
+    statement::{ Statement, StatementKind },
+    store::GlobalStore,
+    token::TokenKind,
+    variable::VariableValue,
+};
+
+pub fn parse_bank(
+    parser: &mut Parser,
+    global_store: &mut GlobalStore
+) -> Result<Statement, String> {
+    let token = parser.peek().ok_or("Unexpected EOF")?.clone();
+
+    let mut bank_name = String::new();
+
+    if parser.next().map(|t| t.kind.clone()) != Some(TokenKind::Bank) {
+        return Err("Expected 'bank' keyword".to_string());
+    }
+
+    if let Some(token) = parser.next() {
+        if token.kind == TokenKind::Identifier {
+            bank_name = token.lexeme.clone();
+        } else if token.kind == TokenKind::String {
+            bank_name = token.lexeme.trim_matches('"').to_string();
+        } else if token.kind == TokenKind::Number {
+            bank_name = token.lexeme.clone();
+        } else {
+            return Err(format!("Expected bank name, found {:?}", token.kind));
+        }
+    } else {
+        return Err("Expected bank name after 'bank' keyword".to_string());
+    }
+
+    Ok(Statement {
+        kind: StatementKind::Bank,
+        value: VariableValue::Text(bank_name.clone()),
+        indent: token.indent,
+        line: token.line,
+        column: token.column,
+    })
+}

package/rust/core/parser/dot.rs

@@ -0,0 +1,107 @@
+use std::{ collections::HashMap, hash::Hash };
+
+use crate::core::types::{
+    statement::{ Statement, StatementKind },
+    token::{ Token, TokenDuration, TokenKind, TokenParamValue },
+    variable::{ Variable, VariableValue },
+};
+
+pub fn parse_dot(
+    parser: &mut crate::core::parser::Parser,
+    global_store: &mut crate::core::types::store::GlobalStore
+) -> Result<crate::core::types::statement::Statement, String> {
+    let token = parser.peek().ok_or("Unexpected EOF")?.clone();
+    let mut trigger_value: String = String::from("Unknown Trigger");
+
+    if token.kind != crate::core::types::token::TokenKind::Dot {
+        return Err(format!("Expected Dot, found {:?}", token.kind));
+    }
+
+    parser.next();
+
+    let next_token = parser.peek().ok_or("Expected identifier after dot")?.clone();
+    if next_token.kind != crate::core::types::token::TokenKind::Identifier {
+        return Err(format!("Expected Identifier after Dot, found {:?}", next_token.kind));
+    }
+
+    parser.next(); 
+
+    let duration_token = parser.peek().ok_or("Expected duration after identifier")?.clone();
+    let mut duration = TokenDuration::Unknown;
+
+    match duration_token.lexeme.as_str() {
+        "auto" => {
+            duration = TokenDuration::Auto;
+        }
+        "infinite" => {
+            duration = TokenDuration::Infinite;
+        }
+        _ => {
+            if let Ok(num) = duration_token.lexeme.parse::<f32>() {
+                duration = TokenDuration::Number(num);
+            } else if let Ok(boolean) = duration_token.lexeme.parse::<bool>() {
+                duration = TokenDuration::Unknown;
+            } else if duration_token.kind == TokenKind::Identifier {
+                duration = TokenDuration::Identifier(duration_token.lexeme.clone());
+            } else {
+                return Err(format!("Invalid duration format: {}", duration_token.lexeme));
+            }
+        }
+    }
+
+    parser.next();
+   
+    let dot_params: Vec<Token> = parser.collect_until(|t| {
+        t.kind == TokenKind::Newline
+    });
+
+    let mut params_value: VariableValue = VariableValue::Null;
+
+    for param in dot_params {
+        let token_value = match param.kind {
+            TokenKind::String => VariableValue::Text(param.lexeme),
+            TokenKind::Number => VariableValue::Number(param.lexeme.parse().unwrap_or(0.0)),
+            TokenKind::Boolean => VariableValue::Boolean(param.lexeme.parse().unwrap_or(false)),
+            TokenKind::Map => {
+                let mut map: HashMap<String, TokenParamValue> = HashMap::new();
+                let entries: Vec<&str> = param.lexeme.split(',').collect();
+                for entry in entries {
+                    let parts: Vec<&str> = entry.split(':').collect();
+                    if parts.len() == 2 {
+                        let key = parts[0].trim().to_string();
+                        let value = match parts[1].trim() {
+                            "true" => TokenParamValue::Boolean(true),
+                            "false" => TokenParamValue::Boolean(false),
+                            _ => TokenParamValue::String(parts[1].trim().to_string()),
+                        };
+                        map.insert(key, value);
+                    }
+                }
+                VariableValue::Map(map)
+            }
+            TokenKind::Identifier => {
+                VariableValue::Text(param.lexeme.clone())
+            }
+            TokenKind::Unknown => {
+                Err(format!("Unsupported token type in dot parameters: {:?}", param.kind))?;
+                VariableValue::Null
+            },
+            _ => {
+                Err(format!("Unsupported token type in dot parameters: {:?}", param.kind))?;
+                VariableValue::Unknown
+            },
+        };
+        params_value = token_value;
+    }
+
+    Ok(Statement {
+        kind: StatementKind::Trigger {
+            entity: next_token.lexeme.clone(),
+            duration: duration.clone(),
+        },
+        value: params_value,
+        indent: token.indent,
+        line: token.line,
+        column: token.column,
+    })
+}

package/rust/core/parser/identifer.rs

@@ -0,0 +1,91 @@
+use crate::core::{
+    parser::{ bank::parse_bank, variable::parse_let_statement, Parser },
+    types::{
+        statement::{ Statement, StatementKind },
+        store::GlobalStore,
+        token::{ Token, TokenKind },
+        variable::VariableValue,
+    },
+};
+
+pub fn parse_identifier(
+    parser: &mut Parser,
+    global_store: &mut GlobalStore
+) -> Result<Statement, String> {
+    let token = parser.peek().ok_or("Unexpected EOF")?.clone();
+
+    if token.kind != TokenKind::Identifier {
+        return Err(format!("Expected Identifier, found {:?}", token.kind));
+    }
+
+    match token.lexeme.as_str() {
+        "let" => {
+            parser.next();
+            return parse_let_statement(parser); 
+        }
+        "bank" => {
+            parser.next(); 
+            return parse_bank(parser, global_store);
+        }
+        _ => {
+            parser.next();
+        }
+    }
+
+    let statment_value = match token.kind {
+        TokenKind::Identifier => {
+            let var_name = &token.lexeme;
+            let current_module = global_store.modules
+                .get(&parser.current_module);
+            let mut variable_value = VariableValue::Unknown;
+
+            if current_module.is_none() {
+                return Err(format!("Module '{}' not found", parser.current_module));
+            } else {
+                variable_value = current_module.unwrap()
+                    .variable_table
+                    .variables
+                    .get(var_name)
+                    .cloned()
+                    .unwrap_or(VariableValue::Unknown);
+            }
+
+            println!("Trying to get variable '{}' in module '{}'", var_name, parser.current_module);
+
+            variable_value
+        }
+        TokenKind::Number => VariableValue::Number(token.lexeme.parse().unwrap_or(0.0)),
+        TokenKind::String => {
+            let var_name = &token.lexeme;
+            let current_module = global_store.modules
+                .get(&parser.current_module);
+            let mut variable_value = VariableValue::Unknown;
+
+            if current_module.is_none() {
+                return Err(format!("Module '{}' not found", parser.current_module));
+            } else {
+                variable_value = current_module.unwrap()
+                    .variable_table
+                    .variables
+                    .get(var_name)
+                    .cloned()
+                    .unwrap_or(VariableValue::Unknown);
+            }
+
+            println!("Trying to get variable '{}' in module '{}'", var_name, parser.current_module);
+
+            variable_value
+        }
+        _ => VariableValue::Unknown,
+    };
+
+    println!("Trying get variable : {:?}", global_store.modules);
+
+    Ok(Statement {
+        kind: StatementKind::Unknown,
+        value: statment_value,
+        indent: token.indent,
+        line: token.line,
+        column: token.column,
+    })
+}

package/rust/core/parser/loop_.rs

@@ -0,0 +1,62 @@
+use std::{ collections::HashMap, iter };
+
+use crate::core::types::{
+    statement::{ Statement, StatementIterator, StatementKind },
+    token::{ Token, TokenDuration, TokenKind, TokenParamValue },
+    variable::VariableValue,
+};
+
+pub fn parse_loop(
+    parser: &mut crate::core::parser::Parser,
+    global_store: &mut crate::core::types::store::GlobalStore
+) -> Result<crate::core::types::statement::Statement, String> {
+    let token = parser.peek().ok_or("Unexpected EOF")?.clone();
+
+    parser.next();
+
+    let mut iterator = StatementIterator::Unknown;
+
+    let iterable_tokens: Vec<Token> = parser.collect_until(|t| { t.kind == TokenKind::Colon });
+
+    iterable_tokens.iter().for_each(|t| {
+        match t.kind {
+            TokenKind::Identifier => {
+                iterator = StatementIterator::Identifier(t.lexeme.clone());
+            }
+            TokenKind::Number => {
+                if let Ok(num) = t.lexeme.parse::<f32>() {
+                    iterator = StatementIterator::Number(num);
+                } else {
+                    eprintln!("⚠️ Invalid number in loop iterator: {}", t.lexeme);
+                }
+            }
+            TokenKind::Array => {
+                println!("🔍 Parsing array in loop iterator: {:?}", t.lexeme);
+                iterator = StatementIterator::Array(vec![]);
+            }
+            TokenKind::Map => {
+                println!("🔍 Parsing map in loop iterator: {:?}", t.lexeme);
+                iterator = StatementIterator::Map(HashMap::new());
+            }
+            _ => {
+                eprintln!("⚠️ Unsupported token type in loop iterator: {:?}", t.kind);
+            }
+        }
+    });
+
+    parser.next(); 
+
+    let loop_body_tokens: Vec<Token> = parser.collect_until(|t| { t.kind == TokenKind::Dedent });
+
+    let loop_statement = Statement {
+        kind: StatementKind::Loop {
+            iterator,
+        },
+        value: VariableValue::Array(loop_body_tokens),
+        line: token.line,
+        column: token.column,
+        indent: token.indent,
+    };
+
+    Ok(loop_statement)
+}

package/rust/core/parser/mod.rs

@@ -0,0 +1,201 @@
+pub mod identifer;
+pub mod variable;
+pub mod at;
+pub mod dot;
+pub mod bank;
+pub mod loop_;
+pub mod tempo;
+
+use crate::{
+    core::{
+        parser::{
+            at::parse_at,
+            bank::parse_bank,
+            dot::parse_dot,
+            identifer::parse_identifier,
+            loop_::parse_loop,
+            tempo::parse_tempo,
+        },
+        preprocessor::resolver::resolve_statement,
+        types::{
+            module::Module,
+            parser::Parser,
+            statement::{ Statement, StatementKind, StatementResolved },
+            store::{ GlobalStore },
+            token::{ Token, TokenKind },
+            variable::VariableValue,
+        },
+    },
+    utils::logger::log_message,
+};
+
+pub fn parse_without_resolving(
+    tokens: Vec<Token>,
+    mut parser: &mut Parser,
+    global_store: &mut GlobalStore
+) -> Vec<Statement> {
+    let mut statements = Vec::new();
+
+    while !parser.is_eof() {
+        let mut error_statement = Statement {
+            kind: StatementKind::Error,
+            value: VariableValue::Null,
+            line: parser.peek().map_or(0, |t| t.line),
+            column: parser.peek().map_or(0, |t| t.column),
+            indent: parser.peek().map_or(0, |t| t.indent),
+        };
+
+        match parser.peek().map(|t| t.kind.clone()) {
+            Some(TokenKind::Identifier) => {
+                match parse_identifier(&mut parser, global_store) {
+                    Ok(statement) => statements.push(statement),
+                    Err(e) => {
+                        error_statement.value = VariableValue::Text(e.to_string());
+                        statements.push(error_statement);
+                    }
+                }
+            }
+
+            Some(TokenKind::Bank) => {
+                match parse_bank(&mut parser, global_store) {
+                    Ok(statement) => statements.push(statement),
+                    Err(e) => {
+                        error_statement.value = VariableValue::Text(e.to_string());
+                        statements.push(error_statement);
+                    }
+                }
+            }
+
+            Some(TokenKind::At) => {
+                match parse_at(&mut parser) {
+                    Ok(statement) => statements.push(statement),
+                    Err(e) => {
+                        error_statement.value = VariableValue::Text(e.to_string());
+                        statements.push(error_statement);
+                    }
+                }
+            }
+
+            Some(TokenKind::Dot) => {
+                match parse_dot(&mut parser, global_store) {
+                    Ok(statement) => statements.push(statement),
+                    Err(e) => {
+                        error_statement.value = VariableValue::Text(e.to_string());
+                        statements.push(error_statement);
+                    }
+                }
+            }
+
+            Some(TokenKind::Loop) => {
+                match parse_loop(&mut parser, global_store) {
+                    Ok(statement) => statements.push(statement),
+                    Err(e) => {
+                        error_statement.value = VariableValue::Text(e.to_string());
+                        statements.push(error_statement);
+                    }
+                }
+            }
+
+            Some(TokenKind::Tempo) => {
+                match parse_tempo(&mut parser, global_store) {
+                    Ok(statement) => statements.push(statement),
+                    Err(e) => {
+                        error_statement.value = VariableValue::Text(e.to_string());
+                        statements.push(error_statement);
+                    }
+                }
+            }
+
+            | Some(TokenKind::LBrace)
+            | Some(TokenKind::RBrace)
+            | Some(TokenKind::LBracket)
+            | Some(TokenKind::RBracket)
+            | Some(TokenKind::DbQuote)
+            | Some(TokenKind::Quote)
+            | Some(TokenKind::Number)
+            | Some(TokenKind::String)
+            | Some(TokenKind::Newline)
+            | Some(TokenKind::Indent)
+            | Some(TokenKind::Dedent) => {
+                parser.next();
+            }
+            Some(_) => {
+                parser.next();
+            }
+            None => {
+                break;
+            }
+        }
+    }
+
+    statements
+}
+
+pub fn parse_without_resolving_with_module(tokens: Vec<Token>, module: &Module) -> Vec<Statement> {
+    let mut parser = Parser::new(tokens.clone());
+
+    parser.current_module = module.path.clone();
+
+    let mut global_store = GlobalStore::new();
+    global_store.insert_module(module.path.clone(), module.clone());
+
+    let statements = parse_without_resolving(tokens, &mut parser, &mut global_store);
+
+    let mut updated_module = module.clone();
+    updated_module.statements = statements.clone();
+
+    let mut errors: Vec<String> = Vec::new();
+
+    statements.iter().for_each(|statement| {
+        match &statement.kind {
+            StatementKind::Error => {
+                let error_message = match &statement.value {
+                    VariableValue::Text(text) => text.clone(),
+                    _ => "Unknown error".to_string(),
+                };
+
+                errors.push(format!(
+                    "Error in module '{}': {} at line {}, column {}",
+                    updated_module.path,
+                    error_message,
+                    statement.line,
+                    statement.column
+                ));
+
+                log_message(&format!("Error: {}", error_message), "ERROR");
+            }
+            _ => {}
+        }
+    });
+
+    if errors.len() > 0 {
+        log_message(&format!("{} error(s) found. Parsing stopped.", errors.len()), "INFO");
+
+        statements
+    } else {
+        statements
+    }
+}
+
+pub fn parse_with_resolving_with_module(
+    tokens: Vec<Token>,
+    module: &Module
+) -> Vec<StatementResolved> {
+    let mut parser = Parser::new(tokens.clone());
+
+    parser.current_module = module.path.clone();
+
+    let mut global_store = GlobalStore::new();
+    global_store.insert_module(module.path.clone(), module.clone());
+
+    let statements = parse_without_resolving(tokens, &mut parser, &mut global_store);
+
+    let mut resolved_statements = Vec::new();
+
+    for statement in statements {
+        let resolved_statement = resolve_statement(&statement, &mut module.clone());
+        resolved_statements.push(resolved_statement);
+    }
+
+    return resolved_statements;
+}

package/rust/core/parser/tempo.rs

@@ -0,0 +1,42 @@
+use crate::core::types::{
+    parser::Parser,
+    statement::{ Statement, StatementKind },
+    store::GlobalStore,
+    token::TokenKind,
+    variable::VariableValue,
+};
+
+pub fn parse_tempo(
+    parser: &mut Parser,
+    global_store: &mut GlobalStore
+) -> Result<Statement, String> {
+    let token = parser.peek().ok_or("Unexpected EOF")?.clone();
+
+    parser.next();
+
+    if let Some(token) = parser.next() {
+
+        if token.kind == TokenKind::Number {
+            let value = token.lexeme.parse::<f32>().map_err(|_| "Invalid tempo value".to_string())?;
+            return Ok(Statement {
+                kind: StatementKind::Tempo,
+                value: VariableValue::Number(value as f32),
+                indent: token.indent,
+                line: token.line,
+                column: token.column,
+            });
+        } else if token.kind == TokenKind::Identifier {
+            let value = token.lexeme.clone();
+
+            return Ok(Statement {
+                kind: StatementKind::Tempo,
+                value: VariableValue::Text(value),
+                indent: token.indent,
+                line: token.line,
+                column: token.column,
+            });
+        }
+    }
+
+    Err(format!("Expected a number after tempo keyword, found {}", token.lexeme))
+}