v0.6.2; Use Ada_Case for typesv0.6.2

1 files changed, 87 insertions, 87 deletions

diff --git a/core/_preload.odin b/core/_preload.odin
index c58c73bf1..eab75ce4f 100644
--- a/core/_preload.odin
+++ b/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 {