ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-07-19 01:01:31 -07:00
Code Issues Packages Projects Releases Wiki Activity

Change precedence order for types e.g. ^T(x) == ^(T(x))

Browse Source
This commit is contained in:
Ginger Bill
2017-07-13 16:20:07 +01:00
parent 03570275c1
commit b8697fb4ed
19 changed files with 1683 additions and 1442 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/_preload.odin
+44 -44
View File
@@ -319,8 +319,8 @@ append :: proc(array: ^[]$T, args: ...T) -> int #cc_contextless {
arg_len = min(cap(array)-len(array), arg_len);
if arg_len > 0 {
s := ^raw.Slice(array);
data := ^T(s.data);
s := cast(^raw.Slice)array;
data := cast(^T)s.data;
assert(data != nil);
sz :: size_of(T);
__mem_copy(data + s.len, &args[0], sz*arg_len);
@@ -344,8 +344,8 @@ append :: proc(array: ^[dynamic]$T, args: ...T) -> int {
// TODO(bill): Better error handling for failed reservation
if !ok do return len(array);
a := ^raw.DynamicArray(array);
data := ^T(a.data);
a := cast(^raw.DynamicArray)array;
data := cast(^T)a.data;
assert(data != nil);
__mem_copy(data + a.len, &args[0], size_of(T) * arg_len);
a.len += arg_len;
@@ -357,7 +357,7 @@ pop :: proc(array: ^[]$T) -> T #cc_contextless {
if array != nil do return res;
assert(len(array) > 0);
res = array[len(array)-1];
^raw.Slice(array).len -= 1;
(cast(^raw.Slice)array).len -= 1;
return res;
}
@@ -366,28 +366,28 @@ pop :: proc(array: ^[dynamic]$T) -> T #cc_contextless {
if array != nil do return res;
assert(len(array) > 0);
res = array[len(array)-1];
^raw.DynamicArray(array).len -= 1;
(cast(^raw.DynamicArray)array).len -= 1;
return res;
}
clear :: proc(slice: ^[]$T) #cc_contextless #inline {
if slice != nil do ^raw.Slice(slice).len = 0;
if slice != nil do (cast(^raw.Slice)slice).len = 0;
}
clear :: proc(array: ^[dynamic]$T) #cc_contextless #inline {
if array != nil do ^raw.DynamicArray(array).len = 0;
if array != nil do (cast(^raw.DynamicArray)array).len = 0;
}
clear :: proc(m: ^map[$K]$V) #cc_contextless #inline {
if m == nil do return;
raw_map := ^raw.DynamicMap(m);
hashes := ^raw.DynamicArray(&raw_map.hashes);
entries := ^raw.DynamicArray(&raw_map.entries);
raw_map := cast(^raw.DynamicMap)m;
hashes := cast(^raw.DynamicArray)&raw_map.hashes;
entries := cast(^raw.DynamicArray)&raw_map.entries;
hashes.len = 0;
entries.len = 0;
}
reserve :: proc(array: ^[dynamic]$T, capacity: int) -> bool {
if array == nil do return false;
a := ^raw.DynamicArray(array);
a := cast(^raw.DynamicArray)array;
if capacity <= a.cap do return true;
@@ -410,7 +410,7 @@ reserve :: proc(array: ^[dynamic]$T, capacity: int) -> bool {
__get_map_header :: proc(m: ^map[$K]$V) -> __MapHeader #cc_contextless {
header := __MapHeader{m = ^raw.DynamicMap(m)};
header := __MapHeader{m = cast(^raw.DynamicMap)m};
Entry :: struct {
key: __MapKey;
next: int;
@@ -432,24 +432,24 @@ __get_map_key :: proc(key: $K) -> __MapKey #cc_contextless {
match _ in ti {
case TypeInfo.Integer:
match 8*size_of(key) {
case 8: map_key.hash = u128( ^u8(&key)^);
case 16: map_key.hash = u128( ^u16(&key)^);
case 32: map_key.hash = u128( ^u32(&key)^);
case 64: map_key.hash = u128( ^u64(&key)^);
case 128: map_key.hash = u128(^u128(&key)^);
case 8: map_key.hash = u128((cast( ^u8)&key)^);
case 16: map_key.hash = u128((cast( ^u16)&key)^);
case 32: map_key.hash = u128((cast( ^u32)&key)^);
case 64: map_key.hash = u128((cast( ^u64)&key)^);
case 128: map_key.hash = u128((cast(^u128)&key)^);
}
case TypeInfo.Rune:
map_key.hash = u128(^rune(&key)^);
map_key.hash = u128((cast(^rune)&key)^);
case TypeInfo.Pointer:
map_key.hash = u128(uint(^rawptr(&key)^));
map_key.hash = u128(uint((cast(^rawptr)&key)^));
case TypeInfo.Float:
match 8*size_of(key) {
case 32: map_key.hash = u128(^u32(&key)^);
case 64: map_key.hash = u128(^u64(&key)^);
case 32: map_key.hash = u128((cast(^u32)&key)^);
case 64: map_key.hash = u128((cast(^u64)&key)^);
case: panic("Unhandled float size");
}
case TypeInfo.String:
str := ^string(&key)^;
str := (cast(^string)&key)^;
map_key.hash = __default_hash_string(str);
map_key.str = str;
case:
@@ -468,12 +468,12 @@ delete :: proc(m: ^map[$K]$V, key: K) {
new :: proc(T: type) -> ^T #inline do return ^T(alloc(size_of(T), align_of(T)));
new :: proc(T: type) -> ^T #inline do return cast(^T)alloc(size_of(T), align_of(T));
free :: proc(ptr: rawptr) do free_ptr(ptr);
free :: proc(str: string) do free_ptr(^raw.String(&str).data);
free :: proc(array: [dynamic]$T) do free_ptr(^raw.DynamicArray(&array).data);
free :: proc(slice: []$T) do free_ptr(^raw.Slice(&slice).data);
free :: proc(str: string) do free_ptr((cast(^raw.String)&str).data);
free :: proc(array: [dynamic]$T) do free_ptr((cast(^raw.DynamicArray)&array).data);
free :: proc(slice: []$T) do free_ptr((cast(^raw.Slice)&slice).data);
free :: proc(m: map[$K]$V) {
raw := ^raw.DynamicMap(&m);
free(raw.hashes);
@@ -688,7 +688,7 @@ __abs_complex128 :: proc(x: complex128) -> f64 #inline #cc_contextless {
__dynamic_array_make :: proc(array_: rawptr, elem_size, elem_align: int, len, cap: int) {
array := ^raw.DynamicArray(array_);
array := cast(^raw.DynamicArray)array_;
array.allocator = context.allocator;
assert(array.allocator.procedure != nil);
@@ -699,7 +699,7 @@ __dynamic_array_make :: proc(array_: rawptr, elem_size, elem_align: int, len, ca
}
__dynamic_array_reserve :: proc(array_: rawptr, elem_size, elem_align: int, cap: int) -> bool {
array := ^raw.DynamicArray(array_);
array := cast(^raw.DynamicArray)array_;
if cap <= array.cap do return true;
@@ -721,7 +721,7 @@ __dynamic_array_reserve :: proc(array_: rawptr, elem_size, elem_align: int, cap:
}
__dynamic_array_resize :: proc(array_: rawptr, elem_size, elem_align: int, len: int) -> bool {
array := ^raw.DynamicArray(array_);
array := cast(^raw.DynamicArray)array_;
ok := __dynamic_array_reserve(array_, elem_size, elem_align, len);
if ok do array.len = len;
@@ -731,7 +731,7 @@ __dynamic_array_resize :: proc(array_: rawptr, elem_size, elem_align: int, len:
__dynamic_array_append :: proc(array_: rawptr, elem_size, elem_align: int,
items: rawptr, item_count: int) -> int {
array := ^raw.DynamicArray(array_);
array := cast(^raw.DynamicArray)array_;
if items == nil do return 0;
if item_count <= 0 do return 0;
@@ -745,7 +745,7 @@ __dynamic_array_append :: proc(array_: rawptr, elem_size, elem_align: int,
// TODO(bill): Better error handling for failed reservation
if !ok do return array.len;
data := ^u8(array.data);
data := cast(^u8)array.data;
assert(data != nil);
__mem_copy(data + (elem_size*array.len), items, elem_size * item_count);
array.len += item_count;
@@ -753,7 +753,7 @@ __dynamic_array_append :: proc(array_: rawptr, elem_size, elem_align: int,
}
__dynamic_array_append_nothing :: proc(array_: rawptr, elem_size, elem_align: int) -> int {
array := ^raw.DynamicArray(array_);
array := cast(^raw.DynamicArray)array_;
ok := true;
if array.cap <= array.len+1 {
@@ -763,7 +763,7 @@ __dynamic_array_append_nothing :: proc(array_: rawptr, elem_size, elem_align: in
// TODO(bill): Better error handling for failed reservation
if !ok do return array.len;
data := ^u8(array.data);
data := cast(^u8)array.data;
assert(data != nil);
__mem_zero(data + (elem_size*array.len), elem_size);
array.len++;
@@ -772,7 +772,7 @@ __dynamic_array_append_nothing :: proc(array_: rawptr, elem_size, elem_align: in
__slice_append :: proc(slice_: rawptr, elem_size, elem_align: int,
items: rawptr, item_count: int) -> int {
slice := ^raw.Slice(slice_);
slice := cast(^raw.Slice)slice_;
if item_count <= 0 || items == nil {
return slice.len;
@@ -780,7 +780,7 @@ __slice_append :: proc(slice_: rawptr, elem_size, elem_align: int,
item_count = min(slice.cap-slice.len, item_count);
if item_count > 0 {
data := ^u8(slice.data);
data := cast(^u8)slice.data;
assert(data != nil);
__mem_copy(data + (elem_size*slice.len), items, elem_size * item_count);
slice.len += item_count;
@@ -800,7 +800,7 @@ __default_hash :: proc(data: []u8) -> u128 {
}
return fnv128a(data);
}
__default_hash_string :: proc(s: string) -> u128 do return __default_hash([]u8(s));
__default_hash_string :: proc(s: string) -> u128 do return __default_hash(cast([]u8)s);
__dynamic_map_reserve :: proc(using header: __MapHeader, cap: int) {
__dynamic_array_reserve(&m.hashes, size_of(int), align_of(int), cap);
@@ -812,8 +812,8 @@ __dynamic_map_rehash :: proc(using header: __MapHeader, new_count: int) {
nm: raw.DynamicMap;
new_header.m = &nm;
header_hashes := ^raw.DynamicArray(&header.m.hashes);
nm_hashes := ^raw.DynamicArray(&nm.hashes);
header_hashes := cast(^raw.DynamicArray)&header.m.hashes;
nm_hashes := cast(^raw.DynamicArray)&nm.hashes;
__dynamic_array_resize(nm_hashes, size_of(int), align_of(int), new_count);
__dynamic_array_reserve(&nm.entries, entry_size, entry_align, m.entries.len);
@@ -823,7 +823,7 @@ __dynamic_map_rehash :: proc(using header: __MapHeader, new_count: int) {
if len(nm.hashes) == 0 do __dynamic_map_grow(new_header);
entry_header := __dynamic_map_get_entry(header, i);
data := ^u8(entry_header);
data := cast(^u8)entry_header;
fr := __dynamic_map_find(new_header, entry_header.key);
j := __dynamic_map_add_entry(new_header, entry_header.key);
@@ -836,7 +836,7 @@ __dynamic_map_rehash :: proc(using header: __MapHeader, new_count: int) {
e := __dynamic_map_get_entry(new_header, j);
e.next = fr.entry_index;
ndata := ^u8(e);
ndata := cast(^u8)e;
__mem_copy(ndata+value_offset, data+value_offset, value_size);
if __dynamic_map_full(new_header) do __dynamic_map_grow(new_header);
@@ -849,7 +849,7 @@ __dynamic_map_rehash :: proc(using header: __MapHeader, new_count: int) {
__dynamic_map_get :: proc(h: __MapHeader, key: __MapKey) -> rawptr {
index := __dynamic_map_find(h, key).entry_index;
if index >= 0 {
data := ^u8(__dynamic_map_get_entry(h, index));
data := cast(^u8)__dynamic_map_get_entry(h, index);
return data + h.value_offset;
}
return nil;
@@ -880,7 +880,7 @@ __dynamic_map_set :: proc(using h: __MapHeader, key: __MapKey, value: rawptr) {
{
e := __dynamic_map_get_entry(h, index);
e.key = key;
val := ^u8(e) + value_offset;
val := cast(^u8)e + value_offset;
__mem_copy(val, value, value_size);
}
@@ -942,7 +942,7 @@ __dynamic_map_delete :: proc(using h: __MapHeader, key: __MapKey) {
}
__dynamic_map_get_entry :: proc(using h: __MapHeader, index: int) -> ^__MapEntryHeader {
return ^__MapEntryHeader(^u8(m.entries.data) + index*entry_size);
return cast(^__MapEntryHeader)(cast(^u8)m.entries.data + index*entry_size);
}
__dynamic_map_erase :: proc(using h: __MapHeader, fr: __MapFindResult) {
core/fmt.odin
+14 -14
View File
@@ -55,7 +55,7 @@ to_string :: proc(buf: StringBuffer) -> string {
write_string :: proc(buf: ^StringBuffer, s: string) {
write_bytes(buf, []u8(s));
write_bytes(buf, cast([]u8)s);
}
write_bytes :: proc(buf: ^StringBuffer, data: []u8) {
match b in buf {
@@ -747,7 +747,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
if t := b.types[i]; types.is_any(t) {
write_string(fi.buf, "any{}");
} else {
data := ^u8(v.data) + b.offsets[i];
data := cast(^u8)v.data + b.offsets[i];
fmt_arg(fi, any{rawptr(data), t}, 'v');
}
}
@@ -766,9 +766,9 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
case Pointer:
if v.type_info == type_info(^TypeInfo) {
write_type(fi.buf, ^^TypeInfo(v.data)^);
write_type(fi.buf, (cast(^^TypeInfo)v.data)^);
} else {
fmt_pointer(fi, ^rawptr(v.data)^, verb);
fmt_pointer(fi, (cast(^rawptr)v.data)^, verb);
}
case Atomic:
@@ -780,25 +780,25 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
for i in 0..info.count {
if i > 0 do write_string(fi.buf, ", ");
data := ^u8(v.data) + i*info.elem_size;
data := cast(^u8)v.data + i*info.elem_size;
fmt_arg(fi, any{rawptr(data), info.elem}, verb);
}
case DynamicArray:
write_byte(fi.buf, '[');
defer write_byte(fi.buf, ']');
array := ^raw.DynamicArray(v.data);
array := cast(^raw.DynamicArray)v.data;
for i in 0..array.len {
if i > 0 do write_string(fi.buf, ", ");
data := ^u8(array.data) + i*info.elem_size;
data := cast(^u8)array.data + i*info.elem_size;
fmt_arg(fi, any{rawptr(data), info.elem}, verb);
}
case Slice:
write_byte(fi.buf, '[');
defer write_byte(fi.buf, ']');
slice := ^[]u8(v.data);
slice := cast(^[]u8)v.data;
for _, i in slice {
if i > 0 do write_string(fi.buf, ", ");
@@ -813,7 +813,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
for i in 0..info.count {
if i > 0 do write_string(fi.buf, ", ");
data := ^u8(v.data) + i*info.elem_size;
data := cast(^u8)v.data + i*info.elem_size;
fmt_value(fi, any{rawptr(data), info.elem}, verb);
}
@@ -826,7 +826,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
write_string(fi.buf, "map[");
defer write_byte(fi.buf, ']');
entries := &(^raw.DynamicMap(v.data).entries);
entries := &((cast(^raw.DynamicMap)v.data).entries);
gs := type_info_base(info.generated_struct).variant.(Struct);
ed := type_info_base(gs.types[1]).variant.(DynamicArray);
entry_type := ed.elem.variant.(Struct);
@@ -835,8 +835,8 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
for i in 0..entries.len {
if i > 0 do write_string(fi.buf, ", ");
data := ^u8(entries.data) + i*entry_size;
header := ^__MapEntryHeader(data);
data := cast(^u8)entries.data + i*entry_size;
header := cast(^__MapEntryHeader)data;
if types.is_string(info.key) {
write_string(fi.buf, header.key.str);
@@ -866,7 +866,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
if t := info.types[i]; types.is_any(t) {
write_string(fi.buf, "any{}");
} else {
data := ^u8(v.data) + info.offsets[i];
data := cast(^u8)v.data + info.offsets[i];
fmt_arg(fi, any{rawptr(data), t}, 'v');
}
}
@@ -883,7 +883,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
case Procedure:
write_type(fi.buf, v.type_info);
write_string(fi.buf, " @ ");
fmt_pointer(fi, ^rawptr(v.data)^, 'p');
fmt_pointer(fi, (cast(^rawptr)v.data)^, 'p');
}
}
core/hash.odin
+3 -3
View File
@@ -57,7 +57,7 @@ murmur32 :: proc(data: []u8) -> u32 {
p1 := p + 4*nblocks;
for ; p < p1; p += 4 {
k1 := ^u32(p)^;
k1 := (cast(^u32)p)^;
k1 *= c1_32;
k1 = (k1 << 15) | (k1 >> 17);
@@ -104,7 +104,7 @@ murmur64 :: proc(data: []u8) -> u64 {
r :: 47;
h: u64 = SEED ~ (u64(len(data)) * m);
data64 := mem.slice_ptr(^u64(&data[0]), len(data)/size_of(u64));
data64 := mem.slice_ptr(cast(^u64)&data[0], len(data)/size_of(u64));
for _, i in data64 {
k := data64[i];
@@ -140,7 +140,7 @@ murmur64 :: proc(data: []u8) -> u64 {
h1 := u32(SEED) ~ u32(len(data));
h2 := u32(SEED) >> 32;
data32 := mem.slice_ptr(^u32(&data[0]), len(data)/size_of(u32));
data32 := mem.slice_ptr(cast(^u32)&data[0], len(data)/size_of(u32));
len := len(data);
i := 0;
core/mem.odin
+8 -8
View File
@@ -29,19 +29,19 @@ compare :: proc(a, b: []u8) -> int #cc_contextless {
slice_ptr :: proc(ptr: ^$T, len: int) -> []T #cc_contextless {
assert(len >= 0);
slice := raw.Slice{data = ptr, len = len, cap = len};
return ^[]T(&slice)^;
return (cast(^[]T)&slice)^;
}
slice_ptr :: proc(ptr: ^$T, len, cap: int) -> []T #cc_contextless {
assert(0 <= len && len <= cap);
slice := raw.Slice{data = ptr, len = len, cap = cap};
return ^[]T(&slice)^;
return (cast(^[]T)&slice)^;
}
slice_to_bytes :: proc(slice: []$T) -> []u8 #cc_contextless {
s := ^raw.Slice(&slice);
s := cast(^raw.Slice)&slice;
s.len *= size_of(T);
s.cap *= size_of(T);
return ^[]u8(s)^;
return (cast(^[]u8)s)^;
}
@@ -73,7 +73,7 @@ AllocationHeader :: struct {
allocation_header_fill :: proc(header: ^AllocationHeader, data: rawptr, size: int) {
header.size = size;
ptr := ^int(header+1);
ptr := cast(^int)(header+1);
for i := 0; rawptr(ptr) < data; i++ {
(ptr+i)^ = -1;
@@ -81,9 +81,9 @@ allocation_header_fill :: proc(header: ^AllocationHeader, data: rawptr, size: in
}
allocation_header :: proc(data: rawptr) -> ^AllocationHeader {
if data == nil do return nil;
p := ^int(data);
p := cast(^int)data;
for (p-1)^ == -1 do p = (p-1);
return ^AllocationHeader(p-1);
return cast(^AllocationHeader)(p-1);
}
@@ -141,7 +141,7 @@ arena_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator.Mode,
size, alignment: int,
old_memory: rawptr, old_size: int, flags: u64) -> rawptr {
using Allocator.Mode;
arena := ^Arena(allocator_data);
arena := cast(^Arena)allocator_data;
match mode {
case Alloc:
core/opengl.odin
+1 -1
View File
@@ -120,7 +120,7 @@ get_proc_address :: proc(name: string) -> rawptr {
init :: proc() {
set_proc_address :: proc(p: rawptr, name: string) #inline {
x := ^rawptr(p);
x := cast(^rawptr)p;
x^ = get_proc_address(name);
}
core/os.odin
+1 -1
View File
@@ -5,7 +5,7 @@ import_load (
)
write_string :: proc(fd: Handle, str: string) -> (int, Errno) {
return write(fd, []u8(str));
return write(fd, cast([]u8)str);
}
read_entire_file :: proc(name: string) -> ([]u8, bool) {
core/os_windows.odin
+2 -2
View File
@@ -96,7 +96,7 @@ open :: proc(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errn
}
buf: [300]u8;
copy(buf[..], []u8(path));
copy(buf[..], cast([]u8)path);
handle := Handle(win32.create_file_a(&buf[0], access, share_mode, sa, create_mode, win32.FILE_ATTRIBUTE_NORMAL, nil));
if handle != INVALID_HANDLE do return handle, ERROR_NONE;
@@ -217,7 +217,7 @@ last_write_time_by_name :: proc(name: string) -> FileTime {
assert(len(buf) > len(name));
copy(buf[..], []u8(name));
copy(buf[..], cast([]u8)name);
if win32.get_file_attributes_ex_a(&buf[0], win32.GetFileExInfoStandard, &data) != 0 {
last_write_time = data.last_write_time;
core/strconv.odin
+2 -2
View File
@@ -191,7 +191,7 @@ parse_f64 :: proc(s: string) -> f64 {
append_bool :: proc(buf: []u8, b: bool) -> string {
s := b ? "true" : "false";
append(&buf, ...[]u8(s));
append(&buf, ...cast([]u8)s);
return string(buf);
}
@@ -257,7 +257,7 @@ generic_ftoa :: proc(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8
} else {
s = "+Inf";
}
append(&buf, ...[]u8(s));
append(&buf, ...cast([]u8)s);
return buf;
case 0: // denormalized
core/strings.odin
+2 -2
View File
@@ -2,14 +2,14 @@ import "mem.odin";
new_string :: proc(s: string) -> string {
c := make([]u8, len(s)+1);
copy(c, []u8(s));
copy(c, cast([]u8)s);
c[len(s)] = 0;
return string(c[..len(s)]);
}
new_c_string :: proc(s: string) -> ^u8 {
c := make([]u8, len(s)+1);
copy(c, []u8(s));
copy(c, cast([]u8)s);
c[len(s)] = 0;
return &c[0];
}
core/utf8.odin
+3 -3
View File
@@ -92,7 +92,7 @@ encode_rune :: proc(r: rune) -> ([4]u8, int) {
return buf, 4;
}
decode_rune :: proc(s: string) -> (rune, int) #inline { return decode_rune([]u8(s)); }
decode_rune :: proc(s: string) -> (rune, int) #inline { return decode_rune(cast([]u8)s); }
decode_rune :: proc(s: []u8) -> (rune, int) {
n := len(s);
if n < 1 {
@@ -132,7 +132,7 @@ decode_rune :: proc(s: []u8) -> (rune, int) {
decode_last_rune :: proc(s: string) -> (rune, int) #inline { return decode_last_rune([]u8(s)); }
decode_last_rune :: proc(s: string) -> (rune, int) #inline { return decode_last_rune(cast([]u8)s); }
decode_last_rune :: proc(s: []u8) -> (rune, int) {
r: rune;
size: int;
@@ -217,7 +217,7 @@ valid_string :: proc(s: string) -> bool {
rune_start :: proc(b: u8) -> bool #inline { return b&0xc0 != 0x80; }
rune_count :: proc(s: string) -> int #inline { return rune_count([]u8(s)); }
rune_count :: proc(s: string) -> int #inline { return rune_count(cast([]u8)s); }
rune_count :: proc(s: []u8) -> int {
count := 0;
n := len(s);