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

package/rust/core/parser/handler/loop_.rs

@@ -0,0 +1,72 @@
+use std::collections::HashMap;
+
+use crate::core::{
+    lexer::{ token::TokenKind },
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+    parser.advance(); // consume 'loop'
+    let Some(loop_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    let Some(iterator_token) = parser.peek_clone() else {
+        return Statement::error(loop_token, "Expected number or identifier after 'loop'".to_string());
+    };
+
+    let iterator_value = match iterator_token.kind {
+        TokenKind::Number => {
+            let val = iterator_token.lexeme.parse::<f32>().unwrap_or(1.0);
+            parser.advance();
+            Value::Number(val)
+        }
+        TokenKind::Identifier => {
+            let val = iterator_token.lexeme.clone();
+            parser.advance();
+            Value::Identifier(val)
+        }
+        _ => {
+            return Statement::error(
+                iterator_token.clone(),
+                "Expected a number or identifier as loop count".to_string()
+            );
+        }
+    };
+
+    // Expect colon
+    let Some(colon_token) = parser.peek_clone() else {
+        return Statement::error(iterator_token.clone(), "Expected ':' after loop count".to_string());
+    };
+
+    if colon_token.kind != TokenKind::Colon {
+        let message = format!("Expected ':' after loop count, got {:?}", colon_token.kind);
+        return Statement::error(colon_token.clone(), message);
+    }
+
+    parser.advance(); // consume ':'
+
+    // Collect body
+    let tokens = parser.collect_until(|t| t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF);
+    let loop_body = parser.parse_block(tokens.clone(), global_store);
+
+    if let Some(token) = parser.peek() {
+        if token.kind == TokenKind::Dedent {
+            parser.advance();
+        }
+    }
+
+    let mut value_map = HashMap::new();
+    value_map.insert("iterator".to_string(), iterator_value);
+    value_map.insert("body".to_string(), Value::Block(loop_body.clone()));
+
+    Statement {
+        kind: StatementKind::Loop,
+        value: Value::Map(value_map),
+        indent: loop_token.indent,
+        line: loop_token.line,
+        column: loop_token.column,
+    }
+}

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

@@ -0,0 +1,8 @@
+pub mod at;
+pub mod identifier;
+pub mod dot;
+pub mod tempo;
+pub mod bank;
+pub mod loop_;
+pub mod condition;
+pub mod arrow_call;

package/rust/core/parser/handler/tempo.rs

@@ -0,0 +1,47 @@
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_tempo_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+    parser.advance(); // consume 'bpm'
+
+    let Some(tempo_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    // Expect a number or identifier
+    let Some(value_token) = parser.peek_clone() else {
+        return Statement::error(
+            tempo_token,
+            "Expected a number or identifier after 'bpm'".to_string()
+        );
+    };
+
+    let value = match value_token.kind {
+        TokenKind::Number => {
+            parser.advance();
+            Value::Number(value_token.lexeme.parse().unwrap_or(0.0))
+        }
+        TokenKind::Identifier => {
+            parser.advance();
+            Value::Identifier(value_token.lexeme.clone())
+        }
+        _ => {
+            return Statement::error(
+                value_token.clone(),
+                format!("Expected a number or identifier after 'bpm', got {:?}", value_token.kind)
+            );
+        }
+    };
+
+    Statement {
+        kind: StatementKind::Tempo,
+        value,
+        indent: tempo_token.indent,
+        line: tempo_token.line,
+        column: tempo_token.column,
+    }
+}

package/rust/core/parser/mod.rs

@@ -1,201 +1,4 @@
-pub mod identifer;
-pub mod variable;
-pub mod at;
-pub mod dot;
-pub mod bank;
-pub mod loop_;
-pub mod tempo;
+pub mod driver;
 
-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;
-}
+pub mod statement;
+pub mod handler;

package/rust/core/parser/statement.rs

@@ -0,0 +1,96 @@
+use serde::{ Deserialize, Serialize };
+use crate::core::{ lexer::token::Token, shared::{ duration::Duration, value::Value } };
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct Statement {
+    pub kind: StatementKind,
+    pub value: Value,
+    pub indent: usize,
+    pub line: usize,
+    pub column: usize,
+}
+
+impl Statement {
+    pub fn unknown() -> Self {
+        Statement {
+            kind: StatementKind::Unknown,
+            value: Value::Null,
+            indent: 0,
+            line: 0,
+            column: 0,
+        }
+    }
+
+    pub fn error(token: Token, message: String) -> Self {
+        Statement {
+            kind: StatementKind::Error { message },
+            value: Value::Null,
+            indent: token.indent,
+            line: token.line,
+            column: token.column,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Clone, Deserialize, PartialEq)]
+pub enum StatementKind {
+    // ───── Core Instructions ─────
+    Tempo,
+    Bank,
+    Load {
+        source: String,
+        alias: String,
+    },
+    Let {
+        name: String,
+    },
+    ArrowCall {
+        target: String,
+        method: String,
+        args: Vec<Value>,
+    },
+
+    // ───── Instruments ─────
+    Synth,
+
+    // ───── Playback / Scheduling ─────
+    Trigger {
+        entity: String,
+        duration: Duration,
+    },
+    Sleep,
+    Call,
+    Spawn,
+    Loop,
+    
+    // ───── Structure & Logic ─────
+    Group,
+
+    // ───── Module System ─────
+    Include(String),
+    Export {
+        names: Vec<String>,
+        source: String,
+    },
+    Import {
+        names: Vec<String>,
+        source: String,
+    },
+
+    // ───── Conditions ─────
+    If,
+    Else,
+    ElseIf,
+
+    // ───── Internal / Utility ─────
+    Comment,
+    Indent,
+    Dedent,
+    NewLine,
+
+    // ───── Error Handling ─────
+    Unknown,
+    Error {
+        message: String,
+    },
+}