This commit is contained in:
2026-11-09 09:37:16 +01:00
commit 1b1f5dbae3
6 changed files with 374 additions and 0 deletions
+1
View File
@@ -0,0 +1 @@
/target
Generated
+7
View File
@@ -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"
+6
View File
@@ -0,0 +1,6 @@
[package]
name = "rscript"
version = "0.1.0"
edition = "2024"
[dependencies]
+65
View File
@@ -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<FnParam>,
pub elements: Vec<FnElement>,
}
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<FnCallArg>,
}
pub enum FnCallArg {
Expr(ExprIdent),
Number(ExprNumber),
String(ExprString),
}
pub struct Ident {
pub name: String,
}
+293
View File
@@ -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<char> {
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::<usize>();
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::<usize>();
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::Item> {
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, ";")
})
);
}
}
+2
View File
@@ -0,0 +1,2 @@
pub mod ast;
pub mod lex;