mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-01-03 11:42:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change naming convention from Ada_Like to RustLike

Browse Source 
Naming Conventions:
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
Procedures:         snake_case
Local Variables:    snake_case
Constant Variables: SCREAMING_SNAKE_CASE
This commit is contained in:
Ginger Bill
2017-05-28 14:47:11 +01:00
parent b41f09b730
commit 80c034ec7c
13 changed files with 374 additions and 362 deletions
Download Patch File Download Diff File Expand all files Collapse all files

169
core/_preload.odin
View File

@@ -5,6 +5,17 @@
#import "utf8.odin";
#import "raw.odin";
// Naming Conventions:
// 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
// Procedures: snake_case
// Local Variables: snake_case
// Constant Variables: SCREAMING_SNAKE_CASE
// IMPORTANT NOTE(bill): `type_info` & `type_info_val` cannot be used within a
// #shared_global_scope due to the internals of the compiler.
// This could change at a later date if the all these data structures are
@@ -13,20 +24,20 @@
// IMPORTANT NOTE(bill): Do not change the order of any of this data
// The compiler relies upon this _exact_ order
Type_Info_Enum_Value :: raw_union {
TypeInfoEnumValue :: raw_union {
f: f64,
i: i64,
}
// NOTE(bill): This must match the compiler's
Calling_Convention :: enum {
CallingConvention :: enum {
ODIN = 0,
C = 1,
STD = 2,
FAST = 3,
}
Type_Info_Record :: struct #ordered {
types: []^Type_Info,
TypeInfoRecord :: struct #ordered {
types: []^TypeInfo,
names: []string,
offsets: []int, // offsets may not be used in tuples
usings: []bool, // usings may not be used in tuples
@@ -35,11 +46,11 @@ Type_Info_Record :: struct #ordered {
custom_align: bool,
}
Type_Info :: union {
TypeInfo :: union {
size: int,
align: int,
Named{name: string, base: ^Type_Info},
Named{name: string, base: ^TypeInfo},
Integer{signed: bool},
Float{},
Complex{},
@@ -48,44 +59,44 @@ Type_Info :: union {
Boolean{},
Any{},
Pointer{
elem: ^Type_Info, // nil -> rawptr
elem: ^TypeInfo, // nil -> rawptr
},
Atomic{elem: ^Type_Info},
Atomic{elem: ^TypeInfo},
Procedure{
params: ^Type_Info, // Type_Info.Tuple
results: ^Type_Info, // Type_Info.Tuple
params: ^TypeInfo, // TypeInfo.Tuple
results: ^TypeInfo, // TypeInfo.Tuple
variadic: bool,
convention: Calling_Convention,
convention: CallingConvention,
},
Array{
elem: ^Type_Info,
elem: ^TypeInfo,
elem_size: int,
count: int,
},
Dynamic_Array{elem: ^Type_Info, elem_size: int},
Slice {elem: ^Type_Info, elem_size: int},
Vector {elem: ^Type_Info, elem_size, count: int},
Tuple {using record: Type_Info_Record}, // Only really used for procedures
Struct {using record: Type_Info_Record},
Raw_Union {using record: Type_Info_Record},
DynamicArray{elem: ^TypeInfo, elem_size: int},
Slice {elem: ^TypeInfo, elem_size: int},
Vector {elem: ^TypeInfo, elem_size, count: int},
Tuple {using record: TypeInfoRecord}, // Only really used for procedures
Struct {using record: TypeInfoRecord},
RawUnion {using record: TypeInfoRecord},
Union{
common_fields: struct {
types: []^Type_Info,
types: []^TypeInfo,
names: []string,
offsets: []int, // offsets may not be used in tuples
},
variant_names: []string,
variant_types: []^Type_Info,
variant_types: []^TypeInfo,
},
Enum{
base: ^Type_Info,
base: ^TypeInfo,
names: []string,
values: []Type_Info_Enum_Value,
values: []TypeInfoEnumValue,
},
Map{
key: ^Type_Info,
value: ^Type_Info,
generated_struct: ^Type_Info,
key: ^TypeInfo,
value: ^TypeInfo,
generated_struct: ^TypeInfo,
count: int, // == 0 if dynamic
},
}
@@ -93,33 +104,33 @@ Type_Info :: union {
// NOTE(bill): only the ones that are needed (not all types)
// This will be set by the compiler
__type_table: []Type_Info;
__type_table: []TypeInfo;
__argv__: ^^byte;
__argc__: i32;
type_info_base :: proc(info: ^Type_Info) -> ^Type_Info {
type_info_base :: proc(info: ^TypeInfo) -> ^TypeInfo {
if info == nil {
return nil;
}
base := info;
match i in base {
case Type_Info.Named:
case TypeInfo.Named:
base = i.base;
}
return base;
}
type_info_base_without_enum :: proc(info: ^Type_Info) -> ^Type_Info {
type_info_base_without_enum :: proc(info: ^TypeInfo) -> ^TypeInfo {
if info == nil {
return nil;
}
base := info;
match i in base {
case Type_Info.Named:
case TypeInfo.Named:
base = i.base;
case Type_Info.Enum:
case TypeInfo.Enum:
base = i.base;
}
return base;
@@ -135,17 +146,17 @@ read_cycle_counter :: proc() -> u64 #foreign __llvm_core "llvm.readcyclecounter"
// IMPORTANT NOTE(bill): Must be in this order (as the compiler relies upon it)
Allocator_Mode :: enum u8 {
ALLOC,
FREE,
FREE_ALL,
RESIZE,
AllocatorMode :: enum u8 {
Alloc,
Free,
FreeAll,
Resize,
}
Allocator_Proc :: #type proc(allocator_data: rawptr, mode: Allocator_Mode,
AllocatorProc :: #type proc(allocator_data: rawptr, mode: AllocatorMode,
size, alignment: int,
old_memory: rawptr, old_size: int, flags: u64) -> rawptr;
Allocator :: struct #ordered {
procedure: Allocator_Proc,
procedure: AllocatorProc,
data: rawptr,
}
@@ -181,7 +192,7 @@ alloc :: proc(size: int) -> rawptr #inline { return alloc_align(size, DEFAULT_AL
alloc_align :: proc(size, alignment: int) -> rawptr #inline {
__check_context();
a := context.allocator;
return a.procedure(a.data, Allocator_Mode.ALLOC, size, alignment, nil, 0, 0);
return a.procedure(a.data, AllocatorMode.Alloc, size, alignment, nil, 0, 0);
}
free_ptr_with_allocator :: proc(a: Allocator, ptr: rawptr) #inline {
@@ -191,7 +202,7 @@ free_ptr_with_allocator :: proc(a: Allocator, ptr: rawptr) #inline {
if a.procedure == nil {
return;
}
a.procedure(a.data, Allocator_Mode.FREE, 0, 0, ptr, 0, 0);
a.procedure(a.data, AllocatorMode.Free, 0, 0, ptr, 0, 0);
}
free_ptr :: proc(ptr: rawptr) #inline {
@@ -202,7 +213,7 @@ free_ptr :: proc(ptr: rawptr) #inline {
free_all :: proc() #inline {
__check_context();
a := context.allocator;
a.procedure(a.data, Allocator_Mode.FREE_ALL, 0, 0, nil, 0, 0);
a.procedure(a.data, AllocatorMode.FreeAll, 0, 0, nil, 0, 0);
}
@@ -210,7 +221,7 @@ resize :: proc(ptr: rawptr, old_size, new_size: int) -> rawptr #inline { r
resize_align :: proc(ptr: rawptr, old_size, new_size, alignment: int) -> rawptr #inline {
__check_context();
a := context.allocator;
return a.procedure(a.data, Allocator_Mode.RESIZE, new_size, alignment, ptr, old_size, 0);
return a.procedure(a.data, AllocatorMode.Resize, new_size, alignment, ptr, old_size, 0);
}
@@ -240,23 +251,23 @@ default_resize_align :: proc(old_memory: rawptr, old_size, new_size, alignment:
}
default_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
default_allocator_proc :: proc(allocator_data: rawptr, mode: AllocatorMode,
size, alignment: int,
old_memory: rawptr, old_size: int, flags: u64) -> rawptr {
using Allocator_Mode;
using AllocatorMode;
match mode {
case ALLOC:
case Alloc:
return os.heap_alloc(size);
case FREE:
case Free:
os.heap_free(old_memory);
return nil;
case FREE_ALL:
case FreeAll:
// NOTE(bill): Does nothing
case RESIZE:
case Resize:
ptr := os.heap_resize(old_memory, size);
assert(ptr != nil);
return ptr;
@@ -360,7 +371,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: ^Type_Info) {
__type_assertion_check :: proc(ok: bool, file: string, line, column: int, from, to: ^TypeInfo) {
if !ok {
fmt.fprintf(os.stderr, "%s(%d:%d) Invalid type_assertion from %T to %T\n",
file, line, column, from, to);
@@ -429,7 +440,7 @@ __abs_quaternion256 :: proc(x: quaternion256) -> f64 #inline {
__dynamic_array_make :: proc(array_: rawptr, elem_size, elem_align: int, len, cap: int) {
array := ^raw.Dynamic_Array(array_);
array := ^raw.DynamicArray(array_);
__check_context();
array.allocator = context.allocator;
assert(array.allocator.procedure != nil);
@@ -441,7 +452,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 := ^raw.Dynamic_Array(array_);
array := ^raw.DynamicArray(array_);
if cap <= array.cap {
return true;
@@ -457,7 +468,7 @@ __dynamic_array_reserve :: proc(array_: rawptr, elem_size, elem_align: int, cap:
new_size := cap * elem_size;
allocator := array.allocator;
new_data := allocator.procedure(allocator.data, Allocator_Mode.RESIZE, new_size, elem_align, array.data, old_size, 0);
new_data := allocator.procedure(allocator.data, AllocatorMode.Resize, new_size, elem_align, array.data, old_size, 0);
if new_data == nil {
return false;
}
@@ -468,7 +479,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 := ^raw.Dynamic_Array(array_);
array := ^raw.DynamicArray(array_);
ok := __dynamic_array_reserve(array_, elem_size, elem_align, len);
if ok {
@@ -480,7 +491,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 := ^raw.Dynamic_Array(array_);
array := ^raw.DynamicArray(array_);
if item_count <= 0 || items == nil {
return array.len;
@@ -504,7 +515,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 := ^raw.Dynamic_Array(array_);
array := ^raw.DynamicArray(array_);
ok := true;
if array.cap <= array.len+1 {
@@ -559,27 +570,27 @@ __default_hash_string :: proc(s: string) -> u64 {
__INITIAL_MAP_CAP :: 16;
__Map_Key :: struct #ordered {
__MapKey :: struct #ordered {
hash: u64,
str: string,
}
__Map_Find_Result :: struct #ordered {
__MapFindResult :: struct #ordered {
hash_index: int,
entry_prev: int,
entry_index: int,
}
__Map_Entry_Header :: struct #ordered {
key: __Map_Key,
__MapEntryHeader :: struct #ordered {
key: __MapKey,
next: int,
/*
value: Value_Type,
*/
}
__Map_Header :: struct #ordered {
m: ^raw.Dynamic_Map,
__MapHeader :: struct #ordered {
m: ^raw.DynamicMap,
is_key_string: bool,
entry_size: int,
entry_align: int,
@@ -587,18 +598,18 @@ __Map_Header :: struct #ordered {
value_size: int,
}
__dynamic_map_reserve :: proc(using header: __Map_Header, cap: int) {
__dynamic_map_reserve :: proc(using header: __MapHeader, 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: __Map_Header, new_count: int) {
new_header: __Map_Header = header;
nm: raw.Dynamic_Map;
__dynamic_map_rehash :: proc(using header: __MapHeader, new_count: int) {
new_header: __MapHeader = header;
nm: raw.DynamicMap;
new_header.m = &nm;
header_hashes := ^raw.Dynamic_Array(&header.m.hashes);
nm_hashes := ^raw.Dynamic_Array(&nm.hashes);
header_hashes := ^raw.DynamicArray(&header.m.hashes);
nm_hashes := ^raw.DynamicArray(&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);
@@ -637,7 +648,7 @@ __dynamic_map_rehash :: proc(using header: __Map_Header, new_count: int) {
header.m^ = nm;
}
__dynamic_map_get :: proc(h: __Map_Header, key: __Map_Key) -> rawptr {
__dynamic_map_get :: proc(h: __MapHeader, key: __MapKey) -> rawptr {
index := __dynamic_map_find(h, key).entry_index;
if index >= 0 {
data := ^byte(__dynamic_map_get_entry(h, index));
@@ -647,7 +658,7 @@ __dynamic_map_get :: proc(h: __Map_Header, key: __Map_Key) -> rawptr {
return nil;
}
__dynamic_map_set :: proc(using h: __Map_Header, key: __Map_Key, value: rawptr) {
__dynamic_map_set :: proc(using h: __MapHeader, key: __MapKey, value: rawptr) {
index: int;
assert(value != nil);
@@ -682,17 +693,17 @@ __dynamic_map_set :: proc(using h: __Map_Header, key: __Map_Key, value: rawptr)
}
__dynamic_map_grow :: proc(using h: __Map_Header) {
__dynamic_map_grow :: proc(using h: __MapHeader) {
new_count := max(2*m.entries.cap + 8, __INITIAL_MAP_CAP);
__dynamic_map_rehash(h, new_count);
}
__dynamic_map_full :: proc(using h: __Map_Header) -> bool {
__dynamic_map_full :: proc(using h: __MapHeader) -> bool {
return int(0.75 * f64(len(m.hashes))) <= m.entries.cap;
}
__dynamic_map_hash_equal :: proc(h: __Map_Header, a, b: __Map_Key) -> bool {
__dynamic_map_hash_equal :: proc(h: __MapHeader, a, b: __MapKey) -> bool {
if a.hash == b.hash {
if h.is_key_string {
return a.str == b.str;
@@ -702,8 +713,8 @@ __dynamic_map_hash_equal :: proc(h: __Map_Header, a, b: __Map_Key) -> bool {
return false;
}
__dynamic_map_find :: proc(using h: __Map_Header, key: __Map_Key) -> __Map_Find_Result {
fr := __Map_Find_Result{-1, -1, -1};
__dynamic_map_find :: proc(using h: __MapHeader, key: __MapKey) -> __MapFindResult {
fr := __MapFindResult{-1, -1, -1};
if len(m.hashes) > 0 {
fr.hash_index = int(key.hash % u64(len(m.hashes)));
fr.entry_index = m.hashes[fr.hash_index];
@@ -719,7 +730,7 @@ __dynamic_map_find :: proc(using h: __Map_Header, key: __Map_Key) -> __Map_Find_
return fr;
}
__dynamic_map_add_entry :: proc(using h: __Map_Header, key: __Map_Key) -> int {
__dynamic_map_add_entry :: proc(using h: __MapHeader, key: __MapKey) -> int {
prev := m.entries.len;
c := __dynamic_array_append_nothing(&m.entries, entry_size, entry_align);
if c != prev {
@@ -731,19 +742,19 @@ __dynamic_map_add_entry :: proc(using h: __Map_Header, key: __Map_Key) -> int {
}
__dynamic_map_delete :: proc(using h: __Map_Header, key: __Map_Key) {
__dynamic_map_delete :: proc(using h: __MapHeader, key: __MapKey) {
fr := __dynamic_map_find(h, key);
if fr.entry_index >= 0 {
__dynamic_map_erase(h, fr);
}
}
__dynamic_map_get_entry :: proc(using h: __Map_Header, index: int) -> ^__Map_Entry_Header {
__dynamic_map_get_entry :: proc(using h: __MapHeader, index: int) -> ^__MapEntryHeader {
data := ^byte(m.entries.data) + index*entry_size;
return ^__Map_Entry_Header(data);
return ^__MapEntryHeader(data);
}
__dynamic_map_erase :: proc(using h: __Map_Header, fr: __Map_Find_Result) {
__dynamic_map_erase :: proc(using h: __MapHeader, fr: __MapFindResult) {
if fr.entry_prev < 0 {
m.hashes[fr.hash_index] = __dynamic_map_get_entry(h, fr.entry_index).next;
} else {

117
core/fmt.odin
View File

@@ -8,57 +8,58 @@
_BUFFER_SIZE :: 1<<12;
String_Buffer :: struct {
// TODO(bill): Make this a union
StringBuffer :: struct {
is_dynamic: bool,
sa: []byte,
da: [dynamic]byte,
};
make_string_buffer_from_slice :: proc(b: []byte) -> String_Buffer {
return String_Buffer{
make_string_buffer_from_slice :: proc(b: []byte) -> StringBuffer {
return StringBuffer{
is_dynamic = false,
sa = b,
};
}
make_string_dynamic_buffer :: proc() -> String_Buffer {
return String_Buffer{
make_string_dynamic_buffer :: proc() -> StringBuffer {
return StringBuffer{
is_dynamic = true,
da = make([dynamic]byte),
};
}
string_buffer_data :: proc(buf: ^String_Buffer) -> []byte {
string_buffer_data :: proc(buf: ^StringBuffer) -> []byte {
return string_buffer_data(buf^);
}
string_buffer_data :: proc(buf: String_Buffer) -> []byte {
string_buffer_data :: proc(buf: StringBuffer) -> []byte {
if buf.is_dynamic {
return buf.da[..];
}
return buf.sa[..];
}
to_string :: proc(buf: String_Buffer) -> string {
to_string :: proc(buf: StringBuffer) -> string {
return string(string_buffer_data(buf));
}
write_string :: proc(buf: ^String_Buffer, s: string) {
write_string :: proc(buf: ^StringBuffer, s: string) {
write_bytes(buf, []byte(s));
}
write_bytes :: proc(buf: ^String_Buffer, b: []byte) {
write_bytes :: proc(buf: ^StringBuffer, b: []byte) {
if buf.is_dynamic {
append(buf.da, ..b);
} else {
append(buf.sa, ..b);
}
}
write_byte :: proc(buf: ^String_Buffer, b: byte) {
write_byte :: proc(buf: ^StringBuffer, b: byte) {
if buf.is_dynamic {
append(buf.da, b);
} else {
append(buf.sa, b);
}
}
write_rune :: proc(buf: ^String_Buffer, r: rune) {
write_rune :: proc(buf: ^StringBuffer, r: rune) {
if r < utf8.RUNE_SELF {
write_byte(buf, byte(r));
return;
@@ -68,7 +69,7 @@ write_rune :: proc(buf: ^String_Buffer, r: rune) {
write_bytes(buf, b[0..<n]);
}
Fmt_Info :: struct {
FmtInfo :: struct {
minus: bool,
plus: bool,
space: bool,
@@ -83,7 +84,7 @@ Fmt_Info :: struct {
reordered: bool,
good_arg_index: bool,
buf: ^String_Buffer,
buf: ^StringBuffer,
arg: any, // Temporary
}
@@ -169,19 +170,19 @@ bprintf :: proc(buf: []byte, fmt: string, args: ..any) -> string {
fprint_type :: proc(fd: os.Handle, info: ^Type_Info) {
fprint_type :: proc(fd: os.Handle, info: ^TypeInfo) {
data: [_BUFFER_SIZE]byte;
buf := make_string_buffer_from_slice(data[0..<0]);
write_type(&buf, info);
os.write(fd, string_buffer_data(buf));
}
write_type :: proc(buf: ^String_Buffer, ti: ^Type_Info) {
write_type :: proc(buf: ^StringBuffer, ti: ^TypeInfo) {
if ti == nil {
return;
}
using Type_Info;
using TypeInfo;
match info in ti {
case Named:
write_string(buf, info.name);
@@ -191,7 +192,7 @@ write_type :: proc(buf: ^String_Buffer, ti: ^Type_Info) {
case ti == type_info(uint): write_string(buf, "uint");
case:
write_string(buf, info.signed ? "i" : "u");
fi := Fmt_Info{buf = buf};
fi := FmtInfo{buf = buf};
fmt_int(&fi, u64(8*info.size), false, 64, 'd');
}
case Float:
@@ -259,11 +260,11 @@ write_type :: proc(buf: ^String_Buffer, ti: ^Type_Info) {
case Array:
write_string(buf, "[");
fi := Fmt_Info{buf = buf};
fi := FmtInfo{buf = buf};
fmt_int(&fi, u64(info.count), false, 64, 'd');
write_string(buf, "]");
write_type(buf, info.elem);
case Dynamic_Array:
case DynamicArray:
write_string(buf, "[dynamic]");
write_type(buf, info.elem);
case Slice:
@@ -271,7 +272,7 @@ write_type :: proc(buf: ^String_Buffer, ti: ^Type_Info) {
write_type(buf, info.elem);
case Vector:
write_string(buf, "[vector ");
fi := Fmt_Info{buf = buf};
fi := FmtInfo{buf = buf};
fmt_int(&fi, u64(info.count), false, 64, 'd');
write_string(buf, "]");
write_type(buf, info.elem);
@@ -288,7 +289,7 @@ write_type :: proc(buf: ^String_Buffer, ti: ^Type_Info) {
if info.ordered { write_string(buf, "#ordered "); }
if info.custom_align {
write_string(buf, "#align ");
fi := Fmt_Info{buf = buf};
fi := FmtInfo{buf = buf};
fmt_int(&fi, u64(info.align), false, 64, 'd');
write_byte(buf, ' ');
}
@@ -340,7 +341,7 @@ write_type :: proc(buf: ^String_Buffer, ti: ^Type_Info) {
}
write_string(buf, "}");
case Raw_Union:
case RawUnion:
write_string(buf, "raw_union {");
for name, i in info.names {
if i > 0 {
@@ -391,7 +392,7 @@ _parse_int :: proc(s: string, offset: int) -> (result: int, offset: int, ok: boo
return result, offset+i, i != 0;
}
_arg_number :: proc(fi: ^Fmt_Info, arg_index: int, format: string, offset, arg_count: int) -> (index, offset: int, ok: bool) {
_arg_number :: proc(fi: ^FmtInfo, 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 {
return 0, 1, false;
@@ -449,7 +450,7 @@ int_from_arg :: proc(args: []any, arg_index: int) -> (int, int, bool) {
}
fmt_bad_verb :: proc(using fi: ^Fmt_Info, verb: rune) {
fmt_bad_verb :: proc(using fi: ^FmtInfo, verb: rune) {
assert(verb != 'v');
write_string(buf, "%!");
write_rune(buf, verb);
@@ -464,7 +465,7 @@ fmt_bad_verb :: proc(using fi: ^Fmt_Info, verb: rune) {
write_byte(buf, ')');
}
fmt_bool :: proc(using fi: ^Fmt_Info, b: bool, verb: rune) {
fmt_bool :: proc(using fi: ^FmtInfo, b: bool, verb: rune) {
match verb {
case 't', 'v':
write_string(buf, b ? "true" : "false");
@@ -474,7 +475,7 @@ fmt_bool :: proc(using fi: ^Fmt_Info, b: bool, verb: rune) {
}
fmt_write_padding :: proc(fi: ^Fmt_Info, width: int) {
fmt_write_padding :: proc(fi: ^FmtInfo, width: int) {
if width <= 0 {
return;
}
@@ -522,7 +523,7 @@ is_integer_negative :: proc(u: u64, is_signed: bool, bit_size: int) -> (unsigned
return u, neg;
}
_write_int :: proc(fi: ^Fmt_Info, u: u64, base: int, is_signed: bool, bit_size: int, digits: string) {
_write_int :: proc(fi: ^FmtInfo, u: u64, base: int, is_signed: bool, bit_size: int, digits: string) {
_, neg := is_integer_negative(u, is_signed, bit_size);
BUF_SIZE :: 256;
@@ -575,11 +576,11 @@ _write_int :: proc(fi: ^Fmt_Info, u: u64, base: int, is_signed: bool, bit_size:
immutable __DIGITS_LOWER := "0123456789abcdefx";
immutable __DIGITS_UPPER := "0123456789ABCDEFX";
fmt_rune :: proc(fi: ^Fmt_Info, r: rune) {
fmt_rune :: proc(fi: ^FmtInfo, r: rune) {
write_rune(fi.buf, r);
}
fmt_int :: proc(fi: ^Fmt_Info, u: u64, is_signed: bool, bit_size: int, verb: rune) {
fmt_int :: proc(fi: ^FmtInfo, u: u64, is_signed: bool, bit_size: int, verb: rune) {
match verb {
case 'v': _write_int(fi, u, 10, is_signed, bit_size, __DIGITS_LOWER);
case 'b': _write_int(fi, u, 2, is_signed, bit_size, __DIGITS_LOWER);
@@ -603,7 +604,7 @@ fmt_int :: proc(fi: ^Fmt_Info, u: u64, is_signed: bool, bit_size: int, verb: run
}
}
_pad :: proc(fi: ^Fmt_Info, s: string) {
_pad :: proc(fi: ^FmtInfo, s: string) {
if !fi.width_set {
write_string(fi.buf, s);
return;
@@ -618,7 +619,7 @@ _pad :: proc(fi: ^Fmt_Info, s: string) {
}
}
fmt_float :: proc(fi: ^Fmt_Info, v: f64, bit_size: int, verb: rune) {
fmt_float :: proc(fi: ^FmtInfo, v: f64, bit_size: int, verb: rune) {
match verb {
// case 'e', 'E', 'f', 'F', 'g', 'G', 'v':
// case 'f', 'F', 'v':
@@ -664,7 +665,7 @@ fmt_float :: proc(fi: ^Fmt_Info, v: f64, bit_size: int, verb: rune) {
return;
}
}
fmt_string :: proc(fi: ^Fmt_Info, s: string, verb: rune) {
fmt_string :: proc(fi: ^FmtInfo, s: string, verb: rune) {
match verb {
case 's', 'v':
write_string(fi.buf, s);
@@ -686,7 +687,7 @@ fmt_string :: proc(fi: ^Fmt_Info, s: string, verb: rune) {
}
}
fmt_pointer :: proc(fi: ^Fmt_Info, p: rawptr, verb: rune) {
fmt_pointer :: proc(fi: ^FmtInfo, p: rawptr, verb: rune) {
match verb {
case 'p', 'v':
// Okay
@@ -701,13 +702,13 @@ fmt_pointer :: proc(fi: ^Fmt_Info, p: rawptr, verb: rune) {
_write_int(fi, u, 16, false, 8*size_of(rawptr), __DIGITS_UPPER);
}
fmt_enum :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
fmt_enum :: proc(fi: ^FmtInfo, v: any, verb: rune) {
if v.type_info == nil || v.data == nil {
write_string(fi.buf, "<nil>");
return;
}
using Type_Info;
using TypeInfo;
match e in v.type_info {
case:
fmt_bad_verb(fi, verb);
@@ -768,13 +769,13 @@ fmt_enum :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
}
fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) {
if v.data == nil || v.type_info == nil {
write_string(fi.buf, "<nil>");
return;
}
using Type_Info;
using TypeInfo;
match info in v.type_info {
case Named:
match b in info.base {
@@ -808,8 +809,8 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
case String: fmt_arg(fi, v, verb);
case Pointer:
if v.type_info == type_info(^Type_Info) {
write_type(fi.buf, (^^Type_Info)(v.data)^);
if v.type_info == type_info(^TypeInfo) {
write_type(fi.buf, (^^TypeInfo)(v.data)^);
} else {
fmt_pointer(fi, (^rawptr)(v.data)^, verb);
}
@@ -828,10 +829,10 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
fmt_arg(fi, any{rawptr(data), info.elem}, verb);
}
case Dynamic_Array:
case DynamicArray:
write_byte(fi.buf, '[');
defer write_byte(fi.buf, ']');
array := (^raw.Dynamic_Array)(v.data);
array := (^raw.DynamicArray)(v.data);
for i in 0..<array.len {
if i > 0 {
write_string(fi.buf, ", ");
@@ -873,9 +874,9 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
write_string(fi.buf, "map[");
defer write_byte(fi.buf, ']');
entries := &(^raw.Dynamic_Map(v.data).entries);
entries := &(^raw.DynamicMap(v.data).entries);
gs := type_info_base(info.generated_struct).(^Struct);
ed := type_info_base(gs.types[1]).(^Dynamic_Array);
ed := type_info_base(gs.types[1]).(^DynamicArray);
entry_type := ed.elem.(^Struct);
entry_size := ed.elem_size;
@@ -885,11 +886,11 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
}
data := ^byte(entries.data) + i*entry_size;
header := ^__Map_Entry_Header(data);
header := ^__MapEntryHeader(data);
if types.is_string(info.key) {
write_string(fi.buf, header.key.str);
} else {
fi := Fmt_Info{buf = fi.buf};
fi := FmtInfo{buf = fi.buf};
fmt_arg(&fi, any{rawptr(&header.key.hash), info.key}, 'v');
}
@@ -931,7 +932,7 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
fmt_value(fi, any{rawptr(data), cf.types[i]}, 'v');
}
case Raw_Union:
case RawUnion:
write_string(fi.buf, "(raw_union)");
case Enum:
@@ -944,7 +945,7 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
}
}
fmt_complex :: proc(fi: ^Fmt_Info, c: complex128, bits: int, verb: rune) {
fmt_complex :: proc(fi: ^FmtInfo, c: complex128, bits: int, verb: rune) {
match verb {
case 'f', 'F', 'v':
r := real(c);
@@ -962,7 +963,7 @@ fmt_complex :: proc(fi: ^Fmt_Info, c: complex128, bits: int, verb: rune) {
}
}
fmt_quaternion :: proc(fi: ^Fmt_Info, c: quaternion256, bits: int, verb: rune) {
fmt_quaternion :: proc(fi: ^FmtInfo, c: quaternion256, bits: int, verb: rune) {
match verb {
case 'f', 'F', 'v':
r := real(c);
@@ -989,7 +990,7 @@ fmt_quaternion :: proc(fi: ^Fmt_Info, c: quaternion256, bits: int, verb: rune) {
}
}
fmt_arg :: proc(fi: ^Fmt_Info, arg: any, verb: rune) {
fmt_arg :: proc(fi: ^FmtInfo, arg: any, verb: rune) {
if arg == nil {
write_string(fi.buf, "<nil>");
return;
@@ -999,7 +1000,7 @@ fmt_arg :: proc(fi: ^Fmt_Info, arg: any, verb: rune) {
if verb == 'T' {
ti := arg.type_info;
match a in arg {
case ^Type_Info: ti = a;
case ^TypeInfo: ti = a;
}
write_type(fi.buf, ti);
return;
@@ -1036,8 +1037,8 @@ fmt_arg :: proc(fi: ^Fmt_Info, arg: any, verb: rune) {
sbprint :: proc(buf: ^String_Buffer, args: ..any) -> string {
fi: Fmt_Info;
sbprint :: proc(buf: ^StringBuffer, args: ..any) -> string {
fi: FmtInfo;
fi.buf = buf;
prev_string := false;
@@ -1052,8 +1053,8 @@ sbprint :: proc(buf: ^String_Buffer, args: ..any) -> string {
return to_string(buf^);
}
sbprintln :: proc(buf: ^String_Buffer, args: ..any) -> string {
fi: Fmt_Info;
sbprintln :: proc(buf: ^StringBuffer, args: ..any) -> string {
fi: FmtInfo;
fi.buf = buf;
for arg, i in args {
@@ -1066,13 +1067,13 @@ sbprintln :: proc(buf: ^String_Buffer, args: ..any) -> string {
return to_string(buf^);
}
sbprintf :: proc(b: ^String_Buffer, fmt: string, args: ..any) -> string {
fi := Fmt_Info{};
sbprintf :: proc(b: ^StringBuffer, fmt: string, args: ..any) -> string {
fi := FmtInfo{};
end := len(fmt);
arg_index := 0;
was_prev_index := false;
for i := 0; i < end; {
fi = Fmt_Info{buf = b, good_arg_index = true};
fi = FmtInfo{buf = b, good_arg_index = true};
prev_i := i;
for i < end && fmt[i] != '%' {

46
core/mem.odin
View File

@@ -50,11 +50,11 @@ align_forward :: proc(ptr: rawptr, align: int) -> rawptr {
Allocation_Header :: struct {
AllocationHeader :: struct {
size: int,
}
allocation_header_fill :: proc(header: ^Allocation_Header, data: rawptr, size: int) {
allocation_header_fill :: proc(header: ^AllocationHeader, data: rawptr, size: int) {
header.size = size;
ptr := ^int(header+1);
@@ -62,7 +62,7 @@ allocation_header_fill :: proc(header: ^Allocation_Header, data: rawptr, size: i
(ptr+i)^ = -1;
}
}
allocation_header :: proc(data: rawptr) -> ^Allocation_Header {
allocation_header :: proc(data: rawptr) -> ^AllocationHeader {
if data == nil {
return nil;
}
@@ -70,7 +70,7 @@ allocation_header :: proc(data: rawptr) -> ^Allocation_Header {
for (p-1)^ == -1 {
p = (p-1);
}
return ^Allocation_Header(p-1);
return ^AllocationHeader(p-1);
}
@@ -85,7 +85,7 @@ Arena :: struct {
temp_count: int,
}
Arena_Temp_Memory :: struct {
ArenaTempMemory :: struct {
arena: ^Arena,
original_count: int,
}
@@ -123,14 +123,14 @@ arena_allocator :: proc(arena: ^Arena) -> Allocator {
};
}
arena_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
arena_allocator_proc :: proc(allocator_data: rawptr, mode: AllocatorMode,
size, alignment: int,
old_memory: rawptr, old_size: int, flags: u64) -> rawptr {
using Allocator_Mode;
using AllocatorMode;
arena := ^Arena(allocator_data);
match mode {
case ALLOC:
case Alloc:
total_size := size + alignment;
if arena.offset + total_size > len(arena.memory) {
@@ -144,29 +144,29 @@ arena_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
arena.offset += total_size;
return zero(ptr, size);
case FREE:
case Free:
// NOTE(bill): Free all at once
// Use Arena_Temp_Memory if you want to free a block
// Use ArenaTempMemory if you want to free a block
case FREE_ALL:
case FreeAll:
arena.offset = 0;
case RESIZE:
case Resize:
return default_resize_align(old_memory, old_size, size, alignment);
}
return nil;
}
begin_arena_temp_memory :: proc(a: ^Arena) -> Arena_Temp_Memory {
tmp: Arena_Temp_Memory;
begin_arena_temp_memory :: proc(a: ^Arena) -> ArenaTempMemory {
tmp: ArenaTempMemory;
tmp.arena = a;
tmp.original_count = len(a.memory);
a.temp_count++;
return tmp;
}
end_arena_temp_memory :: proc(using tmp: Arena_Temp_Memory) {
end_arena_temp_memory :: proc(using tmp: ArenaTempMemory) {
assert(len(arena.memory) >= original_count);
assert(arena.temp_count > 0);
arena.memory = arena.memory[0..<original_count];
@@ -179,7 +179,7 @@ end_arena_temp_memory :: proc(using tmp: Arena_Temp_Memory) {
align_of_type_info :: proc(type_info: ^Type_Info) -> int {
align_of_type_info :: proc(type_info: ^TypeInfo) -> int {
prev_pow2 :: proc(n: i64) -> i64 {
if n <= 0 {
return 0;
@@ -195,7 +195,7 @@ align_of_type_info :: proc(type_info: ^Type_Info) -> int {
WORD_SIZE :: size_of(int);
MAX_ALIGN :: size_of([vector 64]f64); // TODO(bill): Should these constants be builtin constants?
using Type_Info;
using TypeInfo;
match info in type_info {
case Named:
return align_of_type_info(info.base);
@@ -215,7 +215,7 @@ align_of_type_info :: proc(type_info: ^Type_Info) -> int {
return WORD_SIZE;
case Array:
return align_of_type_info(info.elem);
case Dynamic_Array:
case DynamicArray:
return WORD_SIZE;
case Slice:
return WORD_SIZE;
@@ -230,7 +230,7 @@ align_of_type_info :: proc(type_info: ^Type_Info) -> int {
return info.align;
case Union:
return info.align;
case Raw_Union:
case RawUnion:
return info.align;
case Enum:
return align_of_type_info(info.base);
@@ -246,9 +246,9 @@ align_formula :: proc(size, align: int) -> int {
return result - result%align;
}
size_of_type_info :: proc(type_info: ^Type_Info) -> int {
size_of_type_info :: proc(type_info: ^TypeInfo) -> int {
WORD_SIZE :: size_of(int);
using Type_Info;
using TypeInfo;
match info in type_info {
case Named:
return size_of_type_info(info.base);
@@ -275,7 +275,7 @@ size_of_type_info :: proc(type_info: ^Type_Info) -> int {
align := align_of_type_info(info.elem);
alignment := align_formula(size, align);
return alignment*(count-1) + size;
case Dynamic_Array:
case DynamicArray:
return size_of(rawptr) + 2*size_of(int) + size_of(Allocator);
case Slice:
return 2*WORD_SIZE;
@@ -292,7 +292,7 @@ size_of_type_info :: proc(type_info: ^Type_Info) -> int {
return info.size;
case Union:
return info.size;
case Raw_Union:
case RawUnion:
return info.size;
case Enum:
return size_of_type_info(info.base);

14
core/os_linux.odin
View File

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

18
core/os_windows.odin
View File

@@ -1,7 +1,7 @@
#import win32 "sys/windows.odin";
Handle :: int;
File_Time :: u64;
FileTime :: u64;
Errno :: int;
INVALID_HANDLE: Handle : -1;
@@ -214,17 +214,17 @@ get_std_handle :: proc(h: int) -> Handle {
last_write_time :: proc(fd: Handle) -> File_Time {
file_info: win32.By_Handle_File_Information;
last_write_time :: proc(fd: Handle) -> FileTime {
file_info: win32.ByHandleFileInformation;
win32.GetFileInformationByHandle(win32.Handle(fd), &file_info);
lo := File_Time(file_info.last_write_time.lo);
hi := File_Time(file_info.last_write_time.hi);
lo := FileTime(file_info.last_write_time.lo);
hi := FileTime(file_info.last_write_time.hi);
return lo | hi << 32;
}
last_write_time_by_name :: proc(name: string) -> File_Time {
last_write_time_by_name :: proc(name: string) -> FileTime {
last_write_time: win32.Filetime;
data: win32.File_Attribute_Data;
data: win32.FileAttributeData;
buf: [1024]byte;
assert(len(buf) > len(name));
@@ -235,8 +235,8 @@ last_write_time_by_name :: proc(name: string) -> File_Time {
last_write_time = data.last_write_time;
}
l := File_Time(last_write_time.lo);
h := File_Time(last_write_time.hi);
l := FileTime(last_write_time.lo);
h := FileTime(last_write_time.hi);
return l | h << 32;
}

6
core/os_x.odin
View File

@@ -2,7 +2,7 @@
#import "strings.odin";
Handle :: i32;
File_Time :: u64;
FileTime :: u64;
Errno :: int;
// TODO(zangent): Find out how to make this work on x64 and x32.
@@ -211,8 +211,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) -> File_Time {}
last_write_time_by_name :: proc(name: string) -> File_Time {}
last_write_time :: proc(fd: Handle) -> FileTime {}
last_write_time_by_name :: proc(name: string) -> FileTime {}
*/
stat :: proc(path: string) -> (Stat, bool) #inline {

8
core/raw.odin
View File

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

10
core/strconv.odin
View File

@@ -1,6 +1,6 @@
#import . "decimal.odin";
Int_Flag :: enum {
IntFlag :: enum {
PREFIX = 1<<0,
PLUS = 1<<1,
SPACE = 1<<2,
@@ -320,7 +320,7 @@ is_integer_negative :: proc(u: u64, is_signed: bool, bit_size: int) -> (unsigned
}
append_bits :: proc(buf: []byte, u: u64, base: int, is_signed: bool, bit_size: int, digits: string, flags: Int_Flag) -> string {
append_bits :: proc(buf: []byte, u: u64, base: int, is_signed: bool, bit_size: int, digits: string, flags: IntFlag) -> string {
is_pow2 :: proc(x: i64) -> bool {
if (x <= 0) {
return false;
@@ -348,7 +348,7 @@ append_bits :: proc(buf: []byte, u: u64, base: int, is_signed: bool, bit_size: i
i--;
a[i] = digits[uint(u)];
if flags&Int_Flag.PREFIX != 0 {
if flags&IntFlag.PREFIX != 0 {
ok := true;
match base {
case 2: i--; a[i] = 'b';
@@ -366,9 +366,9 @@ append_bits :: proc(buf: []byte, u: u64, base: int, is_signed: bool, bit_size: i
if neg {
i--; a[i] = '-';
} else if flags&Int_Flag.PLUS != 0 {
} else if flags&IntFlag.PLUS != 0 {
i--; a[i] = '+';
} else if flags&Int_Flag.SPACE != 0 {
} else if flags&IntFlag.SPACE != 0 {
i--; a[i] = ' ';
}

28
core/sys/wgl.odin
View File

@@ -12,7 +12,7 @@ CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB :: 0x00000002;
Hglrc :: Handle;
Color_Ref :: u32;
Layer_Plane_Descriptor :: struct {
LayerPlaneDescriptor :: struct {
size: u16,
version: u16,
flags: u32,
@@ -39,28 +39,28 @@ Layer_Plane_Descriptor :: struct {
transparent: Color_Ref,
}
Point_Float :: struct {
PointFloat :: struct {
x, y: f32,
}
Glyph_Metrics_Float :: struct {
Glyph_MetricsFloat :: struct {
black_box_x: f32,
black_box_y: f32,
glyph_origin: Point_Float,
glyph_origin: PointFloat,
cell_inc_x: f32,
cell_inc_y: f32,
}
CreateContextAttribsARB_Type :: #type proc(hdc: Hdc, h_share_context: rawptr, attribList: ^i32) -> Hglrc;
ChoosePixelFormatARB_Type :: #type proc(hdc: Hdc, attrib_i_list: ^i32, attrib_f_list: ^f32, max_formats: u32, formats: ^i32, num_formats : ^u32) -> Bool #cc_c;
SwapIntervalEXT_Type :: #type proc(interval : i32) -> bool #cc_c;
GetExtensionsStringARB_Type :: #type proc(Hdc) -> ^byte #cc_c;
CreateContextAttribsARBType :: #type proc(hdc: Hdc, h_share_context: rawptr, attribList: ^i32) -> Hglrc;
ChoosePixelFormatARBType :: #type proc(hdc: Hdc, attrib_i_list: ^i32, attrib_f_list: ^f32, max_formats: u32, formats: ^i32, num_formats : ^u32) -> Bool #cc_c;
SwapIntervalEXTType :: #type proc(interval : i32) -> bool #cc_c;
GetExtensionsStringARBType :: #type proc(Hdc) -> ^byte #cc_c;
CreateContextAttribsARB: CreateContextAttribsARB_Type;
ChoosePixelFormatARB: ChoosePixelFormatARB_Type;
SwapIntervalEXT: SwapIntervalEXT_Type;
GetExtensionsStringARB: GetExtensionsStringARB_Type;
CreateContextAttribsARB: CreateContextAttribsARBType;
ChoosePixelFormatARB: ChoosePixelFormatARBType;
SwapIntervalEXT: SwapIntervalEXTType;
GetExtensionsStringARB: GetExtensionsStringARBType;
@@ -70,7 +70,7 @@ GetProcAddress :: proc(c_str: ^u8) -> Proc
DeleteContext :: proc(hglrc: Hglrc) -> Bool #foreign opengl32 "wglDeleteContext";
CopyContext :: proc(src, dst: Hglrc, mask: u32) -> Bool #foreign opengl32 "wglCopyContext";
CreateLayerContext :: proc(hdc: Hdc, layer_plane: i32) -> Hglrc #foreign opengl32 "wglCreateLayerContext";
DescribeLayerPlane :: proc(hdc: Hdc, pixel_format, layer_plane: i32, bytes: u32, pd: ^Layer_Plane_Descriptor) -> Bool #foreign opengl32 "wglDescribeLayerPlane";
DescribeLayerPlane :: proc(hdc: Hdc, pixel_format, layer_plane: i32, bytes: u32, pd: ^LayerPlaneDescriptor) -> Bool #foreign opengl32 "wglDescribeLayerPlane";
GetCurrentContext :: proc() -> Hglrc #foreign opengl32 "wglGetCurrentContext";
GetCurrentDC :: proc() -> Hdc #foreign opengl32 "wglGetCurrentDC";
GetLayerPaletteEntries :: proc(hdc: Hdc, layer_plane, start, entries: i32, cr: ^Color_Ref) -> i32 #foreign opengl32 "wglGetLayerPaletteEntries";
@@ -79,4 +79,4 @@ SetLayerPaletteEntries :: proc(hdc: Hdc, layer_plane, start, entries: i32, cr:
ShareLists :: proc(hglrc1, hglrc2: Hglrc) -> Bool #foreign opengl32 "wglShareLists";
SwapLayerBuffers :: proc(hdc: Hdc, planes: u32) -> Bool #foreign opengl32 "wglSwapLayerBuffers";
UseFontBitmaps :: proc(hdc: Hdc, first, count, list_base: u32) -> Bool #foreign opengl32 "wglUseFontBitmaps";
UseFontOutlines :: proc(hdc: Hdc, first, count, list_base: u32, deviation, extrusion: f32, format: i32, gmf: ^Glyph_Metrics_Float) -> Bool #foreign opengl32 "wglUseFontOutlines";
UseFontOutlines :: proc(hdc: Hdc, first, count, list_base: u32, deviation, extrusion: f32, format: i32, gmf: ^Glyph_MetricsFloat) -> Bool #foreign opengl32 "wglUseFontOutlines";

226
core/sys/windows.odin
View File

@@ -18,7 +18,7 @@ Wparam :: uint;
Lparam :: int;
Lresult :: int;
Bool :: i32;
Wnd_Proc :: #type proc(Hwnd, u32, Wparam, Lparam) -> Lresult #cc_c;
WndProc :: #type proc(Hwnd, u32, Wparam, Lparam) -> Lresult #cc_c;
INVALID_HANDLE :: Handle(~int(0));
@@ -71,7 +71,7 @@ Point :: struct #ordered {
WndClassExA :: struct #ordered {
size, style: u32,
wnd_proc: Wnd_Proc,
wndproc: WndProc,
cls_extra, wnd_extra: i32,
instance: Hinstance,
icon: Hicon,
@@ -107,7 +107,7 @@ Systemtime :: struct #ordered {
hour, minute, second, millisecond: u16,
}
By_Handle_File_Information :: struct #ordered {
ByHandleFileInformation :: struct #ordered {
file_attributes: u32,
creation_time,
last_access_time,
@@ -120,7 +120,7 @@ By_Handle_File_Information :: struct #ordered {
file_index_low: u32,
}
File_Attribute_Data :: struct #ordered {
FileAttributeData :: struct #ordered {
file_attributes: u32,
creation_time,
last_access_time,
@@ -129,7 +129,7 @@ File_Attribute_Data :: struct #ordered {
file_size_low: u32,
}
Find_Data :: struct #ordered {
FindData :: struct #ordered {
file_attributes : u32,
creation_time : Filetime,
last_access_time : Filetime,
@@ -188,7 +188,7 @@ AdjustWindowRect :: proc(rect: ^Rect, style: u32, menu: Bool) -> Bool #foreign u
GetActiveWindow :: proc() -> Hwnd #foreign user32;
DestroyWindow :: proc(wnd: Hwnd) -> Bool #foreign user32;
DescribePixelFormat :: proc(dc: Hdc, pixel_format: i32, bytes : u32, pfd: ^PIXELFORMATDESCRIPTOR) -> i32 #foreign user32;
DescribePixelFormat :: proc(dc: Hdc, pixel_format: i32, bytes : u32, pfd: ^PixelFormatDescriptor) -> i32 #foreign user32;
GetQueryPerformanceFrequency :: proc() -> i64 {
@@ -222,15 +222,15 @@ WriteFile :: proc(h: Handle, buf: rawptr, len: i32, written_result: ^i32, overla
GetFileSizeEx :: proc(file_handle: Handle, file_size: ^i64) -> Bool #foreign kernel32;
GetFileAttributesA :: proc(filename : ^byte) -> u32 #foreign kernel32;
GetFileAttributesExA :: proc(filename: ^u8, info_level_id: GET_FILEEX_INFO_LEVELS, file_info: rawptr) -> Bool #foreign kernel32;
GetFileInformationByHandle :: proc(file_handle: Handle, file_info: ^By_Handle_File_Information) -> Bool #foreign kernel32;
GetFileInformationByHandle :: proc(file_handle: Handle, file_info: ^ByHandleFileInformation) -> Bool #foreign kernel32;
GetFileType :: proc(file_handle: Handle) -> u32 #foreign kernel32;
SetFilePointer :: proc(file_handle: Handle, distance_to_move: i32, distance_to_move_high: ^i32, move_method: u32) -> u32 #foreign kernel32;
SetHandleInformation :: proc(obj: Handle, mask, flags: u32) -> Bool #foreign kernel32;
FindFirstFileA :: proc(file_name : ^byte, data : ^Find_Data) -> Handle #foreign kernel32;
FindNextFileA :: proc(file : Handle, data : ^Find_Data) -> Bool #foreign kernel32;
FindFirstFileA :: proc(file_name : ^byte, data : ^FindData) -> Handle #foreign kernel32;
FindNextFileA :: proc(file : Handle, data : ^FindData) -> Bool #foreign kernel32;
FindClose :: proc(file : Handle) -> Bool #foreign kernel32;
MAX_PATH :: 0x00000104;
@@ -350,14 +350,14 @@ SWP_NOSIZE :: 0x0001;
SWP_NOMOVE :: 0x0002;
Monitor_Info :: struct #ordered {
MonitorInfo :: struct #ordered {
size: u32,
monitor: Rect,
work: Rect,
flags: u32,
}
Window_Placement :: struct #ordered {
WindowPlacement :: struct #ordered {
length: u32,
flags: u32,
show_cmd: u32,
@@ -366,13 +366,13 @@ Window_Placement :: struct #ordered {
normal_pos: Rect,
}
GetMonitorInfoA :: proc(monitor: Hmonitor, mi: ^Monitor_Info) -> Bool #foreign user32;
GetMonitorInfoA :: proc(monitor: Hmonitor, mi: ^MonitorInfo) -> Bool #foreign user32;
MonitorFromWindow :: proc(wnd: Hwnd, flags : u32) -> Hmonitor #foreign user32;
SetWindowPos :: proc(wnd: Hwnd, wndInsertAfter: Hwnd, x, y, width, height: i32, flags: u32) #foreign user32 "SetWindowPos";
GetWindowPlacement :: proc(wnd: Hwnd, wndpl: ^Window_Placement) -> Bool #foreign user32;
SetWindowPlacement :: proc(wnd: Hwnd, wndpl: ^Window_Placement) -> Bool #foreign user32;
GetWindowPlacement :: proc(wnd: Hwnd, wndpl: ^WindowPlacement) -> Bool #foreign user32;
SetWindowPlacement :: proc(wnd: Hwnd, wndpl: ^WindowPlacement) -> Bool #foreign user32;
GetWindowRect :: proc(wnd: Hwnd, rect: ^Rect) -> Bool #foreign user32;
GetWindowLongPtrA :: proc(wnd: Hwnd, index: i32) -> i64 #foreign user32;
@@ -394,7 +394,7 @@ LOWORD :: proc(lParam: Lparam) -> u16 { return u16(lParam); }
Bitmap_Info_Header :: struct #ordered {
BitmapInfoHeader :: struct #ordered {
size: u32,
width, height: i32,
planes, bit_count: i16,
@@ -405,13 +405,13 @@ Bitmap_Info_Header :: struct #ordered {
clr_used: u32,
clr_important: u32,
}
Bitmap_Info :: struct #ordered {
using header: Bitmap_Info_Header,
colors: [1]Rgb_Quad,
BitmapInfo :: struct #ordered {
using header: BitmapInfoHeader,
colors: [1]RgbQuad,
}
Rgb_Quad :: struct #ordered { blue, green, red, reserved: byte }
RgbQuad :: struct #ordered { blue, green, red, reserved: byte }
BI_RGB :: 0;
DIB_RGB_COLORS :: 0x00;
@@ -421,7 +421,7 @@ SRCCOPY: u32 : 0x00cc0020;
StretchDIBits :: 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: ^Bitmap_Info,
bits: rawptr, bits_info: ^BitmapInfo,
usage: u32,
rop: u32) -> i32 #foreign gdi32;
@@ -457,7 +457,7 @@ PFD_DOUBLEBUFFER_DONTCARE :: 0x40000000;
PFD_STEREO_DONTCARE :: 0x80000000;
PIXELFORMATDESCRIPTOR :: struct #ordered {
PixelFormatDescriptor :: struct #ordered {
size,
version,
flags: u32,
@@ -489,8 +489,8 @@ PIXELFORMATDESCRIPTOR :: struct #ordered {
}
GetDC :: proc(h: Hwnd) -> Hdc #foreign user32;
SetPixelFormat :: proc(hdc: Hdc, pixel_format: i32, pfd: ^PIXELFORMATDESCRIPTOR) -> Bool #foreign gdi32;
ChoosePixelFormat :: proc(hdc: Hdc, pfd: ^PIXELFORMATDESCRIPTOR) -> i32 #foreign gdi32;
SetPixelFormat :: proc(hdc: Hdc, pixel_format: i32, pfd: ^PixelFormatDescriptor) -> Bool #foreign gdi32;
ChoosePixelFormat :: proc(hdc: Hdc, pfd: ^PixelFormatDescriptor) -> i32 #foreign gdi32;
SwapBuffers :: proc(hdc: Hdc) -> Bool #foreign gdi32;
ReleaseDC :: proc(wnd: Hwnd, hdc: Hdc) -> i32 #foreign user32;
@@ -501,62 +501,62 @@ Proc :: #type proc() #cc_c;
GetKeyState :: proc(v_key: i32) -> i16 #foreign user32;
GetAsyncKeyState :: proc(v_key: i32) -> i16 #foreign user32;
is_key_down :: proc(key: Key_Code) -> bool #inline { return GetAsyncKeyState(i32(key)) < 0; }
is_key_down :: proc(key: KeyCode) -> bool #inline { return GetAsyncKeyState(i32(key)) < 0; }
Key_Code :: enum i32 {
LBUTTON = 0x01,
RBUTTON = 0x02,
CANCEL = 0x03,
MBUTTON = 0x04,
BACK = 0x08,
TAB = 0x09,
CLEAR = 0x0C,
RETURN = 0x0D,
KeyCode :: enum i32 {
Lbutton = 0x01,
Rbutton = 0x02,
Cancel = 0x03,
Mbutton = 0x04,
Back = 0x08,
Tab = 0x09,
Clear = 0x0C,
Return = 0x0D,
SHIFT = 0x10,
CONTROL = 0x11,
MENU = 0x12,
PAUSE = 0x13,
CAPITAL = 0x14,
KANA = 0x15,
HANGEUL = 0x15,
HANGUL = 0x15,
JUNJA = 0x17,
FINAL = 0x18,
HANJA = 0x19,
KANJI = 0x19,
ESCAPE = 0x1B,
CONVERT = 0x1C,
NONCONVERT = 0x1D,
ACCEPT = 0x1E,
MODECHANGE = 0x1F,
SPACE = 0x20,
PRIOR = 0x21,
NEXT = 0x22,
END = 0x23,
HOME = 0x24,
LEFT = 0x25,
UP = 0x26,
RIGHT = 0x27,
DOWN = 0x28,
SELECT = 0x29,
PRINT = 0x2A,
EXECUTE = 0x2B,
SNAPSHOT = 0x2C,
INSERT = 0x2D,
DELETE = 0x2E,
HELP = 0x2F,
Shift = 0x10,
Control = 0x11,
Menu = 0x12,
Pause = 0x13,
Capital = 0x14,
Kana = 0x15,
Hangeul = 0x15,
Hangul = 0x15,
Junja = 0x17,
Final = 0x18,
Hanja = 0x19,
Kanji = 0x19,
Escape = 0x1B,
Convert = 0x1C,
NonConvert = 0x1D,
Accept = 0x1E,
ModeChange = 0x1F,
Space = 0x20,
Prior = 0x21,
Next = 0x22,
End = 0x23,
Home = 0x24,
Left = 0x25,
Up = 0x26,
Right = 0x27,
Down = 0x28,
Select = 0x29,
Print = 0x2A,
Execute = 0x2B,
Snapshot = 0x2C,
Insert = 0x2D,
Delete = 0x2E,
Help = 0x2F,
NUM0 = '0',
NUM1 = '1',
NUM2 = '2',
NUM3 = '3',
NUM4 = '4',
NUM5 = '5',
NUM6 = '6',
NUM7 = '7',
NUM8 = '8',
NUM9 = '9',
Num0 = '0',
Num1 = '1',
Num2 = '2',
Num3 = '3',
Num4 = '4',
Num5 = '5',
Num6 = '6',
Num7 = '7',
Num8 = '8',
Num9 = '9',
A = 'A',
B = 'B',
C = 'C',
@@ -584,26 +584,26 @@ Key_Code :: enum i32 {
Y = 'Y',
Z = 'Z',
LWIN = 0x5B,
RWIN = 0x5C,
APPS = 0x5D,
Lwin = 0x5B,
Rwin = 0x5C,
Apps = 0x5D,
NUMPAD0 = 0x60,
NUMPAD1 = 0x61,
NUMPAD2 = 0x62,
NUMPAD3 = 0x63,
NUMPAD4 = 0x64,
NUMPAD5 = 0x65,
NUMPAD6 = 0x66,
NUMPAD7 = 0x67,
NUMPAD8 = 0x68,
NUMPAD9 = 0x69,
MULTIPLY = 0x6A,
ADD = 0x6B,
SEPARATOR = 0x6C,
SUBTRACT = 0x6D,
DECIMAL = 0x6E,
DIVIDE = 0x6F,
Numpad0 = 0x60,
Numpad1 = 0x61,
Numpad2 = 0x62,
Numpad3 = 0x63,
Numpad4 = 0x64,
Numpad5 = 0x65,
Numpad6 = 0x66,
Numpad7 = 0x67,
Numpad8 = 0x68,
Numpad9 = 0x69,
Multiply = 0x6A,
Add = 0x6B,
Separator = 0x6C,
Subtract = 0x6D,
Decimal = 0x6E,
Divide = 0x6F,
F1 = 0x70,
F2 = 0x71,
@@ -630,22 +630,22 @@ Key_Code :: enum i32 {
F23 = 0x86,
F24 = 0x87,
NUMLOCK = 0x90,
SCROLL = 0x91,
LSHIFT = 0xA0,
RSHIFT = 0xA1,
LCONTROL = 0xA2,
RCONTROL = 0xA3,
LMENU = 0xA4,
RMENU = 0xA5,
ProcESSKEY = 0xE5,
ATTN = 0xF6,
CRSEL = 0xF7,
EXSEL = 0xF8,
EREOF = 0xF9,
PLAY = 0xFA,
ZOOM = 0xFB,
NONAME = 0xFC,
PA1 = 0xFD,
OEM_CLEAR = 0xFE,
Numlock = 0x90,
Scroll = 0x91,
Lshift = 0xA0,
Rshift = 0xA1,
Lcontrol = 0xA2,
Rcontrol = 0xA3,
Lmenu = 0xA4,
Rmenu = 0xA5,
ProcessKey = 0xE5,
Attn = 0xF6,
Crsel = 0xF7,
Exsel = 0xF8,
Ereof = 0xF9,
Play = 0xFA,
Zoom = 0xFB,
Noname = 0xFC,
Pa1 = 0xFD,
OemClear = 0xFE,
}

78
core/types.odin
View File

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

4
core/utf8.odin
View File

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