diff --git a/code/demo.odin b/code/demo.odin index 557753ff8..759ed7951 100644 --- a/code/demo.odin +++ b/code/demo.odin @@ -10,5 +10,4 @@ proc main() { fmt.println("Here"); - } diff --git a/core/_preload.odin b/core/_preload.odin index 35d9a4a1c..d1791474e 100644 --- a/core/_preload.odin +++ b/core/_preload.odin @@ -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]; } diff --git a/core/atomic.odin b/core/atomic.odin index e0c0b6c19..1c2886041 100644 --- a/core/atomic.odin +++ b/core/atomic.odin @@ -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; } diff --git a/core/fmt.odin b/core/fmt.odin index c2857cfe9..2da874bcc 100644 --- a/core/fmt.odin +++ b/core/fmt.odin @@ -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, ' '); } diff --git a/core/hash.odin b/core/hash.odin index e5eb3ba67..e590a4567 100644 --- a/core/hash.odin +++ b/core/hash.odin @@ -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, diff --git a/core/math.odin b/core/math.odin index 4ad900bbe..1b503c0a2 100644 --- a/core/math.odin +++ b/core/math.odin @@ -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); diff --git a/core/mem.odin b/core/mem.odin index 9c37018ce..059ca2011 100644 --- a/core/mem.odin +++ b/core/mem.odin @@ -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: diff --git a/core/opengl.odin b/core/opengl.odin index fe9fe7b96..8d7575b94 100644 --- a/core/opengl.odin +++ b/core/opengl.odin @@ -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); } diff --git a/core/os_windows.odin b/core/os_windows.odin index 553b8bd49..06e4c6e4d 100644 --- a/core/os_windows.odin +++ b/core/os_windows.odin @@ -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; diff --git a/core/sync.odin b/core/sync.odin index 9b317e56d..db2e7a1dc 100644 --- a/core/sync.odin +++ b/core/sync.odin @@ -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--; diff --git a/core/utf8.odin b/core/utf8.odin index 73688fd75..bbfd2cbff 100644 --- a/core/utf8.odin +++ b/core/utf8.odin @@ -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; diff --git a/src/parser.c b/src/parser.c index e5c64ae88..c8329aabe 100644 --- a/src/parser.c +++ b/src/parser.c @@ -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: {