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

Change casting syntax: cast(T)x transmute(T)x et al.

Browse Source
This commit is contained in:
Ginger Bill
2017-01-25 19:19:25 +00:00
parent 12498b2d39
commit b59a052e32
24 changed files with 655 additions and 540 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/_preload.odin
+6 -17
View File
@@ -91,6 +91,10 @@ Type_Info :: union {
},
}
// // NOTE(bill): only the ones that are needed (not all types)
// // This will be set by the compiler
// immutable __type_infos: []Type_Info;
type_info_base :: proc(info: ^Type_Info) -> ^Type_Info {
if info == nil {
return nil;
@@ -111,21 +115,6 @@ __debug_trap :: proc() #foreign "llvm.debugtrap"
__trap :: proc() #foreign "llvm.trap"
read_cycle_counter :: proc() -> u64 #foreign "llvm.readcyclecounter"
bit_reverse :: proc(b: u16) -> u16 #foreign "llvm.bitreverse.i16"
bit_reverse :: proc(b: u32) -> u32 #foreign "llvm.bitreverse.i32"
bit_reverse :: proc(b: u64) -> u64 #foreign "llvm.bitreverse.i64"
byte_swap :: proc(b: u16) -> u16 #foreign "llvm.bswap.i16"
byte_swap :: proc(b: u32) -> u32 #foreign "llvm.bswap.i32"
byte_swap :: proc(b: u64) -> u64 #foreign "llvm.bswap.i64"
fmuladd :: proc(a, b, c: f32) -> f32 #foreign "llvm.fmuladd.f32"
fmuladd :: proc(a, b, c: f64) -> f64 #foreign "llvm.fmuladd.f64"
Allocator_Mode :: enum u8 {
ALLOC,
@@ -297,11 +286,11 @@ __string_eq :: proc(a, b: string) -> bool {
if a.data == b.data {
return true;
}
return mem.compare(rawptr(a.data), rawptr(b.data), a.count) == 0;
return mem.compare(cast(rawptr)a.data, cast(rawptr)b.data, a.count) == 0;
}
__string_cmp :: proc(a, b: string) -> int {
return mem.compare(rawptr(a.data), rawptr(b.data), min(a.count, b.count));
return mem.compare(cast(rawptr)a.data, cast(rawptr)b.data, min(a.count, b.count));
}
__string_ne :: proc(a, b: string) -> bool #inline { return !__string_eq(a, b); }
core/fmt.odin
+92 -94
View File
@@ -19,7 +19,7 @@ buffer_write :: proc(buf: ^Buffer, b: []byte) {
}
}
buffer_write_string :: proc(buf: ^Buffer, s: string) {
buffer_write(buf, []byte(s));
buffer_write(buf, cast([]byte)s);
}
buffer_write_byte :: proc(buf: ^Buffer, b: byte) {
if buf.length < buf.data.count {
@@ -29,7 +29,7 @@ buffer_write_byte :: proc(buf: ^Buffer, b: byte) {
}
buffer_write_rune :: proc(buf: ^Buffer, r: rune) {
if r < utf8.RUNE_SELF {
buffer_write_byte(buf, byte(r));
buffer_write_byte(buf, cast(byte)r);
return;
}
@@ -117,7 +117,7 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
default:
buffer_write_string(buf, if info.signed { give "i" } else { give "u"});
fi := Fmt_Info{buf = buf};
fmt_int(^fi, u64(8*info.size), false, 'd');
fmt_int(^fi, cast(u64)(8*info.size), false, 'd');
}
case Float:
@@ -142,7 +142,7 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
if info.params == nil {
buffer_write_string(buf, "()");
} else {
count := (^Tuple)(info.params).fields.count;
count := (cast(^Tuple)info.params).fields.count;
if count == 1 { buffer_write_string(buf, "("); }
buffer_write_type(buf, info.params);
if count == 1 { buffer_write_string(buf, ")"); }
@@ -170,7 +170,7 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
case Array:
buffer_write_string(buf, "[");
fi := Fmt_Info{buf = buf};
fmt_int(^fi, u64(info.count), false, 'd');
fmt_int(^fi, cast(u64)info.count, false, 'd');
buffer_write_string(buf, "]");
buffer_write_type(buf, info.elem);
case Slice:
@@ -180,7 +180,7 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
case Vector:
buffer_write_string(buf, "[vector ");
fi := Fmt_Info{buf = buf};
fmt_int(^fi, u64(info.count), false, 'd');
fmt_int(^fi, cast(u64)info.count, false, 'd');
buffer_write_string(buf, "]");
buffer_write_type(buf, info.elem);
@@ -221,7 +221,6 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
buffer_write_string(buf, "enum ");
buffer_write_type(buf, info.base);
buffer_write_string(buf, " {}");
}
}
@@ -307,14 +306,14 @@ parse_int :: proc(s: string, offset: int) -> (int, int, bool) {
i := 0;
for _ : offset..<s.count {
c := rune(s[offset]);
c := cast(rune)s[offset];
if !is_digit(c) {
break;
}
i += 1;
result *= 10;
result += int(c - '0');
result += cast(int)(c - '0');
}
return result, offset, i != 0;
@@ -361,14 +360,14 @@ int_from_arg :: proc(args: []any, arg_index: int) -> (int, int, bool) {
arg.type_info = type_info_base(arg.type_info);
match type i : arg {
case int: num = i;
case i8: num = int(i);
case i16: num = int(i);
case i32: num = int(i);
case i64: num = int(i);
case u8: num = int(i);
case u16: num = int(i);
case u32: num = int(i);
case u64: num = int(i);
case i8: num = cast(int)i;
case i16: num = cast(int)i;
case i32: num = cast(int)i;
case i64: num = cast(int)i;
case u8: num = cast(int)i;
case u16: num = cast(int)i;
case u32: num = cast(int)i;
case u64: num = cast(int)i;
default:
ok = false;
}
@@ -421,7 +420,7 @@ fmt_write_padding :: proc(fi: ^Fmt_Info, width: int) {
}
fmt_integer :: proc(fi: ^Fmt_Info, u: u64, base: int, signed: bool, digits: string) {
negative := signed && i64(u) < 0;
negative := signed && cast(i64)u < 0;
if negative {
u = -u;
}
@@ -461,7 +460,7 @@ fmt_integer :: proc(fi: ^Fmt_Info, u: u64, base: int, signed: bool, digits: stri
panic("fmt_integer: unknown base, whoops");
}
while b := u64(base); u >= b {
while b := cast(u64)base; u >= b {
i -= 1;
next := u / b;
buf[i] = digits[u%b];
@@ -504,7 +503,7 @@ fmt_integer :: proc(fi: ^Fmt_Info, u: u64, base: int, signed: bool, digits: stri
if !fi.width_set || fi.width == 0 {
buffer_write(fi.buf, buf[i:]);
} else {
width := fi.width - utf8.rune_count(string(buf[i:]));
width := fi.width - utf8.rune_count(cast(string)buf[i:]);
if fi.minus {
// Right pad
buffer_write(fi.buf, buf[i:]);
@@ -533,9 +532,9 @@ fmt_int :: proc(fi: ^Fmt_Info, u: u64, signed: bool, verb: rune) {
case 'd': fmt_integer(fi, u, 10, signed, __DIGITS_LOWER);
case 'x': fmt_integer(fi, u, 16, signed, __DIGITS_LOWER);
case 'X': fmt_integer(fi, u, 16, signed, __DIGITS_UPPER);
case 'c': fmt_rune(fi, rune(u));
case 'c': fmt_rune(fi, cast(rune)u);
case 'U':
r := rune(u);
r := cast(rune)u;
if r < 0 || r > utf8.MAX_RUNE {
fmt_bad_verb(fi, verb);
} else {
@@ -566,24 +565,24 @@ __TEN_TO_19TH :: 1000000000000000000;
__ddmulthi :: proc(ol: f64, xh, yh: f64) -> f64 {
bt: i64;
oh := xh * yh;
bt = transmute(i64, xh);
bt &= i64(~u64(0)<<27);
ahi := transmute(f64, bt);
bt = transmute(i64)xh;
bt &= cast(i64)(~cast(u64)0<<27);
ahi := transmute(f64)bt;
alo := xh-ahi;
bt = transmute(i64, yh);
bt &= i64(~u64(0)<<27);
bhi := transmute(f64, bt);
bt = transmute(i64)yh;
bt &= cast(i64)(~cast(u64)0<<27);
bhi := transmute(f64)bt;
blo := yh-bhi;
return ((ahi*bhi-oh)+ahi*blo+alo*bhi)+alo*blo;
}
__ddtoi64 :: proc(xh, xl: f64) -> i64 {
ob := i64(xh);
vh := f64(ob);
ob := cast(i64)xh;
vh := cast(f64)ob;
ahi := xh-vh;
t := ahi-xh;
alo := (xh-(ahi-t)) - (vh+t);
ob += i64(ahi+alo+xl);
ob += cast(i64)(ahi+alo+xl);
return ob;
}
@@ -670,9 +669,9 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
e, tens: i32;
d: f64 = val;
bits := transmute(i64, d);
expo := i32(bits>>52 & 2047);
neg := i32(bits>>63) != 0;
bits := transmute(i64)d;
expo := cast(i32)(bits>>52 & 2047);
neg := cast(i32)(bits>>63) != 0;
if neg {
d = -d;
}
@@ -692,7 +691,7 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
if bits<<1 == 0 {
decimal_pos^ = 1;
out[0] = '0';
start^ = string(out[:1]);
start^ = cast(string)out[:1];
return neg;
}
// find the right expo for denormals
@@ -721,7 +720,7 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
bits = __ddtoi64(ph, pl);
// check if we undershot
if f64(bits) >= __TEN_TO_19TH {
if cast(f64)bits >= __TEN_TO_19TH {
tens += 1;
}
}
@@ -737,10 +736,10 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
if frac_digits < 24 {
skip := false;
dg: u32 = 1;
if u64(bits) >= __powten[9] {
if cast(u64)bits >= __powten[9] {
dg = 10;
}
while u64(bits) >= __powten[dg] {
while cast(u64)bits >= __powten[dg] {
dg += 1;
if dg == 20 {
skip = true;
@@ -751,14 +750,14 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
if (!skip) {
r: u64;
// add 0.5 at the right position and round
e = i32(dg) - frac_digits;
if u32(e) < 24 {
e = cast(i32)dg - frac_digits;
if cast(u32)e < 24 {
r = __powten[e];
bits += i64(r/2);
if u64(bits) >= __powten[dg] {
bits += cast(i64)(r/2);
if cast(u64)bits >= __powten[dg] {
tens += 1;
}
bits /= i64(r);
bits /= cast(i64)(r);
}
}
}
@@ -777,11 +776,11 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
bits /= 1000;
}
if !skip {
n := u32(bits);
n := cast(u32)bits;
while n%1000 == 0 {
n /= 1000;
}
bits = i64(n);
bits = cast(i64)n;
}
}
@@ -793,15 +792,15 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
o := outp-8;
// do the conversion in chunks of u32s (avoid most 64-bit divides, worth it, constant denomiators be damned)
if bits >= 100000000 {
n = u32(bits%100000000);
n = cast(u32)(bits%100000000);
bits /= 100000000;
} else {
n = u32(bits);
n = cast(u32)bits;
bits = 0;
}
while n != 0 {
outp -= 2;
(^u16)(outp)^ = (^u16)(^__digitpair[(n%100)*2])^;
(cast(^u16)outp)^ = (cast(^u16)^__digitpair[(n%100)*2])^;
n /= 100;
e += 2;
}
@@ -820,7 +819,7 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
}
decimal_pos^ = tens;
start^ = string(slice_ptr(outp, e));
start^ = cast(string)slice_ptr(outp, e);
return neg;
}
@@ -839,18 +838,18 @@ generic_ftoa :: proc(buf: []byte, val: f64, verb: rune, prec, bit_size: int) ->
flt: ^Float_Info;
match bit_size {
case 32:
bits = u64(transmute(u32, f32(val)));
bits = cast(u64)transmute(u32)cast(f32)val;
flt = ^f32info;
case 64:
bits = u64(val);
bits = cast(u64)val;
flt = ^f64info;
default:
panic("illegal float bit_size");
}
neg := bits>>(flt.expbits+flt.mantbits) != 0;
exp := int(bits>>flt.mantbits) & (1<<flt.expbits - 1);
mant := bits & (u64(1)<<flt.mantbits - 1);
exp := cast(int)(bits>>flt.mantbits) & (1<<flt.expbits - 1);
mant := bits & (cast(u64)1<<flt.mantbits - 1);
match exp {
case 1<<flt.expbits-1:
@@ -860,13 +859,13 @@ generic_ftoa :: proc(buf: []byte, val: f64, verb: rune, prec, bit_size: int) ->
case neg: s = "-Inf";
default: s = "+Inf";
}
copy(buf, []byte(s));
copy(buf, cast([]byte)s);
return buf[:s.count];
case 0: // denormalized
exp+=1;
default: // add implicit top bit
mant |= u64(1)<<flt.mantbits;
mant |= cast(u64)1<<flt.mantbits;
}
@@ -924,7 +923,7 @@ fmt_pointer :: proc(fi: ^Fmt_Info, p: rawptr, verb: rune) {
fmt_bad_verb(fi, verb);
return;
}
u := u64(uint(p));
u := cast(u64)cast(uint)p;
if !fi.hash || verb == 'v' {
buffer_write_string(fi.buf, "0x");
}
@@ -952,18 +951,18 @@ fmt_enum :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
ok := false;
a := any{type_info_base(e.base), v.data};
match type v : a {
case i8: i = i64(v);
case i16: i = i64(v);
case i32: i = i64(v);
case i64: i = i64(v);
case int: i = i64(v);
case u8: i = i64(v);
case u16: i = i64(v);
case u32: i = i64(v);
case u64: i = i64(v);
case uint: i = i64(v);
case f32: f = f64(v);
case f64: f = f64(v);
case i8: i = cast(i64)v;
case i16: i = cast(i64)v;
case i32: i = cast(i64)v;
case i64: i = cast(i64)v;
case int: i = cast(i64)v;
case u8: i = cast(i64)v;
case u16: i = cast(i64)v;
case u32: i = cast(i64)v;
case u64: i = cast(i64)v;
case uint: i = cast(i64)v;
case f32: f = cast(f64)v;
case f64: f = cast(f64)v;
}
if is_type_integer(e.base) {
@@ -1017,10 +1016,9 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
buffer_write_string(fi.buf, ", ");
}
buffer_write_string(fi.buf, f.name);
// bprint_any(fi.buf, f.offset);
buffer_write_string(fi.buf, " = ");
data := (^byte)(v.data) + f.offset;
fmt_arg(fi, any{f.type_info, rawptr(data)}, 'v');
data := cast(^byte)v.data + f.offset;
fmt_arg(fi, any{f.type_info, cast(rawptr)data}, 'v');
}
buffer_write_byte(fi.buf, '}');
@@ -1035,15 +1033,15 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
case Pointer:
if v.type_info == type_info(^Type_Info) {
buffer_write_type(fi.buf, (^^Type_Info)(v.data)^);
buffer_write_type(fi.buf, (cast(^^Type_Info)v.data)^);
} else {
fmt_pointer(fi, (^rawptr)(v.data)^, verb);
fmt_pointer(fi, (cast(^rawptr)v.data)^, verb);
}
case Maybe:
// TODO(bill): Correct verbs for Maybe types?
size := mem.size_of_type_info(info.elem);
data := slice_ptr((^byte)(v.data), size+1);
data := slice_ptr(cast(^byte)v.data, size+1);
if data[size] != 0 {
fmt_arg(fi, any{info.elem, v.data}, verb);
} else {
@@ -1062,8 +1060,8 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
if i > 0 {
buffer_write_string(fi.buf, ", ");
}
data := (^byte)(v.data) + i*info.elem_size;
fmt_arg(fi, any{info.elem, rawptr(data)}, 'v');
data := cast(^byte)v.data + i*info.elem_size;
fmt_arg(fi, any{info.elem, cast(rawptr)data}, 'v');
}
case Slice:
@@ -1074,13 +1072,13 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
buffer_write_byte(fi.buf, '[');
defer buffer_write_byte(fi.buf, ']');
slice := (^[]byte)(v.data);
slice := cast(^[]byte)v.data;
for i : 0..<slice.count {
if i > 0 {
buffer_write_string(fi.buf, ", ");
}
data := slice.data + i*info.elem_size;
fmt_arg(fi, any{info.elem, rawptr(data)}, 'v');
fmt_arg(fi, any{info.elem, cast(rawptr)data}, 'v');
}
case Vector:
@@ -1106,8 +1104,8 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
buffer_write_string(fi.buf, ", ");
}
data := (^byte)(v.data) + i*info.elem_size;
fmt_value(fi, any{info.elem, rawptr(data)}, 'v');
data := cast(^byte)v.data + i*info.elem_size;
fmt_value(fi, any{info.elem, cast(rawptr)data}, 'v');
}
case Struct:
@@ -1120,9 +1118,9 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
}
buffer_write_string(fi.buf, f.name);
buffer_write_string(fi.buf, " = ");
data := (^byte)(v.data) + f.offset;
data := cast(^byte)v.data + f.offset;
ti := f.type_info;
fmt_value(fi, any{ti, rawptr(data)}, 'v');
fmt_value(fi, any{ti, cast(rawptr)data}, 'v');
}
case Union:
@@ -1136,7 +1134,7 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
case Procedure:
buffer_write_type(fi.buf, v.type_info);
buffer_write_string(fi.buf, " @ ");
fmt_pointer(fi, (^rawptr)(v.data)^, 'p');
fmt_pointer(fi, (cast(^rawptr)v.data)^, 'p');
}
}
@@ -1161,19 +1159,19 @@ fmt_arg :: proc(fi: ^Fmt_Info, arg: any, verb: rune) {
base_arg.type_info = type_info_base(base_arg.type_info);
match type a : base_arg {
case bool: fmt_bool(fi, a, verb);
case f32: fmt_float(fi, f64(a), 32, verb);
case f32: fmt_float(fi, cast(f64)a, 32, verb);
case f64: fmt_float(fi, a, 64, verb);
case int: fmt_int(fi, u64(a), true, verb);
case i8: fmt_int(fi, u64(a), true, verb);
case i16: fmt_int(fi, u64(a), true, verb);
case i32: fmt_int(fi, u64(a), true, verb);
case i64: fmt_int(fi, u64(a), true, verb);
case uint: fmt_int(fi, u64(a), false, verb);
case u8: fmt_int(fi, u64(a), false, verb);
case u16: fmt_int(fi, u64(a), false, verb);
case u32: fmt_int(fi, u64(a), false, verb);
case u64: fmt_int(fi, u64(a), false, verb);
case int: fmt_int(fi, cast(u64)a, true, verb);
case i8: fmt_int(fi, cast(u64)a, true, verb);
case i16: fmt_int(fi, cast(u64)a, true, verb);
case i32: fmt_int(fi, cast(u64)a, true, verb);
case i64: fmt_int(fi, cast(u64)a, true, verb);
case uint: fmt_int(fi, cast(u64)a, false, verb);
case u8: fmt_int(fi, cast(u64)a, false, verb);
case u16: fmt_int(fi, cast(u64)a, false, verb);
case u32: fmt_int(fi, cast(u64)a, false, verb);
case u64: fmt_int(fi, cast(u64)a, false, verb);
case string: fmt_string(fi, a, verb);
default: fmt_value(fi, arg, verb);
}
core/hash.odin
+31 -31
View File
@@ -1,58 +1,58 @@
crc32 :: proc(data: rawptr, len: int) -> u32 {
result := ~u32(0);
s := slice_ptr((^u8)(data), len);
result := ~cast(u32)0;
s := slice_ptr(cast(^u8)data, len);
for i : 0..<len {
b := u32(s[i]);
b := cast(u32)s[i];
result = result>>8 ~ __CRC32_TABLE[(result ~ b) & 0xff];
}
return ~result;
}
crc64 :: proc(data: rawptr, len: int) -> u64 {
result := ~u64(0);
s := slice_ptr((^u8)(data), len);
result := ~cast(u64)0;
s := slice_ptr(cast(^u8)data, len);
for i : 0..<len {
b := u64(s[i]);
b := cast(u64)s[i];
result = result>>8 ~ __CRC64_TABLE[(result ~ b) & 0xff];
}
return ~result;
}
fnv32 :: proc(data: rawptr, len: int) -> u32 {
s := slice_ptr((^u8)(data), len);
s := slice_ptr(cast(^u8)data, len);
h: u32 = 0x811c9dc5;
for i : 0..<len {
h = (h * 0x01000193) ~ u32(s[i]);
h = (h * 0x01000193) ~ cast(u32)s[i];
}
return h;
}
fnv64 :: proc(data: rawptr, len: int) -> u64 {
s := slice_ptr((^u8)(data), len);
s := slice_ptr(cast(^u8)data, len);
h: u64 = 0xcbf29ce484222325;
for i : 0..<len {
h = (h * 0x100000001b3) ~ u64(s[i]);
h = (h * 0x100000001b3) ~ cast(u64)s[i];
}
return h;
}
fnv32a :: proc(data: rawptr, len: int) -> u32 {
s := slice_ptr((^u8)(data), len);
s := slice_ptr(cast(^u8)data, len);
h: u32 = 0x811c9dc5;
for i : 0..<len {
h = (h ~ u32(s[i])) * 0x01000193;
h = (h ~ cast(u32)s[i]) * 0x01000193;
}
return h;
}
fnv64a :: proc(data: rawptr, len: int) -> u64 {
s := slice_ptr((^u8)(data), len);
s := slice_ptr(cast(^u8)data, len);
h :u64 = 0xcbf29ce484222325;
for i : 0..<len {
h = (h ~ u64(s[i])) * 0x100000001b3;
h = (h ~ cast(u64)s[i]) * 0x100000001b3;
}
return h;
}
@@ -65,10 +65,10 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {
m :: 0xc6a4a7935bd1e995;
r :: 47;
h: u64 = SEED ~ (u64(len) * m);
h: u64 = SEED ~ (cast(u64)len * m);
data := slice_ptr((^u64)(data_), len/size_of(u64));
data2 := slice_ptr((^u8)(data_), len);
data := slice_ptr(cast(^u64)data_, len/size_of(u64));
data2 := slice_ptr(cast(^u8)data_, len);
for i : 0 ..< data.count {
k := data[i];
@@ -82,14 +82,14 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {
}
match len & 7 {
case 7: h ~= u64(data2[6]) << 48; fallthrough;
case 6: h ~= u64(data2[5]) << 40; fallthrough;
case 5: h ~= u64(data2[4]) << 32; fallthrough;
case 4: h ~= u64(data2[3]) << 24; fallthrough;
case 3: h ~= u64(data2[2]) << 16; fallthrough;
case 2: h ~= u64(data2[1]) << 8; fallthrough;
case 7: h ~= cast(u64)data2[6] << 48; fallthrough;
case 6: h ~= cast(u64)data2[5] << 40; fallthrough;
case 5: h ~= cast(u64)data2[4] << 32; fallthrough;
case 4: h ~= cast(u64)data2[3] << 24; fallthrough;
case 3: h ~= cast(u64)data2[2] << 16; fallthrough;
case 2: h ~= cast(u64)data2[1] << 8; fallthrough;
case 1:
h ~= u64(data2[0]);
h ~= cast(u64)data2[0];
h *= m;
}
@@ -102,10 +102,10 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {
m :: 0x5bd1e995;
r :: 24;
h1: u32 = u32(SEED) ~ u32(len);
h1: u32 = cast(u32)SEED ~ cast(u32)len;
h2: u32 = SEED >> 32;
data := slice_ptr((^u32)(data_), len/size_of(u32));
data := slice_ptr(cast(^u32)data_, len/size_of(u32));
i := 0;
while len >= 8 {
@@ -138,13 +138,13 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {
len -= 4;
}
data8 := slice_ptr((^u8)(data.data+i), 3); // NOTE(bill): This is unsafe
data8 := slice_ptr(cast(^u8)(data.data+i), 3); // NOTE(bill): This is unsafe
match len {
case 3: h2 ~= u32(data8[2]) << 16; fallthrough;
case 2: h2 ~= u32(data8[1]) << 8; fallthrough;
case 3: h2 ~= cast(u32)data8[2] << 16; fallthrough;
case 2: h2 ~= cast(u32)data8[1] << 8; fallthrough;
case 1:
h2 ~= u32(data8[0]);
h2 ~= cast(u32)data8[0];
h2 *= m;
}
@@ -157,7 +157,7 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {
h2 ~= h1>>19;
h2 *= m;
h := u64(h1)<<32 | u64(h2);
h := cast(u64)(h1)<<32 | cast(u64)(h2);
return h;
}
}
core/math.odin
+17 -7
View File
@@ -42,14 +42,24 @@ lerp :: proc(a, b, t: f64) -> f64 { return a*(1-t) + b*t; }
sign :: proc(x: f32) -> f32 { if x >= 0 { return +1; } return -1; }
sign :: proc(x: f64) -> f64 { if x >= 0 { return +1; } return -1; }
bit_reverse :: proc(b: u16) -> u16 #foreign "llvm.bitreverse.i16"
bit_reverse :: proc(b: u32) -> u32 #foreign "llvm.bitreverse.i32"
bit_reverse :: proc(b: u64) -> u64 #foreign "llvm.bitreverse.i64"
byte_swap :: proc(b: u16) -> u16 #foreign "llvm.bswap.i16"
byte_swap :: proc(b: u32) -> u32 #foreign "llvm.bswap.i32"
byte_swap :: proc(b: u64) -> u64 #foreign "llvm.bswap.i64"
fmuladd :: proc(a, b, c: f32) -> f32 #foreign "llvm.fmuladd.f32"
fmuladd :: proc(a, b, c: f64) -> f64 #foreign "llvm.fmuladd.f64"
copy_sign :: proc(x, y: f32) -> f32 {
ix := transmute(u32, x);
iy := transmute(u32, y);
ix := transmute(u32)x;
iy := transmute(u32)y;
ix &= 0x7fffffff;
ix |= iy & 0x80000000;
return transmute(f32, ix);
return transmute(f32)ix;
}
round :: proc(x: f32) -> f32 {
if x >= 0 {
@@ -59,15 +69,15 @@ round :: proc(x: f32) -> f32 {
}
floor :: proc(x: f32) -> f32 {
if x >= 0 {
return f32(int(x));
return cast(f32)cast(int)x;
}
return f32(int(x-0.5));
return cast(f32)cast(int)(x-0.5);
}
ceil :: proc(x: f32) -> f32 {
if x < 0 {
return f32(int(x));
return cast(f32)cast(int)x;
}
return f32(int(x)+1);
return cast(f32)cast(int)(x+1);
}
remainder32 :: proc(x, y: f32) -> f32 {
core/mem.odin
+12 -12
View File
@@ -3,7 +3,7 @@
set :: proc(data: rawptr, value: i32, len: int) -> rawptr #link_name "__mem_set" {
llvm_memset_64bit :: proc(dst: rawptr, val: byte, len: int, align: i32, is_volatile: bool) #foreign "llvm.memset.p0i8.i64"
llvm_memset_64bit(data, byte(value), len, 1, false);
llvm_memset_64bit(data, cast(byte)value, len, 1, false);
return data;
}
@@ -26,8 +26,8 @@ copy_non_overlapping :: proc(dst, src: rawptr, len: int) -> rawptr #link_name "_
}
compare :: proc(dst, src: rawptr, n: int) -> int #link_name "__mem_compare" {
a := slice_ptr((^byte)(dst), n);
b := slice_ptr((^byte)(src), n);
a := slice_ptr(cast(^byte)dst, n);
b := slice_ptr(cast(^byte)src, n);
for i : 0..<n {
match {
case a[i] < b[i]:
@@ -56,13 +56,13 @@ is_power_of_two :: proc(x: int) -> bool {
align_forward :: proc(ptr: rawptr, align: int) -> rawptr {
assert(is_power_of_two(align));
a := uint(align);
p := uint(ptr);
a := cast(uint)align;
p := cast(uint)ptr;
modulo := p & (a-1);
if modulo != 0 {
p += a - modulo;
}
return rawptr(p);
return cast(rawptr)p;
}
@@ -73,19 +73,19 @@ Allocation_Header :: struct {
allocation_header_fill :: proc(header: ^Allocation_Header, data: rawptr, size: int) {
header.size = size;
ptr := (^int)(header+1);
ptr := cast(^int)(header+1);
while i := 0; rawptr(ptr) < data {
while i := 0; cast(rawptr)ptr < data {
(ptr+i)^ = -1;
i += 1;
}
}
allocation_header :: proc(data: rawptr) -> ^Allocation_Header {
p := (^int)(data);
p := cast(^int)data;
while (p-1)^ == -1 {
p = (p-1);
}
return (^Allocation_Header)(p)-1;
return cast(^Allocation_Header)p-1;
}
@@ -142,7 +142,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:
@@ -235,7 +235,7 @@ align_of_type_info :: proc(type_info: ^Type_Info) -> int {
return WORD_SIZE;
case Vector:
size := size_of_type_info(info.elem);
count := int(max(prev_pow2(i64(info.count)), 1));
count := cast(int)max(prev_pow2(cast(i64)info.count), 1);
total := size * count;
return clamp(total, 1, MAX_ALIGN);
case Struct:
core/opengl.odin
+2 -2
View File
@@ -30,7 +30,7 @@ GetIntegerv :: proc(name: i32, v: ^i32) #foreign "glGetIntegerv"
_libgl := win32.LoadLibraryA(string("opengl32.dll\x00").data);
_libgl := win32.LoadLibraryA((cast(string)"opengl32.dll\x00").data);
GetProcAddress :: proc(name: string) -> proc() #cc_c {
assert(name[name.count-1] == 0);
@@ -100,7 +100,7 @@ UniformMatrix4fv: proc(loc: i32, count: u32, transpose: i32, value: ^f32) #cc_c
GetUniformLocation: proc(program: u32, name: ^byte) -> i32 #cc_c;
init :: proc() {
set_proc_address :: proc(p: rawptr, name: string) #inline { (^(proc() #cc_c))(p)^ = GetProcAddress(name); }
set_proc_address :: proc(p: rawptr, name: string) #inline { (cast(^(proc() #cc_c))p)^ = GetProcAddress(name); }
set_proc_address(^GenBuffers, "glGenBuffers\x00");
set_proc_address(^GenVertexArrays, "glGenVertexArrays\x00");
core/os_windows.odin
+32 -32
View File
@@ -73,7 +73,7 @@ open :: proc(path: string, mode: int, perm: u32) -> (Handle, Errno) {
access |= FILE_APPEND_DATA;
}
share_mode := u32(FILE_SHARE_READ|FILE_SHARE_WRITE);
share_mode := cast(u32)(FILE_SHARE_READ|FILE_SHARE_WRITE);
sa: ^SECURITY_ATTRIBUTES = nil;
sa_inherit := SECURITY_ATTRIBUTES{length = size_of(SECURITY_ATTRIBUTES), inherit_handle = 1};
if mode&O_CLOEXEC == 0 {
@@ -95,38 +95,38 @@ open :: proc(path: string, mode: int, perm: u32) -> (Handle, Errno) {
}
buf: [300]byte;
copy(buf[:], []byte(path));
copy(buf[:], cast([]byte)path);
handle := Handle(CreateFileA(^buf[0], access, share_mode, sa, create_mode, FILE_ATTRIBUTE_NORMAL, nil));
handle := cast(Handle)CreateFileA(^buf[0], access, share_mode, sa, create_mode, FILE_ATTRIBUTE_NORMAL, nil);
if handle != INVALID_HANDLE {
return handle, ERROR_NONE;
}
err := GetLastError();
return INVALID_HANDLE, Errno(err);
return INVALID_HANDLE, cast(Errno)err;
}
close :: proc(fd: Handle) {
win32.CloseHandle(win32.HANDLE(fd));
win32.CloseHandle(cast(win32.HANDLE)fd);
}
write :: proc(fd: Handle, data: []byte) -> (int, Errno) {
bytes_written: i32;
e := win32.WriteFile(win32.HANDLE(fd), data.data, i32(data.count), ^bytes_written, nil);
e := win32.WriteFile(cast(win32.HANDLE)fd, data.data, cast(i32)data.count, ^bytes_written, nil);
if e == win32.FALSE {
err := win32.GetLastError();
return 0, Errno(err);
return 0, cast(Errno)err;
}
return int(bytes_written), ERROR_NONE;
return cast(int)bytes_written, ERROR_NONE;
}
read :: proc(fd: Handle, data: []byte) -> (int, Errno) {
bytes_read: i32;
e := win32.ReadFile(win32.HANDLE(fd), data.data, u32(data.count), ^bytes_read, nil);
e := win32.ReadFile(cast(win32.HANDLE)fd, data.data, cast(u32)data.count, ^bytes_read, nil);
if e == win32.FALSE {
err := win32.GetLastError();
return 0, Errno(err);
return 0, cast(Errno)err;
}
return int(bytes_read), ERROR_NONE;
return cast(int)bytes_read, ERROR_NONE;
}
seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
@@ -137,18 +137,18 @@ seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
case 1: w = FILE_CURRENT;
case 2: w = FILE_END;
}
hi := i32(offset>>32);
lo := i32(offset);
ft := GetFileType(HANDLE(fd));
hi := cast(i32)(offset>>32);
lo := cast(i32)(offset);
ft := GetFileType(cast(HANDLE)fd);
if ft == FILE_TYPE_PIPE {
return 0, ERROR_FILE_IS_PIPE;
}
dw_ptr := SetFilePointer(HANDLE(fd), lo, ^hi, w);
dw_ptr := SetFilePointer(cast(HANDLE)fd, lo, ^hi, w);
if dw_ptr == INVALID_SET_FILE_POINTER {
err := GetLastError();
return 0, Errno(err);
return 0, cast(Errno)err;
}
return i64(hi)<<32 + i64(dw_ptr), ERROR_NONE;
return cast(i64)hi<<32 + cast(i64)dw_ptr, ERROR_NONE;
}
@@ -159,9 +159,9 @@ stderr := get_std_handle(win32.STD_ERROR_HANDLE);
get_std_handle :: proc(h: int) -> Handle {
fd := win32.GetStdHandle(i32(h));
fd := win32.GetStdHandle(cast(i32)h);
win32.SetHandleInformation(fd, win32.HANDLE_FLAG_INHERIT, 0);
return Handle(fd);
return cast(Handle)fd;
}
@@ -171,9 +171,9 @@ get_std_handle :: proc(h: int) -> Handle {
last_write_time :: proc(fd: Handle) -> File_Time {
file_info: win32.BY_HANDLE_FILE_INFORMATION;
win32.GetFileInformationByHandle(win32.HANDLE(fd), ^file_info);
lo := File_Time(file_info.last_write_time.lo);
hi := File_Time(file_info.last_write_time.hi);
win32.GetFileInformationByHandle(cast(win32.HANDLE)fd, ^file_info);
lo := cast(File_Time)file_info.last_write_time.lo;
hi := cast(File_Time)file_info.last_write_time.hi;
return lo | hi << 32;
}
@@ -184,14 +184,14 @@ last_write_time_by_name :: proc(name: string) -> File_Time {
assert(buf.count > name.count);
copy(buf[:], []byte(name));
copy(buf[:], cast([]byte)name);
if win32.GetFileAttributesExA(^buf[0], win32.GetFileExInfoStandard, ^data) != 0 {
last_write_time = data.last_write_time;
}
l := File_Time(last_write_time.lo);
h := File_Time(last_write_time.hi);
l := cast(File_Time)last_write_time.lo;
h := cast(File_Time)last_write_time.hi;
return l | h << 32;
}
@@ -201,7 +201,7 @@ last_write_time_by_name :: proc(name: string) -> File_Time {
read_entire_file :: proc(name: string) -> ([]byte, bool) {
buf: [300]byte;
copy(buf[:], []byte(name));
copy(buf[:], cast([]byte)name);
fd, err := open(name, O_RDONLY, 0);
if err != ERROR_NONE {
@@ -210,7 +210,7 @@ read_entire_file :: proc(name: string) -> ([]byte, bool) {
defer close(fd);
length: i64;
file_size_ok := win32.GetFileSizeEx(win32.HANDLE(fd), ^length) != 0;
file_size_ok := win32.GetFileSizeEx(cast(win32.HANDLE)fd, ^length) != 0;
if !file_size_ok {
return nil, false;
}
@@ -228,18 +228,18 @@ read_entire_file :: proc(name: string) -> ([]byte, bool) {
to_read: u32;
MAX :: 1<<32-1;
if remaining <= MAX {
to_read = u32(remaining);
to_read = cast(u32)remaining;
} else {
to_read = MAX;
}
win32.ReadFile(win32.HANDLE(fd), ^data[total_read], to_read, ^single_read_length, nil);
win32.ReadFile(cast(win32.HANDLE)fd, ^data[total_read], to_read, ^single_read_length, nil);
if single_read_length <= 0 {
free(data.data);
return nil, false;
}
total_read += i64(single_read_length);
total_read += cast(i64)single_read_length;
}
return data, true;
@@ -259,14 +259,14 @@ heap_free :: proc(ptr: rawptr) {
exit :: proc(code: int) {
win32.ExitProcess(u32(code));
win32.ExitProcess(cast(u32)code);
}
current_thread_id :: proc() -> int {
GetCurrentThreadId :: proc() -> u32 #foreign #dll_import
return int(GetCurrentThreadId());
return cast(int)GetCurrentThreadId();
}
core/sync.odin
+2 -2
View File
@@ -13,7 +13,7 @@ Mutex :: struct {
}
current_thread_id :: proc() -> i32 {
return i32(win32.GetCurrentThreadId());
return cast(i32)win32.GetCurrentThreadId();
}
semaphore_init :: proc(s: ^Semaphore) {
@@ -25,7 +25,7 @@ semaphore_destroy :: proc(s: ^Semaphore) {
}
semaphore_post :: proc(s: ^Semaphore, count: int) {
win32.ReleaseSemaphore(s.handle, i32(count), nil);
win32.ReleaseSemaphore(s.handle, cast(i32)count, nil);
}
semaphore_release :: proc(s: ^Semaphore) #inline { semaphore_post(s, 1); }
core/sys/windows.odin
+4 -4
View File
@@ -19,7 +19,7 @@ BOOL :: i32;
WNDPROC :: type proc(HWND, u32, WPARAM, LPARAM) -> LRESULT #cc_c;
INVALID_HANDLE_VALUE :: HANDLE(~int(0));
INVALID_HANDLE_VALUE :: cast(HANDLE)(~cast(int)0);
FALSE: BOOL : 0;
TRUE: BOOL : 1;
@@ -46,7 +46,7 @@ WM_KEYUP :: 0x0101;
PM_REMOVE :: 1;
COLOR_BACKGROUND :: HBRUSH(int(1));
COLOR_BACKGROUND :: cast(HBRUSH)(cast(int)1);
BLACK_BRUSH :: 4;
SM_CXSCREEN :: 0;
@@ -233,7 +233,7 @@ FILE_TYPE_DISK :: 0x0001;
FILE_TYPE_CHAR :: 0x0002;
FILE_TYPE_PIPE :: 0x0003;
INVALID_SET_FILE_POINTER :: ~u32(0);
INVALID_SET_FILE_POINTER :: ~cast(u32)0;
@@ -402,7 +402,7 @@ wglDeleteContext :: proc(hglrc: HGLRC) -> BOOL #foreign #dll_import
GetKeyState :: proc(v_key: i32) -> i16 #foreign #dll_import
GetAsyncKeyState :: proc(v_key: i32) -> i16 #foreign #dll_import
is_key_down :: proc(key: Key_Code) -> bool #inline { return GetAsyncKeyState(i32(key)) < 0; }
is_key_down :: proc(key: Key_Code) -> bool #inline { return GetAsyncKeyState(cast(i32)key) < 0; }
Key_Code :: enum i32 {
LBUTTON = 0x01,
core/utf8.odin
+20 -20
View File
@@ -1,7 +1,7 @@
RUNE_ERROR :: '\ufffd';
RUNE_SELF :: 0x80;
RUNE_BOM :: 0xfeff;
RUNE_EOF :: ~rune(0);
RUNE_EOF :: ~cast(rune)0;
MAX_RUNE :: '\U0010ffff';
UTF_MAX :: 4;
@@ -40,15 +40,15 @@ accept_sizes := [256]byte{
encode_rune :: proc(r: rune) -> ([4]byte, int) {
buf: [4]byte;
i := u32(r);
i := cast(u32)r;
mask: byte : 0x3f;
if i <= 1<<7-1 {
buf[0] = byte(r);
buf[0] = cast(byte)r;
return buf, 1;
}
if i <= 1<<11-1 {
buf[0] = 0xc0 | byte(r>>6);
buf[1] = 0x80 | byte(r) & mask;
buf[0] = 0xc0 | cast(byte)(r>>6);
buf[1] = 0x80 | cast(byte)r & mask;
return buf, 2;
}
@@ -59,16 +59,16 @@ encode_rune :: proc(r: rune) -> ([4]byte, int) {
}
if i <= 1<<16-1 {
buf[0] = 0xe0 | byte(r>>12);
buf[1] = 0x80 | byte(r>>6) & mask;
buf[2] = 0x80 | byte(r) & mask;
buf[0] = 0xe0 | cast(byte)(r>>12);
buf[1] = 0x80 | cast(byte)(r>>6) & mask;
buf[2] = 0x80 | cast(byte)r & mask;
return buf, 3;
}
buf[0] = 0xf0 | byte(r>>18);
buf[1] = 0x80 | byte(r>>12) & mask;
buf[2] = 0x80 | byte(r>>6) & mask;
buf[3] = 0x80 | byte(r) & mask;
buf[0] = 0xf0 | cast(byte)(r>>18);
buf[1] = 0x80 | cast(byte)(r>>12) & mask;
buf[2] = 0x80 | cast(byte)(r>>6) & mask;
buf[3] = 0x80 | cast(byte)r & mask;
return buf, 4;
}
@@ -80,12 +80,12 @@ decode_rune :: proc(s: string) -> (rune, int) {
b0 := s[0];
x := accept_sizes[b0];
if x >= 0xf0 {
mask := (rune(x) << 31) >> 31; // all zeros or all ones
return rune(b0) &~ mask | RUNE_ERROR&mask, 1;
mask := (cast(rune)x << 31) >> 31; // all zeros or all ones
return cast(rune)b0 &~ mask | RUNE_ERROR&mask, 1;
}
size := x & 7;
ar := accept_ranges[x>>4];
if n < int(size) {
if n < cast(int)size {
return RUNE_ERROR, 1;
}
b1 := s[1];
@@ -99,20 +99,20 @@ decode_rune :: proc(s: string) -> (rune, int) {
MASK_4 :: 0b00000111;
if size == 2 {
return rune(b0&MASK_2)<<6 | rune(b1&MASK_X), 2;
return cast(rune)(b0&MASK_2)<<6 | cast(rune)(b1&MASK_X), 2;
}
b2 := s[2];
if b2 < 0x80 || 0xbf < b2 {
return RUNE_ERROR, 1;
}
if size == 3 {
return rune(b0&MASK_3)<<12 | rune(b1&MASK_X)<<6 | rune(b2&MASK_X), 3;
return cast(rune)(b0&MASK_3)<<12 | cast(rune)(b1&MASK_X)<<6 | cast(rune)(b2&MASK_X), 3;
}
b3 := s[3];
if b3 < 0x80 || 0xbf < b3 {
return RUNE_ERROR, 1;
}
return rune(b0&MASK_4)<<18 | rune(b1&MASK_X)<<12 | rune(b3&MASK_X)<<6 | rune(b3&MASK_X), 4;
return cast(rune)(b0&MASK_4)<<18 | cast(rune)(b1&MASK_X)<<12 | cast(rune)(b3&MASK_X)<<6 | cast(rune)(b3&MASK_X), 4;
}
@@ -141,7 +141,7 @@ valid_string :: proc(s: string) -> bool {
if x == 0xf1 {
return false;
}
size := int(x & 7);
size := cast(int)(x & 7);
if i+size > n {
return false;
}
@@ -178,7 +178,7 @@ rune_count :: proc(s: string) -> int {
i += 1;
continue;
}
size := int(x & 7);
size := cast(int)(x & 7);
if i+size > n {
i += 1;
continue;