diff options
Diffstat (limited to 'std')
| -rw-r--r-- | std/core.zc | 2 | ||||
| -rw-r--r-- | std/cuda.zc | 30 | ||||
| -rw-r--r-- | std/env.zc | 12 | ||||
| -rw-r--r-- | std/fs.zc | 48 | ||||
| -rw-r--r-- | std/io.zc | 34 | ||||
| -rw-r--r-- | std/json.zc | 58 | ||||
| -rw-r--r-- | std/map.zc | 38 | ||||
| -rw-r--r-- | std/mem.zc | 2 | ||||
| -rw-r--r-- | std/net.zc | 14 | ||||
| -rw-r--r-- | std/option.zc | 2 | ||||
| -rw-r--r-- | std/path.zc | 34 | ||||
| -rw-r--r-- | std/queue.zc | 16 | ||||
| -rw-r--r-- | std/result.zc | 2 | ||||
| -rw-r--r-- | std/set.zc | 30 | ||||
| -rw-r--r-- | std/stack.zc | 4 | ||||
| -rw-r--r-- | std/string.zc | 120 | ||||
| -rw-r--r-- | std/thread.zc | 10 | ||||
| -rw-r--r-- | std/vec.zc | 22 |
18 files changed, 239 insertions, 239 deletions
diff --git a/std/core.zc b/std/core.zc index 910bfa6..f450517 100644 --- a/std/core.zc +++ b/std/core.zc @@ -5,7 +5,7 @@ include <stdio.h> include <stdbool.h> include <stdarg.h> -var __zen_hash_seed: usize = 14695981039346656037; +let __zen_hash_seed: usize = 14695981039346656037; raw { void _zen_panic(const char* file, int line, const char* func, const char* msg) { diff --git a/std/cuda.zc b/std/cuda.zc index dbb1fe6..c6a9403 100644 --- a/std/cuda.zc +++ b/std/cuda.zc @@ -7,7 +7,7 @@ import "./mem.zc" /// Allocate device memory for n elements of type T. fn cuda_alloc<T>(n: usize) -> T* { - var ptr: T* = NULL; + let ptr: T* = NULL; cudaMalloc((void**)&ptr, n * sizeof(T)); return ptr; } @@ -76,7 +76,7 @@ fn cuda_sync() { /// Get the number of CUDA devices. fn cuda_device_count() -> int { - var count: int = 0; + let count: int = 0; cudaGetDeviceCount(&count); return count; } @@ -90,7 +90,7 @@ fn cuda_set_device(id: int) { /// Get the last CUDA error code. fn cuda_last_error() -> int { - var err: int; + let err: int; err = (int)cudaGetLastError(); return err; } @@ -134,19 +134,19 @@ struct CudaMemInfo { } fn cuda_device_properties(device_id: int) -> CudaDeviceProp { - var mem: usize = 0; - var sm: int = 0; - var maj: int = 0; - var min: int = 0; - var max_t: int = 0; - var warp: int = 0; + let mem: usize = 0; + let sm: int = 0; + let maj: int = 0; + let min: int = 0; + let max_t: int = 0; + let warp: int = 0; - var name_ptr = alloc_n<char>(256); + let name_ptr = alloc_n<char>(256); name_ptr[0] = 0; _z_cuda_get_props(device_id, name_ptr, &mem, &sm, &maj, &min, &max_t, &warp); - var s = String::new(name_ptr); + let s = String::new(name_ptr); free(name_ptr); return CudaDeviceProp { @@ -161,20 +161,20 @@ fn cuda_device_properties(device_id: int) -> CudaDeviceProp { } fn cuda_driver_version() -> int { - var d: int = 0; + let d: int = 0; cudaDriverGetVersion(&d); return d; } fn cuda_runtime_version() -> int { - var r: int = 0; + let r: int = 0; cudaRuntimeGetVersion(&r); return r; } fn cuda_mem_info() -> CudaMemInfo { - var f: usize = 0; - var t: usize = 0; + let f: usize = 0; + let t: usize = 0; cudaMemGetInfo(&f, &t); return CudaMemInfo { free: f, total: t }; } @@ -30,7 +30,7 @@ struct Env {} impl Env { fn get(name: string) -> Option<string> { - var value: string = _z_env_get(name); + let value: string = _z_env_get(name); if (value == NULL) { return Option<string>::None(); } @@ -39,26 +39,26 @@ impl Env { } fn get_dup(name: string) -> Option<String> { - var value: string = _z_env_get(name); + let value: string = _z_env_get(name); if (value == NULL) { return Option<String>::None(); } - var v = String::from(value); - var o = Option<String>::Some(v); + let v = String::from(value); + let o = Option<String>::Some(v); v.forget(); return o; } fn set(name: string, value: string) -> EnvRes { - var ret: int = _z_env_set(name, value, 1); + let ret: int = _z_env_set(name, value, 1); return (ret == 0) ? EnvRes::OK() : EnvRes::ERR(); } fn unset(name: string) -> EnvRes { - var ret: int = _z_env_unset(name); + let ret: int = _z_env_unset(name); return (ret == 0) ? EnvRes::OK() : EnvRes::ERR(); } @@ -130,7 +130,7 @@ struct DirEntry { impl File { fn open(path: char*, mode: char*) -> Result<File> { - var h = _z_fs_fopen(path, mode); + let h = _z_fs_fopen(path, mode); if (h == NULL) { return Result<File>::Err("Failed to open file"); } @@ -150,39 +150,39 @@ impl File { } _z_fs_fseek(self.handle, 0, Z_SEEK_END); - var size = _z_fs_ftell(self.handle); + let size = _z_fs_ftell(self.handle); _z_fs_fseek(self.handle, 0, Z_SEEK_SET); - var buffer: char* = _z_fs_malloc((usize)size + 1); + let buffer: char* = _z_fs_malloc((usize)size + 1); if (buffer == NULL) { return Result<String>::Err("Out of memory"); } - var read = _z_fs_fread(buffer, 1, size, self.handle); + let read = _z_fs_fread(buffer, 1, size, self.handle); buffer[read] = 0; - var s = String::new(buffer); + let s = String::new(buffer); _z_fs_free(buffer); - var res = Result<String>::Ok(s); + let res = Result<String>::Ok(s); s.forget(); - var ret = res; + let ret = res; res.forget(); return ret; } fn read_all(path: char*) -> Result<String> { - var res = File::open(path, "rb"); + let res = File::open(path, "rb"); if (res.is_err()) { return Result<String>::Err(res.err); } - var f: File = res.unwrap(); - var s_res = f.read_to_string(); + let f: File = res.unwrap(); + let s_res = f.read_to_string(); f.close(); - var ret = s_res; + let ret = s_res; s_res.forget(); return ret; } @@ -192,8 +192,8 @@ impl File { return Result<bool>::Err("File not open"); } - var len = strlen(content); - var written = _z_fs_fwrite(content, 1, len, self.handle); + let len = strlen(content); + let written = _z_fs_fwrite(content, 1, len, self.handle); if (written != len) { return Result<bool>::Err("Write incomplete"); } @@ -205,9 +205,9 @@ impl File { } fn metadata(path: char*) -> Result<Metadata> { - var size: uint64_t; - var is_d: int; - var is_f: int; + let size: uint64_t; + let is_d: int; + let is_f: int; if (_z_fs_get_metadata(path, &size, &is_d, &is_f) != 0) { return Result<Metadata>::Err("Failed to get metadata"); @@ -242,28 +242,28 @@ impl File { } fn read_dir(path: char*) -> Result< Vec<DirEntry> > { - var dir = _z_fs_opendir(path); + let dir = _z_fs_opendir(path); if (dir == NULL) { return Result< Vec<DirEntry> >::Err("Failed to open directory"); } - var entries = Vec<DirEntry>::new(); - var name_buf: char* = _z_fs_malloc(256); + let entries = Vec<DirEntry>::new(); + let name_buf: char* = _z_fs_malloc(256); if (name_buf == NULL) { _z_fs_closedir(dir); return Result< Vec<DirEntry> >::Err("Out of memory"); } - var is_d: int = 0; + let is_d: int = 0; while (_z_fs_read_entry(dir, name_buf, 256, &is_d)) { if (strcmp(name_buf, ".") == 0 || strcmp(name_buf, "..") == 0) { continue; } - var s = String::new(name_buf); - var ent = DirEntry { + let s = String::new(name_buf); + let ent = DirEntry { name: s, is_dir: is_d != 0 }; @@ -280,9 +280,9 @@ impl File { _z_fs_free(name_buf); _z_fs_closedir(dir); - var res = Result< Vec<DirEntry> >::Ok(entries); + let res = Result< Vec<DirEntry> >::Ok(entries); entries.forget(); - var ret = res; + let ret = res; res.forget(); return ret; } @@ -20,8 +20,8 @@ extern fn _z_vprintf(fmt: char*, ap: va_list) -> int; extern fn _z_vsnprintf(str: char*, size: usize, fmt: char*, ap: va_list) -> int; fn format(fmt: char*, ...) -> char* { - static var buffer: char[1024]; - var ap: va_list; + static let buffer: char[1024]; + let ap: va_list; va_start(ap, fmt); _z_vsnprintf(buffer, 1024, fmt, ap); va_end(ap); @@ -29,18 +29,18 @@ fn format(fmt: char*, ...) -> char* { } fn format_into(buffer: char*, size: usize, fmt: char*, ...) -> int { - var ap: va_list; + let ap: va_list; va_start(ap, fmt); - var ret = _z_vsnprintf(buffer, size, fmt, ap); + let ret = _z_vsnprintf(buffer, size, fmt, ap); va_end(ap); return ret; } fn format_new(fmt: char*, ...) -> char* { - var buffer: char* = malloc(1024); + let buffer: char* = malloc(1024); if buffer == NULL return NULL; - var ap: va_list; + let ap: va_list; va_start(ap, fmt); _z_vsnprintf(buffer, 1024, fmt, ap); va_end(ap); @@ -48,31 +48,31 @@ fn format_new(fmt: char*, ...) -> char* { } fn print(fmt: char*, ...) -> int { - var ap: va_list; + let ap: va_list; va_start(ap, fmt); - var ret = _z_vprintf(fmt, ap); + let ret = _z_vprintf(fmt, ap); va_end(ap); return ret; } fn println(fmt: char*, ...) -> int { - var ap: va_list; + let ap: va_list; va_start(ap, fmt); - var ret = _z_vprintf(fmt, ap); + let ret = _z_vprintf(fmt, ap); va_end(ap); puts(""); return ret + 1; } fn readln() -> char* { - var cap: usize = 64; - var len: usize = 0; - var line: char* = malloc(cap); + let cap: usize = 64; + let len: usize = 0; + let line: char* = malloc(cap); if (line == NULL) return NULL; - var c: int; - var std_in = _z_get_stdin(); - var eof_val = _z_get_eof(); + let c: int; + let std_in = _z_get_stdin(); + let eof_val = _z_get_eof(); while (true) { c = _z_fgetc(std_in); @@ -81,7 +81,7 @@ fn readln() -> char* { if (len + 1 >= cap) { cap = cap * 2; - var n = realloc(line, cap); + let n = realloc(line, cap); if (n == NULL) { free(line); return NULL; diff --git a/std/json.zc b/std/json.zc index 6c4a0da..e6a15cd 100644 --- a/std/json.zc +++ b/std/json.zc @@ -192,13 +192,13 @@ impl JsonValue { } fn array() -> JsonValue { - var v: Vec<JsonValue*>* = malloc(sizeof(Vec_JsonValuePtr)); + let v: Vec<JsonValue*>* = malloc(sizeof(Vec_JsonValuePtr)); *v = Vec_JsonValuePtr::new(); return JsonValue { kind: JsonType::JSON_ARRAY(), string_val: 0, number_val: 0, bool_val: false, array_val: v, object_val: 0 }; } fn object() -> JsonValue { - var m: Map<JsonValue*>* = malloc(sizeof(Map_JsonValuePtr)); + let m: Map<JsonValue*>* = malloc(sizeof(Map_JsonValuePtr)); *m = Map_JsonValuePtr::new(); return JsonValue { kind: JsonType::JSON_OBJECT(), string_val: 0, number_val: 0, bool_val: false, array_val: 0, object_val: m }; } @@ -208,57 +208,57 @@ impl JsonValue { // ============================================ fn null_ptr() -> JsonValue* { - var p: JsonValue* = malloc(sizeof(JsonValue)); + let p: JsonValue* = malloc(sizeof(JsonValue)); *p = JsonValue::null(); return p; } fn bool_ptr(b: bool) -> JsonValue* { - var p: JsonValue* = malloc(sizeof(JsonValue)); + let p: JsonValue* = malloc(sizeof(JsonValue)); *p = JsonValue::bool(b); return p; } fn number_ptr(n: double) -> JsonValue* { - var p: JsonValue* = malloc(sizeof(JsonValue)); + let p: JsonValue* = malloc(sizeof(JsonValue)); *p = JsonValue::number(n); return p; } fn string_ptr(s: char*) -> JsonValue* { - var p: JsonValue* = malloc(sizeof(JsonValue)); + let p: JsonValue* = malloc(sizeof(JsonValue)); *p = JsonValue::string(s); return p; } fn array_ptr() -> JsonValue* { - var p: JsonValue* = malloc(sizeof(JsonValue)); + let p: JsonValue* = malloc(sizeof(JsonValue)); *p = JsonValue::array(); return p; } fn object_ptr() -> JsonValue* { - var p: JsonValue* = malloc(sizeof(JsonValue)); + let p: JsonValue* = malloc(sizeof(JsonValue)); *p = JsonValue::object(); return p; } fn push(self, val: JsonValue) { if (self.kind.tag != JsonType::JSON_ARRAY().tag) return; - var p: JsonValue* = malloc(sizeof(JsonValue)); + let p: JsonValue* = malloc(sizeof(JsonValue)); *p = val; self.array_val.push(p); } fn set(self, key: char*, val: JsonValue) { if (self.kind.tag != JsonType::JSON_OBJECT().tag) return; - var p: JsonValue* = malloc(sizeof(JsonValue)); + let p: JsonValue* = malloc(sizeof(JsonValue)); *p = val; self.object_val.put(key, p); } fn parse(json: char*) -> Result<JsonValue*> { - var result: JsonValue* = _json_do_parse(json); + let result: JsonValue* = _json_do_parse(json); if (result != NULL) { return Result<JsonValue*>::Ok(result); } @@ -340,47 +340,47 @@ impl JsonValue { } fn get_string(self, key: char*) -> Option<char*> { - var opt = self.get(key); + let opt = self.get(key); if opt.is_none() { return Option<char*>::None(); } - var val = opt.unwrap(); + let val = opt.unwrap(); return (*val).as_string(); } fn get_int(self, key: char*) -> Option<int> { - var opt = self.get(key); + let opt = self.get(key); if opt.is_none() { return Option<int>::None(); } - var val = opt.unwrap(); + let val = opt.unwrap(); return (*val).as_int(); } fn get_float(self, key: char*) -> Option<double> { - var opt = self.get(key); + let opt = self.get(key); if opt.is_none() { return Option<double>::None(); } - var val = opt.unwrap(); + let val = opt.unwrap(); return (*val).as_float(); } fn get_bool(self, key: char*) -> Option<bool> { - var opt = self.get(key); + let opt = self.get(key); if opt.is_none() { return Option<bool>::None(); } - var val = opt.unwrap(); + let val = opt.unwrap(); return (*val).as_bool(); } fn get_object(self, key: char*) -> Option<JsonValue*> { - var opt = self.get(key); + let opt = self.get(key); if opt.is_none() { return Option<JsonValue*>::None(); } - var val = opt.unwrap(); + let val = opt.unwrap(); if (*val).kind.tag == JsonType::JSON_OBJECT().tag { return Option<JsonValue*>::Some(val); } @@ -388,11 +388,11 @@ impl JsonValue { } fn get_array(self, key: char*) -> Option<JsonValue*> { - var opt = self.get(key); + let opt = self.get(key); if opt.is_none() { return Option<JsonValue*>::None(); } - var val = opt.unwrap(); + let val = opt.unwrap(); if (*val).kind.tag == JsonType::JSON_ARRAY().tag { return Option<JsonValue*>::Some(val); } @@ -426,9 +426,9 @@ impl JsonValue { fn free(self) { if (self.kind.tag == JsonType::JSON_STRING().tag) free(self.string_val); if (self.kind.tag == JsonType::JSON_ARRAY().tag) { - var v: Vec<JsonValue*>* = self.array_val; - for (var i: usize = 0; i < v.length(); i = i + 1) { - var item: JsonValue* = v.get(i); + let v: Vec<JsonValue*>* = self.array_val; + for (let i: usize = 0; i < v.length(); i = i + 1) { + let item: JsonValue* = v.get(i); item.free(); free(item); } @@ -437,10 +437,10 @@ impl JsonValue { free(v); } if (self.kind.tag == JsonType::JSON_OBJECT().tag) { - var m: Map<JsonValue*>* = self.object_val; - for (var i: usize = 0; i < m.capacity(); i = i + 1) { + let m: Map<JsonValue*>* = self.object_val; + for (let i: usize = 0; i < m.capacity(); i = i + 1) { if (m.is_slot_occupied(i)) { - var child: JsonValue* = m.val_at(i); + let child: JsonValue* = m.val_at(i); child.free(); free(child); } @@ -59,11 +59,11 @@ impl MapIterResult<V> { impl MapIter<V> { fn next(self) -> MapIterResult<V> { while self.idx < self.cap { - var i = self.idx; + let i = self.idx; self.idx = self.idx + 1; if (self.occupied[i] && !self.deleted[i]) { - var entry = MapEntry<V> { + let entry = MapEntry<V> { key: self.keys[i], val: self.vals[i] }; @@ -74,7 +74,7 @@ impl MapIter<V> { } } // Empty entry for None - var empty = MapEntry<V> { key: 0, val: self.vals[0] }; // Should be 0-init if possible + let empty = MapEntry<V> { key: 0, val: self.vals[0] }; // Should be 0-init if possible return MapIterResult<V> { entry: empty, has_val: false }; } } @@ -85,11 +85,11 @@ impl Map<V> { } fn _resize(self, new_cap: usize) { - var old_keys = self.keys; - var old_vals = self.vals; - var old_occupied = self.occupied; - var old_deleted = self.deleted; - var old_cap = self.cap; + let old_keys = self.keys; + let old_vals = self.vals; + let old_occupied = self.occupied; + let old_deleted = self.deleted; + let old_cap = self.cap; self.cap = new_cap; self.keys = calloc(new_cap, sizeof(char*)); @@ -98,7 +98,7 @@ impl Map<V> { self.deleted = calloc(new_cap, sizeof(bool)); self.len = 0; - for (var i: usize = 0; i < old_cap; i = i + 1) { + for (let i: usize = 0; i < old_cap; i = i + 1) { if (old_occupied[i] && !old_deleted[i]) { self.put(old_keys[i], old_vals[i]); } @@ -113,13 +113,13 @@ impl Map<V> { fn put(self, key: char*, val: V) { if (self.len >= self.cap * 0.75) { - var new_cap = self.cap * 2; + let new_cap = self.cap * 2; if (new_cap < 8) new_cap = 8; self._resize(new_cap); } - var hash = _map_hash_str(key); - var idx = hash % self.cap; + let hash = _map_hash_str(key); + let idx = hash % self.cap; while (true) { if (!self.occupied[idx] || (self.occupied[idx] && !self.deleted[idx] && strcmp(self.keys[idx], key) == 0)) { @@ -144,9 +144,9 @@ impl Map<V> { return Option<V>::None(); } - var hash = _map_hash_str(key); - var idx = hash % self.cap; - var start_idx = idx; + let hash = _map_hash_str(key); + let idx = hash % self.cap; + let start_idx = idx; while (true) { if (!self.occupied[idx]) { @@ -165,15 +165,15 @@ impl Map<V> { } fn contains(self, key: char*) -> bool { - var opt: Option<V> = self.get(key); + let opt: Option<V> = self.get(key); return opt.is_some(); } fn remove(self, key: char*) { if (self.cap == 0) return; - var hash = _map_hash_str(key); - var idx = hash % self.cap; + let hash = _map_hash_str(key); + let idx = hash % self.cap; while (true) { if (!self.occupied[idx]) return; @@ -199,7 +199,7 @@ impl Map<V> { fn free(self) { if (self.keys) { - for (var i: usize = 0; i < self.cap; i = i + 1) { + for (let i: usize = 0; i < self.cap; i = i + 1) { if (self.occupied[i] && !self.deleted[i]) { free(self.keys[i]); } @@ -81,7 +81,7 @@ fn mem_copy<T>(dst: T*, src: T*, count: usize) { } fn swap<T>(a: T*, b: T*) { - var tmp = *a; + let tmp = *a; *a = *b; *b = tmp; } @@ -66,13 +66,13 @@ struct TcpStream { impl TcpStream { fn read(self, buf: char*, len: usize) -> Result<usize> { - var n = _z_net_read(self.fd, buf, len); + let n = _z_net_read(self.fd, buf, len); if (n < 0) return Result<usize>::Err("Read failed"); return Result<usize>::Ok((usize)n); } fn write(self, buf: char*, len: usize) -> Result<usize> { - var n = _z_net_write(self.fd, buf, len); + let n = _z_net_write(self.fd, buf, len); if (n < 0) return Result<usize>::Err("Write failed"); return Result<usize>::Ok((usize)n); } @@ -85,10 +85,10 @@ impl TcpStream { } fn connect(host: char*, port: int) -> Result<TcpStream> { - var fd = socket(Z_AF_INET, Z_SOCK_STREAM, 0); + let fd = socket(Z_AF_INET, Z_SOCK_STREAM, 0); if (fd < 0) return Result<TcpStream>::Err("Failed to create socket"); - var res = _z_net_connect(fd, host, port); + let res = _z_net_connect(fd, host, port); if (res == -1) { close(fd); return Result<TcpStream>::Err("Invalid address"); } if (res == -2) { close(fd); return Result<TcpStream>::Err("Connection failed"); } @@ -102,10 +102,10 @@ struct TcpListener { impl TcpListener { fn bind(host: char*, port: int) -> Result<TcpListener> { - var fd = socket(Z_AF_INET, Z_SOCK_STREAM, 0); + let fd = socket(Z_AF_INET, Z_SOCK_STREAM, 0); if (fd < 0) return Result<TcpListener>::Err("Failed to create socket"); - var res = _z_net_bind(fd, host, port); + let res = _z_net_bind(fd, host, port); if (res == -1) { close(fd); return Result<TcpListener>::Err("Invalid address"); } if (res == -2) { close(fd); return Result<TcpListener>::Err("Bind failed"); } if (res == -3) { close(fd); return Result<TcpListener>::Err("Listen failed"); } @@ -114,7 +114,7 @@ impl TcpListener { } fn accept(self) -> Result<TcpStream> { - var client_fd = _z_net_accept(self.fd); + let client_fd = _z_net_accept(self.fd); if (client_fd < 0) return Result<TcpStream>::Err("Accept failed"); return Result<TcpStream>::Ok(TcpStream { fd: client_fd }); } diff --git a/std/option.zc b/std/option.zc index 11b4428..4098c99 100644 --- a/std/option.zc +++ b/std/option.zc @@ -32,7 +32,7 @@ impl Option<T> { !"Panic: unwrap called on None"; exit(1); } - var v = self.val; + let v = self.val; memset(&self.val, 0, sizeof(T)); return v; } diff --git a/std/path.zc b/std/path.zc index 7055880..b5c39ad 100644 --- a/std/path.zc +++ b/std/path.zc @@ -26,18 +26,18 @@ impl Path { } fn join(self, other: char*) -> Path { - var base_len = self.str.length(); - var new_s = String::from(self.str.c_str()); + let base_len = self.str.length(); + let new_s = String::from(self.str.c_str()); if (base_len > 0) { - var last = self.str.vec.get(base_len - 1); + let last = self.str.vec.get(base_len - 1); if (last != '/' && last != '\\') { - var sep = String::new("/"); + let sep = String::new("/"); new_s.append(&sep); } } - var other_str = String::new(other); + let other_str = String::new(other); new_s.append(&other_str); return Path { str: new_s }; @@ -45,11 +45,11 @@ impl Path { fn extension(self) -> Option<String> { - var s = self.c_str(); - var len = self.str.length(); + let s = self.c_str(); + let len = self.str.length(); - for (var i: usize = len; i > 0; i = i - 1) { - var c = s[i-1]; + for (let i: usize = len; i > 0; i = i - 1) { + let c = s[i-1]; if (c == '.') { // Check if we hit a separator before element // e.g. /d.ir/file - found dot @@ -64,19 +64,19 @@ impl Path { } fn file_name(self) -> Option<String> { - var s = self.c_str(); - var len = self.str.length(); + let s = self.c_str(); + let len = self.str.length(); if (len == 0) return Option<String>::None(); // Remove trailing separators - var end = len; + let end = len; while (end > 0 && (s[end-1] == '/' || s[end-1] == '\\')) { end = end - 1; } if (end == 0) return Option<String>::None(); // Root - var start = end; + let start = end; while (start > 0 && s[start-1] != '/' && s[start-1] != '\\') { start = start - 1; } @@ -85,12 +85,12 @@ impl Path { } fn parent(self) -> Option<Path> { - var s = self.c_str(); - var len = self.str.length(); + let s = self.c_str(); + let len = self.str.length(); if (len == 0) return Option<Path>::None(); // Trim trailing separators - var end = len; + let end = len; while (end > 0 && (s[end-1] == '/' || s[end-1] == '\\')) { end = end - 1; } @@ -111,7 +111,7 @@ impl Path { return Option<Path>::Some(Path::new("/")); } - var parent_str = self.str.substring(0, end); + let parent_str = self.str.substring(0, end); return Option<Path>::Some(Path { str: parent_str }); } } diff --git a/std/queue.zc b/std/queue.zc index 0b00ee2..c2fcd32 100644 --- a/std/queue.zc +++ b/std/queue.zc @@ -26,15 +26,15 @@ impl Queue<T> { } fn _grow(self) { - var new_cap = (self.cap == 0) ? 8 : self.cap * 2; - var new_data = malloc(sizeof(T) * new_cap); + let new_cap = (self.cap == 0) ? 8 : self.cap * 2; + let new_data = malloc(sizeof(T) * new_cap); if (self.count > 0) { if (self.tail > self.head) { memcpy(new_data, self.data + self.head, sizeof(T) * self.count); } else { - var first_part = self.cap - self.head; - var second_part = self.tail; + let first_part = self.cap - self.head; + let second_part = self.tail; memcpy(new_data, self.data + self.head, sizeof(T) * first_part); memcpy(new_data + first_part, self.data, sizeof(T) * second_part); } @@ -48,7 +48,7 @@ impl Queue<T> { } fn clone(self) -> Queue<T> { - var new_queue = Queue<T>::new(); + let new_queue = Queue<T>::new(); new_queue.data = malloc(sizeof(T) * self.cap); new_queue.cap = self.cap; new_queue.head = 0; @@ -60,8 +60,8 @@ impl Queue<T> { memcpy(new_queue.data, self.data + self.head, sizeof(T) * self.count); } else { - var first_part = self.cap - self.head; - var second_part = self.tail; + let first_part = self.cap - self.head; + let second_part = self.tail; memcpy(new_queue.data, self.data + self.head, sizeof(T) * first_part); memcpy(new_queue.data + first_part, self.data, sizeof(T) * second_part); } @@ -85,7 +85,7 @@ impl Queue<T> { return Option<T>::None(); } - var value = self.data[self.head]; + let value = self.data[self.head]; self.head = (self.head + 1) % self.cap; self.count = self.count - 1; diff --git a/std/result.zc b/std/result.zc index 1d10b1a..12c974c 100644 --- a/std/result.zc +++ b/std/result.zc @@ -32,7 +32,7 @@ impl Result<T> { !"Panic: unwrap called on Err: {self.err}"; exit(1); } - var v = self.val; + let v = self.val; memset(&self.val, 0, sizeof(T)); return v; } @@ -29,10 +29,10 @@ impl Set<T> { } fn _resize(self, new_cap: usize) { - var old_data = self.data; - var old_occupied = self.occupied; - var old_deleted = self.deleted; - var old_cap = self.cap; + let old_data = self.data; + let old_occupied = self.occupied; + let old_deleted = self.deleted; + let old_cap = self.cap; self.cap = new_cap; self.data = calloc(new_cap, sizeof(T)); @@ -40,7 +40,7 @@ impl Set<T> { self.deleted = calloc(new_cap, sizeof(bool)); self.len = 0; - for (var i: usize = 0; i < old_cap; i = i + 1) { + for (let i: usize = 0; i < old_cap; i = i + 1) { if (old_occupied[i] && !old_deleted[i]) { self.add(old_data[i]); } @@ -57,13 +57,13 @@ impl Set<T> { } if (self.len >= self.cap * 0.75) { - var new_cap = self.cap * 2; + let new_cap = self.cap * 2; if (new_cap < 8) new_cap = 8; self._resize(new_cap); } - var hash = _set_hash(&val, sizeof(T)); - var idx = hash % self.cap; + let hash = _set_hash(&val, sizeof(T)); + let idx = hash % self.cap; while (self.occupied[idx] && !self.deleted[idx]) { idx = (idx + 1) % self.cap; @@ -81,9 +81,9 @@ impl Set<T> { return false; } - var hash = _set_hash(&val, sizeof(T)); - var idx = hash % self.cap; - var start_idx = idx; + let hash = _set_hash(&val, sizeof(T)); + let idx = hash % self.cap; + let start_idx = idx; while (self.occupied[idx]) { if (!self.deleted[idx] && self.data[idx] == val) { @@ -101,9 +101,9 @@ impl Set<T> { fn remove(self, val: T) -> bool { if (self.cap == 0) return false; - var hash = _set_hash(&val, sizeof(T)); - var idx = hash % self.cap; - var start_idx = idx; + let hash = _set_hash(&val, sizeof(T)); + let idx = hash % self.cap; + let start_idx = idx; while (self.occupied[idx]) { if (!self.deleted[idx] && self.data[idx] == val) { @@ -155,7 +155,7 @@ impl Set<T> { return Option<T>::Some(self.data[idx]); } fn clear(self) { - for (var i: usize = 0; i < self.cap; i = i + 1) { + for (let i: usize = 0; i < self.cap; i = i + 1) { self.occupied[i] = false; self.deleted[i] = false; } diff --git a/std/stack.zc b/std/stack.zc index db02f2d..9b4d375 100644 --- a/std/stack.zc +++ b/std/stack.zc @@ -21,7 +21,7 @@ impl Stack<T> { } fn clone(self) -> Stack<T> { - var new_stack = Stack<T>::new(); + let new_stack = Stack<T>::new(); new_stack.len = self.len; new_stack.cap = self.cap; new_stack.data = malloc(sizeof(T) * new_stack.cap); @@ -44,7 +44,7 @@ impl Stack<T> { fn pop(self) -> Option<T> { if (self.len > 0) { - var value = self.data[self.len - 1]; + let value = self.data[self.len - 1]; self.len = self.len - 1; return Option<T>::Some(value); } diff --git a/std/string.zc b/std/string.zc index a7dd6ce..fe5b0ad 100644 --- a/std/string.zc +++ b/std/string.zc @@ -8,18 +8,18 @@ struct String { impl String { fn new(s: char*) -> String { - var len = strlen(s); - var v = Vec<char>::new(); + let len = strlen(s); + let v = Vec<char>::new(); // Manual copy for now - for (var i = 0; i < len; i = i + 1) { + for (let i = 0; i < len; i = i + 1) { v.push(s[i]); } v.push(0); // Extract fields to transfer ownership - var d = v.data; - var l = v.len; - var c = v.cap; + let d = v.data; + let l = v.len; + let c = v.cap; // Forget the local vector so it doesn't free the memory v.forget(); @@ -49,19 +49,19 @@ impl String { self.vec.len = self.vec.len - 1; } - var other_len = (*other).vec.len; - for (var i = 0; i < other_len; i = i + 1) { + let other_len = (*other).vec.len; + for (let i = 0; i < other_len; i = i + 1) { self.vec.push((*other).vec.get(i)); } } fn add(self, other: String*) -> String { - var new_s = String::from(self.c_str()); + let new_s = String::from(self.c_str()); new_s.append(other); - var d = new_s.vec.data; - var l = new_s.vec.len; - var c = new_s.vec.cap; + let d = new_s.vec.data; + let l = new_s.vec.len; + let c = new_s.vec.cap; new_s.forget(); return String { vec: Vec<char> { data: d, len: l, cap: c } }; @@ -80,23 +80,23 @@ impl String { if (start + len > self.length()) { panic("substring out of bounds"); } - var v = Vec<char>::new(); - for (var i: usize = 0; i < len; i = i + 1) { + let v = Vec<char>::new(); + for (let i: usize = 0; i < len; i = i + 1) { v.push(self.vec.get(start + i)); } v.push(0); - var d = v.data; - var l = v.len; - var c = v.cap; + let d = v.data; + let l = v.len; + let c = v.cap; v.forget(); return String { vec: Vec<char> { data: d, len: l, cap: c } }; } fn find(self, target: char) -> Option<usize> { - var len = self.length(); - for (var i: usize = 0; i < len; i = i + 1) { + let len = self.length(); + for (let i: usize = 0; i < len; i = i + 1) { if (self.vec.get(i) == target) { return Option<usize>::Some(i); } @@ -122,16 +122,16 @@ impl String { } fn starts_with(self, prefix: char*) -> bool { - var plen = strlen(prefix); + let plen = strlen(prefix); if plen > self.length() { return false; } return strncmp(self.c_str(), prefix, plen) == 0; } fn ends_with(self, suffix: char*) -> bool { - var slen = strlen(suffix); - var len = self.length(); + let slen = strlen(suffix); + let len = self.length(); if slen > len { return false; } - var offset = (int)(len - slen); + let offset = (int)(len - slen); return strcmp(self.c_str() + offset, suffix) == 0; } @@ -140,7 +140,7 @@ impl String { } fn _utf8_seq_len(first_byte: char) -> usize { - var b = (int)first_byte; + let b = (int)first_byte; if ((b & 0x80) == 0) { return 1; } if ((b & 0xE0) == 0xC0) { return 2; } if ((b & 0xF0) == 0xE0) { return 3; } @@ -149,11 +149,11 @@ impl String { } fn utf8_len(self) -> usize { - var count: usize = 0; - var i: usize = 0; - var len = self.length(); + let count: usize = 0; + let i: usize = 0; + let len = self.length(); while i < len { - var c = self.vec.get(i); + let c = self.vec.get(i); i = i + String::_utf8_seq_len(c); count = count + 1; } @@ -161,12 +161,12 @@ impl String { } fn utf8_at(self, idx: usize) -> String { - var count: usize = 0; - var i: usize = 0; - var len = self.length(); + let count: usize = 0; + let i: usize = 0; + let len = self.length(); while i < len { - var c = self.vec.get(i); - var seq = String::_utf8_seq_len(c); + let c = self.vec.get(i); + let seq = String::_utf8_seq_len(c); if (count == idx) { return self.substring(i, seq); @@ -181,13 +181,13 @@ impl String { fn utf8_substr(self, start_idx: usize, num_chars: usize) -> String { if (num_chars == 0) { return String::new(""); } - var byte_start: usize = 0; - var byte_len: usize = 0; + let byte_start: usize = 0; + let byte_len: usize = 0; - var count: usize = 0; - var i: usize = 0; - var len = self.length(); - var found_start = false; + let count: usize = 0; + let i: usize = 0; + let len = self.length(); + let found_start = false; while i < len { // Check if we reached the start char @@ -198,7 +198,7 @@ impl String { count = 0; } else if (!found_start) { // Still seeking start - var c = self.vec.get(i); + let c = self.vec.get(i); i = i + String::_utf8_seq_len(c); count = count + 1; continue; @@ -206,8 +206,8 @@ impl String { // If we are here, we are collecting chars if (count < num_chars) { - var c = self.vec.get(i); - var seq = String::_utf8_seq_len(c); + let c = self.vec.get(i); + let seq = String::_utf8_seq_len(c); byte_len = byte_len + seq; i = i + seq; count = count + 1; @@ -221,12 +221,12 @@ impl String { return self.substring(byte_start, byte_len); } fn split(self, delim: char) -> Vec<String> { - var parts = Vec<String>::new(); - var len = self.length(); + let parts = Vec<String>::new(); + let len = self.length(); if (len == 0) { return parts; } - var start: usize = 0; - var i: usize = 0; + let start: usize = 0; + let i: usize = 0; while i < len { if (self.vec.get(i) == delim) { @@ -246,13 +246,13 @@ impl String { } fn trim(self) -> String { - var start: usize = 0; - var len = self.length(); - var end = len; + let start: usize = 0; + let len = self.length(); + let end = len; // Find start while (start < len) { - var c = self.vec.get(start); + let c = self.vec.get(start); if (c != ' ' && c != '\t' && c != '\n' && c != '\r') { break; } @@ -265,7 +265,7 @@ impl String { // Find end while (end > start) { - var c = self.vec.get(end - 1); + let c = self.vec.get(end - 1); if (c != ' ' && c != '\t' && c != '\n' && c != '\r') { break; } @@ -276,20 +276,20 @@ impl String { } fn replace(self, target: char*, replacement: char*) -> String { - var t_len = strlen(target); + let t_len = strlen(target); if (t_len == 0) return self.substring(0, self.length()); // clone - var s_len = self.length(); - var result = String::new(""); + let s_len = self.length(); + let result = String::new(""); - var i: usize = 0; + let i: usize = 0; while (i < s_len) { // Check if match if (i + t_len <= s_len) { - var is_match = true; + let is_match = true; // Manual strncmp against vec data - for (var k: usize = 0; k < t_len; k = k + 1) { + for (let k: usize = 0; k < t_len; k = k + 1) { if (self.vec.get(i + k) != target[k]) { is_match = false; break; @@ -297,7 +297,7 @@ impl String { } if (is_match) { - var r_str = String::new(replacement); + let r_str = String::new(replacement); result.append(&r_str); i = i + t_len; continue; @@ -305,10 +305,10 @@ impl String { } // Append single char - var v = Vec<char>::new(); + let v = Vec<char>::new(); v.push(self.vec.get(i)); v.push(0); - var ch_s = String::new(v.data); + let ch_s = String::new(v.data); result.append(&ch_s); v.free(); i = i + 1; diff --git a/std/thread.zc b/std/thread.zc index 0ebcd03..e90943b 100644 --- a/std/thread.zc +++ b/std/thread.zc @@ -73,14 +73,14 @@ struct Thread { impl Thread { fn spawn(func: fn()) -> Result<Thread> { - var t: usize = 0; + let t: usize = 0; - var ctx_copy = malloc(16); // z_closure_T is 16 bytes + let ctx_copy = malloc(16); // z_closure_T is 16 bytes if (ctx_copy == NULL) return Result<Thread>::Err("OOM"); memcpy(ctx_copy, &func, 16); - var ret = _z_thread_spawn(ctx_copy, &t); + let ret = _z_thread_spawn(ctx_copy, &t); if (ret != 0) { free(ctx_copy); @@ -91,7 +91,7 @@ impl Thread { } fn join(self) -> Result<bool> { - var ret = _z_thread_join(self.handle); + let ret = _z_thread_join(self.handle); if (ret != 0) return Result<bool>::Err("Join failed"); return Result<bool>::Ok(true); } @@ -103,7 +103,7 @@ struct Mutex { impl Mutex { fn new() -> Mutex { - var ptr = malloc(64); + let ptr = malloc(64); _z_mutex_init(ptr); return Mutex { handle: ptr }; } @@ -41,7 +41,7 @@ struct VecIterRef<T> { impl VecIter<T> { fn next(self) -> Option<T> { if (self.idx < self.count) { - var item = self.data[self.idx]; + let item = self.data[self.idx]; self.idx = self.idx + 1; return Option<T>::Some(item); } @@ -56,7 +56,7 @@ impl VecIter<T> { impl VecIterRef<T> { fn next(self) -> VecIterResult<T> { if (self.idx < self.count) { - var item = &self.data[self.idx]; + let item = &self.data[self.idx]; self.idx = self.idx + 1; return VecIterResult<T> { ptr: item }; } @@ -165,7 +165,7 @@ impl Vec<T> { !"Panic: Remove index out of bounds"; exit(1); } - var item = self.data[idx]; + let item = self.data[idx]; // Shift elements left if (idx < self.len - 1) { memmove(self.data + idx, self.data + idx + 1, (self.len - idx - 1) * sizeof(T)); @@ -175,7 +175,7 @@ impl Vec<T> { } fn append(self, other: Vec<T>) { - var new_len = self.len + other.len; + let new_len = self.len + other.len; self.grow_to_fit(new_len); memcpy(self.data + self.len, other.data, other.len * sizeof(T)); @@ -203,7 +203,7 @@ impl Vec<T> { } fn contains(self, item: T) -> bool { - var i: usize = 0; + let i: usize = 0; while i < self.len { if memcmp(&self.data[i], &item, sizeof(T)) == 0 { return true; } i++; @@ -243,10 +243,10 @@ impl Vec<T> { } fn reverse(self) { - var i: usize = 0; - var j = self.len - 1; + let i: usize = 0; + let j = self.len - 1; while i < j { - var tmp = self.data[i]; + let tmp = self.data[i]; self.data[i] = self.data[j]; self.data[j] = tmp; i++; @@ -256,7 +256,7 @@ impl Vec<T> { fn eq(self, other: Vec<T>) -> bool { if self.len != other.len { return false; } - var i: usize = 0; + let i: usize = 0; while i < self.len { if memcmp(&self.data[i], &other.data[i], sizeof(T)) != 0 { return false; } i = i + 1; @@ -275,8 +275,8 @@ impl Vec<T> { if (self.len == 0) { return Vec<T> { data: 0, len: 0, cap: 0 }; } - var new_data = (T*)malloc(self.len * sizeof(T)); - var i: usize = 0; + let new_data = (T*)malloc(self.len * sizeof(T)); + let i: usize = 0; while i < self.len { new_data[i] = self.data[i]; i = i + 1; |