ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-06 15:48:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make rune a basic type and not an alias; Remove byte

Browse Source
This commit is contained in:
Ginger Bill
2017-06-06 23:54:33 +01:00
parent 107740ca5e
commit f60c772c11
22 changed files with 270 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/_preload.odin
+16 -15
View File
@@ -52,6 +52,7 @@ TypeInfo :: union {
Named{name: string, base: ^TypeInfo}, Named{name: string, base: ^TypeInfo},
Integer{signed: bool}, Integer{signed: bool},
Rune{},
Float{}, Float{},
Complex{}, Complex{},
String{}, String{},
@@ -110,7 +111,7 @@ TypeInfo :: union {
// This will be set by the compiler // This will be set by the compiler
__type_table: []TypeInfo; __type_table: []TypeInfo;
__argv__: ^^byte; __argv__: ^^u8;
__argc__: i32; __argc__: i32;
type_info_base :: proc(info: ^TypeInfo) -> ^TypeInfo { type_info_base :: proc(info: ^TypeInfo) -> ^TypeInfo {
@@ -376,8 +377,8 @@ __string_decode_rune :: proc(s: string) -> (rune, int) #inline {
__mem_set :: proc(data: rawptr, value: i32, len: int) -> rawptr { __mem_set :: proc(data: rawptr, value: i32, len: int) -> rawptr {
llvm_memset_64bit :: proc(dst: rawptr, val: byte, len: int, align: i32, is_volatile: bool) #foreign __llvm_core "llvm.memset.p0i8.i64"; llvm_memset_64bit :: proc(dst: rawptr, val: u8, len: int, align: i32, is_volatile: bool) #foreign __llvm_core "llvm.memset.p0i8.i64";
llvm_memset_64bit(data, byte(value), len, 1, false); llvm_memset_64bit(data, u8(value), len, 1, false);
return data; return data;
} }
__mem_zero :: proc(data: rawptr, len: int) -> rawptr { __mem_zero :: proc(data: rawptr, len: int) -> rawptr {
@@ -396,7 +397,7 @@ __mem_copy_non_overlapping :: proc(dst, src: rawptr, len: int) -> rawptr {
return dst; return dst;
} }
__mem_compare :: proc(a, b: ^byte, n: int) -> int { __mem_compare :: proc(a, b: ^u8, n: int) -> int {
for i in 0..<n { for i in 0..<n {
match { match {
case (a+i)^ < (b+i)^: case (a+i)^ < (b+i)^:
@@ -490,7 +491,7 @@ __dynamic_array_append :: proc(array_: rawptr, elem_size, elem_align: int,
// TODO(bill): Better error handling for failed reservation // TODO(bill): Better error handling for failed reservation
return array.len; return array.len;
} }
data := ^byte(array.data); data := ^u8(array.data);
assert(data != nil); assert(data != nil);
__mem_copy(data + (elem_size*array.len), items, elem_size * item_count); __mem_copy(data + (elem_size*array.len), items, elem_size * item_count);
array.len += item_count; array.len += item_count;
@@ -509,7 +510,7 @@ __dynamic_array_append_nothing :: proc(array_: rawptr, elem_size, elem_align: in
// TODO(bill): Better error handling for failed reservation // TODO(bill): Better error handling for failed reservation
return array.len; return array.len;
} }
data := ^byte(array.data); data := ^u8(array.data);
assert(data != nil); assert(data != nil);
__mem_zero(data + (elem_size*array.len), elem_size); __mem_zero(data + (elem_size*array.len), elem_size);
array.len++; array.len++;
@@ -526,7 +527,7 @@ __slice_append :: proc(slice_: rawptr, elem_size, elem_align: int,
item_count = min(slice.cap-slice.len, item_count); item_count = min(slice.cap-slice.len, item_count);
if item_count > 0 { if item_count > 0 {
data := ^byte(slice.data); data := ^u8(slice.data);
assert(data != nil); assert(data != nil);
__mem_copy(data + (elem_size*slice.len), items, elem_size * item_count); __mem_copy(data + (elem_size*slice.len), items, elem_size * item_count);
slice.len += item_count; slice.len += item_count;
@@ -537,8 +538,8 @@ __slice_append :: proc(slice_: rawptr, elem_size, elem_align: int,
// Map stuff // Map stuff
__default_hash :: proc(data: []byte) -> u128 { __default_hash :: proc(data: []u8) -> u128 {
fnv128a :: proc(data: []byte) -> u128 { fnv128a :: proc(data: []u8) -> u128 {
h: u128 = 0x6c62272e07bb014262b821756295c58d; h: u128 = 0x6c62272e07bb014262b821756295c58d;
for b in data { for b in data {
h = (h ~ u128(b)) * 0x1000000000000000000013b; h = (h ~ u128(b)) * 0x1000000000000000000013b;
@@ -548,7 +549,7 @@ __default_hash :: proc(data: []byte) -> u128 {
return fnv128a(data); return fnv128a(data);
} }
__default_hash_string :: proc(s: string) -> u128 { __default_hash_string :: proc(s: string) -> u128 {
return __default_hash([]byte(s)); return __default_hash([]u8(s));
} }
__INITIAL_MAP_CAP :: 16; __INITIAL_MAP_CAP :: 16;
@@ -606,7 +607,7 @@ __dynamic_map_rehash :: proc(using header: __MapHeader, new_count: int) {
} }
entry_header := __dynamic_map_get_entry(header, i); entry_header := __dynamic_map_get_entry(header, i);
data := ^byte(entry_header); data := ^u8(entry_header);
fr := __dynamic_map_find(new_header, entry_header.key); fr := __dynamic_map_find(new_header, entry_header.key);
j := __dynamic_map_add_entry(new_header, entry_header.key); j := __dynamic_map_add_entry(new_header, entry_header.key);
@@ -619,7 +620,7 @@ __dynamic_map_rehash :: proc(using header: __MapHeader, new_count: int) {
e := __dynamic_map_get_entry(new_header, j); e := __dynamic_map_get_entry(new_header, j);
e.next = fr.entry_index; e.next = fr.entry_index;
ndata := ^byte(e); ndata := ^u8(e);
__mem_copy(ndata+value_offset, data+value_offset, value_size); __mem_copy(ndata+value_offset, data+value_offset, value_size);
if __dynamic_map_full(new_header) { if __dynamic_map_full(new_header) {
@@ -634,7 +635,7 @@ __dynamic_map_rehash :: proc(using header: __MapHeader, new_count: int) {
__dynamic_map_get :: proc(h: __MapHeader, key: __MapKey) -> rawptr { __dynamic_map_get :: proc(h: __MapHeader, key: __MapKey) -> rawptr {
index := __dynamic_map_find(h, key).entry_index; index := __dynamic_map_find(h, key).entry_index;
if index >= 0 { if index >= 0 {
data := ^byte(__dynamic_map_get_entry(h, index)); data := ^u8(__dynamic_map_get_entry(h, index));
val := data + h.value_offset; val := data + h.value_offset;
return val; return val;
} }
@@ -666,7 +667,7 @@ __dynamic_map_set :: proc(using h: __MapHeader, key: __MapKey, value: rawptr) {
{ {
e := __dynamic_map_get_entry(h, index); e := __dynamic_map_get_entry(h, index);
e.key = key; e.key = key;
val := ^byte(e) + value_offset; val := ^u8(e) + value_offset;
__mem_copy(val, value, value_size); __mem_copy(val, value, value_size);
} }
@@ -733,7 +734,7 @@ __dynamic_map_delete :: proc(using h: __MapHeader, key: __MapKey) {
} }
__dynamic_map_get_entry :: proc(using h: __MapHeader, index: int) -> ^__MapEntryHeader { __dynamic_map_get_entry :: proc(using h: __MapHeader, index: int) -> ^__MapEntryHeader {
data := ^byte(m.entries.data) + index*entry_size; data := ^u8(m.entries.data) + index*entry_size;
return ^__MapEntryHeader(data); return ^__MapEntryHeader(data);
} }
core/decimal.odin
+9 -9
View File
@@ -3,14 +3,14 @@
// NOTE: This is only for floating point printing and nothing else // NOTE: This is only for floating point printing and nothing else
Decimal :: struct { Decimal :: struct {
digits: [384]byte, // big-endian digits digits: [384]u8, // big-endian digits
count: int, count: int,
decimal_point: int, decimal_point: int,
neg, trunc: bool, neg, trunc: bool,
} }
decimal_to_string :: proc(buf: []byte, a: ^Decimal) -> string { decimal_to_string :: proc(buf: []u8, a: ^Decimal) -> string {
digit_zero :: proc(buf: []byte) -> int { digit_zero :: proc(buf: []u8) -> int {
for _, i in buf { for _, i in buf {
buf[i] = '0'; buf[i] = '0';
} }
@@ -59,12 +59,12 @@ trim :: proc(a: ^Decimal) {
assign :: proc(a: ^Decimal, i: u64) { assign :: proc(a: ^Decimal, i: u64) {
buf: [32]byte; buf: [32]u8;
n := 0; n := 0;
for i > 0 { for i > 0 {
j := i/10; j := i/10;
i -= 10*j; i -= 10*j;
buf[n] = byte('0'+i); buf[n] = u8('0'+i);
n++; n++;
i = j; i = j;
} }
@@ -110,7 +110,7 @@ shift_right :: proc(a: ^Decimal, k: uint) {
c := uint(a.digits[r]); c := uint(a.digits[r]);
dig := n>>k; dig := n>>k;
n &= mask; n &= mask;
a.digits[w] = byte('0' + dig); a.digits[w] = u8('0' + dig);
w++; w++;
n = n*10 + c - '0'; n = n*10 + c - '0';
} }
@@ -119,7 +119,7 @@ shift_right :: proc(a: ^Decimal, k: uint) {
dig := n>>k; dig := n>>k;
n &= mask; n &= mask;
if w < len(a.digits) { if w < len(a.digits) {
a.digits[w] = byte('0' + dig); a.digits[w] = u8('0' + dig);
w++; w++;
} else if dig > 0 { } else if dig > 0 {
a.trunc = true; a.trunc = true;
@@ -145,7 +145,7 @@ shift_left :: proc(a: ^Decimal, k: uint) {
rem := n - 10*quo; rem := n - 10*quo;
w--; w--;
if w < len(a.digits) { if w < len(a.digits) {
a.digits[w] = byte('0' + rem); a.digits[w] = u8('0' + rem);
} else if rem != 0 { } else if rem != 0 {
a.trunc = true; a.trunc = true;
} }
@@ -157,7 +157,7 @@ shift_left :: proc(a: ^Decimal, k: uint) {
rem := n - 10*quo; rem := n - 10*quo;
w--; w--;
if 0 <= w && w < len(a.digits) { if 0 <= w && w < len(a.digits) {
a.digits[w] = byte('0' + rem); a.digits[w] = u8('0' + rem);
} else if rem != 0 { } else if rem != 0 {
a.trunc = true; a.trunc = true;
} }
core/fmt.odin
+45 -35
View File
@@ -9,8 +9,8 @@
_BUFFER_SIZE :: 1<<12; _BUFFER_SIZE :: 1<<12;
StringBuffer :: union { StringBuffer :: union {
Static {buf: []byte}, Static {buf: []u8},
Dynamic{buf: [dynamic]byte}, Dynamic{buf: [dynamic]u8},
} }
FmtInfo :: struct { FmtInfo :: struct {
@@ -33,14 +33,14 @@ FmtInfo :: struct {
} }
make_string_buffer_from_slice :: proc(b: []byte) -> StringBuffer { make_string_buffer_from_slice :: proc(b: []u8) -> StringBuffer {
return StringBuffer.Static{b}; return StringBuffer.Static{b};
} }
make_string_dynamic_buffer :: proc() -> StringBuffer { make_string_dynamic_buffer :: proc() -> StringBuffer {
return StringBuffer.Dynamic{make([dynamic]byte)}; return StringBuffer.Dynamic{make([dynamic]u8)};
} }
string_buffer_data :: proc(buf: ^StringBuffer) -> []byte { string_buffer_data :: proc(buf: ^StringBuffer) -> []u8 {
match b in buf { match b in buf {
case StringBuffer.Static: case StringBuffer.Static:
return b.buf[..]; return b.buf[..];
@@ -49,7 +49,7 @@ string_buffer_data :: proc(buf: ^StringBuffer) -> []byte {
} }
return nil; return nil;
} }
string_buffer_data :: proc(buf: StringBuffer) -> []byte { string_buffer_data :: proc(buf: StringBuffer) -> []u8 {
match b in buf { match b in buf {
case StringBuffer.Static: case StringBuffer.Static:
return b.buf[..]; return b.buf[..];
@@ -64,9 +64,9 @@ to_string :: proc(buf: StringBuffer) -> string {
write_string :: proc(buf: ^StringBuffer, s: string) { write_string :: proc(buf: ^StringBuffer, s: string) {
write_bytes(buf, []byte(s)); write_bytes(buf, []u8(s));
} }
write_bytes :: proc(buf: ^StringBuffer, data: []byte) { write_bytes :: proc(buf: ^StringBuffer, data: []u8) {
match b in buf { match b in buf {
case StringBuffer.Static: case StringBuffer.Static:
append(b.buf, ..data); append(b.buf, ..data);
@@ -74,7 +74,7 @@ write_bytes :: proc(buf: ^StringBuffer, data: []byte) {
append(b.buf, ..data); append(b.buf, ..data);
} }
} }
write_byte :: proc(buf: ^StringBuffer, data: byte) { write_byte :: proc(buf: ^StringBuffer, data: u8) {
match b in buf { match b in buf {
case StringBuffer.Static: case StringBuffer.Static:
append(b.buf, data); append(b.buf, data);
@@ -84,7 +84,7 @@ write_byte :: proc(buf: ^StringBuffer, data: byte) {
} }
write_rune :: proc(buf: ^StringBuffer, r: rune) { write_rune :: proc(buf: ^StringBuffer, r: rune) {
if r < utf8.RUNE_SELF { if r < utf8.RUNE_SELF {
write_byte(buf, byte(r)); write_byte(buf, u8(r));
return; return;
} }
@@ -93,12 +93,12 @@ write_rune :: proc(buf: ^StringBuffer, r: rune) {
} }
write_int :: proc(buf: ^StringBuffer, i: i128, base: int) { write_int :: proc(buf: ^StringBuffer, i: i128, base: int) {
b: [129]byte; b: [129]u8;
s := strconv.append_bits(b[0..<0], u128(i), base, true, 128, strconv.digits, 0); s := strconv.append_bits(b[0..<0], u128(i), base, true, 128, strconv.digits, 0);
write_string(buf, s); write_string(buf, s);
} }
write_int :: proc(buf: ^StringBuffer, i: i64, base: int) { write_int :: proc(buf: ^StringBuffer, i: i64, base: int) {
b: [129]byte; b: [129]u8;
s := strconv.append_bits(b[0..<0], u128(i), base, true, 64, strconv.digits, 0); s := strconv.append_bits(b[0..<0], u128(i), base, true, 64, strconv.digits, 0);
write_string(buf, s); write_string(buf, s);
} }
@@ -106,7 +106,7 @@ write_int :: proc(buf: ^StringBuffer, i: i64, base: int) {
fprint :: proc(fd: os.Handle, args: ..any) -> int { fprint :: proc(fd: os.Handle, args: ..any) -> int {
data: [_BUFFER_SIZE]byte; data: [_BUFFER_SIZE]u8;
buf := make_string_buffer_from_slice(data[0..<0]); buf := make_string_buffer_from_slice(data[0..<0]);
sbprint(&buf, ..args); sbprint(&buf, ..args);
res := string_buffer_data(buf); res := string_buffer_data(buf);
@@ -115,7 +115,7 @@ fprint :: proc(fd: os.Handle, args: ..any) -> int {
} }
fprintln :: proc(fd: os.Handle, args: ..any) -> int { fprintln :: proc(fd: os.Handle, args: ..any) -> int {
data: [_BUFFER_SIZE]byte; data: [_BUFFER_SIZE]u8;
buf := make_string_buffer_from_slice(data[0..<0]); buf := make_string_buffer_from_slice(data[0..<0]);
sbprintln(&buf, ..args); sbprintln(&buf, ..args);
res := string_buffer_data(buf); res := string_buffer_data(buf);
@@ -123,7 +123,7 @@ fprintln :: proc(fd: os.Handle, args: ..any) -> int {
return len(res); return len(res);
} }
fprintf :: proc(fd: os.Handle, fmt: string, args: ..any) -> int { fprintf :: proc(fd: os.Handle, fmt: string, args: ..any) -> int {
data: [_BUFFER_SIZE]byte; data: [_BUFFER_SIZE]u8;
buf := make_string_buffer_from_slice(data[0..<0]); buf := make_string_buffer_from_slice(data[0..<0]);
sbprintf(&buf, fmt, ..args); sbprintf(&buf, fmt, ..args);
res := string_buffer_data(buf); res := string_buffer_data(buf);
@@ -162,15 +162,15 @@ aprintf :: proc(fmt: string, args: ..any) -> string {
// bprint* procedures return a string that was allocated with the current context // bprint* procedures return a string that was allocated with the current context
// They must be freed accordingly // They must be freed accordingly
bprint :: proc(buf: []byte, args: ..any) -> string { bprint :: proc(buf: []u8, args: ..any) -> string {
sb := make_string_buffer_from_slice(buf[0..<0..<len(buf)]); sb := make_string_buffer_from_slice(buf[0..<0..<len(buf)]);
return sbprint(&sb, ..args); return sbprint(&sb, ..args);
} }
bprintln :: proc(buf: []byte, args: ..any) -> string { bprintln :: proc(buf: []u8, args: ..any) -> string {
sb := make_string_buffer_from_slice(buf[0..<0..<len(buf)]); sb := make_string_buffer_from_slice(buf[0..<0..<len(buf)]);
return sbprintln(&sb, ..args); return sbprintln(&sb, ..args);
} }
bprintf :: proc(buf: []byte, fmt: string, args: ..any) -> string { bprintf :: proc(buf: []u8, fmt: string, args: ..any) -> string {
sb := make_string_buffer_from_slice(buf[0..<0..<len(buf)]); sb := make_string_buffer_from_slice(buf[0..<0..<len(buf)]);
return sbprintf(&sb, fmt, ..args); return sbprintf(&sb, fmt, ..args);
} }
@@ -181,7 +181,7 @@ bprintf :: proc(buf: []byte, fmt: string, args: ..any) -> string {
fprint_type :: proc(fd: os.Handle, info: ^TypeInfo) { fprint_type :: proc(fd: os.Handle, info: ^TypeInfo) {
data: [_BUFFER_SIZE]byte; data: [_BUFFER_SIZE]u8;
buf := make_string_buffer_from_slice(data[0..<0]); buf := make_string_buffer_from_slice(data[0..<0]);
write_type(&buf, info); write_type(&buf, info);
os.write(fd, string_buffer_data(buf)); os.write(fd, string_buffer_data(buf));
@@ -204,6 +204,8 @@ write_type :: proc(buf: ^StringBuffer, ti: ^TypeInfo) {
write_string(buf, info.signed ? "i" : "u"); write_string(buf, info.signed ? "i" : "u");
write_int(buf, i64(8*info.size), 10); write_int(buf, i64(8*info.size), 10);
} }
case Rune:
write_string(buf, "rune");
case Float: case Float:
match info.size { match info.size {
case 2: write_string(buf, "f16"); case 2: write_string(buf, "f16");
@@ -500,7 +502,7 @@ fmt_write_padding :: proc(fi: ^FmtInfo, width: int) {
if width <= 0 { if width <= 0 {
return; return;
} }
pad_byte: byte = '0'; pad_byte: u8 = '0';
if fi.space { if fi.space {
pad_byte = ' '; pad_byte = ' ';
} }
@@ -549,7 +551,7 @@ _fmt_int :: proc(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: in
panic("_fmt_int: unknown base, whoops"); panic("_fmt_int: unknown base, whoops");
} }
buf: [256]byte; buf: [256]u8;
start := 0; start := 0;
@@ -560,7 +562,7 @@ _fmt_int :: proc(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: in
s := strconv.append_bits(buf[start..<start], u128(u), base, is_signed, bit_size, digits, flags); s := strconv.append_bits(buf[start..<start], u128(u), base, is_signed, bit_size, digits, flags);
if fi.hash && fi.zero { if fi.hash && fi.zero {
c: byte; c: u8;
match base { match base {
case 2: c = 'b'; case 2: c = 'b';
case 8: c = 'o'; case 8: c = 'o';
@@ -583,8 +585,13 @@ _fmt_int :: proc(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: in
immutable __DIGITS_LOWER := "0123456789abcdefx"; immutable __DIGITS_LOWER := "0123456789abcdefx";
immutable __DIGITS_UPPER := "0123456789ABCDEFX"; immutable __DIGITS_UPPER := "0123456789ABCDEFX";
fmt_rune :: proc(fi: ^FmtInfo, r: rune) { fmt_rune :: proc(fi: ^FmtInfo, r: rune, verb: rune) {
write_rune(fi.buf, r); match verb {
case 'c', 'r', 'v':
write_rune(fi.buf, r);
case:
fmt_bad_verb(fi, verb);
}
} }
fmt_int :: proc(fi: ^FmtInfo, u: u128, is_signed: bool, bit_size: int, verb: rune) { fmt_int :: proc(fi: ^FmtInfo, u: u128, is_signed: bool, bit_size: int, verb: rune) {
@@ -596,7 +603,7 @@ fmt_int :: proc(fi: ^FmtInfo, u: u128, is_signed: bool, bit_size: int, verb: run
case 'x': _fmt_int(fi, u, 16, is_signed, bit_size, __DIGITS_LOWER); case 'x': _fmt_int(fi, u, 16, is_signed, bit_size, __DIGITS_LOWER);
case 'X': _fmt_int(fi, u, 16, is_signed, bit_size, __DIGITS_UPPER); case 'X': _fmt_int(fi, u, 16, is_signed, bit_size, __DIGITS_UPPER);
case 'c', 'r': case 'c', 'r':
fmt_rune(fi, rune(u)); fmt_rune(fi, rune(u), verb);
case 'U': case 'U':
r := rune(u); r := rune(u);
if r < 0 || r > utf8.MAX_RUNE { if r < 0 || r > utf8.MAX_RUNE {
@@ -637,7 +644,7 @@ fmt_float :: proc(fi: ^FmtInfo, v: f64, bit_size: int, verb: rune) {
prec = fi.prec; prec = fi.prec;
} }
buf: [386]byte; buf: [386]u8;
str := strconv.append_float(buf[1..<1], v, 'f', prec, bit_size); str := strconv.append_float(buf[1..<1], v, 'f', prec, bit_size);
str = string(buf[0..len(str)]); str = string(buf[0..len(str)]);
if str[1] == '+' || str[1] == '-' { if str[1] == '+' || str[1] == '-' {
@@ -729,6 +736,7 @@ fmt_enum :: proc(fi: ^FmtInfo, v: any, verb: rune) {
ok := false; ok := false;
a := any{v.data, type_info_base(e.base)}; a := any{v.data, type_info_base(e.base)};
match v in a { match v in a {
case rune: i = i128(v);
case i8: i = i128(v); case i8: i = i128(v);
case i16: i = i128(v); case i16: i = i128(v);
case i32: i = i128(v); case i32: i = i128(v);
@@ -801,7 +809,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
} }
write_string(fi.buf, b.names[i]); write_string(fi.buf, b.names[i]);
write_string(fi.buf, " = "); write_string(fi.buf, " = ");
data := ^byte(v.data) + b.offsets[i]; data := ^u8(v.data) + b.offsets[i];
fmt_arg(fi, any{rawptr(data), b.types[i]}, 'v'); fmt_arg(fi, any{rawptr(data), b.types[i]}, 'v');
} }
write_byte(fi.buf, '}'); write_byte(fi.buf, '}');
@@ -812,6 +820,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
case Boolean: fmt_arg(fi, v, verb); case Boolean: fmt_arg(fi, v, verb);
case Integer: fmt_arg(fi, v, verb); case Integer: fmt_arg(fi, v, verb);
case Rune: fmt_arg(fi, v, verb);
case Float: fmt_arg(fi, v, verb); case Float: fmt_arg(fi, v, verb);
case Complex: fmt_arg(fi, v, verb); case Complex: fmt_arg(fi, v, verb);
case String: fmt_arg(fi, v, verb); case String: fmt_arg(fi, v, verb);
@@ -833,7 +842,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
if i > 0 { if i > 0 {
write_string(fi.buf, ", "); write_string(fi.buf, ", ");
} }
data := ^byte(v.data) + i*info.elem_size; data := ^u8(v.data) + i*info.elem_size;
fmt_arg(fi, any{rawptr(data), info.elem}, verb); fmt_arg(fi, any{rawptr(data), info.elem}, verb);
} }
@@ -845,14 +854,14 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
if i > 0 { if i > 0 {
write_string(fi.buf, ", "); write_string(fi.buf, ", ");
} }
data := ^byte(array.data) + i*info.elem_size; data := ^u8(array.data) + i*info.elem_size;
fmt_arg(fi, any{rawptr(data), info.elem}, verb); fmt_arg(fi, any{rawptr(data), info.elem}, verb);
} }
case Slice: case Slice:
write_byte(fi.buf, '['); write_byte(fi.buf, '[');
defer write_byte(fi.buf, ']'); defer write_byte(fi.buf, ']');
slice := ^[]byte(v.data); slice := ^[]u8(v.data);
for _, i in slice { for _, i in slice {
if i > 0 { if i > 0 {
write_string(fi.buf, ", "); write_string(fi.buf, ", ");
@@ -870,7 +879,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
write_string(fi.buf, ", "); write_string(fi.buf, ", ");
} }
data := ^byte(v.data) + i*info.elem_size; data := ^u8(v.data) + i*info.elem_size;
fmt_value(fi, any{rawptr(data), info.elem}, verb); fmt_value(fi, any{rawptr(data), info.elem}, verb);
} }
@@ -892,7 +901,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
if i > 0 { if i > 0 {
write_string(fi.buf, ", "); write_string(fi.buf, ", ");
} }
data := ^byte(entries.data) + i*entry_size; data := ^u8(entries.data) + i*entry_size;
header := ^__MapEntryHeader(data); header := ^__MapEntryHeader(data);
if types.is_string(info.key) { if types.is_string(info.key) {
@@ -920,7 +929,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
} }
write_string(fi.buf, info.names[i]); write_string(fi.buf, info.names[i]);
write_string(fi.buf, " = "); write_string(fi.buf, " = ");
data := ^byte(v.data) + info.offsets[i]; data := ^u8(v.data) + info.offsets[i];
fmt_value(fi, any{rawptr(data), info.types[i]}, 'v'); fmt_value(fi, any{rawptr(data), info.types[i]}, 'v');
} }
@@ -936,7 +945,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
} }
write_string(fi.buf, cf.names[i]); write_string(fi.buf, cf.names[i]);
write_string(fi.buf, " = "); write_string(fi.buf, " = ");
data := ^byte(v.data) + cf.offsets[i]; data := ^u8(v.data) + cf.offsets[i];
fmt_value(fi, any{rawptr(data), cf.types[i]}, 'v'); fmt_value(fi, any{rawptr(data), cf.types[i]}, 'v');
} }
@@ -999,8 +1008,9 @@ fmt_arg :: proc(fi: ^FmtInfo, arg: any, verb: rune) {
base_arg := arg; base_arg := arg;
base_arg.type_info = type_info_base(base_arg.type_info); base_arg.type_info = type_info_base(base_arg.type_info);
match a in base_arg { match a in base_arg {
case any: fmt_arg(fi, a, verb); case any: fmt_arg(fi, a, verb);
case bool: fmt_bool(fi, a, verb); case bool: fmt_bool(fi, a, verb);
case rune: fmt_rune(fi, a, verb);
case f32: fmt_float(fi, f64(a), 32, verb); case f32: fmt_float(fi, f64(a), 32, verb);
case f64: fmt_float(fi, a, 64, verb); case f64: fmt_float(fi, a, 64, verb);
core/hash.odin
+8 -8
View File
@@ -1,11 +1,11 @@
crc32 :: proc(data: []byte) -> u32 { crc32 :: proc(data: []u8) -> u32 {
result := ~u32(0); result := ~u32(0);
for b in data { for b in data {
result = result>>8 ~ _crc32_table[(result ~ u32(b)) & 0xff]; result = result>>8 ~ _crc32_table[(result ~ u32(b)) & 0xff];
} }
return ~result; return ~result;
} }
crc64 :: proc(data: []byte) -> u64 { crc64 :: proc(data: []u8) -> u64 {
result := ~u64(0); result := ~u64(0);
for b in data { for b in data {
result = result>>8 ~ _crc64_table[(result ~ u64(b)) & 0xff]; result = result>>8 ~ _crc64_table[(result ~ u64(b)) & 0xff];
@@ -13,7 +13,7 @@ crc64 :: proc(data: []byte) -> u64 {
return ~result; return ~result;
} }
fnv32 :: proc(data: []byte) -> u32 { fnv32 :: proc(data: []u8) -> u32 {
h: u32 = 0x811c9dc5; h: u32 = 0x811c9dc5;
for b in data { for b in data {
h = (h * 0x01000193) ~ u32(b); h = (h * 0x01000193) ~ u32(b);
@@ -21,7 +21,7 @@ fnv32 :: proc(data: []byte) -> u32 {
return h; return h;
} }
fnv64 :: proc(data: []byte) -> u64 { fnv64 :: proc(data: []u8) -> u64 {
h: u64 = 0xcbf29ce484222325; h: u64 = 0xcbf29ce484222325;
for b in data { for b in data {
h = (h * 0x100000001b3) ~ u64(b); h = (h * 0x100000001b3) ~ u64(b);
@@ -29,7 +29,7 @@ fnv64 :: proc(data: []byte) -> u64 {
return h; return h;
} }
fnv32a :: proc(data: []byte) -> u32 { fnv32a :: proc(data: []u8) -> u32 {
h: u32 = 0x811c9dc5; h: u32 = 0x811c9dc5;
for b in data { for b in data {
h = (h ~ u32(b)) * 0x01000193; h = (h ~ u32(b)) * 0x01000193;
@@ -37,7 +37,7 @@ fnv32a :: proc(data: []byte) -> u32 {
return h; return h;
} }
fnv64a :: proc(data: []byte) -> u64 { fnv64a :: proc(data: []u8) -> u64 {
h: u64 = 0xcbf29ce484222325; h: u64 = 0xcbf29ce484222325;
for b in data { for b in data {
h = (h ~ u64(b)) * 0x100000001b3; h = (h ~ u64(b)) * 0x100000001b3;
@@ -45,7 +45,7 @@ fnv64a :: proc(data: []byte) -> u64 {
return h; return h;
} }
murmur32 :: proc(data: []byte) -> u32 { murmur32 :: proc(data: []u8) -> u32 {
c1_32: u32 : 0xcc9e2d51; c1_32: u32 : 0xcc9e2d51;
c2_32: u32 : 0x1b873593; c2_32: u32 : 0x1b873593;
@@ -95,7 +95,7 @@ murmur32 :: proc(data: []byte) -> u32 {
return h1; return h1;
} }
murmur64 :: proc(data: []byte) -> u64 { murmur64 :: proc(data: []u8) -> u64 {
SEED :: 0x9747b28c; SEED :: 0x9747b28c;
when size_of(int) == 8 { when size_of(int) == 8 {
core/mem.odin
+4 -4
View File
@@ -18,7 +18,7 @@ copy :: proc(dst, src: rawptr, len: int) -> rawptr {
copy_non_overlapping :: proc(dst, src: rawptr, len: int) -> rawptr { copy_non_overlapping :: proc(dst, src: rawptr, len: int) -> rawptr {
return __mem_copy_non_overlapping(dst, src, len); return __mem_copy_non_overlapping(dst, src, len);
} }
compare :: proc(a, b: []byte) -> int { compare :: proc(a, b: []u8) -> int {
return __mem_compare(&a[0], &b[0], min(len(a), len(b))); return __mem_compare(&a[0], &b[0], min(len(a), len(b)));
} }
@@ -81,7 +81,7 @@ allocation_header :: proc(data: rawptr) -> ^AllocationHeader {
Arena :: struct { Arena :: struct {
backing: Allocator, backing: Allocator,
offset: int, offset: int,
memory: []byte, memory: []u8,
temp_count: int, temp_count: int,
} }
@@ -94,7 +94,7 @@ ArenaTempMemory :: struct {
init_arena_from_memory :: proc(using a: ^Arena, data: []byte) { init_arena_from_memory :: proc(using a: ^Arena, data: []u8) {
backing = Allocator{}; backing = Allocator{};
memory = data[0..<0]; memory = data[0..<0];
temp_count = 0; temp_count = 0;
@@ -102,7 +102,7 @@ init_arena_from_memory :: proc(using a: ^Arena, data: []byte) {
init_arena_from_context :: proc(using a: ^Arena, size: int) { init_arena_from_context :: proc(using a: ^Arena, size: int) {
backing = context.allocator; backing = context.allocator;
memory = make([]byte, size); memory = make([]u8, size);
temp_count = 0; temp_count = 0;
} }
core/opengl.odin
+5 -5
View File
@@ -23,7 +23,7 @@ Ortho :: proc(left, right, bottom, top, near, far: f64) #foreign lib "gl
Color3f :: proc(r, g, b: f32) #foreign lib "glColor3f"; Color3f :: proc(r, g, b: f32) #foreign lib "glColor3f";
Vertex3f :: proc(x, y, z: f32) #foreign lib "glVertex3f"; Vertex3f :: proc(x, y, z: f32) #foreign lib "glVertex3f";
GetError :: proc() -> i32 #foreign lib "glGetError"; GetError :: proc() -> i32 #foreign lib "glGetError";
GetString :: proc(name: i32) -> ^byte #foreign lib "glGetString"; GetString :: proc(name: i32) -> ^u8 #foreign lib "glGetString";
GetIntegerv :: proc(name: i32, v: ^i32) #foreign lib "glGetIntegerv"; GetIntegerv :: proc(name: i32, v: ^i32) #foreign lib "glGetIntegerv";
TexCoord2f :: proc(x, y: f32) #foreign lib "glTexCoord2f"; TexCoord2f :: proc(x, y: f32) #foreign lib "glTexCoord2f";
TexImage2D :: proc(target, level, internal_format, TexImage2D :: proc(target, level, internal_format,
@@ -69,7 +69,7 @@ VertexAttribPointer: proc(index: u32, size, type_: i32, normalized: i32, st
EnableVertexAttribArray: proc(index: u32) #cc_c; EnableVertexAttribArray: proc(index: u32) #cc_c;
CreateShader: proc(shader_type: i32) -> u32 #cc_c; CreateShader: proc(shader_type: i32) -> u32 #cc_c;
ShaderSource: proc(shader: u32, count: u32, str: ^^byte, length: ^i32) #cc_c; ShaderSource: proc(shader: u32, count: u32, str: ^^u8, length: ^i32) #cc_c;
CompileShader: proc(shader: u32) #cc_c; CompileShader: proc(shader: u32) #cc_c;
CreateProgram: proc() -> u32 #cc_c; CreateProgram: proc() -> u32 #cc_c;
AttachShader: proc(program, shader: u32) #cc_c; AttachShader: proc(program, shader: u32) #cc_c;
@@ -82,8 +82,8 @@ DeleteProgram: proc(program: u32) #cc_c;
GetShaderiv: proc(shader: u32, pname: i32, params: ^i32) #cc_c; GetShaderiv: proc(shader: u32, pname: i32, params: ^i32) #cc_c;
GetProgramiv: proc(program: u32, pname: i32, params: ^i32) #cc_c; GetProgramiv: proc(program: u32, pname: i32, params: ^i32) #cc_c;
GetShaderInfoLog: proc(shader: u32, max_length: u32, length: ^u32, info_long: ^byte) #cc_c; GetShaderInfoLog: proc(shader: u32, max_length: u32, length: ^u32, info_long: ^u8) #cc_c;
GetProgramInfoLog: proc(program: u32, max_length: u32, length: ^u32, info_long: ^byte) #cc_c; GetProgramInfoLog: proc(program: u32, max_length: u32, length: ^u32, info_long: ^u8) #cc_c;
ActiveTexture: proc(texture: i32) #cc_c; ActiveTexture: proc(texture: i32) #cc_c;
GenerateMipmap: proc(target: i32) #cc_c; GenerateMipmap: proc(target: i32) #cc_c;
@@ -106,7 +106,7 @@ Uniform3f: proc(loc: i32, v0, v1, v2: f32) #cc_c;
Uniform4f: proc(loc: i32, v0, v1, v2, v3: f32) #cc_c; Uniform4f: proc(loc: i32, v0, v1, v2, v3: f32) #cc_c;
UniformMatrix4fv: proc(loc: i32, count: u32, transpose: i32, value: ^f32) #cc_c; UniformMatrix4fv: proc(loc: i32, count: u32, transpose: i32, value: ^f32) #cc_c;
GetUniformLocation: proc(program: u32, name: ^byte) -> i32 #cc_c; GetUniformLocation: proc(program: u32, name: ^u8) -> i32 #cc_c;
init :: proc() { init :: proc() {
set_proc_address :: proc(p: rawptr, name: string) #inline { set_proc_address :: proc(p: rawptr, name: string) #inline {
core/os.odin
+4 -4
View File
@@ -3,10 +3,10 @@
#load "os_linux.odin" when ODIN_OS == "linux"; #load "os_linux.odin" when ODIN_OS == "linux";
write_string :: proc(fd: Handle, str: string) -> (int, Errno) { write_string :: proc(fd: Handle, str: string) -> (int, Errno) {
return write(fd, []byte(str)); return write(fd, []u8(str));
} }
read_entire_file :: proc(name: string) -> ([]byte, bool) { read_entire_file :: proc(name: string) -> ([]u8, bool) {
fd, err := open(name, O_RDONLY, 0); fd, err := open(name, O_RDONLY, 0);
if err != 0 { if err != 0 {
return nil, false; return nil, false;
@@ -22,7 +22,7 @@ read_entire_file :: proc(name: string) -> ([]byte, bool) {
return nil, true; return nil, true;
} }
data := make([]byte, length); data := make([]u8, length);
if data == nil { if data == nil {
return nil, false; return nil, false;
} }
@@ -35,7 +35,7 @@ read_entire_file :: proc(name: string) -> ([]byte, bool) {
return data[0..<bytes_read], true; return data[0..<bytes_read], true;
} }
write_entire_file :: proc(name: string, data: []byte) -> bool { write_entire_file :: proc(name: string, data: []u8) -> bool {
fd, err := open(name, O_WRONLY, 0); fd, err := open(name, O_WRONLY, 0);
if err != 0 { if err != 0 {
return false; return false;
core/os_linux.odin
+3 -3
View File
@@ -164,12 +164,12 @@ close :: proc(fd: Handle) {
_unix_close(fd); _unix_close(fd);
} }
read :: proc(fd: Handle, data: []byte) -> (int, Errno) { read :: proc(fd: Handle, data: []u8) -> (int, Errno) {
sz := _unix_read(fd, &data[0], len(data)); sz := _unix_read(fd, &data[0], len(data));
return sz, 0; return sz, 0;
} }
write :: proc(fd: Handle, data: []byte) -> (int, Errno) { write :: proc(fd: Handle, data: []u8) -> (int, Errno) {
sz := _unix_write(fd, &data[0], len(data)); sz := _unix_write(fd, &data[0], len(data));
return sz, 0; return sz, 0;
} }
@@ -213,7 +213,7 @@ access :: proc(path: string, mask: int) -> bool #inline {
// read_entire_file :: proc(name: string) -> ([]byte, bool) { // read_entire_file :: proc(name: string) -> ([]u8, bool) {
// fd: Handle; // fd: Handle;
// err: Errno; // err: Errno;
// size: i64; // size: i64;
core/os_windows.odin
+17 -17
View File
@@ -93,8 +93,8 @@ open :: proc(path: string, mode: int, perm: u32) -> (Handle, Errno) {
create_mode = win32.OPEN_EXISTING; create_mode = win32.OPEN_EXISTING;
} }
buf: [300]byte; buf: [300]u8;
copy(buf[..], []byte(path)); copy(buf[..], []u8(path));
handle := Handle(win32.create_file_a(&buf[0], access, share_mode, sa, create_mode, win32.FILE_ATTRIBUTE_NORMAL, nil)); handle := Handle(win32.create_file_a(&buf[0], access, share_mode, sa, create_mode, win32.FILE_ATTRIBUTE_NORMAL, nil));
if handle != INVALID_HANDLE { if handle != INVALID_HANDLE {
@@ -109,7 +109,7 @@ close :: proc(fd: Handle) {
} }
write :: proc(fd: Handle, data: []byte) -> (int, Errno) { write :: proc(fd: Handle, data: []u8) -> (int, Errno) {
if len(data) == 0 { if len(data) == 0 {
return 0, ERROR_NONE; return 0, ERROR_NONE;
} }
@@ -136,7 +136,7 @@ write :: proc(fd: Handle, data: []byte) -> (int, Errno) {
return int(total_write), ERROR_NONE; return int(total_write), ERROR_NONE;
} }
read :: proc(fd: Handle, data: []byte) -> (int, Errno) { read :: proc(fd: Handle, data: []u8) -> (int, Errno) {
if len(data) == 0 { if len(data) == 0 {
return 0, ERROR_NONE; return 0, ERROR_NONE;
} }
@@ -225,11 +225,11 @@ last_write_time :: proc(fd: Handle) -> FileTime {
last_write_time_by_name :: proc(name: string) -> FileTime { last_write_time_by_name :: proc(name: string) -> FileTime {
last_write_time: win32.Filetime; last_write_time: win32.Filetime;
data: win32.FileAttributeData; data: win32.FileAttributeData;
buf: [1024]byte; buf: [1024]u8;
assert(len(buf) > len(name)); assert(len(buf) > len(name));
copy(buf[..], []byte(name)); copy(buf[..], []u8(name));
if win32.get_file_attributes_ex_a(&buf[0], win32.GetFileExInfoStandard, &data) != 0 { if win32.get_file_attributes_ex_a(&buf[0], win32.GetFileExInfoStandard, &data) != 0 {
last_write_time = data.last_write_time; last_write_time = data.last_write_time;
@@ -283,7 +283,7 @@ _alloc_command_line_arguments :: proc() -> []string {
wstr_len++; wstr_len++;
} }
len := 2*wstr_len-1; len := 2*wstr_len-1;
buf := make([]byte, len+1); buf := make([]u8, len+1);
str := slice_ptr(wstr, wstr_len+1); str := slice_ptr(wstr, wstr_len+1);
i, j := 0, 0; i, j := 0, 0;
@@ -293,24 +293,24 @@ _alloc_command_line_arguments :: proc() -> []string {
if i+1 > len { if i+1 > len {
return ""; return "";
} }
buf[i] = byte(str[j]); i++; buf[i] = u8(str[j]); i++;
j++; j++;
case str[j] < 0x800: case str[j] < 0x800:
if i+2 > len { if i+2 > len {
return ""; return "";
} }
buf[i] = byte(0xc0 + (str[j]>>6)); i++; buf[i] = u8(0xc0 + (str[j]>>6)); i++;
buf[i] = byte(0x80 + (str[j]&0x3f)); i++; buf[i] = u8(0x80 + (str[j]&0x3f)); i++;
j++; j++;
case 0xd800 <= str[j] && str[j] < 0xdc00: case 0xd800 <= str[j] && str[j] < 0xdc00:
if i+4 > len { if i+4 > len {
return ""; return "";
} }
c := rune((str[j] - 0xd800) << 10) + rune((str[j+1]) - 0xdc00) + 0x10000; c := rune((str[j] - 0xd800) << 10) + rune((str[j+1]) - 0xdc00) + 0x10000;
buf[i] = byte(0xf0 + (c >> 18)); i++; buf[i] = u8(0xf0 + (c >> 18)); i++;
buf[i] = byte(0x80 + ((c >> 12) & 0x3f)); i++; buf[i] = u8(0x80 + ((c >> 12) & 0x3f)); i++;
buf[i] = byte(0x80 + ((c >> 6) & 0x3f)); i++; buf[i] = u8(0x80 + ((c >> 6) & 0x3f)); i++;
buf[i] = byte(0x80 + ((c ) & 0x3f)); i++; buf[i] = u8(0x80 + ((c ) & 0x3f)); i++;
j += 2; j += 2;
case 0xdc00 <= str[j] && str[j] < 0xe000: case 0xdc00 <= str[j] && str[j] < 0xe000:
return ""; return "";
@@ -318,9 +318,9 @@ _alloc_command_line_arguments :: proc() -> []string {
if i+3 > len { if i+3 > len {
return ""; return "";
} }
buf[i] = 0xe0 + byte (str[j] >> 12); i++; buf[i] = 0xe0 + u8 (str[j] >> 12); i++;
buf[i] = 0x80 + byte((str[j] >> 6) & 0x3f); i++; buf[i] = 0x80 + u8((str[j] >> 6) & 0x3f); i++;
buf[i] = 0x80 + byte((str[j] ) & 0x3f); i++; buf[i] = 0x80 + u8((str[j] ) & 0x3f); i++;
j++; j++;
} }
} }
core/os_x.odin
+3 -3
View File
@@ -166,7 +166,7 @@ close :: proc(fd: Handle) {
unix_close(fd); unix_close(fd);
} }
write :: proc(fd: Handle, data: []byte) -> (AddressSize, Errno) { write :: proc(fd: Handle, data: []u8) -> (AddressSize, Errno) {
assert(fd != -1); assert(fd != -1);
bytes_written := unix_write(fd, &data[0], len(data)); bytes_written := unix_write(fd, &data[0], len(data));
@@ -176,7 +176,7 @@ write :: proc(fd: Handle, data: []byte) -> (AddressSize, Errno) {
return bytes_written, 0; return bytes_written, 0;
} }
read :: proc(fd: Handle, data: []byte) -> (AddressSize, Errno) { read :: proc(fd: Handle, data: []u8) -> (AddressSize, Errno) {
assert(fd != -1); assert(fd != -1);
bytes_read := unix_read(fd, &data[0], len(data)); bytes_read := unix_read(fd, &data[0], len(data));
@@ -229,7 +229,7 @@ access :: proc(path: string, mask: int) -> bool #inline {
return unix_access(cstr, mask) == 0; return unix_access(cstr, mask) == 0;
} }
// read_entire_file :: proc(name: string) -> ([]byte, bool) { // read_entire_file :: proc(name: string) -> ([]u8, bool) {
// handle, err := open_simple(name, O_RDONLY); // handle, err := open_simple(name, O_RDONLY);
// if(err != 0) { // if(err != 0) {
core/raw.odin
+1 -1
View File
@@ -4,7 +4,7 @@ Any :: struct #ordered {
} }
String :: struct #ordered { String :: struct #ordered {
data: ^byte, data: ^u8,
len: int, len: int,
}; };
core/strconv.odin
+16 -16
View File
@@ -189,21 +189,21 @@ parse_f64 :: proc(s: string) -> f64 {
} }
append_bool :: proc(buf: []byte, b: bool) -> string { append_bool :: proc(buf: []u8, b: bool) -> string {
s := b ? "true" : "false"; s := b ? "true" : "false";
append(buf, ..[]byte(s)); append(buf, ..[]u8(s));
return string(buf); return string(buf);
} }
append_uint :: proc(buf: []byte, u: u64, base: int) -> string { append_uint :: proc(buf: []u8, u: u64, base: int) -> string {
return append_bits(buf, u128(u), base, false, 8*size_of(uint), digits, 0); return append_bits(buf, u128(u), base, false, 8*size_of(uint), digits, 0);
} }
append_int :: proc(buf: []byte, i: i64, base: int) -> string { append_int :: proc(buf: []u8, i: i64, base: int) -> string {
return append_bits(buf, u128(i), base, true, 8*size_of(int), digits, 0); return append_bits(buf, u128(i), base, true, 8*size_of(int), digits, 0);
} }
itoa :: proc(buf: []byte, i: int) -> string { return append_int(buf, i64(i), 10); } itoa :: proc(buf: []u8, i: int) -> string { return append_int(buf, i64(i), 10); }
append_float :: proc(buf: []byte, f: f64, fmt: byte, prec, bit_size: int) -> string { append_float :: proc(buf: []u8, f: f64, fmt: u8, prec, bit_size: int) -> string {
return string(generic_ftoa(buf, f, fmt, prec, bit_size)); return string(generic_ftoa(buf, f, fmt, prec, bit_size));
} }
@@ -211,7 +211,7 @@ append_float :: proc(buf: []byte, f: f64, fmt: byte, prec, bit_size: int) -> str
DecimalSlice :: struct { DecimalSlice :: struct {
digits: []byte, digits: []u8,
count: int, count: int,
decimal_point: int, decimal_point: int,
neg: bool, neg: bool,
@@ -228,7 +228,7 @@ _f32_info := Float_Info{23, 8, -127};
_f64_info := Float_Info{52, 11, -1023}; _f64_info := Float_Info{52, 11, -1023};
generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, prec, bit_size: int) -> []byte { generic_ftoa :: proc(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8 {
bits: u64; bits: u64;
flt: ^Float_Info; flt: ^Float_Info;
match bit_size { match bit_size {
@@ -256,7 +256,7 @@ generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, prec, bit_size: int) -> [
} else { } else {
s = "+Inf"; s = "+Inf";
} }
append(buf, ..[]byte(s)); append(buf, ..[]u8(s));
return buf; return buf;
case 0: // denormalized case 0: // denormalized
@@ -300,7 +300,7 @@ generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, prec, bit_size: int) -> [
format_digits :: proc(buf: []byte, shortest: bool, neg: bool, digs: DecimalSlice, prec: int, fmt: byte) -> []byte { format_digits :: proc(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice, prec: int, fmt: u8) -> []u8 {
match fmt { match fmt {
case 'f', 'F': case 'f', 'F':
append(buf, neg ? '-' : '+'); append(buf, neg ? '-' : '+');
@@ -321,7 +321,7 @@ format_digits :: proc(buf: []byte, shortest: bool, neg: bool, digs: DecimalSlice
if prec > 0 { if prec > 0 {
append(buf, '.'); append(buf, '.');
for i in 0..<prec { for i in 0..<prec {
c: byte = '0'; c: u8 = '0';
if j := digs.decimal_point + i; 0 <= j && j < digs.count { if j := digs.decimal_point + i; 0 <= j && j < digs.count {
c = digs.digits[j]; c = digs.digits[j];
} }
@@ -340,7 +340,7 @@ format_digits :: proc(buf: []byte, shortest: bool, neg: bool, digs: DecimalSlice
return buf; // TODO return buf; // TODO
} }
c: [2]byte; c: [2]u8;
c[0] = '%'; c[0] = '%';
c[1] = fmt; c[1] = fmt;
append(buf, ..c[..]); append(buf, ..c[..]);
@@ -385,12 +385,12 @@ round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
inclusive := mant%2 == 0; inclusive := mant%2 == 0;
for i in 0..<d.count { for i in 0..<d.count {
l: byte = '0'; // lower digit l: u8 = '0'; // lower digit
if i < lower.count { if i < lower.count {
l = lower.digits[i]; l = lower.digits[i];
} }
m := d.digits[i]; // middle digit m := d.digits[i]; // middle digit
u: byte = '0'; // upper digit u: u8 = '0'; // upper digit
if i < upper.count { if i < upper.count {
u = upper.digits[i]; u = upper.digits[i];
} }
@@ -454,12 +454,12 @@ is_integer_negative :: proc(u: u128, is_signed: bool, bit_size: int) -> (unsigne
return u, neg; return u, neg;
} }
append_bits :: proc(buf: []byte, u_: u128, base: int, is_signed: bool, bit_size: int, digits: string, flags: IntFlag) -> string { append_bits :: proc(buf: []u8, u_: u128, base: int, is_signed: bool, bit_size: int, digits: string, flags: IntFlag) -> string {
if base < 2 || base > MAX_BASE { if base < 2 || base > MAX_BASE {
panic("strconv: illegal base passed to append_bits"); panic("strconv: illegal base passed to append_bits");
} }
a: [129]byte; a: [129]u8;
i := len(a); i := len(a);
u, neg := is_integer_negative(u_, is_signed, bit_size); u, neg := is_integer_negative(u_, is_signed, bit_size);
b := u128(base); b := u128(base);
core/strings.odin
+4 -4
View File
@@ -1,11 +1,11 @@
new_c_string :: proc(s: string) -> ^byte { new_c_string :: proc(s: string) -> ^u8 {
c := make([]byte, len(s)+1); c := make([]u8, len(s)+1);
copy(c, []byte(s)); copy(c, []u8(s));
c[len(s)] = 0; c[len(s)] = 0;
return &c[0]; return &c[0];
} }
to_odin_string :: proc(c: ^byte) -> string { to_odin_string :: proc(c: ^u8) -> string {
len := 0; len := 0;
for (c+len)^ != 0 { for (c+len)^ != 0 {
len++; len++;
core/sys/wgl.odin
+22 -22
View File
@@ -16,26 +16,26 @@ LayerPlaneDescriptor :: struct {
size: u16, size: u16,
version: u16, version: u16,
flags: u32, flags: u32,
pixel_type: byte, pixel_type: u8,
color_bits: byte, color_bits: u8,
red_bits: byte, red_bits: u8,
red_shift: byte, red_shift: u8,
green_bits: byte, green_bits: u8,
green_shift: byte, green_shift: u8,
blue_bits: byte, blue_bits: u8,
blue_shift: byte, blue_shift: u8,
alpha_bits: byte, alpha_bits: u8,
alpha_shift: byte, alpha_shift: u8,
accum_bits: byte, accum_bits: u8,
accum_red_bits: byte, accum_red_bits: u8,
accum_green_bits: byte, accum_green_bits: u8,
accum_blue_bits: byte, accum_blue_bits: u8,
accum_alpha_bits: byte, accum_alpha_bits: u8,
depth_bits: byte, depth_bits: u8,
stencil_bits: byte, stencil_bits: u8,
aux_buffers: byte, aux_buffers: u8,
layer_type: byte, layer_type: u8,
reserved: byte, reserved: u8,
transparent: ColorRef, transparent: ColorRef,
} }
@@ -53,8 +53,8 @@ Glyph_MetricsFloat :: struct {
CreateContextAttribsARBType :: #type proc(hdc: Hdc, h_share_context: rawptr, attribList: ^i32) -> Hglrc; CreateContextAttribsARBType :: #type proc(hdc: Hdc, h_share_context: rawptr, attribList: ^i32) -> Hglrc;
ChoosePixelFormatARBType :: #type proc(hdc: Hdc, attrib_i_list: ^i32, attrib_f_list: ^f32, max_formats: u32, formats: ^i32, num_formats : ^u32) -> Bool #cc_c; ChoosePixelFormatARBType :: #type proc(hdc: Hdc, attrib_i_list: ^i32, attrib_f_list: ^f32, max_formats: u32, formats: ^i32, num_formats : ^u32) -> Bool #cc_c;
SwapIntervalEXTType :: #type proc(interval : i32) -> bool #cc_c; SwapIntervalEXTType :: #type proc(interval: i32) -> bool #cc_c;
GetExtensionsStringARBType :: #type proc(Hdc) -> ^byte #cc_c; GetExtensionsStringARBType :: #type proc(Hdc) -> ^u8 #cc_c;
create_context_attribs_arb: CreateContextAttribsARBType; create_context_attribs_arb: CreateContextAttribsARBType;
core/sys/windows.odin
+11 -11
View File
@@ -73,7 +73,7 @@ Point :: struct #ordered {
WndClassExA :: struct #ordered { WndClassExA :: struct #ordered {
size, style: u32, size, style: u32,
wndproc: WndProc, wnd_proc: WndProc,
cls_extra, wnd_extra: i32, cls_extra, wnd_extra: i32,
instance: Hinstance, instance: Hinstance,
icon: Hicon, icon: Hicon,
@@ -140,8 +140,8 @@ FindData :: struct #ordered {
file_size_low : u32, file_size_low : u32,
reserved0 : u32, reserved0 : u32,
reserved1 : u32, reserved1 : u32,
file_name : [MAX_PATH]byte, file_name : [MAX_PATH]u8,
alternate_file_name : [14]byte, alternate_file_name : [14]u8,
} }
@@ -225,7 +225,7 @@ read_file :: proc(h: Handle, buf: rawptr, to_read: u32, bytes_read: ^i32, overl
write_file :: proc(h: Handle, buf: rawptr, len: i32, written_result: ^i32, overlapped: rawptr) -> Bool #foreign kernel32 "WriteFile"; write_file :: proc(h: Handle, buf: rawptr, len: i32, written_result: ^i32, overlapped: rawptr) -> Bool #foreign kernel32 "WriteFile";
get_file_size_ex :: proc(file_handle: Handle, file_size: ^i64) -> Bool #foreign kernel32 "GetFileSizeEx"; get_file_size_ex :: proc(file_handle: Handle, file_size: ^i64) -> Bool #foreign kernel32 "GetFileSizeEx";
get_file_attributes_a :: proc(filename: ^byte) -> u32 #foreign kernel32 "GetFileAttributesA"; get_file_attributes_a :: proc(filename: ^u8) -> u32 #foreign kernel32 "GetFileAttributesA";
get_file_attributes_ex_a :: proc(filename: ^u8, info_level_id: GET_FILEEX_INFO_LEVELS, file_info: rawptr) -> Bool #foreign kernel32 "GetFileAttributesExA"; get_file_attributes_ex_a :: proc(filename: ^u8, info_level_id: GET_FILEEX_INFO_LEVELS, file_info: rawptr) -> Bool #foreign kernel32 "GetFileAttributesExA";
get_file_information_by_handle :: proc(file_handle: Handle, file_info: ^ByHandleFileInformation) -> Bool #foreign kernel32 "GetFileInformationByHandle"; get_file_information_by_handle :: proc(file_handle: Handle, file_info: ^ByHandleFileInformation) -> Bool #foreign kernel32 "GetFileInformationByHandle";
@@ -234,7 +234,7 @@ set_file_pointer :: proc(file_handle: Handle, distance_to_move: i32, distance_to
set_handle_information :: proc(obj: Handle, mask, flags: u32) -> Bool #foreign kernel32 "SetHandleInformation"; set_handle_information :: proc(obj: Handle, mask, flags: u32) -> Bool #foreign kernel32 "SetHandleInformation";
find_first_file_a :: proc(file_name : ^byte, data : ^FindData) -> Handle #foreign kernel32 "FindFirstFileA"; find_first_file_a :: proc(file_name : ^u8, data : ^FindData) -> Handle #foreign kernel32 "FindFirstFileA";
find_next_file_a :: proc(file : Handle, data : ^FindData) -> Bool #foreign kernel32 "FindNextFileA"; find_next_file_a :: proc(file : Handle, data : ^FindData) -> Bool #foreign kernel32 "FindNextFileA";
find_close :: proc(file : Handle) -> Bool #foreign kernel32 "FindClose"; find_close :: proc(file : Handle) -> Bool #foreign kernel32 "FindClose";
@@ -312,7 +312,7 @@ Security_Attributes :: struct #ordered {
INFINITE :: 0xffffffff; INFINITE :: 0xffffffff;
create_semaphore_a :: proc(attributes: ^Security_Attributes, initial_count, maximum_count: i32, name: ^byte) -> Handle #foreign kernel32 "CreateSemaphoreA"; create_semaphore_a :: proc(attributes: ^Security_Attributes, initial_count, maximum_count: i32, name: ^u8) -> Handle #foreign kernel32 "CreateSemaphoreA";
release_semaphore :: proc(semaphore: Handle, release_count: i32, previous_count: ^i32) -> Bool #foreign kernel32 "ReleaseSemaphore"; release_semaphore :: proc(semaphore: Handle, release_count: i32, previous_count: ^i32) -> Bool #foreign kernel32 "ReleaseSemaphore";
wait_for_single_object :: proc(handle: Handle, milliseconds: u32) -> u32 #foreign kernel32 "WaitForSingleObject"; wait_for_single_object :: proc(handle: Handle, milliseconds: u32) -> u32 #foreign kernel32 "WaitForSingleObject";
@@ -383,7 +383,7 @@ get_window_rect :: proc(wnd: Hwnd, rect: ^Rect) -> Bool
get_window_long_ptr_a :: proc(wnd: Hwnd, index: i32) -> i64 #foreign user32 "GetWindowLongPtrA"; get_window_long_ptr_a :: proc(wnd: Hwnd, index: i32) -> i64 #foreign user32 "GetWindowLongPtrA";
set_window_long_ptr_a :: proc(wnd: Hwnd, index: i32, new: i64) -> i64 #foreign user32 "SetWindowLongPtrA"; set_window_long_ptr_a :: proc(wnd: Hwnd, index: i32, new: i64) -> i64 #foreign user32 "SetWindowLongPtrA";
get_window_text :: proc(wnd: Hwnd, str: ^byte, maxCount: i32) -> i32 #foreign user32 "GetWindowText"; get_window_text :: proc(wnd: Hwnd, str: ^u8, maxCount: i32) -> i32 #foreign user32 "GetWindowText";
HIWORD :: proc(wParam: Wparam) -> u16 { return u16((u32(wParam) >> 16) & 0xffff); } HIWORD :: proc(wParam: Wparam) -> u16 { return u16((u32(wParam) >> 16) & 0xffff); }
HIWORD :: proc(lParam: Lparam) -> u16 { return u16((u32(lParam) >> 16) & 0xffff); } HIWORD :: proc(lParam: Lparam) -> u16 { return u16((u32(lParam) >> 16) & 0xffff); }
@@ -416,7 +416,7 @@ BitmapInfo :: struct #ordered {
} }
RgbQuad :: struct #ordered { blue, green, red, reserved: byte } RgbQuad :: struct #ordered { blue, green, red, reserved: u8 }
BI_RGB :: 0; BI_RGB :: 0;
DIB_RGB_COLORS :: 0x00; DIB_RGB_COLORS :: 0x00;
@@ -486,18 +486,18 @@ PixelFormatDescriptor :: struct #ordered {
stencil_bits, stencil_bits,
aux_buffers, aux_buffers,
layer_type, layer_type,
reserved: byte, reserved: u8,
layer_mask, layer_mask,
visible_mask, visible_mask,
damage_mask: u32, damage_mask: u32,
} }
get_d_c :: proc(h: Hwnd) -> Hdc #foreign user32 "GetDC"; get_dc :: proc(h: Hwnd) -> Hdc #foreign user32 "GetDC";
set_pixel_format :: proc(hdc: Hdc, pixel_format: i32, pfd: ^PixelFormatDescriptor) -> Bool #foreign gdi32 "SetPixelFormat"; set_pixel_format :: proc(hdc: Hdc, pixel_format: i32, pfd: ^PixelFormatDescriptor) -> Bool #foreign gdi32 "SetPixelFormat";
choose_pixel_format :: proc(hdc: Hdc, pfd: ^PixelFormatDescriptor) -> i32 #foreign gdi32 "ChoosePixelFormat"; choose_pixel_format :: proc(hdc: Hdc, pfd: ^PixelFormatDescriptor) -> i32 #foreign gdi32 "ChoosePixelFormat";
swap_buffers :: proc(hdc: Hdc) -> Bool #foreign gdi32 "SwapBuffers"; swap_buffers :: proc(hdc: Hdc) -> Bool #foreign gdi32 "SwapBuffers";
release_d_c :: proc(wnd: Hwnd, hdc: Hdc) -> i32 #foreign user32 "ReleaseDC"; release_dc :: proc(wnd: Hwnd, hdc: Hdc) -> i32 #foreign user32 "ReleaseDC";
Proc :: #type proc() #cc_c; Proc :: #type proc() #cc_c;
core/utf8.odin
+21 -21
View File
@@ -38,7 +38,7 @@ immutable accept_ranges := [5]AcceptRange{
{0x80, 0x8f}, {0x80, 0x8f},
}; };
immutable accept_sizes := [256]byte{ immutable accept_sizes := [256]u8{
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x00-0x0f 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x00-0x0f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x10-0x1f 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x10-0x1f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x20-0x2f 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x20-0x2f
@@ -58,17 +58,17 @@ immutable accept_sizes := [256]byte{
0x34, 0x04, 0x04, 0x04, 0x44, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xf0-0xff 0x34, 0x04, 0x04, 0x04, 0x44, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xf0-0xff
}; };
encode_rune :: proc(r: rune) -> ([4]byte, int) { encode_rune :: proc(r: rune) -> ([4]u8, int) {
buf: [4]byte; buf: [4]u8;
i := u32(r); i := u32(r);
mask: byte : 0x3f; mask: u8 : 0x3f;
if i <= 1<<7-1 { if i <= 1<<7-1 {
buf[0] = byte(r); buf[0] = u8(r);
return buf, 1; return buf, 1;
} }
if i <= 1<<11-1 { if i <= 1<<11-1 {
buf[0] = 0xc0 | byte(r>>6); buf[0] = 0xc0 | u8(r>>6);
buf[1] = 0x80 | byte(r) & mask; buf[1] = 0x80 | u8(r) & mask;
return buf, 2; return buf, 2;
} }
@@ -79,21 +79,21 @@ encode_rune :: proc(r: rune) -> ([4]byte, int) {
} }
if i <= 1<<16-1 { if i <= 1<<16-1 {
buf[0] = 0xe0 | byte(r>>12); buf[0] = 0xe0 | u8(r>>12);
buf[1] = 0x80 | byte(r>>6) & mask; buf[1] = 0x80 | u8(r>>6) & mask;
buf[2] = 0x80 | byte(r) & mask; buf[2] = 0x80 | u8(r) & mask;
return buf, 3; return buf, 3;
} }
buf[0] = 0xf0 | byte(r>>18); buf[0] = 0xf0 | u8(r>>18);
buf[1] = 0x80 | byte(r>>12) & mask; buf[1] = 0x80 | u8(r>>12) & mask;
buf[2] = 0x80 | byte(r>>6) & mask; buf[2] = 0x80 | u8(r>>6) & mask;
buf[3] = 0x80 | byte(r) & mask; buf[3] = 0x80 | u8(r) & mask;
return buf, 4; return buf, 4;
} }
decode_rune :: proc(s: string) -> (rune, int) #inline { return decode_rune([]byte(s)); } decode_rune :: proc(s: string) -> (rune, int) #inline { return decode_rune([]u8(s)); }
decode_rune :: proc(s: []byte) -> (rune, int) { decode_rune :: proc(s: []u8) -> (rune, int) {
n := len(s); n := len(s);
if n < 1 { if n < 1 {
return RUNE_ERROR, 0; return RUNE_ERROR, 0;
@@ -132,8 +132,8 @@ decode_rune :: proc(s: []byte) -> (rune, int) {
decode_last_rune :: proc(s: string) -> (rune, int) #inline { return decode_last_rune([]byte(s)); } decode_last_rune :: proc(s: string) -> (rune, int) #inline { return decode_last_rune([]u8(s)); }
decode_last_rune :: proc(s: []byte) -> (rune, int) { decode_last_rune :: proc(s: []u8) -> (rune, int) {
r: rune; r: rune;
size: int; size: int;
start, end, limit: int; start, end, limit: int;
@@ -215,10 +215,10 @@ valid_string :: proc(s: string) -> bool {
return true; return true;
} }
rune_start :: proc(b: byte) -> bool #inline { return b&0xc0 != 0x80; } rune_start :: proc(b: u8) -> bool #inline { return b&0xc0 != 0x80; }
rune_count :: proc(s: string) -> int #inline { return rune_count([]byte(s)); } rune_count :: proc(s: string) -> int #inline { return rune_count([]u8(s)); }
rune_count :: proc(s: []byte) -> int { rune_count :: proc(s: []u8) -> int {
count := 0; count := 0;
n := len(s); n := len(s);
src/check_expr.c
+21 -5
View File
@@ -156,7 +156,7 @@ i64 check_distance_between_types(Checker *c, Operand *operand, Type *type) {
if (is_type_typed(dst) && src->kind == Type_Basic) { if (is_type_typed(dst) && src->kind == Type_Basic) {
switch (src->Basic.kind) { switch (src->Basic.kind) {
case Basic_UntypedInteger: case Basic_UntypedInteger:
if (is_type_integer(dst)) { if (is_type_integer(dst) || is_type_rune(dst)) {
return 1; return 1;
} }
break; break;
@@ -2102,7 +2102,7 @@ bool check_representable_as_constant(Checker *c, ExactValue in_value, Type *type
return in_value.kind == ExactValue_Bool; return in_value.kind == ExactValue_Bool;
} else if (is_type_string(type)) { } else if (is_type_string(type)) {
return in_value.kind == ExactValue_String; return in_value.kind == ExactValue_String;
} else if (is_type_integer(type)) { } else if (is_type_integer(type) || is_type_rune(type)) {
ExactValue v = exact_value_to_integer(in_value); ExactValue v = exact_value_to_integer(in_value);
if (v.kind != ExactValue_Integer) { if (v.kind != ExactValue_Integer) {
return false; return false;
@@ -2127,6 +2127,7 @@ bool check_representable_as_constant(Checker *c, ExactValue in_value, Type *type
i128 imax = i128_shl(I128_ONE, s-1ll); i128 imax = i128_shl(I128_ONE, s-1ll);
switch (type->Basic.kind) { switch (type->Basic.kind) {
case Basic_rune:
case Basic_i8: case Basic_i8:
case Basic_i16: case Basic_i16:
case Basic_i32: case Basic_i32:
@@ -2212,7 +2213,15 @@ void check_is_expressible(Checker *c, Operand *o, Type *type) {
if (!is_type_integer(o->type) && is_type_integer(type)) { if (!is_type_integer(o->type) && is_type_integer(type)) {
error_node(o->expr, "`%s` truncated to `%s`", a, b); error_node(o->expr, "`%s` truncated to `%s`", a, b);
} else { } else {
error_node(o->expr, "`%s = %lld` overflows `%s`", a, i128_to_i64(o->value.value_integer), b); char buf[127] = {0};
String str = {0};
i128 i = o->value.value_integer;
if (is_type_unsigned(o->type)) {
str = u128_to_string(*cast(u128 *)&i, buf, gb_size_of(buf));
} else {
str = i128_to_string(i, buf, gb_size_of(buf));
}
error_node(o->expr, "`%s = %.*s` overflows `%s`", a, str, b);
} }
} else { } else {
error_node(o->expr, "Cannot convert `%s` to `%s`", a, b); error_node(o->expr, "Cannot convert `%s` to `%s`", a, b);
@@ -2623,6 +2632,13 @@ bool check_is_castable_to(Checker *c, Operand *operand, Type *y) {
} }
} }
if (is_type_integer(src) && is_type_rune(dst)) {
return true;
}
if (is_type_rune(src) && is_type_integer(dst)) {
return true;
}
if (is_type_complex(src) && is_type_complex(dst)) { if (is_type_complex(src) && is_type_complex(dst)) {
return true; return true;
} }
@@ -4349,7 +4365,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
} break; } break;
case BuiltinProc_slice_to_bytes: { case BuiltinProc_slice_to_bytes: {
// slice_to_bytes :: proc(a: []T) -> []byte // slice_to_bytes :: proc(a: []T) -> []u8
Type *slice_type = base_type(operand->type); Type *slice_type = base_type(operand->type);
if (!is_type_slice(slice_type)) { if (!is_type_slice(slice_type)) {
gbString type_str = type_to_string(operand->type); gbString type_str = type_to_string(operand->type);
@@ -4358,7 +4374,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
return false; return false;
} }
operand->type = t_byte_slice; operand->type = t_u8_slice;
operand->mode = Addressing_Value; operand->mode = Addressing_Value;
} break; } break;
src/checker.c
+28 -25
View File
@@ -658,13 +658,12 @@ void init_universal_scope(void) {
add_global_entity(make_entity_type_name(a, NULL, make_token_ident(basic_types[i].Basic.name), &basic_types[i])); add_global_entity(make_entity_type_name(a, NULL, make_token_ident(basic_types[i].Basic.name), &basic_types[i]));
} }
#if 1 #if 1
for (isize i = 0; i < gb_count_of(basic_type_aliases); i++) { // for (isize i = 0; i < gb_count_of(basic_type_aliases); i++) {
add_global_entity(make_entity_type_name(a, NULL, make_token_ident(basic_type_aliases[i].Basic.name), &basic_type_aliases[i])); // add_global_entity(make_entity_type_name(a, NULL, make_token_ident(basic_type_aliases[i].Basic.name), &basic_type_aliases[i]));
} // }
#else #else
{ {
t_byte = add_global_type_alias(a, str_lit("byte"), &basic_types[Basic_u8]); t_byte = add_global_type_alias(a, str_lit("byte"), &basic_types[Basic_u8]);
t_rune = add_global_type_alias(a, str_lit("rune"), &basic_types[Basic_i32]);
} }
#endif #endif
@@ -700,7 +699,7 @@ void init_universal_scope(void) {
t_i64_ptr = make_type_pointer(a, t_i64); t_i64_ptr = make_type_pointer(a, t_i64);
t_i128_ptr = make_type_pointer(a, t_i128); t_i128_ptr = make_type_pointer(a, t_i128);
t_f64_ptr = make_type_pointer(a, t_f64); t_f64_ptr = make_type_pointer(a, t_f64);
t_byte_slice = make_type_slice(a, t_byte); t_u8_slice = make_type_slice(a, t_u8);
t_string_slice = make_type_slice(a, t_string); t_string_slice = make_type_slice(a, t_string);
} }
@@ -1204,33 +1203,35 @@ void init_preload(Checker *c) {
if (record->variant_count != 22) { if (record->variant_count != 23) {
compiler_error("Invalid `TypeInfo` layout"); compiler_error("Invalid `TypeInfo` layout");
} }
t_type_info_named = record->variants[ 1]->type; t_type_info_named = record->variants[ 1]->type;
t_type_info_integer = record->variants[ 2]->type; t_type_info_integer = record->variants[ 2]->type;
t_type_info_float = record->variants[ 3]->type; t_type_info_rune = record->variants[ 3]->type;
t_type_info_complex = record->variants[ 4]->type; t_type_info_float = record->variants[ 4]->type;
t_type_info_string = record->variants[ 5]->type; t_type_info_complex = record->variants[ 5]->type;
t_type_info_boolean = record->variants[ 6]->type; t_type_info_string = record->variants[ 6]->type;
t_type_info_any = record->variants[ 7]->type; t_type_info_boolean = record->variants[ 7]->type;
t_type_info_pointer = record->variants[ 8]->type; t_type_info_any = record->variants[ 8]->type;
t_type_info_atomic = record->variants[ 9]->type; t_type_info_pointer = record->variants[ 9]->type;
t_type_info_procedure = record->variants[10]->type; t_type_info_atomic = record->variants[10]->type;
t_type_info_array = record->variants[11]->type; t_type_info_procedure = record->variants[11]->type;
t_type_info_dynamic_array = record->variants[12]->type; t_type_info_array = record->variants[12]->type;
t_type_info_slice = record->variants[13]->type; t_type_info_dynamic_array = record->variants[13]->type;
t_type_info_vector = record->variants[14]->type; t_type_info_slice = record->variants[14]->type;
t_type_info_tuple = record->variants[15]->type; t_type_info_vector = record->variants[15]->type;
t_type_info_struct = record->variants[16]->type; t_type_info_tuple = record->variants[16]->type;
t_type_info_raw_union = record->variants[17]->type; t_type_info_struct = record->variants[17]->type;
t_type_info_union = record->variants[18]->type; t_type_info_raw_union = record->variants[18]->type;
t_type_info_enum = record->variants[19]->type; t_type_info_union = record->variants[19]->type;
t_type_info_map = record->variants[20]->type; t_type_info_enum = record->variants[20]->type;
t_type_info_bit_field = record->variants[21]->type; t_type_info_map = record->variants[21]->type;
t_type_info_bit_field = record->variants[22]->type;
t_type_info_named_ptr = make_type_pointer(c->allocator, t_type_info_named); t_type_info_named_ptr = make_type_pointer(c->allocator, t_type_info_named);
t_type_info_integer_ptr = make_type_pointer(c->allocator, t_type_info_integer); t_type_info_integer_ptr = make_type_pointer(c->allocator, t_type_info_integer);
t_type_info_rune_ptr = make_type_pointer(c->allocator, t_type_info_rune);
t_type_info_float_ptr = make_type_pointer(c->allocator, t_type_info_float); t_type_info_float_ptr = make_type_pointer(c->allocator, t_type_info_float);
t_type_info_complex_ptr = make_type_pointer(c->allocator, t_type_info_complex); t_type_info_complex_ptr = make_type_pointer(c->allocator, t_type_info_complex);
t_type_info_string_ptr = make_type_pointer(c->allocator, t_type_info_string); t_type_info_string_ptr = make_type_pointer(c->allocator, t_type_info_string);
@@ -2118,12 +2119,14 @@ void check_parsed_files(Checker *c) {
} }
} }
/*
for (isize i = 0; i < gb_count_of(basic_type_aliases)-1; i++) { for (isize i = 0; i < gb_count_of(basic_type_aliases)-1; i++) {
Type *t = &basic_type_aliases[i]; Type *t = &basic_type_aliases[i];
if (t->Basic.size > 0) { if (t->Basic.size > 0) {
add_type_info_type(c, t); add_type_info_type(c, t);
} }
} }
*/
#endif #endif
src/ir.c
+4
View File
@@ -7526,6 +7526,10 @@ void ir_gen_tree(irGen *s) {
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 2), is_signed); ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 2), is_signed);
} break; } break;
case Basic_rune:
tag = ir_emit_conv(proc, ti_ptr, t_type_info_rune_ptr);
break;
// case Basic_f16: // case Basic_f16:
case Basic_f32: case Basic_f32:
case Basic_f64: case Basic_f64:
src/ir_print.c
+2
View File
@@ -193,6 +193,8 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t) {
case Basic_i128: ir_fprintf(f, "i128"); return; case Basic_i128: ir_fprintf(f, "i128"); return;
case Basic_u128: ir_fprintf(f, "i128"); return; case Basic_u128: ir_fprintf(f, "i128"); return;
case Basic_rune: ir_fprintf(f, "i32"); return;
// case Basic_f16: ir_fprintf(f, "half"); return; // case Basic_f16: ir_fprintf(f, "half"); return;
case Basic_f32: ir_fprintf(f, "float"); return; case Basic_f32: ir_fprintf(f, "float"); return;
case Basic_f64: ir_fprintf(f, "double"); return; case Basic_f64: ir_fprintf(f, "double"); return;
src/tokenizer.c
+3 -3
View File
@@ -890,9 +890,9 @@ Token tokenizer_get_token(Tokenizer *t) {
case '}': token.kind = Token_CloseBrace; break; case '}': token.kind = Token_CloseBrace; break;
case '\\': token.kind = Token_BackSlash; break; case '\\': token.kind = Token_BackSlash; break;
case '≠': token.kind = Token_NotEq; break; case 0x2260: token.kind = Token_NotEq; break; // '≠'
case '≤': token.kind = Token_LtEq; break; case 0x2264: token.kind = Token_LtEq; break; // '≤'
case '≥': token.kind = Token_GtEq; break; case 0x2265: token.kind = Token_GtEq; break; // '≥'
case '%': token.kind = token_kind_dub_eq(t, '%', Token_Mod, Token_ModEq, Token_ModMod, Token_ModModEq); break; case '%': token.kind = token_kind_dub_eq(t, '%', Token_Mod, Token_ModEq, Token_ModMod, Token_ModModEq); break;
src/types.c
+23 -10
View File
@@ -14,6 +14,8 @@ typedef enum BasicKind {
Basic_i128, Basic_i128,
Basic_u128, Basic_u128,
Basic_rune,
// Basic_f16, // Basic_f16,
Basic_f32, Basic_f32,
Basic_f64, Basic_f64,
@@ -39,7 +41,6 @@ typedef enum BasicKind {
Basic_COUNT, Basic_COUNT,
Basic_byte = Basic_u8, Basic_byte = Basic_u8,
Basic_rune = Basic_i32,
} BasicKind; } BasicKind;
typedef enum BasicFlag { typedef enum BasicFlag {
@@ -54,8 +55,8 @@ typedef enum BasicFlag {
BasicFlag_Untyped = GB_BIT(8), BasicFlag_Untyped = GB_BIT(8),
BasicFlag_Numeric = BasicFlag_Integer | BasicFlag_Float | BasicFlag_Complex, BasicFlag_Numeric = BasicFlag_Integer | BasicFlag_Float | BasicFlag_Complex,
BasicFlag_Ordered = BasicFlag_Integer | BasicFlag_Float | BasicFlag_String | BasicFlag_Pointer, BasicFlag_Ordered = BasicFlag_Integer | BasicFlag_Float | BasicFlag_String | BasicFlag_Pointer | BasicFlag_Rune,
BasicFlag_ConstantType = BasicFlag_Boolean | BasicFlag_Numeric | BasicFlag_Pointer | BasicFlag_String | BasicFlag_Rune, BasicFlag_ConstantType = BasicFlag_Boolean | BasicFlag_Numeric | BasicFlag_String | BasicFlag_Pointer | BasicFlag_Rune,
} BasicFlag; } BasicFlag;
typedef struct BasicType { typedef struct BasicType {
@@ -235,6 +236,7 @@ gb_global Type basic_types[] = {
{Type_Basic, {Basic_i128, BasicFlag_Integer, 16, STR_LIT("i128")}}, {Type_Basic, {Basic_i128, BasicFlag_Integer, 16, STR_LIT("i128")}},
{Type_Basic, {Basic_u128, BasicFlag_Integer | BasicFlag_Unsigned, 16, STR_LIT("u128")}}, {Type_Basic, {Basic_u128, BasicFlag_Integer | BasicFlag_Unsigned, 16, STR_LIT("u128")}},
{Type_Basic, {Basic_rune, BasicFlag_Integer | BasicFlag_Rune, 4, STR_LIT("rune")}},
// {Type_Basic, {Basic_f16, BasicFlag_Float, 2, STR_LIT("f16")}}, // {Type_Basic, {Basic_f16, BasicFlag_Float, 2, STR_LIT("f16")}},
{Type_Basic, {Basic_f32, BasicFlag_Float, 4, STR_LIT("f32")}}, {Type_Basic, {Basic_f32, BasicFlag_Float, 4, STR_LIT("f32")}},
@@ -260,10 +262,10 @@ gb_global Type basic_types[] = {
{Type_Basic, {Basic_UntypedNil, BasicFlag_Untyped, 0, STR_LIT("untyped nil")}}, {Type_Basic, {Basic_UntypedNil, BasicFlag_Untyped, 0, STR_LIT("untyped nil")}},
}; };
gb_global Type basic_type_aliases[] = { // gb_global Type basic_type_aliases[] = {
{Type_Basic, {Basic_byte, BasicFlag_Integer | BasicFlag_Unsigned, 1, STR_LIT("byte")}}, // // {Type_Basic, {Basic_byte, BasicFlag_Integer | BasicFlag_Unsigned, 1, STR_LIT("byte")}},
{Type_Basic, {Basic_rune, BasicFlag_Integer, 4, STR_LIT("rune")}}, // // {Type_Basic, {Basic_rune, BasicFlag_Integer, 4, STR_LIT("rune")}},
}; // };
gb_global Type *t_invalid = &basic_types[Basic_Invalid]; gb_global Type *t_invalid = &basic_types[Basic_Invalid];
gb_global Type *t_bool = &basic_types[Basic_bool]; gb_global Type *t_bool = &basic_types[Basic_bool];
@@ -278,6 +280,8 @@ gb_global Type *t_u64 = &basic_types[Basic_u64];
gb_global Type *t_i128 = &basic_types[Basic_i128]; gb_global Type *t_i128 = &basic_types[Basic_i128];
gb_global Type *t_u128 = &basic_types[Basic_u128]; gb_global Type *t_u128 = &basic_types[Basic_u128];
gb_global Type *t_rune = &basic_types[Basic_rune];
// gb_global Type *t_f16 = &basic_types[Basic_f16]; // gb_global Type *t_f16 = &basic_types[Basic_f16];
gb_global Type *t_f32 = &basic_types[Basic_f32]; gb_global Type *t_f32 = &basic_types[Basic_f32];
gb_global Type *t_f64 = &basic_types[Basic_f64]; gb_global Type *t_f64 = &basic_types[Basic_f64];
@@ -301,15 +305,13 @@ gb_global Type *t_untyped_string = &basic_types[Basic_UntypedString];
gb_global Type *t_untyped_rune = &basic_types[Basic_UntypedRune]; gb_global Type *t_untyped_rune = &basic_types[Basic_UntypedRune];
gb_global Type *t_untyped_nil = &basic_types[Basic_UntypedNil]; gb_global Type *t_untyped_nil = &basic_types[Basic_UntypedNil];
gb_global Type *t_byte = &basic_type_aliases[0];
gb_global Type *t_rune = &basic_type_aliases[1];
gb_global Type *t_u8_ptr = NULL; gb_global Type *t_u8_ptr = NULL;
gb_global Type *t_int_ptr = NULL; gb_global Type *t_int_ptr = NULL;
gb_global Type *t_i64_ptr = NULL; gb_global Type *t_i64_ptr = NULL;
gb_global Type *t_i128_ptr = NULL; gb_global Type *t_i128_ptr = NULL;
gb_global Type *t_f64_ptr = NULL; gb_global Type *t_f64_ptr = NULL;
gb_global Type *t_byte_slice = NULL; gb_global Type *t_u8_slice = NULL;
gb_global Type *t_string_slice = NULL; gb_global Type *t_string_slice = NULL;
@@ -323,6 +325,7 @@ gb_global Type *t_type_info_enum_value_ptr = NULL;
gb_global Type *t_type_info_named = NULL; gb_global Type *t_type_info_named = NULL;
gb_global Type *t_type_info_integer = NULL; gb_global Type *t_type_info_integer = NULL;
gb_global Type *t_type_info_rune = NULL;
gb_global Type *t_type_info_float = NULL; gb_global Type *t_type_info_float = NULL;
gb_global Type *t_type_info_complex = NULL; gb_global Type *t_type_info_complex = NULL;
gb_global Type *t_type_info_any = NULL; gb_global Type *t_type_info_any = NULL;
@@ -345,6 +348,7 @@ gb_global Type *t_type_info_bit_field = NULL;
gb_global Type *t_type_info_named_ptr = NULL; gb_global Type *t_type_info_named_ptr = NULL;
gb_global Type *t_type_info_integer_ptr = NULL; gb_global Type *t_type_info_integer_ptr = NULL;
gb_global Type *t_type_info_rune_ptr = NULL;
gb_global Type *t_type_info_float_ptr = NULL; gb_global Type *t_type_info_float_ptr = NULL;
gb_global Type *t_type_info_complex_ptr = NULL; gb_global Type *t_type_info_complex_ptr = NULL;
gb_global Type *t_type_info_quaternion_ptr = NULL; gb_global Type *t_type_info_quaternion_ptr = NULL;
@@ -646,6 +650,13 @@ bool is_type_unsigned(Type *t) {
} }
return false; return false;
} }
bool is_type_rune(Type *t) {
t = core_type(t);
if (t->kind == Type_Basic) {
return (t->Basic.flags & BasicFlag_Rune) != 0;
}
return false;
}
bool is_type_numeric(Type *t) { bool is_type_numeric(Type *t) {
t = core_type(t); t = core_type(t);
if (t->kind == Type_Basic) { if (t->kind == Type_Basic) {
@@ -932,6 +943,8 @@ bool is_type_comparable(Type *t) {
case Basic_UntypedNil: case Basic_UntypedNil:
case Basic_any: case Basic_any:
return false; return false;
case Basic_rune:
return true;
} }
return true; return true;
case Type_Pointer: case Type_Pointer: