clean up main.rs

Cargo.lock

@@ -238,7 +238,7 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "zern"
-version = "0.1.0"
+version = "0.3.0"
 dependencies = [
  "clap",
 ]

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "zern"
-version = "0.1.0"
+version = "0.3.0"
 edition = "2024"
 
 [dependencies]

examples/chip8.zr

@@ -290,7 +290,7 @@ func main[argc: i64, argv: ptr] : i64
     
     let c: CHIP8 = chip8_create()
 
-    let buffer: io.Buffer = io.read_binary_file(path)
+    let buffer: io.Buffer = must(io.read_binary_file?(path))
 
     for i in 0..buffer->size
         c->memory[0x200 + i] = buffer->data[i]

src/codegen_x86_64.rs

@@ -72,22 +72,22 @@ static REGISTERS: [&str; 6] = ["rdi", "rsi", "rdx", "rcx", "r8", "r9"];
 // TODO: currently they are all just 64 bit values
 static BUILTIN_TYPES: [&str; 7] = ["void", "u8", "i64", "str", "bool", "ptr", "any"];
 
-pub struct CodegenX86_64<'a> {
+pub struct CodegenX86_64 {
     output: String,
     data_section: String,
     label_counter: usize,
     data_counter: usize,
-    pub analyzer: &'a mut Analyzer,
+    pub analyzer: Analyzer,
 }
 
-impl<'a> CodegenX86_64<'a> {
+impl CodegenX86_64 {
-    pub fn new(analyzer: &'a mut Analyzer) -> CodegenX86_64<'a> {
+    pub fn new() -> CodegenX86_64 {
         CodegenX86_64 {
             output: String::new(),
             data_section: String::new(),
             label_counter: 0,
             data_counter: 1,
-            analyzer,
+            analyzer: Analyzer::new(),
         }
     }
 
@@ -135,7 +135,7 @@ _builtin_err_msg:
 
 section .text._builtin_read64
 _builtin_read64:
-    mov rax, qword [rdi]
+    mov rax, QWORD [rdi]
     ret
 
 section .text._builtin_set64

src/main.rs

@@ -73,39 +73,44 @@ fn compile_file(args: Args) -> Result<(), ZernError> {
 
     let filename = Path::new(&args.path).file_name().unwrap().to_str().unwrap();
 
-    let mut analyzer = analyzer::Analyzer::new();
+    let mut codegen = codegen_x86_64::CodegenX86_64::new();
-    let mut codegen = codegen_x86_64::CodegenX86_64::new(&mut analyzer);
     codegen.emit_prologue(args.use_gcc)?;
     compile_std!(&mut codegen, "syscalls.zr", "std.zr", "net.zr");
     compile_file_to(&mut codegen, filename, source)?;
 
     if !args.output_asm {
-        fs::write(format!("{}.s", args.out), codegen.get_output()).unwrap();
+        let out = args.out.unwrap_or_else(|| "out".into());
 
-        run_command(format!("nasm -f elf64 -o {}.o {}.s", args.out, args.out));
+        fs::write(format!("{}.s", out), codegen.get_output()).unwrap();
+
+        run_command(format!("nasm -f elf64 -o {}.o {}.s", out, out));
 
         if args.use_gcc {
             run_command(format!(
                 "gcc -no-pie -o {} {}.o -flto -Wl,--gc-sections {}",
-                args.out, args.out, args.cflags
+                out, out, args.cflags
             ));
         } else {
             run_command(format!(
                 "ld -static -o {} {}.o --gc-sections -e _start",
-                args.out, args.out
+                out, out
             ));
         }
 
         if args.run_exe {
             run_command(
-                std::fs::canonicalize(args.out)
+                std::fs::canonicalize(out)
                     .unwrap()
                     .to_string_lossy()
                     .into_owned(),
             );
         }
     } else {
-        fs::write(&args.out, codegen.get_output()).unwrap();
+        fs::write(
+            args.out.unwrap_or_else(|| "out.s".into()),
+            codegen.get_output(),
+        )
+        .unwrap();
     }
 
     Ok(())
@@ -116,8 +121,8 @@ fn compile_file(args: Args) -> Result<(), ZernError> {
 struct Args {
     path: String,
 
-    #[arg(short, default_value = "out", help = "Output path")]
+    #[arg(short, help = "Output path")]
-    out: String,
+    out: Option<String>,
 
     #[arg(short = 'S', help = "Only generate assembly")]
     output_asm: bool,

src/std/net.zr

@@ -42,7 +42,6 @@ func net.listen?[packed_host: i64, port: i64] : i64
     
     return s
 
-// TODO: resolve DNS
 func net.connect?[packed_host: i64, port: i64] : i64
     err.clear()
     let s: i64 = _builtin_syscall(SYS_socket, AF_INET, SOCK_STREAM, 0)