@devaloop/devalang 0.0.1-alpha.2 → 0.0.1-alpha.4

package/rust/core/lexer/driver.rs

@@ -1,286 +0,0 @@
-
-
-use crate::core::{
-    lexer::{
-        at::handle_at_lexer,
-        brace::{ handle_lbrace_lexer, handle_rbrace_lexer },
-        colon::handle_colon_lexer,
-        comment::handle_comment_lexer,
-        equal::handle_equal_lexer,
-        newline::handle_newline_lexer,
-        bracket::{ handle_lbracket_lexer, handle_rbracket_lexer },
-        dot::handle_dot_lexer,
-        identifier::handle_identifier_lexer,
-        indent::handle_indent_lexer,
-        number::handle_number_lexer,
-        quote::{ handle_double_quote_lexer, handle_single_quote_lexer },
-    },
-    types::token::{ Token, TokenKind },
-};
-
-pub fn lex(input: String) -> Vec<Token> {
-    let mut tokens = Vec::new();
-
-    let mut line = 1;
-    let mut column = 1;
-
-    let mut indent_stack: Vec<usize> = vec![0];
-    let mut current_indent = 0;
-    let mut at_line_start = true;
-
-    let mut chars = input.chars().peekable();
-
-    while let Some(_) = chars.peek() {
-        if at_line_start {
-            let (new_tokens, new_indent_stack, new_line, new_column) = handle_indent_lexer(
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            // Update the main tokens vector and indent stack
-            tokens = new_tokens;
-            indent_stack = new_indent_stack;
-            line = new_line;
-            column = new_column;
-
-            // Reset at_line_start flag
-            at_line_start = false;
-        }
-
-        // Read the next character
-        let Some(ch) = chars.next() else {
-            break;
-        };
-
-        // Newline handling
-        if ch == '\n' {
-            handle_newline_lexer(
-                ch,
-                &mut chars,
-                &mut tokens,
-                &mut line,
-                &mut column,
-                &mut at_line_start,
-                &mut current_indent
-            );
-
-            continue;
-        }
-
-        if ch == ' ' || ch == '\t' {
-            column += if ch == '\t' { 4 } else { 1 };
-            continue;
-        }
-
-        if ch == '#' {
-            handle_comment_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == ':' {
-            handle_colon_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '=' {
-            handle_equal_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '[' {
-            handle_lbracket_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == ']' {
-            handle_rbracket_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '{' {
-            handle_lbrace_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '}' {
-            handle_rbrace_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '"' {
-            handle_double_quote_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '\'' {
-            handle_single_quote_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '.' {
-            handle_dot_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '@' {
-            handle_at_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch.is_ascii_digit() {
-            handle_number_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch.is_ascii_alphabetic() {
-            handle_identifier_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        // Skip unknown char
-        column += 1;
-    }
-
-    while indent_stack.len() > 1 {
-        indent_stack.pop();
-        current_indent = *indent_stack.last().unwrap();
-        tokens.push(Token {
-            kind: TokenKind::Dedent,
-            lexeme: String::new(),
-            line,
-            column,
-            indent: current_indent,
-        });
-    }
-
-    tokens.push(Token {
-        kind: TokenKind::EOF,
-        lexeme: String::new(),
-        line: line + 1, // EOF is considered to be on the next line
-        column: 0, // EOF has no column
-        indent: 0, // EOF has no indent
-    });
-
-    tokens
-}

package/rust/core/lexer/quote.rs

@@ -1,61 +0,0 @@
-use crate::core::types::token::{Token, TokenKind};
-
-pub fn handle_single_quote_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize
-) {
-    let mut string_content = String::new();
-    *column += 1;
-
-    while let Some(next_ch) = chars.next() {
-        *column += 1;
-        if next_ch == '\'' {
-            break;
-        } else {
-            string_content.push(next_ch);
-        }
-    }
-
-    tokens.push(Token {
-        kind: TokenKind::String,
-        lexeme: string_content,
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-}
-
-pub fn handle_double_quote_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize
-) {
-    let mut string_content = String::new();
-    *column += 1; // skip the opening quote
-
-    while let Some(next_ch) = chars.next() {
-        *column += 1;
-        if next_ch == '"' {
-            break; // closing quote reached
-        } else {
-            string_content.push(next_ch);
-        }
-    }
-
-    tokens.push(Token {
-        kind: TokenKind::String,
-        lexeme: string_content,
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-}

package/rust/core/parser/at.rs

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

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

@@ -1,137 +0,0 @@
-use std::{ collections::HashMap, hash::Hash };
-
-use crate::{
-    core::types::{
-        statement::{ Statement, StatementKind },
-        token::{ Token, TokenDuration, TokenKind, TokenParamValue },
-        variable::{ Variable, VariableValue },
-    },
-    utils::logger::log_message,
-};
-
-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 identifier_token = parser.peek().ok_or("Expected identifier after dot")?.clone();
-    if identifier_token.kind != crate::core::types::token::TokenKind::Identifier {
-        return Err(format!("Expected Identifier after Dot, found {:?}", identifier_token.kind));
-    }
-
-    match identifier_token.lexeme.as_str() {
-        // TODO Execute each trigger logic
-
-        "kick" => {
-            trigger_value = String::from("Kick");
-        }
-        "snare" => {
-            trigger_value = String::from("Snare");
-        }
-        "hihat" => {
-            trigger_value = String::from("HiHat");
-        }
-        "tom" => {
-            trigger_value = String::from("Tom");
-        }
-        "clap" => {
-            trigger_value = String::from("Clap");
-        }
-        "crash" => {
-            trigger_value = String::from("Crash");
-        }
-        "ride" => {
-            trigger_value = String::from("Ride");
-        }
-
-        _ => {
-            log_message("Custom triggers are experimental", "WARNING");
-            trigger_value = identifier_token.lexeme.clone();
-        }
-    }
-
-    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: identifier_token.lexeme.clone(),
-            duration: duration.clone(),
-        },
-        value: params_value,
-        indent: token.indent,
-        line: token.line,
-        column: token.column,
-    })
-}