mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-04-28 09:13:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change var decl syntax

Browse Source 
`var x int;` from `x: int;`
This commit is contained in:
Ginger Bill
2016-12-18 22:32:18 +00:00
parent 4c10fbdcd4
commit 77e219d442
12 changed files with 342 additions and 342 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
code/demo.odin
View File

@@ -10,5 +10,4 @@
proc main() {
fmt.println("Here");
}

28
core/_preload.odin
View File

@@ -81,7 +81,7 @@ proc type_info_base(info ^Type_Info) -> ^Type_Info {
if info == nil {
return nil;
}
base := info;
var base = info;
match type i : base {
case Type_Info.Named:
base = i.base;
@@ -147,7 +147,7 @@ const DEFAULT_ALIGNMENT = align_of([vector 4]f32);
proc __check_context() {
c := ^__context;
var c = ^__context;
if c.allocator.procedure == nil {
c.allocator = default_allocator();
@@ -161,20 +161,20 @@ proc alloc(size int) -> rawptr #inline { return alloc_align(size, DEFAULT_ALIGNM
proc alloc_align(size, alignment int) -> rawptr #inline {
__check_context();
a := context.allocator;
var a = context.allocator;
return a.procedure(a.data, Allocator_Mode.ALLOC, size, alignment, nil, 0, 0);
}
proc free(ptr rawptr) #inline {
__check_context();
a := context.allocator;
var a = context.allocator;
if ptr != nil {
a.procedure(a.data, Allocator_Mode.FREE, 0, 0, ptr, 0, 0);
}
}
proc free_all() #inline {
__check_context();
a := context.allocator;
var a = context.allocator;
a.procedure(a.data, Allocator_Mode.FREE_ALL, 0, 0, nil, 0, 0);
}
@@ -182,7 +182,7 @@ proc free_all() #inline {
proc resize (ptr rawptr, old_size, new_size int) -> rawptr #inline { return resize_align(ptr, old_size, new_size, DEFAULT_ALIGNMENT); }
proc resize_align(ptr rawptr, old_size, new_size, alignment int) -> rawptr #inline {
__check_context();
a := context.allocator;
var a = context.allocator;
return a.procedure(a.data, Allocator_Mode.RESIZE, new_size, alignment, ptr, old_size, 0);
}
@@ -202,7 +202,7 @@ proc default_resize_align(old_memory rawptr, old_size, new_size, alignment int)
return old_memory;
}
new_memory := alloc_align(new_size, alignment);
var new_memory = alloc_align(new_size, alignment);
if new_memory == nil {
return nil;
}
@@ -220,9 +220,9 @@ proc default_allocator_proc(allocator_data rawptr, mode Allocator_Mode,
when false {
match mode {
case ALLOC:
total_size := size + alignment + size_of(mem.AllocationHeader);
ptr := os.heap_alloc(total_size);
header := ptr as ^mem.AllocationHeader;
var total_size = size + alignment + size_of(mem.AllocationHeader);
var ptr = os.heap_alloc(total_size);
var header = ptr as ^mem.AllocationHeader;
ptr = mem.align_forward(header+1, alignment);
mem.allocation_header_fill(header, ptr, size);
return mem.zero(ptr, size);
@@ -235,9 +235,9 @@ proc default_allocator_proc(allocator_data rawptr, mode Allocator_Mode,
// NOTE(bill): Does nothing
case RESIZE:
total_size := size + alignment + size_of(mem.AllocationHeader);
ptr := os.heap_resize(mem.allocation_header(old_memory), total_size);
header := ptr as ^mem.AllocationHeader;
var total_size = size + alignment + size_of(mem.AllocationHeader);
var ptr = os.heap_resize(mem.allocation_header(old_memory), total_size);
var header = ptr as ^mem.AllocationHeader;
ptr = mem.align_forward(header+1, alignment);
mem.allocation_header_fill(header, ptr, size);
return mem.zero(ptr, size);
@@ -336,7 +336,7 @@ proc __enum_to_string(info ^Type_Info, value i64) -> string {
match type ti : type_info_base(info) {
case Type_Info.Enum:
// TODO(bill): Search faster than linearly
for i := 0; i < ti.values.count; i++ {
for var i = 0; i < ti.values.count; i++ {
if ti.values[i] == value {
return ti.names[i];
}

14
core/atomic.odin
View File

@@ -2,7 +2,7 @@
// Inline vs external file?
#import win32 "sys/windows.odin" when ODIN_OS == "windows";
_ := compile_assert(ODIN_ARCH == "amd64"); // TODO(bill): x86 version
var _ = compile_assert(ODIN_ARCH == "amd64"); // TODO(bill): x86 version
proc yield_thread() { win32._mm_pause(); }
@@ -35,8 +35,8 @@ proc fetch_or32(a ^i32, operand i32) -> i32 {
return win32.InterlockedOr(a, operand);
}
proc spin_lock32(a ^i32, time_out int) -> bool { // NOTE(bill) time_out = -1 as default
old_value := compare_exchange32(a, 1, 0);
counter := 0;
var old_value = compare_exchange32(a, 1, 0);
var counter = 0;
for old_value != 0 && (time_out < 0 || counter < time_out) {
counter++;
yield_thread();
@@ -51,7 +51,7 @@ proc spin_unlock32(a ^i32) {
}
proc try_acquire_lock32(a ^i32) -> bool {
yield_thread();
old_value := compare_exchange32(a, 1, 0);
var old_value = compare_exchange32(a, 1, 0);
mfence();
return old_value == 0;
}
@@ -79,8 +79,8 @@ proc fetch_or64(a ^i64, operand i64) -> i64 {
return win32.InterlockedOr64(a, operand);
}
proc spin_lock64(a ^i64, time_out int) -> bool { // NOTE(bill) time_out = -1 as default
old_value := compare_exchange64(a, 1, 0);
counter := 0;
var old_value = compare_exchange64(a, 1, 0);
var counter = 0;
for old_value != 0 && (time_out < 0 || counter < time_out) {
counter++;
yield_thread();
@@ -95,7 +95,7 @@ proc spin_unlock64(a ^i64) {
}
proc try_acquire_lock64(a ^i64) -> bool {
yield_thread();
old_value := compare_exchange64(a, 1, 0);
var old_value = compare_exchange64(a, 1, 0);
mfence();
return old_value == 0;
}

120
core/fmt.odin
View File

@@ -5,23 +5,23 @@
const PRINT_BUF_SIZE = 1<<12;
proc fprint(f ^os.File, args ..any) -> int {
data: [PRINT_BUF_SIZE]byte;
buf := data[:0];
var data [PRINT_BUF_SIZE]byte;
var buf = data[:0];
bprint(^buf, ..args);
os.write(f, buf);
return buf.count;
}
proc fprintln(f ^os.File, args ..any) -> int {
data: [PRINT_BUF_SIZE]byte;
buf := data[:0];
var data [PRINT_BUF_SIZE]byte;
var buf = data[:0];
bprintln(^buf, ..args);
os.write(f, buf);
return buf.count;
}
proc fprintf(f ^os.File, fmt string, args ..any) -> int {
data: [PRINT_BUF_SIZE]byte;
buf := data[:0];
var data [PRINT_BUF_SIZE]byte;
var buf = data[:0];
bprintf(^buf, fmt, ..args);
os.write(f, buf);
return buf.count;
@@ -41,8 +41,8 @@ proc printf(fmt string, args ..any) -> int {
proc fprint_type(f ^os.File, info ^Type_Info) {
data: [PRINT_BUF_SIZE]byte;
buf := data[:0];
var data [PRINT_BUF_SIZE]byte;
var buf = data[:0];
bprint_type(^buf, info);
os.write(f, buf);
}
@@ -51,7 +51,7 @@ proc fprint_type(f ^os.File, info ^Type_Info) {
proc print_byte_buffer(buf ^[]byte, b []byte) {
if buf.count < buf.capacity {
n := min(buf.capacity-buf.count, b.count);
var n = min(buf.capacity-buf.count, b.count);
if n > 0 {
mem.copy(buf.data + buf.count, b.data, n);
buf.count += n;
@@ -65,21 +65,21 @@ proc bprint_string(buf ^[]byte, s string) {
proc byte_reverse(b []byte) {
n := b.count;
for i := 0; i < n/2; i++ {
var n = b.count;
for var i = 0; i < n/2; i++ {
b[i], b[n-1-i] = b[n-1-i], b[i];
}
}
proc bprint_rune(buf ^[]byte, r rune) {
b, n := utf8.encode_rune(r);
var b, n = utf8.encode_rune(r);
bprint_string(buf, b[:n] as string);
}
proc bprint_space(buf ^[]byte) { bprint_rune(buf, ' '); }
proc bprint_nl (buf ^[]byte) { bprint_rune(buf, '\n'); }
__NUM_TO_CHAR_TABLE := "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@$";
var __NUM_TO_CHAR_TABLE = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@$";
proc bprint_bool(buffer ^[]byte, b bool) {
if b {
@@ -98,9 +98,9 @@ proc bprint_f16 (buffer ^[]byte, f f32) #inline { print__f64(buffer, f as f64,
proc bprint_f32 (buffer ^[]byte, f f32) #inline { print__f64(buffer, f as f64, 7); }
proc bprint_f64 (buffer ^[]byte, f f64) #inline { print__f64(buffer, f as f64, 16); }
proc bprint_u64(buffer ^[]byte, value u64) {
i := value;
buf: [20]byte;
len := 0;
var i = value;
var buf [20]byte;
var len = 0;
if i == 0 {
buf[len] = '0';
len++;
@@ -115,7 +115,7 @@ proc bprint_u64(buffer ^[]byte, value u64) {
}
proc bprint_i64(buffer ^[]byte, value i64) {
// TODO(bill): Cleanup printing
i := value;
var i = value;
if i < 0 {
i = -i;
bprint_rune(buffer, '-');
@@ -125,14 +125,14 @@ proc bprint_i64(buffer ^[]byte, value i64) {
/*
proc bprint_u128(buffer ^[]byte, value u128) {
a := value transmute [2]u64;
var a = value transmute [2]u64;
if a[1] != 0 {
bprint_u64(buffer, a[1]);
}
bprint_u64(buffer, a[0]);
}
proc bprint_i128(buffer ^[]byte, value i128) {
i := value;
var i = value;
if i < 0 {
i = -i;
bprint_rune(buffer, '-');
@@ -143,7 +143,7 @@ proc bprint_i128(buffer ^[]byte, value i128) {
proc print__f64(buffer ^[]byte, value f64, decimal_places int) {
f := value;
var f = value;
if f == 0 {
bprint_rune(buffer, '0');
return;
@@ -153,13 +153,13 @@ proc print__f64(buffer ^[]byte, value f64, decimal_places int) {
f = -f;
}
i := f as u64;
var i = f as u64;
bprint_u64(buffer, i);
f -= i as f64;
bprint_rune(buffer, '.');
mult: f64 = 10.0;
var mult f64 = 10.0;
for ; decimal_places >= 0; decimal_places-- {
i = (f * mult) as u64;
bprint_u64(buffer, i as u64);
@@ -212,7 +212,7 @@ proc bprint_type(buf ^[]byte, ti ^Type_Info) {
if info.params == nil {
bprint_string(buf, "()");
} else {
count := (info.params as ^Tuple).fields.count;
var count = (info.params as ^Tuple).fields.count;
if count == 1 { bprint_string(buf, "("); }
bprint_type(buf, info.params);
if count == 1 { bprint_string(buf, ")"); }
@@ -222,12 +222,12 @@ proc bprint_type(buf ^[]byte, ti ^Type_Info) {
bprint_type(buf, info.results);
}
case Tuple:
count := info.fields.count;
var count = info.fields.count;
if count != 1 { bprint_string(buf, "("); }
for i := 0; i < count; i++ {
for var i = 0; i < count; i++ {
if i > 0 { bprint_string(buf, ", "); }
f := info.fields[i];
var f = info.fields[i];
if f.name.count > 0 {
bprint_string(buf, f.name);
@@ -257,7 +257,7 @@ proc bprint_type(buf ^[]byte, ti ^Type_Info) {
if info.packed { bprint_string(buf, "#packed "); }
if info.ordered { bprint_string(buf, "#ordered "); }
bprint_string(buf, "{");
for i := 0; i < info.fields.count; i++ {
for var i = 0; i < info.fields.count; i++ {
if i > 0 {
bprint_string(buf, ", ");
}
@@ -269,7 +269,7 @@ proc bprint_type(buf ^[]byte, ti ^Type_Info) {
case Union:
bprint_string(buf, "union {");
for i := 0; i < info.fields.count; i++ {
for var i = 0; i < info.fields.count; i++ {
if i > 0 {
bprint_string(buf, ", ");
}
@@ -281,7 +281,7 @@ proc bprint_type(buf ^[]byte, ti ^Type_Info) {
case Raw_Union:
bprint_string(buf, "raw_union {");
for i := 0; i < info.fields.count; i++ {
for var i = 0; i < info.fields.count; i++ {
if i > 0 {
bprint_string(buf, ", ");
}
@@ -300,7 +300,7 @@ proc bprint_type(buf ^[]byte, ti ^Type_Info) {
proc make_any(type_info ^Type_Info, data rawptr) -> any {
a: any;
var a any;
a.type_info = type_info;
a.data = data;
return a;
@@ -320,20 +320,20 @@ proc bprint_any(buf ^[]byte, arg any) {
using Type_Info;
match type info : arg.type_info {
case Named:
a := make_any(info.base, arg.data);
var a = make_any(info.base, arg.data);
match type b : info.base {
case Struct:
bprint_string(buf, info.name);
bprint_string(buf, "{");
for i := 0; i < b.fields.count; i++ {
f := b.fields[i];
for var i = 0; i < b.fields.count; i++ {
var f = b.fields[i];
if i > 0 {
bprint_string(buf, ", ");
}
bprint_string(buf, f.name);
// bprint_any(buf, f.offset);
bprint_string(buf, " = ");
data := arg.data as ^byte + f.offset;
var data = arg.data as ^byte + f.offset;
bprint_any(buf, make_any(f.type_info, data));
}
bprint_string(buf, "}");
@@ -384,8 +384,8 @@ proc bprint_any(buf ^[]byte, arg any) {
}
case Maybe:
size := mem.size_of_type_info(info.elem);
data := slice_ptr(arg.data as ^byte, size+1);
var size = mem.size_of_type_info(info.elem);
var data = slice_ptr(arg.data as ^byte, size+1);
if data[size] != 0 {
bprint_any(buf, make_any(info.elem, arg.data));
} else {
@@ -393,7 +393,7 @@ proc bprint_any(buf ^[]byte, arg any) {
}
case Enum:
value: i64 = 0;
var value i64 = 0;
match type i : make_any(info.base, arg.data) {
case i8: value = i as i64;
@@ -411,26 +411,26 @@ proc bprint_any(buf ^[]byte, arg any) {
bprintf(buf, "[%]%{", info.count, info.elem);
defer bprint_string(buf, "}");
for i := 0; i < info.count; i++ {
for var i = 0; i < info.count; i++ {
if i > 0 {
bprint_string(buf, ", ");
}
data := arg.data as ^byte + i*info.elem_size;
var data = arg.data as ^byte + i*info.elem_size;
bprint_any(buf, make_any(info.elem, data));
}
case Slice:
slice := arg.data as ^[]byte;
var slice = arg.data as ^[]byte;
bprintf(buf, "[]%{", info.elem);
defer bprint_string(buf, "}");
for i := 0; i < slice.count; i++ {
for var i = 0; i < slice.count; i++ {
if i > 0 {
bprint_string(buf, ", ");
}
data := slice.data + i*info.elem_size;
var data = slice.data + i*info.elem_size;
bprint_any(buf, make_any(info.elem, data));
}
@@ -452,12 +452,12 @@ proc bprint_any(buf ^[]byte, arg any) {
return;
}
for i := 0; i < info.count; i++ {
for var i = 0; i < info.count; i++ {
if i > 0 {
bprint_string(buf, ", ");
}
data := arg.data as ^byte + i*info.elem_size;
var data = arg.data as ^byte + i*info.elem_size;
bprint_any(buf, make_any(info.elem, data));
}
@@ -466,14 +466,14 @@ proc bprint_any(buf ^[]byte, arg any) {
bprintf(buf, "%{", arg.type_info);
defer bprint_string(buf, "}");
for i := 0; i < info.fields.count; i++ {
for var i = 0; i < info.fields.count; i++ {
if i > 0 {
bprint_string(buf, ", ");
}
bprint_string(buf, info.fields[i].name);
bprint_string(buf, " = ");
data := arg.data as ^byte + info.fields[i].offset;
ti := info.fields[i].type_info;
var data = arg.data as ^byte + info.fields[i].offset;
var ti = info.fields[i].type_info;
bprint_any(buf, make_any(ti, data));
}
@@ -495,10 +495,10 @@ proc bprintf(buf ^[]byte, fmt string, args ..any) -> int {
}
proc parse_int(s string, offset int) -> (int, int) {
result := 0;
var result = 0;
for ; offset < s.count; offset++ {
c := s[offset] as rune;
var c = s[offset] as rune;
if !is_digit(c) {
break;
}
@@ -510,12 +510,12 @@ proc bprintf(buf ^[]byte, fmt string, args ..any) -> int {
return result, offset;
}
prev := 0;
implicit_index := 0;
var prev = 0;
var implicit_index = 0;
for i := 0; i < fmt.count; i++ {
r := fmt[i] as rune;
index := implicit_index;
for var i = 0; i < fmt.count; i++ {
var r = fmt[i] as rune;
var index = implicit_index;
if r != '%' {
continue;
@@ -524,7 +524,7 @@ proc bprintf(buf ^[]byte, fmt string, args ..any) -> int {
bprint_string(buf, fmt[prev:i]);
i++; // Skip %
if i < fmt.count {
next := fmt[i] as rune;
var next = fmt[i] as rune;
if next == '%' {
bprint_string(buf, "%");
@@ -569,10 +569,10 @@ proc bprint(buf ^[]byte, args ..any) -> int {
}
prev_string := false;
for i := 0; i < args.count; i++ {
arg := args[i];
is_string := arg.data != nil && is_type_string(arg.type_info);
var prev_string = false;
for var i = 0; i < args.count; i++ {
var arg = args[i];
var is_string = arg.data != nil && is_type_string(arg.type_info);
if i > 0 && !is_string && !prev_string {
bprint_space(buf);
}
@@ -583,7 +583,7 @@ proc bprint(buf ^[]byte, args ..any) -> int {
}
proc bprintln(buf ^[]byte, args ..any) -> int {
for i := 0; i < args.count; i++ {
for var i = 0; i < args.count; i++ {
if i > 0 {
append(buf, ' ');
}

70
core/hash.odin
View File

@@ -1,57 +1,57 @@
proc crc32(data rawptr, len int) -> u32 {
result := ~(0 as u32);
s := slice_ptr(data as ^u8, len);
for i := 0; i < len; i++ {
b := s[i] as u32;
var result = ~(0 as u32);
var s = slice_ptr(data as ^u8, len);
for var i = 0; i < len; i++ {
var b = s[i] as u32;
result = result>>8 ~ __CRC32_TABLE[(result ~ b) & 0xff];
}
return ~result;
}
proc crc64(data rawptr, len int) -> u64 {
result := ~(0 as u64);
s := slice_ptr(data as ^u8, len);
for i := 0; i < len; i++ {
b := s[i] as u64;
var result = ~(0 as u64);
var s = slice_ptr(data as ^u8, len);
for var i = 0; i < len; i++ {
var b = s[i] as u64;
result = result>>8 ~ __CRC64_TABLE[(result ~ b) & 0xff];
}
return ~result;
}
proc fnv32(data rawptr, len int) -> u32 {
s := slice_ptr(data as ^u8, len);
var s = slice_ptr(data as ^u8, len);
h: u32 = 0x811c9dc5;
for i := 0; i < len; i++ {
var h u32 = 0x811c9dc5;
for var i = 0; i < len; i++ {
h = (h * 0x01000193) ~ s[i] as u32;
}
return h;
}
proc fnv64(data rawptr, len int) -> u64 {
s := slice_ptr(data as ^u8, len);
var s = slice_ptr(data as ^u8, len);
h: u64 = 0xcbf29ce484222325;
for i := 0; i < len; i++ {
var h u64 = 0xcbf29ce484222325;
for var i = 0; i < len; i++ {
h = (h * 0x100000001b3) ~ s[i] as u64;
}
return h;
}
proc fnv32a(data rawptr, len int) -> u32 {
s := slice_ptr(data as ^u8, len);
var s = slice_ptr(data as ^u8, len);
h: u32 = 0x811c9dc5;
for i := 0; i < len; i++ {
var h u32 = 0x811c9dc5;
for var i = 0; i < len; i++ {
h = (h ~ s[i] as u32) * 0x01000193;
}
return h;
}
proc fnv64a(data rawptr, len int) -> u64 {
s := slice_ptr(data as ^u8, len);
var s = slice_ptr(data as ^u8, len);
h: u64 = 0xcbf29ce484222325;
for i := 0; i < len; i++ {
var h u64 = 0xcbf29ce484222325;
for var i = 0; i < len; i++ {
h = (h ~ s[i] as u64) * 0x100000001b3;
}
return h;
@@ -65,13 +65,13 @@ proc murmur64(data_ rawptr, len int) -> u64 {
const m = 0xc6a4a7935bd1e995;
const r = 47;
h: u64 = SEED ~ (len as u64 * m);
var h u64 = SEED ~ (len as u64 * m);
data := slice_ptr(data_ as ^u64, len/size_of(u64));
data2 := slice_ptr(data_ as ^u8, len);
var data = slice_ptr(data_ as ^u64, len/size_of(u64));
var data2 = slice_ptr(data_ as ^u8, len);
for i := 0; i < data.count; i++ {
k := data[i];
for var i = 0; i < data.count; i++ {
var k = data[i];
k *= m;
k ~= k>>r;
@@ -102,14 +102,14 @@ proc murmur64(data_ rawptr, len int) -> u64 {
const m = 0x5bd1e995;
const r = 24;
h1: u32 = SEED as u32 ~ len as u32;
h2: u32 = SEED >> 32;
var h1 u32 = SEED as u32 ~ len as u32;
var h2 u32 = SEED >> 32;
data := slice_ptr(data_ as ^u32, len/size_of(u32));
var data = slice_ptr(data_ as ^u32, len/size_of(u32));
i := 0;
var i = 0;
for len >= 8 {
k1, k2: u32;
var k1, k2 u32;
k1 = data[i]; i++;
k1 *= m;
k1 ~= k1>>r;
@@ -128,7 +128,7 @@ proc murmur64(data_ rawptr, len int) -> u64 {
}
if (len >= 4) {
k1: u32;
var k1 u32;
k1 = data[i]; i++;
k1 *= m;
k1 ~= k1>>r;
@@ -138,7 +138,7 @@ proc murmur64(data_ rawptr, len int) -> u64 {
len -= 4;
}
data8 := slice_ptr((data.data+i) as ^u8, 3); // NOTE(bill): This is unsafe
var data8 = slice_ptr((data.data+i) as ^u8, 3); // NOTE(bill): This is unsafe
match len {
case 3: h2 ~= data8[2] as u32 << 16; fallthrough;
@@ -157,14 +157,14 @@ proc murmur64(data_ rawptr, len int) -> u64 {
h2 ~= h1>>19;
h2 *= m;
h := (h1 as u64)<<32 | h2 as u64;
var h = (h1 as u64)<<32 | h2 as u64;
return h;
}
}
__CRC32_TABLE := [256]u32{
var __CRC32_TABLE = [256]u32{
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
@@ -230,7 +230,7 @@ __CRC32_TABLE := [256]u32{
0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
};
__CRC64_TABLE := [256]u64{
var __CRC64_TABLE = [256]u64{
0x0000000000000000, 0x42f0e1eba9ea3693, 0x85e1c3d753d46d26, 0xc711223cfa3e5bb5,
0x493366450e42ecdf, 0x0bc387aea7a8da4c, 0xccd2a5925d9681f9, 0x8e224479f47cb76a,
0x9266cc8a1c85d9be, 0xd0962d61b56fef2d, 0x17870f5d4f51b498, 0x5577eeb6e6bb820b,

100
core/math.odin
View File

@@ -47,8 +47,8 @@ proc sign64(x f64) -> f64 { if x >= 0 { return +1; } return -1; }
proc copy_sign32(x, y f32) -> f32 {
ix := x transmute u32;
iy := y transmute u32;
var ix = x transmute u32;
var iy = y transmute u32;
ix &= 0x7fffffff;
ix |= iy & 0x80000000;
return ix transmute f32;
@@ -78,7 +78,7 @@ proc remainder32(x, y f32) -> f32 {
proc fmod32(x, y f32) -> f32 {
y = abs(y);
result := remainder32(abs(x), y);
var result = remainder32(abs(x), y);
if sign32(result) < 0 {
result += y;
}
@@ -92,13 +92,13 @@ proc to_degrees(radians f32) -> f32 { return radians * 360 / TAU; }
proc dot2(a, b Vec2) -> f32 { c := a*b; return c.x + c.y; }
proc dot3(a, b Vec3) -> f32 { c := a*b; return c.x + c.y + c.z; }
proc dot4(a, b Vec4) -> f32 { c := a*b; return c.x + c.y + c.z + c.w; }
proc dot2(a, b Vec2) -> f32 { var c = a*b; return c.x + c.y; }
proc dot3(a, b Vec3) -> f32 { var c = a*b; return c.x + c.y + c.z; }
proc dot4(a, b Vec4) -> f32 { var c = a*b; return c.x + c.y + c.z + c.w; }
proc cross3(x, y Vec3) -> Vec3 {
a := swizzle(x, 1, 2, 0) * swizzle(y, 2, 0, 1);
b := swizzle(x, 2, 0, 1) * swizzle(y, 1, 2, 0);
var a = swizzle(x, 1, 2, 0) * swizzle(y, 2, 0, 1);
var b = swizzle(x, 2, 0, 1) * swizzle(y, 1, 2, 0);
return a - b;
}
@@ -112,7 +112,7 @@ proc vec3_norm(v Vec3) -> Vec3 { return v / Vec3{vec3_mag(v)}; }
proc vec4_norm(v Vec4) -> Vec4 { return v / Vec4{vec4_mag(v)}; }
proc vec2_norm0(v Vec2) -> Vec2 {
m := vec2_mag(v);
var m = vec2_mag(v);
if m == 0 {
return Vec2{0};
}
@@ -120,7 +120,7 @@ proc vec2_norm0(v Vec2) -> Vec2 {
}
proc vec3_norm0(v Vec3) -> Vec3 {
m := vec3_mag(v);
var m = vec3_mag(v);
if m == 0 {
return Vec3{0};
}
@@ -128,7 +128,7 @@ proc vec3_norm0(v Vec3) -> Vec3 {
}
proc vec4_norm0(v Vec4) -> Vec4 {
m := vec4_mag(v);
var m = vec4_mag(v);
if m == 0 {
return Vec4{0};
}
@@ -147,8 +147,8 @@ proc mat4_identity() -> Mat4 {
}
proc mat4_transpose(m Mat4) -> Mat4 {
for j := 0; j < 4; j++ {
for i := 0; i < 4; i++ {
for var j = 0; j < 4; j++ {
for var i = 0; i < 4; i++ {
m[i][j], m[j][i] = m[j][i], m[i][j];
}
}
@@ -156,9 +156,9 @@ proc mat4_transpose(m Mat4) -> Mat4 {
}
proc mat4_mul(a, b Mat4) -> Mat4 {
c: Mat4;
for j := 0; j < 4; j++ {
for i := 0; i < 4; i++ {
var c Mat4;
for var j = 0; j < 4; j++ {
for var i = 0; i < 4; i++ {
c[j][i] = a[0][i]*b[j][0] +
a[1][i]*b[j][1] +
a[2][i]*b[j][2] +
@@ -178,27 +178,27 @@ proc mat4_mul_vec4(m Mat4, v Vec4) -> Vec4 {
}
proc mat4_inverse(m Mat4) -> Mat4 {
o: Mat4;
var o Mat4;
sf00 := m[2][2] * m[3][3] - m[3][2] * m[2][3];
sf01 := m[2][1] * m[3][3] - m[3][1] * m[2][3];
sf02 := m[2][1] * m[3][2] - m[3][1] * m[2][2];
sf03 := m[2][0] * m[3][3] - m[3][0] * m[2][3];
sf04 := m[2][0] * m[3][2] - m[3][0] * m[2][2];
sf05 := m[2][0] * m[3][1] - m[3][0] * m[2][1];
sf06 := m[1][2] * m[3][3] - m[3][2] * m[1][3];
sf07 := m[1][1] * m[3][3] - m[3][1] * m[1][3];
sf08 := m[1][1] * m[3][2] - m[3][1] * m[1][2];
sf09 := m[1][0] * m[3][3] - m[3][0] * m[1][3];
sf10 := m[1][0] * m[3][2] - m[3][0] * m[1][2];
sf11 := m[1][1] * m[3][3] - m[3][1] * m[1][3];
sf12 := m[1][0] * m[3][1] - m[3][0] * m[1][1];
sf13 := m[1][2] * m[2][3] - m[2][2] * m[1][3];
sf14 := m[1][1] * m[2][3] - m[2][1] * m[1][3];
sf15 := m[1][1] * m[2][2] - m[2][1] * m[1][2];
sf16 := m[1][0] * m[2][3] - m[2][0] * m[1][3];
sf17 := m[1][0] * m[2][2] - m[2][0] * m[1][2];
sf18 := m[1][0] * m[2][1] - m[2][0] * m[1][1];
var sf00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
var sf01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
var sf02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
var sf03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
var sf04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
var sf05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
var sf06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
var sf07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
var sf08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
var sf09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
var sf10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
var sf11 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
var sf12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
var sf13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
var sf14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
var sf15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
var sf16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
var sf17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
var sf18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
o[0][0] = +(m[1][1] * sf00 - m[1][2] * sf01 + m[1][3] * sf02);
o[0][1] = -(m[1][0] * sf00 - m[1][2] * sf03 + m[1][3] * sf04);
@@ -220,7 +220,7 @@ proc mat4_inverse(m Mat4) -> Mat4 {
o[3][2] = -(m[0][0] * sf14 - m[0][1] * sf16 + m[0][3] * sf18);
o[3][3] = +(m[0][0] * sf15 - m[0][1] * sf17 + m[0][2] * sf18);
ood := 1.0 / (m[0][0] * o[0][0] +
var ood = 1.0 / (m[0][0] * o[0][0] +
m[0][1] * o[0][1] +
m[0][2] * o[0][2] +
m[0][3] * o[0][3]);
@@ -247,7 +247,7 @@ proc mat4_inverse(m Mat4) -> Mat4 {
proc mat4_translate(v Vec3) -> Mat4 {
m := mat4_identity();
var m = mat4_identity();
m[3][0] = v.x;
m[3][1] = v.y;
m[3][2] = v.z;
@@ -256,13 +256,13 @@ proc mat4_translate(v Vec3) -> Mat4 {
}
proc mat4_rotate(v Vec3, angle_radians f32) -> Mat4 {
c := cos32(angle_radians);
s := sin32(angle_radians);
var c = cos32(angle_radians);
var s = sin32(angle_radians);
a := vec3_norm(v);
t := a * Vec3{1-c};
var a = vec3_norm(v);
var t = a * Vec3{1-c};
rot := mat4_identity();
var rot = mat4_identity();
rot[0][0] = c + t.x*a.x;
rot[0][1] = 0 + t.x*a.y + s*a.z;
@@ -298,11 +298,11 @@ proc mat4_scalef(m Mat4, s f32) -> Mat4 {
proc mat4_look_at(eye, centre, up Vec3) -> Mat4 {
f := vec3_norm(centre - eye);
s := vec3_norm(cross3(f, up));
u := cross3(s, f);
var f = vec3_norm(centre - eye);
var s = vec3_norm(cross3(f, up));
var u = cross3(s, f);
m: Mat4;
var m Mat4;
m[0] = Vec4{+s.x, +s.y, +s.z, 0};
m[1] = Vec4{+u.x, +u.y, +u.z, 0};
@@ -312,8 +312,8 @@ proc mat4_look_at(eye, centre, up Vec3) -> Mat4 {
return m;
}
proc mat4_perspective(fovy, aspect, near, far f32) -> Mat4 {
m: Mat4;
tan_half_fovy := tan32(0.5 * fovy);
var m Mat4;
var tan_half_fovy = tan32(0.5 * fovy);
m[0][0] = 1.0 / (aspect*tan_half_fovy);
m[1][1] = 1.0 / (tan_half_fovy);
m[2][2] = -(far + near) / (far - near);
@@ -324,7 +324,7 @@ proc mat4_perspective(fovy, aspect, near, far f32) -> Mat4 {
proc mat4_ortho3d(left, right, bottom, top, near, far f32) -> Mat4 {
m := mat4_identity();
var m = mat4_identity();
m[0][0] = +2.0 / (right - left);
m[1][1] = +2.0 / (top - bottom);
m[2][2] = -2.0 / (far - near);

62
core/mem.odin
View File

@@ -28,22 +28,22 @@ proc copy_non_overlapping(dst, src rawptr, len int) -> rawptr #link_name "__mem_
proc compare(dst, src rawptr, n int) -> int #link_name "__mem_compare" {
// Translation of http://mgronhol.github.io/fast-strcmp/
a := slice_ptr(dst as ^byte, n);
b := slice_ptr(src as ^byte, n);
var a = slice_ptr(dst as ^byte, n);
var b = slice_ptr(src as ^byte, n);
fast := n/size_of(int) + 1;
offset := (fast-1)*size_of(int);
curr_block := 0;
var fast = n/size_of(int) + 1;
var offset = (fast-1)*size_of(int);
var curr_block = 0;
if n <= size_of(int) {
fast = 0;
}
la := slice_ptr(^a[0] as ^int, fast);
lb := slice_ptr(^b[0] as ^int, fast);
var la = slice_ptr(^a[0] as ^int, fast);
var lb = slice_ptr(^b[0] as ^int, fast);
for ; curr_block < fast; curr_block++ {
if (la[curr_block] ~ lb[curr_block]) != 0 {
for pos := curr_block*size_of(int); pos < n; pos++ {
for var pos = curr_block*size_of(int); pos < n; pos++ {
if (a[pos] ~ b[pos]) != 0 {
return a[pos] as int - b[pos] as int;
}
@@ -78,9 +78,9 @@ proc is_power_of_two(x int) -> bool {
proc align_forward(ptr rawptr, align int) -> rawptr {
assert(is_power_of_two(align));
a := align as uint;
p := ptr as uint;
modulo := p & (a-1);
var a = align as uint;
var p = ptr as uint;
var modulo = p & (a-1);
if modulo != 0 {
p += a - modulo;
}
@@ -94,14 +94,14 @@ type Allocation_Header struct {
}
proc allocation_header_fill(header ^Allocation_Header, data rawptr, size int) {
header.size = size;
ptr := (header+1) as ^int;
var ptr = (header+1) as ^int;
for i := 0; ptr as rawptr < data; i++ {
for var i = 0; ptr as rawptr < data; i++ {
(ptr+i)^ = -1;
}
}
proc allocation_header(data rawptr) -> ^Allocation_Header {
p := data as ^int;
var p = data as ^int;
for (p-1)^ == -1 {
p = (p-1);
}
@@ -160,21 +160,21 @@ proc arena_allocator(arena ^Arena) -> Allocator {
proc arena_allocator_proc(allocator_data rawptr, mode Allocator_Mode,
size, alignment int,
old_memory rawptr, old_size int, flags u64) -> rawptr {
arena := allocator_data as ^Arena;
var arena = allocator_data as ^Arena;
using Allocator_Mode;
match mode {
case ALLOC:
total_size := size + alignment;
var total_size = size + alignment;
if arena.memory.count + total_size > arena.memory.capacity {
fmt.fprintln(os.stderr, "Arena out of memory");
return nil;
}
#no_bounds_check end := ^arena.memory[arena.memory.count];
#no_bounds_check var end = ^arena.memory[arena.memory.count];
ptr := align_forward(end, alignment);
var ptr = align_forward(end, alignment);
arena.memory.count += total_size;
return zero(ptr, size);
@@ -193,7 +193,7 @@ proc arena_allocator_proc(allocator_data rawptr, mode Allocator_Mode,
}
proc begin_arena_temp_memory(a ^Arena) -> Arena_Temp_Memory {
tmp: Arena_Temp_Memory;
var tmp Arena_Temp_Memory;
tmp.arena = a;
tmp.original_count = a.memory.count;
a.temp_count++;
@@ -253,9 +253,9 @@ proc align_of_type_info(type_info ^Type_Info) -> int {
case Slice:
return WORD_SIZE;
case Vector:
size := size_of_type_info(info.elem);
count := max(prev_pow2(info.count as i64), 1) as int;
total := size * count;
var size = size_of_type_info(info.elem);
var count = max(prev_pow2(info.count as i64), 1) as int;
var total = size * count;
return clamp(total, 1, MAX_ALIGN);
case Struct:
return info.align;
@@ -271,7 +271,7 @@ proc align_of_type_info(type_info ^Type_Info) -> int {
}
proc align_formula(size, align int) -> int {
result := size + align-1;
var result = size + align-1;
return result - result%align;
};
@@ -298,13 +298,13 @@ proc size_of_type_info(type_info ^Type_Info) -> int {
case Procedure:
return WORD_SIZE;
case Array:
count := info.count;
var count = info.count;
if count == 0 {
return 0;
}
size := size_of_type_info(info.elem);
align := align_of_type_info(info.elem);
alignment := align_formula(size, align);
var size = size_of_type_info(info.elem);
var align = align_of_type_info(info.elem);
var alignment = align_formula(size, align);
return alignment*(count-1) + size;
case Slice:
return 3*WORD_SIZE;
@@ -319,18 +319,18 @@ proc size_of_type_info(type_info ^Type_Info) -> int {
return false;
}
count := info.count;
var count = info.count;
if count == 0 {
return 0;
}
bit_size := 8*size_of_type_info(info.elem);
var bit_size = 8*size_of_type_info(info.elem);
if is_bool(info.elem) {
// NOTE(bill): LLVM can store booleans as 1 bit because a boolean _is_ an `i1`
// Silly LLVM spec
bit_size = 1;
}
total_size_in_bits := bit_size * count;
total_size := (total_size_in_bits+7)/8;
var total_size_in_bits = bit_size * count;
var total_size = (total_size_in_bits+7)/8;
return total_size;
case Struct:

96
core/opengl.odin
View File

@@ -30,11 +30,11 @@ proc GetIntegerv(name i32, v ^i32) #foreign "glGetIntegerv"
_libgl := win32.LoadLibraryA(("opengl32.dll\x00" as string).data);
var _libgl = win32.LoadLibraryA(("opengl32.dll\x00" as string).data);
proc GetProcAddress(name string) -> proc() {
assert(name[name.count-1] == 0);
res := win32.wglGetProcAddress(name.data);
var res = win32.wglGetProcAddress(name.data);
if res == nil {
res = win32.GetProcAddress(_libgl, name.data);
}
@@ -42,63 +42,63 @@ proc GetProcAddress(name string) -> proc() {
}
GenBuffers: proc(count i32, buffers ^u32);
GenVertexArrays: proc(count i32, buffers ^u32);
GenSamplers: proc(count i32, buffers ^u32);
BindBuffer: proc(target i32, buffer u32);
BindVertexArray: proc(buffer u32);
BindSampler: proc(position i32, sampler u32);
BufferData: proc(target i32, size int, data rawptr, usage i32);
BufferSubData: proc(target i32, offset, size int, data rawptr);
var GenBuffers proc(count i32, buffers ^u32);
var GenVertexArrays proc(count i32, buffers ^u32);
var GenSamplers proc(count i32, buffers ^u32);
var BindBuffer proc(target i32, buffer u32);
var BindVertexArray proc(buffer u32);
var BindSampler proc(position i32, sampler u32);
var BufferData proc(target i32, size int, data rawptr, usage i32);
var BufferSubData proc(target i32, offset, size int, data rawptr);
DrawArrays: proc(mode, first i32, count u32);
DrawElements: proc(mode i32, count u32, type_ i32, indices rawptr);
var DrawArrays proc(mode, first i32, count u32);
var DrawElements proc(mode i32, count u32, type_ i32, indices rawptr);
MapBuffer: proc(target, access i32) -> rawptr;
UnmapBuffer: proc(target i32);
var MapBuffer proc(target, access i32) -> rawptr;
var UnmapBuffer proc(target i32);
VertexAttribPointer: proc(index u32, size, type_ i32, normalized i32, stride u32, pointer rawptr);
EnableVertexAttribArray: proc(index u32);
var VertexAttribPointer proc(index u32, size, type_ i32, normalized i32, stride u32, pointer rawptr);
var EnableVertexAttribArray proc(index u32);
CreateShader: proc(shader_type i32) -> u32;
ShaderSource: proc(shader u32, count u32, str ^^byte, length ^i32);
CompileShader: proc(shader u32);
CreateProgram: proc() -> u32;
AttachShader: proc(program, shader u32);
DetachShader: proc(program, shader u32);
DeleteShader: proc(shader u32);
LinkProgram: proc(program u32);
UseProgram: proc(program u32);
DeleteProgram: proc(program u32);
var CreateShader proc(shader_type i32) -> u32;
var ShaderSource proc(shader u32, count u32, str ^^byte, length ^i32);
var CompileShader proc(shader u32);
var CreateProgram proc() -> u32;
var AttachShader proc(program, shader u32);
var DetachShader proc(program, shader u32);
var DeleteShader proc(shader u32);
var LinkProgram proc(program u32);
var UseProgram proc(program u32);
var DeleteProgram proc(program u32);
GetShaderiv: proc(shader u32, pname i32, params ^i32);
GetProgramiv: proc(program u32, pname i32, params ^i32);
GetShaderInfoLog: proc(shader u32, max_length u32, length ^u32, info_long ^byte);
GetProgramInfoLog: proc(program u32, max_length u32, length ^u32, info_long ^byte);
var GetShaderiv proc(shader u32, pname i32, params ^i32);
var GetProgramiv proc(program u32, pname i32, params ^i32);
var GetShaderInfoLog proc(shader u32, max_length u32, length ^u32, info_long ^byte);
var GetProgramInfoLog proc(program u32, max_length u32, length ^u32, info_long ^byte);
ActiveTexture: proc(texture i32);
GenerateMipmap: proc(target i32);
var ActiveTexture proc(texture i32);
var GenerateMipmap proc(target i32);
SamplerParameteri: proc(sampler u32, pname i32, param i32);
SamplerParameterf: proc(sampler u32, pname i32, param f32);
SamplerParameteriv: proc(sampler u32, pname i32, params ^i32);
SamplerParameterfv: proc(sampler u32, pname i32, params ^f32);
SamplerParameterIiv: proc(sampler u32, pname i32, params ^i32);
SamplerParameterIuiv: proc(sampler u32, pname i32, params ^u32);
var SamplerParameteri proc(sampler u32, pname i32, param i32);
var SamplerParameterf proc(sampler u32, pname i32, param f32);
var SamplerParameteriv proc(sampler u32, pname i32, params ^i32);
var SamplerParameterfv proc(sampler u32, pname i32, params ^f32);
var SamplerParameterIiv proc(sampler u32, pname i32, params ^i32);
var SamplerParameterIuiv proc(sampler u32, pname i32, params ^u32);
Uniform1i: proc(loc i32, v0 i32);
Uniform2i: proc(loc i32, v0, v1 i32);
Uniform3i: proc(loc i32, v0, v1, v2 i32);
Uniform4i: proc(loc i32, v0, v1, v2, v3 i32);
Uniform1f: proc(loc i32, v0 f32);
Uniform2f: proc(loc i32, v0, v1 f32);
Uniform3f: proc(loc i32, v0, v1, v2 f32);
Uniform4f: proc(loc i32, v0, v1, v2, v3 f32);
UniformMatrix4fv: proc(loc i32, count u32, transpose i32, value ^f32);
var Uniform1i proc(loc i32, v0 i32);
var Uniform2i proc(loc i32, v0, v1 i32);
var Uniform3i proc(loc i32, v0, v1, v2 i32);
var Uniform4i proc(loc i32, v0, v1, v2, v3 i32);
var Uniform1f proc(loc i32, v0 f32);
var Uniform2f proc(loc i32, v0, v1 f32);
var Uniform3f proc(loc i32, v0, v1, v2 f32);
var Uniform4f proc(loc i32, v0, v1, v2, v3 f32);
var UniformMatrix4fv proc(loc i32, count u32, transpose i32, value ^f32);
GetUniformLocation: proc(program u32, name ^byte) -> i32;
var GetUniformLocation proc(program u32, name ^byte) -> i32;
proc init() {
proc set_proc_address(p rawptr, name string) #inline { (p as ^proc())^ = GetProcAddress(name); }

58
core/os_windows.odin
View File

@@ -15,22 +15,22 @@ type File struct {
proc open(name string) -> (File, bool) {
using win32;
buf: [300]byte;
var buf [300]byte;
var f File;
copy(buf[:], name as []byte);
f: File;
f.handle.p = CreateFileA(^buf[0], FILE_GENERIC_READ, FILE_SHARE_READ, nil, OPEN_EXISTING, 0, nil) as rawptr;
success := f.handle.p != INVALID_HANDLE_VALUE;
var success = f.handle.p != INVALID_HANDLE_VALUE;
f.last_write_time = last_write_time(^f);
return f, success;
}
proc create(name string) -> (File, bool) {
using win32;
buf: [300]byte;
var buf [300]byte;
var f File;
copy(buf[:], name as []byte);
f: File;
f.handle.p = CreateFileA(^buf[0], FILE_GENERIC_WRITE, FILE_SHARE_READ, nil, CREATE_ALWAYS, 0, nil) as rawptr;
success := f.handle.p != INVALID_HANDLE_VALUE;
var success = f.handle.p != INVALID_HANDLE_VALUE;
f.last_write_time = last_write_time(^f);
return f, success;
}
@@ -40,12 +40,12 @@ proc close(using f ^File) {
}
proc write(using f ^File, buf []byte) -> bool {
bytes_written: i32;
var bytes_written i32;
return win32.WriteFile(handle.p as win32.HANDLE, buf.data, buf.count as i32, ^bytes_written, nil) != 0;
}
proc file_has_changed(f ^File) -> bool {
last_write_time := last_write_time(f);
var last_write_time = last_write_time(f);
if f.last_write_time != last_write_time {
f.last_write_time = last_write_time;
return true;
@@ -56,17 +56,17 @@ proc file_has_changed(f ^File) -> bool {
proc last_write_time(f ^File) -> File_Time {
file_info: win32.BY_HANDLE_FILE_INFORMATION;
var file_info win32.BY_HANDLE_FILE_INFORMATION;
win32.GetFileInformationByHandle(f.handle.p as win32.HANDLE, ^file_info);
l := file_info.last_write_time.low_date_time as File_Time;
h := file_info.last_write_time.high_date_time as File_Time;
var l = file_info.last_write_time.low_date_time as File_Time;
var h = file_info.last_write_time.high_date_time as File_Time;
return l | h << 32;
}
proc last_write_time_by_name(name string) -> File_Time {
last_write_time: win32.FILETIME;
data: win32.WIN32_FILE_ATTRIBUTE_DATA;
buf: [1024]byte;
var last_write_time win32.FILETIME;
var data win32.WIN32_FILE_ATTRIBUTE_DATA;
var buf [1024]byte;
assert(buf.count > name.count);
@@ -76,8 +76,8 @@ proc last_write_time_by_name(name string) -> File_Time {
last_write_time = data.last_write_time;
}
l := last_write_time.low_date_time as File_Time;
h := last_write_time.high_date_time as File_Time;
var l = last_write_time.low_date_time as File_Time;
var h = last_write_time.high_date_time as File_Time;
return l | h << 32;
}
@@ -91,45 +91,45 @@ type File_Standard enum {
}
// NOTE(bill): Uses startup to initialize it
__std_files := [File_Standard.count]File{
var __std_files = [File_Standard.count]File{
{handle = win32.GetStdHandle(win32.STD_INPUT_HANDLE) transmute File_Handle },
{handle = win32.GetStdHandle(win32.STD_OUTPUT_HANDLE) transmute File_Handle },
{handle = win32.GetStdHandle(win32.STD_ERROR_HANDLE) transmute File_Handle },
};
stdin := ^__std_files[File_Standard.INPUT];
stdout := ^__std_files[File_Standard.OUTPUT];
stderr := ^__std_files[File_Standard.ERROR];
var stdin = ^__std_files[File_Standard.INPUT];
var stdout = ^__std_files[File_Standard.OUTPUT];
var stderr = ^__std_files[File_Standard.ERROR];
proc read_entire_file(name string) -> ([]byte, bool) {
buf: [300]byte;
var buf [300]byte;
copy(buf[:], name as []byte);
f, file_ok := open(name);
var f, file_ok = open(name);
if !file_ok {
return nil, false;
}
defer close(^f);
length: i64;
file_size_ok := win32.GetFileSizeEx(f.handle.p as win32.HANDLE, ^length) != 0;
var length i64;
var file_size_ok = win32.GetFileSizeEx(f.handle.p as win32.HANDLE, ^length) != 0;
if !file_size_ok {
return nil, false;
}
data := new_slice(u8, length);
var data = new_slice(u8, length);
if data.data == nil {
return nil, false;
}
single_read_length: i32;
total_read: i64;
var single_read_length i32;
var total_read i64;
for total_read < length {
remaining := length - total_read;
to_read: u32;
var remaining = length - total_read;
var to_read u32;
const MAX = 1<<32-1;
if remaining <= MAX {
to_read = remaining as u32;

10
core/sync.odin
View File

@@ -46,7 +46,7 @@ proc mutex_destroy(m ^Mutex) {
semaphore_destroy(^m.semaphore);
}
proc mutex_lock(m ^Mutex) {
thread_id := current_thread_id();
var thread_id = current_thread_id();
if atomic.fetch_add32(^m.counter, 1) > 0 {
if thread_id != atomic.load32(^m.owner) {
semaphore_wait(^m.semaphore);
@@ -56,11 +56,11 @@ proc mutex_lock(m ^Mutex) {
m.recursion++;
}
proc mutex_try_lock(m ^Mutex) -> bool {
thread_id := current_thread_id();
var thread_id = current_thread_id();
if atomic.load32(^m.owner) == thread_id {
atomic.fetch_add32(^m.counter, 1);
} else {
expected: i32 = 0;
var expected i32 = 0;
if atomic.load32(^m.counter) != 0 {
return false;
}
@@ -73,8 +73,8 @@ proc mutex_try_lock(m ^Mutex) -> bool {
return true;
}
proc mutex_unlock(m ^Mutex) {
recursion: i32;
thread_id := current_thread_id();
var recursion i32;
var thread_id = current_thread_id();
assert(thread_id == atomic.load32(^m.owner));
m.recursion--;

64
core/utf8.odin
View File

@@ -14,7 +14,7 @@ type Accept_Range struct {
lo, hi u8;
};
accept_ranges := [5]Accept_Range{
var accept_ranges = [5]Accept_Range{
{0x80, 0xbf},
{0xa0, 0xbf},
{0x80, 0x9f},
@@ -22,7 +22,7 @@ accept_ranges := [5]Accept_Range{
{0x80, 0x8f},
};
accept_sizes := [256]byte{
var accept_sizes = [256]byte{
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x00-0x0f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x10-0x1f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x20-0x2f
@@ -43,8 +43,8 @@ accept_sizes := [256]byte{
};
proc encode_rune(r rune) -> ([4]byte, int) {
buf: [4]byte;
i := r as u32;
var buf [4]byte;
var i = r as u32;
const mask = 0x3f as byte;
if i <= 1<<7-1 {
buf[0] = r as byte;
@@ -77,22 +77,22 @@ proc encode_rune(r rune) -> ([4]byte, int) {
}
proc decode_rune(s string) -> (rune, int) {
n := s.count;
var n = s.count;
if n < 1 {
return RUNE_ERROR, 0;
}
b0 := s[0];
x := accept_sizes[b0];
var b0 = s[0];
var x = accept_sizes[b0];
if x >= 0xf0 {
mask := (x as rune << 31) >> 31; // all zeros or all ones
var mask = (x as rune << 31) >> 31; // all zeros or all ones
return (b0 as rune) &~ mask | RUNE_ERROR&mask, 1;
}
size := x & 7;
ar := accept_ranges[x>>4];
var size = x & 7;
var ar = accept_ranges[x>>4];
if n < size as int {
return RUNE_ERROR, 1;
}
b1 := s[1];
var b1 = s[1];
if b1 < ar.lo || ar.hi < b1 {
return RUNE_ERROR, 1;
}
@@ -105,14 +105,14 @@ proc decode_rune(s string) -> (rune, int) {
if size == 2 {
return (b0&MASK_2) as rune <<6 | (b1&MASK_X) as rune, 2;
}
b2 := s[2];
var b2 = s[2];
if b2 < 0x80 || 0xbf < b2 {
return RUNE_ERROR, 1;
}
if size == 3 {
return (b0&MASK_3) as rune <<12 | (b1&MASK_X) as rune <<6 | (b2&MASK_X) as rune, 3;
}
b3 := s[3];
var b3 = s[3];
if b3 < 0x80 || 0xbf < b3 {
return RUNE_ERROR, 1;
}
@@ -133,31 +133,31 @@ proc valid_rune(r rune) -> bool {
}
proc valid_string(s string) -> bool {
n := s.count;
for i := 0; i < n; {
si := s[i];
var n = s.count;
for var i = 0; i < n; {
var si = s[i];
if si < RUNE_SELF { // ascii
i++;
continue;
}
x := accept_sizes[si];
var x = accept_sizes[si];
if x == 0xf1 {
return false;
}
size := (x & 7) as int;
var size = (x & 7) as int;
if i+size > n {
return false;
}
ar := accept_ranges[x>>4];
if b := s[i+1]; b < ar.lo || ar.hi < b {
var ar = accept_ranges[x>>4];
if var b = s[i+1]; b < ar.lo || ar.hi < b {
return false;
} else if size == 2 {
// Okay
} else if b := s[i+2]; b < 0x80 || 0xbf < b {
} else if var b = s[i+2]; b < 0x80 || 0xbf < b {
return false;
} else if size == 3 {
// Okay
} else if b := s[i+3]; b < 0x80 || 0xbf < b {
} else if var b = s[i+3]; b < 0x80 || 0xbf < b {
return false;
}
i += size;
@@ -166,34 +166,34 @@ proc valid_string(s string) -> bool {
}
proc rune_count(s string) -> int {
count := 0;
n := s.count;
for i := 0; i < n; count++ {
si := s[i];
var count = 0;
var n = s.count;
for var i = 0; i < n; count++ {
var si = s[i];
if si < RUNE_SELF { // ascii
i++;
continue;
}
x := accept_sizes[si];
var x = accept_sizes[si];
if x == 0xf1 {
i++;
continue;
}
size := (x & 7) as int;
var size = (x & 7) as int;
if i+size > n {
i++;
continue;
}
ar := accept_ranges[x>>4];
if b := s[i+1]; b < ar.lo || ar.hi < b {
var ar = accept_ranges[x>>4];
if var b = s[i+1]; b < ar.lo || ar.hi < b {
size = 1;
} else if size == 2 {
// Okay
} else if b := s[i+2]; b < 0x80 || 0xbf < b {
} else if var b = s[i+2]; b < 0x80 || 0xbf < b {
size = 1;
} else if size == 3 {
// Okay
} else if b := s[i+3]; b < 0x80 || 0xbf < b {
} else if var b = s[i+3]; b < 0x80 || 0xbf < b {
size = 1;
}
i += size;

61
src/parser.c
View File

@@ -1889,33 +1889,33 @@ AstNode *parse_simple_stmt(AstFile *f) {
return make_assign_stmt(f, token, lhs, rhs);
} break;
case Token_Colon: { // Declare
AstNodeArray names = lhs;
parse_check_name_list_for_reserves(f, names);
// case Token_Colon: { // Declare
// AstNodeArray names = lhs;
// parse_check_name_list_for_reserves(f, names);
Token colon = expect_token(f, Token_Colon);
AstNode *type = parse_identifier_or_type(f);
AstNodeArray values = {0};
// Token colon = expect_token(f, Token_Colon);
// AstNode *type = parse_identifier_or_type(f);
// AstNodeArray values = {0};
if (allow_token(f, Token_Eq)) {
values = parse_rhs_expr_list(f);
if (values.count > names.count) {
syntax_error(f->curr_token, "Too many values on the right hand side of the declaration");
} else if (values.count == 0) {
syntax_error(f->curr_token, "Expected an expression for this declaration");
}
if (type == NULL && values.count == 0) {
syntax_error(f->curr_token, "Missing variable type or initialization");
return make_bad_decl(f, f->curr_token, f->curr_token);
}
}
// if (allow_token(f, Token_Eq)) {
// values = parse_rhs_expr_list(f);
// if (values.count > names.count) {
// syntax_error(f->curr_token, "Too many values on the right hand side of the declaration");
// } else if (values.count == 0) {
// syntax_error(f->curr_token, "Expected an expression for this declaration");
// }
// if (type == NULL && values.count == 0) {
// syntax_error(f->curr_token, "Missing variable type or initialization");
// return make_bad_decl(f, f->curr_token, f->curr_token);
// }
// }
if (values.e == NULL) {
values = make_ast_node_array(f);
}
// if (values.e == NULL) {
// values = make_ast_node_array(f);
// }
return make_var_decl(f, names, type, values);
} break;
// return make_var_decl(f, names, type, values);
// } break;
// case Token_ColonColon: {
// AstNodeArray names = lhs;
@@ -2695,9 +2695,7 @@ AstNode *parse_type_decl(AstFile *f) {
Token token = expect_token(f, Token_type);
AstNode *name = parse_identifier(f);
AstNode *type = parse_type(f);
AstNode *decl = make_type_decl(f, token, name, type);
expect_semicolon(f, decl);
return decl;
return make_type_decl(f, token, name, type);
}
AstNode *parse_value_decl(AstFile *f) {
@@ -2714,7 +2712,7 @@ AstNode *parse_value_decl(AstFile *f) {
return make_bad_decl(f, token, f->curr_token);
}
AstNodeArray names = parse_lhs_expr_list(f);
AstNodeArray names = parse_identfier_list(f);
parse_check_name_list_for_reserves(f, names);
AstNode *type = parse_type_attempt(f);
AstNodeArray values = {0};
@@ -2754,7 +2752,6 @@ AstNode *parse_value_decl(AstFile *f) {
decl = make_const_decl(f, names, type, values);
break;
}
expect_semicolon(f, decl);
return decl;
}
@@ -2798,10 +2795,14 @@ AstNode *parse_stmt(AstFile *f) {
case Token_proc:
return parse_proc_decl(f);
case Token_type:
return parse_type_decl(f);
s = parse_type_decl(f);
expect_semicolon(f, s);
return s;
case Token_var:
case Token_const:
return parse_value_decl(f);
s = parse_value_decl(f);
expect_semicolon(f, s);
return s;
case Token_using: {