From 1b1f5dbae3043bdf965d29220a860f2e3e61d82f Mon Sep 17 00:00:00 2001 From: Rogier Reerink Date: Mon, 9 Nov 2026 09:37:16 +0100 Subject: [PATCH] Init. --- .gitignore | 1 + Cargo.lock | 7 ++ Cargo.toml | 6 ++ src/ast.rs | 65 ++++++++++++ src/lex.rs | 293 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/lib.rs | 2 + 6 files changed, 374 insertions(+) create mode 100644 .gitignore create mode 100644 Cargo.lock create mode 100644 Cargo.toml create mode 100644 src/ast.rs create mode 100644 src/lex.rs create mode 100644 src/lib.rs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ea8c4bf --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/target diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000..a96b264 --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "rscript" +version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..c73794b --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "rscript" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/src/ast.rs b/src/ast.rs new file mode 100644 index 0000000..f5a6375 --- /dev/null +++ b/src/ast.rs @@ -0,0 +1,65 @@ +pub enum Script { + Expr(Expr), + Fn(Fn), + FnCall(FnCall), +} + +pub struct Expr { + pub ident: ExprIdent, + pub value: ExprValue, +} + +pub struct ExprIdent(pub Ident); + +pub enum ExprValue { + Number(ExprNumber), + String(ExprString), +} + +pub struct ExprNumber { + pub raw: String, + pub value: f64, +} + +pub struct ExprString { + pub value: String, +} + +pub struct Fn { + pub ident: FnIdent, + pub params: Vec, + pub elements: Vec, +} + +pub struct FnIdent(pub Ident); + +pub struct FnParam { + pub ident: FnParamIdent, + pub ty: FnParamType, +} + +pub struct FnParamIdent(pub Ident); + +pub enum FnParamType { + Number, + String, +} + +pub enum FnElement { + Expr(Expr), +} + +pub struct FnCall { + pub ident: FnIdent, + pub args: Vec, +} + +pub enum FnCallArg { + Expr(ExprIdent), + Number(ExprNumber), + String(ExprString), +} + +pub struct Ident { + pub name: String, +} diff --git a/src/lex.rs b/src/lex.rs new file mode 100644 index 0000000..75ef8d8 --- /dev/null +++ b/src/lex.rs @@ -0,0 +1,293 @@ +#[derive(Debug, PartialEq, Eq)] +pub enum Token { + Comma, + Equals, + Fn, + Ident, + Let, + Number, + ParenL, + ParenR, + Semi, + String, + Unknown, +} + +#[derive(Debug, PartialEq, Eq)] +pub struct Span<'a> { + start: usize, + raw: &'a str, +} + +impl<'a> Span<'a> { + fn new(start: usize, raw: &'a str) -> Self { + Span { start, raw } + } + + pub fn start(&self) -> usize { + self.start + } + + pub fn end(&self) -> usize { + self.start + self.raw.len() + } + + pub fn raw(&self) -> &'a str { + self.raw + } +} + +#[derive(Debug, PartialEq, Eq)] +pub struct TokenSpan<'a> { + pub token: Token, + pub span: Span<'a>, +} + +struct Cursor { + pos: usize, +} + +impl Cursor { + fn advance_by(&mut self, n: usize) { + self.pos += n; + } +} + +impl Default for Cursor { + fn default() -> Self { + Cursor { pos: 0 } + } +} + +pub struct Lexer<'a> { + input: &'a str, + cursor: Cursor, +} + +impl<'a> Lexer<'a> { + pub fn new(input: &'a str) -> Self { + Lexer { + cursor: Cursor::default(), + input, + } + } + + fn consume(&mut self, n: usize) -> Span<'a> { + let start = self.cursor.pos; + let end = start + n; + let span = Span::new(start, &self.input[start..end]); + self.cursor.advance_by(n); + span + } + + fn peek_char(&self) -> Option { + self.input[self.cursor.pos..].chars().next() + } + + fn peek_ident(&self) -> Option<&'a str> { + let first = self + .peek_char() + .filter(|c| c.is_alphabetic() || *c == '_')?; + let start = self.cursor.pos; + let remaining = start + first.len_utf8(); + let end = remaining + + self.input[remaining..] + .chars() + .take_while(|c| c.is_alphanumeric() || *c == '_') + .map(|c| c.len_utf8()) + .sum::(); + Some(&self.input[start..end]) + } + + fn peek_number(&self) -> Option<&'a str> { + let first = self.peek_char().filter(|c| c.is_digit(10))?; + let start = self.cursor.pos; + let remaining = start + first.len_utf8(); + let end = remaining + + self.input[remaining..] + .chars() + .take_while(|c| c.is_digit(10) || *c == '_' || *c == '.') + .map(|c| c.len_utf8()) + .sum::(); + Some(&self.input[start..end]) + } + + fn peek_string(&self) -> Option<&'a str> { + let first = self.peek_char().filter(|c| *c == QUOTE)?; + let start = self.cursor.pos; + let remaining = start + first.len_utf8(); + let mut end = remaining; + let mut escaped = false; + while let Some(c) = self.input[end..].chars().next() { + end += c.len_utf8(); + if escaped { + escaped = false; + continue; + } + if c == '\\' { + escaped = true; + continue; + } + if c == QUOTE { + break; + } + } + Some(&self.input[start..end]) + } + + fn skip_whitespace(&mut self) { + while let Some(c) = self.peek_char().filter(|c| c.is_whitespace()) { + self.cursor.advance_by(c.len_utf8()); + } + } + + fn starts_with(&self, s: &str) -> bool { + self.input[self.cursor.pos..].starts_with(s) + } +} + +impl<'a> Iterator for Lexer<'a> { + type Item = TokenSpan<'a>; + + fn next(&mut self) -> Option { + self.skip_whitespace(); + + match self.peek_char()? { + EQUALS => { + return Some(TokenSpan { + token: Token::Equals, + span: self.consume(EQUALS.len_utf8()), + }); + } + SEMI => { + return Some(TokenSpan { + token: Token::Semi, + span: self.consume(SEMI.len_utf8()), + }); + } + _ => {} + } + + if self.starts_with(LET) { + return Some(TokenSpan { + token: Token::Let, + span: self.consume(LET.len()), + }); + } + + if let Some(ident) = self.peek_ident() { + Some(TokenSpan { + token: Token::Ident, + span: self.consume(ident.len()), + }) + } else if let Some(number) = self.peek_number() { + Some(TokenSpan { + token: Token::Number, + span: self.consume(number.len()), + }) + } else if let Some(string) = self.peek_string() { + Some(TokenSpan { + token: Token::String, + span: self.consume(string.len()), + }) + } else { + Some(TokenSpan { + token: Token::Unknown, + span: self.consume(1), + }) + } + } +} + +const EQUALS: char = '='; +const QUOTE: char = '"'; +const SEMI: char = ';'; + +const LET: &str = "let"; + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_let_number() { + let input = "let x = 5_000.0;"; + let mut lexer = Lexer::new(input); + assert_eq!( + lexer.next(), + Some(TokenSpan { + token: Token::Let, + span: Span::new(0, "let") + }) + ); + assert_eq!( + lexer.next(), + Some(TokenSpan { + token: Token::Ident, + span: Span::new(4, "x") + }) + ); + assert_eq!( + lexer.next(), + Some(TokenSpan { + token: Token::Equals, + span: Span::new(6, "=") + }) + ); + assert_eq!( + lexer.next(), + Some(TokenSpan { + token: Token::Number, + span: Span::new(8, "5_000.0") + }) + ); + assert_eq!( + lexer.next(), + Some(TokenSpan { + token: Token::Semi, + span: Span::new(15, ";") + }) + ); + } + + #[test] + fn test_let_string() { + let input = "let x = \"hello, world\";"; + let mut lexer = Lexer::new(input); + assert_eq!( + lexer.next(), + Some(TokenSpan { + token: Token::Let, + span: Span::new(0, "let") + }) + ); + assert_eq!( + lexer.next(), + Some(TokenSpan { + token: Token::Ident, + span: Span::new(4, "x") + }) + ); + assert_eq!( + lexer.next(), + Some(TokenSpan { + token: Token::Equals, + span: Span::new(6, "=") + }) + ); + assert_eq!( + lexer.next(), + Some(TokenSpan { + token: Token::String, + span: Span::new(8, "\"hello, world\"") + }) + ); + assert_eq!( + lexer.next(), + Some(TokenSpan { + token: Token::Semi, + span: Span::new(22, ";") + }) + ); + } +} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..851fe46 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,2 @@ +pub mod ast; +pub mod lex;