ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-06-23 06:05:00 -07:00
Code Issues Packages Projects Releases Wiki Activity

Disable var and const declarations

Browse Source
This commit is contained in:
Ginger Bill
2017-06-28 23:17:20 +01:00
parent 9ca2246bac
commit 0622509807
27 changed files with 2508 additions and 2537 deletions
Download Patch File Download Diff File Expand all files Collapse all files
code/demo.odin
+53 -35
View File
@@ -1,4 +1,22 @@
import "fmt.odin";
import (
"atomics.odin";
"bits.odin";
"decimal.odin";
"fmt.odin";
"hash.odin";
"math.odin";
"mem.odin";
"opengl.odin";
"os.odin";
"pool.odin";
"raw.odin";
"strconv.odin";
"strings.odin";
"sync.odin";
"types.odin";
"utf8.odin";
"utf16.odin";
)
proc general_stuff() {
// Complex numbers
@@ -20,13 +38,13 @@ proc general_stuff() {
}
type Foo struct {
Foo :: struct {
x: int,
y: f32,
z: string,
}
var foo = Foo{123, 0.513, "A string"};
var x, y, z = expand_to_tuple(foo);
foo := Foo{123, 0.513, "A string"};
x, y, z := expand_to_tuple(foo);
fmt.println(x, y, z);
compile_assert(type_of(x) == int);
compile_assert(type_of(y) == f32);
@@ -36,7 +54,7 @@ proc general_stuff() {
// By default, all variables are zeroed
// This can be overridden with the "uninitialized value"
// This is similar to `nil` but applied to everything
var undef_int: int = ---;
undef_int: int = ---;
// Context system is now implemented using Implicit Parameter Passing (IPP)
@@ -66,7 +84,7 @@ proc default_arguments() {
}
proc named_arguments() {
type Colour enum {
Colour :: enum {
Red,
Orange,
Yellow,
@@ -110,7 +128,7 @@ proc named_arguments() {
// Named arguments can also aid with default arguments
proc numerous_things(s: string, a = 1, b = 2, c = 3.14,
d = "The Best String!", e = false, f = 10.3/3.1, g = false) {
var g_str = g ? "true" : "false";
g_str := g ? "true" : "false";
fmt.printf("How many?! %s: %v\n", s, g_str);
}
@@ -150,13 +168,13 @@ proc default_return_values() {
// A more "real" example
type Error enum {
Error :: enum {
None,
WhyTheNumberThree,
TenIsTooBig,
};
type Entity struct {
Entity :: struct {
name: string,
id: u32,
}
@@ -167,7 +185,7 @@ proc default_return_values() {
case input >= 10: return err = Error.TenIsTooBig;
}
var e = new(Entity);
e := new(Entity);
e.id = u32(input);
return result = e;
@@ -183,7 +201,7 @@ proc call_location() {
fmt.println();
}
var loc = #location(main);
loc := #location(main);
fmt.println("`main` is located at", loc);
fmt.println("This line is located at", #location());
@@ -203,18 +221,18 @@ proc explicit_parametric_polymorphic_procedures() {
return ^T(alloc(size_of(T), align_of(T)));
}
var int_ptr = alloc_type(int);
int_ptr := alloc_type(int);
defer free(int_ptr);
int_ptr^ = 137;
fmt.println(int_ptr, int_ptr^);
// Named arguments work too!
var another_ptr = alloc_type(T = f32);
another_ptr := alloc_type(T = f32);
defer free(another_ptr);
proc add(T: type, args: ..T) -> T {
var res: T;
res: T;
for arg in args {
res += arg;
}
@@ -224,12 +242,12 @@ proc explicit_parametric_polymorphic_procedures() {
fmt.println("add =", add(int, 1, 2, 3, 4, 5, 6));
proc swap(T: type, a, b: ^T) {
var tmp = a^;
tmp := a^;
a^ = b^;
b^ = tmp;
}
var a, b: int = 3, 4;
a, b: int = 3, 4;
fmt.println("Pre-swap:", a, b);
swap(int, &a, &b);
fmt.println("Post-swap:", a, b);
@@ -242,9 +260,9 @@ proc explicit_parametric_polymorphic_procedures() {
// A more complicated example using subtyping
// Something like this could be used in a game
type Vector2 struct {x, y: f32};
Vector2 :: struct {x, y: f32};
type Entity struct {
Entity :: struct {
using position: Vector2,
flags: u64,
id: u64,
@@ -254,27 +272,27 @@ proc explicit_parametric_polymorphic_procedures() {
derived: any,
}
type Rock struct {
Rock :: struct {
using entity: ^Entity,
heavy: bool,
}
type Door struct {
Door :: struct {
using entity: ^Entity,
open: bool,
}
type Monster struct {
Monster :: struct {
using entity: ^Entity,
is_robot: bool,
is_zombie: bool,
}
type EntityManager struct {
EntityManager :: struct {
batches: [dynamic]^EntityBatch,
next_portable_id: u32,
}
const ENTITIES_PER_BATCH = 16;
type EntityBatch struct {
ENTITIES_PER_BATCH :: 16;
EntityBatch :: struct {
data: [ENTITIES_PER_BATCH]Entity,
occupied: [ENTITIES_PER_BATCH]bool,
batch_index: u32,
@@ -285,7 +303,7 @@ proc explicit_parametric_polymorphic_procedures() {
if ok -> continue;
batch.occupied[i] = true;
var e = &batch.data[i];
e := &batch.data[i];
e.batch_index = u32(batch.batch_index);
e.slot_index = u32(i);
e.portable_id = manager.next_portable_id;
@@ -297,11 +315,11 @@ proc explicit_parametric_polymorphic_procedures() {
proc gen_new_entity(manager: ^EntityManager) -> ^Entity {
for b in manager.batches {
var e = use_empty_slot(manager, b);
e := use_empty_slot(manager, b);
if e != nil -> return e;
}
var new_batch = new(EntityBatch);
new_batch := new(EntityBatch);
append(manager.batches, new_batch);
new_batch.batch_index = u32(len(manager.batches)-1);
@@ -311,7 +329,7 @@ proc explicit_parametric_polymorphic_procedures() {
proc new_entity(manager: ^EntityManager, Type: type, x, y: int) -> ^Type {
var result = new(Type);
result := new(Type);
result.entity = gen_new_entity(manager);
result.derived.data = result;
result.derived.type_info = type_info(Type);
@@ -322,16 +340,16 @@ proc explicit_parametric_polymorphic_procedures() {
return result;
}
var manager: EntityManager;
var entities: [dynamic]^Entity;
manager: EntityManager;
entities: [dynamic]^Entity;
var rock = new_entity(&manager, Rock, 3, 5);
rock := new_entity(&manager, Rock, 3, 5);
// Named arguments work too!
var door = new_entity(manager = &manager, Type = Door, x = 3, y = 6);
door := new_entity(manager = &manager, Type = Door, x = 3, y = 6);
// And named arguments can be any order
var monster = new_entity(
monster := new_entity(
y = 1,
x = 2,
manager = &manager,
@@ -417,8 +435,8 @@ proc main() {
/*
proc main() {
var program = "+ + * - /";
var accumulator = 0;
program := "+ + * - /";
accumulator := 0;
for token in program {
match token {
core/_preload.odin
+87 -90
View File
@@ -113,17 +113,16 @@ type (
// NOTE(bill): only the ones that are needed (not all types)
// This will be set by the compiler
var (
__type_table: []TypeInfo;
__type_table: []TypeInfo;
__argv__: ^^u8;
__argc__: i32;
__argv__: ^^u8;
__argc__: i32;
)
proc type_info_base(info: ^TypeInfo) -> ^TypeInfo {
if info == nil -> return nil;
var base = info;
base := info;
match i in base {
case TypeInfo.Named:
base = i.base;
@@ -135,7 +134,7 @@ proc type_info_base(info: ^TypeInfo) -> ^TypeInfo {
proc type_info_base_without_enum(info: ^TypeInfo) -> ^TypeInfo {
if info == nil -> return nil;
var base = info;
base := info;
match i in base {
case TypeInfo.Named:
base = i.base;
@@ -197,7 +196,7 @@ proc make_source_code_location(file: string, line, column: i64, procedure: strin
const DEFAULT_ALIGNMENT = align_of([vector 4]f32);
DEFAULT_ALIGNMENT :: align_of([vector 4]f32);
proc __init_context_from_ptr(c: ^Context, other: ^Context) #cc_contextless {
if c == nil -> return;
@@ -231,7 +230,7 @@ proc __check_context() {
proc alloc(size: int, alignment: int = DEFAULT_ALIGNMENT) -> rawptr #inline {
// __check_context();
var a = context.allocator;
a := context.allocator;
return a.procedure(a.data, AllocatorMode.Alloc, size, alignment, nil, 0, 0);
}
@@ -252,14 +251,14 @@ proc free_ptr(ptr: rawptr) #inline {
proc free_all() #inline {
// __check_context();
var a = context.allocator;
a := context.allocator;
a.procedure(a.data, AllocatorMode.FreeAll, 0, 0, nil, 0, 0);
}
proc resize(ptr: rawptr, old_size, new_size: int, alignment: int = DEFAULT_ALIGNMENT) -> rawptr #inline {
// __check_context();
var a = context.allocator;
a := context.allocator;
return a.procedure(a.data, AllocatorMode.Resize, new_size, alignment, ptr, old_size, 0);
}
@@ -284,7 +283,7 @@ proc default_resize_align(old_memory: rawptr, old_size, new_size, alignment: int
return old_memory;
}
var new_memory = alloc(new_size, alignment);
new_memory := alloc(new_size, alignment);
if new_memory == nil {
return nil;
}
@@ -312,7 +311,7 @@ proc default_allocator_proc(allocator_data: rawptr, mode: AllocatorMode,
// NOTE(bill): Does nothing
case Resize:
var ptr = os.heap_resize(old_memory, size);
ptr := os.heap_resize(old_memory, size);
assert(ptr != nil);
return ptr;
}
@@ -478,11 +477,11 @@ foreign __llvm_core {
proc __sqrt_f64(x: f64) -> f64 #link_name "llvm.sqrt.f64";
}
proc __abs_complex64(x: complex64) -> f32 #inline #cc_contextless {
var r, i = real(x), imag(x);
r, i := real(x), imag(x);
return __sqrt_f32(r*r + i*i);
}
proc __abs_complex128(x: complex128) -> f64 #inline #cc_contextless {
var r, i = real(x), imag(x);
r, i := real(x), imag(x);
return __sqrt_f64(r*r + i*i);
}
@@ -490,7 +489,7 @@ proc __abs_complex128(x: complex128) -> f64 #inline #cc_contextless {
proc __dynamic_array_make(array_: rawptr, elem_size, elem_align: int, len, cap: int) {
var array = ^raw.DynamicArray(array_);
array := ^raw.DynamicArray(array_);
// __check_context();
array.allocator = context.allocator;
assert(array.allocator.procedure != nil);
@@ -502,7 +501,7 @@ proc __dynamic_array_make(array_: rawptr, elem_size, elem_align: int, len, cap:
}
proc __dynamic_array_reserve(array_: rawptr, elem_size, elem_align: int, cap: int) -> bool {
var array = ^raw.DynamicArray(array_);
array := ^raw.DynamicArray(array_);
if cap <= array.cap -> return true;
@@ -512,11 +511,11 @@ proc __dynamic_array_reserve(array_: rawptr, elem_size, elem_align: int, cap: in
}
assert(array.allocator.procedure != nil);
var old_size = array.cap * elem_size;
var new_size = cap * elem_size;
var allocator = array.allocator;
old_size := array.cap * elem_size;
new_size := cap * elem_size;
allocator := array.allocator;
var new_data = allocator.procedure(allocator.data, AllocatorMode.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;
array.data = new_data;
@@ -525,9 +524,9 @@ proc __dynamic_array_reserve(array_: rawptr, elem_size, elem_align: int, cap: in
}
proc __dynamic_array_resize(array_: rawptr, elem_size, elem_align: int, len: int) -> bool {
var array = ^raw.DynamicArray(array_);
array := ^raw.DynamicArray(array_);
var ok = __dynamic_array_reserve(array_, elem_size, elem_align, len);
ok := __dynamic_array_reserve(array_, elem_size, elem_align, len);
if ok -> array.len = len;
return ok;
}
@@ -535,22 +534,22 @@ proc __dynamic_array_resize(array_: rawptr, elem_size, elem_align: int, len: int
proc __dynamic_array_append(array_: rawptr, elem_size, elem_align: int,
items: rawptr, item_count: int) -> int {
var array = ^raw.DynamicArray(array_);
array := ^raw.DynamicArray(array_);
if item_count <= 0 || items == nil {
return array.len;
}
var ok = true;
ok := true;
if array.cap <= array.len+item_count {
var cap = 2 * array.cap + max(8, item_count);
cap := 2 * array.cap + max(8, item_count);
ok = __dynamic_array_reserve(array, elem_size, elem_align, cap);
}
// TODO(bill): Better error handling for failed reservation
if !ok -> return array.len;
var data = ^u8(array.data);
data := ^u8(array.data);
assert(data != nil);
__mem_copy(data + (elem_size*array.len), items, elem_size * item_count);
array.len += item_count;
@@ -558,17 +557,17 @@ proc __dynamic_array_append(array_: rawptr, elem_size, elem_align: int,
}
proc __dynamic_array_append_nothing(array_: rawptr, elem_size, elem_align: int) -> int {
var array = ^raw.DynamicArray(array_);
array := ^raw.DynamicArray(array_);
var ok = true;
ok := true;
if array.cap <= array.len+1 {
var cap = 2 * array.cap + max(8, 1);
cap := 2 * array.cap + max(8, 1);
ok = __dynamic_array_reserve(array, elem_size, elem_align, cap);
}
// TODO(bill): Better error handling for failed reservation
if !ok -> return array.len;
var data = ^u8(array.data);
data := ^u8(array.data);
assert(data != nil);
__mem_zero(data + (elem_size*array.len), elem_size);
array.len++;
@@ -577,7 +576,7 @@ proc __dynamic_array_append_nothing(array_: rawptr, elem_size, elem_align: int)
proc __slice_append(slice_: rawptr, elem_size, elem_align: int,
items: rawptr, item_count: int) -> int {
var slice = ^raw.Slice(slice_);
slice := ^raw.Slice(slice_);
if item_count <= 0 || items == nil {
return slice.len;
@@ -585,7 +584,7 @@ proc __slice_append(slice_: rawptr, elem_size, elem_align: int,
item_count = min(slice.cap-slice.len, item_count);
if item_count > 0 {
var data = ^u8(slice.data);
data := ^u8(slice.data);
assert(data != nil);
__mem_copy(data + (elem_size*slice.len), items, elem_size * item_count);
slice.len += item_count;
@@ -598,7 +597,7 @@ proc __slice_append(slice_: rawptr, elem_size, elem_align: int,
proc __default_hash(data: []u8) -> u128 {
proc fnv128a(data: []u8) -> u128 {
var h: u128 = 0x6c62272e07bb014262b821756295c58d;
h: u128 = 0x6c62272e07bb014262b821756295c58d;
for b in data {
h = (h ~ u128(b)) * 0x1000000000000000000013b;
}
@@ -610,37 +609,35 @@ proc __default_hash_string(s: string) -> u128 {
return __default_hash([]u8(s));
}
const __INITIAL_MAP_CAP = 16;
__INITIAL_MAP_CAP :: 16;
type (
__MapKey struct #ordered {
hash: u128,
str: string,
}
__MapKey :: struct #ordered {
hash: u128,
str: string,
}
__MapFindResult struct #ordered {
hash_index: int,
entry_prev: int,
entry_index: int,
}
__MapFindResult :: struct #ordered {
hash_index: int,
entry_prev: int,
entry_index: int,
}
__MapEntryHeader struct #ordered {
key: __MapKey,
next: int,
/*
value: Value_Type,
*/
}
__MapEntryHeader :: struct #ordered {
key: __MapKey,
next: int,
/*
value: Value_Type,
*/
}
__MapHeader struct #ordered {
m: ^raw.DynamicMap,
is_key_string: bool,
entry_size: int,
entry_align: int,
value_offset: int,
value_size: int,
}
)
__MapHeader :: struct #ordered {
m: ^raw.DynamicMap,
is_key_string: bool,
entry_size: int,
entry_align: int,
value_offset: int,
value_size: int,
}
proc __dynamic_map_reserve(using header: __MapHeader, cap: int) {
__dynamic_array_reserve(&m.hashes, size_of(int), align_of(int), cap);
@@ -648,37 +645,37 @@ proc __dynamic_map_reserve(using header: __MapHeader, cap: int) {
}
proc __dynamic_map_rehash(using header: __MapHeader, new_count: int) {
var new_header: __MapHeader = header;
var nm: raw.DynamicMap;
new_header: __MapHeader = header;
nm: raw.DynamicMap;
new_header.m = &nm;
var header_hashes = ^raw.DynamicArray(&header.m.hashes);
var nm_hashes = ^raw.DynamicArray(&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);
for i in 0..<new_count -> nm.hashes[i] = -1;
for var i = 0; i < m.entries.len; i++ {
for i := 0; i < m.entries.len; i++ {
if len(nm.hashes) == 0 {
__dynamic_map_grow(new_header);
}
var entry_header = __dynamic_map_get_entry(header, i);
var data = ^u8(entry_header);
entry_header := __dynamic_map_get_entry(header, i);
data := ^u8(entry_header);
var fr = __dynamic_map_find(new_header, entry_header.key);
var j = __dynamic_map_add_entry(new_header, entry_header.key);
fr := __dynamic_map_find(new_header, entry_header.key);
j := __dynamic_map_add_entry(new_header, entry_header.key);
if fr.entry_prev < 0 {
nm.hashes[fr.hash_index] = j;
} else {
var e = __dynamic_map_get_entry(new_header, fr.entry_prev);
e := __dynamic_map_get_entry(new_header, fr.entry_prev);
e.next = j;
}
var e = __dynamic_map_get_entry(new_header, j);
e := __dynamic_map_get_entry(new_header, j);
e.next = fr.entry_index;
var ndata = ^u8(e);
ndata := ^u8(e);
__mem_copy(ndata+value_offset, data+value_offset, value_size);
if __dynamic_map_full(new_header) {
@@ -691,17 +688,17 @@ proc __dynamic_map_rehash(using header: __MapHeader, new_count: int) {
}
proc __dynamic_map_get(h: __MapHeader, key: __MapKey) -> rawptr {
var index = __dynamic_map_find(h, key).entry_index;
index := __dynamic_map_find(h, key).entry_index;
if index >= 0 {
var data = ^u8(__dynamic_map_get_entry(h, index));
var val = data + h.value_offset;
data := ^u8(__dynamic_map_get_entry(h, index));
val := data + h.value_offset;
return val;
}
return nil;
}
proc __dynamic_map_set(using h: __MapHeader, key: __MapKey, value: rawptr) {
var index: int;
index: int;
assert(value != nil);
@@ -710,22 +707,22 @@ proc __dynamic_map_set(using h: __MapHeader, key: __MapKey, value: rawptr) {
__dynamic_map_grow(h);
}
var fr = __dynamic_map_find(h, key);
fr := __dynamic_map_find(h, key);
if fr.entry_index >= 0 {
index = fr.entry_index;
} else {
index = __dynamic_map_add_entry(h, key);
if fr.entry_prev >= 0 {
var entry = __dynamic_map_get_entry(h, fr.entry_prev);
entry := __dynamic_map_get_entry(h, fr.entry_prev);
entry.next = index;
} else {
m.hashes[fr.hash_index] = index;
}
}
{
var e = __dynamic_map_get_entry(h, index);
e := __dynamic_map_get_entry(h, index);
e.key = key;
var val = ^u8(e) + value_offset;
val := ^u8(e) + value_offset;
__mem_copy(val, value, value_size);
}
@@ -736,7 +733,7 @@ proc __dynamic_map_set(using h: __MapHeader, key: __MapKey, value: rawptr) {
proc __dynamic_map_grow(using h: __MapHeader) {
var new_count = max(2*m.entries.cap + 8, __INITIAL_MAP_CAP);
new_count := max(2*m.entries.cap + 8, __INITIAL_MAP_CAP);
__dynamic_map_rehash(h, new_count);
}
@@ -754,12 +751,12 @@ proc __dynamic_map_hash_equal(h: __MapHeader, a, b: __MapKey) -> bool {
}
proc __dynamic_map_find(using h: __MapHeader, key: __MapKey) -> __MapFindResult {
var fr = __MapFindResult{-1, -1, -1};
fr := __MapFindResult{-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];
for fr.entry_index >= 0 {
var entry = __dynamic_map_get_entry(h, fr.entry_index);
entry := __dynamic_map_get_entry(h, fr.entry_index);
if __dynamic_map_hash_equal(h, entry.key, key) {
return fr;
}
@@ -771,10 +768,10 @@ proc __dynamic_map_find(using h: __MapHeader, key: __MapKey) -> __MapFindResult
}
proc __dynamic_map_add_entry(using h: __MapHeader, key: __MapKey) -> int {
var prev = m.entries.len;
var c = __dynamic_array_append_nothing(&m.entries, entry_size, entry_align);
prev := m.entries.len;
c := __dynamic_array_append_nothing(&m.entries, entry_size, entry_align);
if c != prev {
var end = __dynamic_map_get_entry(h, c-1);
end := __dynamic_map_get_entry(h, c-1);
end.key = key;
end.next = -1;
}
@@ -783,14 +780,14 @@ proc __dynamic_map_add_entry(using h: __MapHeader, key: __MapKey) -> int {
proc __dynamic_map_delete(using h: __MapHeader, key: __MapKey) {
var fr = __dynamic_map_find(h, key);
fr := __dynamic_map_find(h, key);
if fr.entry_index >= 0 {
__dynamic_map_erase(h, fr);
}
}
proc __dynamic_map_get_entry(using h: __MapHeader, index: int) -> ^__MapEntryHeader {
var data = ^u8(m.entries.data) + index*entry_size;
data := ^u8(m.entries.data) + index*entry_size;
return ^__MapEntryHeader(data);
}
@@ -805,7 +802,7 @@ proc __dynamic_map_erase(using h: __MapHeader, fr: __MapFindResult) {
m.entries.len--;
}
__mem_copy(__dynamic_map_get_entry(h, fr.entry_index), __dynamic_map_get_entry(h, m.entries.len-1), entry_size);
var last = __dynamic_map_find(h, __dynamic_map_get_entry(h, fr.entry_index).key);
last := __dynamic_map_find(h, __dynamic_map_get_entry(h, fr.entry_index).key);
if last.entry_prev >= 0 {
__dynamic_map_get_entry(h, last.entry_prev).next = fr.entry_index;
} else {
core/_soft_numbers.odin
+25 -25
View File
@@ -1,8 +1,8 @@
#shared_global_scope;
proc __multi3(a, b: u128) -> u128 #cc_c #link_name "__multi3" {
const bits_in_dword_2 = size_of(i64) * 4;
const lower_mask = u128(~u64(0) >> bits_in_dword_2);
bits_in_dword_2 :: size_of(i64) * 4;
lower_mask :: u128(~u64(0) >> bits_in_dword_2);
when ODIN_ENDIAN == "bit" {
@@ -17,18 +17,18 @@ proc __multi3(a, b: u128) -> u128 #cc_c #link_name "__multi3" {
};
}
var r: TWords;
var t: u64;
r: TWords;
t: u64;
r.lo = u64(a & lower_mask) * u64(b & lower_mask);
t = r.lo >> bits_in_dword_2;
r.lo = u64(a & lower_mask) * u64(b & lower_mask);
t = r.lo >> bits_in_dword_2;
r.lo &= u64(lower_mask);
t += u64(a >> bits_in_dword_2) * u64(b & lower_mask);
t += u64(a >> bits_in_dword_2) * u64(b & lower_mask);
r.lo += u64(t & u64(lower_mask)) << bits_in_dword_2;
r.hi = t >> bits_in_dword_2;
t = r.lo >> bits_in_dword_2;
r.hi = t >> bits_in_dword_2;
t = r.lo >> bits_in_dword_2;
r.lo &= u64(lower_mask);
t += u64(b >> bits_in_dword_2) * u64(a & lower_mask);
t += u64(b >> bits_in_dword_2) * u64(a & lower_mask);
r.lo += u64(t & u64(lower_mask)) << bits_in_dword_2;
r.hi += t >> bits_in_dword_2;
r.hi += u64(a >> bits_in_dword_2) * u64(b >> bits_in_dword_2);
@@ -36,7 +36,7 @@ proc __multi3(a, b: u128) -> u128 #cc_c #link_name "__multi3" {
}
proc __u128_mod(a, b: u128) -> u128 #cc_c #link_name "__umodti3" {
var r: u128;
r: u128;
__u128_quo_mod(a, b, &r);
return r;
}
@@ -46,7 +46,7 @@ proc __u128_quo(a, b: u128) -> u128 #cc_c #link_name "__udivti3" {
}
proc __i128_mod(a, b: i128) -> i128 #cc_c #link_name "__modti3" {
var r: i128;
r: i128;
__i128_quo_mod(a, b, &r);
return r;
}
@@ -56,16 +56,16 @@ proc __i128_quo(a, b: i128) -> i128 #cc_c #link_name "__divti3" {
}
proc __i128_quo_mod(a, b: i128, rem: ^i128) -> (quo: i128) #cc_c #link_name "__divmodti4" {
var s: i128;
s: i128;
s = b >> 127;
b = (b~s) - s;
s = a >> 127;
b = (a~s) - s;
var uquo: u128;
var urem = __u128_quo_mod(transmute(u128, a), transmute(u128, b), &uquo);
var iquo = transmute(i128, uquo);
var irem = transmute(i128, urem);
uquo: u128;
urem := __u128_quo_mod(transmute(u128, a), transmute(u128, b), &uquo);
iquo := transmute(i128, uquo);
irem := transmute(i128, urem);
iquo = (iquo~s) - s;
irem = (irem~s) - s;
@@ -75,14 +75,14 @@ proc __i128_quo_mod(a, b: i128, rem: ^i128) -> (quo: i128) #cc_c #link_name "__d
proc __u128_quo_mod(a, b: u128, rem: ^u128) -> (quo: u128) #cc_c #link_name "__udivmodti4" {
var alo, ahi = u64(a), u64(a>>64);
var blo, bhi = u64(b), u64(b>>64);
alo, ahi := u64(a), u64(a>>64);
blo, bhi := u64(b), u64(b>>64);
if b == 0 {
if rem != nil { rem^ = 0; }
return u128(alo/blo);
}
var r, d, x, q: u128 = a, b, 1, 0;
r, d, x, q: u128 = a, b, 1, 0;
for r >= d && (d>>127)&1 == 0 {
x <<= 1;
@@ -106,7 +106,7 @@ proc __u128_quo_mod(a, b: u128, rem: ^u128) -> (quo: u128) #cc_c #link_name "__u
proc __f16_to_f32(f: f16) -> f32 #cc_c #no_inline #link_name "__gnu_h2f_ieee" {
when true {
// Source: https://fgiesen.wordpress.com/2012/03/28/half-to-float-done-quic/
const FP32 = raw_union {u: u32, f: f32};
FP32 :: raw_union {u: u32, f: f32};
magic, was_infnan: FP32;
magic.u = (254-15) << 23;
@@ -130,16 +130,16 @@ proc __f16_to_f32(f: f16) -> f32 #cc_c #no_inline #link_name "__gnu_h2f_ieee" {
proc __f32_to_f16(f_: f32) -> f16 #cc_c #no_inline #link_name "__gnu_f2h_ieee" {
when false {
// Source: https://gist.github.com/rygorous/2156668
const FP16 = raw_union {u: u16, f: f16};
const FP32 = raw_union {u: u32, f: f32};
FP16 :: raw_union {u: u16, f: f16};
FP32 :: raw_union {u: u32, f: f32};
f32infty, f16infty, magic: FP32;
f32infty.u = 255<<23;
f16infty.u = 31<<23;
magic.u = 15<<23;
const sign_mask = u32(0x80000000);
const round_mask = ~u32(0x0fff);
sign_mask :: u32(0x80000000);
round_mask :: ~u32(0x0fff);
f := transmute(FP32, f_);
core/atomics.odin
+7 -7
View File
@@ -2,7 +2,7 @@
// Inline vs external file?
import win32 "sys/windows.odin" when ODIN_OS == "windows";
var _ = compile_assert(ODIN_ARCH == "amd64"); // TODO(bill): x86 version
_ := compile_assert(ODIN_ARCH == "amd64"); // TODO(bill): x86 version
proc yield_thread() { win32.mm_pause(); }
@@ -34,8 +34,8 @@ proc fetch_or(a: ^i32, operand: i32) -> i32 {
return win32.interlocked_or(a, operand);
}
proc spin_lock(a: ^i32, time_out: int) -> bool { // NOTE(bill) time_out = -1 as default
var old_value = compare_exchange(a, 1, 0);
var counter = 0;
old_value := compare_exchange(a, 1, 0);
counter := 0;
for old_value != 0 && (time_out < 0 || counter < time_out) {
counter++;
yield_thread();
@@ -50,7 +50,7 @@ proc spin_unlock(a: ^i32) {
}
proc try_acquire_lock(a: ^i32) -> bool {
yield_thread();
var old_value = compare_exchange(a, 1, 0);
old_value := compare_exchange(a, 1, 0);
mfence();
return old_value == 0;
}
@@ -78,8 +78,8 @@ proc fetch_or(a: ^i64, operand: i64) -> i64 {
return win32.interlocked_or64(a, operand);
}
proc spin_lock(a: ^i64, time_out: int) -> bool { // NOTE(bill) time_out = -1 as default
var old_value = compare_exchange(a, 1, 0);
var counter = 0;
old_value := compare_exchange(a, 1, 0);
counter := 0;
for old_value != 0 && (time_out < 0 || counter < time_out) {
counter++;
yield_thread();
@@ -94,7 +94,7 @@ proc spin_unlock(a: ^i64) {
}
proc try_acquire_lock(a: ^i64) -> bool {
yield_thread();
var old_value = compare_exchange(a, 1, 0);
old_value := compare_exchange(a, 1, 0);
mfence();
return old_value == 0;
}
core/bits.odin
+32 -34
View File
@@ -1,28 +1,26 @@
const (
U8_MIN = u8(0);
U16_MIN = u16(0);
U32_MIN = u32(0);
U64_MIN = u64(0);
U128_MIN = u128(0);
U8_MIN :: u8(0);
U16_MIN :: u16(0);
U32_MIN :: u32(0);
U64_MIN :: u64(0);
U128_MIN :: u128(0);
I8_MIN = i8(-0x80);
I16_MIN = i16(-0x8000);
I32_MIN = i32(-0x8000_0000);
I64_MIN = i64(-0x8000_0000_0000_0000);
I128_MIN = i128(-0x8000_0000_0000_0000_0000_0000_0000_0000);
I8_MIN :: i8(-0x80);
I16_MIN :: i16(-0x8000);
I32_MIN :: i32(-0x8000_0000);
I64_MIN :: i64(-0x8000_0000_0000_0000);
I128_MIN :: i128(-0x8000_0000_0000_0000_0000_0000_0000_0000);
U8_MAX = ~u8(0);
U16_MAX = ~u16(0);
U32_MAX = ~u32(0);
U64_MAX = ~u64(0);
U128_MAX = ~u128(0);
U8_MAX :: ~u8(0);
U16_MAX :: ~u16(0);
U32_MAX :: ~u32(0);
U64_MAX :: ~u64(0);
U128_MAX :: ~u128(0);
I8_MAX = i8(0x7f);
I16_MAX = i16(0x7fff);
I32_MAX = i32(0x7fff_ffff);
I64_MAX = i64(0x7fff_ffff_ffff_ffff);
I128_MAX = i128(0x7fff_ffff_ffff_ffff_ffff_ffff_ffff_ffff);
)
I8_MAX :: i8(0x7f);
I16_MAX :: i16(0x7fff);
I32_MAX :: i32(0x7fff_ffff);
I64_MAX :: i64(0x7fff_ffff_ffff_ffff);
I128_MAX :: i128(0x7fff_ffff_ffff_ffff_ffff_ffff_ffff_ffff);
proc count_ones(i: u8) -> u8 { foreign __llvm_core proc __llvm_ctpop(u8) -> u8 #link_name "llvm.ctpop.i8"; return __llvm_ctpop(i); }
proc count_ones(i: i8) -> i8 { foreign __llvm_core proc __llvm_ctpop(i8) -> i8 #link_name "llvm.ctpop.i8"; return __llvm_ctpop(i); }
@@ -198,19 +196,19 @@ proc overflowing_add(lhs, rhs: u128) -> (u128, bool) { foreign __llvm_core proc
proc overflowing_add(lhs, rhs: i128) -> (i128, bool) { foreign __llvm_core proc op(i128, i128) -> (i128, bool) #link_name "llvm.sadd.with.overflow.i128"; return op(lhs, rhs); }
proc overflowing_add(lhs, rhs: uint) -> (uint, bool) {
when size_of(uint) == size_of(u32) {
var x, ok = overflowing_add(u32(lhs), u32(rhs));
x, ok := overflowing_add(u32(lhs), u32(rhs));
return uint(x), ok;
} else {
var x, ok = overflowing_add(u64(lhs), u64(rhs));
x, ok := overflowing_add(u64(lhs), u64(rhs));
return uint(x), ok;
}
}
proc overflowing_add(lhs, rhs: int) -> (int, bool) {
when size_of(int) == size_of(i32) {
var x, ok = overflowing_add(i32(lhs), i32(rhs));
x, ok := overflowing_add(i32(lhs), i32(rhs));
return int(x), ok;
} else {
var x, ok = overflowing_add(i64(lhs), i64(rhs));
x, ok := overflowing_add(i64(lhs), i64(rhs));
return int(x), ok;
}
}
@@ -227,19 +225,19 @@ proc overflowing_sub(lhs, rhs: u128) -> (u128, bool) { foreign __llvm_core proc
proc overflowing_sub(lhs, rhs: i128) -> (i128, bool) { foreign __llvm_core proc op(i128, i128) -> (i128, bool) #link_name "llvm.ssub.with.overflow.i128"; return op(lhs, rhs); }
proc overflowing_sub(lhs, rhs: uint) -> (uint, bool) {
when size_of(uint) == size_of(u32) {
var x, ok = overflowing_sub(u32(lhs), u32(rhs));
x, ok := overflowing_sub(u32(lhs), u32(rhs));
return uint(x), ok;
} else {
var x, ok = overflowing_sub(u64(lhs), u64(rhs));
x, ok := overflowing_sub(u64(lhs), u64(rhs));
return uint(x), ok;
}
}
proc overflowing_sub(lhs, rhs: int) -> (int, bool) {
when size_of(int) == size_of(i32) {
var x, ok = overflowing_sub(i32(lhs), i32(rhs));
x, ok := overflowing_sub(i32(lhs), i32(rhs));
return int(x), ok;
} else {
var x, ok = overflowing_sub(i64(lhs), i64(rhs));
x, ok := overflowing_sub(i64(lhs), i64(rhs));
return int(x), ok;
}
}
@@ -256,19 +254,19 @@ proc overflowing_mul(lhs, rhs: u128) -> (u128, bool) { foreign __llvm_core proc
proc overflowing_mul(lhs, rhs: i128) -> (i128, bool) { foreign __llvm_core proc op(i128, i128) -> (i128, bool) #link_name "llvm.smul.with.overflow.i128"; return op(lhs, rhs); }
proc overflowing_mul(lhs, rhs: uint) -> (uint, bool) {
when size_of(uint) == size_of(u32) {
var x, ok = overflowing_mul(u32(lhs), u32(rhs));
x, ok := overflowing_mul(u32(lhs), u32(rhs));
return uint(x), ok;
} else {
var x, ok = overflowing_mul(u64(lhs), u64(rhs));
x, ok := overflowing_mul(u64(lhs), u64(rhs));
return uint(x), ok;
}
}
proc overflowing_mul(lhs, rhs: int) -> (int, bool) {
when size_of(int) == size_of(i32) {
var x, ok = overflowing_mul(i32(lhs), i32(rhs));
x, ok := overflowing_mul(i32(lhs), i32(rhs));
return int(x), ok;
} else {
var x, ok = overflowing_mul(i64(lhs), i64(rhs));
x, ok := overflowing_mul(i64(lhs), i64(rhs));
return int(x), ok;
}
}
core/decimal.odin
+28 -30
View File
@@ -16,7 +16,7 @@ proc decimal_to_string(buf: []u8, a: ^Decimal) -> string {
}
var n = 10 + a.count + abs(a.decimal_point);
n := 10 + a.count + abs(a.decimal_point);
// TODO(bill): make this work with a buffer that's not big enough
assert(len(buf) >= n);
@@ -27,7 +27,7 @@ proc decimal_to_string(buf: []u8, a: ^Decimal) -> string {
return string(buf[0..<1]);
}
var w = 0;
w := 0;
if a.decimal_point <= 0 {
buf[w] = '0'; w++;
buf[w] = '.'; w++;
@@ -57,10 +57,10 @@ proc trim(a: ^Decimal) {
proc assign(a: ^Decimal, i: u64) {
var buf: [32]u8;
var n = 0;
buf: [32]u8;
n := 0;
for i > 0 {
var j = i/10;
j := i/10;
i -= 10*j;
buf[n] = u8('0'+i);
n++;
@@ -79,10 +79,10 @@ proc assign(a: ^Decimal, i: u64) {
proc shift_right(a: ^Decimal, k: uint) {
var r = 0; // read index
var w = 0; // write index
r := 0; // read index
w := 0; // write index
var n: uint;
n: uint;
for ; n>>k == 0; r++ {
if r >= a.count {
if n == 0 {
@@ -96,16 +96,16 @@ proc shift_right(a: ^Decimal, k: uint) {
}
break;
}
var c = uint(a.digits[r]);
c := uint(a.digits[r]);
n = n*10 + c - '0';
}
a.decimal_point -= r-1;
var mask: uint = (1<<k) - 1;
mask: uint = (1<<k) - 1;
for ; r < a.count; r++ {
var c = uint(a.digits[r]);
var dig = n>>k;
c := uint(a.digits[r]);
dig := n>>k;
n &= mask;
a.digits[w] = u8('0' + dig);
w++;
@@ -113,7 +113,7 @@ proc shift_right(a: ^Decimal, k: uint) {
}
for n > 0 {
var dig = n>>k;
dig := n>>k;
n &= mask;
if w < len(a.digits) {
a.digits[w] = u8('0' + dig);
@@ -130,16 +130,16 @@ proc shift_right(a: ^Decimal, k: uint) {
}
proc shift_left(a: ^Decimal, k: uint) {
var delta = int(k/4);
delta := int(k/4);
var r = a.count; // read index
var w = a.count+delta; // write index
r := a.count; // read index
w := a.count+delta; // write index
var n: uint;
n: uint;
for r--; r >= 0; r-- {
n += (uint(a.digits[r]) - '0') << k;
var quo = n/10;
var rem = n - 10*quo;
quo := n/10;
rem := n - 10*quo;
w--;
if w < len(a.digits) {
a.digits[w] = u8('0' + rem);
@@ -150,8 +150,8 @@ proc shift_left(a: ^Decimal, k: uint) {
}
for n > 0 {
var quo = n/10;
var rem = n - 10*quo;
quo := n/10;
rem := n - 10*quo;
w--;
if 0 <= w && w < len(a.digits) {
a.digits[w] = u8('0' + rem);
@@ -168,10 +168,8 @@ proc shift_left(a: ^Decimal, k: uint) {
}
proc shift(a: ^Decimal, k: int) {
const (
uint_size = 8*size_of(uint);
max_shift = uint_size-4;
)
uint_size :: 8*size_of(uint);
max_shift :: uint_size-4;
match {
case a.count == 0:
@@ -215,8 +213,8 @@ proc round(a: ^Decimal, nd: int) {
proc round_up(a: ^Decimal, nd: int) {
if nd < 0 || nd >= a.count { return; }
for var i = nd-1; i >= 0; i-- {
if var c = a.digits[i]; c < '9' {
for i := nd-1; i >= 0; i-- {
if c := a.digits[i]; c < '9' {
a.digits[i]++;
a.count = i+1;
return;
@@ -241,9 +239,9 @@ proc rounded_integer(a: ^Decimal) -> u64 {
if a.decimal_point > 20 {
return 0xffff_ffff_ffff_ffff;
}
var i: int;
var n: u64 = 0;
var m = min(a.decimal_point, a.count);
i: int;
n: u64 = 0;
m := min(a.decimal_point, a.count);
for i = 0; i < m; i++ {
n = n*10 + u64(a.digits[i]-'0');
}
core/fmt.odin
+108 -113
View File
@@ -7,7 +7,7 @@ import (
"raw.odin";
)
const _BUFFER_SIZE = 1<<12;
_BUFFER_SIZE :: 1<<12;
type StringBuffer union {
Static {buf: []u8},
@@ -89,45 +89,45 @@ proc write_rune(buf: ^StringBuffer, r: rune) {
return;
}
var b, n = utf8.encode_rune(r);
b, n := utf8.encode_rune(r);
write_bytes(buf, b[0..<n]);
}
proc write_int(buf: ^StringBuffer, i: i128, base: int) {
var b: [129]u8;
var s = strconv.append_bits(b[0..<0], u128(i), base, true, 128, strconv.digits, 0);
b: [129]u8;
s := strconv.append_bits(b[0..<0], u128(i), base, true, 128, strconv.digits, 0);
write_string(buf, s);
}
proc write_int(buf: ^StringBuffer, i: i64, base: int) {
var b: [129]u8;
var s = strconv.append_bits(b[0..<0], u128(i), base, true, 64, strconv.digits, 0);
b: [129]u8;
s := strconv.append_bits(b[0..<0], u128(i), base, true, 64, strconv.digits, 0);
write_string(buf, s);
}
proc fprint(fd: os.Handle, args: ..any) -> int {
var data: [_BUFFER_SIZE]u8;
var buf = make_string_buffer_from_slice(data[0..<0]);
data: [_BUFFER_SIZE]u8;
buf := make_string_buffer_from_slice(data[0..<0]);
sbprint(&buf, ..args);
var res = string_buffer_data(buf);
res := string_buffer_data(buf);
os.write(fd, res);
return len(res);
}
proc fprintln(fd: os.Handle, args: ..any) -> int {
var data: [_BUFFER_SIZE]u8;
var buf = make_string_buffer_from_slice(data[0..<0]);
data: [_BUFFER_SIZE]u8;
buf := make_string_buffer_from_slice(data[0..<0]);
sbprintln(&buf, ..args);
var res = string_buffer_data(buf);
res := string_buffer_data(buf);
os.write(fd, res);
return len(res);
}
proc fprintf(fd: os.Handle, fmt: string, args: ..any) -> int {
var data: [_BUFFER_SIZE]u8;
var buf = make_string_buffer_from_slice(data[0..<0]);
data: [_BUFFER_SIZE]u8;
buf := make_string_buffer_from_slice(data[0..<0]);
sbprintf(&buf, fmt, ..args);
var res = string_buffer_data(buf);
res := string_buffer_data(buf);
os.write(fd, res);
return len(res);
}
@@ -145,17 +145,17 @@ proc printf_err (fmt: string, args: ..any) -> int { return fprintf(os.stderr, f
// aprint* procedures return a string that was allocated with the current context
// They must be freed accordingly
proc aprint(args: ..any) -> string {
var buf = make_string_dynamic_buffer();
buf := make_string_dynamic_buffer();
sbprint(&buf, ..args);
return to_string(buf);
}
proc aprintln(args: ..any) -> string {
var buf = make_string_dynamic_buffer();
buf := make_string_dynamic_buffer();
sbprintln(&buf, ..args);
return to_string(buf);
}
proc aprintf(fmt: string, args: ..any) -> string {
var buf = make_string_dynamic_buffer();
buf := make_string_dynamic_buffer();
sbprintf(&buf, fmt, ..args);
return to_string(buf);
}
@@ -164,15 +164,15 @@ proc aprintf(fmt: string, args: ..any) -> string {
// bprint* procedures return a string that was allocated with the current context
// They must be freed accordingly
proc bprint(buf: []u8, args: ..any) -> string {
var sb = make_string_buffer_from_slice(buf[0..<0..<len(buf)]);
sb := make_string_buffer_from_slice(buf[0..<0..<len(buf)]);
return sbprint(&sb, ..args);
}
proc bprintln(buf: []u8, args: ..any) -> string {
var sb = make_string_buffer_from_slice(buf[0..<0..<len(buf)]);
sb := make_string_buffer_from_slice(buf[0..<0..<len(buf)]);
return sbprintln(&sb, ..args);
}
proc bprintf(buf: []u8, fmt: string, args: ..any) -> string {
var sb = make_string_buffer_from_slice(buf[0..<0..<len(buf)]);
sb := make_string_buffer_from_slice(buf[0..<0..<len(buf)]);
return sbprintf(&sb, fmt, ..args);
}
@@ -182,8 +182,8 @@ proc bprintf(buf: []u8, fmt: string, args: ..any) -> string {
proc fprint_type(fd: os.Handle, info: ^TypeInfo) {
var data: [_BUFFER_SIZE]u8;
var buf = make_string_buffer_from_slice(data[0..<0]);
data: [_BUFFER_SIZE]u8;
buf := make_string_buffer_from_slice(data[0..<0]);
write_type(&buf, info);
os.write(fd, string_buffer_data(buf));
}
@@ -237,7 +237,7 @@ proc write_type(buf: ^StringBuffer, ti: ^TypeInfo) {
if info.params == nil {
write_string(buf, "()");
} else {
var t = info.params.(^Tuple);
t := info.params.(^Tuple);
write_string(buf, "(");
for t, i in t.types {
if i > 0 -> write_string(buf, ", ");
@@ -250,12 +250,12 @@ proc write_type(buf: ^StringBuffer, ti: ^TypeInfo) {
write_type(buf, info.results);
}
case Tuple:
var count = len(info.names);
count := len(info.names);
if count != 1 -> write_string(buf, "(");
for name, i in info.names {
if i > 0 -> write_string(buf, ", ");
var t = info.types[i];
t := info.types[i];
if len(name) > 0 {
write_string(buf, name);
@@ -267,7 +267,7 @@ proc write_type(buf: ^StringBuffer, ti: ^TypeInfo) {
case Array:
write_string(buf, "[");
var fi = FmtInfo{buf = buf};
fi := FmtInfo{buf = buf};
write_int(buf, i64(info.count), 10);
write_string(buf, "]");
write_type(buf, info.elem);
@@ -309,8 +309,8 @@ proc write_type(buf: ^StringBuffer, ti: ^TypeInfo) {
case Union:
write_string(buf, "union {");
var cf = info.common_fields;
var total_count = 0;
cf := info.common_fields;
total_count := 0;
for name, i in cf.names {
if i > 0 -> write_string(buf, ", ");
write_string(buf, name);
@@ -324,13 +324,13 @@ proc write_type(buf: ^StringBuffer, ti: ^TypeInfo) {
write_byte(buf, '{');
defer write_byte(buf, '}');
var variant_type = type_info_base(info.variant_types[i]);
var variant = variant_type.(^Struct);
variant_type := type_info_base(info.variant_types[i]);
variant := variant_type.(^Struct);
var vc = len(variant.names)-len(cf.names);
for j in 0..vc {
vc := len(variant.names)-len(cf.names);
for j in 0..<vc {
if j > 0 -> write_string(buf, ", ");
var index = j + len(cf.names);
index := j + len(cf.names);
write_string(buf, variant.names[index]);
write_string(buf, ": ");
write_type(buf, variant.types[index]);
@@ -382,12 +382,12 @@ proc _parse_int(s: string, offset: int) -> (result: int, offset: int, ok: bool)
return '0' <= r && r <= '9';
}
var result = 0;
var ok = true;
result := 0;
ok := true;
var i = 0;
i := 0;
for i < len(s[offset..]) {
var c = rune(s[offset+i]);
c := rune(s[offset+i]);
if !is_digit(c) -> break;
i++;
@@ -406,7 +406,7 @@ proc _arg_number(fi: ^FmtInfo, arg_index: int, format: string, offset, arg_count
for i in 1..len(format) {
if format[i] == ']' {
var width, new_index, ok = _parse_int(format, 1);
width, new_index, ok := _parse_int(format, 1);
if !ok || new_index != i {
return 0, i+1, false;
}
@@ -422,7 +422,7 @@ proc _arg_number(fi: ^FmtInfo, arg_index: int, format: string, offset, arg_count
return arg_index, offset, false;
}
fi.reordered = true;
var index, width, ok = parse_arg_number(format[offset..]);
index, width, ok := parse_arg_number(format[offset..]);
if ok && 0 <= index && index < arg_count {
return index, offset+width, true;
}
@@ -431,11 +431,11 @@ proc _arg_number(fi: ^FmtInfo, arg_index: int, format: string, offset, arg_count
}
proc int_from_arg(args: []any, arg_index: int) -> (int, int, bool) {
var num = 0;
var new_arg_index = arg_index;
var ok = true;
num := 0;
new_arg_index := arg_index;
ok := true;
if arg_index < len(args) {
var arg = args[arg_index];
arg := args[arg_index];
arg.type_info = type_info_base(arg.type_info);
match i in arg {
case int: num = i;
@@ -484,30 +484,30 @@ proc fmt_bool(using fi: ^FmtInfo, b: bool, verb: rune) {
proc fmt_write_padding(fi: ^FmtInfo, width: int) {
if width <= 0 -> return;
var pad_byte: u8 = fi.space ? ' ' : '0';
pad_byte: u8 = fi.space ? ' ' : '0';
var data = string_buffer_data(fi.buf^);
var count = min(width, cap(data)-len(data));
data := string_buffer_data(fi.buf^);
count := min(width, cap(data)-len(data));
for _ in 0..<count -> write_byte(fi.buf, pad_byte);
}
proc _fmt_int(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: int, digits: string) {
var _, neg = strconv.is_integer_negative(u128(u), is_signed, bit_size);
_, neg := strconv.is_integer_negative(u128(u), is_signed, bit_size);
const BUF_SIZE = 256;
BUF_SIZE :: 256;
if fi.width_set || fi.prec_set {
var width = fi.width + fi.prec + 3; // 3 extra bytes for sign and prefix
width := fi.width + fi.prec + 3; // 3 extra bytes for sign and prefix
if width > BUF_SIZE {
// TODO(bill):????
panic("_fmt_int: buffer overrun. Width and precision too big");
}
}
var prec = 0;
prec := 0;
if fi.prec_set {
prec = fi.prec;
if prec == 0 && u == 0 {
var prev_zero = fi.zero;
prev_zero := fi.zero;
fi.zero = false;
fmt_write_padding(fi, fi.width);
fi.zero = prev_zero;
@@ -528,18 +528,18 @@ proc _fmt_int(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: int,
panic("_fmt_int: unknown base, whoops");
}
var buf: [256]u8;
var start = 0;
buf: [256]u8;
start := 0;
var flags: strconv.IntFlag;
flags: strconv.IntFlag;
if fi.hash && !fi.zero -> flags |= strconv.IntFlag.Prefix;
if fi.plus -> flags |= strconv.IntFlag.Plus;
if fi.space -> flags |= strconv.IntFlag.Space;
var s = strconv.append_bits(buf[start..<start], u128(u), base, is_signed, bit_size, digits, flags);
s := strconv.append_bits(buf[start..<start], u128(u), base, is_signed, bit_size, digits, flags);
if fi.hash && fi.zero {
var c: u8;
c: u8;
match base {
case 2: c = 'b';
case 8: c = 'o';
@@ -553,16 +553,15 @@ proc _fmt_int(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: int,
}
}
var prev_zero = fi.zero;
prev_zero := fi.zero;
defer fi.zero = prev_zero;
fi.zero = false;
_pad(fi, s);
}
var (
__DIGITS_LOWER = "0123456789abcdefx";
__DIGITS_UPPER = "0123456789ABCDEFX";
)
__DIGITS_LOWER := "0123456789abcdefx";
__DIGITS_UPPER := "0123456789ABCDEFX";
proc fmt_rune(fi: ^FmtInfo, r: rune, verb: rune) {
match verb {
@@ -584,7 +583,7 @@ proc fmt_int(fi: ^FmtInfo, u: u128, is_signed: bool, bit_size: int, verb: rune)
case 'c', 'r':
fmt_rune(fi, rune(u), verb);
case 'U':
var r = rune(u);
r := rune(u);
if r < 0 || r > utf8.MAX_RUNE {
fmt_bad_verb(fi, verb);
} else {
@@ -602,7 +601,7 @@ proc _pad(fi: ^FmtInfo, s: string) {
write_string(fi.buf, s);
return;
}
var width = fi.width - utf8.rune_count(s);
width := fi.width - utf8.rune_count(s);
if fi.minus { // right pad
write_string(fi.buf, s);
fmt_write_padding(fi, width);
@@ -618,10 +617,10 @@ proc fmt_float(fi: ^FmtInfo, v: f64, bit_size: int, verb: rune) {
// case 'f', 'F', 'v':
case 'f', 'F', 'v':
var prec: int = fi.prec_set ? fi.prec : 3;
var buf: [386]u8;
prec: int = fi.prec_set ? fi.prec : 3;
buf: [386]u8;
var str = strconv.append_float(buf[1..<1], v, 'f', prec, bit_size);
str := strconv.append_float(buf[1..<1], v, 'f', prec, bit_size);
str = string(buf[0..len(str)]);
if str[1] == '+' || str[1] == '-' {
str = str[1..];
@@ -660,7 +659,7 @@ proc fmt_string(fi: ^FmtInfo, s: string, verb: rune) {
write_string(fi.buf, s);
case 'x', 'X':
var space = fi.space;
space := fi.space;
fi.space = false;
defer fi.space = space;
@@ -682,7 +681,7 @@ proc fmt_pointer(fi: ^FmtInfo, p: rawptr, verb: rune) {
fmt_bad_verb(fi, verb);
return;
}
var u = u128(uint(p));
u := u128(uint(p));
if !fi.hash || verb == 'v' {
write_string(fi.buf, "0x");
}
@@ -705,13 +704,10 @@ proc fmt_enum(fi: ^FmtInfo, v: any, verb: rune) {
case 'd', 'f':
fmt_arg(fi, any{v.data, type_info_base(e.base)}, verb);
case 's', 'v':
var (
i: i128;
f: f64;
ok: bool;
a: any;
)
a = any{v.data, type_info_base(e.base)};
i: i128;
f: f64;
ok: bool;
a := any{v.data, type_info_base(e.base)};
match v in a {
case rune: i = i128(v);
case i8: i = i128(v);
@@ -785,7 +781,7 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
write_string(fi.buf, b.names[i]);
write_string(fi.buf, " = ");
var data = ^u8(v.data) + b.offsets[i];
data := ^u8(v.data) + b.offsets[i];
fmt_arg(fi, any{rawptr(data), b.types[i]}, 'v');
}
write_byte(fi.buf, '}');
@@ -817,29 +813,29 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
for i in 0..<info.count {
if i > 0 -> write_string(fi.buf, ", ");
var data = ^u8(v.data) + i*info.elem_size;
data := ^u8(v.data) + i*info.elem_size;
fmt_arg(fi, any{rawptr(data), info.elem}, verb);
}
case DynamicArray:
write_byte(fi.buf, '[');
defer write_byte(fi.buf, ']');
var array = ^raw.DynamicArray(v.data);
array := ^raw.DynamicArray(v.data);
for i in 0..<array.len {
if i > 0 -> write_string(fi.buf, ", ");
var data = ^u8(array.data) + i*info.elem_size;
data := ^u8(array.data) + i*info.elem_size;
fmt_arg(fi, any{rawptr(data), info.elem}, verb);
}
case Slice:
write_byte(fi.buf, '[');
defer write_byte(fi.buf, ']');
var slice = ^[]u8(v.data);
slice := ^[]u8(v.data);
for _, i in slice {
if i > 0 -> write_string(fi.buf, ", ");
var data = &slice[0] + i*info.elem_size;
data := &slice[0] + i*info.elem_size;
fmt_arg(fi, any{rawptr(data), info.elem}, verb);
}
@@ -850,7 +846,7 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
for i in 0..<info.count {
if i > 0 -> write_string(fi.buf, ", ");
var data = ^u8(v.data) + i*info.elem_size;
data := ^u8(v.data) + i*info.elem_size;
fmt_value(fi, any{rawptr(data), info.elem}, verb);
}
@@ -862,29 +858,29 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
write_string(fi.buf, "map[");
defer write_byte(fi.buf, ']');
var (
entries = &(^raw.DynamicMap(v.data).entries);
gs = type_info_base(info.generated_struct).(^Struct);
ed = type_info_base(gs.types[1]).(^DynamicArray);
entry_type = ed.elem.(^Struct);
entry_size = ed.elem_size;
)
entries := &(^raw.DynamicMap(v.data).entries);
gs := type_info_base(info.generated_struct).(^Struct);
ed := type_info_base(gs.types[1]).(^DynamicArray);
entry_type := ed.elem.(^Struct);
entry_size := ed.elem_size;
for i in 0..<entries.len {
if i > 0 -> write_string(fi.buf, ", ");
var data = ^u8(entries.data) + i*entry_size;
var header = ^__MapEntryHeader(data);
data := ^u8(entries.data) + i*entry_size;
header := ^__MapEntryHeader(data);
if types.is_string(info.key) {
write_string(fi.buf, header.key.str);
} else {
var fi = FmtInfo{buf = fi.buf};
fi := FmtInfo{buf = fi.buf};
fmt_arg(&fi, any{rawptr(&header.key.hash), info.key}, 'v');
}
write_string(fi.buf, "=");
var value = data + entry_type.offsets[2];
value := data + entry_type.offsets[2];
fmt_arg(fi, any{rawptr(value), info.value}, 'v');
}
@@ -899,7 +895,7 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
write_string(fi.buf, info.names[i]);
write_string(fi.buf, " = ");
var data = ^u8(v.data) + info.offsets[i];
data := ^u8(v.data) + info.offsets[i];
fmt_value(fi, any{rawptr(data), info.types[i]}, 'v');
}
@@ -907,13 +903,13 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
write_byte(fi.buf, '{');
defer write_byte(fi.buf, '}');
var cf = info.common_fields;
cf := info.common_fields;
for _, i in cf.names {
if i > 0 -> write_string(fi.buf, ", ");
write_string(fi.buf, cf.names[i]);
write_string(fi.buf, " = ");
var data = ^u8(v.data) + cf.offsets[i];
data := ^u8(v.data) + cf.offsets[i];
fmt_value(fi, any{rawptr(data), cf.types[i]}, 'v');
}
@@ -933,7 +929,7 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
proc fmt_complex(fi: ^FmtInfo, c: complex128, bits: int, verb: rune) {
match verb {
case 'f', 'F', 'v':
var r, i = real(c), imag(c);
r, i := real(c), imag(c);
fmt_float(fi, r, bits/2, verb);
if !fi.plus && i >= 0 {
write_rune(fi.buf, '+');
@@ -963,7 +959,7 @@ proc fmt_arg(fi: ^FmtInfo, arg: any, verb: rune) {
fi.arg = arg;
if verb == 'T' {
var ti = arg.type_info;
ti := arg.type_info;
match a in arg {
case ^TypeInfo: ti = a;
}
@@ -972,7 +968,7 @@ proc fmt_arg(fi: ^FmtInfo, arg: any, verb: rune) {
}
var base_arg = arg;
base_arg := arg;
base_arg.type_info = type_info_base(base_arg.type_info);
match a in base_arg {
case any: fmt_arg(fi, a, verb);
@@ -1011,13 +1007,13 @@ proc fmt_arg(fi: ^FmtInfo, arg: any, verb: rune) {
proc sbprint(buf: ^StringBuffer, args: ..any) -> string {
var fi: FmtInfo;
var prev_string = false;
fi: FmtInfo;
prev_string := false;
fi.buf = buf;
for arg, i in args {
var is_string = arg != nil && types.is_string(arg.type_info);
is_string := arg != nil && types.is_string(arg.type_info);
if i > 0 && !is_string && !prev_string {
write_byte(buf, ' ');
}
@@ -1028,7 +1024,7 @@ proc sbprint(buf: ^StringBuffer, args: ..any) -> string {
}
proc sbprintln(buf: ^StringBuffer, args: ..any) -> string {
var fi: FmtInfo;
fi: FmtInfo;
fi.buf = buf;
for arg, i in args {
@@ -1041,17 +1037,16 @@ proc sbprintln(buf: ^StringBuffer, args: ..any) -> string {
}
proc sbprintf(b: ^StringBuffer, fmt: string, args: ..any) -> string {
var (
end = len(fmt);
arg_index: int = 0;
was_prev_index = false;
fi: FmtInfo;
)
fi: FmtInfo;
arg_index: int = 0;
end := len(fmt);
was_prev_index := false;
for var i = 0; i < end; /**/ {
for i := 0; i < end; /**/ {
fi = FmtInfo{buf = b, good_arg_index = true};
var prev_i = i;
prev_i := i;
for i < end && fmt[i] != '%' {
i++;
}
@@ -1142,7 +1137,7 @@ proc sbprintf(b: ^StringBuffer, fmt: string, args: ..any) -> string {
break;
}
var verb, w = utf8.decode_rune(fmt[i..]);
verb, w := utf8.decode_rune(fmt[i..]);
i += w;
if verb == '%' {
core/hash.odin
+33 -43
View File
@@ -1,12 +1,12 @@
proc crc32(data: []u8) -> u32 {
var result = ~u32(0);
result := ~u32(0);
for b in data {
result = result>>8 ~ _crc32_table[(result ~ u32(b)) & 0xff];
}
return ~result;
}
proc crc64(data: []u8) -> u64 {
var result = ~u64(0);
result := ~u64(0);
for b in data {
result = result>>8 ~ _crc64_table[(result ~ u64(b)) & 0xff];
}
@@ -14,7 +14,7 @@ proc crc64(data: []u8) -> u64 {
}
proc fnv32(data: []u8) -> u32 {
var h: u32 = 0x811c9dc5;
h: u32 = 0x811c9dc5;
for b in data {
h = (h * 0x01000193) ~ u32(b);
}
@@ -22,7 +22,7 @@ proc fnv32(data: []u8) -> u32 {
}
proc fnv64(data: []u8) -> u64 {
var h: u64 = 0xcbf29ce484222325;
h: u64 = 0xcbf29ce484222325;
for b in data {
h = (h * 0x100000001b3) ~ u64(b);
}
@@ -30,7 +30,7 @@ proc fnv64(data: []u8) -> u64 {
}
proc fnv32a(data: []u8) -> u32 {
var h: u32 = 0x811c9dc5;
h: u32 = 0x811c9dc5;
for b in data {
h = (h ~ u32(b)) * 0x01000193;
}
@@ -38,7 +38,7 @@ proc fnv32a(data: []u8) -> u32 {
}
proc fnv64a(data: []u8) -> u64 {
var h: u64 = 0xcbf29ce484222325;
h: u64 = 0xcbf29ce484222325;
for b in data {
h = (h ~ u64(b)) * 0x100000001b3;
}
@@ -46,20 +46,16 @@ proc fnv64a(data: []u8) -> u64 {
}
proc murmur32(data: []u8) -> u32 {
const (
c1_32: u32 = 0xcc9e2d51;
c2_32: u32 = 0x1b873593;
)
c1_32: u32 : 0xcc9e2d51;
c2_32: u32 : 0x1b873593;
var (
h1: u32 = 0;
nblocks = len(data)/4;
p = &data[0];
p1 = p + 4*nblocks;
)
h1: u32 = 0;
nblocks := len(data)/4;
p := &data[0];
p1 := p + 4*nblocks;
for ; p < p1; p += 4 {
var k1 = ^u32(p)^;
k1 := ^u32(p)^;
k1 *= c1_32;
k1 = (k1 << 15) | (k1 >> 17);
@@ -70,8 +66,8 @@ proc murmur32(data: []u8) -> u32 {
h1 = h1*5 + 0xe6546b64;
}
var tail = data[nblocks*4 ..];
var k1: u32;
tail := data[nblocks*4 ..];
k1: u32;
match len(tail)&3 {
case 3:
k1 ~= u32(tail[2]) << 16;
@@ -99,19 +95,17 @@ proc murmur32(data: []u8) -> u32 {
}
proc murmur64(data: []u8) -> u64 {
const SEED = 0x9747b28c;
SEED :: 0x9747b28c;
when size_of(int) == 8 {
const (
m = 0xc6a4a7935bd1e995;
r = 47;
)
m :: 0xc6a4a7935bd1e995;
r :: 47;
var h: u64 = SEED ~ (u64(len(data)) * m);
var data64 = slice_ptr(^u64(&data[0]), len(data)/size_of(u64));
h: u64 = SEED ~ (u64(len(data)) * m);
data64 := slice_ptr(^u64(&data[0]), len(data)/size_of(u64));
for _, i in data64 {
var k = data64[i];
k := data64[i];
k *= m;
k ~= k>>r;
@@ -139,21 +133,17 @@ proc murmur64(data: []u8) -> u64 {
return h;
} else {
const (
m = 0x5bd1e995;
r = 24;
)
m :: 0x5bd1e995;
r :: 24;
var (
h1 = u32(SEED) ~ u32(len(data));
h2 = u32(SEED) >> 32;
data32 = slice_ptr(^u32(&data[0]), len(data)/size_of(u32));
len = len(data);
i = 0;
)
h1 := u32(SEED) ~ u32(len(data));
h2 := u32(SEED) >> 32;
data32 := slice_ptr(^u32(&data[0]), len(data)/size_of(u32));
len := len(data);
i := 0;
for len >= 8 {
var k1, k2: u32;
k1, k2: u32;
k1 = data32[i]; i++;
k1 *= m;
k1 ~= k1>>r;
@@ -172,7 +162,7 @@ proc murmur64(data: []u8) -> u64 {
}
if len >= 4 {
var k1: u32;
k1: u32;
k1 = data32[i]; i++;
k1 *= m;
k1 ~= k1>>r;
@@ -183,7 +173,7 @@ proc murmur64(data: []u8) -> u64 {
}
// TODO(bill): Fix this
#no_bounds_check var data8 = slice_to_bytes(data32[i..])[0..<3];
#no_bounds_check data8 := slice_to_bytes(data32[i..])[0..<3];
match len {
case 3:
h2 ~= u32(data8[2]) << 16;
@@ -210,7 +200,7 @@ proc murmur64(data: []u8) -> u64 {
}
var _crc32_table = [256]u32{
_crc32_table := [256]u32{
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
@@ -276,7 +266,7 @@ var _crc32_table = [256]u32{
0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
};
var _crc64_table = [256]u64{
_crc64_table := [256]u64{
0x0000000000000000, 0x42f0e1eba9ea3693, 0x85e1c3d753d46d26, 0xc711223cfa3e5bb5,
0x493366450e42ecdf, 0x0bc387aea7a8da4c, 0xccd2a5925d9681f9, 0x8e224479f47cb76a,
0x9266cc8a1c85d9be, 0xd0962d61b56fef2d, 0x17870f5d4f51b498, 0x5577eeb6e6bb820b,
core/math.odin
+88 -97
View File
@@ -1,22 +1,21 @@
const (
TAU = 6.28318530717958647692528676655900576;
PI = 3.14159265358979323846264338327950288;
ONE_OVER_TAU = 0.636619772367581343075535053490057448;
ONE_OVER_PI = 0.159154943091895335768883763372514362;
TAU :: 6.28318530717958647692528676655900576;
PI :: 3.14159265358979323846264338327950288;
ONE_OVER_TAU :: 0.636619772367581343075535053490057448;
ONE_OVER_PI :: 0.159154943091895335768883763372514362;
E = 2.71828182845904523536;
SQRT_TWO = 1.41421356237309504880168872420969808;
SQRT_THREE = 1.73205080756887729352744634150587236;
SQRT_FIVE = 2.23606797749978969640917366873127623;
E :: 2.71828182845904523536;
SQRT_TWO :: 1.41421356237309504880168872420969808;
SQRT_THREE :: 1.73205080756887729352744634150587236;
SQRT_FIVE :: 2.23606797749978969640917366873127623;
LOG_TWO = 0.693147180559945309417232121458176568;
LOG_TEN = 2.30258509299404568401799145468436421;
LOG_TWO :: 0.693147180559945309417232121458176568;
LOG_TEN :: 2.30258509299404568401799145468436421;
EPSILON = 1.19209290e-7;
EPSILON :: 1.19209290e-7;
τ :: TAU;
π :: PI;
τ = TAU;
π = PI;
)
type (
Vec2 [vector 2]f32;
Vec3 [vector 3]f32;
@@ -63,16 +62,16 @@ proc sign(x: f64) -> f64 { return x >= 0 ? +1 : -1; }
proc copy_sign(x, y: f32) -> f32 {
var ix = transmute(u32, x);
var iy = transmute(u32, y);
ix := transmute(u32, x);
iy := transmute(u32, y);
ix &= 0x7fff_ffff;
ix |= iy & 0x8000_0000;
return transmute(f32, ix);
}
proc copy_sign(x, y: f64) -> f64 {
var ix = transmute(u64, x);
var iy = transmute(u64, y);
ix := transmute(u64, x);
iy := transmute(u64, y);
ix &= 0x7fff_ffff_ffff_ff;
ix |= iy & 0x8000_0000_0000_0000;
return transmute(f64, ix);
@@ -91,7 +90,7 @@ proc remainder(x, y: f32) -> f32 { return x - round(x/y) * y; }
proc remainder(x, y: f64) -> f64 { return x - round(x/y) * y; }
proc mod(x, y: f32) -> f32 {
var result: f32;
result: f32;
y = abs(y);
result = remainder(abs(x), y);
if sign(result) < 0 {
@@ -100,7 +99,7 @@ proc mod(x, y: f32) -> f32 {
return copy_sign(result, x);
}
proc mod(x, y: f64) -> f64 {
var result: f64;
result: f64;
y = abs(y);
result = remainder(abs(x), y);
if sign(result) < 0 {
@@ -115,13 +114,13 @@ proc to_degrees(radians: f32) -> f32 { return radians * 360 / TAU; }
proc dot(a, b: Vec2) -> f32 { var c = a*b; return c.x + c.y; }
proc dot(a, b: Vec3) -> f32 { var c = a*b; return c.x + c.y + c.z; }
proc dot(a, b: Vec4) -> f32 { var c = a*b; return c.x + c.y + c.z + c.w; }
proc dot(a, b: Vec2) -> f32 { c := a*b; return c.x + c.y; }
proc dot(a, b: Vec3) -> f32 { c := a*b; return c.x + c.y + c.z; }
proc dot(a, b: Vec4) -> f32 { c := a*b; return c.x + c.y + c.z + c.w; }
proc cross(x, y: Vec3) -> Vec3 {
var a = swizzle(x, 1, 2, 0) * swizzle(y, 2, 0, 1);
var b = swizzle(x, 2, 0, 1) * swizzle(y, 1, 2, 0);
a := swizzle(x, 1, 2, 0) * swizzle(y, 2, 0, 1);
b := swizzle(x, 2, 0, 1) * swizzle(y, 1, 2, 0);
return a - b;
}
@@ -135,7 +134,7 @@ proc norm(v: Vec3) -> Vec3 { return v / mag(v); }
proc norm(v: Vec4) -> Vec4 { return v / mag(v); }
proc norm0(v: Vec2) -> Vec2 {
var m = mag(v);
m := mag(v);
if m == 0 {
return 0;
}
@@ -143,7 +142,7 @@ proc norm0(v: Vec2) -> Vec2 {
}
proc norm0(v: Vec3) -> Vec3 {
var m = mag(v);
m := mag(v);
if m == 0 {
return 0;
}
@@ -151,7 +150,7 @@ proc norm0(v: Vec3) -> Vec3 {
}
proc norm0(v: Vec4) -> Vec4 {
var m = mag(v);
m := mag(v);
if m == 0 {
return 0;
}
@@ -179,7 +178,7 @@ proc mat4_transpose(m: Mat4) -> Mat4 {
}
proc mul(a, b: Mat4) -> Mat4 {
var c: Mat4;
c: Mat4;
for j in 0..<4 {
for i in 0..<4 {
c[j][i] = a[0][i]*b[j][0] +
@@ -201,29 +200,28 @@ proc mul(m: Mat4, v: Vec4) -> Vec4 {
}
proc inverse(m: Mat4) -> Mat4 {
var o: Mat4;
o: Mat4;
sf00 := m[2][2] * m[3][3] - m[3][2] * m[2][3];
sf01 := m[2][1] * m[3][3] - m[3][1] * m[2][3];
sf02 := m[2][1] * m[3][2] - m[3][1] * m[2][2];
sf03 := m[2][0] * m[3][3] - m[3][0] * m[2][3];
sf04 := m[2][0] * m[3][2] - m[3][0] * m[2][2];
sf05 := m[2][0] * m[3][1] - m[3][0] * m[2][1];
sf06 := m[1][2] * m[3][3] - m[3][2] * m[1][3];
sf07 := m[1][1] * m[3][3] - m[3][1] * m[1][3];
sf08 := m[1][1] * m[3][2] - m[3][1] * m[1][2];
sf09 := m[1][0] * m[3][3] - m[3][0] * m[1][3];
sf10 := m[1][0] * m[3][2] - m[3][0] * m[1][2];
sf11 := m[1][1] * m[3][3] - m[3][1] * m[1][3];
sf12 := m[1][0] * m[3][1] - m[3][0] * m[1][1];
sf13 := m[1][2] * m[2][3] - m[2][2] * m[1][3];
sf14 := m[1][1] * m[2][3] - m[2][1] * m[1][3];
sf15 := m[1][1] * m[2][2] - m[2][1] * m[1][2];
sf16 := m[1][0] * m[2][3] - m[2][0] * m[1][3];
sf17 := m[1][0] * m[2][2] - m[2][0] * m[1][2];
sf18 := m[1][0] * m[2][1] - m[2][0] * m[1][1];
var (
sf00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
sf01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
sf02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
sf03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
sf04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
sf05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
sf06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
sf07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
sf08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
sf09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
sf10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
sf11 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
sf12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
sf13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
sf14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
sf15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
sf16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
sf17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
sf18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
)
o[0][0] = +(m[1][1] * sf00 - m[1][2] * sf01 + m[1][3] * sf02);
o[0][1] = -(m[1][0] * sf00 - m[1][2] * sf03 + m[1][3] * sf04);
@@ -245,7 +243,7 @@ proc inverse(m: Mat4) -> Mat4 {
o[3][2] = -(m[0][0] * sf14 - m[0][1] * sf16 + m[0][3] * sf18);
o[3][3] = +(m[0][0] * sf15 - m[0][1] * sf17 + m[0][2] * sf18);
var ood = 1.0 / (m[0][0] * o[0][0] +
ood := 1.0 / (m[0][0] * o[0][0] +
m[0][1] * o[0][1] +
m[0][2] * o[0][2] +
m[0][3] * o[0][3]);
@@ -272,7 +270,7 @@ proc inverse(m: Mat4) -> Mat4 {
proc mat4_translate(v: Vec3) -> Mat4 {
var m = mat4_identity();
m := mat4_identity();
m[3][0] = v.x;
m[3][1] = v.y;
m[3][2] = v.z;
@@ -281,15 +279,13 @@ proc mat4_translate(v: Vec3) -> Mat4 {
}
proc mat4_rotate(v: Vec3, angle_radians: f32) -> Mat4 {
var (
c = cos(angle_radians);
s = sin(angle_radians);
c := cos(angle_radians);
s := sin(angle_radians);
a = norm(v);
t = a * (1-c);
a := norm(v);
t := a * (1-c);
rot = mat4_identity();
)
rot := mat4_identity();
rot[0][0] = c + t.x*a.x;
rot[0][1] = 0 + t.x*a.y + s*a.z;
@@ -325,11 +321,9 @@ proc scale(m: Mat4, s: f32) -> Mat4 {
proc look_at(eye, centre, up: Vec3) -> Mat4 {
var (
f = norm(centre - eye);
s = norm(cross(f, up));
u = cross(s, f);
)
f := norm(centre - eye);
s := norm(cross(f, up));
u := cross(s, f);
return Mat4{
{+s.x, +u.x, -f.x, 0},
@@ -340,10 +334,9 @@ proc look_at(eye, centre, up: Vec3) -> Mat4 {
}
proc perspective(fovy, aspect, near, far: f32) -> Mat4 {
var (
m: Mat4;
tan_half_fovy = tan(0.5 * fovy);
)
m: Mat4;
tan_half_fovy := tan(0.5 * fovy);
m[0][0] = 1.0 / (aspect*tan_half_fovy);
m[1][1] = 1.0 / (tan_half_fovy);
m[2][2] = -(far + near) / (far - near);
@@ -354,7 +347,7 @@ proc perspective(fovy, aspect, near, far: f32) -> Mat4 {
proc ortho3d(left, right, bottom, top, near, far: f32) -> Mat4 {
var m = mat4_identity();
m := mat4_identity();
m[0][0] = +2.0 / (right - left);
m[1][1] = +2.0 / (top - bottom);
m[2][2] = -2.0 / (far - near);
@@ -367,30 +360,28 @@ proc ortho3d(left, right, bottom, top, near, far: f32) -> Mat4 {
const (
F32_DIG = 6;
F32_EPSILON = 1.192092896e-07;
F32_GUARD = 0;
F32_MANT_DIG = 24;
F32_MAX = 3.402823466e+38;
F32_MAX_10_EXP = 38;
F32_MAX_EXP = 128;
F32_MIN = 1.175494351e-38;
F32_MIN_10_EXP = -37;
F32_MIN_EXP = -125;
F32_NORMALIZE = 0;
F32_RADIX = 2;
F32_ROUNDS = 1;
F32_DIG :: 6;
F32_EPSILON :: 1.192092896e-07;
F32_GUARD :: 0;
F32_MANT_DIG :: 24;
F32_MAX :: 3.402823466e+38;
F32_MAX_10_EXP :: 38;
F32_MAX_EXP :: 128;
F32_MIN :: 1.175494351e-38;
F32_MIN_10_EXP :: -37;
F32_MIN_EXP :: -125;
F32_NORMALIZE :: 0;
F32_RADIX :: 2;
F32_ROUNDS :: 1;
F64_DIG = 15; // # of decimal digits of precision
F64_EPSILON = 2.2204460492503131e-016; // smallest such that 1.0+F64_EPSILON != 1.0
F64_MANT_DIG = 53; // # of bits in mantissa
F64_MAX = 1.7976931348623158e+308; // max value
F64_MAX_10_EXP = 308; // max decimal exponent
F64_MAX_EXP = 1024; // max binary exponent
F64_MIN = 2.2250738585072014e-308; // min positive value
F64_MIN_10_EXP = -307; // min decimal exponent
F64_MIN_EXP = -1021; // min binary exponent
F64_RADIX = 2; // exponent radix
F64_ROUNDS = 1; // addition rounding: near
)
F64_DIG :: 15; // # of decimal digits of precision
F64_EPSILON :: 2.2204460492503131e-016; // smallest such that 1.0+F64_EPSILON != 1.0
F64_MANT_DIG :: 53; // # of bits in mantissa
F64_MAX :: 1.7976931348623158e+308; // max value
F64_MAX_10_EXP :: 308; // max decimal exponent
F64_MAX_EXP :: 1024; // max binary exponent
F64_MIN :: 2.2250738585072014e-308; // min positive value
F64_MIN_10_EXP :: -307; // min decimal exponent
F64_MIN_EXP :: -1021; // min binary exponent
F64_RADIX :: 2; // exponent radix
F64_ROUNDS :: 1; // addition rounding: near
core/mem.odin
+26 -26
View File
@@ -41,9 +41,9 @@ proc is_power_of_two(x: int) -> bool {
proc align_forward(ptr: rawptr, align: int) -> rawptr {
assert(is_power_of_two(align));
var a = uint(align);
var p = uint(ptr);
var modulo = p & (a-1);
a := uint(align);
p := uint(ptr);
modulo := p & (a-1);
if modulo != 0 {
p += a - modulo;
}
@@ -58,9 +58,9 @@ type AllocationHeader struct {
proc allocation_header_fill(header: ^AllocationHeader, data: rawptr, size: int) {
header.size = size;
var ptr = ^int(header+1);
ptr := ^int(header+1);
for var i = 0; rawptr(ptr) < data; i++ {
for i := 0; rawptr(ptr) < data; i++ {
(ptr+i)^ = -1;
}
}
@@ -68,7 +68,7 @@ proc allocation_header(data: rawptr) -> ^AllocationHeader {
if data == nil {
return nil;
}
var p = ^int(data);
p := ^int(data);
for (p-1)^ == -1 {
p = (p-1);
}
@@ -130,20 +130,20 @@ proc arena_allocator_proc(allocator_data: rawptr, mode: AllocatorMode,
size, alignment: int,
old_memory: rawptr, old_size: int, flags: u64) -> rawptr {
using AllocatorMode;
var arena = ^Arena(allocator_data);
arena := ^Arena(allocator_data);
match mode {
case Alloc:
var total_size = size + alignment;
total_size := size + alignment;
if arena.offset + total_size > len(arena.memory) {
fmt.fprintln(os.stderr, "Arena out of memory");
return nil;
}
#no_bounds_check var end = &arena.memory[arena.offset];
#no_bounds_check end := &arena.memory[arena.offset];
var ptr = align_forward(end, alignment);
ptr := align_forward(end, alignment);
arena.offset += total_size;
return zero(ptr, size);
@@ -162,7 +162,7 @@ proc arena_allocator_proc(allocator_data: rawptr, mode: AllocatorMode,
}
proc begin_arena_temp_memory(a: ^Arena) -> ArenaTempMemory {
var tmp: ArenaTempMemory;
tmp: ArenaTempMemory;
tmp.arena = a;
tmp.original_count = len(a.memory);
a.temp_count++;
@@ -196,8 +196,8 @@ proc align_of_type_info(type_info: ^TypeInfo) -> int {
return n - (n >> 1);
}
const WORD_SIZE = size_of(int);
const MAX_ALIGN = size_of([vector 64]f64); // TODO(bill): Should these constants be builtin constants?
WORD_SIZE :: size_of(int);
MAX_ALIGN :: size_of([vector 64]f64); // TODO(bill): Should these constants be builtin constants?
using TypeInfo;
match info in type_info {
case Named:
@@ -223,9 +223,9 @@ proc align_of_type_info(type_info: ^TypeInfo) -> int {
case Slice:
return WORD_SIZE;
case Vector:
var size = size_of_type_info(info.elem);
var count = int(max(prev_pow2(i64(info.count)), 1));
var total = size * count;
size := size_of_type_info(info.elem);
count := int(max(prev_pow2(i64(info.count)), 1));
total := size * count;
return clamp(total, 1, MAX_ALIGN);
case Tuple:
return info.align;
@@ -245,12 +245,12 @@ proc align_of_type_info(type_info: ^TypeInfo) -> int {
}
proc align_formula(size, align: int) -> int {
var result = size + align-1;
result := size + align-1;
return result - result%align;
}
proc size_of_type_info(type_info: ^TypeInfo) -> int {
const WORD_SIZE = size_of(int);
WORD_SIZE :: size_of(int);
using TypeInfo;
match info in type_info {
case Named:
@@ -270,26 +270,26 @@ proc size_of_type_info(type_info: ^TypeInfo) -> int {
case Procedure:
return WORD_SIZE;
case Array:
var count = info.count;
count := info.count;
if count == 0 {
return 0;
}
var size = size_of_type_info(info.elem);
var align = align_of_type_info(info.elem);
var alignment = align_formula(size, align);
size := size_of_type_info(info.elem);
align := align_of_type_info(info.elem);
alignment := align_formula(size, align);
return alignment*(count-1) + size;
case DynamicArray:
return size_of(rawptr) + 2*size_of(int) + size_of(Allocator);
case Slice:
return 2*WORD_SIZE;
case Vector:
var count = info.count;
count := info.count;
if count == 0 {
return 0;
}
var size = size_of_type_info(info.elem);
var align = align_of_type_info(info.elem);
var alignment = align_formula(size, align);
size := size_of_type_info(info.elem);
align := align_of_type_info(info.elem);
alignment := align_formula(size, align);
return alignment*(count-1) + size;
case Struct:
return info.size;
core/opengl.odin
+5 -5
View File
@@ -39,7 +39,7 @@ foreign lib {
proc _string_data(s: string) -> ^u8 #inline { return &s[0]; }
var _libgl = win32.load_library_a(_string_data("opengl32.dll\x00"));
_libgl := win32.load_library_a(_string_data("opengl32.dll\x00"));
proc get_proc_address(name: string) -> rawptr {
if name[len(name)-1] == 0 {
@@ -47,14 +47,14 @@ proc get_proc_address(name: string) -> rawptr {
}
// NOTE(bill): null terminated
assert((&name[0] + len(name))^ == 0);
var res = wgl.get_proc_address(&name[0]);
res := wgl.get_proc_address(&name[0]);
if res == nil {
res = win32.get_proc_address(_libgl, &name[0]);
}
return rawptr(res);
}
var (
// Procedures
GenBuffers: proc(count: i32, buffers: ^u32) #cc_c;
GenVertexArrays: proc(count: i32, buffers: ^u32) #cc_c;
GenSamplers: proc(count: i32, buffers: ^u32) #cc_c;
@@ -114,11 +114,11 @@ var (
UniformMatrix4fv: proc(loc: i32, count: u32, transpose: i32, value: ^f32) #cc_c;
GetUniformLocation: proc(program: u32, name: ^u8) -> i32 #cc_c;
)
proc init() {
proc set_proc_address(p: rawptr, name: string) #inline {
var x = ^rawptr(p);
x := ^rawptr(p);
x^ = get_proc_address(name);
}
core/opengl_constants.odin
+1365 -1367
View File
File diff suppressed because it is too large Load Diff
core/os.odin
+6 -6
View File
@@ -9,13 +9,13 @@ proc write_string(fd: Handle, str: string) -> (int, Errno) {
}
proc read_entire_file(name: string) -> ([]u8, bool) {
var fd, err = open(name, O_RDONLY, 0);
fd, err := open(name, O_RDONLY, 0);
if err != 0 {
return nil, false;
}
defer close(fd);
var length: i64;
length: i64;
if length, err = file_size(fd); err != 0 {
return nil, false;
}
@@ -24,12 +24,12 @@ proc read_entire_file(name: string) -> ([]u8, bool) {
return nil, true;
}
var data = make([]u8, length);
data := make([]u8, length);
if data == nil {
return nil, false;
}
var bytes_read, read_err = read(fd, data);
bytes_read, read_err := read(fd, data);
if read_err != 0 {
free(data);
return nil, false;
@@ -38,12 +38,12 @@ proc read_entire_file(name: string) -> ([]u8, bool) {
}
proc write_entire_file(name: string, data: []u8) -> bool {
var fd, err = open(name, O_WRONLY, 0);
fd, err := open(name, O_WRONLY, 0);
if err != 0 {
return false;
}
defer close(fd);
var bytes_written, write_err = write(fd, data);
bytes_written, write_err := write(fd, data);
return write_err != 0;
}
core/os_linux.odin
+80 -86
View File
@@ -10,40 +10,37 @@ type (
Errno i32;
)
const (
O_RDONLY = 0x00000;
O_WRONLY = 0x00001;
O_RDWR = 0x00002;
O_CREAT = 0x00040;
O_EXCL = 0x00080;
O_NOCTTY = 0x00100;
O_TRUNC = 0x00200;
O_NONBLOCK = 0x00800;
O_APPEND = 0x00400;
O_SYNC = 0x01000;
O_ASYNC = 0x02000;
O_CLOEXEC = 0x80000;
)
const (
SEEK_SET = 0;
SEEK_CUR = 1;
SEEK_END = 2;
SEEK_DATA = 3;
SEEK_HOLE = 4;
SEEK_MAX = SEEK_HOLE;
)
const (
// NOTE(zangent): These are OS specific!
// Do not mix these up!
RTLD_LAZY = 0x001;
RTLD_NOW = 0x002;
RTLD_BINDING_MASK = 0x3;
RTLD_GLOBAL = 0x100;
)
O_RDONLY :: 0x00000;
O_WRONLY :: 0x00001;
O_RDWR :: 0x00002;
O_CREAT :: 0x00040;
O_EXCL :: 0x00080;
O_NOCTTY :: 0x00100;
O_TRUNC :: 0x00200;
O_NONBLOCK :: 0x00800;
O_APPEND :: 0x00400;
O_SYNC :: 0x01000;
O_ASYNC :: 0x02000;
O_CLOEXEC :: 0x80000;
SEEK_SET :: 0;
SEEK_CUR :: 1;
SEEK_END :: 2;
SEEK_DATA :: 3;
SEEK_HOLE :: 4;
SEEK_MAX :: SEEK_HOLE;
// NOTE(zangent): These are OS specific!
// Do not mix these up!
RTLD_LAZY :: 0x001;
RTLD_NOW :: 0x002;
RTLD_BINDING_MASK :: 0x3;
RTLD_GLOBAL :: 0x100;
// "Argv" arguments converted to Odin strings
var args = _alloc_command_line_arguments();
args := _alloc_command_line_arguments();
type _FileTime struct #ordered {
seconds: i64,
@@ -80,39 +77,38 @@ type Stat struct #ordered {
};
// File type
const (
S_IFMT = 0170000; // Type of file mask
S_IFIFO = 0010000; // Named pipe (fifo)
S_IFCHR = 0020000; // Character special
S_IFDIR = 0040000; // Directory
S_IFBLK = 0060000; // Block special
S_IFREG = 0100000; // Regular
S_IFLNK = 0120000; // Symbolic link
S_IFSOCK = 0140000; // Socket
S_IFMT :: 0170000; // Type of file mask
S_IFIFO :: 0010000; // Named pipe (fifo)
S_IFCHR :: 0020000; // Character special
S_IFDIR :: 0040000; // Directory
S_IFBLK :: 0060000; // Block special
S_IFREG :: 0100000; // Regular
S_IFLNK :: 0120000; // Symbolic link
S_IFSOCK :: 0140000; // Socket
// File mode
// Read, write, execute/search by owner
S_IRWXU = 0000700; // RWX mask for owner
S_IRUSR = 0000400; // R for owner
S_IWUSR = 0000200; // W for owner
S_IXUSR = 0000100; // X for owner
// File mode
// Read, write, execute/search by owner
S_IRWXU :: 0000700; // RWX mask for owner
S_IRUSR :: 0000400; // R for owner
S_IWUSR :: 0000200; // W for owner
S_IXUSR :: 0000100; // X for owner
// Read, write, execute/search by group
S_IRWXG = 0000070; // RWX mask for group
S_IRGRP = 0000040; // R for group
S_IWGRP = 0000020; // W for group
S_IXGRP = 0000010; // X for group
S_IRWXG :: 0000070; // RWX mask for group
S_IRGRP :: 0000040; // R for group
S_IWGRP :: 0000020; // W for group
S_IXGRP :: 0000010; // X for group
// Read, write, execute/search by others
S_IRWXO = 0000007; // RWX mask for other
S_IROTH = 0000004; // R for other
S_IWOTH = 0000002; // W for other
S_IXOTH = 0000001; // X for other
S_IRWXO :: 0000007; // RWX mask for other
S_IROTH :: 0000004; // R for other
S_IWOTH :: 0000002; // W for other
S_IXOTH :: 0000001; // X for other
S_ISUID :: 0004000; // Set user id on execution
S_ISGID :: 0002000; // Set group id on execution
S_ISVTX :: 0001000; // Directory restrcted delete
S_ISUID = 0004000; // Set user id on execution
S_ISGID = 0002000; // Set group id on execution
S_ISVTX = 0001000; // Directory restrcted delete
)
proc S_ISLNK (m: u32) -> bool #inline {return (m & S_IFMT) == S_IFLNK; }
proc S_ISREG (m: u32) -> bool #inline {return (m & S_IFMT) == S_IFREG; }
@@ -122,12 +118,10 @@ proc S_ISBLK (m: u32) -> bool #inline {return (m & S_IFMT) == S_IFBLK; }
proc S_ISFIFO(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFIFO; }
proc S_ISSOCK(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFSOCK;}
const (
R_OK = 4; // Test for read permission
W_OK = 2; // Test for write permission
X_OK = 1; // Test for execute permission
F_OK = 0; // Test for file existance
)
F_OK :: 0; // Test for file existance
X_OK :: 1; // Test for execute permission
W_OK :: 2; // Test for write permission
R_OK :: 4; // Test for read permission
foreign libc {
proc _unix_open (path: ^u8, mode: int) -> Handle #link_name "open";
@@ -156,8 +150,8 @@ foreign dl {
// TODO(zangent): Change this to just `open` when Bill fixes overloading.
proc open_simple(path: string, mode: int) -> (Handle, Errno) {
var cstr = strings.new_c_string(path);
var handle = _unix_open(cstr, mode);
cstr := strings.new_c_string(path);
handle := _unix_open(cstr, mode);
free(cstr);
if(handle == -1) {
return 0, 1;
@@ -174,49 +168,49 @@ proc close(fd: Handle) {
}
proc read(fd: Handle, data: []u8) -> (int, Errno) {
var sz = _unix_read(fd, &data[0], len(data));
sz := _unix_read(fd, &data[0], len(data));
return sz, 0;
}
proc write(fd: Handle, data: []u8) -> (int, Errno) {
var sz = _unix_write(fd, &data[0], len(data));
sz := _unix_write(fd, &data[0], len(data));
return sz, 0;
}
proc seek(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
var res = _unix_seek(fd, offset, i32(whence));
res := _unix_seek(fd, offset, i32(whence));
return res, 0;
}
proc file_size(fd: Handle) -> (i64, Errno) {
var prev, _ = seek(fd, 0, SEEK_CUR);
var size, err = seek(fd, 0, SEEK_END);
prev, _ := seek(fd, 0, SEEK_CUR);
size, err := seek(fd, 0, SEEK_END);
seek(fd, prev, SEEK_SET);
return size, err;
}
// NOTE(bill): Uses startup to initialize it
var (
stdin: Handle = 0;
stdout: Handle = 1;
stderr: Handle = 2;
)
stdin: Handle = 0;
stdout: Handle = 1;
stderr: Handle = 2;
/* TODO(zangent): Implement these!
proc last_write_time(fd: Handle) -> FileTime {}
proc last_write_time_by_name(name: string) -> FileTime {}
*/
proc stat(path: string) -> (Stat, int) #inline {
var s: Stat;
var cstr = strings.new_c_string(path);
s: Stat;
cstr := strings.new_c_string(path);
defer free(cstr);
var ret_int = _unix_stat(cstr, &s);
ret_int := _unix_stat(cstr, &s);
return s, int(ret_int);
}
proc access(path: string, mask: int) -> bool #inline {
var cstr = strings.new_c_string(path);
cstr := strings.new_c_string(path);
defer free(cstr);
return _unix_access(cstr, mask) == 0;
}
@@ -235,8 +229,8 @@ proc heap_free(ptr: rawptr) {
}
proc getenv(name: string) -> (string, bool) {
var path_str = strings.new_c_string(name);
var cstr: ^u8 = _unix_getenv(path_str);
path_str := strings.new_c_string(name);
cstr: ^u8 = _unix_getenv(path_str);
free(path_str);
if(cstr == nil) {
return "", false;
@@ -254,15 +248,15 @@ proc current_thread_id() -> int {
}
proc dlopen(filename: string, flags: int) -> rawptr #inline {
var cstr = strings.new_c_string(filename);
var handle = _unix_dlopen(cstr, flags);
cstr := strings.new_c_string(filename);
handle := _unix_dlopen(cstr, flags);
free(cstr);
return handle;
}
proc dlsym(handle: rawptr, symbol: string) -> (proc() #cc_c) #inline {
assert(handle != nil);
var cstr = strings.new_c_string(symbol);
var proc_handle = _unix_dlsym(handle, cstr);
cstr := strings.new_c_string(symbol);
proc_handle := _unix_dlsym(handle, cstr);
free(cstr);
return proc_handle;
}
core/os_windows.odin
+95 -96
View File
@@ -5,56 +5,55 @@ type (
FileTime u64;
)
const INVALID_HANDLE: Handle = -1;
INVALID_HANDLE: Handle : -1;
const (
O_RDONLY = 0x00000;
O_WRONLY = 0x00001;
O_RDWR = 0x00002;
O_CREAT = 0x00040;
O_EXCL = 0x00080;
O_NOCTTY = 0x00100;
O_TRUNC = 0x00200;
O_NONBLOCK = 0x00800;
O_APPEND = 0x00400;
O_SYNC = 0x01000;
O_ASYNC = 0x02000;
O_CLOEXEC = 0x80000;
)
O_RDONLY :: 0x00000;
O_WRONLY :: 0x00001;
O_RDWR :: 0x00002;
O_CREAT :: 0x00040;
O_EXCL :: 0x00080;
O_NOCTTY :: 0x00100;
O_TRUNC :: 0x00200;
O_NONBLOCK :: 0x00800;
O_APPEND :: 0x00400;
O_SYNC :: 0x01000;
O_ASYNC :: 0x02000;
O_CLOEXEC :: 0x80000;
type Errno int;
const (
ERROR_NONE: Errno = 0;
ERROR_FILE_NOT_FOUND = 2;
ERROR_PATH_NOT_FOUND = 3;
ERROR_ACCESS_DENIED = 5;
ERROR_NO_MORE_FILES = 18;
ERROR_HANDLE_EOF = 38;
ERROR_NETNAME_DELETED = 64;
ERROR_FILE_EXISTS = 80;
ERROR_BROKEN_PIPE = 109;
ERROR_BUFFER_OVERFLOW = 111;
ERROR_INSUFFICIENT_BUFFER = 122;
ERROR_MOD_NOT_FOUND = 126;
ERROR_PROC_NOT_FOUND = 127;
ERROR_DIR_NOT_EMPTY = 145;
ERROR_ALREADY_EXISTS = 183;
ERROR_ENVVAR_NOT_FOUND = 203;
ERROR_MORE_DATA = 234;
ERROR_OPERATION_ABORTED = 995;
ERROR_IO_PENDING = 997;
ERROR_NOT_FOUND = 1168;
ERROR_PRIVILEGE_NOT_HELD = 1314;
WSAEACCES = 10013;
WSAECONNRESET = 10054;
// Windows reserves errors >= 1<<29 for application use
ERROR_FILE_IS_PIPE = 1<<29 + 0;
)
ERROR_NONE: Errno : 0;
ERROR_FILE_NOT_FOUND: Errno : 2;
ERROR_PATH_NOT_FOUND: Errno : 3;
ERROR_ACCESS_DENIED: Errno : 5;
ERROR_NO_MORE_FILES: Errno : 18;
ERROR_HANDLE_EOF: Errno : 38;
ERROR_NETNAME_DELETED: Errno : 64;
ERROR_FILE_EXISTS: Errno : 80;
ERROR_BROKEN_PIPE: Errno : 109;
ERROR_BUFFER_OVERFLOW: Errno : 111;
ERROR_INSUFFICIENT_BUFFER: Errno : 122;
ERROR_MOD_NOT_FOUND: Errno : 126;
ERROR_PROC_NOT_FOUND: Errno : 127;
ERROR_DIR_NOT_EMPTY: Errno : 145;
ERROR_ALREADY_EXISTS: Errno : 183;
ERROR_ENVVAR_NOT_FOUND: Errno : 203;
ERROR_MORE_DATA: Errno : 234;
ERROR_OPERATION_ABORTED: Errno : 995;
ERROR_IO_PENDING: Errno : 997;
ERROR_NOT_FOUND: Errno : 1168;
ERROR_PRIVILEGE_NOT_HELD: Errno : 1314;
WSAEACCES: Errno : 10013;
WSAECONNRESET: Errno : 10054;
// Windows reserves errors >= 1<<29 for application use
ERROR_FILE_IS_PIPE: Errno : 1<<29 + 0;
// "Argv" arguments converted to Odin strings
var args = _alloc_command_line_arguments();
args := _alloc_command_line_arguments();
proc open(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errno) {
@@ -62,7 +61,7 @@ proc open(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errno)
return INVALID_HANDLE, ERROR_FILE_NOT_FOUND;
}
var access: u32;
access: u32;
match mode & (O_RDONLY|O_WRONLY|O_RDWR) {
case O_RDONLY: access = win32.FILE_GENERIC_READ;
case O_WRONLY: access = win32.FILE_GENERIC_WRITE;
@@ -77,14 +76,14 @@ proc open(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errno)
access |= win32.FILE_APPEND_DATA;
}
var share_mode = u32(win32.FILE_SHARE_READ|win32.FILE_SHARE_WRITE);
var sa: ^win32.Security_Attributes = nil;
var sa_inherit = win32.Security_Attributes{length = size_of(win32.Security_Attributes), inherit_handle = 1};
share_mode := u32(win32.FILE_SHARE_READ|win32.FILE_SHARE_WRITE);
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;
}
var create_mode: u32;
create_mode: u32;
match {
case mode&(O_CREAT|O_EXCL) == (O_CREAT | O_EXCL):
create_mode = win32.CREATE_NEW;
@@ -98,14 +97,14 @@ proc open(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errno)
create_mode = win32.OPEN_EXISTING;
}
var buf: [300]u8;
buf: [300]u8;
copy(buf[..], []u8(path));
var handle = Handle(win32.create_file_a(&buf[0], access, share_mode, sa, create_mode, win32.FILE_ATTRIBUTE_NORMAL, nil));
handle := Handle(win32.create_file_a(&buf[0], access, share_mode, sa, create_mode, win32.FILE_ATTRIBUTE_NORMAL, nil));
if handle != INVALID_HANDLE {
return handle, ERROR_NONE;
}
var err = win32.get_last_error();
err := win32.get_last_error();
return INVALID_HANDLE, Errno(err);
}
@@ -118,22 +117,22 @@ proc write(fd: Handle, data: []u8) -> (int, Errno) {
if len(data) == 0 {
return 0, ERROR_NONE;
}
var single_write_length: i32;
var total_write: i64;
var length = i64(len(data));
single_write_length: i32;
total_write: i64;
length := i64(len(data));
for total_write < length {
var remaining = length - total_write;
var to_read: i32;
const MAX = 1<<31-1;
remaining := length - total_write;
to_read: i32;
MAX :: 1<<31-1;
if remaining <= MAX {
to_read = i32(remaining);
} else {
to_read = MAX;
}
var e = win32.write_file(win32.Handle(fd), &data[total_write], to_read, &single_write_length, nil);
e := win32.write_file(win32.Handle(fd), &data[total_write], to_read, &single_write_length, nil);
if single_write_length <= 0 || e == win32.FALSE {
var err = win32.get_last_error();
err := win32.get_last_error();
return int(total_write), Errno(e);
}
total_write += i64(single_write_length);
@@ -146,23 +145,23 @@ proc read(fd: Handle, data: []u8) -> (int, Errno) {
return 0, ERROR_NONE;
}
var single_read_length: i32;
var total_read: i64;
var length = i64(len(data));
single_read_length: i32;
total_read: i64;
length := i64(len(data));
for total_read < length {
var remaining = length - total_read;
var to_read: u32;
const MAX = 1<<32-1;
remaining := length - total_read;
to_read: u32;
MAX :: 1<<32-1;
if remaining <= MAX {
to_read = u32(remaining);
} else {
to_read = MAX;
}
var e = win32.read_file(win32.Handle(fd), &data[total_read], to_read, &single_read_length, nil);
e := win32.read_file(win32.Handle(fd), &data[total_read], to_read, &single_read_length, nil);
if single_read_length <= 0 || e == win32.FALSE {
var err = win32.get_last_error();
err := win32.get_last_error();
return int(total_read), Errno(e);
}
total_read += i64(single_read_length);
@@ -171,29 +170,29 @@ proc read(fd: Handle, data: []u8) -> (int, Errno) {
}
proc seek(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
var w: u32;
w: u32;
match whence {
case 0: w = win32.FILE_BEGIN;
case 1: w = win32.FILE_CURRENT;
case 2: w = win32.FILE_END;
}
var hi = i32(offset>>32);
var lo = i32(offset);
var ft = win32.get_file_type(win32.Handle(fd));
hi := i32(offset>>32);
lo := i32(offset);
ft := win32.get_file_type(win32.Handle(fd));
if ft == win32.FILE_TYPE_PIPE {
return 0, ERROR_FILE_IS_PIPE;
}
var dw_ptr = win32.set_file_pointer(win32.Handle(fd), lo, &hi, w);
dw_ptr := win32.set_file_pointer(win32.Handle(fd), lo, &hi, w);
if dw_ptr == win32.INVALID_SET_FILE_POINTER {
var err = win32.get_last_error();
err := win32.get_last_error();
return 0, Errno(err);
}
return i64(hi)<<32 + i64(dw_ptr), ERROR_NONE;
}
proc file_size(fd: Handle) -> (i64, Errno) {
var length: i64;
var err: Errno;
length: i64;
err: Errno;
if win32.get_file_size_ex(win32.Handle(fd), &length) == 0 {
err = Errno(win32.get_last_error());
}
@@ -203,13 +202,13 @@ proc file_size(fd: Handle) -> (i64, Errno) {
// NOTE(bill): Uses startup to initialize it
var stdin = get_std_handle(win32.STD_INPUT_HANDLE);
var stdout = get_std_handle(win32.STD_OUTPUT_HANDLE);
var stderr = get_std_handle(win32.STD_ERROR_HANDLE);
stdin := get_std_handle(win32.STD_INPUT_HANDLE);
stdout := get_std_handle(win32.STD_OUTPUT_HANDLE);
stderr := get_std_handle(win32.STD_ERROR_HANDLE);
proc get_std_handle(h: int) -> Handle {
var fd = win32.get_std_handle(i32(h));
fd := win32.get_std_handle(i32(h));
win32.set_handle_information(fd, win32.HANDLE_FLAG_INHERIT, 0);
return Handle(fd);
}
@@ -220,17 +219,17 @@ proc get_std_handle(h: int) -> Handle {
proc last_write_time(fd: Handle) -> FileTime {
var file_info: win32.ByHandleFileInformation;
file_info: win32.ByHandleFileInformation;
win32.get_file_information_by_handle(win32.Handle(fd), &file_info);
var lo = FileTime(file_info.last_write_time.lo);
var hi = FileTime(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;
}
proc last_write_time_by_name(name: string) -> FileTime {
var last_write_time: win32.Filetime;
var data: win32.FileAttributeData;
var buf: [1024]u8;
last_write_time: win32.Filetime;
data: win32.FileAttributeData;
buf: [1024]u8;
assert(len(buf) > len(name));
@@ -240,8 +239,8 @@ proc last_write_time_by_name(name: string) -> FileTime {
last_write_time = data.last_write_time;
}
var l = FileTime(last_write_time.lo);
var h = FileTime(last_write_time.hi);
l := FileTime(last_write_time.lo);
h := FileTime(last_write_time.hi);
return l | h << 32;
}
@@ -283,15 +282,15 @@ proc current_thread_id() -> int {
proc _alloc_command_line_arguments() -> []string {
proc alloc_ucs2_to_utf8(wstr: ^u16) -> string {
var wstr_len = 0;
wstr_len := 0;
for (wstr+wstr_len)^ != 0 {
wstr_len++;
}
var len = 2*wstr_len-1;
var buf = make([]u8, len+1);
var str = slice_ptr(wstr, wstr_len+1);
len := 2*wstr_len-1;
buf := make([]u8, len+1);
str := slice_ptr(wstr, wstr_len+1);
var i, j = 0, 0;
i, j := 0, 0;
for str[j] != 0 {
match {
case str[j] < 0x80:
@@ -311,7 +310,7 @@ proc _alloc_command_line_arguments() -> []string {
if i+4 > len {
return "";
}
var 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++;
buf[i] = u8(0x80 + ((c >> 12) & 0x3f)); i++;
buf[i] = u8(0x80 + ((c >> 6) & 0x3f)); i++;
@@ -333,9 +332,9 @@ proc _alloc_command_line_arguments() -> []string {
return string(buf[0..<i]);
}
var arg_count: i32;
var arg_list_ptr = win32.command_line_to_argv_w(win32.get_command_line_w(), &arg_count);
var arg_list = make([]string, arg_count);
arg_count: i32;
arg_list_ptr := win32.command_line_to_argv_w(win32.get_command_line_w(), &arg_count);
arg_list := make([]string, arg_count);
for _, i in arg_list {
arg_list[i] = alloc_ucs2_to_utf8((arg_list_ptr+i)^);
}
core/os_x.odin
+86 -91
View File
@@ -13,42 +13,42 @@ type (
AddressSize int;
)
const (
O_RDONLY = 0x00000;
O_WRONLY = 0x00001;
O_RDWR = 0x00002;
O_CREAT = 0x00040;
O_EXCL = 0x00080;
O_NOCTTY = 0x00100;
O_TRUNC = 0x00200;
O_NONBLOCK = 0x00800;
O_APPEND = 0x00400;
O_SYNC = 0x01000;
O_ASYNC = 0x02000;
O_CLOEXEC = 0x80000;
)
const (
SEEK_SET = 0;
SEEK_CUR = 1;
SEEK_END = 2;
SEEK_DATA = 3;
SEEK_HOLE = 4;
SEEK_MAX = SEEK_HOLE;
)
const (
// NOTE(zangent): These are OS specific!
// Do not mix these up!
RTLD_LAZY = 0x1;
RTLD_NOW = 0x2;
RTLD_LOCAL = 0x4;
RTLD_GLOBAL = 0x8;
RTLD_NODELETE = 0x80;
RTLD_NOLOAD = 0x10;
RTLD_FIRST = 0x100;
)
O_RDONLY :: 0x00000;
O_WRONLY :: 0x00001;
O_RDWR :: 0x00002;
O_CREAT :: 0x00040;
O_EXCL :: 0x00080;
O_NOCTTY :: 0x00100;
O_TRUNC :: 0x00200;
O_NONBLOCK :: 0x00800;
O_APPEND :: 0x00400;
O_SYNC :: 0x01000;
O_ASYNC :: 0x02000;
O_CLOEXEC :: 0x80000;
var args: [dynamic]string;
SEEK_SET :: 0;
SEEK_CUR :: 1;
SEEK_END :: 2;
SEEK_DATA :: 3;
SEEK_HOLE :: 4;
SEEK_MAX :: SEEK_HOLE;
// NOTE(zangent): These are OS specific!
// Do not mix these up!
RTLD_LAZY :: 0x1;
RTLD_NOW :: 0x2;
RTLD_LOCAL :: 0x4;
RTLD_GLOBAL :: 0x8;
RTLD_NODELETE :: 0x80;
RTLD_NOLOAD :: 0x10;
RTLD_FIRST :: 0x100;
args: [dynamic]string;
type _FileTime struct #ordered {
seconds: i64,
@@ -80,39 +80,37 @@ type Stat struct #ordered {
};
// File type
const (
S_IFMT = 0170000; // Type of file mask
S_IFIFO = 0010000; // Named pipe (fifo)
S_IFCHR = 0020000; // Character special
S_IFDIR = 0040000; // Directory
S_IFBLK = 0060000; // Block special
S_IFREG = 0100000; // Regular
S_IFLNK = 0120000; // Symbolic link
S_IFSOCK = 0140000; // Socket
S_IFMT :: 0170000; // Type of file mask
S_IFIFO :: 0010000; // Named pipe (fifo)
S_IFCHR :: 0020000; // Character special
S_IFDIR :: 0040000; // Directory
S_IFBLK :: 0060000; // Block special
S_IFREG :: 0100000; // Regular
S_IFLNK :: 0120000; // Symbolic link
S_IFSOCK :: 0140000; // Socket
// File mode
// Read, write, execute/search by owner
S_IRWXU = 0000700; // RWX mask for owner
S_IRUSR = 0000400; // R for owner
S_IWUSR = 0000200; // W for owner
S_IXUSR = 0000100; // X for owner
// File mode
// Read, write, execute/search by owner
S_IRWXU :: 0000700; // RWX mask for owner
S_IRUSR :: 0000400; // R for owner
S_IWUSR :: 0000200; // W for owner
S_IXUSR :: 0000100; // X for owner
// Read, write, execute/search by group
S_IRWXG = 0000070; // RWX mask for group
S_IRGRP = 0000040; // R for group
S_IWGRP = 0000020; // W for group
S_IXGRP = 0000010; // X for group
// Read, write, execute/search by group
S_IRWXG :: 0000070; // RWX mask for group
S_IRGRP :: 0000040; // R for group
S_IWGRP :: 0000020; // W for group
S_IXGRP :: 0000010; // X for group
// Read, write, execute/search by others
S_IRWXO = 0000007; // RWX mask for other
S_IROTH = 0000004; // R for other
S_IWOTH = 0000002; // W for other
S_IXOTH = 0000001; // X for other
// Read, write, execute/search by others
S_IRWXO :: 0000007; // RWX mask for other
S_IROTH :: 0000004; // R for other
S_IWOTH :: 0000002; // W for other
S_IXOTH :: 0000001; // X for other
S_ISUID = 0004000; // Set user id on execution
S_ISGID = 0002000; // Set group id on execution
S_ISVTX = 0001000; // Directory restrcted delete
)
S_ISUID :: 0004000; // Set user id on execution
S_ISGID :: 0002000; // Set group id on execution
S_ISVTX :: 0001000; // Directory restrcted delete
proc S_ISLNK (m: u32) -> bool #inline {return (m & S_IFMT) == S_IFLNK; }
proc S_ISREG (m: u32) -> bool #inline {return (m & S_IFMT) == S_IFREG; }
@@ -122,12 +120,10 @@ proc S_ISBLK (m: u32) -> bool #inline {return (m & S_IFMT) == S_IFBLK; }
proc S_ISFIFO(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFIFO; }
proc S_ISSOCK(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFSOCK;}
const (
R_OK = 4; // Test for read permission
W_OK = 2; // Test for write permission
X_OK = 1; // Test for execute permission
F_OK = 0; // Test for file existance
)
R_OK :: 4; // Test for read permission
W_OK :: 2; // Test for write permission
X_OK :: 1; // Test for execute permission
F_OK :: 0; // Test for file existance
foreign libc {
proc unix_open (path: ^u8, mode: int) -> Handle #link_name "open";
@@ -157,8 +153,8 @@ foreign dl {
// TODO(zangent): Change this to just `open` when Bill fixes overloading.
proc open_simple(path: string, mode: int) -> (Handle, Errno) {
var cstr = strings.new_c_string(path);
var handle = unix_open(cstr, mode);
cstr := strings.new_c_string(path);
handle := unix_open(cstr, mode);
free(cstr);
if(handle == -1) {
return 0, 1;
@@ -178,7 +174,7 @@ proc close(fd: Handle) {
proc write(fd: Handle, data: []u8) -> (AddressSize, Errno) {
assert(fd != -1);
var bytes_written = unix_write(fd, &data[0], len(data));
bytes_written := unix_write(fd, &data[0], len(data));
if(bytes_written == -1) {
return 0, 1;
}
@@ -188,7 +184,7 @@ proc write(fd: Handle, data: []u8) -> (AddressSize, Errno) {
proc read(fd: Handle, data: []u8) -> (AddressSize, Errno) {
assert(fd != -1);
var bytes_read = unix_read(fd, &data[0], len(data));
bytes_read := unix_read(fd, &data[0], len(data));
if(bytes_read == -1) {
return 0, 1;
}
@@ -198,7 +194,7 @@ proc read(fd: Handle, data: []u8) -> (AddressSize, Errno) {
proc seek(fd: Handle, offset: AddressSize, whence: int) -> (AddressSize, Errno) {
assert(fd != -1);
var final_offset = unix_lseek(fd, offset, whence);
final_offset := unix_lseek(fd, offset, whence);
if(final_offset == -1) {
return 0, 1;
}
@@ -206,8 +202,8 @@ proc seek(fd: Handle, offset: AddressSize, whence: int) -> (AddressSize, Errno)
}
proc file_size(fd: Handle) -> (i64, Errno) {
var prev, _ = seek(fd, 0, SEEK_CUR);
var size, err = seek(fd, 0, SEEK_END);
prev, _ := seek(fd, 0, SEEK_CUR);
size, err := seek(fd, 0, SEEK_END);
seek(fd, prev, SEEK_SET);
return size, err;
}
@@ -215,26 +211,25 @@ proc file_size(fd: Handle) -> (i64, Errno) {
// NOTE(bill): Uses startup to initialize it
var (
stdin: Handle = 0; // get_std_handle(win32.STD_INPUT_HANDLE);
stdout: Handle = 1; // get_std_handle(win32.STD_OUTPUT_HANDLE);
stderr: Handle = 2; // get_std_handle(win32.STD_ERROR_HANDLE);
)
stdin: Handle = 0; // get_std_handle(win32.STD_INPUT_HANDLE);
stdout: Handle = 1; // get_std_handle(win32.STD_OUTPUT_HANDLE);
stderr: Handle = 2; // get_std_handle(win32.STD_ERROR_HANDLE);
/* TODO(zangent): Implement these!
proc last_write_time(fd: Handle) -> FileTime {}
proc last_write_time_by_name(name: string) -> FileTime {}
*/
proc stat(path: string) -> (Stat, bool) #inline {
var s: Stat;
var cstr = strings.new_c_string(path);
s: Stat;
cstr := strings.new_c_string(path);
defer free(cstr);
var ret_int = unix_stat(cstr, &s);
ret_int := unix_stat(cstr, &s);
return s, ret_int==0;
}
proc access(path: string, mask: int) -> bool #inline {
var cstr = strings.new_c_string(path);
cstr := strings.new_c_string(path);
defer free(cstr);
return unix_access(cstr, mask) == 0;
}
@@ -251,8 +246,8 @@ proc heap_free(ptr: rawptr) #inline {
}
proc getenv(name: string) -> (string, bool) {
var path_str = strings.new_c_string(name);
var cstr: ^u8 = unix_getenv(path_str);
path_str := strings.new_c_string(name);
cstr: ^u8 = unix_getenv(path_str);
free(path_str);
if(cstr == nil) {
return "", false;
@@ -271,15 +266,15 @@ proc current_thread_id() -> int {
}
proc dlopen(filename: string, flags: int) -> rawptr #inline {
var cstr = strings.new_c_string(filename);
var handle = unix_dlopen(cstr, flags);
cstr := strings.new_c_string(filename);
handle := unix_dlopen(cstr, flags);
free(cstr);
return handle;
}
proc dlsym(handle: rawptr, symbol: string) -> (proc() #cc_c) #inline {
assert(handle != nil);
var cstr = strings.new_c_string(symbol);
var proc_handle = unix_dlsym(handle, cstr);
cstr := strings.new_c_string(symbol);
proc_handle := unix_dlsym(handle, cstr);
free(cstr);
return proc_handle;
}
core/strconv.odin
+69 -71
View File
@@ -18,8 +18,8 @@ proc parse_bool(s: string) -> (result: bool, ok: bool) {
}
proc _digit_value(r: rune) -> int {
var ri = int(r);
var v: int = 16;
ri := int(r);
v: int = 16;
match r {
case '0'..'9': v = ri-'0';
case 'a'..'z': v = ri-'a'+10;
@@ -29,7 +29,7 @@ proc _digit_value(r: rune) -> int {
}
proc parse_i128(s: string) -> i128 {
var neg = false;
neg := false;
if len(s) > 1 {
match s[0] {
case '-':
@@ -41,7 +41,7 @@ proc parse_i128(s: string) -> i128 {
}
var base: i128 = 10;
base: i128 = 10;
if len(s) > 2 && s[0] == '0' {
match s[1] {
case 'b': base = 2; s = s[2..];
@@ -53,13 +53,13 @@ proc parse_i128(s: string) -> i128 {
}
var value: i128;
value: i128;
for r in s {
if r == '_' {
continue;
}
var v = i128(_digit_value(r));
v := i128(_digit_value(r));
if v >= base {
break;
}
@@ -71,13 +71,13 @@ proc parse_i128(s: string) -> i128 {
}
proc parse_u128(s: string) -> u128 {
var neg = false;
neg := false;
if len(s) > 1 && s[0] == '+' {
s = s[1..];
}
var base = u128(10);
base := u128(10);
if len(s) > 2 && s[0] == '0' {
match s[1] {
case 'b': base = 2; s = s[2..];
@@ -89,13 +89,13 @@ proc parse_u128(s: string) -> u128 {
}
var value: u128;
value: u128;
for r in s {
if r == '_' {
continue;
}
var v = u128(_digit_value(r));
v := u128(_digit_value(r));
if v >= base {
break;
}
@@ -115,21 +115,21 @@ proc parse_uint(s: string, base: int) -> uint {
}
proc parse_f64(s: string) -> f64 {
var i = 0;
i := 0;
var sign: f64 = 1;
sign: f64 = 1;
match s[i] {
case '-': i++; sign = -1;
case '+': i++;
}
var value: f64 = 0;
value: f64 = 0;
for ; i < len(s); i++ {
var r = rune(s[i]);
r := rune(s[i]);
if r == '_' {
continue;
}
var v = _digit_value(r);
v := _digit_value(r);
if v >= 10 {
break;
}
@@ -138,15 +138,15 @@ proc parse_f64(s: string) -> f64 {
}
if s[i] == '.' {
var pow10: f64 = 10;
pow10: f64 = 10;
i++;
for ; i < len(s); i++ {
var r = rune(s[i]);
r := rune(s[i]);
if r == '_' {
continue;
}
var v = _digit_value(r);
v := _digit_value(r);
if v >= 10 {
break;
}
@@ -155,8 +155,8 @@ proc parse_f64(s: string) -> f64 {
}
}
var frac = false;
var scale: f64 = 1;
frac := false;
scale: f64 = 1;
if s[i] == 'e' || s[i] == 'E' {
i++;
@@ -166,13 +166,13 @@ proc parse_f64(s: string) -> f64 {
case '+': i++;
}
var exp: u32 = 0;
exp: u32 = 0;
for ; i < len(s); i++ {
var r = rune(s[i]);
r := rune(s[i]);
if r == '_' {
continue;
}
var d = u32(_digit_value(r));
d := u32(_digit_value(r));
if d >= 10 {
break;
}
@@ -190,7 +190,7 @@ proc parse_f64(s: string) -> f64 {
proc append_bool(buf: []u8, b: bool) -> string {
var s = b ? "true" : "false";
s := b ? "true" : "false";
append(buf, ..[]u8(s));
return string(buf);
}
@@ -210,28 +210,28 @@ proc append_float(buf: []u8, f: f64, fmt: u8, prec, bit_size: int) -> string {
type DecimalSlice struct {
DecimalSlice :: struct {
digits: []u8,
count: int,
decimal_point: int,
neg: bool,
}
type Float_Info struct {
Float_Info :: struct {
mantbits: uint,
expbits: uint,
bias: int,
}
var (
_f16_info = Float_Info{10, 5, -15};
_f32_info = Float_Info{23, 8, -127};
_f64_info = Float_Info{52, 11, -1023};
)
_f16_info := Float_Info{10, 5, -15};
_f32_info := Float_Info{23, 8, -127};
_f64_info := Float_Info{52, 11, -1023};
proc generic_ftoa(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8 {
var bits: u64;
var flt: ^Float_Info;
bits: u64;
flt: ^Float_Info;
match bit_size {
case 32:
bits = u64(transmute(u32, f32(val)));
@@ -243,13 +243,13 @@ proc generic_ftoa(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8 {
panic("strconv: invalid bit_size");
}
var neg = bits>>(flt.expbits+flt.mantbits) != 0;
var exp = int(bits>>flt.mantbits) & (1<<flt.expbits - 1);
var mant = bits & (u64(1) << flt.mantbits - 1);
neg := bits>>(flt.expbits+flt.mantbits) != 0;
exp := int(bits>>flt.mantbits) & (1<<flt.expbits - 1);
mant := bits & (u64(1) << flt.mantbits - 1);
match exp {
case 1<<flt.expbits - 1:
var s: string;
s: string;
if mant != 0 {
s = "NaN";
} else if neg {
@@ -269,12 +269,12 @@ proc generic_ftoa(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8 {
exp += flt.bias;
var d_: Decimal;
var d = &d_;
d_: Decimal;
d := &d_;
assign(d, mant);
shift(d, exp - int(flt.mantbits));
var digs: DecimalSlice;
var shortest = prec < 0;
digs: DecimalSlice;
shortest := prec < 0;
if shortest {
round_shortest(d, mant, exp, flt);
digs = DecimalSlice{digits = d.digits[..], count = d.count, decimal_point = d.decimal_point};
@@ -308,7 +308,7 @@ proc format_digits(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice, pre
// integer, padded with zeros when needed
if digs.decimal_point > 0 {
var m = min(digs.count, digs.decimal_point);
m := min(digs.count, digs.decimal_point);
append(buf, ..digs.digits[0..<m]);
for ; m < digs.decimal_point; m++ {
append(buf, '0');
@@ -322,8 +322,8 @@ proc format_digits(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice, pre
if prec > 0 {
append(buf, '.');
for i in 0..<prec {
var c: u8 = '0';
if var j = digs.decimal_point + i; 0 <= j && j < digs.count {
c: u8 = '0';
if j := digs.decimal_point + i; 0 <= j && j < digs.count {
c = digs.digits[j];
}
append(buf, c);
@@ -341,9 +341,7 @@ proc format_digits(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice, pre
return buf; // TODO
}
var c: [2]u8;
c[0] = '%';
c[1] = fmt;
c := [2]u8{'%', fmt};
append(buf, ..c[..]);
return buf;
}
@@ -360,18 +358,18 @@ proc round_shortest(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
log(2) >~ 0.332
332*(dp-nd) >= 100*(exp-mantbits)
*/
var minexp = flt.bias+1;
minexp := flt.bias+1;
if exp > minexp && 332*(d.decimal_point-d.count) >= 100*(exp - int(flt.mantbits)) {
// Number is already its shortest
return;
}
var upper_: Decimal; var upper = &upper_;
upper_: Decimal; upper := &upper_;
assign(upper, 2*mant - 1);
shift(upper, exp - int(flt.mantbits) - 1);
var mantlo: u64;
var explo: int;
mantlo: u64;
explo: int;
if mant > 1<<flt.mantbits || exp == minexp {
mantlo = mant-1;
explo = exp;
@@ -379,25 +377,25 @@ proc round_shortest(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
mantlo = 2*mant - 1;
explo = exp-1;
}
var lower_: Decimal; var lower = &lower_;
lower_: Decimal; lower := &lower_;
assign(lower, 2*mantlo + 1);
shift(lower, explo - int(flt.mantbits) - 1);
var inclusive = mant%2 == 0;
inclusive := mant%2 == 0;
for i in 0..<d.count {
var l: u8 = '0'; // lower digit
l: u8 = '0'; // lower digit
if i < lower.count {
l = lower.digits[i];
}
var m = d.digits[i]; // middle digit
var u: u8 = '0'; // upper digit
m := d.digits[i]; // middle digit
u: u8 = '0'; // upper digit
if i < upper.count {
u = upper.digits[i];
}
var ok_round_down = l != m || inclusive && i+1 == lower.count;
var ok_round_up = m != u && (inclusive || m+1 < u || i+1 < upper.count);
ok_round_down := l != m || inclusive && i+1 == lower.count;
ok_round_up := m != u && (inclusive || m+1 < u || i+1 < upper.count);
if (ok_round_down && ok_round_up) {
round(d, i+1);
@@ -415,36 +413,36 @@ proc round_shortest(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
}
const MAX_BASE = 32;
var digits = "0123456789abcdefghijklmnopqrstuvwxyz";
MAX_BASE :: 32;
digits := "0123456789abcdefghijklmnopqrstuvwxyz";
proc is_integer_negative(u: u128, is_signed: bool, bit_size: int) -> (unsigned: u128, neg: bool) {
var neg = false;
neg := false;
if is_signed {
match bit_size {
case 8:
var i = i8(u);
i := i8(u);
neg = i < 0;
if neg { i = -i; }
u = u128(i);
case 16:
var i = i16(u);
i := i16(u);
neg = i < 0;
if neg { i = -i; }
u = u128(i);
case 32:
var i = i32(u);
i := i32(u);
neg = i < 0;
if neg { i = -i; }
u = u128(i);
case 64:
var i = i64(u);
i := i64(u);
neg = i < 0;
if neg { i = -i; }
u = u128(i);
case 128:
var i = i128(u);
i := i128(u);
neg = i < 0;
if neg { i = -i; }
u = u128(i);
@@ -460,11 +458,11 @@ proc append_bits(buf: []u8, u: u128, base: int, is_signed: bool, bit_size: int,
panic("strconv: illegal base passed to append_bits");
}
var neg: bool;
var a: [129]u8;
var i = len(a);
neg: bool;
a: [129]u8;
i := len(a);
u, neg = is_integer_negative(u, is_signed, bit_size);
var b = u128(base);
b := u128(base);
for u >= b {
i--; a[i] = digits[uint(u % b)];
u /= b;
@@ -472,7 +470,7 @@ proc append_bits(buf: []u8, u: u128, base: int, is_signed: bool, bit_size: int,
i--; a[i] = digits[uint(u % b)];
if flags&IntFlag.Prefix != 0 {
var ok = true;
ok := true;
match base {
case 2: i--; a[i] = 'b';
case 8: i--; a[i] = 'o';
core/strings.odin
+3 -3
View File
@@ -1,19 +1,19 @@
proc new_string(s: string) -> string {
var c = make([]u8, len(s)+1);
c := make([]u8, len(s)+1);
copy(c, []u8(s));
c[len(s)] = 0;
return string(c[0..<len(s)]);
}
proc new_c_string(s: string) -> ^u8 {
var c = make([]u8, len(s)+1);
c := make([]u8, len(s)+1);
copy(c, []u8(s));
c[len(s)] = 0;
return &c[0];
}
proc to_odin_string(c: ^u8) -> string {
var len = 0;
len := 0;
for (c+len)^ != 0 {
len++;
}
core/sync_linux.odin
+5 -5
View File
@@ -49,7 +49,7 @@ proc mutex_destroy(m: ^Mutex) {
semaphore_destroy(&m._semaphore);
}
proc mutex_lock(m: ^Mutex) {
var thread_id = current_thread_id();
thread_id := current_thread_id();
if atomics.fetch_add(&m._counter, 1) > 0 {
if thread_id != atomics.load(&m._owner) {
semaphore_wait(&m._semaphore);
@@ -59,11 +59,11 @@ proc mutex_lock(m: ^Mutex) {
m._recursion++;
}
proc mutex_try_lock(m: ^Mutex) -> bool {
var thread_id = current_thread_id();
thread_id := current_thread_id();
if atomics.load(&m._owner) == thread_id {
atomics.fetch_add(&m._counter, 1);
} else {
var expected: i32 = 0;
expected: i32 = 0;
if atomics.load(&m._counter) != 0 {
return false;
}
@@ -76,8 +76,8 @@ proc mutex_try_lock(m: ^Mutex) -> bool {
return true;
}
proc mutex_unlock(m: ^Mutex) {
var recursion: i32;
var thread_id = current_thread_id();
recursion: i32;
thread_id := current_thread_id();
assert(thread_id == atomics.load(&m._owner));
m._recursion--;
core/sync_windows.odin
+5 -5
View File
@@ -47,7 +47,7 @@ proc mutex_destroy(m: ^Mutex) {
semaphore_destroy(&m._semaphore);
}
proc mutex_lock(m: ^Mutex) {
var thread_id = current_thread_id();
thread_id := current_thread_id();
if atomics.fetch_add(&m._counter, 1) > 0 {
if thread_id != atomics.load(&m._owner) {
semaphore_wait(&m._semaphore);
@@ -57,11 +57,11 @@ proc mutex_lock(m: ^Mutex) {
m._recursion++;
}
proc mutex_try_lock(m: ^Mutex) -> bool {
var thread_id = current_thread_id();
thread_id := current_thread_id();
if atomics.load(&m._owner) == thread_id {
atomics.fetch_add(&m._counter, 1);
} else {
var expected: i32 = 0;
expected: i32 = 0;
if atomics.load(&m._counter) != 0 {
return false;
}
@@ -74,8 +74,8 @@ proc mutex_try_lock(m: ^Mutex) -> bool {
return true;
}
proc mutex_unlock(m: ^Mutex) {
var recursion: i32;
var thread_id = current_thread_id();
recursion: i32;
thread_id := current_thread_id();
assert(thread_id == atomics.load(&m._owner));
m._recursion--;
core/sys/wgl.odin
+10 -11
View File
@@ -1,15 +1,14 @@
foreign_system_library "opengl32.lib" when ODIN_OS == "windows";
import . "windows.odin";
const (
CONTEXT_MAJOR_VERSION_ARB = 0x2091;
CONTEXT_MINOR_VERSION_ARB = 0x2092;
CONTEXT_FLAGS_ARB = 0x2094;
CONTEXT_PROFILE_MASK_ARB = 0x9126;
CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = 0x0002;
CONTEXT_CORE_PROFILE_BIT_ARB = 0x00000001;
CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = 0x00000002;
)
CONTEXT_MAJOR_VERSION_ARB :: 0x2091;
CONTEXT_MINOR_VERSION_ARB :: 0x2092;
CONTEXT_FLAGS_ARB :: 0x2094;
CONTEXT_PROFILE_MASK_ARB :: 0x9126;
CONTEXT_FORWARD_COMPATIBLE_BIT_ARB :: 0x0002;
CONTEXT_CORE_PROFILE_BIT_ARB :: 0x00000001;
CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB :: 0x00000002;
type (
Hglrc Handle;
@@ -62,12 +61,12 @@ type (
GetExtensionsStringARBType proc(Hdc) -> ^u8 #cc_c;
)
var (
// Procedures
create_context_attribs_arb: CreateContextAttribsARBType;
choose_pixel_format_arb: ChoosePixelFormatARBType;
swap_interval_ext: SwapIntervalEXTType;
get_extensions_string_arb: GetExtensionsStringARBType;
)
foreign opengl32 {
core/sys/windows.odin
+160 -172
View File
@@ -25,16 +25,14 @@ type (
)
type Bool i32;
const (
FALSE: Bool = 0;
TRUE = 1;
)
FALSE: Bool : 0;
TRUE: Bool : 1;
type Point struct #ordered {
Point :: struct #ordered {
x, y: i32,
}
type WndClassExA struct #ordered {
WndClassExA :: struct #ordered {
size, style: u32,
wnd_proc: WndProc,
cls_extra, wnd_extra: i32,
@@ -46,7 +44,7 @@ type WndClassExA struct #ordered {
sm: Hicon,
}
type Msg struct #ordered {
Msg :: struct #ordered {
hwnd: Hwnd,
message: u32,
wparam: Wparam,
@@ -55,24 +53,24 @@ type Msg struct #ordered {
pt: Point,
}
type Rect struct #ordered {
Rect :: struct #ordered {
left: i32,
top: i32,
right: i32,
bottom: i32,
}
type Filetime struct #ordered {
Filetime :: struct #ordered {
lo, hi: u32,
}
type Systemtime struct #ordered {
Systemtime :: struct #ordered {
year, month: u16,
day_of_week, day: u16,
hour, minute, second, millisecond: u16,
}
type ByHandleFileInformation struct #ordered {
ByHandleFileInformation :: struct #ordered {
file_attributes: u32,
creation_time,
last_access_time,
@@ -85,7 +83,7 @@ type ByHandleFileInformation struct #ordered {
file_index_low: u32,
}
type FileAttributeData struct #ordered {
FileAttributeData :: struct #ordered {
file_attributes: u32,
creation_time,
last_access_time,
@@ -94,7 +92,7 @@ type FileAttributeData struct #ordered {
file_size_low: u32,
}
type FindData struct #ordered {
FindData :: struct #ordered {
file_attributes: u32,
creation_time: Filetime,
last_access_time: Filetime,
@@ -107,7 +105,7 @@ type FindData struct #ordered {
alternate_file_name: [14]u8,
}
type Security_Attributes struct #ordered {
Security_Attributes :: struct #ordered {
length: u32,
security_descriptor: rawptr,
inherit_handle: Bool,
@@ -115,7 +113,7 @@ type Security_Attributes struct #ordered {
type PixelFormatDescriptor struct #ordered {
PixelFormatDescriptor :: struct #ordered {
size,
version,
flags: u32,
@@ -151,138 +149,129 @@ type PixelFormatDescriptor struct #ordered {
type Proc proc() #cc_c;
const (
MAPVK_VK_TO_VSC = 0;
MAPVK_VSC_TO_VK = 1;
MAPVK_VK_TO_CHAR = 2;
MAPVK_VSC_TO_VK_EX = 3;
)
MAPVK_VK_TO_VSC :: 0;
MAPVK_VSC_TO_VK :: 1;
MAPVK_VK_TO_CHAR :: 2;
MAPVK_VSC_TO_VK_EX :: 3;
const INVALID_HANDLE = Handle(~int(0));
INVALID_HANDLE :: Handle(~int(0));
const (
CS_VREDRAW = 0x0001;
CS_HREDRAW = 0x0002;
CS_OWNDC = 0x0020;
CW_USEDEFAULT = -0x80000000;
CS_VREDRAW :: 0x0001;
CS_HREDRAW :: 0x0002;
CS_OWNDC :: 0x0020;
CW_USEDEFAULT :: -0x80000000;
WS_OVERLAPPED = 0;
WS_MAXIMIZEBOX = 0x00010000;
WS_MINIMIZEBOX = 0x00020000;
WS_THICKFRAME = 0x00040000;
WS_SYSMENU = 0x00080000;
WS_BORDER = 0x00800000;
WS_CAPTION = 0x00C00000;
WS_VISIBLE = 0x10000000;
WS_POPUP = 0x80000000;
WS_OVERLAPPEDWINDOW = WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX;
WS_POPUPWINDOW = WS_POPUP | WS_BORDER | WS_SYSMENU;
WS_OVERLAPPED :: 0;
WS_MAXIMIZEBOX :: 0x00010000;
WS_MINIMIZEBOX :: 0x00020000;
WS_THICKFRAME :: 0x00040000;
WS_SYSMENU :: 0x00080000;
WS_BORDER :: 0x00800000;
WS_CAPTION :: 0x00C00000;
WS_VISIBLE :: 0x10000000;
WS_POPUP :: 0x80000000;
WS_OVERLAPPEDWINDOW :: WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX;
WS_POPUPWINDOW :: WS_POPUP | WS_BORDER | WS_SYSMENU;
WM_DESTROY = 0x0002;
WM_SIZE = 0x0005;
WM_CLOSE = 0x0010;
WM_ACTIVATEAPP = 0x001C;
WM_QUIT = 0x0012;
WM_KEYDOWN = 0x0100;
WM_KEYUP = 0x0101;
WM_SIZING = 0x0214;
WM_SYSKEYDOWN = 0x0104;
WM_SYSKEYUP = 0x0105;
WM_WINDOWPOSCHANGED = 0x0047;
WM_SETCURSOR = 0x0020;
WM_CHAR = 0x0102;
WM_ACTIVATE = 0x0006;
WM_SETFOCUS = 0x0007;
WM_KILLFOCUS = 0x0008;
WM_USER = 0x0400;
WM_DESTROY :: 0x0002;
WM_SIZE :: 0x0005;
WM_CLOSE :: 0x0010;
WM_ACTIVATEAPP :: 0x001C;
WM_QUIT :: 0x0012;
WM_KEYDOWN :: 0x0100;
WM_KEYUP :: 0x0101;
WM_SIZING :: 0x0214;
WM_SYSKEYDOWN :: 0x0104;
WM_SYSKEYUP :: 0x0105;
WM_WINDOWPOSCHANGED :: 0x0047;
WM_SETCURSOR :: 0x0020;
WM_CHAR :: 0x0102;
WM_ACTIVATE :: 0x0006;
WM_SETFOCUS :: 0x0007;
WM_KILLFOCUS :: 0x0008;
WM_USER :: 0x0400;
WM_MOUSEWHEEL = 0x020A;
WM_MOUSEMOVE = 0x0200;
WM_LBUTTONDOWN = 0x0201;
WM_LBUTTONUP = 0x0202;
WM_LBUTTONDBLCLK = 0x0203;
WM_RBUTTONDOWN = 0x0204;
WM_RBUTTONUP = 0x0205;
WM_RBUTTONDBLCLK = 0x0206;
WM_MBUTTONDOWN = 0x0207;
WM_MBUTTONUP = 0x0208;
WM_MBUTTONDBLCLK = 0x0209;
WM_MOUSEWHEEL :: 0x020A;
WM_MOUSEMOVE :: 0x0200;
WM_LBUTTONDOWN :: 0x0201;
WM_LBUTTONUP :: 0x0202;
WM_LBUTTONDBLCLK :: 0x0203;
WM_RBUTTONDOWN :: 0x0204;
WM_RBUTTONUP :: 0x0205;
WM_RBUTTONDBLCLK :: 0x0206;
WM_MBUTTONDOWN :: 0x0207;
WM_MBUTTONUP :: 0x0208;
WM_MBUTTONDBLCLK :: 0x0209;
PM_NOREMOVE = 0x0000;
PM_REMOVE = 0x0001;
PM_NOYIELD = 0x0002;
PM_NOREMOVE :: 0x0000;
PM_REMOVE :: 0x0001;
PM_NOYIELD :: 0x0002;
BLACK_BRUSH = 4;
BLACK_BRUSH :: 4;
SM_CXSCREEN = 0;
SM_CYSCREEN = 1;
SM_CXSCREEN :: 0;
SM_CYSCREEN :: 1;
SW_SHOW = 5;
)
SW_SHOW :: 5;
const COLOR_BACKGROUND = Hbrush(int(1));
COLOR_BACKGROUND :: Hbrush(int(1));
const INVALID_SET_FILE_POINTER = ~u32(0);
const HEAP_ZERO_MEMORY = 0x00000008;
const INFINITE = 0xffffffff;
const GWL_STYLE = -16;
const Hwnd_TOP = Hwnd(uint(0));
INVALID_SET_FILE_POINTER :: ~u32(0);
HEAP_ZERO_MEMORY :: 0x00000008;
INFINITE :: 0xffffffff;
GWL_STYLE :: -16;
Hwnd_TOP :: Hwnd(uint(0));
const BI_RGB = 0;
const DIB_RGB_COLORS = 0x00;
const SRCCOPY: u32 = 0x00cc0020;
BI_RGB :: 0;
DIB_RGB_COLORS :: 0x00;
SRCCOPY: u32 : 0x00cc0020;
const (
MONITOR_DEFAULTTONULL = 0x00000000;
MONITOR_DEFAULTTOPRIMARY = 0x00000001;
MONITOR_DEFAULTTONEAREST = 0x00000002;
)
const (
SWP_FRAMECHANGED = 0x0020;
SWP_NOOWNERZORDER = 0x0200;
SWP_NOZORDER = 0x0004;
SWP_NOSIZE = 0x0001;
SWP_NOMOVE = 0x0002;
)
MONITOR_DEFAULTTONULL :: 0x00000000;
MONITOR_DEFAULTTOPRIMARY :: 0x00000001;
MONITOR_DEFAULTTONEAREST :: 0x00000002;
SWP_FRAMECHANGED :: 0x0020;
SWP_NOOWNERZORDER :: 0x0200;
SWP_NOZORDER :: 0x0004;
SWP_NOSIZE :: 0x0001;
SWP_NOMOVE :: 0x0002;
// Windows OpenGL
const (
PFD_TYPE_RGBA = 0;
PFD_TYPE_COLORINDEX = 1;
PFD_MAIN_PLANE = 0;
PFD_OVERLAY_PLANE = 1;
PFD_UNDERLAY_PLANE = -1;
PFD_DOUBLEBUFFER = 1;
PFD_STEREO = 2;
PFD_DRAW_TO_WINDOW = 4;
PFD_DRAW_TO_BITMAP = 8;
PFD_SUPPORT_GDI = 16;
PFD_SUPPORT_OPENGL = 32;
PFD_GENERIC_FORMAT = 64;
PFD_NEED_PALETTE = 128;
PFD_NEED_SYSTEM_PALETTE = 0x00000100;
PFD_SWAP_EXCHANGE = 0x00000200;
PFD_SWAP_COPY = 0x00000400;
PFD_SWAP_LAYER_BUFFERS = 0x00000800;
PFD_GENERIC_ACCELERATED = 0x00001000;
PFD_DEPTH_DONTCARE = 0x20000000;
PFD_DOUBLEBUFFER_DONTCARE = 0x40000000;
PFD_STEREO_DONTCARE = 0x80000000;
)
PFD_TYPE_RGBA :: 0;
PFD_TYPE_COLORINDEX :: 1;
PFD_MAIN_PLANE :: 0;
PFD_OVERLAY_PLANE :: 1;
PFD_UNDERLAY_PLANE :: -1;
PFD_DOUBLEBUFFER :: 1;
PFD_STEREO :: 2;
PFD_DRAW_TO_WINDOW :: 4;
PFD_DRAW_TO_BITMAP :: 8;
PFD_SUPPORT_GDI :: 16;
PFD_SUPPORT_OPENGL :: 32;
PFD_GENERIC_FORMAT :: 64;
PFD_NEED_PALETTE :: 128;
PFD_NEED_SYSTEM_PALETTE :: 0x00000100;
PFD_SWAP_EXCHANGE :: 0x00000200;
PFD_SWAP_COPY :: 0x00000400;
PFD_SWAP_LAYER_BUFFERS :: 0x00000800;
PFD_GENERIC_ACCELERATED :: 0x00001000;
PFD_DEPTH_DONTCARE :: 0x20000000;
PFD_DOUBLEBUFFER_DONTCARE :: 0x40000000;
PFD_STEREO_DONTCARE :: 0x80000000;
type GET_FILEEX_INFO_LEVELS i32;
const (
GetFileExInfoStandard: GET_FILEEX_INFO_LEVELS = 0;
GetFileExMaxInfoLevel = 1;
)
GetFileExInfoStandard: GET_FILEEX_INFO_LEVELS : 0;
GetFileExMaxInfoLevel: GET_FILEEX_INFO_LEVELS : 1;
foreign kernel32 {
proc get_last_error () -> i32 #cc_std #link_name "GetLastError";
@@ -448,7 +437,7 @@ foreign winmm {
proc get_query_performance_frequency() -> i64 {
var r: i64;
r: i64;
query_performance_frequency(&r);
return r;
}
@@ -463,67 +452,66 @@ proc is_key_down(key: KeyCode) -> bool #inline { return get_async_key_state(i32(
const (
MAX_PATH = 0x00000104;
HANDLE_FLAG_INHERIT = 1;
HANDLE_FLAG_PROTECT_FROM_CLOSE = 2;
MAX_PATH :: 0x00000104;
FILE_BEGIN = 0;
FILE_CURRENT = 1;
FILE_END = 2;
HANDLE_FLAG_INHERIT :: 1;
HANDLE_FLAG_PROTECT_FROM_CLOSE :: 2;
FILE_SHARE_READ = 0x00000001;
FILE_SHARE_WRITE = 0x00000002;
FILE_SHARE_DELETE = 0x00000004;
FILE_GENERIC_ALL = 0x10000000;
FILE_GENERIC_EXECUTE = 0x20000000;
FILE_GENERIC_WRITE = 0x40000000;
FILE_GENERIC_READ = 0x80000000;
FILE_BEGIN :: 0;
FILE_CURRENT :: 1;
FILE_END :: 2;
FILE_APPEND_DATA = 0x0004;
FILE_SHARE_READ :: 0x00000001;
FILE_SHARE_WRITE :: 0x00000002;
FILE_SHARE_DELETE :: 0x00000004;
FILE_GENERIC_ALL :: 0x10000000;
FILE_GENERIC_EXECUTE :: 0x20000000;
FILE_GENERIC_WRITE :: 0x40000000;
FILE_GENERIC_READ :: 0x80000000;
STD_INPUT_HANDLE = -10;
STD_OUTPUT_HANDLE = -11;
STD_ERROR_HANDLE = -12;
FILE_APPEND_DATA :: 0x0004;
CREATE_NEW = 1;
CREATE_ALWAYS = 2;
OPEN_EXISTING = 3;
OPEN_ALWAYS = 4;
TRUNCATE_EXISTING = 5;
STD_INPUT_HANDLE :: -10;
STD_OUTPUT_HANDLE :: -11;
STD_ERROR_HANDLE :: -12;
INVALID_FILE_ATTRIBUTES = -1;
CREATE_NEW :: 1;
CREATE_ALWAYS :: 2;
OPEN_EXISTING :: 3;
OPEN_ALWAYS :: 4;
TRUNCATE_EXISTING :: 5;
FILE_ATTRIBUTE_READONLY = 0x00000001;
FILE_ATTRIBUTE_HIDDEN = 0x00000002;
FILE_ATTRIBUTE_SYSTEM = 0x00000004;
FILE_ATTRIBUTE_DIRECTORY = 0x00000010;
FILE_ATTRIBUTE_ARCHIVE = 0x00000020;
FILE_ATTRIBUTE_DEVICE = 0x00000040;
FILE_ATTRIBUTE_NORMAL = 0x00000080;
FILE_ATTRIBUTE_TEMPORARY = 0x00000100;
FILE_ATTRIBUTE_SPARSE_FILE = 0x00000200;
FILE_ATTRIBUTE_REPARSE_Point = 0x00000400;
FILE_ATTRIBUTE_COMPRESSED = 0x00000800;
FILE_ATTRIBUTE_OFFLINE = 0x00001000;
FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = 0x00002000;
FILE_ATTRIBUTE_ENCRYPTED = 0x00004000;
INVALID_FILE_ATTRIBUTES :: -1;
FILE_TYPE_DISK = 0x0001;
FILE_TYPE_CHAR = 0x0002;
FILE_TYPE_PIPE = 0x0003;
)
FILE_ATTRIBUTE_READONLY :: 0x00000001;
FILE_ATTRIBUTE_HIDDEN :: 0x00000002;
FILE_ATTRIBUTE_SYSTEM :: 0x00000004;
FILE_ATTRIBUTE_DIRECTORY :: 0x00000010;
FILE_ATTRIBUTE_ARCHIVE :: 0x00000020;
FILE_ATTRIBUTE_DEVICE :: 0x00000040;
FILE_ATTRIBUTE_NORMAL :: 0x00000080;
FILE_ATTRIBUTE_TEMPORARY :: 0x00000100;
FILE_ATTRIBUTE_SPARSE_FILE :: 0x00000200;
FILE_ATTRIBUTE_REPARSE_Point :: 0x00000400;
FILE_ATTRIBUTE_COMPRESSED :: 0x00000800;
FILE_ATTRIBUTE_OFFLINE :: 0x00001000;
FILE_ATTRIBUTE_NOT_CONTENT_INDEXED :: 0x00002000;
FILE_ATTRIBUTE_ENCRYPTED :: 0x00004000;
FILE_TYPE_DISK :: 0x0001;
FILE_TYPE_CHAR :: 0x0002;
FILE_TYPE_PIPE :: 0x0003;
type MonitorInfo struct #ordered {
MonitorInfo :: struct #ordered {
size: u32,
monitor: Rect,
work: Rect,
flags: u32,
}
type WindowPlacement struct #ordered {
WindowPlacement :: struct #ordered {
length: u32,
flags: u32,
show_cmd: u32,
@@ -532,7 +520,7 @@ type WindowPlacement struct #ordered {
normal_pos: Rect,
}
type BitmapInfoHeader struct #ordered {
BitmapInfoHeader :: struct #ordered {
size: u32,
width, height: i32,
planes, bit_count: i16,
@@ -543,16 +531,16 @@ type BitmapInfoHeader struct #ordered {
clr_used: u32,
clr_important: u32,
}
type BitmapInfo struct #ordered {
BitmapInfo :: struct #ordered {
using header: BitmapInfoHeader,
colors: [1]RgbQuad,
}
type RgbQuad struct #ordered { blue, green, red, reserved: u8 }
RgbQuad :: struct #ordered { blue, green, red, reserved: u8 }
type KeyCode enum i32 {
KeyCode :: enum i32 {
Lbutton = 0x01,
Rbutton = 0x02,
Cancel = 0x03,
core/types.odin
+18 -18
View File
@@ -8,91 +8,91 @@ proc is_signed(info: ^TypeInfo) -> bool {
}
proc is_integer(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.Integer);
_, ok := type_info_base(info).(^TypeInfo.Integer);
return ok;
}
proc is_float(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.Float);
_, ok := type_info_base(info).(^TypeInfo.Float);
return ok;
}
proc is_complex(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.Complex);
_, ok := type_info_base(info).(^TypeInfo.Complex);
return ok;
}
proc is_any(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.Any);
_, ok := type_info_base(info).(^TypeInfo.Any);
return ok;
}
proc is_string(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.String);
_, ok := type_info_base(info).(^TypeInfo.String);
return ok;
}
proc is_boolean(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.Boolean);
_, ok := type_info_base(info).(^TypeInfo.Boolean);
return ok;
}
proc is_pointer(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.Pointer);
_, ok := type_info_base(info).(^TypeInfo.Pointer);
return ok;
}
proc is_procedure(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.Procedure);
_, ok := type_info_base(info).(^TypeInfo.Procedure);
return ok;
}
proc is_array(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.Array);
_, ok := type_info_base(info).(^TypeInfo.Array);
return ok;
}
proc is_dynamic_array(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.DynamicArray);
_, ok := type_info_base(info).(^TypeInfo.DynamicArray);
return ok;
}
proc is_dynamic_map(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.Map);
_, ok := type_info_base(info).(^TypeInfo.Map);
return ok;
}
proc is_slice(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.Slice);
_, ok := type_info_base(info).(^TypeInfo.Slice);
return ok;
}
proc is_vector(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.Vector);
_, ok := type_info_base(info).(^TypeInfo.Vector);
return ok;
}
proc is_tuple(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.Tuple);
_, ok := type_info_base(info).(^TypeInfo.Tuple);
return ok;
}
proc is_struct(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.Struct);
_, ok := type_info_base(info).(^TypeInfo.Struct);
return ok;
}
proc is_union(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.Union);
_, ok := type_info_base(info).(^TypeInfo.Union);
return ok;
}
proc is_raw_union(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.RawUnion);
_, ok := type_info_base(info).(^TypeInfo.RawUnion);
return ok;
}
proc is_enum(info: ^TypeInfo) -> bool {
if info == nil { return false; }
var _, ok = type_info_base(info).(^TypeInfo.Enum);
_, ok := type_info_base(info).(^TypeInfo.Enum);
return ok;
}
core/utf16.odin
+10 -11
View File
@@ -1,12 +1,11 @@
const (
REPLACEMENT_CHAR = '\uFFFD';
MAX_RUNE = '\U0010FFFF';
REPLACEMENT_CHAR :: '\uFFFD';
MAX_RUNE :: '\U0010FFFF';
_surr1 :: 0xd800;
_surr2 :: 0xdc00;
_surr3 :: 0xe000;
_surr_self :: 0x10000;
_surr1 = 0xd800;
_surr2 = 0xdc00;
_surr3 = 0xe000;
_surr_self = 0x10000;
)
proc is_surrogate(r: rune) -> bool {
return _surr1 <= r && r < _surr3;
@@ -29,14 +28,14 @@ proc encode_surrogate_pair(r: rune) -> (r1, r2: rune) {
}
proc encode(d: []u16, s: []rune) {
var n = len(s);
n := len(s);
for r in s {
if r >= _surr_self {
n++;
}
}
var max_n = min(len(d), n);
max_n := min(len(d), n);
n = 0;
for r in s {
@@ -46,7 +45,7 @@ proc encode(d: []u16, s: []rune) {
n++;
case _surr_self..MAX_RUNE:
var r1, r2 = encode_surrogate_pair(r);
r1, r2 := encode_surrogate_pair(r);
d[n] = u16(r1);
d[n+1] = u16(r2);
n += 2;
core/utf8.odin
+83 -87
View File
@@ -1,71 +1,67 @@
const (
RUNE_ERROR = '\ufffd';
RUNE_SELF = 0x80;
RUNE_BOM = 0xfeff;
RUNE_EOF = ~rune(0);
MAX_RUNE = '\U0010ffff';
UTF_MAX = 4;
RUNE_ERROR :: '\ufffd';
RUNE_SELF :: 0x80;
RUNE_BOM :: 0xfeff;
RUNE_EOF :: ~rune(0);
MAX_RUNE :: '\U0010ffff';
UTF_MAX :: 4;
SURROGATE_MIN = 0xd800;
SURROGATE_MAX = 0xdfff;
SURROGATE_MIN :: 0xd800;
SURROGATE_MAX :: 0xdfff;
T1 = 0b0000_0000;
TX = 0b1000_0000;
T2 = 0b1100_0000;
T3 = 0b1110_0000;
T4 = 0b1111_0000;
T5 = 0b1111_1000;
T1 :: 0b0000_0000;
TX :: 0b1000_0000;
T2 :: 0b1100_0000;
T3 :: 0b1110_0000;
T4 :: 0b1111_0000;
T5 :: 0b1111_1000;
MASKX = 0b0011_1111;
MASK2 = 0b0001_1111;
MASK3 = 0b0000_1111;
MASK4 = 0b0000_0111;
MASKX :: 0b0011_1111;
MASK2 :: 0b0001_1111;
MASK3 :: 0b0000_1111;
MASK4 :: 0b0000_0111;
RUNE1_MAX = 1<<7 - 1;
RUNE2_MAX = 1<<11 - 1;
RUNE3_MAX = 1<<16 - 1;
RUNE1_MAX :: 1<<7 - 1;
RUNE2_MAX :: 1<<11 - 1;
RUNE3_MAX :: 1<<16 - 1;
// The default lowest and highest continuation byte.
LOCB = 0b1000_0000;
HICB = 0b1011_1111;
)
LOCB :: 0b1000_0000;
HICB :: 0b1011_1111;
type AcceptRange struct { lo, hi: u8 }
AcceptRange :: struct { lo, hi: u8 }
var (
accept_ranges = [5]AcceptRange{
{0x80, 0xbf},
{0xa0, 0xbf},
{0x80, 0x9f},
{0x90, 0xbf},
{0x80, 0x8f},
};
accept_ranges := [5]AcceptRange{
{0x80, 0xbf},
{0xa0, 0xbf},
{0x80, 0x9f},
{0x90, 0xbf},
{0x80, 0x8f},
};
accept_sizes = [256]u8{
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x00-0x0f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x10-0x1f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x20-0x2f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x30-0x3f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x40-0x4f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x50-0x5f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x60-0x6f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x70-0x7f
accept_sizes := [256]u8{
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x00-0x0f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x10-0x1f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x20-0x2f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x30-0x3f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x40-0x4f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x50-0x5f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x60-0x6f
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x70-0x7f
0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0x80-0x8f
0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0x90-0x9f
0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xa0-0xaf
0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xb0-0xbf
0xf1, 0xf1, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xc0-0xcf
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xd0-0xdf
0x13, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x23, 0x03, 0x03, // 0xe0-0xef
0x34, 0x04, 0x04, 0x04, 0x44, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xf0-0xff
};
)
0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0x80-0x8f
0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0x90-0x9f
0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xa0-0xaf
0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xb0-0xbf
0xf1, 0xf1, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xc0-0xcf
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xd0-0xdf
0x13, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x23, 0x03, 0x03, // 0xe0-0xef
0x34, 0x04, 0x04, 0x04, 0x44, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xf0-0xff
};
proc encode_rune(r: rune) -> ([4]u8, int) {
var buf: [4]u8;
var i = u32(r);
const mask: u8 = 0x3f;
buf: [4]u8;
i := u32(r);
mask: u8 : 0x3f;
if i <= 1<<7-1 {
buf[0] = u8(r);
return buf, 1;
@@ -98,36 +94,36 @@ proc encode_rune(r: rune) -> ([4]u8, int) {
proc decode_rune(s: string) -> (rune, int) #inline { return decode_rune([]u8(s)); }
proc decode_rune(s: []u8) -> (rune, int) {
var n = len(s);
n := len(s);
if n < 1 {
return RUNE_ERROR, 0;
}
var s0 = s[0];
var x = accept_sizes[s0];
s0 := s[0];
x := accept_sizes[s0];
if x >= 0xF0 {
var mask = rune(x) << 31 >> 31; // NOTE(bill): Create 0x0000 or 0xffff.
mask := rune(x) << 31 >> 31; // NOTE(bill): Create 0x0000 or 0xffff.
return rune(s[0])&~mask | RUNE_ERROR&mask, 1;
}
var sz = x & 7;
var accept = accept_ranges[x>>4];
sz := x & 7;
accept := accept_ranges[x>>4];
if n < int(sz) {
return RUNE_ERROR, 1;
}
var b1 = s[1];
b1 := s[1];
if b1 < accept.lo || accept.hi < b1 {
return RUNE_ERROR, 1;
}
if sz == 2 {
return rune(s0&MASK2)<<6 | rune(b1&MASKX), 2;
}
var b2 = s[2];
b2 := s[2];
if b2 < LOCB || HICB < b2 {
return RUNE_ERROR, 1;
}
if sz == 3 {
return rune(s0&MASK3)<<12 | rune(b1&MASKX)<<6 | rune(b2&MASKX), 3;
}
var b3 = s[3];
b3 := s[3];
if b3 < LOCB || HICB < b3 {
return RUNE_ERROR, 1;
}
@@ -138,9 +134,9 @@ proc decode_rune(s: []u8) -> (rune, int) {
proc decode_last_rune(s: string) -> (rune, int) #inline { return decode_last_rune([]u8(s)); }
proc decode_last_rune(s: []u8) -> (rune, int) {
var r: rune;
var size: int;
var start, end, limit: int;
r: rune;
size: int;
start, end, limit: int;
end = len(s);
if end == 0 {
@@ -187,31 +183,31 @@ proc valid_rune(r: rune) -> bool {
}
proc valid_string(s: string) -> bool {
var n = len(s);
for var i = 0; i < n; {
var si = s[i];
n := len(s);
for i := 0; i < n; {
si := s[i];
if si < RUNE_SELF { // ascii
i++;
continue;
}
var x = accept_sizes[si];
x := accept_sizes[si];
if x == 0xf1 {
return false;
}
var size = int(x & 7);
size := int(x & 7);
if i+size > n {
return false;
}
var ar = accept_ranges[x>>4];
if var b = s[i+1]; b < ar.lo || ar.hi < b {
ar := accept_ranges[x>>4];
if b := s[i+1]; b < ar.lo || ar.hi < b {
return false;
} else if size == 2 {
// Okay
} else if var b = s[i+2]; b < 0x80 || 0xbf < b {
} else if b := s[i+2]; b < 0x80 || 0xbf < b {
return false;
} else if size == 3 {
// Okay
} else if var b = s[i+3]; b < 0x80 || 0xbf < b {
} else if b := s[i+3]; b < 0x80 || 0xbf < b {
return false;
}
i += size;
@@ -223,36 +219,36 @@ proc rune_start(b: u8) -> bool #inline { return b&0xc0 != 0x80; }
proc rune_count(s: string) -> int #inline { return rune_count([]u8(s)); }
proc rune_count(s: []u8) -> int {
var count = 0;
var n = len(s);
count := 0;
n := len(s);
for var i = 0; i < n; {
for i := 0; i < n; {
defer count++;
var si = s[i];
si := s[i];
if si < RUNE_SELF { // ascii
i++;
continue;
}
var x = accept_sizes[si];
x := accept_sizes[si];
if x == 0xf1 {
i++;
continue;
}
var size = int(x & 7);
size := int(x & 7);
if i+size > n {
i++;
continue;
}
var ar = accept_ranges[x>>4];
if var b = s[i+1]; b < ar.lo || ar.hi < b {
ar := accept_ranges[x>>4];
if b := s[i+1]; b < ar.lo || ar.hi < b {
size = 1;
} else if size == 2 {
// Okay
} else if var b = s[i+2]; b < 0x80 || 0xbf < b {
} else if b := s[i+2]; b < 0x80 || 0xbf < b {
size = 1;
} else if size == 3 {
// Okay
} else if var b = s[i+3]; b < 0x80 || 0xbf < b {
} else if b := s[i+3]; b < 0x80 || 0xbf < b {
size = 1;
}
i += size;
src/check_expr.cpp
+5
View File
@@ -2219,6 +2219,11 @@ Type *check_type(Checker *c, AstNode *e, Type *named_type) {
}
}
if (is_type_gen_proc(type)) {
error(e, "Invalid use of polymorphic procedure type");
type = t_invalid;
}
if (is_type_typed(type)) {
add_type_and_value(&c->info, e, Addressing_Type, type, empty_exact_value);
} else {
src/parser.cpp
+16 -3
View File
@@ -1871,6 +1871,15 @@ bool is_semicolon_optional_for_node(AstFile *f, AstNode *s) {
case AstNode_ProcDecl:
return s->ProcDecl.body != NULL;
case AstNode_ValueDecl:
if (s->ValueDecl.is_mutable) {
return false;
}
if (s->ValueDecl.values.count > 0) {
return is_semicolon_optional_for_node(f, s->ValueDecl.values[s->ValueDecl.values.count-1]);
}
break;
case AstNode_GenDecl:
if (s->GenDecl.close.pos.line != 0) {
return true;
@@ -3149,7 +3158,11 @@ AstNode *parse_value_decl(AstFile *f, Array<AstNode *> names, CommentGroup docs)
}
if (f->expr_level >= 0) {
expect_semicolon(f, NULL);
AstNode *end = NULL;
if (!is_mutable && values.count > 0) {
end = values[values.count-1];
}
expect_semicolon(f, end);
}
return ast_value_decl(f, names, type, values, is_mutable, docs, f->line_comment);
@@ -4317,8 +4330,8 @@ AstNode *parse_stmt(AstFile *f) {
expect_semicolon(f, s);
return s;
case Token_var:
case Token_const:
// case Token_var:
// case Token_const:
case Token_proc:
case Token_type:
case Token_import: