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

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

@@ -1,59 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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,
-            }
-        }
-    }
-}

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

@@ -1,176 +0,0 @@
-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

@@ -1,160 +0,0 @@
-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

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