ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-05 15:18:49 +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/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);
}