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

package/rust/core/lexer/handler/driver.rs

@@ -0,0 +1,241 @@
+use crate::core::lexer::{
+    handler::{
+        arrow::handle_arrow_lexer, at::handle_at_lexer, brace::{ handle_lbrace_lexer, handle_rbrace_lexer }, colon::handle_colon_lexer, comment::handle_comment_lexer, dot::handle_dot_lexer, identifier::handle_identifier_lexer, indent::handle_indent_lexer, newline::handle_newline_lexer, number::handle_number_lexer, operator::handle_operator_lexer, slash::handle_slash_lexer, string::handle_string_lexer
+    },
+    token::{ Token, TokenKind },
+};
+
+fn advance_char<I: Iterator<Item = char>>(
+    chars: &mut std::iter::Peekable<I>,
+    line: &mut usize,
+    column: &mut usize
+) -> Option<char> {
+    while let Some(c) = chars.next() {
+        if c == '\r' {
+            continue;
+        } else if c == '\n' {
+            // newline: don't increment column
+        } else {
+            *column += 1;
+        }
+        return Some(c);
+    }
+    None
+}
+
+pub fn handle_content_lexing(content: String) -> Result<Vec<Token>, String> {
+    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 = content.chars().peekable();
+
+    while chars.peek().is_some() {
+        if at_line_start {
+            handle_indent_lexer(
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            at_line_start = false;
+        }
+
+        let Some(ch) = advance_char(&mut chars, &mut line, &mut column) else {
+            break;
+        };
+
+        match ch {
+            '\n' => {
+                handle_newline_lexer(
+                    ch,
+                    &mut chars,
+                    &mut tokens,
+                    &mut line,
+                    &mut column,
+                    &mut at_line_start,
+                    &mut current_indent
+                );
+            }
+            ' ' | '\t' => {
+                // Already handled by indent_lexer
+            }
+            '#' => {
+                handle_comment_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            ':' => {
+                handle_colon_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '=' | '!' | '<' | '>' => {
+                handle_operator_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '/' => {
+                handle_slash_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '-' => {
+                handle_arrow_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '{' => {
+                handle_lbrace_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '}' => {
+                handle_rbrace_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '.' => {
+                handle_dot_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '@' => {
+                handle_at_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            '\"' | '\'' => {
+                handle_string_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            c if c.is_ascii_digit() => {
+                handle_number_lexer(
+                    c,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            c if c.is_ascii_alphabetic() => {
+                handle_identifier_lexer(
+                    c,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            _ => {
+                // Ignore unknown char
+            }
+        }
+    }
+
+    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,
+        column: 0,
+        indent: 0,
+    });
+
+    // NOTE: Debug only
+    // for token in &tokens {
+    //     println!(
+    //         "{:?} @ line {}, col {}, indent {}",
+    //         token.kind,
+    //         token.line,
+    //         token.column,
+    //         token.indent
+    //     );
+    // }
+
+    Ok(tokens)
+}

package/rust/core/lexer/handler/identifier.rs

@@ -0,0 +1,41 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_identifier_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 ident = char.to_string();
+
+    while let Some(&c) = chars.peek() {
+        if c.is_ascii_alphanumeric() || c == '_' {
+            ident.push(c);
+            chars.next();
+            *column += 1;
+        } else {
+            break;
+        }
+    }
+
+    let kind = match ident.as_str() {
+        "if" => TokenKind::If,
+        "else" => TokenKind::Else,
+        "bank" => TokenKind::Bank,
+        "bpm" => TokenKind::Tempo,
+        "loop" => TokenKind::Loop,
+        "synth" => TokenKind::Synth,
+        _ => TokenKind::Identifier,
+    };
+
+    tokens.push(Token {
+        kind: kind.clone(),
+        lexeme: ident,
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+}

package/rust/core/lexer/handler/indent.rs

@@ -0,0 +1,52 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_indent_lexer(
+    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
+) {
+    *current_indent = 0;
+    let mut col = *column;
+
+    while let Some(&c) = chars.peek() {
+        if c == ' ' {
+            *current_indent += 1;
+            chars.next();
+            col += 1;
+        } else if c == '\t' {
+            *current_indent += 4;
+            chars.next();
+            col += 4;
+        } else {
+            break;
+        }
+    }
+
+    *column = col;
+
+    let last_indent = *indent_stack.last().unwrap();
+    if *current_indent > last_indent {
+        indent_stack.push(*current_indent);
+        tokens.push(Token {
+            kind: TokenKind::Indent,
+            lexeme: String::new(),
+            line: *line,
+            column: *column,
+            indent: *current_indent,
+        });
+    } else {
+        while *current_indent < *indent_stack.last().unwrap() {
+            indent_stack.pop();
+            tokens.push(Token {
+                kind: TokenKind::Dedent,
+                lexeme: String::new(),
+                line: *line,
+                column: *column,
+                indent: *current_indent,
+            });
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+pub mod driver;
+
+pub mod at;
+pub mod brace;
+pub mod colon;
+pub mod comment;
+pub mod dot;
+pub mod operator;
+pub mod identifier;
+pub mod newline;
+pub mod number;
+pub mod indent;
+pub mod string;
+pub mod arrow;
+pub mod slash;

package/rust/core/lexer/handler/newline.rs

@@ -0,0 +1,23 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_newline_lexer(
+    ch: char,
+    chars: &mut std::iter::Peekable<std::str::Chars>,
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize,
+    at_line_start: &mut bool,
+    current_indent: &mut usize
+) {
+    tokens.push(Token {
+        kind: TokenKind::Newline,
+        lexeme: ch.to_string(),
+        line: *line,
+        column: 0,
+        indent: *current_indent,
+    });
+
+    *line += 1;
+    *column = 1;
+    *at_line_start = true;
+}

package/rust/core/lexer/handler/number.rs

@@ -0,0 +1,31 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_number_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 number = char.to_string();
+
+    while let Some(&c) = chars.peek() {
+        if c.is_ascii_digit() {
+            number.push(c);
+            chars.next();
+            *column += 1;
+        } else {
+            break;
+        }
+    }
+
+    tokens.push(Token {
+        kind: TokenKind::Number,
+        lexeme: number,
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+}

package/rust/core/lexer/handler/operator.rs

@@ -0,0 +1,44 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_operator_lexer(
+    ch: 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 next = chars.peek().copied();
+
+    let (kind, len) = match (ch, next) {
+        ('=', Some('=')) => (TokenKind::DoubleEquals, 2),
+        ('!', Some('=')) => (TokenKind::NotEquals, 2),
+        ('>', Some('=')) => (TokenKind::GreaterEqual, 2),
+        ('<', Some('=')) => (TokenKind::LessEqual, 2),
+        ('=', _) => (TokenKind::Equals, 1),
+        ('>', _) => (TokenKind::Greater, 1),
+        ('<', _) => (TokenKind::Less, 1),
+        _ => {
+            return;
+        }
+    };
+
+    if len == 2 {
+        chars.next(); // consume second char
+    }
+
+    tokens.push(Token {
+        kind,
+        lexeme: if len == 2 {
+            format!("{}{}", ch, next.unwrap())
+        } else {
+            ch.to_string()
+        },
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += len;
+}

package/rust/core/lexer/handler/slash.rs

@@ -0,0 +1,21 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_slash_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 slash = char.to_string();
+
+    tokens.push(Token {
+        kind: TokenKind::Slash,
+        lexeme: slash,
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+}

package/rust/core/lexer/handler/string.rs

@@ -0,0 +1,63 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_string_lexer(
+    ch: 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 quote_char = ch;
+
+    let start_column = *column;
+    let start_line = *line;
+
+    *column += 1;
+
+    let mut string_content = String::new();
+
+    while let Some(&next_ch) = chars.peek() {
+        if next_ch == quote_char {
+            chars.next();
+            *column += 1;
+            break;
+        } else if next_ch == '\\' {
+            chars.next();
+            *column += 1;
+
+            if let Some(escaped) = chars.next() {
+                match escaped {
+                    'n' => string_content.push('\n'),
+                    't' => string_content.push('\t'),
+                    '\\' => string_content.push('\\'),
+                    '"' => string_content.push('"'),
+                    '\'' => string_content.push('\''),
+                    other => {
+                        string_content.push('\\');
+                        string_content.push(other);
+                    }
+                }
+                *column += 1;
+            }
+        } else {
+            chars.next();
+            if next_ch == '\n' {
+                *line += 1;
+                *column = 1;
+            } else {
+                *column += 1;
+            }
+            string_content.push(next_ch);
+        }
+    }
+
+    tokens.push(Token {
+        kind: TokenKind::String,
+        lexeme: string_content,
+        indent: *current_indent,
+        line: start_line,
+        column: start_column,
+    });
+}