parse variadic functions

src/codegen_x86_64.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, fmt::Write};
 
 use crate::{
-    parser::{Expr, Stmt},
+    parser::{Expr, Params, Stmt},
     symbol_table::SymbolTable,
     tokenizer::{Token, TokenType, ZernError, error},
 };
@@ -317,9 +317,13 @@ _builtin_environ:
                 emit!(&mut self.output, "    mov rbp, rsp");
                 emit!(&mut self.output, "    sub rsp, 256"); // TODO: eww
 
+                match params {
+                    Params::Normal(params) => {
                         for (i, param) in params.iter().enumerate() {
-                    let offset = env
+                            let offset = env.define_var(
-                        .define_var(param.var_name.lexeme.clone(), param.var_type.lexeme.clone());
+                                param.var_name.lexeme.clone(),
+                                param.var_type.lexeme.clone(),
+                            );
                             if let Some(reg) = REGISTERS.get(i) {
                                 emit!(&mut self.output, "    mov QWORD [rbp-{}], {}", offset, reg);
                             } else {
@@ -332,6 +336,9 @@ _builtin_environ:
                                 emit!(&mut self.output, "    mov QWORD [rbp-{}], rax", offset);
                             }
                         }
+                    }
+                    Params::Variadic(_name) => todo!(),
+                }
 
                 self.compile_stmt(env, body)?;
 

src/parser.rs

@@ -6,6 +6,12 @@ pub struct Param {
     pub var_name: Token,
 }
 
+#[derive(Debug, Clone)]
+pub enum Params {
+    Normal(Vec<Param>),
+    Variadic(Token),
+}
+
 #[derive(Debug, Clone)]
 pub enum Stmt {
     Expression(Expr),
@@ -38,7 +44,7 @@ pub enum Stmt {
     },
     Function {
         name: Token,
-        params: Vec<Param>,
+        params: Params,
         return_type: Token,
         body: Box<Stmt>,
         exported: bool,
@@ -164,13 +170,20 @@ impl Parser {
         let name = self.consume(TokenType::Identifier, "expected function name")?;
         self.consume(TokenType::LeftBracket, "expected '[' after function name")?;
 
+        let mut variadic_param: Option<Token> = None;
         let mut params = vec![];
         if !self.check(&TokenType::RightBracket) {
+            if self.match_token(&[TokenType::DoubleDot]) {
+                variadic_param =
+                    Some(self.consume(TokenType::Identifier, "expected variadic parameter name")?);
+            } else {
                 loop {
-                let var_name = self.consume(TokenType::Identifier, "expected parameter name")?;
+                    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")?;
+                    let var_type =
+                        self.consume(TokenType::Identifier, "expected parameter type")?;
 
                     params.push(Param { var_type, var_name });
                     if !self.match_token(&[TokenType::Comma]) {
@@ -178,6 +191,7 @@ impl Parser {
                     }
                 }
             }
+        }
 
         self.consume(TokenType::RightBracket, "expected ']' after arguments")?;
         self.consume(TokenType::Colon, "expected ':' after '['")?;
@@ -187,6 +201,10 @@ impl Parser {
         let body = Box::new(self.block()?);
         self.is_inside_function = false;
 
+        let params = match variadic_param {
+            Some(name) => Params::Variadic(name),
+            None => Params::Normal(params),
+        };
         Ok(Stmt::Function {
             name,
             params,

src/std/std.zr

@@ -1007,7 +1007,7 @@ func os.urandom?[n: i64]: ptr
     let fd: i64 = _builtin_syscall(SYS_openat, -100, "/dev/urandom", 0, 0)
     if fd < 0
         mem.free(buffer)
-        err.set(ERR_READ_FAILED, "os.urandom?: failed to open /dev/urandom")
+        err.set(ERR_OPEN_FAILED, "os.urandom?: failed to open /dev/urandom")
         return 0 as ptr
 
     let bytes_read: i64 = _builtin_syscall(SYS_read, fd, buffer, n)

src/symbol_table.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use crate::{
-    parser::Stmt,
+    parser::{Params, Stmt},
     tokenizer::{ZernError, error},
 };
 
@@ -100,13 +100,24 @@ impl SymbolTable {
                 if self.is_name_defined(&name.lexeme) {
                     return error!(name.loc, format!("tried to redefine '{}'", name.lexeme));
                 }
-                self.functions.insert(
+                match params {
+                    Params::Normal(params) => self.functions.insert(
                         name.lexeme.clone(),
                         FnType {
                             return_type: return_type.lexeme.clone(),
-                        params: Some(params.iter().map(|x| x.var_type.lexeme.clone()).collect()),
+                            params: Some(
+                                params.iter().map(|x| x.var_type.lexeme.clone()).collect(),
+                            ),
                         },
-                );
+                    ),
+                    Params::Variadic(name) => self.functions.insert(
+                        name.lexeme.clone(),
+                        FnType {
+                            return_type: return_type.lexeme.clone(),
+                            params: None,
+                        },
+                    ),
+                };
             }
             Stmt::Struct { name, fields } => {
                 if self.is_name_defined(&name.lexeme) {

src/typechecker.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use crate::{
-    parser::{Expr, Stmt},
+    parser::{Expr, Params, Stmt},
     symbol_table::{SymbolTable, Type},
     tokenizer::{TokenType, ZernError, error},
 };
@@ -171,8 +171,13 @@ impl<'a> TypeChecker<'a> {
                         return error!(&name.loc, "main function must return i64");
                     }
 
+                    match params {
+                        Params::Normal(params) => {
                             if !params.is_empty() && params.len() != 2 {
-                        return error!(&name.loc, "main function must accept 0 or 2 parameters");
+                                return error!(
+                                    &name.loc,
+                                    "main function must accept 0 or 2 parameters"
+                                );
                             }
 
                             if params.len() == 2 {
@@ -190,6 +195,11 @@ impl<'a> TypeChecker<'a> {
                                 }
                             }
                         }
+                        Params::Variadic(_) => {
+                            return error!(&name.loc, "main function cannot be variadic");
+                        }
+                    }
+                }
 
                 if !self.is_valid_type_name(&return_type.lexeme) {
                     return error!(
@@ -202,6 +212,8 @@ impl<'a> TypeChecker<'a> {
 
                 env.push_scope();
 
+                match params {
+                    Params::Normal(params) => {
                         for param in params {
                             if !self.is_valid_type_name(&param.var_type.lexeme) {
                                 return error!(
@@ -210,7 +222,15 @@ impl<'a> TypeChecker<'a> {
                                 );
                             }
 
-                    env.define_var(param.var_name.lexeme.clone(), param.var_type.lexeme.clone());
+                            env.define_var(
+                                param.var_name.lexeme.clone(),
+                                param.var_type.lexeme.clone(),
+                            );
+                        }
+                    }
+                    Params::Variadic(name) => {
+                        env.define_var(name.lexeme.clone(), "ptr".into());
+                    }
                 }
 
                 self.typecheck_stmt(env, body)?;