v0.6.2; Use Ada_Case for types

core/_preload.odin

@@ -10,9 +10,9 @@ import (
 // In general, PascalCase for types and snake_case for values
 //
 // Import Name:        snake_case (but prefer single word)
-// Types:              PascalCase
-// Union Variants:     PascalCase
-// Enum Values:        PascalCase
+// Types:              Ada_Case
+// Union Variants:     Ada_Case
+// Enum Values:        Ada_Case
 // Procedures:         snake_case
 // Local Variables:    snake_case
 // Constant Variables: SCREAMING_SNAKE_CASE
@@ -26,7 +26,7 @@ import (
 // implemented within the compiler rather than in this "preload" file
 
 // NOTE(bill): This must match the compiler's
-CallingConvention :: enum {
+Calling_Convention :: enum {
 	Invalid         = 0,
 	Odin            = 1,
 	Contextless     = 2,
@@ -36,9 +36,9 @@ CallingConvention :: enum {
 }
 // IMPORTANT NOTE(bill): Do not change the order of any of this data
 // The compiler relies upon this _exact_ order
-TypeInfo :: struct #ordered {
+Type_Info :: struct #ordered {
 // Core Types
-	EnumValue :: union {
+	Enum_Value :: union {
 		rune,
 		i8, i16, i32, i64, i128, int,
 		u8, u16, u32, u64, u128, uint,
@@ -46,7 +46,7 @@ TypeInfo :: struct #ordered {
 	};
 
 // Variant Types
-	Named   :: struct #ordered {name: string; base: ^TypeInfo};
+	Named   :: struct #ordered {name: string; base: ^Type_Info};
 	Integer :: struct #ordered {signed: bool};
 	Rune    :: struct{};
 	Float   :: struct{};
@@ -55,28 +55,28 @@ TypeInfo :: struct #ordered {
 	Boolean :: struct{};
 	Any     :: struct{};
 	Pointer :: struct #ordered {
-		elem: ^TypeInfo; // nil -> rawptr
+		elem: ^Type_Info; // nil -> rawptr
 	};
 	Procedure :: struct #ordered {
-		params:     ^TypeInfo; // TypeInfo.Tuple
-		results:    ^TypeInfo; // TypeInfo.Tuple
+		params:     ^Type_Info; // Type_Info.Tuple
+		results:    ^Type_Info; // Type_Info.Tuple
 		variadic:   bool;
-		convention: CallingConvention;
+		convention: Calling_Convention;
 	};
 	Array :: struct #ordered {
-		elem:      ^TypeInfo;
+		elem:      ^Type_Info;
 		elem_size: int;
 		count:     int;
 	};
-	DynamicArray :: struct #ordered {elem: ^TypeInfo; elem_size: int};
-	Slice        :: struct #ordered {elem: ^TypeInfo; elem_size: int};
-	Vector       :: struct #ordered {elem: ^TypeInfo; elem_size, count: int};
+	Dynamic_Array :: struct #ordered {elem: ^Type_Info; elem_size: int};
+	Slice         :: struct #ordered {elem: ^Type_Info; elem_size: int};
+	Vector        :: struct #ordered {elem: ^Type_Info; elem_size, count: int};
 	Tuple :: struct #ordered { // Only really used for procedures
-		types:        []^TypeInfo;
+		types:        []^Type_Info;
 		names:        []string;
 	};
 	Struct :: struct #ordered {
-		types:        []^TypeInfo;
+		types:        []^Type_Info;
 		names:        []string;
 		offsets:      []int;  // offsets may not be used in tuples
 		usings:       []bool; // usings may not be used in tuples
@@ -86,20 +86,20 @@ TypeInfo :: struct #ordered {
 		custom_align: bool;
 	};
 	Union :: struct #ordered {
-		variants:   []^TypeInfo;
+		variants:   []^Type_Info;
 		tag_offset: int;
 	};
 	Enum :: struct #ordered {
-		base:   ^TypeInfo;
+		base:   ^Type_Info;
 		names:  []string;
-		values: []EnumValue;
+		values: []Enum_Value;
 	};
 	Map :: struct #ordered {
-		key:              ^TypeInfo;
-		value:            ^TypeInfo;
-		generated_struct: ^TypeInfo;
+		key:              ^Type_Info;
+		value:            ^Type_Info;
+		generated_struct: ^Type_Info;
 	};
-	BitField :: struct #ordered {
+	Bit_Field :: struct #ordered {
 		names:   []string;
 		bits:    []i32;
 		offsets: []i32;
@@ -122,7 +122,7 @@ TypeInfo :: struct #ordered {
 		Pointer,
 		Procedure,
 		Array,
-		DynamicArray,
+		Dynamic_Array,
 		Slice,
 		Vector,
 		Tuple,
@@ -130,13 +130,13 @@ TypeInfo :: struct #ordered {
 		Union,
 		Enum,
 		Map,
-		BitField,
+		Bit_Field,
 	};
 }
 
 // NOTE(bill): only the ones that are needed (not all types)
 // This will be set by the compiler
-__type_table: []TypeInfo;
+__type_table: []Type_Info;
 
 __argv__: ^^u8;
 __argc__: i32;
@@ -171,7 +171,7 @@ Context :: struct #ordered {
 
 DEFAULT_ALIGNMENT :: align_of([vector 4]f32);
 
-SourceCodeLocation :: struct #ordered {
+Source_Code_Location :: struct #ordered {
 	file_path:    string;
 	line, column: i64;
 	procedure:    string;
@@ -180,27 +180,27 @@ SourceCodeLocation :: struct #ordered {
 
 __INITIAL_MAP_CAP :: 16;
 
-__MapKey :: struct #ordered {
+__Map_Key :: struct #ordered {
 	hash: u128;
 	str:  string;
 }
 
-__MapFindResult :: struct #ordered {
+__Map_Find_Result :: struct #ordered {
 	hash_index:  int;
 	entry_prev:  int;
 	entry_index: int;
 }
 
-__MapEntryHeader :: struct #ordered {
-	key:  __MapKey;
+__Map_Entry_Header :: struct #ordered {
+	key:  __Map_Key;
 	next: int;
 /*
 	value: Value_Type;
 */
 }
 
-__MapHeader :: struct #ordered {
-	m:             ^raw.DynamicMap;
+__Map_Header :: struct #ordered {
+	m:             ^raw.Map;
 	is_key_string: bool;
 	entry_size:    int;
 	entry_align:   int;
@@ -210,24 +210,24 @@ __MapHeader :: struct #ordered {
 
 
 
-type_info_base :: proc(info: ^TypeInfo) -> ^TypeInfo {
+type_info_base :: proc(info: ^Type_Info) -> ^Type_Info {
 	if info == nil do return nil;
 
 	base := info;
 	match i in base.variant {
-	case TypeInfo.Named: base = i.base;
+	case Type_Info.Named: base = i.base;
 	}
 	return base;
 }
 
 
-type_info_base_without_enum :: proc(info: ^TypeInfo) -> ^TypeInfo {
+type_info_base_without_enum :: proc(info: ^Type_Info) -> ^Type_Info {
 	if info == nil do return nil;
 
 	base := info;
 	match i in base.variant {
-	case TypeInfo.Named: base = i.base;
-	case TypeInfo.Enum:  base = i.base;
+	case Type_Info.Named: base = i.base;
+	case Type_Info.Enum:  base = i.base;
 	}
 	return base;
 }
@@ -243,8 +243,8 @@ foreign __llvm_core {
 
 
 
-make_source_code_location :: proc(file: string, line, column: i64, procedure: string) -> SourceCodeLocation #cc_contextless #inline {
-	return SourceCodeLocation{file, line, column, procedure};
+make_source_code_location :: proc(file: string, line, column: i64, procedure: string) -> Source_Code_Location #cc_contextless #inline {
+	return Source_Code_Location{file, line, column, procedure};
 }
 
 
@@ -344,7 +344,7 @@ append :: proc(array: ^$T/[dynamic]$E, args: ...E) -> int {
 	}
 	// TODO(bill): Better error handling for failed reservation
 	if ok {
-		a := cast(^raw.DynamicArray)array;
+		a := cast(^raw.Dynamic_Array)array;
 		data := cast(^E)a.data;
 		assert(data != nil);
 		__mem_copy(data + a.len, &args[0], size_of(E) * arg_len);
@@ -378,7 +378,7 @@ pop :: proc(array: ^$T/[dynamic]$E) -> E #cc_contextless {
 	if array == nil do return E{};
 	assert(len(array) > 0);
 	res := array[len(array)-1];
-	(^raw.DynamicArray)(array).len -= 1;
+	(^raw.Dynamic_Array)(array).len -= 1;
 	return res;
 }
 
@@ -386,20 +386,20 @@ clear :: proc(slice: ^$T/[]$E) #cc_contextless #inline {
 	if slice != nil do (cast(^raw.Slice)slice).len = 0;
 }
 clear :: proc(array: ^$T/[dynamic]$E) #cc_contextless #inline {
-	if array != nil do (cast(^raw.DynamicArray)array).len = 0;
+	if array != nil do (cast(^raw.Dynamic_Array)array).len = 0;
 }
 clear :: proc(m: ^$T/map[$K]$V) #cc_contextless #inline {
 	if m == nil do return;
-	raw_map := cast(^raw.DynamicMap)m;
-	hashes  := cast(^raw.DynamicArray)&raw_map.hashes;
-	entries := cast(^raw.DynamicArray)&raw_map.entries;
+	raw_map := cast(^raw.Map)m;
+	hashes  := cast(^raw.Dynamic_Array)&raw_map.hashes;
+	entries := cast(^raw.Dynamic_Array)&raw_map.entries;
 	hashes.len  = 0;
 	entries.len = 0;
 }
 
 reserve :: proc(array: ^$T/[dynamic]$E, capacity: int) -> bool {
 	if array == nil do return false;
-	a := cast(^raw.DynamicArray)array;
+	a := cast(^raw.Dynamic_Array)array;
 
 	if capacity <= a.cap do return true;
 
@@ -421,15 +421,15 @@ reserve :: proc(array: ^$T/[dynamic]$E, capacity: int) -> bool {
 }
 
 
-__get_map_header :: proc(m: ^$T/map[$K]$V) -> __MapHeader #cc_contextless {
-	header := __MapHeader{m = cast(^raw.DynamicMap)m};
+__get_map_header :: proc(m: ^$T/map[$K]$V) -> __Map_Header #cc_contextless {
+	header := __Map_Header{m = cast(^raw.Map)m};
 	Entry :: struct {
-		key:   __MapKey;
+		key:   __Map_Key;
 		next:  int;
 		value: V;
 	}
 
-	_, is_string := type_info_base(type_info_of(K)).variant.(TypeInfo.String);
+	_, is_string := type_info_base(type_info_of(K)).variant.(Type_Info.String);
 	header.is_key_string = is_string;
 	header.entry_size    = size_of(Entry);
 	header.entry_align   = align_of(Entry);
@@ -438,11 +438,11 @@ __get_map_header :: proc(m: ^$T/map[$K]$V) -> __MapHeader #cc_contextless {
 	return header;
 }
 
-__get_map_key :: proc(key: $K) -> __MapKey #cc_contextless {
-	map_key: __MapKey;
+__get_map_key :: proc(key: $K) -> __Map_Key #cc_contextless {
+	map_key: __Map_Key;
 	ti := type_info_base_without_enum(type_info_of(K));
 	match _ in ti {
-	case TypeInfo.Integer:
+	case Type_Info.Integer:
 		match 8*size_of(key) {
 		case   8: map_key.hash = u128((  ^u8)(&key)^);
 		case  16: map_key.hash = u128(( ^u16)(&key)^);
@@ -451,17 +451,17 @@ __get_map_key :: proc(key: $K) -> __MapKey #cc_contextless {
 		case 128: map_key.hash = u128((^u128)(&key)^);
 		case: panic("Unhandled integer size");
 		}
-	case TypeInfo.Rune:
+	case Type_Info.Rune:
 		map_key.hash = u128((cast(^rune)&key)^);
-	case TypeInfo.Pointer:
+	case Type_Info.Pointer:
 		map_key.hash = u128(uint((^rawptr)(&key)^));
-	case TypeInfo.Float:
+	case Type_Info.Float:
 		match 8*size_of(key) {
 		case 32: map_key.hash = u128((^u32)(&key)^);
 		case 64: map_key.hash = u128((^u64)(&key)^);
 		case: panic("Unhandled float size");
 		}
-	case TypeInfo.String:
+	case Type_Info.String:
 		str := (^string)(&key)^;
 		map_key.hash = __default_hash_string(str);
 		map_key.str  = str;
@@ -494,10 +494,10 @@ new_clone :: proc(data: $T) -> ^T #inline {
 
 free :: proc(ptr:   rawptr)         do free_ptr(ptr);
 free :: proc(str:   $T/string)      do free_ptr((^raw.String      )(&str).data);
-free :: proc(array: $T/[dynamic]$E) do free_ptr((^raw.DynamicArray)(&array).data);
+free :: proc(array: $T/[dynamic]$E) do free_ptr((^raw.Dynamic_Array)(&array).data);
 free :: proc(slice: $T/[]$E)        do free_ptr((^raw.Slice       )(&slice).data);
 free :: proc(m:     $T/map[$K]$V) {
-	raw := cast(^raw.DynamicMap)&m;
+	raw := cast(^raw.Map)&m;
 	free(raw.hashes);
 	free(raw.entries.data);
 }
@@ -525,14 +525,14 @@ make :: proc(T: type/[dynamic]$E, len: int = 8, using location := #caller_locati
 	__slice_expr_error(file_path, int(line), int(column), 0, len, cap);
 	data := cast(^E)alloc(cap * size_of(E), align_of(E));
 	for i in 0..len do (data+i)^ = E{};
-	s := raw.DynamicArray{data = data, len = len, cap = cap, allocator = context.allocator};
+	s := raw.Dynamic_Array{data = data, len = len, cap = cap, allocator = context.allocator};
 	return (cast(^T)&s)^;
 }
 make :: proc(T: type/[dynamic]$E, len, cap: int, using location := #caller_location) -> T {
 	__slice_expr_error(file_path, int(line), int(column), 0, len, cap);
 	data := cast(^E)alloc(cap * size_of(E), align_of(E));
 	for i in 0..len do (data+i)^ = E{};
-	s := raw.DynamicArray{data = data, len = len, cap = cap, allocator = context.allocator};
+	s := raw.Dynamic_Array{data = data, len = len, cap = cap, allocator = context.allocator};
 	return (cast(^T)&s)^;
 }
 
@@ -671,7 +671,7 @@ __substring_expr_error :: proc(file: string, line, column: int, low, high: int)
 	            file, line, column, low, high);
 	__debug_trap();
 }
-__type_assertion_check :: proc(ok: bool, file: string, line, column: int, from, to: ^TypeInfo) #cc_contextless {
+__type_assertion_check :: proc(ok: bool, file: string, line, column: int, from, to: ^Type_Info) #cc_contextless {
 	if ok do return;
 	fmt.fprintf(os.stderr, "%s(%d:%d) Invalid type_assertion from %T to %T\n",
 	            file, line, column, from, to);
@@ -767,7 +767,7 @@ __abs_complex128 :: proc(x: complex128) -> f64 #inline #cc_contextless {
 
 
 __dynamic_array_make :: proc(array_: rawptr, elem_size, elem_align: int, len, cap: int) {
-	array := cast(^raw.DynamicArray)array_;
+	array := cast(^raw.Dynamic_Array)array_;
 	array.allocator = context.allocator;
 	assert(array.allocator.procedure != nil);
 
@@ -778,7 +778,7 @@ __dynamic_array_make :: proc(array_: rawptr, elem_size, elem_align: int, len, ca
 }
 
 __dynamic_array_reserve :: proc(array_: rawptr, elem_size, elem_align: int, cap: int) -> bool {
-	array := cast(^raw.DynamicArray)array_;
+	array := cast(^raw.Dynamic_Array)array_;
 
 	if cap <= array.cap do return true;
 
@@ -800,7 +800,7 @@ __dynamic_array_reserve :: proc(array_: rawptr, elem_size, elem_align: int, cap:
 }
 
 __dynamic_array_resize :: proc(array_: rawptr, elem_size, elem_align: int, len: int) -> bool {
-	array := cast(^raw.DynamicArray)array_;
+	array := cast(^raw.Dynamic_Array)array_;
 
 	ok := __dynamic_array_reserve(array_, elem_size, elem_align, len);
 	if ok do array.len = len;
@@ -810,7 +810,7 @@ __dynamic_array_resize :: proc(array_: rawptr, elem_size, elem_align: int, len:
 
 __dynamic_array_append :: proc(array_: rawptr, elem_size, elem_align: int,
                                items: rawptr, item_count: int) -> int {
-	array := cast(^raw.DynamicArray)array_;
+	array := cast(^raw.Dynamic_Array)array_;
 
 	if items == nil    do return 0;
 	if item_count <= 0 do return 0;
@@ -832,7 +832,7 @@ __dynamic_array_append :: proc(array_: rawptr, elem_size, elem_align: int,
 }
 
 __dynamic_array_append_nothing :: proc(array_: rawptr, elem_size, elem_align: int) -> int {
-	array := cast(^raw.DynamicArray)array_;
+	array := cast(^raw.Dynamic_Array)array_;
 
 	ok := true;
 	if array.cap <= array.len+1 {
@@ -881,18 +881,18 @@ __default_hash :: proc(data: []u8) -> u128 {
 }
 __default_hash_string :: proc(s: string) -> u128 do return __default_hash(cast([]u8)s);
 
-__dynamic_map_reserve :: proc(using header: __MapHeader, cap: int)  {
+__dynamic_map_reserve :: proc(using header: __Map_Header, cap: int)  {
 	__dynamic_array_reserve(&m.hashes, size_of(int), align_of(int), cap);
 	__dynamic_array_reserve(&m.entries, entry_size, entry_align,    cap);
 }
 
-__dynamic_map_rehash :: proc(using header: __MapHeader, new_count: int) {
-	new_header: __MapHeader = header;
-	nm: raw.DynamicMap;
+__dynamic_map_rehash :: proc(using header: __Map_Header, new_count: int) {
+	new_header: __Map_Header = header;
+	nm: raw.Map;
 	new_header.m = &nm;
 
-	header_hashes := cast(^raw.DynamicArray)&header.m.hashes;
-	nm_hashes     := cast(^raw.DynamicArray)&nm.hashes;
+	header_hashes := cast(^raw.Dynamic_Array)&header.m.hashes;
+	nm_hashes     := cast(^raw.Dynamic_Array)&nm.hashes;
 
 	__dynamic_array_resize(nm_hashes, size_of(int), align_of(int), new_count);
 	__dynamic_array_reserve(&nm.entries, entry_size, entry_align, m.entries.len);
@@ -925,7 +925,7 @@ __dynamic_map_rehash :: proc(using header: __MapHeader, new_count: int) {
 	header.m^ = nm;
 }
 
-__dynamic_map_get :: proc(h: __MapHeader, key: __MapKey) -> rawptr {
+__dynamic_map_get :: proc(h: __Map_Header, key: __Map_Key) -> rawptr {
 	index := __dynamic_map_find(h, key).entry_index;
 	if index >= 0 {
 		data := cast(^u8)__dynamic_map_get_entry(h, index);
@@ -934,7 +934,7 @@ __dynamic_map_get :: proc(h: __MapHeader, key: __MapKey) -> rawptr {
 	return nil;
 }
 
-__dynamic_map_set :: proc(using h: __MapHeader, key: __MapKey, value: rawptr) {
+__dynamic_map_set :: proc(using h: __Map_Header, key: __Map_Key, value: rawptr) {
 	index: int;
 	assert(value != nil);
 
@@ -968,17 +968,17 @@ __dynamic_map_set :: proc(using h: __MapHeader, key: __MapKey, value: rawptr) {
 }
 
 
-__dynamic_map_grow :: proc(using h: __MapHeader) {
+__dynamic_map_grow :: proc(using h: __Map_Header) {
 	new_count := max(2*m.entries.cap + 8, __INITIAL_MAP_CAP);
 	__dynamic_map_rehash(h, new_count);
 }
 
-__dynamic_map_full :: proc(using h: __MapHeader) -> bool #inline {
+__dynamic_map_full :: proc(using h: __Map_Header) -> bool #inline {
 	return int(0.75 * f64(len(m.hashes))) <= m.entries.cap;
 }
 
 
-__dynamic_map_hash_equal :: proc(h: __MapHeader, a, b: __MapKey) -> bool {
+__dynamic_map_hash_equal :: proc(h: __Map_Header, a, b: __Map_Key) -> bool {
 	if a.hash == b.hash {
 		if h.is_key_string do return a.str == b.str;
 		return true;
@@ -986,8 +986,8 @@ __dynamic_map_hash_equal :: proc(h: __MapHeader, a, b: __MapKey) -> bool {
 	return false;
 }
 
-__dynamic_map_find :: proc(using h: __MapHeader, key: __MapKey) -> __MapFindResult {
-	fr := __MapFindResult{-1, -1, -1};
+__dynamic_map_find :: proc(using h: __Map_Header, key: __Map_Key) -> __Map_Find_Result {
+	fr := __Map_Find_Result{-1, -1, -1};
 	if len(m.hashes) > 0 {
 		fr.hash_index = int(key.hash % u128(len(m.hashes)));
 		fr.entry_index = m.hashes[fr.hash_index];
@@ -1001,7 +1001,7 @@ __dynamic_map_find :: proc(using h: __MapHeader, key: __MapKey) -> __MapFindResu
 	return fr;
 }
 
-__dynamic_map_add_entry :: proc(using h: __MapHeader, key: __MapKey) -> int {
+__dynamic_map_add_entry :: proc(using h: __Map_Header, key: __Map_Key) -> int {
 	prev := m.entries.len;
 	c := __dynamic_array_append_nothing(&m.entries, entry_size, entry_align);
 	if c != prev {
@@ -1012,18 +1012,18 @@ __dynamic_map_add_entry :: proc(using h: __MapHeader, key: __MapKey) -> int {
 	return prev;
 }
 
-__dynamic_map_delete :: proc(using h: __MapHeader, key: __MapKey) {
+__dynamic_map_delete :: proc(using h: __Map_Header, key: __Map_Key) {
 	fr := __dynamic_map_find(h, key);
 	if fr.entry_index >= 0 {
 		__dynamic_map_erase(h, fr);
 	}
 }
 
-__dynamic_map_get_entry :: proc(using h: __MapHeader, index: int) -> ^__MapEntryHeader {
-	return cast(^__MapEntryHeader)(cast(^u8)m.entries.data + index*entry_size);
+__dynamic_map_get_entry :: proc(using h: __Map_Header, index: int) -> ^__Map_Entry_Header {
+	return cast(^__Map_Entry_Header)(cast(^u8)m.entries.data + index*entry_size);
 }
 
-__dynamic_map_erase :: proc(using h: __MapHeader, fr: __MapFindResult) {
+__dynamic_map_erase :: proc(using h: __Map_Header, fr: __Map_Find_Result) {
 	if fr.entry_prev < 0 {
 		m.hashes[fr.hash_index] = __dynamic_map_get_entry(h, fr.entry_index).next;
 	} else {

core/fmt.odin

@@ -10,12 +10,12 @@ import (
 
 _BUFFER_SIZE :: 1<<12;
 
-StringBuffer :: union {
+String_Buffer :: union {
 	[]u8,
 	[dynamic]u8,
 }
 
-FmtInfo :: struct {
+Fmt_Info :: struct {
 	minus:     bool;
 	plus:      bool;
 	space:     bool;
@@ -31,47 +31,47 @@ FmtInfo :: struct {
 	reordered:      bool;
 	good_arg_index: bool;
 
-	buf: ^StringBuffer;
+	buf: ^String_Buffer;
 	arg: any; // Temporary
 }
 
 
 
-string_buffer_data :: proc(buf: ^StringBuffer) -> []u8 {
+string_buffer_data :: proc(buf: ^String_Buffer) -> []u8 {
 	match b in buf {
 	case []u8:        return b[..];
 	case [dynamic]u8: return b[..];
 	}
 	return nil;
 }
-string_buffer_data :: proc(buf: StringBuffer) -> []u8 {
+string_buffer_data :: proc(buf: String_Buffer) -> []u8 {
 	match b in buf {
 	case []u8:        return b[..];
 	case [dynamic]u8: return b[..];
 	}
 	return nil;
 }
-to_string :: proc(buf: StringBuffer) -> string {
+to_string :: proc(buf: String_Buffer) -> string {
 	return string(string_buffer_data(buf));
 }
 
 
-write_string :: proc(buf: ^StringBuffer, s: string) {
+write_string :: proc(buf: ^String_Buffer, s: string) {
 	write_bytes(buf, cast([]u8)s);
 }
-write_bytes :: proc(buf: ^StringBuffer, data: []u8) {
+write_bytes :: proc(buf: ^String_Buffer, data: []u8) {
 	match b in buf {
 	case []u8:        append(b, ...data);
 	case [dynamic]u8: append(b, ...data);
 	}
 }
-write_byte :: proc(buf: ^StringBuffer, data: u8) {
+write_byte :: proc(buf: ^String_Buffer, data: u8) {
 	match b in buf {
 	case []u8:        append(b, data);
 	case [dynamic]u8: append(b, data);
 	}
 }
-write_rune :: proc(buf: ^StringBuffer, r: rune) {
+write_rune :: proc(buf: ^String_Buffer, r: rune) {
 	if r < utf8.RUNE_SELF {
 		write_byte(buf, u8(r));
 		return;
@@ -81,12 +81,12 @@ write_rune :: proc(buf: ^StringBuffer, r: rune) {
 	write_bytes(buf, b[..n]);
 }
 
-write_int :: proc(buf: ^StringBuffer, i: i128, base: int) {
+write_int :: proc(buf: ^String_Buffer, i: i128, base: int) {
 	b: [129]u8;
 	s := strconv.append_bits(b[..0], u128(i), base, true, 128, strconv.digits, 0);
 	write_string(buf, s);
 }
-write_int :: proc(buf: ^StringBuffer, i: i64, base: int) {
+write_int :: proc(buf: ^String_Buffer, i: i64, base: int) {
 	b: [129]u8;
 	s := strconv.append_bits(b[..0], u128(i), base, true, 64, strconv.digits, 0);
 	write_string(buf, s);
@@ -96,7 +96,7 @@ write_int :: proc(buf: ^StringBuffer, i: i64, base: int) {
 
 fprint :: proc(fd: os.Handle, args: ...any) -> int {
 	data: [_BUFFER_SIZE]u8;
-	buf := StringBuffer(data[..0]);
+	buf := String_Buffer(data[..0]);
 	sbprint(&buf, ...args);
 	res := string_buffer_data(buf);
 	os.write(fd, res);
@@ -105,7 +105,7 @@ fprint :: proc(fd: os.Handle, args: ...any) -> int {
 
 fprintln :: proc(fd: os.Handle, args: ...any) -> int {
 	data: [_BUFFER_SIZE]u8;
-	buf := StringBuffer(data[..0]);
+	buf := String_Buffer(data[..0]);
 	sbprintln(&buf, ...args);
 	res := string_buffer_data(buf);
 	os.write(fd, res);
@@ -113,7 +113,7 @@ fprintln :: proc(fd: os.Handle, args: ...any) -> int {
 }
 fprintf :: proc(fd: os.Handle, fmt: string, args: ...any) -> int {
 	data: [_BUFFER_SIZE]u8;
-	buf := StringBuffer(data[..0]);
+	buf := String_Buffer(data[..0]);
 	sbprintf(&buf, fmt, ...args);
 	res := string_buffer_data(buf);
 	os.write(fd, res);
@@ -133,17 +133,17 @@ printf_err  :: proc(fmt: string, args: ...any) -> int { return fprintf(os.stderr
 // aprint* procedures return a string that was allocated with the current context
 // They must be freed accordingly
 aprint :: proc(args: ...any) -> string {
-	buf := StringBuffer(make([dynamic]u8));
+	buf := String_Buffer(make([dynamic]u8));
 	sbprint(&buf, ...args);
 	return to_string(buf);
 }
 aprintln :: proc(args: ...any) -> string {
-	buf := StringBuffer(make([dynamic]u8));
+	buf := String_Buffer(make([dynamic]u8));
 	sbprintln(&buf, ...args);
 	return to_string(buf);
 }
 aprintf :: proc(fmt: string, args: ...any) -> string {
-	buf := StringBuffer(make([dynamic]u8));
+	buf := String_Buffer(make([dynamic]u8));
 	sbprintf(&buf, fmt, ...args);
 	return to_string(buf);
 }
@@ -151,15 +151,15 @@ aprintf :: proc(fmt: string, args: ...any) -> string {
 
 // bprint* procedures return a string using a buffer from an array
 bprint :: proc(buf: []u8, args: ...any) -> string {
-	sb := StringBuffer(buf[..0..len(buf)]);
+	sb := String_Buffer(buf[..0..len(buf)]);
 	return sbprint(&sb, ...args);
 }
 bprintln :: proc(buf: []u8, args: ...any) -> string {
-	sb := StringBuffer(buf[..0..len(buf)]);
+	sb := String_Buffer(buf[..0..len(buf)]);
 	return sbprintln(&sb, ...args);
 }
 bprintf :: proc(buf: []u8, fmt: string, args: ...any) -> string {
-	sb := StringBuffer(buf[..0..len(buf)]);
+	sb := String_Buffer(buf[..0..len(buf)]);
 	return sbprintf(&sb, fmt, ...args);
 }
 
@@ -168,17 +168,17 @@ bprintf :: proc(buf: []u8, fmt: string, args: ...any) -> string {
 
 
 
-fprint_type :: proc(fd: os.Handle, info: ^TypeInfo) {
+fprint_type :: proc(fd: os.Handle, info: ^Type_Info) {
 	data: [_BUFFER_SIZE]u8;
-	buf := StringBuffer(data[..0]);
+	buf := String_Buffer(data[..0]);
 	write_type(&buf, info);
 	os.write(fd, string_buffer_data(buf));
 }
 
-write_type :: proc(buf: ^StringBuffer, ti: ^TypeInfo) {
+write_type :: proc(buf: ^String_Buffer, ti: ^Type_Info) {
 	if ti == nil do return;
 
-	using TypeInfo;
+	using Type_Info;
 	match info in ti.variant {
 	case Named:
 		write_string(buf, info.name);
@@ -252,11 +252,11 @@ write_type :: proc(buf: ^StringBuffer, ti: ^TypeInfo) {
 
 	case Array:
 		write_string(buf, "[");
-		fi := FmtInfo{buf = buf};
+		fi := Fmt_Info{buf = buf};
 		write_int(buf, i64(info.count), 10);
 		write_string(buf, "]");
 		write_type(buf, info.elem);
-	case DynamicArray:
+	case Dynamic_Array:
 		write_string(buf, "[dynamic]");
 		write_type(buf, info.elem);
 	case Slice:
@@ -311,7 +311,7 @@ write_type :: proc(buf: ^StringBuffer, ti: ^TypeInfo) {
 		}
 		write_string(buf, "}");
 
-	case BitField:
+	case Bit_Field:
 		write_string(buf, "bit_field ");
 		if ti.align != 1 {
 			write_string(buf, "#align ");
@@ -352,7 +352,7 @@ _parse_int :: proc(s: string, offset: int) -> (result: int, offset: int, ok: boo
 	return result, offset+i, i != 0;
 }
 
-_arg_number :: proc(fi: ^FmtInfo, arg_index: int, format: string, offset, arg_count: int) -> (index, offset: int, ok: bool) {
+_arg_number :: proc(fi: ^Fmt_Info, arg_index: int, format: string, offset, arg_count: int) -> (index, offset: int, ok: bool) {
 	parse_arg_number :: proc(format: string) -> (int, int, bool) {
 		if len(format) < 3 do return 0, 1, false;
 
@@ -408,7 +408,7 @@ int_from_arg :: proc(args: []any, arg_index: int) -> (int, int, bool) {
 }
 
 
-fmt_bad_verb :: proc(using fi: ^FmtInfo, verb: rune) {
+fmt_bad_verb :: proc(using fi: ^Fmt_Info, verb: rune) {
 	assert(verb != 'v');
 	write_string(buf, "%!");
 	write_rune(buf, verb);
@@ -423,7 +423,7 @@ fmt_bad_verb :: proc(using fi: ^FmtInfo, verb: rune) {
 	write_byte(buf, ')');
 }
 
-fmt_bool :: proc(using fi: ^FmtInfo, b: bool, verb: rune) {
+fmt_bool :: proc(using fi: ^Fmt_Info, b: bool, verb: rune) {
 	match verb {
 	case 't', 'v':
 		s := "false";
@@ -435,7 +435,7 @@ fmt_bool :: proc(using fi: ^FmtInfo, b: bool, verb: rune) {
 }
 
 
-fmt_write_padding :: proc(fi: ^FmtInfo, width: int) {
+fmt_write_padding :: proc(fi: ^Fmt_Info, width: int) {
 	if width <= 0 do return;
 
 	pad_byte: u8 = '0';
@@ -446,7 +446,7 @@ fmt_write_padding :: proc(fi: ^FmtInfo, width: int) {
 	}
 }
 
-_fmt_int :: proc(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: int, digits: string) {
+_fmt_int :: proc(fi: ^Fmt_Info, u: u128, base: int, is_signed: bool, bit_size: int, digits: string) {
 	_, neg := strconv.is_integer_negative(u128(u), is_signed, bit_size);
 
 	BUF_SIZE :: 256;
@@ -486,10 +486,10 @@ _fmt_int :: proc(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: in
 	buf: [256]u8;
 	start := 0;
 
-	flags: strconv.IntFlag;
-	if fi.hash && !fi.zero do flags |= strconv.IntFlag.Prefix;
-	if fi.plus             do flags |= strconv.IntFlag.Plus;
-	if fi.space            do flags |= strconv.IntFlag.Space;
+	flags: strconv.Int_Flag;
+	if fi.hash && !fi.zero do flags |= strconv.Int_Flag.Prefix;
+	if fi.plus             do flags |= strconv.Int_Flag.Plus;
+	if fi.space            do flags |= strconv.Int_Flag.Space;
 	s := strconv.append_bits(buf[start..start], u128(u), base, is_signed, bit_size, digits, flags);
 
 	if fi.hash && fi.zero {
@@ -517,7 +517,7 @@ _fmt_int :: proc(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: in
 __DIGITS_LOWER := "0123456789abcdefx";
 __DIGITS_UPPER := "0123456789ABCDEFX";
 
-fmt_rune :: proc(fi: ^FmtInfo, r: rune, verb: rune) {
+fmt_rune :: proc(fi: ^Fmt_Info, r: rune, verb: rune) {
 	match verb {
 	case 'c', 'r', 'v':
 		write_rune(fi.buf, r);
@@ -526,7 +526,7 @@ fmt_rune :: proc(fi: ^FmtInfo, r: rune, verb: rune) {
 	}
 }
 
-fmt_int :: proc(fi: ^FmtInfo, u: u128, is_signed: bool, bit_size: int, verb: rune) {
+fmt_int :: proc(fi: ^Fmt_Info, u: u128, is_signed: bool, bit_size: int, verb: rune) {
 	match verb {
 	case 'v': _fmt_int(fi, u, 10, is_signed, bit_size, __DIGITS_LOWER);
 	case 'b': _fmt_int(fi, u,  2, is_signed, bit_size, __DIGITS_LOWER);
@@ -551,7 +551,7 @@ fmt_int :: proc(fi: ^FmtInfo, u: u128, is_signed: bool, bit_size: int, verb: run
 	}
 }
 
-_pad :: proc(fi: ^FmtInfo, s: string) {
+_pad :: proc(fi: ^Fmt_Info, s: string) {
 	if !fi.width_set {
 		write_string(fi.buf, s);
 		return;
@@ -568,7 +568,7 @@ _pad :: proc(fi: ^FmtInfo, s: string) {
 	}
 }
 
-fmt_float :: proc(fi: ^FmtInfo, v: f64, bit_size: int, verb: rune) {
+fmt_float :: proc(fi: ^Fmt_Info, v: f64, bit_size: int, verb: rune) {
 	match verb {
 	// case 'e', 'E', 'f', 'F', 'g', 'G', 'v':
 	// case 'f', 'F', 'v':
@@ -611,7 +611,7 @@ fmt_float :: proc(fi: ^FmtInfo, v: f64, bit_size: int, verb: rune) {
 		fmt_bad_verb(fi, verb);
 	}
 }
-fmt_string :: proc(fi: ^FmtInfo, s: string, verb: rune) {
+fmt_string :: proc(fi: ^Fmt_Info, s: string, verb: rune) {
 	match verb {
 	case 's', 'v':
 		write_string(fi.buf, s);
@@ -633,7 +633,7 @@ fmt_string :: proc(fi: ^FmtInfo, s: string, verb: rune) {
 	}
 }
 
-fmt_pointer :: proc(fi: ^FmtInfo, p: rawptr, verb: rune) {
+fmt_pointer :: proc(fi: ^Fmt_Info, p: rawptr, verb: rune) {
 	match verb {
 	case 'p', 'v':
 		// Okay
@@ -651,7 +651,7 @@ fmt_pointer :: proc(fi: ^FmtInfo, p: rawptr, verb: rune) {
 enum_value_to_string :: proc(v: any) -> (string, bool) {
 	v.type_info = type_info_base(v.type_info);
 
-	using TypeInfo;
+	using Type_Info;
 	match e in v.type_info.variant {
 	case: return "", false;
 	case Enum:
@@ -700,7 +700,7 @@ enum_value_to_string :: proc(v: any) -> (string, bool) {
 
 string_to_enum_value :: proc(T: type, s: string) -> (T, bool) {
 	ti := type_info_base(type_info_of(T));
-	if e, ok := ti.variant.(TypeInfo.Enum); ok {
+	if e, ok := ti.variant.(Type_Info.Enum); ok {
 		for str, idx in e.names {
 			if s == str {
 				// NOTE(bill): Unsafe cast
@@ -712,13 +712,13 @@ string_to_enum_value :: proc(T: type, s: string) -> (T, bool) {
 	return T{}, false;
 }
 
-fmt_enum :: proc(fi: ^FmtInfo, v: any, verb: rune) {
+fmt_enum :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
 	if v.type_info == nil || v.data == nil {
 		write_string(fi.buf, "<nil>");
 		return;
 	}
 
-	using TypeInfo;
+	using Type_Info;
 	match e in v.type_info.variant {
 	case: fmt_bad_verb(fi, verb);
 	case Enum:
@@ -735,13 +735,13 @@ fmt_enum :: proc(fi: ^FmtInfo, v: any, verb: rune) {
 }
 
 
-fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
+fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
 	if v.data == nil || v.type_info == nil {
 		write_string(fi.buf, "<nil>");
 		return;
 	}
 
-	using TypeInfo;
+	using Type_Info;
 	match info in v.type_info.variant {
 	case Named:
 		match b in info.base.variant {
@@ -800,8 +800,8 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
 	case String:     fmt_arg(fi, v, verb);
 
 	case Pointer:
-		if v.type_info == type_info_of(^TypeInfo) {
-			write_type(fi.buf, (cast(^^TypeInfo)v.data)^);
+		if v.type_info == type_info_of(^Type_Info) {
+			write_type(fi.buf, (cast(^^Type_Info)v.data)^);
 		} else {
 			fmt_pointer(fi, (cast(^rawptr)v.data)^, verb);
 		}
@@ -816,10 +816,10 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
 			fmt_arg(fi, any{rawptr(data), info.elem}, verb);
 		}
 
-	case DynamicArray:
+	case Dynamic_Array:
 		write_byte(fi.buf, '[');
 		defer write_byte(fi.buf, ']');
-		array := cast(^raw.DynamicArray)v.data;
+		array := cast(^raw.Dynamic_Array)v.data;
 		for i in 0..array.len {
 			if i > 0 do write_string(fi.buf, ", ");
 
@@ -858,9 +858,9 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
 		write_string(fi.buf, "map[");
 		defer write_byte(fi.buf, ']');
 
-		entries    := &((cast(^raw.DynamicMap)v.data).entries);
+		entries    := &((cast(^raw.Map)v.data).entries);
 		gs         := type_info_base(info.generated_struct).variant.(Struct);
-		ed         := type_info_base(gs.types[1]).variant.(DynamicArray);
+		ed         := type_info_base(gs.types[1]).variant.(Dynamic_Array);
 		entry_type := ed.elem.variant.(Struct);
 		entry_size := ed.elem_size;
 
@@ -868,12 +868,12 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
 			if i > 0 do write_string(fi.buf, ", ");
 
 			data := cast(^u8)entries.data + i*entry_size;
-			header := cast(^__MapEntryHeader)data;
+			header := cast(^__Map_Entry_Header)data;
 
 			if types.is_string(info.key) {
 				write_string(fi.buf, header.key.str);
 			} else {
-				fi := FmtInfo{buf = fi.buf};
+				fi := Fmt_Info{buf = fi.buf};
 				fmt_arg(&fi, any{rawptr(&header.key.hash), info.key}, 'v');
 			}
 
@@ -924,7 +924,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
 
 	case Union:
 		data := cast(^u8)v.data;
-		tipp := cast(^^TypeInfo)(data + info.tag_offset);
+		tipp := cast(^^Type_Info)(data + info.tag_offset);
 		if data == nil || tipp == nil {
 			write_string(fi.buf, "(union)");
 		} else {
@@ -942,7 +942,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
 	}
 }
 
-fmt_complex :: proc(fi: ^FmtInfo, c: complex128, bits: int, verb: rune) {
+fmt_complex :: proc(fi: ^Fmt_Info, c: complex128, bits: int, verb: rune) {
 	match verb {
 	case 'f', 'F', 'v':
 		r, i := real(c), imag(c);
@@ -963,11 +963,11 @@ _u128_to_lo_hi :: proc(a: u128) -> (lo, hi: u64) { return u64(a), u64(a>>64); }
 _i128_to_lo_hi :: proc(a: u128) -> (lo: u64 hi: i64) { return u64(a), i64(a>>64); }
 
 
-do_foo :: proc(fi: ^FmtInfo, f: f64) {
+do_foo :: proc(fi: ^Fmt_Info, f: f64) {
 	fmt_string(fi, "Hellope$%!", 'v');
 }
 
-fmt_arg :: proc(fi: ^FmtInfo, arg: any, verb: rune) {
+fmt_arg :: proc(fi: ^Fmt_Info, arg: any, verb: rune) {
 	if arg == nil {
 		write_string(fi.buf, "<nil>");
 		return;
@@ -977,7 +977,7 @@ fmt_arg :: proc(fi: ^FmtInfo, arg: any, verb: rune) {
 	if verb == 'T' {
 		ti := arg.type_info;
 		match a in arg {
-		case ^TypeInfo: ti = a;
+		case ^Type_Info: ti = a;
 		}
 		write_type(fi.buf, ti);
 		return;
@@ -1022,8 +1022,8 @@ fmt_arg :: proc(fi: ^FmtInfo, arg: any, verb: rune) {
 
 
 
-sbprint :: proc(buf: ^StringBuffer, args: ...any) -> string {
-	fi: FmtInfo;
+sbprint :: proc(buf: ^String_Buffer, args: ...any) -> string {
+	fi: Fmt_Info;
 	prev_string := false;
 
 	fi.buf = buf;
@@ -1039,8 +1039,8 @@ sbprint :: proc(buf: ^StringBuffer, args: ...any) -> string {
 	return to_string(buf^);
 }
 
-sbprintln :: proc(buf: ^StringBuffer, args: ...any) -> string {
-	fi: FmtInfo;
+sbprintln :: proc(buf: ^String_Buffer, args: ...any) -> string {
+	fi: Fmt_Info;
 	fi.buf = buf;
 
 	for arg, i in args {
@@ -1052,15 +1052,15 @@ sbprintln :: proc(buf: ^StringBuffer, args: ...any) -> string {
 	return to_string(buf^);
 }
 
-sbprintf :: proc(b: ^StringBuffer, fmt: string, args: ...any) -> string {
-	fi: FmtInfo;
+sbprintf :: proc(b: ^String_Buffer, fmt: string, args: ...any) -> string {
+	fi: Fmt_Info;
 	arg_index: int = 0;
 	end := len(fmt);
 	was_prev_index := false;
 
 
 	for i := 0; i < end; /**/ {
-		fi = FmtInfo{buf = b, good_arg_index = true};
+		fi = Fmt_Info{buf = b, good_arg_index = true};
 
 		prev_i := i;
 		for i < end && fmt[i] != '%' {

core/mem.odin

@@ -194,7 +194,7 @@ end_arena_temp_memory :: proc(using tmp: ArenaTempMemory) {
 
 
 
-align_of_type_info :: proc(type_info: ^TypeInfo) -> int {
+align_of_type_info :: proc(type_info: ^Type_Info) -> int {
 	prev_pow2 :: proc(n: i64) -> i64 {
 		if n <= 0 do return 0;
 		n |= n >> 1;
@@ -208,7 +208,7 @@ align_of_type_info :: proc(type_info: ^TypeInfo) -> int {
 
 	WORD_SIZE :: size_of(int);
 	MAX_ALIGN :: size_of([vector 64]f64); // TODO(bill): Should these constants be builtin constants?
-	using TypeInfo;
+	using Type_Info;
 	match info in type_info.variant {
 	case Named:
 		return align_of_type_info(info.base);
@@ -230,7 +230,7 @@ align_of_type_info :: proc(type_info: ^TypeInfo) -> int {
 		return WORD_SIZE;
 	case Array:
 		return align_of_type_info(info.elem);
-	case DynamicArray:
+	case Dynamic_Array:
 		return WORD_SIZE;
 	case Slice:
 		return WORD_SIZE;
@@ -259,9 +259,9 @@ align_formula :: proc(size, align: int) -> int {
 	return result - result%align;
 }
 
-size_of_type_info :: proc(type_info: ^TypeInfo) -> int {
+size_of_type_info :: proc(type_info: ^Type_Info) -> int {
 	WORD_SIZE :: size_of(int);
-	using TypeInfo;
+	using Type_Info;
 	match info in type_info.variant {
 	case Named:
 		return size_of_type_info(info.base);
@@ -288,7 +288,7 @@ size_of_type_info :: proc(type_info: ^TypeInfo) -> int {
 		align     := align_of_type_info(info.elem);
 		alignment := align_formula(size, align);
 		return alignment*(count-1) + size;
-	case DynamicArray:
+	case Dynamic_Array:
 		return size_of(rawptr) + 2*size_of(int) + size_of(Allocator);
 	case Slice:
 		return 2*WORD_SIZE;

core/os_linux.odin

@@ -5,7 +5,7 @@ foreign_system_library (
 import "strings.odin";
 
 Handle   :: i32;
-FileTime :: u64;
+File_Time :: u64;
 Errno    :: i32;
 
 
@@ -40,7 +40,7 @@ RTLD_GLOBAL       :: 0x100;
 // "Argv" arguments converted to Odin strings
 args := _alloc_command_line_arguments();
 
-_FileTime :: struct #ordered {
+_File_Time :: struct #ordered {
 	seconds:     i64;
 	nanoseconds: i32;
 	reserved:    i32;
@@ -63,9 +63,9 @@ Stat :: struct #ordered {
 	block_size:    i64; // Optimal bllocksize for I/O
 	blocks:        i64; // Number of 512-byte blocks allocated
 
-	last_access:   _FileTime; // Time of last access
-	modified:      _FileTime; // Time of last modification
-	status_change: _FileTime; // Time of last status change
+	last_access:   _File_Time; // Time of last access
+	modified:      _File_Time; // Time of last modification
+	status_change: _File_Time; // Time of last status change
 
 	_reserve1,
 	_reserve2,
@@ -195,8 +195,8 @@ stdout: Handle = 1;
 stderr: Handle = 2;
 
 /* TODO(zangent): Implement these!
-last_write_time :: proc(fd: Handle) -> FileTime {}
-last_write_time_by_name :: proc(name: string) -> FileTime {}
+last_write_time :: proc(fd: Handle) -> File_Time {}
+last_write_time_by_name :: proc(name: string) -> File_Time {}
 */
 
 stat :: proc(path: string) -> (Stat, int) #inline {

core/os_windows.odin

@@ -2,7 +2,7 @@ import win32 "sys/windows.odin";
 import "mem.odin";
 
 Handle   :: int;
-FileTime :: u64;
+File_Time :: u64;
 
 
 INVALID_HANDLE: Handle : -1;
@@ -75,8 +75,8 @@ open :: proc(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errn
 	}
 
 	share_mode := u32(win32.FILE_SHARE_READ|win32.FILE_SHARE_WRITE);
-	sa: ^win32.SecurityAttributes = nil;
-	sa_inherit := win32.SecurityAttributes{length = size_of(win32.SecurityAttributes), inherit_handle = 1};
+	sa: ^win32.Security_Attributes = nil;
+	sa_inherit := win32.Security_Attributes{length = size_of(win32.Security_Attributes), inherit_handle = 1};
 	if mode&O_CLOEXEC == 0 {
 		sa = &sa_inherit;
 	}
@@ -202,17 +202,17 @@ get_std_handle :: proc(h: int) -> Handle {
 
 
 
-last_write_time :: proc(fd: Handle) -> FileTime {
-	file_info: win32.ByHandleFileInformation;
+last_write_time :: proc(fd: Handle) -> File_Time {
+	file_info: win32.By_Handle_File_Information;
 	win32.get_file_information_by_handle(win32.Handle(fd), &file_info);
-	lo := FileTime(file_info.last_write_time.lo);
-	hi := FileTime(file_info.last_write_time.hi);
+	lo := File_Time(file_info.last_write_time.lo);
+	hi := File_Time(file_info.last_write_time.hi);
 	return lo | hi << 32;
 }
 
-last_write_time_by_name :: proc(name: string) -> FileTime {
+last_write_time_by_name :: proc(name: string) -> File_Time {
 	last_write_time: win32.Filetime;
-	data: win32.FileAttributeData;
+	data: win32.File_Attribute_Data;
 	buf: [1024]u8;
 
 	assert(len(buf) > len(name));
@@ -223,8 +223,8 @@ last_write_time_by_name :: proc(name: string) -> FileTime {
 		last_write_time = data.last_write_time;
 	}
 
-	l := FileTime(last_write_time.lo);
-	h := FileTime(last_write_time.hi);
+	l := File_Time(last_write_time.lo);
+	h := File_Time(last_write_time.hi);
 	return l | h << 32;
 }
 
@@ -284,7 +284,7 @@ _alloc_command_line_arguments :: proc() -> []string {
 				j += 1;
 			case 0xd800 <= str[j] && str[j] < 0xdc00:
 				if i+4 > len do return "";
-				c := rune((str[j] - 0xd800) << 10) + rune((str[j+1]) - 0xdc00) + 0x10000;
+			c := rune((str[j] - 0xd800) << 10) + rune((str[j+1]) - 0xdc00) + 0x10000;
 				buf[i] = u8(0xf0 +  (c >> 18));         i += 1;
 				buf[i] = u8(0x80 + ((c >> 12) & 0x3f)); i += 1;
 				buf[i] = u8(0x80 + ((c >>  6) & 0x3f)); i += 1;

core/os_x.odin

@@ -6,7 +6,7 @@ foreign_system_library (
 import "strings.odin";
 
 Handle      :: i32;
-FileTime    :: u64;
+File_Time    :: u64;
 Errno       :: int;
 
 
@@ -46,7 +46,7 @@ RTLD_FIRST    :: 0x100;
 
 args: [dynamic]string;
 
-_FileTime :: struct #ordered {
+_File_Time :: struct #ordered {
 	seconds: i64;
 	nanoseconds: i64;
 }
@@ -60,10 +60,10 @@ Stat :: struct #ordered {
 	gid:           u32; // Group ID of the file's group
 	rdev:          i32; // Device ID, if device
 
-	last_access:   FileTime; // Time of last access
-	modified:      FileTime; // Time of last modification
-	status_change: FileTime; // Time of last status change
-	created:       FileTime; // Time of creation
+	last_access:   File_Time; // Time of last access
+	modified:      File_Time; // Time of last modification
+	status_change: File_Time; // Time of last status change
+	created:       File_Time; // Time of creation
 
 	size:          i64;  // Size of the file, in bytes
 	blocks:        i64;  // Number of blocks allocated for the file
@@ -212,8 +212,8 @@ stdout: Handle = 1; // get_std_handle(win32.STD_OUTPUT_HANDLE);
 stderr: Handle = 2; // get_std_handle(win32.STD_ERROR_HANDLE);
 
 /* TODO(zangent): Implement these!
-last_write_time :: proc(fd: Handle) -> FileTime {}
-last_write_time_by_name :: proc(name: string) -> FileTime {}
+last_write_time :: proc(fd: Handle) -> File_Time {}
+last_write_time_by_name :: proc(name: string) -> File_Time {}
 */
 
 stat :: proc(path: string) -> (Stat, bool) #inline {

core/raw.odin

@@ -1,6 +1,6 @@
 Any :: struct #ordered {
 	data:      rawptr;
-	type_info: ^TypeInfo;
+	type_info: ^Type_Info;
 };
 
 String :: struct #ordered {
@@ -14,15 +14,15 @@ Slice :: struct #ordered {
 	cap:  int;
 };
 
-DynamicArray :: struct #ordered {
+Dynamic_Array :: struct #ordered {
 	data:      rawptr;
 	len:       int;
 	cap:       int;
 	allocator: Allocator;
 };
 
-DynamicMap :: struct #ordered {
+Map :: struct #ordered {
 	hashes:  [dynamic]int;
-	entries: DynamicArray;
+	entries: Dynamic_Array;
 };
 

core/strconv.odin

@@ -1,6 +1,6 @@
 import . "decimal.odin";
 
-IntFlag :: enum {
+Int_Flag :: enum {
 	Prefix = 1<<0,
 	Plus   = 1<<1,
 	Space  = 1<<2,
@@ -445,7 +445,7 @@ is_integer_negative :: proc(u: u128, is_signed: bool, bit_size: int) -> (unsigne
 	return u, neg;
 }
 
-append_bits :: proc(buf: []u8, u: u128, base: int, is_signed: bool, bit_size: int, digits: string, flags: IntFlag) -> string {
+append_bits :: proc(buf: []u8, u: u128, base: int, is_signed: bool, bit_size: int, digits: string, flags: Int_Flag) -> string {
 	if base < 2 || base > MAX_BASE {
 		panic("strconv: illegal base passed to append_bits");
 	}
@@ -461,7 +461,7 @@ append_bits :: proc(buf: []u8, u: u128, base: int, is_signed: bool, bit_size: in
 	}
 	i-=1; a[i] = digits[uint(u % b)];
 
-	if flags&IntFlag.Prefix != 0 {
+	if flags&Int_Flag.Prefix != 0 {
 		ok := true;
 		match base {
 		case  2: i-=1; a[i] = 'b';
@@ -478,9 +478,9 @@ append_bits :: proc(buf: []u8, u: u128, base: int, is_signed: bool, bit_size: in
 
 	if neg {
 		i-=1; a[i] = '-';
-	} else if flags&IntFlag.Plus != 0 {
+	} else if flags&Int_Flag.Plus != 0 {
 		i-=1; a[i] = '+';
-	} else if flags&IntFlag.Space != 0 {
+	} else if flags&Int_Flag.Space != 0 {
 		i-=1; a[i] = ' ';
 	}
 

core/sync_windows.odin

@@ -17,7 +17,7 @@ Mutex :: struct {
 */
 
 Mutex :: struct {
-	_critical_section: win32.CriticalSection;
+	_critical_section: win32.Critical_Section;
 }
 
 current_thread_id :: proc() -> i32 {

core/sys/wgl.odin

@@ -11,9 +11,9 @@ CONTEXT_CORE_PROFILE_BIT_ARB          :: 0x00000001;
 CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB :: 0x00000002;
 
 Hglrc    :: Handle;
-ColorRef :: u32;
+Color_Ref :: u32;
 
-LayerPlaneDescriptor :: struct {
+Layer_Plane_Descriptor :: struct {
 	size:             u16;
 	version:          u16;
 	flags:            u32;
@@ -37,29 +37,29 @@ LayerPlaneDescriptor :: struct {
 	aux_buffers:      u8;
 	layer_type:       u8;
 	reserved:         u8;
-	transparent:      ColorRef;
+	transparent:      Color_Ref;
 }
 
-PointFloat :: struct {x, y: f32};
+Point_Float :: struct {x, y: f32};
 
-Glyph_MetricsFloat :: struct {
+Glyph_Metrics_Float :: struct {
 	black_box_x:  f32;
 	black_box_y:  f32;
-	glyph_origin: PointFloat;
+	glyph_origin: Point_Float;
 	cell_inc_x:   f32;
 	cell_inc_y:   f32;
 }
 
-CreateContextAttribsARBType :: proc(hdc: Hdc, h_share_context: rawptr, attribList: ^i32) -> Hglrc;
-ChoosePixelFormatARBType    :: proc(hdc: Hdc, attrib_i_list: ^i32, attrib_f_list: ^f32, max_formats: u32, formats: ^i32, num_formats : ^u32) -> Bool #cc_c;
-SwapIntervalEXTType         :: proc(interval: i32) -> bool #cc_c;
-GetExtensionsStringARBType  :: proc(Hdc) -> ^u8 #cc_c;
+Create_Context_Attribs_ARB_Type :: #type proc(hdc: Hdc, h_share_context: rawptr, attribList: ^i32) -> Hglrc;
+Choose_Pixel_Format_ARB_Type    :: #type proc(hdc: Hdc, attrib_i_list: ^i32, attrib_f_list: ^f32, max_formats: u32, formats: ^i32, num_formats : ^u32) -> Bool #cc_c;
+Swap_Interval_EXT_Type          :: #type proc(interval: i32) -> bool #cc_c;
+Get_Extensions_String_ARB_Type  :: #type proc(Hdc) -> ^u8 #cc_c;
 
 // Procedures
-	create_context_attribs_arb: CreateContextAttribsARBType;
-	choose_pixel_format_arb:    ChoosePixelFormatARBType;
-	swap_interval_ext:          SwapIntervalEXTType;
-	get_extensions_string_arb:  GetExtensionsStringARBType;
+	create_context_attribs_arb: Create_Context_Attribs_ARB_Type;
+	choose_pixel_format_arb:    Choose_Pixel_Format_ARB_Type;
+	swap_interval_ext:          Swap_Interval_EXT_Type;
+	get_extensions_string_arb:  Get_Extensions_String_ARB_Type;
 
 
 
@@ -70,14 +70,14 @@ foreign opengl32 {
 	delete_context            :: proc(hglrc: Hglrc) -> Bool                                                                                              #link_name "wglDeleteContext"          ---;
 	copy_context              :: proc(src, dst: Hglrc, mask: u32) -> Bool                                                                                #link_name "wglCopyContext"            ---;
 	create_layer_context      :: proc(hdc: Hdc, layer_plane: i32) -> Hglrc                                                                               #link_name "wglCreateLayerContext"     ---;
-	describe_layer_plane      :: proc(hdc: Hdc, pixel_format, layer_plane: i32, bytes: u32, pd: ^LayerPlaneDescriptor) -> Bool                           #link_name "wglDescribeLayerPlane"     ---;
+	describe_layer_plane      :: proc(hdc: Hdc, pixel_format, layer_plane: i32, bytes: u32, pd: ^Layer_Plane_Descriptor) -> Bool                         #link_name "wglDescribeLayerPlane"     ---;
 	get_current_context       :: proc() -> Hglrc                                                                                                         #link_name "wglGetCurrentContext"      ---;
 	get_current_dc            :: proc() -> Hdc                                                                                                           #link_name "wglGetCurrentDC"           ---;
-	get_layer_palette_entries :: proc(hdc: Hdc, layer_plane, start, entries: i32, cr: ^ColorRef) -> i32                                                  #link_name "wglGetLayerPaletteEntries" ---;
+	get_layer_palette_entries :: proc(hdc: Hdc, layer_plane, start, entries: i32, cr: ^Color_Ref) -> i32                                                 #link_name "wglGetLayerPaletteEntries" ---;
 	realize_layer_palette     :: proc(hdc: Hdc, layer_plane: i32, realize: Bool) -> Bool                                                                 #link_name "wglRealizeLayerPalette"    ---;
-	set_layer_palette_entries :: proc(hdc: Hdc, layer_plane, start, entries: i32, cr: ^ColorRef) -> i32                                                  #link_name "wglSetLayerPaletteEntries" ---;
+	set_layer_palette_entries :: proc(hdc: Hdc, layer_plane, start, entries: i32, cr: ^Color_Ref) -> i32                                                 #link_name "wglSetLayerPaletteEntries" ---;
 	share_lists               :: proc(hglrc1, hglrc2: Hglrc) -> Bool                                                                                     #link_name "wglShareLists"             ---;
 	swap_layer_buffers        :: proc(hdc: Hdc, planes: u32) -> Bool                                                                                     #link_name "wglSwapLayerBuffers"       ---;
 	use_font_bitmaps          :: proc(hdc: Hdc, first, count, list_base: u32) -> Bool                                                                    #link_name "wglUseFontBitmaps"         ---;
-	use_font_outlines         :: proc(hdc: Hdc, first, count, list_base: u32, deviation, extrusion: f32, format: i32, gmf: ^Glyph_MetricsFloat) -> Bool  #link_name "wglUseFontOutlines"        ---;
+	use_font_outlines         :: proc(hdc: Hdc, first, count, list_base: u32, deviation, extrusion: f32, format: i32, gmf: ^Glyph_Metrics_Float) -> Bool #link_name "wglUseFontOutlines"        ---;
 }

core/sys/windows.odin

@@ -20,7 +20,7 @@ Hmonitor  :: Handle;
 Wparam    :: uint;
 Lparam    :: int;
 Lresult   :: int;
-WndProc   :: proc(Hwnd, u32, Wparam, Lparam) -> Lresult #cc_c;
+Wnd_Proc  :: proc(Hwnd, u32, Wparam, Lparam) -> Lresult #cc_c;
 
 Bool :: i32;
 FALSE: Bool : 0;
@@ -30,9 +30,9 @@ Point :: struct #ordered {
 	x, y: i32;
 }
 
-WndClassExA :: struct #ordered {
+Wnd_Class_Ex_A :: struct #ordered {
 	size, style:           u32;
-	wnd_proc:              WndProc;
+	wnd_proc:              Wnd_Proc;
 	cls_extra, wnd_extra:  i32;
 	instance:              Hinstance;
 	icon:                  Hicon;
@@ -68,7 +68,7 @@ Systemtime :: struct #ordered {
 	hour, minute, second, millisecond: u16;
 }
 
-ByHandleFileInformation :: struct #ordered {
+By_Handle_File_Information :: struct #ordered {
 	file_attributes:      u32;
 	creation_time,
 	last_access_time,
@@ -81,7 +81,7 @@ ByHandleFileInformation :: struct #ordered {
 	file_index_low:       u32;
 }
 
-FileAttributeData :: struct #ordered {
+File_Attribute_Data :: struct #ordered {
 	file_attributes:  u32;
 	creation_time,
 	last_access_time,
@@ -90,7 +90,7 @@ FileAttributeData :: struct #ordered {
 	file_size_low:    u32;
 }
 
-FindData :: struct #ordered {
+Find_Data :: struct #ordered{
     file_attributes:     u32;
     creation_time:       Filetime;
     last_access_time:    Filetime;
@@ -103,7 +103,7 @@ FindData :: struct #ordered {
     alternate_file_name: [14]u8;
 }
 
-SecurityAttributes :: struct #ordered {
+Security_Attributes :: struct #ordered {
 	length:              u32;
 	security_descriptor: rawptr;
 	inherit_handle:      Bool;
@@ -111,7 +111,7 @@ SecurityAttributes :: struct #ordered {
 
 
 
-PixelFormatDescriptor :: struct #ordered {
+Pixel_Format_Descriptor :: struct #ordered {
 	size,
 	version,
 	flags: u32;
@@ -142,8 +142,8 @@ PixelFormatDescriptor :: struct #ordered {
 	damage_mask: u32;
 }
 
-CriticalSection :: struct #ordered {
-	debug_info:      ^CriticalSectionDebug;
+Critical_Section :: struct #ordered {
+	debug_info:      ^Critical_Section_Debug;
 
 	lock_count:      i32;
 	recursion_count: i32;
@@ -152,11 +152,11 @@ CriticalSection :: struct #ordered {
 	spin_count:      ^u32;
 }
 
-CriticalSectionDebug :: struct #ordered {
+Critical_Section_Debug :: struct #ordered {
 	typ:                           u16;
 	creator_back_trace_index:      u16;
-	critical_section:              ^CriticalSection;
-	process_locks_list:            ^ListEntry;
+	critical_section:              ^Critical_Section;
+	process_locks_list:            ^List_Entry;
 	entry_count:                   u32;
 	contention_count:              u32;
 	flags:                         u32;
@@ -164,7 +164,7 @@ CriticalSectionDebug :: struct #ordered {
 	spare_word:                    u16;
 }
 
-ListEntry :: struct #ordered {flink, blink: ^ListEntry};
+List_Entry :: struct #ordered {flink, blink: ^List_Entry};
 
 
 
@@ -328,15 +328,15 @@ foreign kernel32 {
 	get_file_size_ex               :: proc(file_handle: Handle, file_size: ^i64) -> Bool                                       #cc_std #link_name "GetFileSizeEx"                ---;
 	get_file_attributes_a          :: proc(filename: ^u8) -> u32                                                               #cc_std #link_name "GetFileAttributesA"           ---;
 	get_file_attributes_ex_a       :: proc(filename: ^u8, info_level_id: GET_FILEEX_INFO_LEVELS, file_info: rawptr) -> Bool    #cc_std #link_name "GetFileAttributesExA"         ---;
-	get_file_information_by_handle :: proc(file_handle: Handle, file_info: ^ByHandleFileInformation) -> Bool                   #cc_std #link_name "GetFileInformationByHandle"   ---;
+	get_file_information_by_handle :: proc(file_handle: Handle, file_info: ^By_Handle_File_Information) -> Bool                #cc_std #link_name "GetFileInformationByHandle"   ---;
 
 	get_file_type    :: proc(file_handle: Handle) -> u32                                                                       #cc_std #link_name "GetFileType"                  ---;
 	set_file_pointer :: proc(file_handle: Handle, distance_to_move: i32, distance_to_move_high: ^i32, move_method: u32) -> u32 #cc_std #link_name "SetFilePointer"               ---;
 
 	set_handle_information :: proc(obj: Handle, mask, flags: u32) -> Bool                                                      #cc_std #link_name "SetHandleInformation"         ---;
 
-	find_first_file_a :: proc(file_name : ^u8, data : ^FindData) -> Handle                                                     #cc_std #link_name "FindFirstFileA"               ---;
-	find_next_file_a  :: proc(file : Handle, data : ^FindData) -> Bool                                                         #cc_std #link_name "FindNextFileA"                ---;
+	find_first_file_a :: proc(file_name : ^u8, data : ^Find_Data) -> Handle                                                    #cc_std #link_name "FindFirstFileA"               ---;
+	find_next_file_a  :: proc(file : Handle, data : ^Find_Data) -> Bool                                                        #cc_std #link_name "FindNextFileA"                ---;
 	find_close        :: proc(file : Handle) -> Bool                                                                           #cc_std #link_name "FindClose"                    ---;
 
 
@@ -346,7 +346,7 @@ foreign kernel32 {
 	get_process_heap :: proc() -> Handle                                                                                       #cc_std #link_name "GetProcessHeap"               ---;
 
 
-	create_semaphore_a     :: proc(attributes: ^SecurityAttributes, initial_count, maximum_count: i32, name: ^u8) -> Handle    #cc_std #link_name "CreateSemaphoreA"             ---;
+	create_semaphore_a     :: proc(attributes: ^Security_Attributes, initial_count, maximum_count: i32, name: ^u8) -> Handle   #cc_std #link_name "CreateSemaphoreA"             ---;
 	release_semaphore      :: proc(semaphore: Handle, release_count: i32, previous_count: ^i32) -> Bool                        #cc_std #link_name "ReleaseSemaphore"             ---;
 	wait_for_single_object :: proc(handle: Handle, milliseconds: u32) -> u32                                                   #cc_std #link_name "WaitForSingleObject"          ---;
 
@@ -368,22 +368,22 @@ foreign kernel32 {
 	write_barrier      :: proc()                                                                                               #cc_std #link_name "WriteBarrier"                 ---;
 	read_barrier       :: proc()                                                                                               #cc_std #link_name "ReadBarrier"                  ---;
 
-	create_thread        :: proc(thread_attributes: ^SecurityAttributes, stack_size: int, start_routine: rawptr,
+	create_thread        :: proc(thread_attributes: ^Security_Attributes, stack_size: int, start_routine: rawptr,
 	                             parameter: rawptr, creation_flags: u32, thread_id: ^u32) -> Handle                            #cc_std #link_name "CreateThread"                 ---;
 	resume_thread        :: proc(thread: Handle) -> u32                                                                        #cc_std #link_name "ResumeThread"                 ---;
 	get_thread_priority  :: proc(thread: Handle) -> i32                                                                        #cc_std #link_name "GetThreadPriority"            ---;
 	set_thread_priority  :: proc(thread: Handle, priority: i32) -> Bool                                                        #cc_std #link_name "SetThreadPriority"            ---;
 	get_exit_code_thread :: proc(thread: Handle, exit_code: ^u32) -> Bool                                                      #cc_std #link_name "GetExitCodeThread"            ---;
 
-	initialize_critical_section                :: proc(critical_section: ^CriticalSection)                                     #cc_std #link_name "InitializeCriticalSection"             ---;
-	initialize_critical_section_and_spin_count :: proc(critical_section: ^CriticalSection, spin_count: u32)                    #cc_std #link_name "InitializeCriticalSectionAndSpinCount" ---;
-	delete_critical_section                    :: proc(critical_section: ^CriticalSection)                                     #cc_std #link_name "DeleteCriticalSection"                 ---;
-	set_critical_section_spin_count            :: proc(critical_section: ^CriticalSection, spin_count: u32) -> u32             #cc_std #link_name "SetCriticalSectionSpinCount"           ---;
-	try_enter_critical_section                 :: proc(critical_section: ^CriticalSection) -> Bool                             #cc_std #link_name "TryEnterCriticalSection"               ---;
-	enter_critical_section                     :: proc(critical_section: ^CriticalSection)                                     #cc_std #link_name "EnterCriticalSection"                  ---;
-	leave_critical_section                     :: proc(critical_section: ^CriticalSection)                                     #cc_std #link_name "LeaveCriticalSection"                  ---;
+	initialize_critical_section                :: proc(critical_section: ^Critical_Section)                                    #cc_std #link_name "InitializeCriticalSection"             ---;
+	initialize_critical_section_and_spin_count :: proc(critical_section: ^Critical_Section, spin_count: u32)                   #cc_std #link_name "InitializeCriticalSectionAndSpinCount" ---;
+	delete_critical_section                    :: proc(critical_section: ^Critical_Section)                                    #cc_std #link_name "DeleteCriticalSection"                 ---;
+	set_critical_section_spin_count            :: proc(critical_section: ^Critical_Section, spin_count: u32) -> u32            #cc_std #link_name "SetCriticalSectionSpinCount"           ---;
+	try_enter_critical_section                 :: proc(critical_section: ^Critical_Section) -> Bool                            #cc_std #link_name "TryEnterCriticalSection"               ---;
+	enter_critical_section                     :: proc(critical_section: ^Critical_Section)                                    #cc_std #link_name "EnterCriticalSection"                  ---;
+	leave_critical_section                     :: proc(critical_section: ^Critical_Section)                                    #cc_std #link_name "LeaveCriticalSection"                  ---;
 
-	create_event_a :: proc(event_attributes: ^SecurityAttributes, manual_reset, initial_state: Bool, name: ^u8) -> Handle      #cc_std #link_name "CreateEventA"                 ---;
+	create_event_a :: proc(event_attributes: ^Security_Attributes, manual_reset, initial_state: Bool, name: ^u8) -> Handle     #cc_std #link_name "CreateEventA"                 ---;
 
 	load_library_a   :: proc(c_str: ^u8) -> Hmodule                                                                            #cc_std #link_name "LoadLibraryA"                 ---;
 	free_library     :: proc(h: Hmodule)                                                                                       #cc_std #link_name "FreeLibrary"                  ---;
@@ -398,7 +398,7 @@ foreign user32 {
 	screen_to_client    :: proc(h: Hwnd, p: ^Point) -> i32                                                      #cc_std #link_name "ScreenToClient"      ---;
 	post_quit_message   :: proc(exit_code: i32)                                                                 #cc_std #link_name "PostQuitMessage"     ---;
 	set_window_text_a   :: proc(hwnd: Hwnd, c_string: ^u8) -> Bool                                              #cc_std #link_name "SetWindowTextA"      ---;
-	register_class_ex_a :: proc(wc: ^WndClassExA) -> i16                                                        #cc_std #link_name "RegisterClassExA"    ---;
+	register_class_ex_a :: proc(wc: ^Wnd_Class_Ex_A) -> i16                                                     #cc_std #link_name "RegisterClassExA"    ---;
 
 	create_window_ex_a  :: proc(ex_style: u32,
 	                            class_name, title: ^u8,
@@ -424,15 +424,15 @@ foreign user32 {
 	get_active_window     :: proc() -> Hwnd                                                                     #cc_std #link_name "GetActiveWindow"     ---;
 
 	destroy_window        :: proc(wnd: Hwnd) -> Bool                                                            #cc_std #link_name "DestroyWindow"       ---;
-	describe_pixel_format :: proc(dc: Hdc, pixel_format: i32, bytes : u32, pfd: ^PixelFormatDescriptor) -> i32  #cc_std #link_name "DescribePixelFormat" ---;
+	describe_pixel_format :: proc(dc: Hdc, pixel_format: i32, bytes: u32, pfd: ^Pixel_Format_Descriptor) -> i32 #cc_std #link_name "DescribePixelFormat" ---;
 
-	get_monitor_info_a    :: proc(monitor: Hmonitor, mi: ^MonitorInfo) -> Bool                                  #cc_std #link_name "GetMonitorInfoA"     ---;
+	get_monitor_info_a    :: proc(monitor: Hmonitor, mi: ^Monitor_Info) -> Bool                                 #cc_std #link_name "GetMonitor_InfoA"     ---;
 	monitor_from_window   :: proc(wnd: Hwnd, flags : u32) -> Hmonitor                                           #cc_std #link_name "MonitorFromWindow"   ---;
 
 	set_window_pos        :: proc(wnd: Hwnd, wndInsertAfter: Hwnd, x, y, width, height: i32, flags: u32)        #cc_std #link_name "SetWindowPos"        ---;
 
-	get_window_placement  :: proc(wnd: Hwnd, wndpl: ^WindowPlacement) -> Bool                                   #cc_std #link_name "GetWindowPlacement"  ---;
-	set_window_placement  :: proc(wnd: Hwnd, wndpl: ^WindowPlacement) -> Bool                                   #cc_std #link_name "SetWindowPlacement"  ---;
+	get_window_placement  :: proc(wnd: Hwnd, wndpl: ^Window_Placement) -> Bool                                  #cc_std #link_name "GetWindowPlacement"  ---;
+	set_window_placement  :: proc(wnd: Hwnd, wndpl: ^Window_Placement) -> Bool                                  #cc_std #link_name "SetWindowPlacement"  ---;
 	get_window_rect       :: proc(wnd: Hwnd, rect: ^Rect) -> Bool                                               #cc_std #link_name "GetWindowRect"       ---;
 
 	get_window_long_ptr_a :: proc(wnd: Hwnd, index: i32) -> i64                                                 #cc_std #link_name "GetWindowLongPtrA"   ---;
@@ -452,18 +452,18 @@ foreign user32 {
 }
 
 foreign gdi32 {
-	get_stock_object :: proc(fn_object: i32) -> Hgdiobj                                           #cc_std #link_name "GetStockObject"    ---;
+	get_stock_object :: proc(fn_object: i32) -> Hgdiobj                                                         #cc_std #link_name "GetStockObject"    ---;
 
 	stretch_dibits   :: proc(hdc: Hdc,
 	                        x_dst, y_dst, width_dst, height_dst: i32,
 	                        x_src, y_src, width_src, header_src: i32,
 	                        bits: rawptr, bits_info: ^BitmapInfo,
 	                        usage: u32,
-	                        rop: u32) -> i32                                                      #cc_std #link_name "StretchDIBits"     ---;
+	                        rop: u32) -> i32                                                                    #cc_std #link_name "StretchDIBits"     ---;
 
-	set_pixel_format    :: proc(hdc: Hdc, pixel_format: i32, pfd: ^PixelFormatDescriptor) -> Bool #cc_std #link_name "SetPixelFormat"    ---;
-	choose_pixel_format :: proc(hdc: Hdc, pfd: ^PixelFormatDescriptor) -> i32                     #cc_std #link_name "ChoosePixelFormat" ---;
-	swap_buffers        :: proc(hdc: Hdc) -> Bool                                                 #cc_std #link_name "SwapBuffers"       ---;
+	set_pixel_format    :: proc(hdc: Hdc, pixel_format: i32, pfd: ^Pixel_Format_Descriptor) -> Bool             #cc_std #link_name "SetPixelFormat"    ---;
+	choose_pixel_format :: proc(hdc: Hdc, pfd: ^Pixel_Format_Descriptor) -> i32                                 #cc_std #link_name "ChoosePixelFormat" ---;
+	swap_buffers        :: proc(hdc: Hdc) -> Bool                                                               #cc_std #link_name "SwapBuffers"       ---;
 
 }
 
@@ -488,7 +488,7 @@ HIWORD :: proc(lParam: Lparam) -> u16 { return u16((u32(lParam) >> 16) & 0xffff)
 LOWORD :: proc(wParam: Wparam) -> u16 { return u16(wParam); }
 LOWORD :: proc(lParam: Lparam) -> u16 { return u16(lParam); }
 
-is_key_down :: proc(key: KeyCode) -> bool #inline { return get_async_key_state(i32(key)) < 0; }
+is_key_down :: proc(key: Key_Code) -> bool #inline { return get_async_key_state(i32(key)) < 0; }
 
 
 
@@ -545,14 +545,14 @@ FILE_TYPE_CHAR :: 0x0002;
 FILE_TYPE_PIPE :: 0x0003;
 
 
-MonitorInfo :: struct #ordered {
+Monitor_Info :: struct #ordered {
 	size:      u32;
 	monitor:   Rect;
 	work:      Rect;
 	flags:     u32;
 }
 
-WindowPlacement :: struct #ordered {
+Window_Placement :: struct #ordered {
 	length:     u32;
 	flags:      u32;
 	show_cmd:   u32;
@@ -561,7 +561,7 @@ WindowPlacement :: struct #ordered {
 	normal_pos: Rect;
 }
 
-BitmapInfoHeader :: struct #ordered {
+Bitmap_Info_Header :: struct #ordered {
 	size:              u32;
 	width, height:     i32;
 	planes, bit_count: i16;
@@ -573,15 +573,15 @@ BitmapInfoHeader :: struct #ordered {
 	clr_important:     u32;
 }
 BitmapInfo :: struct #ordered {
-	using header: BitmapInfoHeader;
-	colors:       [1]RgbQuad;
+	using header: Bitmap_Info_Header;
+	colors:       [1]Rgb_Quad;
 }
 
 
-RgbQuad :: struct #ordered { blue, green, red, reserved: u8 }
+Rgb_Quad :: struct #ordered {blue, green, red, reserved: u8}
 
 
-KeyCode :: enum i32 {
+Key_Code :: enum i32 {
 	Lbutton    = 0x01,
 	Rbutton    = 0x02,
 	Cancel     = 0x03,

core/thread.odin

@@ -3,7 +3,7 @@ _ :: compile_assert(ODIN_OS == "windows");
 import win32 "sys/windows.odin";
 
 Thread :: struct {
-	using specific:   OsSpecific;
+	using specific:   Os_Specific;
 	procedure:        Proc;
 	data:             any;
 	user_index:       int;
@@ -12,7 +12,7 @@ Thread :: struct {
 	use_init_context: bool;
 
 	Proc :: #type proc(^Thread) -> int;
-	OsSpecific :: struct {
+	Os_Specific :: struct {
 		win32_thread:    win32.Handle;
 		win32_thread_id: u32;
 	}

core/types.odin

@@ -1,103 +1,103 @@
-is_signed :: proc(info: ^TypeInfo) -> bool {
+is_signed :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
 	match i in type_info_base(info).variant {
-	case TypeInfo.Integer: return i.signed;
-	case TypeInfo.Float:   return true;
+	case Type_Info.Integer: return i.signed;
+	case Type_Info.Float:   return true;
 	}
 	return false;
 }
-is_integer :: proc(info: ^TypeInfo) -> bool {
+is_integer :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.Integer);
+	_, ok := type_info_base(info).variant.(Type_Info.Integer);
 	return ok;
 }
-is_rune :: proc(info: ^TypeInfo) -> bool {
+is_rune :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.Rune);
+	_, ok := type_info_base(info).variant.(Type_Info.Rune);
 	return ok;
 }
-is_float :: proc(info: ^TypeInfo) -> bool {
+is_float :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.Float);
+	_, ok := type_info_base(info).variant.(Type_Info.Float);
 	return ok;
 }
-is_complex :: proc(info: ^TypeInfo) -> bool {
+is_complex :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.Complex);
+	_, ok := type_info_base(info).variant.(Type_Info.Complex);
 	return ok;
 }
-is_any :: proc(info: ^TypeInfo) -> bool {
+is_any :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.Any);
+	_, ok := type_info_base(info).variant.(Type_Info.Any);
 	return ok;
 }
-is_string :: proc(info: ^TypeInfo) -> bool {
+is_string :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.String);
+	_, ok := type_info_base(info).variant.(Type_Info.String);
 	return ok;
 }
-is_boolean :: proc(info: ^TypeInfo) -> bool {
+is_boolean :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.Boolean);
+	_, ok := type_info_base(info).variant.(Type_Info.Boolean);
 	return ok;
 }
-is_pointer :: proc(info: ^TypeInfo) -> bool {
+is_pointer :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.Pointer);
+	_, ok := type_info_base(info).variant.(Type_Info.Pointer);
 	return ok;
 }
-is_procedure :: proc(info: ^TypeInfo) -> bool {
+is_procedure :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.Procedure);
+	_, ok := type_info_base(info).variant.(Type_Info.Procedure);
 	return ok;
 }
-is_array :: proc(info: ^TypeInfo) -> bool {
+is_array :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.Array);
+	_, ok := type_info_base(info).variant.(Type_Info.Array);
 	return ok;
 }
-is_dynamic_array :: proc(info: ^TypeInfo) -> bool {
+is_dynamic_array :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.DynamicArray);
+	_, ok := type_info_base(info).variant.(Type_Info.Dynamic_Array);
 	return ok;
 }
-is_dynamic_map :: proc(info: ^TypeInfo) -> bool {
+is_dynamic_map :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.Map);
+	_, ok := type_info_base(info).variant.(Type_Info.Map);
 	return ok;
 }
-is_slice :: proc(info: ^TypeInfo) -> bool {
+is_slice :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.Slice);
+	_, ok := type_info_base(info).variant.(Type_Info.Slice);
 	return ok;
 }
-is_vector :: proc(info: ^TypeInfo) -> bool {
+is_vector :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.Vector);
+	_, ok := type_info_base(info).variant.(Type_Info.Vector);
 	return ok;
 }
-is_tuple :: proc(info: ^TypeInfo) -> bool {
+is_tuple :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.Tuple);
+	_, ok := type_info_base(info).variant.(Type_Info.Tuple);
 	return ok;
 }
-is_struct :: proc(info: ^TypeInfo) -> bool {
+is_struct :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	s, ok := type_info_base(info).variant.(TypeInfo.Struct);
+	s, ok := type_info_base(info).variant.(Type_Info.Struct);
 	return ok && !s.is_raw_union;
 }
-is_raw_union :: proc(info: ^TypeInfo) -> bool {
+is_raw_union :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	s, ok := type_info_base(info).variant.(TypeInfo.Struct);
+	s, ok := type_info_base(info).variant.(Type_Info.Struct);
 	return ok && s.is_raw_union;
 }
-is_union :: proc(info: ^TypeInfo) -> bool {
+is_union :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.Union);
+	_, ok := type_info_base(info).variant.(Type_Info.Union);
 	return ok;
 }
-is_enum :: proc(info: ^TypeInfo) -> bool {
+is_enum :: proc(info: ^Type_Info) -> bool {
 	if info == nil do return false;
-	_, ok := type_info_base(info).variant.(TypeInfo.Enum);
+	_, ok := type_info_base(info).variant.(Type_Info.Enum);
 	return ok;
 }

core/utf8.odin

@@ -28,9 +28,9 @@ RUNE3_MAX :: 1<<16 - 1;
 LOCB :: 0b1000_0000;
 HICB :: 0b1011_1111;
 
-AcceptRange :: struct { lo, hi: u8 }
+Accept_Range :: struct {lo, hi: u8};
 
-accept_ranges := [5]AcceptRange{
+accept_ranges := [5]Accept_Range{
 	{0x80, 0xbf},
 	{0xa0, 0xbf},
 	{0x80, 0x9f},

src/build_settings.cpp

@@ -283,7 +283,7 @@ String get_fullpath_core(gbAllocator a, String path) {
 }
 
 
-String const ODIN_VERSION = str_lit("0.6.1a");
+String const ODIN_VERSION = str_lit("0.6.2");
 
 void init_build_context(void) {
 	BuildContext *bc = &build_context;

src/check_expr.cpp

@@ -8136,7 +8136,9 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 				o->type = t->Pointer.elem;
  			} else {
  				gbString str = expr_to_string(o->expr);
- 				error(o->expr, "Cannot dereference `%s`", str);
+ 				gbString typ = type_to_string(o->type);
+ 				error(o->expr, "Cannot dereference `%s` of type `%s`", str, typ);
+ 				gb_string_free(typ);
  				gb_string_free(str);
  				o->mode = Addressing_Invalid;
  				o->expr = node;

src/checker.cpp

@@ -1341,14 +1341,14 @@ void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type);
 
 void init_preload(Checker *c) {
 	if (t_type_info == nullptr) {
-		Entity *type_info_entity = find_core_entity(c, str_lit("TypeInfo"));
+		Entity *type_info_entity = find_core_entity(c, str_lit("Type_Info"));
 
 		t_type_info = type_info_entity->type;
 		t_type_info_ptr = make_type_pointer(c->allocator, t_type_info);
 		GB_ASSERT(is_type_struct(type_info_entity->type));
 		TypeStruct *tis = &base_type(type_info_entity->type)->Struct;
 
-		Entity *type_info_enum_value = find_sub_core_entity(tis, str_lit("EnumValue"));
+		Entity *type_info_enum_value = find_sub_core_entity(tis, str_lit("Enum_Value"));
 
 		t_type_info_enum_value = type_info_enum_value->type;
 		t_type_info_enum_value_ptr = make_type_pointer(c->allocator, t_type_info_enum_value);
@@ -1361,7 +1361,7 @@ void init_preload(Checker *c) {
 		TypeUnion *tiv = &tiv_type->Union;
 
 		if (tiv->variants.count != 20) {
-			compiler_error("Invalid `TypeInfo` layout");
+			compiler_error("Invalid `Type_Info` layout");
 		}
 		t_type_info_named         = tiv->variants[ 0];
 		t_type_info_integer       = tiv->variants[ 1];
@@ -1420,18 +1420,18 @@ void init_preload(Checker *c) {
 	}
 
 	if (t_source_code_location == nullptr) {
-		Entity *e = find_core_entity(c, str_lit("SourceCodeLocation"));
+		Entity *e = find_core_entity(c, str_lit("Source_Code_Location"));
 		t_source_code_location = e->type;
 		t_source_code_location_ptr = make_type_pointer(c->allocator, t_allocator);
 	}
 
 	if (t_map_key == nullptr) {
-		Entity *e = find_core_entity(c, str_lit("__MapKey"));
+		Entity *e = find_core_entity(c, str_lit("__Map_Key"));
 		t_map_key = e->type;
 	}
 
 	if (t_map_header == nullptr) {
-		Entity *e = find_core_entity(c, str_lit("__MapHeader"));
+		Entity *e = find_core_entity(c, str_lit("__Map_Header"));
 		t_map_header = e->type;
 	}
 

src/ir_print.cpp

@@ -293,7 +293,7 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t) {
 
 	case Type_Union: {
 		if (t->Union.variants.count == 0) {
-			ir_write_string(f, "%%..opaque");
+			ir_print_encoded_local(f, str_lit("..opaque"));
 		} else {
 			// NOTE(bill): The zero size array is used to fix the alignment used in a structure as
 			// LLVM takes the first element's alignment as the entire alignment (like C)
@@ -1723,10 +1723,41 @@ void ir_print_proc(irFileBuffer *f, irModule *m, irProcedure *proc) {
 
 void ir_print_type_name(irFileBuffer *f, irModule *m, irValue *v) {
 	GB_ASSERT(v->kind == irValue_TypeName);
-	Type *bt = base_type(ir_type(v));
+	Type *t = base_type(v->TypeName.type);
 	ir_print_encoded_local(f, v->TypeName.name);
 	ir_write_string(f, str_lit(" = type "));
-	ir_print_type(f, m, base_type(v->TypeName.type));
+
+
+	switch (t->kind) {
+	case Type_Union:
+		if (t->Union.variants.count == 0) {
+			ir_write_string(f, str_lit("{}"));
+		} else {
+			ir_print_type(f, m, t);
+		}
+		break;
+	case Type_Struct:
+		if (t->Struct.fields.count == 0) {
+			if (t->Struct.is_packed) {
+				ir_write_byte(f, '<');
+			}
+			ir_write_byte(f, '{');
+			if (t->Struct.custom_align > 0) {
+				ir_fprintf(f, "[0 x <%lld x i8>]", t->Struct.custom_align);
+			}
+			ir_write_byte(f, '}');
+			if (t->Struct.is_packed) {
+				ir_write_byte(f, '>');
+			}
+		} else {
+			ir_print_type(f, m, t);
+		}
+		break;
+	default:
+		ir_print_type(f, m, t);
+		break;
+	}
+
 	ir_write_byte(f, '\n');
 }
 

src/main.cpp

@@ -1,6 +1,8 @@
 #define USE_CUSTOM_BACKEND 0
-#define USE_THREADED_PARSER 1
 // #define NO_ARRAY_BOUNDS_CHECK
+#if !defined(USE_THREADED_PARSER)
+#define USE_THREADED_PARSER 0
+#endif
 
 #include "common.cpp"
 #include "timings.cpp"