toni/zern
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

array indexing, nested array literals

Browse Source
This commit is contained in:
Antoni Piasecki
2025-06-29 10:36:55 +02:00
parent 26598fe6f2
commit 574b9fd37c
6 changed files with 79 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
src/codegen_x86_64.rs
View File

@@ -58,8 +58,6 @@ macro_rules! emit {
}
static REGISTERS: [&str; 6] = ["rdi", "rsi", "rdx", "rcx", "r8", "r9"];
// TODO: currently they are all just 8 byte values
static TYPES: [&str; 6] = ["U8", "I64", "String", "Bool", "Ptr", "Array"];
pub struct CodegenX86_64 {
output: String,
@@ -234,12 +232,6 @@ OS.listdir:
pop r14
ret
section .text.Array.nth
Array.nth:
mov rax, [rdi]
mov rax, [rax + rsi*8]
ret
section .text.Array.set
Array.set:
mov rax, [rdi]
@@ -302,11 +294,6 @@ Array.free:
var_type,
initializer,
} => {
// TODO: types
if !TYPES.contains(&var_type.lexeme.as_str()) {
return error!(&name.loc, format!("unknown type: {}", var_type.lexeme));
}
self.compile_expr(env, initializer)?;
let offset = env.define_var(name.lexeme.clone(), var_type.lexeme);
emit!(&mut self.output, " mov QWORD [rbp-{}], rax", offset);
@@ -353,10 +340,6 @@ Array.free:
return_type,
body,
} => {
if !TYPES.contains(&return_type.lexeme.as_str()) {
return error!(&name.loc, format!("unknown type: {}", return_type.lexeme));
}
// TODO
if name.lexeme == "main" {
emit!(&mut self.output, "global {}", name.lexeme);
@@ -377,7 +360,7 @@ Array.free:
Some(x) => x,
None => return error!(&name.loc, "only up to 6 params allowed"),
};
emit!(&mut self.output, " mov QWORD [rbp-{}], {}", offset, reg,);
emit!(&mut self.output, " mov QWORD [rbp-{}], {}", offset, reg);
}
self.compile_stmt(env, *body)?;
@@ -625,16 +608,24 @@ Array.free:
}
Expr::ArrayLiteral(exprs) => {
emit!(&mut self.output, " call Array.new");
emit!(&mut self.output, " mov r12, rax");
emit!(&mut self.output, " push rax");
// TODO: nested array literals probably dont work
for expr in exprs {
self.compile_expr(env, expr)?;
emit!(&mut self.output, " mov rsi, rax");
emit!(&mut self.output, " mov rdi, r12");
emit!(&mut self.output, " pop rdi");
emit!(&mut self.output, " push rdi");
emit!(&mut self.output, " call Array.push");
}
emit!(&mut self.output, " mov rax, r12");
emit!(&mut self.output, " pop rax");
}
Expr::Index { expr, index } => {
self.compile_expr(env, *expr)?;
emit!(&mut self.output, " push rax");
self.compile_expr(env, *index)?;
emit!(&mut self.output, " pop rbx");
emit!(&mut self.output, " mov rbx, [rbx]");
emit!(&mut self.output, " mov rax, [rbx + rax*8]");
}
}
Ok(())

61
src/parser.rs
View File

@@ -67,8 +67,15 @@ pub enum Expr {
args: Vec<Expr>,
},
ArrayLiteral(Vec<Expr>),
Index {
expr: Box<Expr>,
index: Box<Expr>,
},
}
// TODO: currently they are all just 8 byte values
static TYPES: [&str; 6] = ["U8", "I64", "String", "Bool", "Ptr", "Array"];
pub struct Parser {
tokens: Vec<Token>,
current: usize,
@@ -120,7 +127,12 @@ impl Parser {
loop {
let var_name = self.consume(TokenType::Identifier, "expected parameter name")?;
self.consume(TokenType::Colon, "expected ':' after parameter name")?;
let var_type = self.consume(TokenType::Identifier, "expected parameter type")?;
if !TYPES.contains(&var_type.lexeme.as_str()) {
return error!(&name.loc, format!("unknown type: {}", var_type.lexeme));
}
params.push(Param { var_type, var_name });
if !self.match_token(&[TokenType::Comma]) {
break;
@@ -131,6 +143,9 @@ impl Parser {
self.consume(TokenType::RightBracket, "expected ']' after arguments")?;
self.consume(TokenType::Colon, "expected ':' after '['")?;
let return_type = self.consume(TokenType::Identifier, "expected return type")?;
if !TYPES.contains(&return_type.lexeme.as_str()) {
return error!(&name.loc, format!("unknown type: {}", return_type.lexeme));
}
self.is_inside_function = true;
let body = Box::new(self.block()?);
@@ -147,7 +162,12 @@ impl Parser {
fn let_declaration(&mut self) -> Result<Stmt, ZernError> {
let name = self.consume(TokenType::Identifier, "expected variable name")?;
self.consume(TokenType::Colon, "expected ':' after variable name")?;
let var_type = self.consume(TokenType::Identifier, "expected variable type")?;
if !TYPES.contains(&var_type.lexeme.as_str()) {
return error!(&name.loc, format!("unknown type: {}", var_type.lexeme));
}
self.consume(TokenType::Equal, "expected '=' after variable type")?;
let initializer = self.expression()?;
Ok(Stmt::Let {
@@ -401,24 +421,35 @@ impl Parser {
fn call(&mut self) -> Result<Expr, ZernError> {
let mut expr = self.primary()?;
while self.match_token(&[TokenType::LeftParen]) {
let mut args = vec![];
if !self.check(&TokenType::RightParen) {
loop {
args.push(self.expression()?);
if !self.match_token(&[TokenType::Comma]) {
break;
loop {
if self.match_token(&[TokenType::LeftParen]) {
let mut args = vec![];
if !self.check(&TokenType::RightParen) {
loop {
args.push(self.expression()?);
if !self.match_token(&[TokenType::Comma]) {
break;
}
}
}
let paren = self.consume(TokenType::RightParen, "expected ')' after arguments")?;
expr = Expr::Call {
callee: Box::new(expr),
paren,
args,
};
} else if self.match_token(&[TokenType::LeftBracket]) {
let index = self.expression()?;
self.consume(TokenType::RightBracket, "expected ']' after index")?;
expr = Expr::Index {
expr: Box::new(expr),
index: Box::new(index),
}
} else {
break;
}
let paren = self.consume(TokenType::RightParen, "expected ')' after arguments")?;
expr = Expr::Call {
callee: Box::new(expr),
paren,
args,
};
}
Ok(expr)