Objective-C interop + a few improvements

6 files changed, 79 insertions, 39 deletions

diff --git a/std/fs.zc b/std/fs.zc
index c19f9f1..7a54005 100644
--- a/std/fs.zc
+++ b/std/fs.zc
@@ -2,21 +2,23 @@ import "./core.zc"
 import "./result.zc"
 import "./string.zc"
 import "./vec.zc"
+import "./mem.zc"
 
 def Z_SEEK_SET = 0;
 def Z_SEEK_END = 2;
 def Z_F_OK = 0;
 
+include <dirent.h>
+include <sys/stat.h>
+include <unistd.h>
+include <stdlib.h>
+include <stdio.h>
 
 // TODO: restructure this tomorrow.
 raw {
-    #include <dirent.h>
-    #include <sys/stat.h>
-    #include <unistd.h>
-
-    // typedef needed for Vec<DirEntry*> generation if inferred
     typedef struct DirEntry* DirEntryPtr;
     
+    // Wrappers for FILE* handling due to opaque pointer casting
     void* _z_fs_fopen(char* path, char* mode) {
         return fopen(path, mode);
     }
@@ -40,7 +42,9 @@ raw {
     int64_t _z_fs_ftell(void* stream) {
         return (int64_t)ftell((FILE*)stream);
     }
-
+    
+    // Wrappers needed because C headers declare these with 'const char*' 
+    // but Zen C externs generate 'char*', leading to conflicting types.
     int _z_fs_access(char* pathname, int mode) {
         return access(pathname, mode);
     }
@@ -53,6 +57,7 @@ raw {
         return rmdir(pathname);
     }
 
+    // Wrappers for DIR* handling
     void* _z_fs_opendir(char* name) {
         return opendir(name);
     }
@@ -61,14 +66,7 @@ raw {
         return closedir((DIR*)dir);
     }
 
-    void* _z_fs_malloc(size_t size) {
-        return malloc(size);
-    }
-
-    void _z_fs_free(void* ptr) {
-        free(ptr);
-    }
-
+    // struct stat / struct dirent helpers
     int _z_fs_get_metadata(char* path, uint64_t* size, int* is_dir, int* is_file) {
         struct stat st;
         if (stat(path, &st) != 0) return -1;
@@ -96,6 +94,10 @@ raw {
     }
 }
 
+// Direct externs
+extern fn malloc(size: usize) -> void*;
+extern fn free(ptr: void*);
+
 extern fn _z_fs_mkdir(path: char*) -> int;
 extern fn _z_fs_get_metadata(path: char*, size: U64*, is_dir: int*, is_file: int*) -> int;
 extern fn _z_fs_read_entry(dir: void*, out_name: char*, buf_size: int, is_dir: int*) -> int;
@@ -105,13 +107,13 @@ extern fn _z_fs_fread(ptr: void*, size: usize, nmemb: usize, stream: void*) -> u
 extern fn _z_fs_fwrite(ptr: void*, size: usize, nmemb: usize, stream: void*) -> usize;
 extern fn _z_fs_fseek(stream: void*, offset: long, whence: int) -> int;
 extern fn _z_fs_ftell(stream: void*) -> long;
+extern fn _z_fs_opendir(name: char*) -> void*;
+extern fn _z_fs_closedir(dir: void*) -> int;
+
 extern fn _z_fs_access(pathname: char*, mode: int) -> int;
 extern fn _z_fs_unlink(pathname: char*) -> int;
 extern fn _z_fs_rmdir(pathname: char*) -> int;
-extern fn _z_fs_opendir(name: char*) -> void*;
-extern fn _z_fs_closedir(dir: void*) -> int;
-extern fn _z_fs_malloc(size: usize) -> void*;
-extern fn _z_fs_free(ptr: void*);
+
 
 struct File {
     handle: void*;
@@ -153,7 +155,7 @@ impl File {
         let size = _z_fs_ftell(self.handle);
         _z_fs_fseek(self.handle, 0, Z_SEEK_SET);
         
-        let buffer: char* = _z_fs_malloc((usize)size + 1);
+        let buffer: char* = malloc((usize)size + 1);
         if (buffer == NULL) {
             return Result<String>::Err("Out of memory");
         }
@@ -162,7 +164,7 @@ impl File {
         buffer[read] = 0;
         
         let s = String::new(buffer);
-        _z_fs_free(buffer);
+        free(buffer);
         
         let res = Result<String>::Ok(s);
         s.forget();
@@ -248,7 +250,7 @@ impl File {
         }
         
         let entries = Vec<DirEntry>::new();
-        let name_buf: char* = _z_fs_malloc(256);
+        let name_buf: char* = malloc(256);
         
         if (name_buf == NULL) {
             _z_fs_closedir(dir);
@@ -277,7 +279,7 @@ impl File {
             ent.name.forget();
         }
         
-        _z_fs_free(name_buf);
+        free(name_buf);
         _z_fs_closedir(dir);
         
         let res = Result< Vec<DirEntry> >::Ok(entries);
diff --git a/std/json.zc b/std/json.zc
index e6a15cd..d373ab9 100644
--- a/std/json.zc
+++ b/std/json.zc
@@ -5,6 +5,7 @@ import "./map.zc"
 import "./string.zc"
 import "./result.zc"
 import "./option.zc"
+import "./mem.zc"
 
 @derive(Eq)
 enum JsonType {
@@ -450,3 +451,9 @@ impl JsonValue {
         }
     }
 }
+
+impl Drop for JsonValue {
+    fn drop(self) {
+        self.free();
+    }
+}
diff --git a/std/map.zc b/std/map.zc
index 8e58cdc..70d6ad2 100644
--- a/std/map.zc
+++ b/std/map.zc
@@ -1,6 +1,7 @@
 
 import "./core.zc"
 import "./option.zc"
+import "./mem.zc"
 
 raw {
     extern size_t __zen_hash_seed;
@@ -248,3 +249,9 @@ impl Map<V> {
         };
     }
 }
+
+impl Drop for Map<V> {
+    fn drop(self) {
+        self.free();
+    }
+}
diff --git a/std/net.zc b/std/net.zc
index 72c3fcb..dd10642 100644
--- a/std/net.zc
+++ b/std/net.zc
@@ -8,6 +8,7 @@ include <errno.h>
 import "./core.zc"
 import "./result.zc"
 import "./string.zc"
+import "./mem.zc"
 
 def Z_AF_INET = 2;
 def Z_SOCK_STREAM = 1;
@@ -36,15 +37,11 @@ raw {
         if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) return -2;
         return 0;
     }
-    
+
     static int _z_net_accept(int fd) {
         return accept(fd, NULL, NULL);
     }
 
-    static ssize_t _z_net_read(int fd, char* buf, size_t n) {
-        return read(fd, (void*)buf, n);
-    }
-
     static ssize_t _z_net_write(int fd, char* buf, size_t n) {
         return write(fd, (const void*)buf, n);
     }
@@ -52,11 +49,11 @@ raw {
 
 extern fn socket(domain: int, type: int, proto: int) -> int;
 extern fn close(fd: int) -> int;
+extern fn read(fd: int, buf: void*, count: usize) -> isize;
 
 extern fn _z_net_bind(fd: int, host: char*, port: int) -> int;
 extern fn _z_net_connect(fd: int, host: char*, port: int) -> int;
 extern fn _z_net_accept(fd: int) -> int;
-extern fn _z_net_read(fd: int, buf: char*, n: usize) -> isize;
 extern fn _z_net_write(fd: int, buf: char*, n: usize) -> isize;
 
 
@@ -66,7 +63,7 @@ struct TcpStream {
 
 impl TcpStream {
     fn read(self, buf: char*, len: usize) -> Result<usize> {
-        let n = _z_net_read(self.fd, buf, len);
+        let n = read(self.fd, (void*)buf, len);
         if (n < 0) return Result<usize>::Err("Read failed");
         return Result<usize>::Ok((usize)n);
     }
@@ -96,6 +93,12 @@ impl TcpStream {
     }
 }
 
+impl Drop for TcpStream {
+    fn drop(self) {
+        self.close();
+    }
+}
+
 struct TcpListener {
     fd: int;
 }
@@ -126,3 +129,9 @@ impl TcpListener {
         }
     }
 }
+
+impl Drop for TcpListener {
+    fn drop(self) {
+        self.close();
+    }
+}
diff --git a/std/thread.zc b/std/thread.zc
index e90943b..98f080e 100644
--- a/std/thread.zc
+++ b/std/thread.zc
@@ -5,6 +5,7 @@ include <unistd.h>
 
 import "./core.zc"
 import "./result.zc"
+import "./mem.zc"
 
 raw {
     typedef void (*ZenThreadFunc)(void*);
@@ -120,11 +121,17 @@ impl Mutex {
         if (self.handle) {
             _z_mutex_destroy(self.handle);
             free(self.handle);
+            self.handle = NULL;
         }
     }
 }
 
+impl Drop for Mutex {
+    fn drop(self) {
+        self.free();
+    }
+}
+
 fn sleep_ms(ms: int) {
     _z_usleep(ms * 1000);
 }
-
diff --git a/std/time.zc b/std/time.zc
index 1191821..8e7cc6c 100644
--- a/std/time.zc
+++ b/std/time.zc
@@ -1,18 +1,28 @@
-
 import "./core.zc"
 
+include <time.h>
+include <unistd.h>
+include <sys/time.h>
+include <stdlib.h>
+
 raw {
-    #include <time.h>
-    #include <unistd.h>
-    #include <sys/time.h>
-    
     static uint64_t _time_now_impl(void) {
         struct timeval tv;
         gettimeofday(&tv, NULL);
         return (uint64_t)(tv.tv_sec) * 1000 + (uint64_t)(tv.tv_usec) / 1000;
     }
+
+    static long _z_time_time(void) {
+        return (long)time(NULL);
+    }
 }
 
+extern fn srand(seed: U32);
+extern fn rand() -> int;
+extern fn usleep(micros: U32) -> int;
+extern fn _time_now_impl() -> U64;
+extern fn _z_time_time() -> long;
+
 struct Duration {
     millis: U64;
 }
@@ -33,10 +43,8 @@ extern size_t __zen_hash_seed;
 
 impl Time {
     fn randomize_hash() {
-        raw {
-            srand(time(NULL));
-            __zen_hash_seed ^= (size_t)rand();
-        }
+        srand((U32)_z_time_time());
+        __zen_hash_seed ^= (size_t)rand();
     }
 
     fn now() -> U64 {