rename usize to uint

Author: StunxFS

lib/c/src/ctypes/mod.ri

@@ -25,10 +25,10 @@ public alias wchar_t := uint32;
 public alias intmax_t := int64;
 public alias uintmax_t := uint64;
 
-public alias size_t := usize;
+public alias size_t := uint;
 public alias ptrdiff_t := int;
 public alias intptr_t := int;
-public alias uintptr_t := usize;
+public alias uintptr_t := uint;
 public alias ssize_t := int;
 
 public alias pid_t := int32;
@@ -37,4 +37,4 @@ public alias ino_t := uint64;
 public alias dev_t := uint64;
 public alias uid_t := uint32;
 public alias gid_t := uint32;
-public alias mode_t := usize;
+public alias mode_t := uint;

lib/c/src/libc/dirent.ri

@@ -3,8 +3,8 @@
 // be found in the LICENSE file.
 
 public struct dirent {
-    public d_ino: usize;
-    public d_off: usize;
+    public d_ino: uint;
+    public d_off: uint;
     public d_reclen: uint16;
     public d_type: uint8;
     public d_name: [256]uint8;

lib/c/src/libc/stat.ri

@@ -9,7 +9,7 @@ import { * } from c/ctypes;
 public struct Stat {
     public dev: dev_t;
     public ino: ino_t;
-    public nlink: usize;
+    public nlink: uint;
 
     public mode: uint32;
     public uid: uid_t;
@@ -31,5 +31,5 @@ extern (C) {
     public func stat(__file: [&]uint8, __buf: &mut Stat) -> int32;
     public func lstat(file: [&]uint8, buf: &mut Stat) -> int32;
 
-    public func mkdir(path: [&]uint8, mode: usize) -> int32;
+    public func mkdir(path: [&]uint8, mode: uint) -> int32;
 }

lib/c/src/libc/stdio.ri

@@ -4,8 +4,8 @@
 
 import { * } from c/ctypes;
 
-public const MAX_PATH_LEN: usize := 4096;
-public const MAX_NAME_LEN: usize := 255;
+public const MAX_PATH_LEN: uint := 4096;
+public const MAX_NAME_LEN: uint := 255;
 
 public const STDIN_FILENO := 0;
 public const STDOUT_FILENO := 1;
@@ -97,13 +97,13 @@ extern (C) {
     public func ferror(stream: &FILE) -> int32;
     public func fseek(stream: &mut FILE, offset: uint64, whence: int32) -> int32;
     public func ftell(stream: &mut FILE) -> int64;
-    public func fread(ptr: rawptr, size: usize, nitems: usize, stream: &mut FILE) -> usize;
+    public func fread(ptr: rawptr, size: uint, nitems: uint, stream: &mut FILE) -> uint;
     public func fputc(c: int32, stream: &mut FILE) -> int32;
     public func fputs(s: [&]uint8, stream: &mut FILE) -> int32;
     public func fprintf(stream: &mut FILE, fmt: [&]uint8, ...) -> int32;
-    public func fwrite(ptr: rawptr, size: usize, nobj: usize, stream: &mut FILE) -> usize;
+    public func fwrite(ptr: rawptr, size: uint, nobj: uint, stream: &mut FILE) -> uint;
     public func fflush(stream: &mut FILE) -> int32;
-    public func fgets(s: [&]mut uint8, n: usize, stream: &mut FILE) -> int32;
+    public func fgets(s: [&]mut uint8, n: uint, stream: &mut FILE) -> int32;
     public func fclose(stream: &mut FILE) -> int32;
     public func fileno(stream: &FILE) -> int32;
     public func rewind(stream: &mut FILE);
@@ -115,5 +115,5 @@ extern (C) {
 	public func popen(cmd: [&]uint8, modes: [&]uint8) -> ?&mut FILE;
 	public func pclose(stream: &mut FILE) -> int32;
 
-	public func getline(lineptr: &?[&]uint8, n: &usize, stream: &mut FILE) -> int;
+	public func getline(lineptr: &?[&]uint8, n: &uint, stream: &mut FILE) -> int;
 }

lib/c/src/libc/stdlib.ri

@@ -26,9 +26,9 @@ extern (C) {
     public func strtoul(nptr: [&]uint8, endptr: ?[&]uint8, base: int32) -> uint64;
     public func strtoull(nptr: [&]uint8, endptr: ?[&]uint8, base: int32) -> uint64;
 
-    public func malloc(size: usize) -> ?rawptr;
-    public func calloc(nobj: usize, size: usize) -> ?rawptr;
-    public func realloc(p: ?rawptr, size: usize) -> ?rawptr;
+    public func malloc(size: uint) -> ?rawptr;
+    public func calloc(nobj: uint, size: uint) -> ?rawptr;
+    public func realloc(p: ?rawptr, size: uint) -> ?rawptr;
     public func free(p: rawptr);
 
     public func getenv(name: [&]uint8) -> ?[&]mut uint8;

lib/c/src/libc/string.ri

@@ -3,13 +3,13 @@
 // be found in the LICENSE file.
 
 extern (C) {
-    public func memchr(cx: rawptr, c: int32, n: usize) -> ?rawptr;
-    public func memcmp(cx: rawptr, ct: rawptr, n: usize) -> int32;
-    public func memcpy(dest: rawptr, src: rawptr, n: usize) -> ?rawptr;
-    public func memmove(dest: rawptr, src: rawptr, n: usize) -> ?rawptr;
-    public func memset(dest: rawptr, c: int32, n: usize) -> ?rawptr;
+    public func memchr(cx: rawptr, c: int32, n: uint) -> ?rawptr;
+    public func memcmp(cx: rawptr, ct: rawptr, n: uint) -> int32;
+    public func memcpy(dest: rawptr, src: rawptr, n: uint) -> ?rawptr;
+    public func memmove(dest: rawptr, src: rawptr, n: uint) -> ?rawptr;
+    public func memset(dest: rawptr, c: int32, n: uint) -> ?rawptr;
 
     public func strerror(code: int32) -> ?[&]mut uint8;
-    public func strlen(cs: ?[&]uint8) -> usize;
+    public func strlen(cs: ?[&]uint8) -> uint;
     public func strstr(needle: ?[&]uint8, haystack: ?[&]uint8) -> ?[&]uint8;
 }

lib/c/src/libc/unistd.ri

@@ -12,14 +12,14 @@ extern (C) {
 
     public func isatty(fd: int32) -> int32;
 
-    public func write(fd: int32, buf: rawptr, count: usize) -> int;
-    public func read(fildes: int32, buf: rawptr, nbyte: usize) -> int;
+    public func write(fd: int32, buf: rawptr, count: uint) -> int;
+    public func read(fildes: int32, buf: rawptr, nbyte: uint) -> int;
 
     public func rmdir(path: [&]uint8) -> int32;
     public func chdir(path: [&]uint8) -> int32;
-    public func getcwd(buf: [&]uint8, size: usize) -> ?[&]uint8;
+    public func getcwd(buf: [&]uint8, size: uint) -> ?[&]uint8;
 
-    public func readlink(path: [&]uint8, buf: [&]uint8, size: usize) -> int;
+    public func readlink(path: [&]uint8, buf: [&]uint8, size: uint) -> int;
 
 #if _LINUX_
     public func get_nprocs() -> int32;

lib/c/src/wyhash.ri

@@ -13,8 +13,8 @@ extern (C) {
     func _wymix(a: uint64, b: uint64) -> uint64;
     func _wyr8(p: &uint8) -> uint64;
     func _wyr4(p: &uint8) -> uint64;
-    func _wyr3(p: &uint8, k: usize) -> uint64;
-    public func wyhash(key: rawptr, len: usize, seed: uint64, secret: &uint64) -> uint64;
+    func _wyr3(p: &uint8, k: uint) -> uint64;
+    public func wyhash(key: rawptr, len: uint, seed: uint64, secret: &uint64) -> uint64;
     public func wyhash64(a: uint64, b: uint64) -> uint64;
     func wyrand(seed: &uint64) -> uint64;
     func wy2u01(r: uint64) -> float64;

lib/core/src/StaticBuffer.c.ri

@@ -6,7 +6,7 @@ import c/libc;
 
 struct StaticBuffer {
     buf: [25]mut uint8;
-    mut len: usize;
+    mut len: uint;
 
     public func push(mut self, byte: uint8) {
         if self.len > self.buf.len {

lib/core/src/StringBuilder.c.ri

@@ -10,7 +10,7 @@ public struct StringBuilder < Stringable {
 
     /// Returns a string builder with capacity `cap`.
     #[inline]
-    public func new(cap: usize := 0) -> Self {
+    public func new(cap: uint := 0) -> Self {
         return Self(unsafe { Vector.new(@size_of(uint8), cap) });
     }
 
@@ -40,7 +40,7 @@ public struct StringBuilder < Stringable {
     }
 
     #[unsafe]
-    public func write_raw_with_len(mut self, s: [&]uint8, len: usize) {
+    public func write_raw_with_len(mut self, s: [&]uint8, len: uint) {
         self.inner.reserve(self.inner.len + len);
         mem_copy(
             unsafe { @ptr_add(self.inner.ptr, self.inner.elem_size * self.inner.len) },
@@ -90,7 +90,7 @@ public struct StringBuilder < Stringable {
 
     /// Returns the number of runes contained in `self`.
     #[inline]
-    public func runes_count(self) -> usize {
+    public func runes_count(self) -> uint {
         return cstr_runes_count(unsafe { @as([&]uint8, self.inner.ptr) }, self.inner.len);
     }
 
@@ -100,12 +100,12 @@ public struct StringBuilder < Stringable {
     }
 
     #[inline]
-    public func len(self) -> usize {
+    public func len(self) -> uint {
         return self.inner.len;
     }
 
     #[inline]
-    public func cap(self) -> usize {
+    public func cap(self) -> uint {
         return self.inner.cap;
     }
 

lib/core/src/StringFormatter.ri

@@ -4,12 +4,12 @@
 
 public struct StringFormatter {
     buf: string;
-    mut i: usize;
+    mut i: uint;
     mut res: StringBuilder;
 
     func fmt(mut self, args: ...Stringable) -> string {
         self.res = StringBuilder.new(self.buf.len);
-        mut args_idx: usize := 0;
+        mut args_idx: uint := 0;
         while self.i < self.buf.len : self.i += 1 {
             b := unsafe { self.buf.ptr[self.i] };
             b2 := if self.i + 1 < self.buf.len unsafe { self.buf.ptr[self.i + 1] } else { 0 };
@@ -35,15 +35,15 @@ public struct StringFormatter {
                         if has_fwidth and fwidth > 0 {
                             value_len := @as(int, value.len);
                             if value_len <= fwidth {
-                                self.res.write_string(" ".repeat(@as(usize, fwidth - value_len)));
+                                self.res.write_string(" ".repeat(@as(uint, fwidth - value_len)));
                             }
                         }
                         self.res.write_string(value);
                         if has_fwidth and fwidth < 0 {
                             fwidth = -fwidth;
                             value_len := @as(int, value.len);
                             if value_len <= fwidth {
-                                self.res.write_string(" ".repeat(@as(usize, fwidth - value_len)));
+                                self.res.write_string(" ".repeat(@as(uint, fwidth - value_len)));
                             }
                         }
                         if !has_fwidth {
@@ -77,15 +77,15 @@ public struct StringFormatter {
                         if has_fwidth and fwidth > 0 {
                             value_len := @as(int, value.len);
                             if value_len <= fwidth {
-                                self.res.write_string(" ".repeat(@as(usize, fwidth - value_len)));
+                                self.res.write_string(" ".repeat(@as(uint, fwidth - value_len)));
                             }
                         }
                         self.res.write_string(value);
                         if has_fwidth and fwidth < 0 {
                             fwidth = -fwidth;
                             value_len := @as(int, value.len);
                             if value_len <= fwidth {
-                                self.res.write_string(" ".repeat(@as(usize, fwidth - value_len)));
+                                self.res.write_string(" ".repeat(@as(uint, fwidth - value_len)));
                             }
                         }
                     } else {

lib/core/src/TokenIterator.ri

@@ -5,7 +5,7 @@
 public struct TokenIterator {
     buffer: string;
     delimiter_bytes: []uint8;
-    mut index: usize;
+    mut index: uint;
 
     /// Returns a slice of the current token, or none if tokenization is
     /// complete, and advances to the next token.
@@ -35,7 +35,7 @@ public struct TokenIterator {
     /// Returns a slice of the remaining bytes. Does not affect iterator state.
     public func rest(&self) -> string {
         // move to beginning of token
-        mut index: usize := self.index;
+        mut index: uint := self.index;
         while index < self.buffer.len and self.is_split_byte(self.buffer[index])
             : index += 1 {}
         return self.buffer[index..];

lib/core/src/Vector.c.ri

@@ -5,46 +5,46 @@
 #[boxed]
 struct Vector {
     mut ptr: rawptr;
-    elem_size: usize;
-    mut len: usize;
-    mut cap: usize;
+    elem_size: uint;
+    mut len: uint;
+    mut cap: uint;
     is_ref: bool;
 
     #[unsafe; inline]
-    func new(elem_size: usize, cap: usize) -> Self {
+    func new(elem_size: uint, cap: uint) -> Self {
         return Self(internal_zeroed(cap * elem_size), elem_size, 0, cap);
     }
 
     #[unsafe; inline]
-    func new_with_len(elem_size: usize, len: usize, cap: usize) -> Self {
+    func new_with_len(elem_size: uint, len: uint, cap: uint) -> Self {
         return Self(internal_zeroed(cap * elem_size), elem_size, len, cap);
     }
 
     #[unsafe]
-    func from_array(arr: rawptr, elem_size: usize, len: usize) -> Self {
+    func from_array(arr: rawptr, elem_size: uint, len: uint) -> Self {
         vec := Self(internal_zeroed(len * elem_size), elem_size, len, len);
         mem_copy(vec.ptr, arr, len * elem_size);
         return vec;
     }
 
     #[unsafe; inline]
-    func from_array_no_alloc(arr: rawptr, elem_size: usize, len: usize) -> Self {
+    func from_array_no_alloc(arr: rawptr, elem_size: uint, len: uint) -> Self {
         return Self(arr, elem_size, len, len, is_ref: true);
     }
 
     #[unsafe; inline]
-    func raw_get(self, idx: usize) -> rawptr {
+    func raw_get(self, idx: uint) -> rawptr {
         return unsafe { @ptr_add(@as([&]mut uint8, self.ptr), idx * self.elem_size) };
     }
 
-    func get(self, idx: usize) -> rawptr {
+    func get(self, idx: uint) -> rawptr {
         if idx >= self.len {
             process_panic("vector index out of range (index: {}, len: {})", idx, self.len);
         }
         return unsafe { @ptr_add(@as([&]mut uint8, self.ptr), idx * self.elem_size) };
     }
 
-    func set(self, idx: usize, val: rawptr) {
+    func set(self, idx: uint, val: rawptr) {
         if idx >= self.len {
             process_panic("vector index out of range (index: {}, len: {})", idx, self.len);
         }
@@ -81,7 +81,7 @@ struct Vector {
     /// NOTE: This function does NOT operate in-place. Internally, it creates a copy
     /// of the vector, skipping over `size` elements starting at `i`, and then points
     /// the original variable to the new memory location.
-    public func delete(mut self, i: usize, size: usize := 1, no_slices: bool := false) {
+    public func delete(mut self, i: uint, size: uint := 1, no_slices: bool := false) {
         if i + size > self.len {
             end_idx := if size == 1 { "..{}".fmt(i + size) } else { "" };
             process_panic(
@@ -93,7 +93,7 @@ struct Vector {
         // `self.delete(0)` should move (2-0-1) elements = 1 element (the 34) forward
         old_ptr := self.ptr;
         new_size := self.len - size;
-        new_cap: usize := if new_size == 0 { 1 } else { new_size };
+        new_cap: uint := if new_size == 0 { 1 } else { new_size };
         self.ptr = mem_zeroed(new_cap * self.elem_size) catch @unreachable();
         mem_copy(self.ptr, old_ptr, i * self.elem_size);
         unsafe {
@@ -112,7 +112,7 @@ struct Vector {
 
     /// Trims the array length to `index` without modifying the allocated data.
     /// If `index` is greater than `len` nothing will be changed.
-    public func trim(mut self, index: usize) {
+    public func trim(mut self, index: uint) {
         if index < self.len {
             self.len = index;
         }
@@ -139,7 +139,7 @@ struct Vector {
         return !(self == rhs);
     }
 
-    func reserve(mut self, required: usize) {
+    func reserve(mut self, required: uint) {
         if required <= self.cap {
             return;
         }
@@ -154,7 +154,7 @@ struct Vector {
         self.cap = cap;
     }
 
-    func slice(self, start: usize, end: usize) -> Self {
+    func slice(self, start: uint, end: uint) -> Self {
         if start > end or end > self.len {
             process_panic(
                 "slice index out of range (range: {}..{}, len: {})", start, end, self.len
@@ -171,7 +171,7 @@ struct Vector {
     }
 
     #[inline]
-    func slice_from(self, start: usize) -> Self {
+    func slice_from(self, start: uint) -> Self {
         return self.slice(start, self.len);
     }