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

Change cast syntax, int(x), []byte(s), (^int)(p)

Browse Source
This commit is contained in:
Ginger Bill
2017-01-17 23:36:07 +00:00
parent 367d307dc4
commit 2af9fb79dc
17 changed files with 529 additions and 356 deletions
Download Patch File Download Diff File Expand all files Collapse all files
code/demo.odin
+6 -5
View File
@@ -10,20 +10,22 @@
#import "utf8.odin"; #import "utf8.odin";
main :: proc() { main :: proc() {
foo :: proc(x: ^i32) { foo :: proc(x: ^i32) -> (int, int) {
fmt.println("^int"); fmt.println("^int");
return 123, int(x^);
} }
foo :: proc(x: rawptr) { foo :: proc(x: rawptr) {
fmt.println("rawptr"); fmt.println("rawptr");
} }
THINGI :: 14451; THINGI :: 14451;
THINGF :: 14451.1; THINGF :: 14451.1;
a: i32; a: i32 = 111111;
b: f32; b: f32;
c: rawptr; c: rawptr;
foo(^a); fmt.println(foo(^a));
foo(^b); foo(^b);
foo(c); foo(c);
// foo(nil); // foo(nil);
@@ -36,12 +38,11 @@ main :: proc() {
fmt.printf("int arg, i=%d\n", i); fmt.printf("int arg, i=%d\n", i);
} }
foo :: proc(f: f64) { foo :: proc(f: f64) {
i := f as int; i := int(f);
fmt.printf("f64 arg, f=%d\n", i); fmt.printf("f64 arg, f=%d\n", i);
} }
foo(); foo();
foo(THINGI as int);
foo(int(THINGI)); foo(int(THINGI));
// foo(THINGI); // foo(THINGI);
foo(THINGF); foo(THINGF);
core/_preload.odin
+4 -4
View File
@@ -233,7 +233,7 @@ default_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
case ALLOC: case ALLOC:
total_size := size + alignment + size_of(mem.AllocationHeader); total_size := size + alignment + size_of(mem.AllocationHeader);
ptr := os.heap_alloc(total_size); ptr := os.heap_alloc(total_size);
header := ptr as ^mem.AllocationHeader; header := (^mem.AllocationHeader)(ptr);
ptr = mem.align_forward(header+1, alignment); ptr = mem.align_forward(header+1, alignment);
mem.allocation_header_fill(header, ptr, size); mem.allocation_header_fill(header, ptr, size);
return mem.zero(ptr, size); return mem.zero(ptr, size);
@@ -248,7 +248,7 @@ default_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
case RESIZE: case RESIZE:
total_size := size + alignment + size_of(mem.AllocationHeader); total_size := size + alignment + size_of(mem.AllocationHeader);
ptr := os.heap_resize(mem.allocation_header(old_memory), total_size); ptr := os.heap_resize(mem.allocation_header(old_memory), total_size);
header := ptr as ^mem.AllocationHeader; header := (^mem.AllocationHeader)(ptr);
ptr = mem.align_forward(header+1, alignment); ptr = mem.align_forward(header+1, alignment);
mem.allocation_header_fill(header, ptr, size); mem.allocation_header_fill(header, ptr, size);
return mem.zero(ptr, size); return mem.zero(ptr, size);
@@ -297,11 +297,11 @@ __string_eq :: proc(a, b: string) -> bool {
if a.data == b.data { if a.data == b.data {
return true; return true;
} }
return mem.compare(a.data as rawptr, b.data as rawptr, a.count) == 0; return mem.compare(rawptr(a.data), rawptr(b.data), a.count) == 0;
} }
__string_cmp :: proc(a, b: string) -> int { __string_cmp :: proc(a, b: string) -> int {
return mem.compare(a.data as rawptr, b.data as rawptr, min(a.count, b.count)); return mem.compare(rawptr(a.data), rawptr(b.data), min(a.count, b.count));
} }
__string_ne :: proc(a, b: string) -> bool #inline { return !__string_eq(a, b); } __string_ne :: proc(a, b: string) -> bool #inline { return !__string_eq(a, b); }
core/fmt.odin
+92 -92
View File
@@ -19,7 +19,7 @@ buffer_write :: proc(buf: ^Buffer, b: []byte) {
} }
} }
buffer_write_string :: proc(buf: ^Buffer, s: string) { buffer_write_string :: proc(buf: ^Buffer, s: string) {
buffer_write(buf, s as []byte); buffer_write(buf, []byte(s));
} }
buffer_write_byte :: proc(buf: ^Buffer, b: byte) { buffer_write_byte :: proc(buf: ^Buffer, b: byte) {
if buf.length < buf.data.count { 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) { buffer_write_rune :: proc(buf: ^Buffer, r: rune) {
if r < utf8.RUNE_SELF { if r < utf8.RUNE_SELF {
buffer_write_byte(buf, r as byte); buffer_write_byte(buf, byte(r));
return; return;
} }
@@ -117,7 +117,7 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
default: default:
buffer_write_string(buf, if info.signed { give "i" } else { give "u"}); buffer_write_string(buf, if info.signed { give "i" } else { give "u"});
fi := Fmt_Info{buf = buf}; fi := Fmt_Info{buf = buf};
fmt_int(^fi, 8*info.size as u64, false, 'd'); fmt_int(^fi, u64(8*info.size), false, 'd');
} }
case Float: case Float:
@@ -142,7 +142,7 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
if info.params == nil { if info.params == nil {
buffer_write_string(buf, "()"); buffer_write_string(buf, "()");
} else { } else {
count := (info.params as ^Tuple).fields.count; count := (^Tuple)(info.params).fields.count;
if count == 1 { buffer_write_string(buf, "("); } if count == 1 { buffer_write_string(buf, "("); }
buffer_write_type(buf, info.params); buffer_write_type(buf, info.params);
if count == 1 { buffer_write_string(buf, ")"); } if count == 1 { buffer_write_string(buf, ")"); }
@@ -170,7 +170,7 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
case Array: case Array:
buffer_write_string(buf, "["); buffer_write_string(buf, "[");
fi := Fmt_Info{buf = buf}; fi := Fmt_Info{buf = buf};
fmt_int(^fi, info.count as u64, false, 'd'); fmt_int(^fi, u64(info.count), false, 'd');
buffer_write_string(buf, "]"); buffer_write_string(buf, "]");
buffer_write_type(buf, info.elem); buffer_write_type(buf, info.elem);
case Slice: case Slice:
@@ -180,7 +180,7 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
case Vector: case Vector:
buffer_write_string(buf, "[vector "); buffer_write_string(buf, "[vector ");
fi := Fmt_Info{buf = buf}; fi := Fmt_Info{buf = buf};
fmt_int(^fi, info.count as u64, false, 'd'); fmt_int(^fi, u64(info.count), false, 'd');
buffer_write_string(buf, "]"); buffer_write_string(buf, "]");
buffer_write_type(buf, info.elem); buffer_write_type(buf, info.elem);
@@ -307,14 +307,14 @@ parse_int :: proc(s: string, offset: int) -> (int, int, bool) {
i := 0; i := 0;
for _ : offset..<s.count { for _ : offset..<s.count {
c := s[offset] as rune; c := rune(s[offset]);
if !is_digit(c) { if !is_digit(c) {
break; break;
} }
i += 1; i += 1;
result *= 10; result *= 10;
result += (c - '0') as int; result += int(c - '0');
} }
return result, offset, i != 0; return result, offset, i != 0;
@@ -361,14 +361,14 @@ int_from_arg :: proc(args: []any, arg_index: int) -> (int, int, bool) {
arg.type_info = type_info_base(arg.type_info); arg.type_info = type_info_base(arg.type_info);
match type i : arg { match type i : arg {
case int: num = i; case int: num = i;
case i8: num = i as int; case i8: num = int(i);
case i16: num = i as int; case i16: num = int(i);
case i32: num = i as int; case i32: num = int(i);
case i64: num = i as int; case i64: num = int(i);
case u8: num = i as int; case u8: num = int(i);
case u16: num = i as int; case u16: num = int(i);
case u32: num = i as int; case u32: num = int(i);
case u64: num = i as int; case u64: num = int(i);
default: default:
ok = false; ok = false;
} }
@@ -421,7 +421,7 @@ fmt_write_padding :: proc(fi: ^Fmt_Info, width: int) {
} }
fmt_integer :: proc(fi: ^Fmt_Info, u: u64, base: int, signed: bool, digits: string) { fmt_integer :: proc(fi: ^Fmt_Info, u: u64, base: int, signed: bool, digits: string) {
negative := signed && u as i64 < 0; negative := signed && i64(u) < 0;
if negative { if negative {
u = -u; u = -u;
} }
@@ -461,7 +461,7 @@ fmt_integer :: proc(fi: ^Fmt_Info, u: u64, base: int, signed: bool, digits: stri
panic("fmt_integer: unknown base, whoops"); panic("fmt_integer: unknown base, whoops");
} }
while b := base as u64; u >= b { while b := u64(base); u >= b {
i -= 1; i -= 1;
next := u / b; next := u / b;
buf[i] = digits[u%b]; buf[i] = digits[u%b];
@@ -504,7 +504,7 @@ fmt_integer :: proc(fi: ^Fmt_Info, u: u64, base: int, signed: bool, digits: stri
if !fi.width_set || fi.width == 0 { if !fi.width_set || fi.width == 0 {
buffer_write(fi.buf, buf[i:]); buffer_write(fi.buf, buf[i:]);
} else { } else {
width := fi.width - utf8.rune_count(buf[i:] as string); width := fi.width - utf8.rune_count(string(buf[i:]));
if fi.minus { if fi.minus {
// Right pad // Right pad
buffer_write(fi.buf, buf[i:]); buffer_write(fi.buf, buf[i:]);
@@ -533,9 +533,9 @@ fmt_int :: proc(fi: ^Fmt_Info, u: u64, signed: bool, verb: rune) {
case 'd': fmt_integer(fi, u, 10, signed, __DIGITS_LOWER); 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_LOWER);
case 'X': fmt_integer(fi, u, 16, signed, __DIGITS_UPPER); case 'X': fmt_integer(fi, u, 16, signed, __DIGITS_UPPER);
case 'c': fmt_rune(fi, u as rune); case 'c': fmt_rune(fi, rune(u));
case 'U': case 'U':
r := u as rune; r := rune(u);
if r < 0 || r > utf8.MAX_RUNE { if r < 0 || r > utf8.MAX_RUNE {
fmt_bad_verb(fi, verb); fmt_bad_verb(fi, verb);
} else { } else {
@@ -566,24 +566,24 @@ __TEN_TO_19TH :: 1000000000000000000;
__ddmulthi :: proc(ol: f64, xh, yh: f64) -> f64 { __ddmulthi :: proc(ol: f64, xh, yh: f64) -> f64 {
bt: i64; bt: i64;
oh := xh * yh; oh := xh * yh;
bt = xh transmute i64; bt = transmute(i64, xh);
bt &= (~(0 as u64)<<27) as i64; bt &= i64(~u64(0)<<27);
ahi := bt transmute f64; ahi := transmute(f64, bt);
alo := xh-ahi; alo := xh-ahi;
bt = yh transmute i64; bt = transmute(i64, yh);
bt &= (~(0 as u64)<<27) as i64; bt &= i64(~u64(0)<<27);
bhi := bt transmute f64; bhi := transmute(f64, bt);
blo := yh-bhi; blo := yh-bhi;
return ((ahi*bhi-oh)+ahi*blo+alo*bhi)+alo*blo; return ((ahi*bhi-oh)+ahi*blo+alo*bhi)+alo*blo;
} }
__ddtoi64 :: proc(xh, xl: f64) -> i64 { __ddtoi64 :: proc(xh, xl: f64) -> i64 {
ob := xh as i64; ob := i64(xh);
vh := ob as f64; vh := f64(ob);
ahi := xh-vh; ahi := xh-vh;
t := ahi-xh; t := ahi-xh;
alo := (xh-(ahi-t)) - (vh+t); alo := (xh-(ahi-t)) - (vh+t);
ob += (ahi+alo+xl) as i64; ob += i64(ahi+alo+xl);
return ob; return ob;
} }
@@ -670,9 +670,9 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
e, tens: i32; e, tens: i32;
d: f64 = val; d: f64 = val;
bits := d transmute i64; bits := transmute(i64, d);
expo := (bits>>52 & 2047) as i32; expo := i32(bits>>52 & 2047);
neg := (bits>>63) as i32 != 0; neg := i32(bits>>63) != 0;
if neg { if neg {
d = -d; d = -d;
} }
@@ -692,7 +692,7 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
if bits<<1 == 0 { if bits<<1 == 0 {
decimal_pos^ = 1; decimal_pos^ = 1;
out[0] = '0'; out[0] = '0';
start^ = out[:1] as string; start^ = string(out[:1]);
return neg; return neg;
} }
// find the right expo for denormals // find the right expo for denormals
@@ -721,7 +721,7 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
bits = __ddtoi64(ph, pl); bits = __ddtoi64(ph, pl);
// check if we undershot // check if we undershot
if bits as u64 >= __TEN_TO_19TH { if f64(bits) >= __TEN_TO_19TH {
tens += 1; tens += 1;
} }
} }
@@ -737,10 +737,10 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
if frac_digits < 24 { if frac_digits < 24 {
skip := false; skip := false;
dg: u32 = 1; dg: u32 = 1;
if bits as u64 >= __powten[9] { if u64(bits) >= __powten[9] {
dg = 10; dg = 10;
} }
while bits as u64 >= __powten[dg] { while u64(bits) >= __powten[dg] {
dg += 1; dg += 1;
if dg == 20 { if dg == 20 {
skip = true; skip = true;
@@ -751,14 +751,14 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
if (!skip) { if (!skip) {
r: u64; r: u64;
// add 0.5 at the right position and round // add 0.5 at the right position and round
e = dg as i32 - frac_digits; e = i32(dg) - frac_digits;
if e as u32 < 24 { if u32(e) < 24 {
r = __powten[e]; r = __powten[e];
bits += (r/2) as i64; bits += i64(r/2);
if bits as u64 >= __powten[dg] { if u64(bits) >= __powten[dg] {
tens += 1; tens += 1;
} }
bits /= r as i64; bits /= i64(r);
} }
} }
} }
@@ -777,11 +777,11 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
bits /= 1000; bits /= 1000;
} }
if !skip { if !skip {
n := bits as u32; n := u32(bits);
while n%1000 == 0 { while n%1000 == 0 {
n /= 1000; n /= 1000;
} }
bits = n as i64; bits = i64(n);
} }
} }
@@ -793,15 +793,15 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
o := outp-8; o := outp-8;
// do the conversion in chunks of u32s (avoid most 64-bit divides, worth it, constant denomiators be damned) // do the conversion in chunks of u32s (avoid most 64-bit divides, worth it, constant denomiators be damned)
if bits >= 100000000 { if bits >= 100000000 {
n = (bits%100000000) as u32; n = u32(bits%100000000);
bits /= 100000000; bits /= 100000000;
} else { } else {
n = bits as u32; n = u32(bits);
bits = 0; bits = 0;
} }
while n != 0 { while n != 0 {
outp -= 2; outp -= 2;
(outp as ^u16)^ = (^__digitpair[(n%100)*2] as ^u16)^; (^u16)(outp)^ = (^u16)(^__digitpair[(n%100)*2])^;
n /= 100; n /= 100;
e += 2; e += 2;
} }
@@ -820,7 +820,7 @@ __real_to_string :: proc(start: ^string, out: []byte, decimal_pos: ^i32, val: f6
} }
decimal_pos^ = tens; decimal_pos^ = tens;
start^ = slice_ptr(outp, e) as string; start^ = string(slice_ptr(outp, e));
return neg; return neg;
} }
@@ -839,18 +839,18 @@ generic_ftoa :: proc(buf: []byte, val: f64, verb: rune, prec, bit_size: int) ->
flt: ^Float_Info; flt: ^Float_Info;
match bit_size { match bit_size {
case 32: case 32:
bits = ((val as f32) transmute u32) as u64; bits = u64(transmute(u32, f32(val)));
flt = ^f32info; flt = ^f32info;
case 64: case 64:
bits = val transmute u64; bits = u64(val);
flt = ^f64info; flt = ^f64info;
default: default:
panic("illegal float bit_size"); panic("illegal float bit_size");
} }
neg := bits>>(flt.expbits+flt.mantbits) != 0; neg := bits>>(flt.expbits+flt.mantbits) != 0;
exp := (bits>>flt.mantbits) as int & (1<<flt.expbits - 1); exp := int(bits>>flt.mantbits) & (1<<flt.expbits - 1);
mant := bits & ((1 as u64)<<flt.mantbits - 1); mant := bits & (u64(1)<<flt.mantbits - 1);
match exp { match exp {
case 1<<flt.expbits-1: case 1<<flt.expbits-1:
@@ -860,13 +860,13 @@ generic_ftoa :: proc(buf: []byte, val: f64, verb: rune, prec, bit_size: int) ->
case neg: s = "-Inf"; case neg: s = "-Inf";
default: s = "+Inf"; default: s = "+Inf";
} }
copy(buf, s as []byte); copy(buf, []byte(s));
return buf[:s.count]; return buf[:s.count];
case 0: // denormalized case 0: // denormalized
exp+=1; exp+=1;
default: // add implicit top bit default: // add implicit top bit
mant |= (1 as u64)<<flt.mantbits; mant |= u64(1)<<flt.mantbits;
} }
@@ -924,7 +924,7 @@ fmt_pointer :: proc(fi: ^Fmt_Info, p: rawptr, verb: rune) {
fmt_bad_verb(fi, verb); fmt_bad_verb(fi, verb);
return; return;
} }
u := p as uint as u64; u := u64(uint(p));
if !fi.hash || verb == 'v' { if !fi.hash || verb == 'v' {
buffer_write_string(fi.buf, "0x"); buffer_write_string(fi.buf, "0x");
} }
@@ -952,18 +952,18 @@ fmt_enum :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
ok := false; ok := false;
a := any{type_info_base(e.base), v.data}; a := any{type_info_base(e.base), v.data};
match type v : a { match type v : a {
case i8: i = v as i64; case i8: i = i64(v);
case i16: i = v as i64; case i16: i = i64(v);
case i32: i = v as i64; case i32: i = i64(v);
case i64: i = v as i64; case i64: i = i64(v);
case int: i = v as i64; case int: i = i64(v);
case u8: i = v as i64; case u8: i = i64(v);
case u16: i = v as i64; case u16: i = i64(v);
case u32: i = v as i64; case u32: i = i64(v);
case u64: i = v as i64; case u64: i = i64(v);
case uint: i = v as i64; case uint: i = i64(v);
case f32: f = v as f64; case f32: f = f64(v);
case f64: f = v as f64; case f64: f = f64(v);
} }
if is_type_integer(e.base) { if is_type_integer(e.base) {
@@ -1019,8 +1019,8 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
buffer_write_string(fi.buf, f.name); buffer_write_string(fi.buf, f.name);
// bprint_any(fi.buf, f.offset); // bprint_any(fi.buf, f.offset);
buffer_write_string(fi.buf, " = "); buffer_write_string(fi.buf, " = ");
data := v.data as ^byte + f.offset; data := (^byte)(v.data) + f.offset;
fmt_arg(fi, any{f.type_info, data as rawptr}, 'v'); fmt_arg(fi, any{f.type_info, rawptr(data)}, 'v');
} }
buffer_write_byte(fi.buf, '}'); buffer_write_byte(fi.buf, '}');
@@ -1035,15 +1035,15 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
case Pointer: case Pointer:
if v.type_info == type_info(^Type_Info) { if v.type_info == type_info(^Type_Info) {
buffer_write_type(fi.buf, (v.data as ^^Type_Info)^); buffer_write_type(fi.buf, (^^Type_Info)(v.data)^);
} else { } else {
fmt_pointer(fi, (v.data as ^rawptr)^, verb); fmt_pointer(fi, (^rawptr)(v.data)^, verb);
} }
case Maybe: case Maybe:
// TODO(bill): Correct verbs for Maybe types? // TODO(bill): Correct verbs for Maybe types?
size := mem.size_of_type_info(info.elem); size := mem.size_of_type_info(info.elem);
data := slice_ptr(v.data as ^byte, size+1); data := slice_ptr((^byte)(v.data), size+1);
if data[size] != 0 { if data[size] != 0 {
fmt_arg(fi, any{info.elem, v.data}, verb); fmt_arg(fi, any{info.elem, v.data}, verb);
} else { } else {
@@ -1062,8 +1062,8 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
if i > 0 { if i > 0 {
buffer_write_string(fi.buf, ", "); buffer_write_string(fi.buf, ", ");
} }
data := v.data as ^byte + i*info.elem_size; data := (^byte)(v.data) + i*info.elem_size;
fmt_arg(fi, any{info.elem, data as rawptr}, 'v'); fmt_arg(fi, any{info.elem, rawptr(data)}, 'v');
} }
case Slice: case Slice:
@@ -1074,13 +1074,13 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
buffer_write_byte(fi.buf, '['); buffer_write_byte(fi.buf, '[');
defer buffer_write_byte(fi.buf, ']'); defer buffer_write_byte(fi.buf, ']');
slice := v.data as ^[]byte; slice := (^[]byte)(v.data);
for i : 0..<slice.count { for i : 0..<slice.count {
if i > 0 { if i > 0 {
buffer_write_string(fi.buf, ", "); buffer_write_string(fi.buf, ", ");
} }
data := slice.data + i*info.elem_size; data := slice.data + i*info.elem_size;
fmt_arg(fi, any{info.elem, data as rawptr}, 'v'); fmt_arg(fi, any{info.elem, rawptr(data)}, 'v');
} }
case Vector: case Vector:
@@ -1106,8 +1106,8 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
buffer_write_string(fi.buf, ", "); buffer_write_string(fi.buf, ", ");
} }
data := v.data as ^byte + i*info.elem_size; data := (^byte)(v.data) + i*info.elem_size;
fmt_value(fi, any{info.elem, data as rawptr}, 'v'); fmt_value(fi, any{info.elem, rawptr(data)}, 'v');
} }
case Struct: case Struct:
@@ -1120,9 +1120,9 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
} }
buffer_write_string(fi.buf, f.name); buffer_write_string(fi.buf, f.name);
buffer_write_string(fi.buf, " = "); buffer_write_string(fi.buf, " = ");
data := v.data as ^byte + f.offset; data := (^byte)(v.data) + f.offset;
ti := f.type_info; ti := f.type_info;
fmt_value(fi, any{ti, data as rawptr}, 'v'); fmt_value(fi, any{ti, rawptr(data)}, 'v');
} }
case Union: case Union:
@@ -1136,7 +1136,7 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
case Procedure: case Procedure:
buffer_write_type(fi.buf, v.type_info); buffer_write_type(fi.buf, v.type_info);
buffer_write_string(fi.buf, " @ "); buffer_write_string(fi.buf, " @ ");
fmt_pointer(fi, (v.data as ^rawptr)^, 'p'); fmt_pointer(fi, (^rawptr)(v.data)^, 'p');
} }
} }
@@ -1161,19 +1161,19 @@ fmt_arg :: proc(fi: ^Fmt_Info, arg: any, verb: rune) {
base_arg.type_info = type_info_base(base_arg.type_info); base_arg.type_info = type_info_base(base_arg.type_info);
match type a : base_arg { match type a : base_arg {
case bool: fmt_bool(fi, a, verb); case bool: fmt_bool(fi, a, verb);
case f32: fmt_float(fi, a as f64, 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);
case int: fmt_int(fi, a as u64, true, verb); case int: fmt_int(fi, u64(a), true, verb);
case i8: fmt_int(fi, a as u64, true, verb); case i8: fmt_int(fi, u64(a), true, verb);
case i16: fmt_int(fi, a as u64, true, verb); case i16: fmt_int(fi, u64(a), true, verb);
case i32: fmt_int(fi, a as u64, true, verb); case i32: fmt_int(fi, u64(a), true, verb);
case i64: fmt_int(fi, a as u64, true, verb); case i64: fmt_int(fi, u64(a), true, verb);
case uint: fmt_int(fi, a as u64, false, verb); case uint: fmt_int(fi, u64(a), false, verb);
case u8: fmt_int(fi, a as u64, false, verb); case u8: fmt_int(fi, u64(a), false, verb);
case u16: fmt_int(fi, a as u64, false, verb); case u16: fmt_int(fi, u64(a), false, verb);
case u32: fmt_int(fi, a as u64, false, verb); case u32: fmt_int(fi, u64(a), false, verb);
case u64: fmt_int(fi, a as u64, false, verb); case u64: fmt_int(fi, u64(a), false, verb);
case string: fmt_string(fi, a, verb); case string: fmt_string(fi, a, verb);
default: fmt_value(fi, arg, 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 { crc32 :: proc(data: rawptr, len: int) -> u32 {
result := ~(0 as u32); result := ~u32(0);
s := slice_ptr(data as ^u8, len); s := slice_ptr((^u8)(data), len);
for i : 0..<len { for i : 0..<len {
b := s[i] as u32; b := u32(s[i]);
result = result>>8 ~ __CRC32_TABLE[(result ~ b) & 0xff]; result = result>>8 ~ __CRC32_TABLE[(result ~ b) & 0xff];
} }
return ~result; return ~result;
} }
crc64 :: proc(data: rawptr, len: int) -> u64 { crc64 :: proc(data: rawptr, len: int) -> u64 {
result := ~(0 as u64); result := ~u64(0);
s := slice_ptr(data as ^u8, len); s := slice_ptr((^u8)(data), len);
for i : 0..<len { for i : 0..<len {
b := s[i] as u64; b := u64(s[i]);
result = result>>8 ~ __CRC64_TABLE[(result ~ b) & 0xff]; result = result>>8 ~ __CRC64_TABLE[(result ~ b) & 0xff];
} }
return ~result; return ~result;
} }
fnv32 :: proc(data: rawptr, len: int) -> u32 { fnv32 :: proc(data: rawptr, len: int) -> u32 {
s := slice_ptr(data as ^u8, len); s := slice_ptr((^u8)(data), len);
h: u32 = 0x811c9dc5; h: u32 = 0x811c9dc5;
for i : 0..<len { for i : 0..<len {
h = (h * 0x01000193) ~ s[i] as u32; h = (h * 0x01000193) ~ u32(s[i]);
} }
return h; return h;
} }
fnv64 :: proc(data: rawptr, len: int) -> u64 { fnv64 :: proc(data: rawptr, len: int) -> u64 {
s := slice_ptr(data as ^u8, len); s := slice_ptr((^u8)(data), len);
h: u64 = 0xcbf29ce484222325; h: u64 = 0xcbf29ce484222325;
for i : 0..<len { for i : 0..<len {
h = (h * 0x100000001b3) ~ s[i] as u64; h = (h * 0x100000001b3) ~ u64(s[i]);
} }
return h; return h;
} }
fnv32a :: proc(data: rawptr, len: int) -> u32 { fnv32a :: proc(data: rawptr, len: int) -> u32 {
s := slice_ptr(data as ^u8, len); s := slice_ptr((^u8)(data), len);
h: u32 = 0x811c9dc5; h: u32 = 0x811c9dc5;
for i : 0..<len { for i : 0..<len {
h = (h ~ s[i] as u32) * 0x01000193; h = (h ~ u32(s[i])) * 0x01000193;
} }
return h; return h;
} }
fnv64a :: proc(data: rawptr, len: int) -> u64 { fnv64a :: proc(data: rawptr, len: int) -> u64 {
s := slice_ptr(data as ^u8, len); s := slice_ptr((^u8)(data), len);
h :u64 = 0xcbf29ce484222325; h :u64 = 0xcbf29ce484222325;
for i : 0..<len { for i : 0..<len {
h = (h ~ s[i] as u64) * 0x100000001b3; h = (h ~ u64(s[i])) * 0x100000001b3;
} }
return h; return h;
} }
@@ -65,10 +65,10 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {
m :: 0xc6a4a7935bd1e995; m :: 0xc6a4a7935bd1e995;
r :: 47; r :: 47;
h: u64 = SEED ~ (len as u64 * m); h: u64 = SEED ~ (u64(len) * m);
data := slice_ptr(data_ as ^u64, len/size_of(u64)); data := slice_ptr((^u64)(data_), len/size_of(u64));
data2 := slice_ptr(data_ as ^u8, len); data2 := slice_ptr((^u8)(data_), len);
for i : 0 ..< data.count { for i : 0 ..< data.count {
k := data[i]; k := data[i];
@@ -82,14 +82,14 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {
} }
match len & 7 { match len & 7 {
case 7: h ~= data2[6] as u64 << 48; fallthrough; case 7: h ~= u64(data2[6]) << 48; fallthrough;
case 6: h ~= data2[5] as u64 << 40; fallthrough; case 6: h ~= u64(data2[5]) << 40; fallthrough;
case 5: h ~= data2[4] as u64 << 32; fallthrough; case 5: h ~= u64(data2[4]) << 32; fallthrough;
case 4: h ~= data2[3] as u64 << 24; fallthrough; case 4: h ~= u64(data2[3]) << 24; fallthrough;
case 3: h ~= data2[2] as u64 << 16; fallthrough; case 3: h ~= u64(data2[2]) << 16; fallthrough;
case 2: h ~= data2[1] as u64 << 8; fallthrough; case 2: h ~= u64(data2[1]) << 8; fallthrough;
case 1: case 1:
h ~= data2[0] as u64; h ~= u64(data2[0]);
h *= m; h *= m;
} }
@@ -102,10 +102,10 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {
m :: 0x5bd1e995; m :: 0x5bd1e995;
r :: 24; r :: 24;
h1: u32 = SEED as u32 ~ len as u32; h1: u32 = u32(SEED) ~ u32(len);
h2: u32 = SEED >> 32; h2: u32 = SEED >> 32;
data := slice_ptr(data_ as ^u32, len/size_of(u32)); data := slice_ptr((^u32)(data_), len/size_of(u32));
i := 0; i := 0;
while len >= 8 { while len >= 8 {
@@ -138,13 +138,13 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {
len -= 4; len -= 4;
} }
data8 := slice_ptr((data.data+i) as ^u8, 3); // NOTE(bill): This is unsafe data8 := slice_ptr((^u8)(data.data+i), 3); // NOTE(bill): This is unsafe
match len { match len {
case 3: h2 ~= data8[2] as u32 << 16; fallthrough; case 3: h2 ~= u32(data8[2]) << 16; fallthrough;
case 2: h2 ~= data8[1] as u32 << 8; fallthrough; case 2: h2 ~= u32(data8[1]) << 8; fallthrough;
case 1: case 1:
h2 ~= data8[0] as u32; h2 ~= u32(data8[0]);
h2 *= m; h2 *= m;
} }
@@ -157,7 +157,7 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {
h2 ~= h1>>19; h2 ~= h1>>19;
h2 *= m; h2 *= m;
h := (h1 as u64)<<32 | h2 as u64; h := u64(h1)<<32 | u64(h2);
return h; return h;
} }
} }
core/math.odin
+7 -7
View File
@@ -45,11 +45,11 @@ sign :: proc(x: f64) -> f64 { if x >= 0 { return +1; } return -1; }
copy_sign :: proc(x, y: f32) -> f32 { copy_sign :: proc(x, y: f32) -> f32 {
ix := x transmute u32; ix := transmute(u32, x);
iy := y transmute u32; iy := transmute(u32, y);
ix &= 0x7fffffff; ix &= 0x7fffffff;
ix |= iy & 0x80000000; ix |= iy & 0x80000000;
return ix transmute f32; return transmute(f32, ix);
} }
round :: proc(x: f32) -> f32 { round :: proc(x: f32) -> f32 {
if x >= 0 { if x >= 0 {
@@ -59,15 +59,15 @@ round :: proc(x: f32) -> f32 {
} }
floor :: proc(x: f32) -> f32 { floor :: proc(x: f32) -> f32 {
if x >= 0 { if x >= 0 {
return x as int as f32; return f32(int(x));
} }
return (x-0.5) as int as f32; return f32(int(x-0.5));
} }
ceil :: proc(x: f32) -> f32 { ceil :: proc(x: f32) -> f32 {
if x < 0 { if x < 0 {
return x as int as f32; return f32(int(x));
} }
return ((x as int)+1) as f32; return f32(int(x)+1);
} }
remainder32 :: proc(x, y: f32) -> f32 { 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" { 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 :: proc(dst: rawptr, val: byte, len: int, align: i32, is_volatile: bool) #foreign "llvm.memset.p0i8.i64"
llvm_memset_64bit(data, value as byte, len, 1, false); llvm_memset_64bit(data, byte(value), len, 1, false);
return data; 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" { compare :: proc(dst, src: rawptr, n: int) -> int #link_name "__mem_compare" {
a := slice_ptr(dst as ^byte, n); a := slice_ptr((^byte)(dst), n);
b := slice_ptr(src as ^byte, n); b := slice_ptr((^byte)(src), n);
for i : 0..<n { for i : 0..<n {
match { match {
case a[i] < b[i]: 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 { align_forward :: proc(ptr: rawptr, align: int) -> rawptr {
assert(is_power_of_two(align)); assert(is_power_of_two(align));
a := align as uint; a := uint(align);
p := ptr as uint; p := uint(ptr);
modulo := p & (a-1); modulo := p & (a-1);
if modulo != 0 { if modulo != 0 {
p += a - modulo; p += a - modulo;
} }
return p as rawptr; return rawptr(p);
} }
@@ -73,19 +73,19 @@ Allocation_Header :: struct {
allocation_header_fill :: proc(header: ^Allocation_Header, data: rawptr, size: int) { allocation_header_fill :: proc(header: ^Allocation_Header, data: rawptr, size: int) {
header.size = size; header.size = size;
ptr := (header+1) as ^int; ptr := (^int)(header+1);
while i := 0; ptr as rawptr < data { while i := 0; rawptr(ptr) < data {
(ptr+i)^ = -1; (ptr+i)^ = -1;
i += 1; i += 1;
} }
} }
allocation_header :: proc(data: rawptr) -> ^Allocation_Header { allocation_header :: proc(data: rawptr) -> ^Allocation_Header {
p := data as ^int; p := (^int)(data);
while (p-1)^ == -1 { while (p-1)^ == -1 {
p = (p-1); p = (p-1);
} }
return (p as ^Allocation_Header)-1; return (^Allocation_Header)(p)-1;
} }
@@ -142,7 +142,7 @@ arena_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
size, alignment: int, size, alignment: int,
old_memory: rawptr, old_size: int, flags: u64) -> rawptr { old_memory: rawptr, old_size: int, flags: u64) -> rawptr {
using Allocator_Mode; using Allocator_Mode;
arena := allocator_data as ^Arena; arena := (^Arena)(allocator_data);
match mode { match mode {
case ALLOC: case ALLOC:
@@ -235,7 +235,7 @@ align_of_type_info :: proc(type_info: ^Type_Info) -> int {
return WORD_SIZE; return WORD_SIZE;
case Vector: case Vector:
size := size_of_type_info(info.elem); size := size_of_type_info(info.elem);
count := max(prev_pow2(info.count as i64), 1) as int; count := int(max(prev_pow2(i64(info.count)), 1));
total := size * count; total := size * count;
return clamp(total, 1, MAX_ALIGN); return clamp(total, 1, MAX_ALIGN);
case Struct: case Struct:
core/opengl.odin
+2 -2
View File
@@ -30,7 +30,7 @@ GetIntegerv :: proc(name: i32, v: ^i32) #foreign "glGetIntegerv"
_libgl := win32.LoadLibraryA(("opengl32.dll\x00" as string).data); _libgl := win32.LoadLibraryA(string("opengl32.dll\x00").data);
GetProcAddress :: proc(name: string) -> proc() #cc_c { GetProcAddress :: proc(name: string) -> proc() #cc_c {
assert(name[name.count-1] == 0); 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; GetUniformLocation: proc(program: u32, name: ^byte) -> i32 #cc_c;
init :: proc() { init :: proc() {
set_proc_address :: proc(p: rawptr, name: string) #inline { (p as ^(proc() #cc_c))^ = GetProcAddress(name); } set_proc_address :: proc(p: rawptr, name: string) #inline { (^(proc() #cc_c))(p)^ = GetProcAddress(name); }
set_proc_address(^GenBuffers, "glGenBuffers\x00"); set_proc_address(^GenBuffers, "glGenBuffers\x00");
set_proc_address(^GenVertexArrays, "glGenVertexArrays\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; access |= FILE_APPEND_DATA;
} }
share_mode := (FILE_SHARE_READ|FILE_SHARE_WRITE) as u32; share_mode := u32(FILE_SHARE_READ|FILE_SHARE_WRITE);
sa: ^SECURITY_ATTRIBUTES = nil; sa: ^SECURITY_ATTRIBUTES = nil;
sa_inherit := SECURITY_ATTRIBUTES{length = size_of(SECURITY_ATTRIBUTES), inherit_handle = 1}; sa_inherit := SECURITY_ATTRIBUTES{length = size_of(SECURITY_ATTRIBUTES), inherit_handle = 1};
if mode&O_CLOEXEC == 0 { if mode&O_CLOEXEC == 0 {
@@ -95,38 +95,38 @@ open :: proc(path: string, mode: int, perm: u32) -> (Handle, Errno) {
} }
buf: [300]byte; buf: [300]byte;
copy(buf[:], path as []byte); copy(buf[:], []byte(path));
handle := CreateFileA(^buf[0], access, share_mode, sa, create_mode, FILE_ATTRIBUTE_NORMAL, nil) as Handle; handle := Handle(CreateFileA(^buf[0], access, share_mode, sa, create_mode, FILE_ATTRIBUTE_NORMAL, nil));
if handle != INVALID_HANDLE { if handle != INVALID_HANDLE {
return handle, ERROR_NONE; return handle, ERROR_NONE;
} }
err := GetLastError(); err := GetLastError();
return INVALID_HANDLE, err as Errno; return INVALID_HANDLE, Errno(err);
} }
close :: proc(fd: Handle) { close :: proc(fd: Handle) {
win32.CloseHandle(fd as win32.HANDLE); win32.CloseHandle(win32.HANDLE(fd));
} }
write :: proc(fd: Handle, data: []byte) -> (int, Errno) { write :: proc(fd: Handle, data: []byte) -> (int, Errno) {
bytes_written: i32; bytes_written: i32;
e := win32.WriteFile(fd as win32.HANDLE, data.data, data.count as i32, ^bytes_written, nil); e := win32.WriteFile(win32.HANDLE(fd), data.data, i32(data.count), ^bytes_written, nil);
if e == win32.FALSE { if e == win32.FALSE {
err := win32.GetLastError(); err := win32.GetLastError();
return 0, err as Errno; return 0, Errno(err);
} }
return bytes_written as int, ERROR_NONE; return int(bytes_written), ERROR_NONE;
} }
read :: proc(fd: Handle, data: []byte) -> (int, Errno) { read :: proc(fd: Handle, data: []byte) -> (int, Errno) {
bytes_read: i32; bytes_read: i32;
e := win32.ReadFile(fd as win32.HANDLE, data.data, data.count as u32, ^bytes_read, nil); e := win32.ReadFile(win32.HANDLE(fd), data.data, u32(data.count), ^bytes_read, nil);
if e == win32.FALSE { if e == win32.FALSE {
err := win32.GetLastError(); err := win32.GetLastError();
return 0, err as Errno; return 0, Errno(err);
} }
return bytes_read as int, ERROR_NONE; return int(bytes_read), ERROR_NONE;
} }
seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) { 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 1: w = FILE_CURRENT;
case 2: w = FILE_END; case 2: w = FILE_END;
} }
hi := (offset>>32) as i32; hi := i32(offset>>32);
lo := offset as i32; lo := i32(offset);
ft := GetFileType(fd as HANDLE); ft := GetFileType(HANDLE(fd));
if ft == FILE_TYPE_PIPE { if ft == FILE_TYPE_PIPE {
return 0, ERROR_FILE_IS_PIPE; return 0, ERROR_FILE_IS_PIPE;
} }
dw_ptr := SetFilePointer(fd as HANDLE, lo, ^hi, w); dw_ptr := SetFilePointer(HANDLE(fd), lo, ^hi, w);
if dw_ptr == INVALID_SET_FILE_POINTER { if dw_ptr == INVALID_SET_FILE_POINTER {
err := GetLastError(); err := GetLastError();
return 0, err as Errno; return 0, Errno(err);
} }
return (hi as i64)<<32 + (dw_ptr as i64), ERROR_NONE; return i64(hi)<<32 + i64(dw_ptr), ERROR_NONE;
} }
@@ -159,9 +159,9 @@ stderr := get_std_handle(win32.STD_ERROR_HANDLE);
get_std_handle :: proc(h: int) -> Handle { get_std_handle :: proc(h: int) -> Handle {
fd := win32.GetStdHandle(h as i32); fd := win32.GetStdHandle(i32(h));
win32.SetHandleInformation(fd, win32.HANDLE_FLAG_INHERIT, 0); win32.SetHandleInformation(fd, win32.HANDLE_FLAG_INHERIT, 0);
return fd as Handle; return Handle(fd);
} }
@@ -171,9 +171,9 @@ get_std_handle :: proc(h: int) -> Handle {
last_write_time :: proc(fd: Handle) -> File_Time { last_write_time :: proc(fd: Handle) -> File_Time {
file_info: win32.BY_HANDLE_FILE_INFORMATION; file_info: win32.BY_HANDLE_FILE_INFORMATION;
win32.GetFileInformationByHandle(fd as win32.HANDLE, ^file_info); win32.GetFileInformationByHandle(win32.HANDLE(fd), ^file_info);
lo := file_info.last_write_time.lo as File_Time; lo := File_Time(file_info.last_write_time.lo);
hi := file_info.last_write_time.hi as File_Time; hi := File_Time(file_info.last_write_time.hi);
return lo | hi << 32; return lo | hi << 32;
} }
@@ -184,14 +184,14 @@ last_write_time_by_name :: proc(name: string) -> File_Time {
assert(buf.count > name.count); assert(buf.count > name.count);
copy(buf[:], name as []byte); copy(buf[:], []byte(name));
if win32.GetFileAttributesExA(^buf[0], win32.GetFileExInfoStandard, ^data) != 0 { if win32.GetFileAttributesExA(^buf[0], win32.GetFileExInfoStandard, ^data) != 0 {
last_write_time = data.last_write_time; last_write_time = data.last_write_time;
} }
l := last_write_time.lo as File_Time; l := File_Time(last_write_time.lo);
h := last_write_time.hi as File_Time; h := File_Time(last_write_time.hi);
return l | h << 32; 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) { read_entire_file :: proc(name: string) -> ([]byte, bool) {
buf: [300]byte; buf: [300]byte;
copy(buf[:], name as []byte); copy(buf[:], []byte(name));
fd, err := open(name, O_RDONLY, 0); fd, err := open(name, O_RDONLY, 0);
if err != ERROR_NONE { if err != ERROR_NONE {
@@ -210,7 +210,7 @@ read_entire_file :: proc(name: string) -> ([]byte, bool) {
defer close(fd); defer close(fd);
length: i64; length: i64;
file_size_ok := win32.GetFileSizeEx(fd as win32.HANDLE, ^length) != 0; file_size_ok := win32.GetFileSizeEx(win32.HANDLE(fd), ^length) != 0;
if !file_size_ok { if !file_size_ok {
return nil, false; return nil, false;
} }
@@ -228,18 +228,18 @@ read_entire_file :: proc(name: string) -> ([]byte, bool) {
to_read: u32; to_read: u32;
MAX :: 1<<32-1; MAX :: 1<<32-1;
if remaining <= MAX { if remaining <= MAX {
to_read = remaining as u32; to_read = u32(remaining);
} else { } else {
to_read = MAX; to_read = MAX;
} }
win32.ReadFile(fd as win32.HANDLE, ^data[total_read], to_read, ^single_read_length, nil); win32.ReadFile(win32.HANDLE(fd), ^data[total_read], to_read, ^single_read_length, nil);
if single_read_length <= 0 { if single_read_length <= 0 {
free(data.data); free(data.data);
return nil, false; return nil, false;
} }
total_read += single_read_length as i64; total_read += i64(single_read_length);
} }
return data, true; return data, true;
@@ -259,14 +259,14 @@ heap_free :: proc(ptr: rawptr) {
exit :: proc(code: int) { exit :: proc(code: int) {
win32.ExitProcess(code as u32); win32.ExitProcess(u32(code));
} }
current_thread_id :: proc() -> int { current_thread_id :: proc() -> int {
GetCurrentThreadId :: proc() -> u32 #foreign #dll_import GetCurrentThreadId :: proc() -> u32 #foreign #dll_import
return GetCurrentThreadId() as int; return int(GetCurrentThreadId());
} }
core/sync.odin
+2 -2
View File
@@ -13,7 +13,7 @@ Mutex :: struct {
} }
current_thread_id :: proc() -> i32 { current_thread_id :: proc() -> i32 {
return win32.GetCurrentThreadId() as i32; return i32(win32.GetCurrentThreadId());
} }
semaphore_init :: proc(s: ^Semaphore) { semaphore_init :: proc(s: ^Semaphore) {
@@ -25,7 +25,7 @@ semaphore_destroy :: proc(s: ^Semaphore) {
} }
semaphore_post :: proc(s: ^Semaphore, count: int) { semaphore_post :: proc(s: ^Semaphore, count: int) {
win32.ReleaseSemaphore(s.handle, count as i32, nil); win32.ReleaseSemaphore(s.handle, i32(count), nil);
} }
semaphore_release :: proc(s: ^Semaphore) #inline { semaphore_post(s, 1); } semaphore_release :: proc(s: ^Semaphore) #inline { semaphore_post(s, 1); }
core/sys/windows.odin
+3 -3
View File
@@ -19,7 +19,7 @@ BOOL :: i32;
WNDPROC :: type proc(HWND, u32, WPARAM, LPARAM) -> LRESULT #cc_c; WNDPROC :: type proc(HWND, u32, WPARAM, LPARAM) -> LRESULT #cc_c;
INVALID_HANDLE_VALUE :: ~int(0) as HANDLE; INVALID_HANDLE_VALUE :: HANDLE(~int(0));
FALSE: BOOL : 0; FALSE: BOOL : 0;
TRUE: BOOL : 1; TRUE: BOOL : 1;
@@ -233,7 +233,7 @@ FILE_TYPE_DISK :: 0x0001;
FILE_TYPE_CHAR :: 0x0002; FILE_TYPE_CHAR :: 0x0002;
FILE_TYPE_PIPE :: 0x0003; FILE_TYPE_PIPE :: 0x0003;
INVALID_SET_FILE_POINTER :: ~(0 as u32); INVALID_SET_FILE_POINTER :: ~u32(0);
@@ -402,7 +402,7 @@ wglDeleteContext :: proc(hglrc: HGLRC) -> BOOL #foreign #dll_import
GetKeyState :: proc(v_key: i32) -> i16 #foreign #dll_import GetKeyState :: proc(v_key: i32) -> i16 #foreign #dll_import
GetAsyncKeyState :: 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(key as i32) < 0; } is_key_down :: proc(key: Key_Code) -> bool #inline { return GetAsyncKeyState(i32(key)) < 0; }
Key_Code :: enum i32 { Key_Code :: enum i32 {
LBUTTON = 0x01, LBUTTON = 0x01,
core/utf8.odin
+20 -20
View File
@@ -1,7 +1,7 @@
RUNE_ERROR :: '\ufffd'; RUNE_ERROR :: '\ufffd';
RUNE_SELF :: 0x80; RUNE_SELF :: 0x80;
RUNE_BOM :: 0xfeff; RUNE_BOM :: 0xfeff;
RUNE_EOF :: ~(0 as rune); RUNE_EOF :: ~rune(0);
MAX_RUNE :: '\U0010ffff'; MAX_RUNE :: '\U0010ffff';
UTF_MAX :: 4; UTF_MAX :: 4;
@@ -40,15 +40,15 @@ accept_sizes := [256]byte{
encode_rune :: proc(r: rune) -> ([4]byte, int) { encode_rune :: proc(r: rune) -> ([4]byte, int) {
buf: [4]byte; buf: [4]byte;
i := r as u32; i := u32(r);
mask: byte : 0x3f; mask: byte : 0x3f;
if i <= 1<<7-1 { if i <= 1<<7-1 {
buf[0] = r as byte; buf[0] = byte(r);
return buf, 1; return buf, 1;
} }
if i <= 1<<11-1 { if i <= 1<<11-1 {
buf[0] = 0xc0 | (r>>6) as byte; buf[0] = 0xc0 | byte(r>>6);
buf[1] = 0x80 | (r) as byte & mask; buf[1] = 0x80 | byte(r) & mask;
return buf, 2; return buf, 2;
} }
@@ -59,16 +59,16 @@ encode_rune :: proc(r: rune) -> ([4]byte, int) {
} }
if i <= 1<<16-1 { if i <= 1<<16-1 {
buf[0] = 0xe0 | (r>>12) as byte; buf[0] = 0xe0 | byte(r>>12);
buf[1] = 0x80 | (r>>6) as byte & mask; buf[1] = 0x80 | byte(r>>6) & mask;
buf[2] = 0x80 | (r) as byte & mask; buf[2] = 0x80 | byte(r) & mask;
return buf, 3; return buf, 3;
} }
buf[0] = 0xf0 | (r>>18) as byte; buf[0] = 0xf0 | byte(r>>18);
buf[1] = 0x80 | (r>>12) as byte & mask; buf[1] = 0x80 | byte(r>>12) & mask;
buf[2] = 0x80 | (r>>6) as byte & mask; buf[2] = 0x80 | byte(r>>6) & mask;
buf[3] = 0x80 | (r) as byte & mask; buf[3] = 0x80 | byte(r) & mask;
return buf, 4; return buf, 4;
} }
@@ -80,12 +80,12 @@ decode_rune :: proc(s: string) -> (rune, int) {
b0 := s[0]; b0 := s[0];
x := accept_sizes[b0]; x := accept_sizes[b0];
if x >= 0xf0 { if x >= 0xf0 {
mask := (x as rune << 31) >> 31; // all zeros or all ones mask := (rune(x) << 31) >> 31; // all zeros or all ones
return (b0 as rune) &~ mask | RUNE_ERROR&mask, 1; return rune(b0) &~ mask | RUNE_ERROR&mask, 1;
} }
size := x & 7; size := x & 7;
ar := accept_ranges[x>>4]; ar := accept_ranges[x>>4];
if n < size as int { if n < int(size) {
return RUNE_ERROR, 1; return RUNE_ERROR, 1;
} }
b1 := s[1]; b1 := s[1];
@@ -99,20 +99,20 @@ decode_rune :: proc(s: string) -> (rune, int) {
MASK_4 :: 0b00000111; MASK_4 :: 0b00000111;
if size == 2 { if size == 2 {
return (b0&MASK_2) as rune <<6 | (b1&MASK_X) as rune, 2; return rune(b0&MASK_2)<<6 | rune(b1&MASK_X), 2;
} }
b2 := s[2]; b2 := s[2];
if b2 < 0x80 || 0xbf < b2 { if b2 < 0x80 || 0xbf < b2 {
return RUNE_ERROR, 1; return RUNE_ERROR, 1;
} }
if size == 3 { if size == 3 {
return (b0&MASK_3) as rune <<12 | (b1&MASK_X) as rune <<6 | (b2&MASK_X) as rune, 3; return rune(b0&MASK_3)<<12 | rune(b1&MASK_X)<<6 | rune(b2&MASK_X), 3;
} }
b3 := s[3]; b3 := s[3];
if b3 < 0x80 || 0xbf < b3 { if b3 < 0x80 || 0xbf < b3 {
return RUNE_ERROR, 1; return RUNE_ERROR, 1;
} }
return (b0&MASK_4) as rune <<18 | (b1&MASK_X) as rune <<12 | (b3&MASK_X) as rune <<6 | (b3&MASK_X) as rune, 4; return rune(b0&MASK_4)<<18 | rune(b1&MASK_X)<<12 | rune(b3&MASK_X)<<6 | rune(b3&MASK_X), 4;
} }
@@ -141,7 +141,7 @@ valid_string :: proc(s: string) -> bool {
if x == 0xf1 { if x == 0xf1 {
return false; return false;
} }
size := (x & 7) as int; size := int(x & 7);
if i+size > n { if i+size > n {
return false; return false;
} }
@@ -178,7 +178,7 @@ rune_count :: proc(s: string) -> int {
i += 1; i += 1;
continue; continue;
} }
size := (x & 7) as int; size := int(x & 7);
if i+size > n { if i+size > n {
i += 1; i += 1;
continue; continue;
src/check_expr.c
+189 -41
View File
@@ -1911,6 +1911,7 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) {
ast_node(be, BinaryExpr, node); ast_node(be, BinaryExpr, node);
#if 0
switch (be->op.kind) { switch (be->op.kind) {
case Token_as: { case Token_as: {
check_expr(c, x, be->left); check_expr(c, x, be->left);
@@ -2103,7 +2104,7 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) {
return; return;
} break; } break;
} }
#endif
check_expr(c, x, be->left); check_expr(c, x, be->left);
check_expr(c, y, be->right); check_expr(c, y, be->right);
if (x->mode == Addressing_Invalid) { if (x->mode == Addressing_Invalid) {
@@ -2728,6 +2729,10 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
case BuiltinProc_align_of: case BuiltinProc_align_of:
case BuiltinProc_offset_of: case BuiltinProc_offset_of:
case BuiltinProc_type_info: case BuiltinProc_type_info:
case BuiltinProc_transmute:
case BuiltinProc_union_cast:
case BuiltinProc_down_cast:
// NOTE(bill): The first arg may be a Type, this will be checked case by case // NOTE(bill): The first arg may be a Type, this will be checked case by case
break; break;
default: default:
@@ -2925,6 +2930,10 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
if (operand->mode == Addressing_Invalid || operand->mode == Addressing_Builtin) { if (operand->mode == Addressing_Invalid || operand->mode == Addressing_Builtin) {
return false; return false;
} }
if (operand->type == NULL || operand->type == t_invalid) {
error_node(operand->expr, "Invalid argument to `type_of_val`");
return false;
}
operand->mode = Addressing_Type; operand->mode = Addressing_Type;
break; break;
@@ -2969,6 +2978,184 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
} break; } break;
case BuiltinProc_transmute: {
Type *type = check_type(c, ce->args.e[0]);
check_expr(c, operand, ce->args.e[1]);
if (operand->mode == Addressing_Invalid) {
return false;
}
if (operand->mode == Addressing_Constant) {
gbString expr_str = expr_to_string(operand->expr);
error_node(operand->expr, "Cannot transmute constant expression: `%s`", expr_str);
gb_string_free(expr_str);
operand->mode = Addressing_Invalid;
return false;
}
if (is_type_untyped(operand->type)) {
gbString expr_str = expr_to_string(operand->expr);
error_node(operand->expr, "Cannot transmute untyped expression: `%s`", expr_str);
gb_string_free(expr_str);
operand->mode = Addressing_Invalid;
return false;
}
i64 srcz = type_size_of(c->sizes, c->allocator, operand->type);
i64 dstz = type_size_of(c->sizes, c->allocator, type);
if (srcz != dstz) {
gbString expr_str = expr_to_string(operand->expr);
gbString type_str = type_to_string(type);
error_node(operand->expr, "Cannot transmute `%s` to `%s`, %lld vs %lld bytes", expr_str, type_str, srcz, dstz);
gb_string_free(type_str);
gb_string_free(expr_str);
operand->mode = Addressing_Invalid;
return false;
}
operand->type = type;
} break;
case BuiltinProc_union_cast: {
Type *type = check_type(c, ce->args.e[0]);
check_expr(c, operand, ce->args.e[1]);
if (operand->mode == Addressing_Invalid) {
return false;
}
if (operand->mode == Addressing_Constant) {
gbString expr_str = expr_to_string(operand->expr);
error_node(operand->expr, "Cannot `union_cast` a constant expression: `%s`", expr_str);
gb_string_free(expr_str);
operand->mode = Addressing_Invalid;
return false;
}
if (is_type_untyped(operand->type)) {
gbString expr_str = expr_to_string(operand->expr);
error_node(operand->expr, "Cannot `union_cast` an untyped expression: `%s`", expr_str);
gb_string_free(expr_str);
operand->mode = Addressing_Invalid;
return false;
}
bool src_is_ptr = is_type_pointer(operand->type);
bool dst_is_ptr = is_type_pointer(type);
Type *src = type_deref(operand->type);
Type *dst = type_deref(type);
Type *bsrc = base_type(src);
Type *bdst = base_type(dst);
if (src_is_ptr != dst_is_ptr) {
gbString src_type_str = type_to_string(operand->type);
gbString dst_type_str = type_to_string(type);
error_node(operand->expr, "Invalid `union_cast` types: `%s` and `%s`", src_type_str, dst_type_str);
gb_string_free(dst_type_str);
gb_string_free(src_type_str);
operand->mode = Addressing_Invalid;
return false;
}
if (!is_type_union(src)) {
error_node(operand->expr, "`union_cast` can only operate on unions");
operand->mode = Addressing_Invalid;
return false;
}
bool ok = false;
for (isize i = 1; i < bsrc->Record.field_count; i++) {
Entity *f = bsrc->Record.fields[i];
if (are_types_identical(f->type, dst)) {
ok = true;
break;
}
}
if (!ok) {
gbString expr_str = expr_to_string(operand->expr);
gbString dst_type_str = type_to_string(type);
error_node(operand->expr, "Cannot `union_cast` `%s` to `%s`", expr_str, dst_type_str);
gb_string_free(dst_type_str);
gb_string_free(expr_str);
operand->mode = Addressing_Invalid;
return false;
}
Entity **variables = gb_alloc_array(c->allocator, Entity *, 2);
variables[0] = make_entity_param(c->allocator, NULL, empty_token, type, false);
variables[1] = make_entity_param(c->allocator, NULL, empty_token, t_bool, false);
Type *tuple = make_type_tuple(c->allocator);
tuple->Tuple.variables = variables;
tuple->Tuple.variable_count = 2;
operand->type = tuple;
operand->mode = Addressing_Value;
} break;
case BuiltinProc_down_cast: {
Type *type = check_type(c, ce->args.e[0]);
check_expr(c, operand, ce->args.e[1]);
if (operand->mode == Addressing_Invalid) {
return false;
}
if (operand->mode == Addressing_Constant) {
gbString expr_str = expr_to_string(operand->expr);
error_node(operand->expr, "Cannot `down_cast` a constant expression: `%s`", expr_str);
gb_string_free(expr_str);
operand->mode = Addressing_Invalid;
return false;
}
if (is_type_untyped(operand->type)) {
gbString expr_str = expr_to_string(operand->expr);
error_node(operand->expr, "Cannot `down_cast` an untyped expression: `%s`", expr_str);
gb_string_free(expr_str);
operand->mode = Addressing_Invalid;
return false;
}
if (!(is_type_pointer(operand->type) && is_type_pointer(type))) {
gbString expr_str = expr_to_string(operand->expr);
error_node(operand->expr, "Can only `down_cast` pointers: `%s`", expr_str);
gb_string_free(expr_str);
operand->mode = Addressing_Invalid;
return false;
}
Type *src = type_deref(operand->type);
Type *dst = type_deref(type);
Type *bsrc = base_type(src);
Type *bdst = base_type(dst);
if (!(is_type_struct(bsrc) || is_type_raw_union(bsrc))) {
gbString expr_str = expr_to_string(operand->expr);
error_node(operand->expr, "Can only `down_cast` pointer from structs or unions: `%s`", expr_str);
gb_string_free(expr_str);
operand->mode = Addressing_Invalid;
return false;
}
if (!(is_type_struct(bdst) || is_type_raw_union(bdst))) {
gbString expr_str = expr_to_string(operand->expr);
error_node(operand->expr, "Can only `down_cast` pointer to structs or unions: `%s`", expr_str);
gb_string_free(expr_str);
operand->mode = Addressing_Invalid;
return false;
}
String param_name = check_down_cast_name(dst, src);
if (param_name.len == 0) {
gbString expr_str = expr_to_string(operand->expr);
error_node(operand->expr, "Illegal `down_cast`: `%s`", expr_str);
gb_string_free(expr_str);
operand->mode = Addressing_Invalid;
return false;
}
operand->mode = Addressing_Value;
operand->type = type;
} break;
case BuiltinProc_compile_assert: case BuiltinProc_compile_assert:
// compile_assert :: proc(cond: bool) // compile_assert :: proc(cond: bool)
@@ -3054,45 +3241,6 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
operand->mode = Addressing_Value; operand->mode = Addressing_Value;
} break; } break;
#if 0
case BuiltinProc_append: {
// append :: proc(x : ^[]Type, y : Type) -> bool
Type *x_type = NULL, *y_type = NULL;
x_type = base_type(operand->type);
Operand op = {0};
check_expr(c, &op, ce->args.e[1]);
if (op.mode == Addressing_Invalid) {
return false;
}
y_type = base_type(op.type);
if (!(is_type_pointer(x_type) && is_type_slice(x_type->Pointer.elem))) {
error_node(call, "First argument to `append` must be a pointer to a slice");
return false;
}
Type *elem_type = x_type->Pointer.elem->Slice.elem;
if (!check_is_assignable_to(c, &op, elem_type)) {
gbString d_arg = expr_to_string(ce->args.e[0]);
gbString s_arg = expr_to_string(ce->args.e[1]);
gbString d_str = type_to_string(elem_type);
gbString s_str = type_to_string(y_type);
error_node(call,
"Arguments to `append`, %s, %s, have different element types: %s vs %s",
d_arg, s_arg, d_str, s_str);
gb_string_free(s_str);
gb_string_free(d_str);
gb_string_free(s_arg);
gb_string_free(d_arg);
return false;
}
operand->type = t_bool; // Returns if it was successful
operand->mode = Addressing_Value;
} break;
#endif
case BuiltinProc_swizzle: { case BuiltinProc_swizzle: {
// swizzle :: proc(v: {N}T, T...) -> {M}T // swizzle :: proc(v: {N}T, T...) -> {M}T
Type *vector_type = base_type(operand->type); Type *vector_type = base_type(operand->type);
@@ -4557,7 +4705,7 @@ ExprKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint
case_ast_node(ue, UnaryExpr, node); case_ast_node(ue, UnaryExpr, node);
check_expr(c, o, ue->expr); check_expr_base(c, o, ue->expr, type_hint);
if (o->mode == Addressing_Invalid) { if (o->mode == Addressing_Invalid) {
goto error; goto error;
} }
src/checker.c
+8
View File
@@ -135,6 +135,10 @@ typedef enum BuiltinProcId {
BuiltinProc_type_info, BuiltinProc_type_info,
BuiltinProc_type_info_of_val, BuiltinProc_type_info_of_val,
BuiltinProc_transmute,
BuiltinProc_union_cast,
BuiltinProc_down_cast,
BuiltinProc_compile_assert, BuiltinProc_compile_assert,
BuiltinProc_assert, BuiltinProc_assert,
BuiltinProc_panic, BuiltinProc_panic,
@@ -178,6 +182,10 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_Count] = {
{STR_LIT("type_info"), 1, false, Expr_Expr}, {STR_LIT("type_info"), 1, false, Expr_Expr},
{STR_LIT("type_info_of_val"), 1, false, Expr_Expr}, {STR_LIT("type_info_of_val"), 1, false, Expr_Expr},
{STR_LIT("transmute"), 2, false, Expr_Expr},
{STR_LIT("union_cast"), 2, false, Expr_Expr},
{STR_LIT("down_cast"), 2, false, Expr_Expr},
{STR_LIT("compile_assert"), 1, false, Expr_Stmt}, {STR_LIT("compile_assert"), 1, false, Expr_Stmt},
{STR_LIT("assert"), 1, false, Expr_Stmt}, {STR_LIT("assert"), 1, false, Expr_Stmt},
{STR_LIT("panic"), 1, false, Expr_Stmt}, {STR_LIT("panic"), 1, false, Expr_Stmt},
src/ir.c
+46 -28
View File
@@ -2772,21 +2772,21 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
case Token_CmpOr: case Token_CmpOr:
return ir_emit_logical_binary_expr(proc, expr); return ir_emit_logical_binary_expr(proc, expr);
case Token_as: // case Token_as:
ir_emit_comment(proc, str_lit("cast - as")); // ir_emit_comment(proc, str_lit("cast - as"));
return ir_emit_conv(proc, left, type); // return ir_emit_conv(proc, left, type);
case Token_transmute: // case Token_transmute:
ir_emit_comment(proc, str_lit("cast - transmute")); // ir_emit_comment(proc, str_lit("cast - transmute"));
return ir_emit_transmute(proc, left, type); // return ir_emit_transmute(proc, left, type);
case Token_down_cast: // case Token_down_cast:
ir_emit_comment(proc, str_lit("cast - down_cast")); // ir_emit_comment(proc, str_lit("cast - down_cast"));
return ir_emit_down_cast(proc, left, type); // return ir_emit_down_cast(proc, left, type);
case Token_union_cast: // case Token_union_cast:
ir_emit_comment(proc, str_lit("cast - union_cast")); // ir_emit_comment(proc, str_lit("cast - union_cast"));
return ir_emit_union_cast(proc, left, type); // return ir_emit_union_cast(proc, left, type);
default: default:
GB_PANIC("Invalid binary expression"); GB_PANIC("Invalid binary expression");
@@ -2844,6 +2844,24 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
return ir_type_info(proc, t); return ir_type_info(proc, t);
} break; } break;
case BuiltinProc_transmute: {
irValue *val = ir_build_expr(proc, ce->args.e[1]);
ir_emit_comment(proc, str_lit("cast - transmute"));
return ir_emit_transmute(proc, val, type_of_expr(proc->module->info, ce->args.e[0]));
}
case BuiltinProc_down_cast: {
irValue *val = ir_build_expr(proc, ce->args.e[1]);
ir_emit_comment(proc, str_lit("cast - down_cast"));
return ir_emit_down_cast(proc, val, type_of_expr(proc->module->info, ce->args.e[0]));
}
case BuiltinProc_union_cast: {
irValue *val = ir_build_expr(proc, ce->args.e[1]);
ir_emit_comment(proc, str_lit("cast - union_cast"));
return ir_emit_union_cast(proc, val, type_of_expr(proc->module->info, ce->args.e[0]));
}
case BuiltinProc_new: { case BuiltinProc_new: {
ir_emit_comment(proc, str_lit("new")); ir_emit_comment(proc, str_lit("new"));
// new :: proc(Type) -> ^Type // new :: proc(Type) -> ^Type
@@ -3399,22 +3417,22 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
case_ast_node(be, BinaryExpr, expr); case_ast_node(be, BinaryExpr, expr);
switch (be->op.kind) { switch (be->op.kind) {
case Token_as: { // case Token_as: {
ir_emit_comment(proc, str_lit("Cast - as")); // ir_emit_comment(proc, str_lit("Cast - as"));
// NOTE(bill): Needed for dereference of pointer conversion // // NOTE(bill): Needed for dereference of pointer conversion
Type *type = type_of_expr(proc->module->info, expr); // Type *type = type_of_expr(proc->module->info, expr);
irValue *v = ir_add_local_generated(proc, type); // irValue *v = ir_add_local_generated(proc, type);
ir_emit_store(proc, v, ir_emit_conv(proc, ir_build_expr(proc, be->left), type)); // ir_emit_store(proc, v, ir_emit_conv(proc, ir_build_expr(proc, be->left), type));
return ir_make_addr(v, expr); // return ir_make_addr(v, expr);
} // }
case Token_transmute: { // case Token_transmute: {
ir_emit_comment(proc, str_lit("Cast - transmute")); // ir_emit_comment(proc, str_lit("Cast - transmute"));
// NOTE(bill): Needed for dereference of pointer conversion // // NOTE(bill): Needed for dereference of pointer conversion
Type *type = type_of_expr(proc->module->info, expr); // Type *type = type_of_expr(proc->module->info, expr);
irValue *v = ir_add_local_generated(proc, type); // irValue *v = ir_add_local_generated(proc, type);
ir_emit_store(proc, v, ir_emit_transmute(proc, ir_build_expr(proc, be->left), type)); // ir_emit_store(proc, v, ir_emit_transmute(proc, ir_build_expr(proc, be->left), type));
return ir_make_addr(v, expr); // return ir_make_addr(v, expr);
} // }
default: default:
GB_PANIC("Invalid binary expression for ir_build_addr: %.*s\n", LIT(be->op.string)); GB_PANIC("Invalid binary expression for ir_build_addr: %.*s\n", LIT(be->op.string));
break; break;
src/parser.c
+14 -16
View File
@@ -1979,11 +1979,11 @@ i32 token_precedence(Token t) {
case Token_Shl: case Token_Shl:
case Token_Shr: case Token_Shr:
return 5; return 5;
case Token_as: // case Token_as:
case Token_transmute: // case Token_transmute:
case Token_down_cast: // case Token_down_cast:
case Token_union_cast: // case Token_union_cast:
return 6; // return 6;
} }
return 0; return 0;
} }
@@ -2005,12 +2005,12 @@ AstNode *parse_binary_expr(AstFile *f, bool lhs, i32 prec_in) {
} }
switch (op.kind) { switch (op.kind) {
case Token_as: /* case Token_as:
case Token_transmute: case Token_transmute:
case Token_down_cast: case Token_down_cast:
case Token_union_cast: case Token_union_cast:
right = parse_type(f); right = parse_type(f);
break; break; */
default: default:
right = parse_binary_expr(f, false, prec+1); right = parse_binary_expr(f, false, prec+1);
@@ -2429,10 +2429,10 @@ AstNode *parse_identifier_or_type(AstFile *f) {
AstNode *sel = parse_identifier(f); AstNode *sel = parse_identifier(f);
e = make_selector_expr(f, token, e, sel); e = make_selector_expr(f, token, e, sel);
} }
if (f->curr_token.kind == Token_OpenParen) { // if (f->curr_token.kind == Token_OpenParen) {
// HACK NOTE(bill): For type_of_val(expr) // // HACK NOTE(bill): For type_of_val(expr)
e = parse_call_expr(f, e); // e = parse_call_expr(f, e);
} // }
return e; return e;
} }
@@ -2560,11 +2560,9 @@ AstNode *parse_identifier_or_type(AstFile *f) {
case Token_OpenParen: { case Token_OpenParen: {
// NOTE(bill): Skip the paren expression // NOTE(bill): Skip the paren expression
AstNode *type; Token open = expect_token(f, Token_OpenParen);
Token open, close; AstNode *type = parse_type(f);
open = expect_token(f, Token_OpenParen); Token close = expect_token(f, Token_CloseParen);
type = parse_type(f);
close = expect_token(f, Token_CloseParen);
return type; return type;
// return make_paren_expr(f, type, open, close); // return make_paren_expr(f, type, open, close);
} break; } break;
src/string.c
+1 -1
View File
@@ -46,7 +46,7 @@ gb_inline String make_string_c(char *text) {
return make_string(cast(u8 *)cast(void *)text, gb_strlen(text)); return make_string(cast(u8 *)cast(void *)text, gb_strlen(text));
} }
#define str_lit(c_str) make_string(cast(u8 *)c_str, gb_size_of(c_str)-1) #define str_lit(c_str) (String){cast(u8 *)c_str, gb_size_of(c_str)-1}
src/tokenizer.c
+60 -60
View File
@@ -1,82 +1,82 @@
#define TOKEN_KINDS \ #define TOKEN_KINDS \
TOKEN_KIND(Token_Invalid, "Invalid"), \ TOKEN_KIND(Token_Invalid, "Invalid"), \
TOKEN_KIND(Token_EOF, "EOF"), \ TOKEN_KIND(Token_EOF, "EOF"), \
TOKEN_KIND(Token_Comment, "Comment"), \ TOKEN_KIND(Token_Comment, "Comment"), \
\ \
TOKEN_KIND(Token__LiteralBegin, "_LiteralBegin"), \ TOKEN_KIND(Token__LiteralBegin, "_LiteralBegin"), \
TOKEN_KIND(Token_Ident, "identifier"), \ TOKEN_KIND(Token_Ident, "identifier"), \
TOKEN_KIND(Token_Integer, "integer"), \ TOKEN_KIND(Token_Integer, "integer"), \
TOKEN_KIND(Token_Float, "float"), \ TOKEN_KIND(Token_Float, "float"), \
TOKEN_KIND(Token_Rune, "rune"), \ TOKEN_KIND(Token_Rune, "rune"), \
TOKEN_KIND(Token_String, "string"), \ TOKEN_KIND(Token_String, "string"), \
TOKEN_KIND(Token__LiteralEnd, "_LiteralEnd"), \ TOKEN_KIND(Token__LiteralEnd, "_LiteralEnd"), \
\ \
TOKEN_KIND(Token__OperatorBegin, "_OperatorBegin"), \ TOKEN_KIND(Token__OperatorBegin, "_OperatorBegin"), \
TOKEN_KIND(Token_Eq, "="), \ TOKEN_KIND(Token_Eq, "="), \
TOKEN_KIND(Token_Not, "!"), \ TOKEN_KIND(Token_Not, "!"), \
TOKEN_KIND(Token_Hash, "#"), \ TOKEN_KIND(Token_Hash, "#"), \
TOKEN_KIND(Token_At, "@"), \ TOKEN_KIND(Token_At, "@"), \
TOKEN_KIND(Token_Pointer, "^"), \ TOKEN_KIND(Token_Pointer, "^"), \
TOKEN_KIND(Token_Maybe, "?"), \ TOKEN_KIND(Token_Maybe, "?"), \
TOKEN_KIND(Token_Add, "+"), \ TOKEN_KIND(Token_Add, "+"), \
TOKEN_KIND(Token_Sub, "-"), \ TOKEN_KIND(Token_Sub, "-"), \
TOKEN_KIND(Token_Mul, "*"), \ TOKEN_KIND(Token_Mul, "*"), \
TOKEN_KIND(Token_Quo, "/"), \ TOKEN_KIND(Token_Quo, "/"), \
TOKEN_KIND(Token_Mod, "%"), \ TOKEN_KIND(Token_Mod, "%"), \
TOKEN_KIND(Token_And, "&"), \ TOKEN_KIND(Token_And, "&"), \
TOKEN_KIND(Token_Or, "|"), \ TOKEN_KIND(Token_Or, "|"), \
TOKEN_KIND(Token_Xor, "~"), \ TOKEN_KIND(Token_Xor, "~"), \
TOKEN_KIND(Token_AndNot, "&~"), \ TOKEN_KIND(Token_AndNot, "&~"), \
TOKEN_KIND(Token_Shl, "<<"), \ TOKEN_KIND(Token_Shl, "<<"), \
TOKEN_KIND(Token_Shr, ">>"), \ TOKEN_KIND(Token_Shr, ">>"), \
\ \
TOKEN_KIND(Token_as, "as"), \ /*TOKEN_KIND(Token_as, "as"), */\
TOKEN_KIND(Token_transmute, "transmute"), \ /*TOKEN_KIND(Token_transmute, "transmute"), */\
TOKEN_KIND(Token_down_cast, "down_cast"), \ /*TOKEN_KIND(Token_down_cast, "down_cast"), */\
TOKEN_KIND(Token_union_cast, "union_cast"), \ /*TOKEN_KIND(Token_union_cast, "union_cast"), */\
\ \
TOKEN_KIND(Token_CmpAnd, "&&"), \ TOKEN_KIND(Token_CmpAnd, "&&"), \
TOKEN_KIND(Token_CmpOr, "||"), \ TOKEN_KIND(Token_CmpOr, "||"), \
\ \
TOKEN_KIND(Token__AssignOpBegin, "_AssignOpBegin"), \ TOKEN_KIND(Token__AssignOpBegin, "_AssignOpBegin"), \
TOKEN_KIND(Token_AddEq, "+="), \ TOKEN_KIND(Token_AddEq, "+="), \
TOKEN_KIND(Token_SubEq, "-="), \ TOKEN_KIND(Token_SubEq, "-="), \
TOKEN_KIND(Token_MulEq, "*="), \ TOKEN_KIND(Token_MulEq, "*="), \
TOKEN_KIND(Token_QuoEq, "/="), \ TOKEN_KIND(Token_QuoEq, "/="), \
TOKEN_KIND(Token_ModEq, "%="), \ TOKEN_KIND(Token_ModEq, "%="), \
TOKEN_KIND(Token_AndEq, "&="), \ TOKEN_KIND(Token_AndEq, "&="), \
TOKEN_KIND(Token_OrEq, "|="), \ TOKEN_KIND(Token_OrEq, "|="), \
TOKEN_KIND(Token_XorEq, "~="), \ TOKEN_KIND(Token_XorEq, "~="), \
TOKEN_KIND(Token_AndNotEq, "&~="), \ TOKEN_KIND(Token_AndNotEq, "&~="), \
TOKEN_KIND(Token_ShlEq, "<<="), \ TOKEN_KIND(Token_ShlEq, "<<="), \
TOKEN_KIND(Token_ShrEq, ">>="), \ TOKEN_KIND(Token_ShrEq, ">>="), \
TOKEN_KIND(Token_CmpAndEq, "&&="), \ TOKEN_KIND(Token_CmpAndEq, "&&="), \
TOKEN_KIND(Token_CmpOrEq, "||="), \ TOKEN_KIND(Token_CmpOrEq, "||="), \
TOKEN_KIND(Token__AssignOpEnd, "_AssignOpEnd"), \ TOKEN_KIND(Token__AssignOpEnd, "_AssignOpEnd"), \
TOKEN_KIND(Token_ArrowRight, "->"), \ TOKEN_KIND(Token_ArrowRight, "->"), \
TOKEN_KIND(Token_ArrowLeft, "<-"), \ TOKEN_KIND(Token_ArrowLeft, "<-"), \
\ \
TOKEN_KIND(Token__ComparisonBegin, "_ComparisonBegin"), \ TOKEN_KIND(Token__ComparisonBegin, "_ComparisonBegin"), \
TOKEN_KIND(Token_CmpEq, "=="), \ TOKEN_KIND(Token_CmpEq, "=="), \
TOKEN_KIND(Token_NotEq, "!="), \ TOKEN_KIND(Token_NotEq, "!="), \
TOKEN_KIND(Token_Lt, "<"), \ TOKEN_KIND(Token_Lt, "<"), \
TOKEN_KIND(Token_Gt, ">"), \ TOKEN_KIND(Token_Gt, ">"), \
TOKEN_KIND(Token_LtEq, "<="), \ TOKEN_KIND(Token_LtEq, "<="), \
TOKEN_KIND(Token_GtEq, ">="), \ TOKEN_KIND(Token_GtEq, ">="), \
TOKEN_KIND(Token__ComparisonEnd, "_ComparisonEnd"), \ TOKEN_KIND(Token__ComparisonEnd, "_ComparisonEnd"), \
\ \
TOKEN_KIND(Token_OpenParen, "("), \ TOKEN_KIND(Token_OpenParen, "("), \
TOKEN_KIND(Token_CloseParen, ")"), \ TOKEN_KIND(Token_CloseParen, ")"), \
TOKEN_KIND(Token_OpenBracket, "["), \ TOKEN_KIND(Token_OpenBracket, "["), \
TOKEN_KIND(Token_CloseBracket, "]"), \ TOKEN_KIND(Token_CloseBracket, "]"), \
TOKEN_KIND(Token_OpenBrace, "{"), \ TOKEN_KIND(Token_OpenBrace, "{"), \
TOKEN_KIND(Token_CloseBrace, "}"), \ TOKEN_KIND(Token_CloseBrace, "}"), \
TOKEN_KIND(Token_Colon, ":"), \ TOKEN_KIND(Token_Colon, ":"), \
TOKEN_KIND(Token_Semicolon, ";"), \ TOKEN_KIND(Token_Semicolon, ";"), \
TOKEN_KIND(Token_Period, "."), \ TOKEN_KIND(Token_Period, "."), \
TOKEN_KIND(Token_Comma, ","), \ TOKEN_KIND(Token_Comma, ","), \
TOKEN_KIND(Token_Ellipsis, "..."), \ TOKEN_KIND(Token_Ellipsis, "..."), \
TOKEN_KIND(Token_Interval, "..<"), \ TOKEN_KIND(Token_Interval, "..<"), \
TOKEN_KIND(Token__OperatorEnd, "_OperatorEnd"), \ TOKEN_KIND(Token__OperatorEnd, "_OperatorEnd"), \
\ \
TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \ TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \
@@ -722,7 +722,7 @@ Token tokenizer_get_token(Tokenizer *t) {
// NOTE(bill): All keywords are > 1 // NOTE(bill): All keywords are > 1
if (token.string.len > 1) { if (token.string.len > 1) {
if (str_eq(token.string, token_strings[Token_as])) { /* if (str_eq(token.string, token_strings[Token_as])) {
token.kind = Token_as; token.kind = Token_as;
} else if (str_eq(token.string, token_strings[Token_transmute])) { } else if (str_eq(token.string, token_strings[Token_transmute])) {
token.kind = Token_transmute; token.kind = Token_transmute;
@@ -730,7 +730,7 @@ Token tokenizer_get_token(Tokenizer *t) {
token.kind = Token_down_cast; token.kind = Token_down_cast;
} else if (str_eq(token.string, token_strings[Token_union_cast])) { } else if (str_eq(token.string, token_strings[Token_union_cast])) {
token.kind = Token_union_cast; token.kind = Token_union_cast;
} else { } else */{
for (i32 k = Token__KeywordBegin+1; k < Token__KeywordEnd; k++) { for (i32 k = Token__KeywordBegin+1; k < Token__KeywordEnd; k++) {
if (str_eq(token.string, token_strings[k])) { if (str_eq(token.string, token_strings[k])) {
token.kind = cast(TokenKind)k; token.kind = cast(TokenKind)k;