@devaloop/devalang 0.0.1-alpha.1

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

@@ -0,0 +1,176 @@
+use std::collections::HashMap;
+
+use crate::core::{
+    parser::parse_with_resolving_with_module,
+    types::{
+        module::Module,
+        statement::{ Statement, StatementKind, StatementResolved, StatementResolvedValue },
+        token::{ TokenDuration, TokenParamValue },
+        variable::VariableValue,
+    },
+};
+
+pub fn resolve_trigger_statement(
+    stmt: &Statement,
+    entity: String,
+    duration: TokenDuration,
+    module: &Module
+) -> StatementResolved {
+    let mut entity_value = VariableValue::Unknown;
+
+    if let Some(value) = module.variable_table.variables.get(&entity) {
+        entity_value = value.clone();
+    } else {
+        entity_value = VariableValue::Text(entity.clone());
+    }
+
+    let duration_raw_value = match duration {
+        TokenDuration::Auto => "auto",
+        TokenDuration::Infinite => "infinite",
+        TokenDuration::Number(n) => &n.to_string(),
+        TokenDuration::Identifier(ref id) => id.as_str(),
+        _ => "unknown",
+    };
+
+    let duration_variable_value = module.variable_table.variables.get(duration_raw_value);
+    let mut parsed_duration_value = TokenDuration::Unknown;
+
+    if duration_variable_value.is_some() {
+        parsed_duration_value = duration_variable_value
+            .as_ref()
+            .map_or(TokenDuration::Unknown, |value| {
+                match value {
+                    VariableValue::Text(text) => TokenDuration::Identifier(text.clone()),
+                    VariableValue::Number(num) => TokenDuration::Number(*num),
+                    VariableValue::Boolean(_) => TokenDuration::Unknown,
+                    _ => {
+                        eprintln!("⚠️ Invalid duration type for Trigger: {:?}", value);
+                        TokenDuration::Unknown
+                    }
+                }
+            });
+    } else if let Ok(num) = duration_raw_value.parse::<f32>() {
+        parsed_duration_value = TokenDuration::Number(num);
+    } else if duration_raw_value == "auto" {
+        parsed_duration_value = TokenDuration::Auto;
+    } else if duration_raw_value == "infinite" {
+        parsed_duration_value = TokenDuration::Infinite;
+    } else {
+        eprintln!("⚠️ Invalid duration format: {}", duration_raw_value);
+    }
+
+    match &stmt.value {
+        VariableValue::Text(text) => {
+            if let Some(value) = module.variable_table.variables.get(text) {
+                let parsed_entity_value: StatementResolvedValue = match value {
+                    VariableValue::Array(arr) => {
+                        StatementResolvedValue::Array(
+                            parse_with_resolving_with_module(arr.clone(), module)
+                        )
+                    }
+                    VariableValue::Map(map) => {
+                        let mut resolved_map = HashMap::new();
+
+                        for (key, value) in map {
+                            let resolved_value = match value {
+                                TokenParamValue::String(text) =>
+                                    StatementResolvedValue::String(text.clone()),
+                                TokenParamValue::Number(num) =>
+                                    StatementResolvedValue::Number(*num),
+                                TokenParamValue::Boolean(b) => StatementResolvedValue::Boolean(*b),
+                                _ => {
+                                    eprintln!(
+                                        "⚠️ Unsupported variable type for Trigger map: {:?}",
+                                        value
+                                    );
+                                    StatementResolvedValue::Unknown
+                                }
+                            };
+                            resolved_map.insert(key.clone(), resolved_value);
+                        }
+
+                        StatementResolvedValue::Map(resolved_map)
+                    }
+
+                    | VariableValue::Text(_)
+                    | VariableValue::Number(_)
+                    | VariableValue::Boolean(_) => {
+                        StatementResolvedValue::String(text.clone())
+                    }
+                    _ => {
+                        eprintln!("⚠️ Unsupported variable type for Trigger entity: {:?}", value);
+                        StatementResolvedValue::Unknown
+                    }
+                };
+
+                StatementResolved {
+                    kind: StatementKind::Trigger {
+                        entity: entity.clone(),
+                        duration: parsed_duration_value,
+                    },
+                    value: parsed_entity_value,
+                    indent: stmt.indent,
+                    line: stmt.line,
+                    column: stmt.column,
+                }
+            } else {
+                eprintln!("⚠️ Trigger variable '{}' not found", text);
+                StatementResolved {
+                    kind: StatementKind::Trigger {
+                        entity: entity.clone(),
+                        duration: parsed_duration_value,
+                    },
+                    value: StatementResolvedValue::Unknown,
+                    indent: stmt.indent,
+                    line: stmt.line,
+                    column: stmt.column,
+                }
+            }
+        }
+        VariableValue::Map(map) => {
+            let mut resolved_map = HashMap::new();
+
+            // TODO Handle nested maps and arrays
+
+            StatementResolved {
+                kind: StatementKind::Trigger {
+                    entity: entity.clone(),
+                    duration: parsed_duration_value,
+                },
+                value: StatementResolvedValue::Map(resolved_map),
+                indent: stmt.indent,
+                line: stmt.line,
+                column: stmt.column,
+            }
+        }
+        VariableValue::Null => {
+            StatementResolved {
+                kind: StatementKind::Trigger {
+                    entity: entity.clone(),
+                    duration: parsed_duration_value,
+                },
+                value: StatementResolvedValue::Map(HashMap::new()),
+                indent: stmt.indent,
+                line: stmt.line,
+                column: stmt.column,
+            }
+        }
+
+        // TODO Parse other parameters
+
+        _ => {
+            eprintln!("⚠️ Invalid value type for Trigger statement: {:?}", stmt.value);
+
+            StatementResolved {
+                kind: StatementKind::Trigger {
+                    entity: entity.clone(),
+                    duration: parsed_duration_value,
+                },
+                value: StatementResolvedValue::Unknown,
+                indent: stmt.indent,
+                line: stmt.line,
+                column: stmt.column,
+            }
+        }
+    }
+}

package/rust/core/types/cli.rs

@@ -0,0 +1,160 @@
+use clap::{ Parser, Subcommand };
+use crate::utils::version::get_version;
+
+#[derive(Parser)]
+#[command(name = "devalang")]
+#[command(author = "Devaloop")]
+#[command(version = get_version())]
+#[command(about = "🦊 Devalang – A programming language for music and sound.")]
+pub struct Cli {
+    #[command(subcommand)]
+    pub command: CliCommands,
+}
+
+#[derive(Subcommand)]
+pub enum CliTemplateCommand {
+    /// Lists all available templates for Devalang projects.
+    List,
+    /// Displays information about a specific template.
+    Info {
+        name: String,
+    },
+}
+
+pub enum CompilationMode {
+    /// Real-time compilation mode, for compiling files as soon as possible.
+    RealTime,
+
+    /// Batch compilation mode, for compiling files one by one.
+    Batch,
+
+    /// Check mode, used for analyzing the code without compiling it.
+    Check,
+}
+
+#[derive(Subcommand)]
+pub enum CliCommands {
+    /// Build the program and generate output files.
+    ///
+    /// ### Arguments
+    /// - `entry` - The entry point of the program to build. Defaults to "./src".
+    /// - `output` - The directory where the output files will be generated. Defaults to "./output".
+    /// - `watch` - Whether to watch for changes and rebuild. Defaults to "true".
+    ///
+    /// ### Example
+    /// ```bash
+    /// devalang build --entry ./src --output ./output --watch true
+    /// ```
+    ///
+    Build {
+        #[arg(short, long, default_value = "./src")]
+        /// The entry point of the program to build.
+        ///
+        /// ### Default value
+        /// - `./src`
+        ///
+        entry: String,
+
+        #[arg(short, long, default_value = "./output")]
+        /// The directory where the output files will be generated.
+        ///
+        /// ### Default value
+        /// - `./output`
+        ///
+        output: String,
+
+        #[arg(short, long, default_value = "true")]
+        /// Whether to watch for changes and rebuild.
+        ///
+        /// ### Default value
+        /// - `true`
+        ///
+        watch: String,
+
+        #[arg(long, default_value = "real-time")]
+        /// The mode of compilation.
+        ///
+        /// ### Default value
+        /// - `real-time`
+        ///
+        /// ### Possible values
+        /// - `real-time` - Compiles files as soon as possible.
+        /// - `batch` - Compiles files one by one.
+        /// - `check` - Analyzes the code without compiling it.
+        ///
+        compilation_mode: String,
+
+        #[arg(short, long, default_value = "false")]
+        /// Whether to print debug information.
+        ///
+        /// ### Default value
+        /// - `false`
+        ///
+        debug: String,
+
+        #[arg(short, long, default_value = "false")]
+        /// Whether to compress the output files.
+        ///
+        /// ### Default value
+        /// - `false`
+        ///
+        compress: String,
+    },
+
+    /// Analyze the program for errors and warnings.
+    ///
+    /// ### Arguments
+    /// - `entry` - The entry point of the program to analyze. Defaults to "./src".
+    /// - `watch` - Whether to watch for changes and re-analyze. Defaults to "true".
+    ///
+    /// ### Example
+    /// ```bash
+    /// devalang check --entry ./src --watch true --compilation-mode real-time
+    /// ```
+    Check {
+        #[arg(short, long, default_value = "./src")]
+        /// The entry point of the program to analyze.
+        ///
+        /// ### Default value
+        /// - `./src`
+        ///
+        entry: String,
+
+        #[arg(short, long, default_value = "./output")]
+        /// The directory where the output files will be generated.
+        ///
+        /// ### Default value
+        /// - `./output`
+        ///
+        output: String,
+
+        #[arg(short, long, default_value = "false")]
+        /// Whether to watch for changes and re-analyze.
+        ///
+        /// ### Default value
+        /// - `false`
+        ///
+        watch: String,
+
+        #[arg(short, long, default_value = "real-time")]
+        /// The mode of compilation.
+        ///
+        /// ### Default value
+        /// - `real-time`
+        ///
+        /// ### Possible values
+        /// - `real-time` - Analyzes files as soon as possible.
+        /// - `batch` - Analyzes files one by one.
+        /// - `check` - Analyzes the code without compiling it.
+        ///
+        compilation_mode: String,
+
+        #[arg(short, long, default_value = "false")]
+        /// Whether to print debug information.
+        ///
+        /// ### Default value
+        /// - `false`
+        ///
+        debug: String,
+    },
+}

package/rust/core/types/mod.rs

@@ -0,0 +1,7 @@
+pub mod token;
+pub mod statement;
+pub mod variable;
+pub mod store;
+pub mod parser;
+pub mod module;
+pub mod cli;

package/rust/core/types/module.rs

@@ -0,0 +1,41 @@
+use crate::core::types::{
+    statement::Statement,
+    store::{ ExportTable, ImportTable, VariableTable },
+    token::Token,
+    variable::VariableValue,
+};
+
+#[derive(Debug, Clone)]
+pub struct Module {
+    pub path: String,
+    pub tokens: Vec<Token>,
+    pub statements: Vec<Statement>,
+    pub variable_table: VariableTable,
+    pub export_table: ExportTable,
+    pub import_table: ImportTable,
+}
+
+impl Module {
+    pub fn new(path: String) -> Self {
+        Module {
+            path,
+            tokens: Vec::new(),
+            statements: Vec::new(),
+            variable_table: VariableTable::new(),
+            export_table: ExportTable::new(),
+            import_table: ImportTable::new(),
+        }
+    }
+
+    pub fn add_statement(&mut self, statement: Statement) {
+        self.statements.push(statement);
+    }
+
+    pub fn set_variable(&mut self, name: String, value: VariableValue) {
+        self.variable_table.set(name, value);
+    }
+
+    pub fn get_variable(&self, name: &str) -> Option<&VariableValue> {
+        self.variable_table.get(name)
+    }
+}

package/rust/core/types/parser.rs

@@ -0,0 +1,73 @@
+use crate::core::types::{
+    store::{ ExportTable, ImportTable, VariableTable },
+    token::{ Token, TokenKind },
+};
+
+#[derive(Debug, Clone)]
+pub struct Parser {
+    pub tokens: Vec<Token>,
+    pub token_index: usize,
+    pub variable_table: VariableTable,
+    pub export_table: ExportTable,
+    pub import_table: ImportTable,
+    pub current_module: String,
+}
+
+impl Parser {
+    pub fn new(tokens: Vec<Token>) -> Self {
+        Self {
+            tokens,
+            token_index: 0,
+            variable_table: VariableTable::new(),
+            export_table: ExportTable::new(),
+            import_table: ImportTable::new(),
+            current_module: String::new(),
+        }
+    }
+
+    pub fn set_tokens(&mut self, tokens: Vec<Token>) {
+        self.tokens = tokens;
+        self.token_index = 0;
+    }
+
+    pub fn peek(&self) -> Option<&Token> {
+        self.tokens.get(self.token_index)
+    }
+
+    pub fn next(&mut self) -> Option<&Token> {
+        let tok = self.tokens.get(self.token_index);
+        self.token_index += 1;
+        tok
+    }
+
+    pub fn expect(&mut self, kind: TokenKind) -> Result<&Token, String> {
+        let tok = self.next().ok_or("Unexpected end of input")?;
+        if tok.kind == kind {
+            Ok(tok)
+        } else {
+            Err(format!("Expected {:?}, got {:?}", kind, tok.kind))
+        }
+    }
+
+    pub fn collect_until<F>(&mut self, condition: F) -> Vec<Token> where F: Fn(&Token) -> bool {
+        let mut collected = Vec::new();
+        while let Some(token) = self.peek() {
+            if token.kind == TokenKind::Newline || token.kind == TokenKind::Indent {
+                self.next(); // Skip newlines and indents
+                continue;
+            }
+            if token.kind == TokenKind::EOF {
+                break;
+            }
+            if condition(token) {
+                break;
+            }
+            collected.push(self.next().unwrap().clone());
+        }
+        collected
+    }
+
+    pub fn is_eof(&self) -> bool {
+        self.token_index >= self.tokens.len()
+    }
+}

package/rust/core/types/statement.rs

@@ -0,0 +1,105 @@
+use std::collections::HashMap;
+use serde::Serialize;
+use crate::core::types::{ token::{ Token, TokenDuration, TokenParam }, variable::VariableValue };
+
+#[derive(Debug, Clone, Serialize)]
+pub struct Statement {
+    pub kind: StatementKind,
+    pub value: VariableValue,
+    pub indent: usize,
+    pub line: usize,
+    pub column: usize,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct StatementResolved {
+    pub kind: StatementKind,
+    pub value: StatementResolvedValue,
+    pub indent: usize,
+    pub line: usize,
+    pub column: usize,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub enum StatementValue {
+    Boolean(bool),
+    Number(f32),
+    String(String),
+    Array(Vec<Statement>),
+    Map(HashMap<String, VariableValue>),
+    Unknown,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub enum StatementResolvedValue {
+    Boolean(bool),
+    Number(f32),
+    String(String),
+    Array(Vec<StatementResolved>),
+    Map(HashMap<String, StatementResolvedValue>),
+    Unknown,
+    Null,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub enum StatementIterator {
+    Identifier(String),
+    Number(f32),
+    Array(Vec<Statement>),
+    Map(HashMap<String, VariableValue>),
+    Unknown,
+}
+
+#[derive(Debug, Serialize, Clone)]
+/// Represents the kind of a statement
+pub enum StatementKind {
+    // Trigger statements
+    Trigger {
+        entity: String,
+        duration: TokenDuration,
+        // params: Vec<TokenParam>,
+    },
+
+    // Variable statements
+    Let {
+        name: String,
+    },
+
+    // Loop statements
+    Loop {
+        iterator: StatementIterator,
+    },
+
+    // Conditional statements
+    // If {
+    //     // condition: ConditionParts,
+    //     condition_state: bool,
+    //     body: Vec<Statement>,
+    // },
+
+    // Keyword statements
+    Tempo,
+    Bank,
+
+    // At (@) statements
+    Include(String),
+    Export,
+    Import {
+        names: Vec<String>,
+        source: String,
+    },
+    Load {
+        source: String,
+        alias: String,
+    },
+
+    // Error & Unknown statements
+    Unknown,
+    Error,
+
+    // Empty or ignored statements
+    Comment(String),
+    Indent,
+    Dedent,
+    NewLine,
+}

package/rust/core/types/store.rs

@@ -0,0 +1,116 @@
+use std::collections::HashMap;
+
+use crate::core::types::{ module::Module, variable::VariableValue };
+
+#[derive(Debug, Default)]
+pub struct GlobalStore {
+    pub modules: HashMap<String, Module>,
+}
+
+impl GlobalStore {
+    pub fn new() -> Self {
+        GlobalStore {
+            modules: HashMap::new(),
+        }
+    }
+
+    pub fn insert_module(&mut self, path: String, module: Module) {
+        self.modules.insert(path, module);
+    }
+
+    pub fn update_module(&mut self, path: String, module: Module) {
+        if !self.modules.contains_key(&path) {
+            eprintln!("❌ Module {} not found in global store for update", path);
+            return;
+        }
+        
+        // Remove the existing module if it exists
+        self.modules.remove(&path);
+
+        // Insert the updated module
+        self.modules.insert(path, module);
+    }
+
+    pub fn get_module(&self, path: &str) -> Option<&Module> {
+        self.modules.get(path)
+    }
+
+    pub fn remove_module(&mut self, path: &str) -> Option<Module> {
+        self.modules.remove(path)
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct VariableTable {
+    pub variables: HashMap<String, VariableValue>,
+}
+
+impl VariableTable {
+    pub fn new() -> Self {
+        VariableTable {
+            variables: HashMap::new(),
+        }
+    }
+
+    pub fn set(&mut self, name: String, value: VariableValue) {
+        self.variables.insert(name, value);
+    }
+
+    pub fn get(&self, name: &str) -> Option<&VariableValue> {
+        self.variables.get(name)
+    }
+
+    pub fn remove(&mut self, name: &str) -> Option<VariableValue> {
+        self.variables.remove(name)
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct ExportTable {
+    pub exports: HashMap<String, VariableValue>,
+}
+
+impl ExportTable {
+    pub fn new() -> Self {
+        ExportTable {
+            exports: HashMap::new(),
+        }
+    }
+
+    pub fn add_export(&mut self, name: String, value: VariableValue) {
+        self.exports.insert(name, value);
+    }
+
+    pub fn get_export(&self, name: &str) -> Option<&VariableValue> {
+        self.exports.get(name)
+    }
+
+    pub fn remove_export(&mut self, name: &str) -> Option<VariableValue> {
+        self.exports.remove(name)
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct ImportTable {
+    pub imports: HashMap<String, VariableValue>,
+}
+
+impl ImportTable {
+    pub fn new() -> Self {
+        ImportTable {
+            imports: HashMap::new(),
+        }
+    }
+
+    pub fn add_import(&mut self, name: String, value: VariableValue) {
+        self.imports.insert(name, value);
+    }
+
+    pub fn get_import(&self, name: &str) -> Option<&VariableValue> {
+        self.imports.get(name)
+    }
+
+    pub fn remove_import(&mut self, name: &str) -> Option<VariableValue> {
+        self.imports.remove(name)
+    }
+}