Restructure
This commit is contained in:
Krzosa Karol
40
Windows.kl
40
Windows.kl
@@ -1,40 +0,0 @@
|
||||
DWORD :: U32
|
||||
LPCSTR :: *char
|
||||
HWND :: *void
|
||||
HMENU :: *void
|
||||
HINSTANCE :: *void
|
||||
LPVOID :: *void
|
||||
SIZE_T :: U64
|
||||
BOOL :: int
|
||||
HANDLE :: *void
|
||||
VOID :: void
|
||||
LPDWORD :: *DWORD
|
||||
|
||||
CreateWindowA :: #foreign (dwExStyle: DWORD, lpClassName: *char, lpWindowName: *char, dwStyle: DWORD, X: int, Y: int, nWidth: int, nHeight: int, hWndParent: HWND, hMenu: HMENU, hInstance: HINSTANCE, lpParam: *void): HWND
|
||||
|
||||
|
||||
MEM_COMMIT :: 0x00001000
|
||||
MEM_RESERVE :: 0x00002000
|
||||
MEM_RESET :: 0x00080000
|
||||
MEM_RESET_UNDO :: 0x1000000
|
||||
|
||||
MEM_DECOMMIT :: 0x00004000
|
||||
MEM_RELEASE :: 0x00008000
|
||||
|
||||
PAGE_NOACCESS :: 1
|
||||
PAGE_READONLY :: 2
|
||||
PAGE_READWRITE :: 4
|
||||
PAGE_WRITECOPY :: 8
|
||||
PAGE_EXECUTE :: 0x10
|
||||
PAGE_EXECUTE_READ :: 0x20
|
||||
PAGE_EXECUTE_READWRITE :: 0x40
|
||||
PAGE_EXECUTE_WRITECOPY :: 0x80
|
||||
|
||||
VirtualAlloc :: #foreign (lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD): LPVOID
|
||||
VirtualFree :: #foreign (lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD): BOOL
|
||||
|
||||
STD_INPUT_HANDLE :: 4294967286//(-10)->DWORD
|
||||
STD_OUTPUT_HANDLE :: 4294967285//(-11)->DWORD
|
||||
//STD_ERROR_HANDLE :: (-12)->DWORD
|
||||
GetStdHandle :: #foreign (nStdHandle: DWORD): HANDLE
|
||||
WriteConsoleA :: #foreign (hConsoleOutput: HANDLE,lpBuffer: *VOID,nNumberOfCharsToWrite: DWORD,lpNumberOfCharsWritten: LPDWORD,lpReserve: LPVOID): BOOL
|
||||
24
base.kl
24
base.kl
@@ -1,24 +0,0 @@
|
||||
Os :: #import "os.kl"
|
||||
|
||||
SizeU :: #strict U64
|
||||
|
||||
Arena :: struct
|
||||
memory: Os.Memory
|
||||
alignment: U64
|
||||
len: U64
|
||||
|
||||
clamp_top_sizeu :: (val: SizeU, max: SizeU): SizeU
|
||||
if val > max
|
||||
return max
|
||||
return val
|
||||
|
||||
get_align_offset :: (size: SizeU, align: SizeU): SizeU
|
||||
mask := align - 1
|
||||
val := size & mask
|
||||
if val != 0
|
||||
val = align - val
|
||||
return val
|
||||
|
||||
align_up :: (size: SizeU, align: SizeU): SizeU
|
||||
result := size + get_align_offset(size, align)
|
||||
return result
|
||||
7
enums.kl
7
enums.kl
@@ -1,7 +0,0 @@
|
||||
Allocator_Kind :: enum #flag
|
||||
Null; Arena; Heap
|
||||
|
||||
kind := Allocator_Kind.Heap
|
||||
|
||||
basic_type_assignment :: () // This works
|
||||
return
|
||||
78
euler.kl
78
euler.kl
@@ -1,78 +0,0 @@
|
||||
// @todo: Add more stats in the preview
|
||||
// @todo: for 0..1000(implicit i) and for i in 0..1000
|
||||
// @todo: Add blocks of stmts that you can simply define inside a function etc.
|
||||
|
||||
entry :: ()
|
||||
print_str("\n")
|
||||
euler1()
|
||||
euler3()
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Euler 2
|
||||
//-----------------------------------------------------------------------------
|
||||
euler1 :: ()
|
||||
end := 1000
|
||||
result := 0
|
||||
for i := 0, i < end, i++
|
||||
if i % 3 == 0
|
||||
result += i
|
||||
else if i % 5 == 0
|
||||
result += i
|
||||
print_str("Euler1: ")
|
||||
print_int(result)
|
||||
print_str("\n")
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Euler 3
|
||||
//-----------------------------------------------------------------------------
|
||||
int_sqrt :: (s: S64): S64
|
||||
result := sqrt(cast(s: F64))
|
||||
return cast(result: S64)
|
||||
|
||||
// https://en.wikipedia.org/wiki/Integer_square_root
|
||||
int_sqrt1 :: (s: S64): S64
|
||||
x0 := s / 2
|
||||
|
||||
if x0 != 0
|
||||
x1 := (x0 + s / x0) / 2
|
||||
for x1 < x0
|
||||
x0 = x1
|
||||
x1 = (x0 + s / x0) / 2
|
||||
return x0
|
||||
else
|
||||
return s
|
||||
|
||||
euler3 :: ()
|
||||
n := 600851475143
|
||||
results: [32]S64
|
||||
results_len := 0
|
||||
|
||||
// First search all 2's
|
||||
for n % 2 == 0
|
||||
results[results_len++] = 2
|
||||
n /= 2
|
||||
|
||||
// Then search other primes, 3, 5, 7 etc.
|
||||
for i := 3, i <= int_sqrt1(n), i += 2
|
||||
for n % i == 0
|
||||
results[results_len++] = i
|
||||
n /= i
|
||||
|
||||
// Then check if our number is a prime it self
|
||||
if n > 2
|
||||
results[results_len++] = n
|
||||
|
||||
print_str("Euler3: ")
|
||||
|
||||
is_correct: S64 = 1
|
||||
for i := 0, i < results_len, i++
|
||||
is_correct = is_correct * results[i]
|
||||
print_int(is_correct)
|
||||
|
||||
print_str(":: ")
|
||||
print_int(is_correct)
|
||||
|
||||
sqrt :: (v: F64): F64 #foreign
|
||||
print_int :: (i: S64) #foreign
|
||||
print_str :: (i: String) #foreign
|
||||
91
globals.kl
91
globals.kl
@@ -1,91 +0,0 @@
|
||||
lambdas :: #load "lambdas.kl"
|
||||
Memory :: #load "enums.kl"
|
||||
#load "lambdas.kl"
|
||||
#load "lambdas.kl"
|
||||
#import "order1.kl"
|
||||
#import "order1.kl"
|
||||
order :: #import "order1.kl"
|
||||
|
||||
|
||||
|
||||
test_load :: ()
|
||||
new_types :: #load "new_types.kl"
|
||||
new_types.basic_type_assignment()
|
||||
arena__: order2.Arena
|
||||
Arena_ :: order.order2.Arena
|
||||
arena___: Arena_
|
||||
//-----------------------------------------------------------------------------
|
||||
// Function types
|
||||
//-----------------------------------------------------------------------------
|
||||
test_function :: (thing: S64): *S64
|
||||
function_type: test_function
|
||||
const_function_alias :: test_function
|
||||
// null_function: (t: S64): *S64 = null
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Booleans
|
||||
//-----------------------------------------------------------------------------
|
||||
Boolean: Bool = true
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Nulls
|
||||
//-----------------------------------------------------------------------------
|
||||
// int_null: S64 = null
|
||||
// str_null: String = null
|
||||
// Bool_null: Bool = null
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Compound expressions
|
||||
//-----------------------------------------------------------------------------
|
||||
array1: [4]S64 = {1,2,3,4}
|
||||
imp_array := [5]S64{1,2}
|
||||
// imp_array_a := [5]S64{1,2,3,4,5,6}
|
||||
// imp_array_b: [5]S64 = {1,2,3,4,5,6}
|
||||
imp_array_c: [5]S64 = {[0] = 1, [2] = 2, [1] = 0} // @todo this should be illegal
|
||||
// without_size: []S64 = {} // @todo: this should be slice, converting from array should be implicit
|
||||
|
||||
string: *char = "string"
|
||||
first_letter := string[0]
|
||||
decl_char: char = 55
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Pointers
|
||||
//-----------------------------------------------------------------------------
|
||||
pointer_decl : *S64
|
||||
variable_from_deref: S64 = *pointer_decl
|
||||
pointer_from_var : *S64 = &variable_from_deref
|
||||
Boolean_pointer := &Boolean
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Implicit type
|
||||
//-----------------------------------------------------------------------------
|
||||
implicit_int :: 10
|
||||
implicit_str :: "Hello world"
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Pointers
|
||||
//-----------------------------------------------------------------------------
|
||||
// pointer1: *S64 = 0
|
||||
// pointer2: *S64 = pointer1
|
||||
// pointer3: **S64 = 0
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// String types
|
||||
//-----------------------------------------------------------------------------
|
||||
string1 :: "Test"
|
||||
string2 :: string1
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Constant S64 variables
|
||||
//-----------------------------------------------------------------------------
|
||||
thing0 :: 10
|
||||
thing4 :: thing0 + 11
|
||||
thing3 :: thing4 + 20
|
||||
combin :: thing0 + thing4 + thing3
|
||||
|
||||
Some :: struct
|
||||
len: S64
|
||||
cap: S64
|
||||
|
||||
some := Some{3, 2}
|
||||
other := Some{len = 1, cap = 3}
|
||||
64
lambdas.kl
64
lambdas.kl
@@ -1,64 +0,0 @@
|
||||
Test :: struct
|
||||
len: S64
|
||||
|
||||
|
||||
test: Test
|
||||
member := test.len
|
||||
|
||||
enum_val: Memory.Allocator_Kind = Memory.Allocator_Kind.Heap
|
||||
other_enum_val: S64 = enum_val->S64
|
||||
|
||||
a_type :: S64
|
||||
pointer_type :: *S64
|
||||
// null_pointer: pointer_type = null
|
||||
|
||||
if_stmt :: (cond: S64): type
|
||||
CONSTANT :: 10
|
||||
thing := 10
|
||||
if i := thing + cond, cond > CONSTANT
|
||||
return i + CONSTANT
|
||||
else if cond < CONSTANT
|
||||
return i - CONSTANT
|
||||
else
|
||||
return CONSTANT
|
||||
|
||||
|
||||
for_stmt :: ()
|
||||
for i := 0, i < 10, i+=1
|
||||
out_of_order_resolving()
|
||||
|
||||
out_of_order_resolving :: ()
|
||||
i := 10
|
||||
|
||||
add_10 :: (size: S64): S64
|
||||
add_20 :: (new_size: S64): S64
|
||||
return 20
|
||||
|
||||
add :: (a: S64, b: S64 = 10): S64
|
||||
return a + b
|
||||
|
||||
constant :: 20; result := constant + 10
|
||||
|
||||
v3 := add(1,2)
|
||||
// v2 := add(a = 1, b = 2)
|
||||
// v1 := add(a = 1)
|
||||
// // v_err := add([0] = 1)
|
||||
// v4 := add(b = 1, a = 2)
|
||||
// // v_err := add([0] = 1, [1] = 2)
|
||||
// // v_err := add([0] = 1, 10) // illegal
|
||||
// // v_err := add([1] = 1) // illegal
|
||||
// // v_err := add() // illegal
|
||||
v4 := constant
|
||||
return v4
|
||||
|
||||
return_constant :: (): S64
|
||||
constant :: 10
|
||||
return constant
|
||||
|
||||
returning_void :: (insert: S64)
|
||||
// val1: S64 = return_constant()
|
||||
// val2: S64 = add_10(val1)
|
||||
return
|
||||
|
||||
|
||||
type :: a_type
|
||||
9
main.kl
9
main.kl
@@ -1,9 +0,0 @@
|
||||
#import "base.kl"
|
||||
os :: #import "os.kl"
|
||||
|
||||
main :: (argc: int, argv: **char): int
|
||||
memory := os.reserve(size = 10000)
|
||||
os.commit(&memory, 1000)
|
||||
os.release(&memory)
|
||||
os.print("Hello world")
|
||||
|
||||
110
new_types.kl
110
new_types.kl
@@ -1,110 +0,0 @@
|
||||
|
||||
unary_test :: ()
|
||||
int_val :: 141
|
||||
float_val :: 124.42
|
||||
conversion: F64 = -+int_val
|
||||
float2 := -float_val
|
||||
unsigned: S64 = -+-+-int_val
|
||||
|
||||
not: Bool = !int_val
|
||||
notf := !float_val
|
||||
notb := !true
|
||||
neg64: S64 = ~int_val
|
||||
neg32: S32 = ~int_val
|
||||
big_neg32: U32 = ~41512512->U32
|
||||
|
||||
var1: S64
|
||||
var2: S64 = 20
|
||||
var_bool: Bool = !var1 == !var2
|
||||
|
||||
pointer: *S64
|
||||
pointer += 10
|
||||
// pointer = pointer + pointer
|
||||
|
||||
// uns: U64 = -int_val
|
||||
// int_float: S64 = float_val
|
||||
// string :: -"Thing"
|
||||
// boolean :: -true
|
||||
// var := -true
|
||||
// var := +true
|
||||
|
||||
// @note: Poggers
|
||||
big_number1 :: 12512512512512521524242
|
||||
big_number2 :: 12512512512512521524242
|
||||
big_number3 :: 12512512512512521524242
|
||||
big_number4 :: 12512512512512521524242
|
||||
big_number5 :: 12512512512512521524242 + big_number1 * big_number1
|
||||
binary_test :: (thing: S32 = 442)
|
||||
int_val :: 1000
|
||||
add :: int_val + 10 + 2.242 + 124
|
||||
mul :: 4 * 2
|
||||
bit_and :: 3 & 1
|
||||
bit_or :: 1 | 4
|
||||
bit_xor :: 8 ^ 7
|
||||
character :: 'ó
|
||||
|
||||
// '
|
||||
|
||||
boolean_equals :: true == false
|
||||
boolean_var: Bool = boolean_equals
|
||||
|
||||
cast_value :: 4242 + 32->S32 + 42->S32
|
||||
value: S32 = cast_value
|
||||
|
||||
bvar2 := int_val > 1
|
||||
if int_val < 1
|
||||
if int_val > 1
|
||||
pass
|
||||
|
||||
basic_type_assignment :: ()
|
||||
// custom_data1 := Custom_Data(thing = 23)
|
||||
// custom_data2: Custom_Data
|
||||
some_constant :: true
|
||||
thing: Bool = some_constant
|
||||
float_val :: 325.42
|
||||
float_var := float_val
|
||||
|
||||
|
||||
for_loops :: ()
|
||||
for thing2 := 10
|
||||
pass
|
||||
for thing1 := 10,,thing1+=1
|
||||
pass
|
||||
for
|
||||
pass
|
||||
for i := 0, i == 4, i+=1
|
||||
pass
|
||||
for j:=0, j < 10
|
||||
pass
|
||||
|
||||
/*
|
||||
Custom_Data :: struct
|
||||
thing: S32
|
||||
|
||||
get_element_item :: (array: []Custom_Data, index: S64): Custom_Data
|
||||
if index < array.len
|
||||
return array[index]
|
||||
else
|
||||
return Custom_Data()
|
||||
|
||||
get_element_pointer :: (array: []Custom_Data, index: S64): *Custom_Data
|
||||
if index < array.len
|
||||
return &array[index]
|
||||
else
|
||||
return 0
|
||||
|
||||
get_slice_len :: (array: []Custom_Data): S64
|
||||
return array.len
|
||||
|
||||
array_test :: ()
|
||||
thing := []Custom_Data(Custom_Data(1), Custom_Data(2))
|
||||
reference := thing
|
||||
length := reference.len
|
||||
|
||||
item := get_element_item(thing, 1)
|
||||
pointer := get_element_pointer(thing, 0)
|
||||
len := get_slice_len(thing)
|
||||
|
||||
with_size: [2]Custom_Data
|
||||
*/
|
||||
// get_slice_len(with_size)
|
||||
21
order1.kl
21
order1.kl
@@ -1,21 +0,0 @@
|
||||
order2 :: #load "order2.kl"
|
||||
|
||||
recursive_lambda :: (thing: S64)
|
||||
in_val := recursive_lambda
|
||||
some_value := thing + const_in_lambda
|
||||
|
||||
other_func :: ()
|
||||
a_val := recursive_lambda
|
||||
|
||||
const_in_lambda :: 10
|
||||
|
||||
not_const := val + 10
|
||||
val := CONSTANT_VAL
|
||||
|
||||
DEPENDENCE :: CONSTANT_VAL
|
||||
CONSTANT_VAL :: 10
|
||||
|
||||
global_thing: a_type = 10
|
||||
|
||||
arena: *order2.Arena
|
||||
order1_arena: order2.Arena
|
||||
69
order2.kl
69
order2.kl
@@ -1,69 +0,0 @@
|
||||
|
||||
Str16 :: String16
|
||||
arena_pointer: *Arena = 0
|
||||
order2_arena: Arena
|
||||
no_type := order2_arena
|
||||
|
||||
Arena :: struct
|
||||
next: *Arena
|
||||
data: *S64
|
||||
len : S64
|
||||
cap : S64
|
||||
|
||||
string16: Str16
|
||||
|
||||
String16 :: struct
|
||||
data: *void
|
||||
len : S64
|
||||
|
||||
thing := arena_pointer.len
|
||||
with_type: Arena = order2_arena
|
||||
test_dot := with_type.len
|
||||
pointer := &with_type
|
||||
deref := *pointer
|
||||
|
||||
|
||||
test_assignments :: ()
|
||||
i := 0
|
||||
i += 4
|
||||
i -= 1
|
||||
i *= 2
|
||||
i /= 2
|
||||
i %= 2
|
||||
i = 2
|
||||
i &= 2
|
||||
i |= 2
|
||||
i >>= 2
|
||||
i <<= 2
|
||||
|
||||
boolean := i > 2
|
||||
CONST :: 23 == 23
|
||||
CONST_FLOAT :: 23.52
|
||||
|
||||
j: *S64
|
||||
*j = 1
|
||||
/* invalid
|
||||
8 = 32
|
||||
i + 4 = 32
|
||||
i += "String"
|
||||
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
for
|
||||
pass
|
||||
for i:=0, i < 10, i+=1
|
||||
pass
|
||||
for array
|
||||
pass
|
||||
for it in array
|
||||
pass
|
||||
for it,i in array
|
||||
pass
|
||||
for i in 0..10
|
||||
pass
|
||||
|
||||
|
||||
|
||||
*/
|
||||
44
os.kl
44
os.kl
@@ -1,44 +0,0 @@
|
||||
#import "Windows.kl"
|
||||
#import "base.kl"
|
||||
|
||||
PAGE_SIZE :: 4096
|
||||
Memory :: struct
|
||||
commit : SizeU
|
||||
reserve: SizeU
|
||||
data : *U8
|
||||
|
||||
reserve :: (size: SizeU): Memory
|
||||
result := Memory{reserve=align_up(size, PAGE_SIZE)}
|
||||
result.data = VirtualAlloc(
|
||||
flProtect = PAGE_READWRITE,
|
||||
dwSize = result.reserve,
|
||||
flAllocationType = MEM_RESERVE,
|
||||
lpAddress = 0)->*U8
|
||||
return result
|
||||
|
||||
commit :: (m: *Memory, size: SizeU): Bool
|
||||
commit_size := align_up(size, PAGE_SIZE)
|
||||
total_commit := m.commit + commit_size
|
||||
clamped_commit := clamp_top_sizeu(total_commit, m.reserve)
|
||||
adjusted_commit := clamped_commit - m.commit
|
||||
if adjusted_commit != 0
|
||||
result := VirtualAlloc(
|
||||
lpAddress = (m.data + m.commit)->*void,
|
||||
dwSize = adjusted_commit,
|
||||
flAllocationType = MEM_COMMIT,
|
||||
flProtect = PAGE_READWRITE,
|
||||
)
|
||||
m.commit += adjusted_commit
|
||||
return true
|
||||
return false
|
||||
|
||||
release :: (m: *Memory)
|
||||
result := VirtualFree(m.data->*void, 0, MEM_RELEASE)
|
||||
if result != 0
|
||||
m.data = 0
|
||||
m.commit = 0
|
||||
m.reserve = 0
|
||||
|
||||
print :: (string: String)
|
||||
handle := GetStdHandle(STD_OUTPUT_HANDLE)
|
||||
WriteConsoleA(handle, &string[0]->*void, length_of(string)->DWORD, 0, 0)
|
||||
43
program.kl
43
program.kl
@@ -1,43 +0,0 @@
|
||||
#foreign printf :: (str: String, ...)
|
||||
|
||||
Token :: struct
|
||||
kind: U8
|
||||
str: *U8
|
||||
len: S64
|
||||
|
||||
Kind :: enum
|
||||
Number
|
||||
|
||||
|
||||
kind_name :: (kind: U8): String
|
||||
if kind == Token.Kind.Number
|
||||
return "<Number>"
|
||||
else
|
||||
return "<Unknown>"
|
||||
|
||||
is_numeric :: (c: U8): Bool
|
||||
result := c >= '0 && c <= '9
|
||||
return result
|
||||
|
||||
print_tokens :: (tokens: []Token)
|
||||
for i := 0, i < tokens.len, i++
|
||||
t := &tokens[i]
|
||||
printf("%d. %.*s", i, cast(t.len: S32), t.str)
|
||||
|
||||
entry :: ()
|
||||
string_to_lex := "Identifier 2425525 Not_Number"
|
||||
token_array: [32]Token
|
||||
token_count: S64 = 0
|
||||
|
||||
t: Token
|
||||
for i := 0, i < string_to_lex.len, i+=1
|
||||
if is_numeric(string_to_lex.str[i])
|
||||
t.kind = Token.Kind.Number
|
||||
t.str = &string_to_lex.str[i]
|
||||
t.len = i
|
||||
for is_numeric(string_to_lex.str[i])
|
||||
i+=1
|
||||
t.len = i - t.len
|
||||
token_array[token_count++] = t
|
||||
print_tokens(token_array)
|
||||
|
||||
Reference in New Issue
Block a user