@devaloop/devalang 0.0.1-alpha.1

package/rust/core/parser/variable.rs

@@ -0,0 +1,129 @@
+use std::collections::HashMap;
+
+use crate::core::{
+    parser::Parser,
+    types::{
+        statement::{ Statement, StatementKind },
+        token::{ Token, TokenKind, TokenParamValue },
+        variable::VariableValue,
+    },
+};
+
+pub fn parse_let_statement(parser: &mut Parser) -> Result<Statement, String> {
+    let name_token = parser.next().ok_or("Expected variable name after 'let'")?.clone();
+    if name_token.kind != TokenKind::Identifier {
+        return Err(format!("Expected variable name, found {:?}", name_token.kind));
+    }
+
+    let variable_name = name_token.lexeme.clone();
+
+    let equal_token = parser.next().ok_or("Expected '=' after variable name")?.clone();
+    if equal_token.kind != TokenKind::Equals {
+        return Err(format!("Expected '=', found {:?} after variable name", equal_token.kind));
+    }
+
+    let value_token = parser.next().ok_or("Expected value after '='")?.clone();
+    let value = match value_token.kind {
+        TokenKind::String => VariableValue::Text(value_token.lexeme.clone()),
+        TokenKind::Number =>
+            value_token.lexeme
+                .parse::<f32>()
+                .map(VariableValue::Number)
+                .map_err(|_| "Invalid number value".to_string())?,
+        TokenKind::Boolean =>
+            value_token.lexeme
+                .parse::<bool>()
+                .map(VariableValue::Boolean)
+                .map_err(|_| "Invalid boolean value".to_string())?,
+        TokenKind::Identifier => VariableValue::Text(value_token.lexeme.clone()),
+        TokenKind::LBrace => {
+            let mut object: HashMap<String, VariableValue> = HashMap::new();
+            while let Some(next_token) = parser.next() {
+                if next_token.kind == TokenKind::RBrace {
+                    break;
+                }
+                if next_token.kind != TokenKind::Identifier {
+                    return Err(
+                        format!("Expected identifier in object, found {:?}", next_token.kind)
+                    );
+                }
+                let key = next_token.lexeme.clone();
+
+                let colon_token = parser.next().ok_or("Expected ':' after object key")?.clone();
+                if colon_token.kind != TokenKind::Colon {
+                    return Err(format!("Expected ':', found {:?}", colon_token.kind));
+                }
+
+                let value_token = parser.next().ok_or("Expected value after ':'")?.clone();
+                let value = match value_token.kind {
+                    TokenKind::String => VariableValue::Text(value_token.lexeme.clone()),
+                    TokenKind::Number =>
+                        value_token.lexeme
+                            .parse::<f32>()
+                            .map(VariableValue::Number)
+                            .map_err(|_| "Invalid number value".to_string())?,
+                    TokenKind::Boolean =>
+                        value_token.lexeme
+                            .parse::<bool>()
+                            .map(VariableValue::Boolean)
+                            .map_err(|_| "Invalid boolean value".to_string())?,
+                    _ => {
+                        return Err(format!("Invalid object value token: {:?}", value_token.kind));
+                    }
+                };
+                object.insert(key, value);
+            }
+
+            let mut variable_object_map: HashMap<String, TokenParamValue> = HashMap::new();
+
+            for (key, value) in object {
+                let token_value = match value {
+                    VariableValue::Text(s) => TokenParamValue::String(s),
+                    VariableValue::Number(n) => TokenParamValue::Number(n),
+                    VariableValue::Boolean(b) => TokenParamValue::Boolean(b),
+                    _ => {
+                        continue;
+                    }
+                };
+                variable_object_map.insert(key, token_value);
+            }
+
+            VariableValue::Map(variable_object_map)
+        }
+        _ => {
+            return Err(format!("Invalid value token: {:?}", value_token.kind));
+        }
+    };
+
+    parser.variable_table.variables.insert(variable_name.clone(), value.clone());
+
+    Ok(Statement {
+        kind: StatementKind::Let {
+            name: variable_name,
+        },
+        value: value,
+        indent: name_token.indent,
+        line: name_token.line,
+        column: name_token.column,
+    })
+}
+
+pub fn parse_variable_value(parser: &mut Parser, token: &Token) -> Result<VariableValue, String> {
+    match token.kind {
+        TokenKind::String => Ok(VariableValue::Text(token.lexeme.clone())),
+        TokenKind::Number => {
+            token.lexeme
+                .parse::<f32>()
+                .map(VariableValue::Number)
+                .map_err(|_| "Invalid number value".to_string())
+        }
+        TokenKind::Boolean => {
+            token.lexeme
+                .parse::<bool>()
+                .map(VariableValue::Boolean)
+                .map_err(|_| "Invalid boolean value".to_string())
+        }
+        TokenKind::Identifier => Ok(VariableValue::Text(token.lexeme.clone())),
+        _ => Err(format!("Invalid variable value token: {:?}", token.kind)),
+    }
+}

package/rust/core/preprocessor/dependencies.rs

@@ -0,0 +1,54 @@
+use std::{ collections::{ HashSet, VecDeque }, fs };
+
+pub fn collect_dependencies_recursively(entry_file: &str) -> Vec<String> {
+    let mut queue = VecDeque::new();
+    let mut loaded = HashSet::new();
+
+    queue.push_back(entry_file.to_string());
+
+    while let Some(file_ref) = queue.pop_front() {
+        if loaded.contains(&file_ref) {
+            continue;
+        }
+
+        let deps = get_direct_dependencies(&file_ref);
+        for dep in deps {
+            queue.push_back(dep.clone());
+        }
+
+        loaded.insert(file_ref);
+    }
+
+    loaded.into_iter().collect()
+}
+
+fn get_direct_dependencies(file: &str) -> Vec<String> {
+    let content = match fs::read_to_string(file) {
+        Ok(c) => c,
+        Err(_) => {
+            eprintln!("⚠️ Unable to read file: {}", file);
+            return vec![];
+        }
+    };
+
+    let mut deps = Vec::new();
+
+    for line in content.lines() {
+        let line = line.trim();
+
+        if line.starts_with("@import") {
+            if let Some(from_index) = line.find("from") {
+                let after_from = line[from_index + 4..].trim();
+                if after_from.starts_with('"') || after_from.starts_with('\'') {
+                    let delimiter = after_from.chars().next().unwrap();
+                    if let Some(end_quote) = after_from[1..].find(delimiter) {
+                        let path = &after_from[1..=end_quote];
+                        deps.push(path.to_string());
+                    }
+                }
+            }
+        }
+    }
+
+    deps
+}

package/rust/core/preprocessor/mod.rs

@@ -0,0 +1,26 @@
+pub mod module;
+pub mod dependencies;
+pub mod resolver;
+
+use crate::core::{
+    preprocessor::{
+        dependencies::collect_dependencies_recursively,
+        module::load_module_into_global_store,
+    },
+    types::{ store::GlobalStore },
+};
+
+pub fn preprocess(entry_file: &str) -> GlobalStore {
+    println!("📦 Collecting dependencies for: {}", entry_file);
+
+    let files = collect_dependencies_recursively(entry_file);
+    let mut store = GlobalStore::default();
+
+    for file in &files {
+        if let Err(e) = load_module_into_global_store(file, &mut store) {
+            eprintln!("❌ Error while loading {}: {}", file, e);
+        }
+    }
+
+    store
+}

package/rust/core/preprocessor/module.rs

@@ -0,0 +1,70 @@
+use crate::core::{
+    lexer::lex,
+    parser::{ parse_without_resolving },
+    preprocessor::{
+        collect_dependencies_recursively,
+        resolver::{ resolve_exports, resolve_imports },
+    },
+    types::{ module::Module, parser::Parser, store::{ ExportTable, GlobalStore, ImportTable } },
+};
+
+pub fn load_all_modules(entry_file: &str) -> GlobalStore {
+    let mut global_store = GlobalStore::default();
+    let files = collect_dependencies_recursively(entry_file);
+
+    for file in &files {
+        if let Err(e) = load_module_into_global_store(file, &mut global_store) {
+            eprintln!("❌ Error loading {}: {}", file, e);
+        }
+    }
+
+    for file in &files {
+        if let Some(module) = global_store.modules.clone().get_mut(file) {
+            let imports = resolve_imports(module, &mut global_store);
+            module.import_table = imports.clone();
+
+            let global_store_module = global_store.modules.get(&file.clone().to_string());
+            if let Some(global_store_module_found) = global_store_module {
+                global_store.insert_module(file.to_string(), module.clone());
+            } else {
+                eprintln!("❌ Module {} not found in global store after import resolution", file);
+            }
+        }
+    }
+
+    global_store
+}
+
+pub fn load_module_into_global_store(
+    path: &str,
+    global_store: &mut GlobalStore
+) -> Result<(), String> {
+    if global_store.modules.contains_key(path) {
+        return Ok(());
+    }
+
+    let content = std::fs::read_to_string(path).map_err(|_| format!("Cannot read file: {}", path))?;
+
+    let tokens = lex(content);
+
+    let mut parser = Parser::new(tokens.clone());
+
+    parser.current_module = path.to_string();
+
+    let raw_statements = parse_without_resolving(tokens.clone(), &mut parser, global_store);
+
+    let export_table = resolve_exports(&raw_statements, &mut parser);
+
+    let mut module = Module {
+        path: path.to_string(),
+        tokens: tokens.clone(),
+        statements: raw_statements,
+        variable_table: parser.variable_table.clone(),
+        export_table: export_table.clone(),
+        import_table: parser.import_table.clone(),
+    };
+
+    global_store.insert_module(path.to_string(), module.clone());
+
+    Ok(())
+}

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

@@ -0,0 +1,24 @@
+use crate::core::types::{
+    module::Module,
+    statement::{ Statement, StatementResolved, StatementResolvedValue },
+    variable::VariableValue,
+};
+
+pub fn resolve_load_statement(
+    stmt: &Statement,
+    source: &str,
+    alias: &str,
+    module: &mut Module
+) -> StatementResolved {
+    let source_string = source.to_string();
+
+    module.set_variable(alias.to_string(), VariableValue::Sample(source_string.clone()));
+
+    StatementResolved {
+        kind: stmt.kind.clone(),
+        value: StatementResolvedValue::Null,
+        indent: stmt.indent,
+        line: stmt.line,
+        column: stmt.column,
+    }
+}

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

@@ -0,0 +1,59 @@
+use crate::core::{parser::parse_with_resolving_with_module, types::{
+    module::Module,
+    statement::{ Statement, StatementKind, StatementResolved, StatementResolvedValue },
+    variable::VariableValue,
+}};
+
+pub fn resolve_bank_statement(stmt: &Statement, module: &Module) -> StatementResolved {
+    match &stmt.value {
+        VariableValue::Text(name) => {
+            if
+                let Some(value) = module.import_table.imports
+                    .get(name)
+                    .or_else(|| module.variable_table.variables.get(name))
+            {
+                let statement_value: StatementResolvedValue = match value {
+                    VariableValue::Array(arr) => {
+                        StatementResolvedValue::Array(
+                            parse_with_resolving_with_module(arr.clone(), module)
+                        )
+                    }
+                    VariableValue::Text(text) => StatementResolvedValue::String(text.clone()),
+                    VariableValue::Number(num) => StatementResolvedValue::Number(*num),
+                    VariableValue::Boolean(b) => StatementResolvedValue::Boolean(*b),
+                    _ => {
+                        eprintln!("⚠️ Unsupported variable type for Bank: {:?}", value);
+                        StatementResolvedValue::Unknown
+                    }
+                };
+
+                StatementResolved {
+                    kind: StatementKind::Bank,
+                    value: statement_value,
+                    indent: stmt.indent,
+                    line: stmt.line,
+                    column: stmt.column,
+                }
+            } else {
+                eprintln!("⚠️ Bank variable '{}' not found", name);
+                StatementResolved {
+                    kind: StatementKind::Bank,
+                    value: StatementResolvedValue::Unknown,
+                    indent: stmt.indent,
+                    line: stmt.line,
+                    column: stmt.column,
+                }
+            }
+        }
+        _ => {
+            eprintln!("⚠️ Invalid value type for Bank statement: {:?}", stmt.value);
+            StatementResolved {
+                kind: StatementKind::Bank,
+                value: StatementResolvedValue::Unknown,
+                indent: stmt.indent,
+                line: stmt.line,
+                column: stmt.column,
+            }
+        }
+    }
+}

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

@@ -0,0 +1,82 @@
+use crate::core::{
+    parser::parse_without_resolving_with_module,
+    preprocessor::resolver::resolve_statement,
+    types::{
+        module::Module,
+        statement::{
+            Statement,
+            StatementIterator,
+            StatementKind,
+            StatementResolved,
+            StatementResolvedValue,
+        },
+        variable::VariableValue,
+    },
+};
+
+pub fn resolve_loop_statement(
+    loop_statement: &Statement,
+    iterator: StatementIterator,
+    module: &Module
+) -> StatementResolved {
+    let mut resolved_iterator = StatementIterator::Unknown;
+
+    match iterator.clone() {
+        StatementIterator::Identifier(id) => {
+            if let Some(value) = module.variable_table.variables.get(&id) {
+                match value {
+                    VariableValue::Array(arr) => {
+                        resolved_iterator = StatementIterator::Array(
+                            parse_without_resolving_with_module(arr.clone(), module)
+                        );
+                    }
+                    VariableValue::Number(num) => {
+                        resolved_iterator = StatementIterator::Number(*num);
+                    }
+                    _ => {
+                        eprintln!("⚠️ Unsupported variable type for loop iterator: {:?}", value);
+                        resolved_iterator = StatementIterator::Unknown;
+                    }
+                }
+            } else {
+                eprintln!("⚠️ Loop iterator variable '{}' not found", id);
+                resolved_iterator = StatementIterator::Unknown;
+            }
+        }
+        StatementIterator::Number(num) => {
+            resolved_iterator = StatementIterator::Number(num);
+        }
+        _ => {
+            resolved_iterator = iterator.clone();
+        }
+    }
+
+    let mut resolved_body: StatementResolvedValue = StatementResolvedValue::Unknown;
+
+    match &loop_statement.value {
+        VariableValue::Array(arr) => {
+            let raw_statements = parse_without_resolving_with_module(arr.clone(), &module.clone());
+
+            let mut resolved_statements = Vec::new();
+
+            for raw_stmt in raw_statements {
+                let resolved_stmt = resolve_statement(&raw_stmt, &mut module.clone());
+                resolved_statements.push(resolved_stmt);
+            }
+
+            resolved_body = StatementResolvedValue::Array(resolved_statements);
+        }
+        _ => {
+            resolved_body = StatementResolvedValue::Unknown;
+            eprintln!("⚠️ Unsupported value type for loop body: {:?}", loop_statement.value);
+        }
+    }
+
+    return StatementResolved {
+        kind: StatementKind::Loop { iterator: resolved_iterator },
+        value: resolved_body,
+        indent: loop_statement.indent,
+        line: loop_statement.line,
+        column: loop_statement.column,
+    };
+}

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

@@ -0,0 +1,113 @@
+pub mod bank;
+pub mod loop_;
+pub mod tempo;
+pub mod trigger;
+pub mod at;
+
+use crate::core::{
+    preprocessor::resolver::{
+        bank::resolve_bank_statement,
+        loop_::resolve_loop_statement,
+        tempo::resolve_tempo_statement,
+        trigger::resolve_trigger_statement,
+        at::{ resolve_load_statement },
+    },
+    types::{
+        module::Module,
+        parser::Parser,
+        statement::{ Statement, StatementKind, StatementResolved, StatementResolvedValue },
+        store::{ ExportTable, GlobalStore, ImportTable },
+        variable::VariableValue,
+    },
+};
+
+pub fn resolve_exports(statements: &[Statement], parser: &Parser) -> ExportTable {
+    let mut export_table = parser.export_table.clone();
+
+    for stmt in statements {
+        if let StatementKind::Export = &stmt.kind {
+            if let VariableValue::Array(tokens) = &stmt.value {
+                for token in tokens {
+                    let var_name = &token.lexeme;
+                    if let Some(value) = parser.variable_table.variables.get(var_name) {
+                        export_table.add_export(var_name.clone(), value.clone());
+                    } else {
+                        eprintln!("⚠️ Variable '{}' not found in scope, export skipped", var_name);
+                    }
+                }
+            } else {
+                eprintln!("⚠️ Unexpected value type in export: {:?}", stmt.value);
+            }
+        }
+    }
+
+    export_table
+}
+
+pub fn resolve_imports(module: &mut Module, global_store: &GlobalStore) -> ImportTable {
+    let mut import_table = ImportTable::default();
+
+    for stmt in &module.statements {
+        if let StatementKind::Import { names, source } = &stmt.kind {
+            if let Some(from_module) = global_store.modules.get(source) {
+                for name in names {
+                    if let Some(value) = from_module.export_table.exports.get(name) {
+                        module.variable_table.variables.insert(name.clone(), value.clone());
+                        import_table.add_import(name.clone(), value.clone());
+                    } else {
+                        eprintln!("⚠️ '{}' not found in exports of '{}'", name, source);
+                    }
+                }
+            } else {
+                eprintln!("⚠️ Module '{}' not found", source);
+            }
+        }
+    }
+
+    import_table
+}
+
+pub fn resolve_statement(stmt: &Statement, module: &mut Module) -> StatementResolved {
+    match &stmt.kind {
+        StatementKind::Loop { iterator } => {
+            resolve_loop_statement(stmt, iterator.clone(), module)
+        }
+
+        StatementKind::Trigger { entity, duration } => {
+            resolve_trigger_statement(stmt, entity.clone(), duration.clone(), module)
+        }
+
+        StatementKind::Bank { .. } => { resolve_bank_statement(stmt, module) }
+
+        StatementKind::Tempo { .. } => { resolve_tempo_statement(stmt, module) }
+
+        StatementKind::Load { source, alias } => {
+            resolve_load_statement(stmt, source, alias, module)
+        }
+
+        // TODO Handle other statement kinds
+
+        StatementKind::Error => {
+            StatementResolved {
+                kind: StatementKind::Error,
+                value: match stmt.value {
+                    VariableValue::Text(ref msg) => StatementResolvedValue::String(msg.clone()),
+                    _ => StatementResolvedValue::Unknown,
+                },
+                indent: stmt.indent,
+                line: stmt.line,
+                column: stmt.column,
+            }
+        }
+
+        _ => {
+            StatementResolved {
+                kind: StatementKind::Unknown,
+                value: StatementResolvedValue::Unknown,
+                indent: stmt.indent,
+                line: stmt.line,
+                column: stmt.column,
+            }
+        }
+    }
+}

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

@@ -0,0 +1,70 @@
+use crate::core::types::{module::Module, statement::{Statement, StatementKind, StatementResolved, StatementResolvedValue}, variable::VariableValue};
+
+pub fn resolve_tempo_statement(
+    tempo_statement: &Statement,
+    module: &Module
+) -> StatementResolved {
+    match &tempo_statement.value {
+        VariableValue::Number(num) => {
+            if *num > 0.0 {
+                StatementResolved {
+                    kind: StatementKind::Tempo,
+                    value: StatementResolvedValue::Number(*num),
+                    indent: tempo_statement.indent,
+                    line: tempo_statement.line,
+                    column: tempo_statement.column,
+                }
+            } else {
+                eprintln!("⚠️ Invalid tempo value: {}", num);
+                StatementResolved {
+                    kind: StatementKind::Tempo,
+                    value: StatementResolvedValue::Unknown,
+                    indent: tempo_statement.indent,
+                    line: tempo_statement.line,
+                    column: tempo_statement.column,
+                }
+            }
+        }
+        VariableValue::Text(text) => {
+            if let Some(value) = module.variable_table.variables.get(text) {
+                let variable_value: StatementResolvedValue = match value {
+                    VariableValue::Number(num) if *num > 0.0 => {
+                        StatementResolvedValue::Number(*num)
+                    }
+                    VariableValue::Text(t) => StatementResolvedValue::String(t.clone()),
+                    _ => {
+                        eprintln!("⚠️ Unsupported variable type for Tempo: {:?}", value);
+                        StatementResolvedValue::Unknown
+                    }
+                };
+
+                StatementResolved {
+                    kind: StatementKind::Tempo,
+                    value: variable_value,
+                    indent: tempo_statement.indent,
+                    line: tempo_statement.line,
+                    column: tempo_statement.column,
+                }
+            } else {
+                eprintln!("⚠️ Tempo variable '{}' not found", text);
+                StatementResolved {
+                    kind: StatementKind::Tempo,
+                    value: StatementResolvedValue::Unknown,
+                    indent: tempo_statement.indent,
+                    line: tempo_statement.line,
+                    column: tempo_statement.column,
+                }
+            }
+        }
+        _ => {
+            eprintln!("⚠️ Invalid value type for Tempo statement: {:?}", tempo_statement.value);
+            StatementResolved {
+                kind: StatementKind::Tempo,
+                value: StatementResolvedValue::Unknown,
+                indent: tempo_statement.indent,
+                line: tempo_statement.line,
+                column: tempo_statement.column,
+            }
+        }
+    }
+}