Update usage text

Added static linking for macOS, too. There's literally %number% of us!

.gitignore

@@ -257,7 +257,17 @@ paket-files/
 builds/
 bin/
 *.exe
+*.obj
+*.pdb
 
 # - Linux/MacOS
 odin
 odin.dSYM
+
+
+# shared collection
+shared/
+
+# temp files
+* .ll
+*.bc

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2016 Ginger Bill. All rights reserved.
+Copyright (c) 2016-2017 Ginger Bill. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

Makefile

@@ -0,0 +1,24 @@
+DISABLED_WARNINGS=-Wno-switch -Wno-writable-strings -Wno-tautological-compare -Wno-macro-redefined #-Wno-pointer-sign -Wno-tautological-constant-out-of-range-compare  
+LDFLAGS=-pthread -ldl -lm -lstdc++
+CFLAGS=-std=c++11
+CC=clang
+
+OS=$(shell uname)
+
+ifeq ($(OS), DARWIN)
+	LDFLAGS=$(LDFLAGS) -liconv
+endif
+
+all: debug demo
+
+demo:
+	./odin run examples/demo.odin
+
+debug:
+	$(CC) src/main.cpp $(DISABLED_WARNINGS) $(CFLAGS) -g $(LDFLAGS) -o odin
+
+release:
+	$(CC) src/main.cpp $(DISABLED_WARNINGS) $(CFLAGS) -O3 -march=native $(LDFLAGS) -o odin
+	
+
+	

README.md

@@ -8,7 +8,6 @@ The Odin programming language is fast, concise, readable, pragmatic and open sou
 * built for modern systems
 * joy of programming
 * metaprogramming
-* designed for good programmers
 
 Website: [https://odin.handmade.network/](https://odin.handmade.network/)
 
@@ -20,15 +19,15 @@ Website: [https://odin.handmade.network/](https://odin.handmade.network/)
 * [Composition & Refactorability](https://www.youtube.com/watch?v=n1wemZfcbXM)
 * [Introspection, Modules, and Record Layout](https://www.youtube.com/watch?v=UFq8rhWhx4s)
 * [push_allocator & Minimal Dependency Building](https://www.youtube.com/watch?v=f_LGVOAMb78)
-* [when, for, & procedure overloading](https://www.youtube.com/watch?v=OzeOekzyZK8)
+* [when, for & procedure overloading](https://www.youtube.com/watch?v=OzeOekzyZK8)
-* [when, for, & procedure overloading](https://www.youtube.com/watch?v=OzeOekzyZK8)
 * [Context Types, Unexported Entities, Labelled Branches](https://www.youtube.com/watch?v=CkHVwT1Qk-g)
+* [Bit Fields, i128 & u128, Syntax Changes](https://www.youtube.com/watch?v=NlTutcLyF64)
 
 ## Requirements to build and run
 
 - Windows
 	* x86-64
-	* MSVC 2015 installed (C99 support)
+	* MSVC 2015 installed (C++11 support)
 	* [LLVM binaries](https://github.com/gingerBill/Odin/releases/tag/llvm-4.0-windows) for `opt.exe` and `llc.exe`
 	* Requires MSVC's link.exe as the linker
 		* run `vcvarsall.bat` to setup the path
@@ -42,7 +41,7 @@ Website: [https://odin.handmade.network/](https://odin.handmade.network/)
 	* x86-64
 	* Build tools (ld)
 	* LLVM installed
-	* Clang installed (temporary - this is calling the linker for now)
+	* Clang installed (temporary - this is Calling the linker for now)
 
 ## Warnings
 

build.bat

@@ -4,8 +4,8 @@
 set exe_name=odin.exe
 
 :: Debug = 0, Release = 1
-set release_mode=1
+set release_mode=0
-set compiler_flags= -nologo -Oi -TC -fp:fast -fp:except- -Gm- -MP -FC -GS- -EHsc- -GR-
+set compiler_flags= -nologo -Oi -TP -fp:fast -fp:except- -Gm- -MP -FC -GS- -EHsc- -GR-
 
 if %release_mode% EQU 0 ( rem Debug
 	set compiler_flags=%compiler_flags% -Od -MDd -Z7
@@ -38,17 +38,13 @@ if %release_mode% EQU 0 ( rem Debug
 set compiler_settings=%compiler_includes% %compiler_flags% %compiler_warnings%
 set linker_settings=%libs% %linker_flags%
 
-
 del *.pdb > NUL 2> NUL
 del *.ilk > NUL 2> NUL
 
-odin run code/demo.odin
+cl %compiler_settings% "src\main.cpp" ^
-rem cl %compiler_settings% "src\main.c" ^
+	/link %linker_settings% -OUT:%exe_name% ^
-	rem /link %linker_settings% -OUT:%exe_name% ^
+	&& odin run examples/demo.odin -opt=0
-	rem && odin run code/demo.odin
+	rem && odin docs core/fmt.odin
-	rem && odin build code/metagen.odin ^
-	rem && call "code\metagen.exe" "src\ast_nodes.metagen"
-	rem && odin run code/Jaze/src/main.odin
 
 del *.obj > NUL 2> NUL
 

build.sh

@@ -1,15 +1,21 @@
 #!/bin/bash
 
-release_mode=0
+release_mode=$1
 
-warnings_to_disable="-std=c11 -Wno-switch -Wno-pointer-sign -Wno-tautological-constant-out-of-range-compare -Wno-tautological-compare -Wno-macro-redefined"
+warnings_to_disable="-std=c++11 -Wno-switch -Wno-pointer-sign -Wno-tautological-constant-out-of-range-compare -Wno-tautological-compare -Wno-macro-redefined -Wno-writable-strings"
-libraries="-pthread -ldl -lm"
+libraries="-pthread -ldl -lm -lstdc++"
 other_args=""
 compiler="clang"
 
+if [ -z "$release_mode" ]; then release_mode="0"; fi
+
 if [ "$release_mode" -eq "0" ]; then
-	other_args="${other_args} -g -fno-inline-functions"
+	other_args="${other_args} -g"
 fi
+if [ "$release_mode" -eq "1" ]; then
+	other_args="${other_args} -O3 -march=native"
+fi
+
 if [[ "$(uname)" == "Darwin" ]]; then
 
 	# Set compiler to clang on MacOS
@@ -19,6 +25,4 @@ if [[ "$(uname)" == "Darwin" ]]; then
 	other_args="${other_args} -liconv"
 fi
 
-${compiler} src/main.c ${warnings_to_disable} ${libraries} ${other_args} -o odin
+${compiler} src/main.cpp ${warnings_to_disable} ${libraries} ${other_args} -o odin && ./odin run examples/demo.odin
-
-./odin run code/demo.odin

code/demo.odin

@@ -1,201 +0,0 @@
-//
-// Odin v0.3 Demo
-//
-
-#import "fmt.odin";
-
-main :: proc() {
-/*
-	Minor features
-	--------------
-
-	* Lexical sugar
-		- ≠, ≤, ≥
-	* Label syntax change
-		name: for {
-			break name;
-		}
-	* `#no_alias` (replacing keyword `no_alias`)
-	* `#ordered` reimplemented
-	* "bits.odin"
-	* `default:` is replaced with `case:`
-	* XOR for booleans
-	* Bug fixes
-	* Removed Quaternion types quaternion128 & quaternion256
-	* `rune` is a core type - allowing for extra type information at runtime
-	* `byte` is removed - use `u8` instead (which it was an alias for)
-*/
-
-	// 128 bit integers
-	{
-		x: u128 = 1234567890123;
-		y: u128 = 9876543210123;
-		z := (x * y) + x + y;
-		fmt.println(z);
-
-		a: i128 = +1234567890123;
-		b: i128 = -9876543210123;
-		c := (a * b) + a + b;
-		fmt.println(c);
-	}
-
-	// Divisor based modulo operator
-	{
-		x: i128 = -15;
-		y: i128 = 2;
-
-		fmt.println(x %  y); // Dividend based
-		fmt.println(x %% y); // Divisor based
-
-		// a %% b == ((a % b) + b) % b;
-	}
-
-	// Casting syntax
-	{
-		// Casting operations have had their syntax change for simplicity and consistency
-		// Original:
-		// Regular cast: `cast(type) expr`
-		// Bit cast:     `transmute(type) expr`
-		// Union cast:   `union_cast(type) expr`
-
-		// Regular Cast
-		f: f32 = 123.321;
-		i := i32(f); // type(expr)
-
-
-		// Bit cast
-		fbits := transmute(u32, f);
-
-
-
-		// Type assertion - replaces `union_cast`
-		Entity :: union {
-			id:       u64,
-			position: [vector 2]f32,
-			name:     string,
-
-			Tree{leaf_count: int},
-			Frog{ribbit_volume: f32},
-		}
-
-		e: Entity;
-		e = Entity.Frog{ribbit_volume = 0.5, name = "Trevor"};
-
-		if frog, ok := e.(Entity.Frog); ok {
-			fmt.printf("%s the frog ribbits at %f\n", frog.name, frog.ribbit_volume);
-		}
-
-		// Panics if the type assertion fails
-		frog := e.(Entity.Frog);
-
-		{
-			// Type assertion can also be applied to `any`
-			foo: any = 123;
-			if i, ok := foo.(int); ok {
-				fmt.println("Foo =", i);
-			}
-		}
-	}
-
-	// Syntax changes
-	{
-		// Originally `^` was used to represent pointer types, pointer dereferencing, and addressing of variables
-		// The addressing of variable operation is not represented with `&`
-		// This is to make sure the concept of a pointer type is separate from that of a addressing
-		// it is also used for familiarity coming from other C-like languages
-		x: int  = 123;
-		y: ^int = &x;
-		z: int  = y^;
-
-		// This change also allows type casting to not require parentheses around the type for pointer evaluation
-		// and consitency with other operations
-
-		data := rawptr(&x);
-		int_ptr := ^int(data);
-
-		array: [10]int; // Type of the left
-		x = array[0];   // Usage on the right
-
-		ptr: ^int = &z; // Type of the left
-		x = ptr^;       // Usage on the right
-
-
-
-		// Minor addition - member access through number
-		TupleLike :: struct{int, f32, string}; // Fields all anonymous
-		t: TupleLike;
-		t.0 = 123;
-		t.1 = 46.432;
-		t.2 = "Foo";
-		fmt.println(t);
-	}
-
-	// Bit fields
-	{
-		BoxProps :: bit_field {
-			opaque:       1,
-			fill_colour:  3,
-			_:            4,
-			show_border:  1,
-			_:            3,
-			border_style: 2,
-			_:            2,
-			width:        4,
-			height:       4,
-		};
-
-		props: BoxProps;
-		props.fill_colour = 4;
-		props.show_border = 1;
-		props.width       = 12;
-		props.height      = 10;
-
-		fmt.printf("Width: %d, Height: %d\n", props.width, props.height);
-
-
-
-		Float32Data :: bit_field #align 4 {
-			fraction: 23,
-			exponent:  8,
-			sign:      1,
-		}
-
-		f: f32 = -123.321;
-		data := transmute(Float32Data, f);
-		bits := transmute(u32, f);
-		fmt.printf("%#05x %#02x %v\n", data.fraction, data.exponent, bool(data.sign));
-		fmt.printf("%#08x\n", bits);
-	}
-
-	// Naming convention
-	{
-		// Odin has finally chose an official naming convention
-		// In general, PascalCase for types and snake_case for values
-
-		// Import Name:        snake_case (but prefer single word)
-		// Types:              PascalCase
-		// Union Variants:     PascalCase
-		// Enum Values:        PascalCase
-		// Procedures:         snake_case
-		// Local Variables:    snake_case
-		// Field Values:       snake_case
-		// Constant Variables: SCREAMING_SNAKE_CASE
-	}
-
-	// Goals for v0.4 and further
-	//  * Compile as C++ and use some of its constructs for sanity e.g. overloading
-	//  	- Safe array with bounds checking
-	//  	- Map type for self documentation
-	//  	- u128 i128 acting like core types
-	//  * Context system implemented as Implicit Parameter Passing (IPP) rather than Thread Local Storage (TLS)
-	//  * Parameter Polymorphism
-	//  	- Type parameter is procedures and types
-	//  * Decide upon a declaration syntax
-	//  	- Current Style (name: type;) vs Prefix Style (var name: type;)
-	//  * Import system with a "solution" for packages/modules/libraries
-	//  * Better foreign interfacing with C (and maybe C++)
-	//  	- Foreign variables
-	//  * Documentation Generation System for code
-	//  * General Documentation for Odin
-	//  * Attributes
-}

code/http_test.odin

@@ -1,180 +0,0 @@
-#import "fmt.odin";
-
-#foreign_system_library ws2 "Ws2_32.lib" when ODIN_OS == "windows";
-
-
-SOCKET :: #type uint;
-INVALID_SOCKET :: ~(cast(SOCKET)0);
-
-AF :: enum i32 {
-	UNSPEC    = 0,       // unspecified
-	UNIX      = 1,       // local to host (pipes, portals)
-	INET      = 2,       // internetwork: UDP, TCP, etc.
-	IMPLINK   = 3,       // arpanet imp addresses
-	PUP       = 4,       // pup protocols: e.g. BSP
-	CHAOS     = 5,       // mit CHAOS protocols
-	NS        = 6,       // XEROX NS protocols
-	ISO       = 7,       // ISO protocols
-	OSI       = ISO,     // OSI is ISO
-	ECMA      = 8,       // european computer manufacturers
-	DATAKIT   = 9,       // datakit protocols
-	CCITT     = 10,      // CCITT protocols, X.25 etc
-	SNA       = 11,      // IBM SNA
-	DECnet    = 12,      // DECnet
-	DLI       = 13,      // Direct data link interface
-	LAT       = 14,      // LAT
-	HYLINK    = 15,      // NSC Hyperchannel
-	APPLETALK = 16,      // AppleTalk
-	ROUTE     = 17,      // Internal Routing Protocol
-	LINK      = 18,      // Link layer interface
-	XTP       = 19,      // eXpress Transfer Protocol (no AF)
-	COIP      = 20,      // connection-oriented IP, aka ST II
-	CNT       = 21,      // Computer Network Technology
-	RTIP      = 22,      // Help Identify RTIP packets
-	IPX       = 23,      // Novell Internet Protocol
-	SIP       = 24,      // Simple Internet Protocol
-	PIP       = 25,      // Help Identify PIP packets
-	MAX       = 26,
-};
-
-SOCK_STREAM  :: 1;
-SOCKET_ERROR :: -1;
-IPPROTO_TCP  :: 6;
-AI_PASSIVE   :: 0x0020;
-SOMAXCONN    :: 128;
-
-SD_RECEIVE :: 0;
-SD_SEND    :: 1;
-SD_BOTH    :: 2;
-
-WSADESCRIPTION_LEN :: 256;
-WSASYS_STATUS_LEN  :: 128;
-WSADATA :: struct #ordered {
-	version:       i16,
-	high_version:  i16,
-
-
-// NOTE(bill): This is x64 ordering
-	max_sockets:   u16,
-	max_udp_dg:    u16,
-	vendor_info:   ^byte,
-	description:   [WSADESCRIPTION_LEN+1]byte,
-	system_status: [WSASYS_STATUS_LEN+1]byte,
-}
-
-addrinfo :: struct #ordered {
-	flags:     i32,
-	family:    i32,
-	socktype:  i32,
-	protocol:  i32,
-	addrlen:   uint,
-	canonname: ^u8,
-	addr:      ^sockaddr,
-	next:      ^addrinfo,
-}
-
-sockaddr :: struct #ordered {
-	family: u16,
-	data:   [14]byte,
-}
-
-
-WSAStartup      :: proc(version_requested: i16, data: ^WSADATA) -> i32                             #foreign ws2;
-WSACleanup      :: proc() -> i32                                                                   #foreign ws2;
-getaddrinfo     :: proc(node_name, service_name: ^u8, hints: ^addrinfo, result: ^^addrinfo) -> i32 #foreign ws2;
-freeaddrinfo    :: proc(ai: ^addrinfo)                                                             #foreign ws2;
-socket          :: proc(af, type_, protocol: i32) -> SOCKET                                        #foreign ws2;
-closesocket     :: proc(s: SOCKET) -> i32                                                          #foreign ws2;
-bind            :: proc(s: SOCKET, name: ^sockaddr, name_len: i32) -> i32                          #foreign ws2;
-listen          :: proc(s: SOCKET, back_log: i32) -> i32                                           #foreign ws2;
-accept          :: proc(s: SOCKET, addr: ^sockaddr, addr_len: i32) -> SOCKET                       #foreign ws2;
-recv            :: proc(s: SOCKET, buf: ^byte, len: i32, flags: i32) -> i32                        #foreign ws2;
-send            :: proc(s: SOCKET, buf: ^byte, len: i32, flags: i32) -> i32                        #foreign ws2;
-shutdown        :: proc(s: SOCKET, how: i32) -> i32                                                #foreign ws2;
-WSAGetLastError :: proc() -> i32                                                                   #foreign ws2;
-
-to_c_string :: proc(s: string) -> ^byte {
-	c_str := new_slice(byte, s.count+1);
-	assert(c_str.data != nil);
-	copy(c_str, cast([]byte)s);
-	c_str[s.count] = 0;
-	return c_str.data;
-}
-
-run :: proc() {
-	wsa: WSADATA;
-	res:  ^addrinfo = nil;
-	hints: addrinfo;
-	s, client: SOCKET;
-
-	if WSAStartup(2 | (2 << 8), ^wsa) != 0 {
-		fmt.println("WSAStartup failed: ", WSAGetLastError());
-		return;
-	}
-	defer WSACleanup();
-
-	hints.family   = cast(i32)AF.INET;
-	hints.socktype = SOCK_STREAM;
-	hints.protocol = IPPROTO_TCP;
-	hints.flags    = AI_PASSIVE;
-
-	if getaddrinfo(nil, to_c_string("8080"), ^hints, ^res) != 0 {
-		fmt.println("getaddrinfo failed: ", WSAGetLastError());
-		return;
-	}
-	defer freeaddrinfo(res);
-
-	s = socket(res.family, res.socktype, res.protocol);
-	if s == INVALID_SOCKET {
-		fmt.println("socket failed: ", WSAGetLastError());
-		return;
-	}
-	defer closesocket(s);
-
-	bind(s, res.addr, cast(i32)res.addrlen);
-	listen(s, SOMAXCONN);
-
-	client = accept(s, nil, 0);
-	if client == INVALID_SOCKET {
-		fmt.println("socket failed: ", WSAGetLastError());
-		return;
-	}
-	defer closesocket(client);
-
-	html :=
-`HTTP/1.1 200 OK
-Connection: close
-Content-type: text/html
-
-<html>
-<head>
-	<title>Demo Title</title>
-</head>
-<body>
-	<h1 style="color: orange;">Odin Server Demo</h1>
-</body>
-</html>
-`;
-
-	buf: [1024]byte;
-	for {
-		bytes := recv(client, ^buf[0], cast(i32)buf.count, 0);
-		if bytes > 0 {
-			// fmt.println(buf[:bytes] as string)
-			bytes_sent := send(client, html.data, cast(i32)(html.count-1), 0);
-			if bytes_sent == SOCKET_ERROR {
-				fmt.println("send failed: ", WSAGetLastError());
-				return;
-			}
-			break;
-		} else if bytes == 0 {
-			fmt.println("Connection closing...");
-			break;
-		} else {
-			fmt.println("recv failed: ", WSAGetLastError());
-			return;
-		}
-	}
-
-	shutdown(client, SD_SEND);
-}

code/punity.odin

@@ -1,489 +0,0 @@
-#import win32 "sys/windows.odin";
-#import "fmt.odin";
-#import "os.odin";
-#import "mem.odin";
-
-CANVAS_WIDTH  :: 128;
-CANVAS_HEIGHT :: 128;
-CANVAS_SCALE  :: 3;
-FRAME_TIME    :: 1.0/30.0;
-WINDOW_TITLE  :: "Punity\x00";
-
-_ := compile_assert(CANVAS_WIDTH % 16 == 0);
-
-WINDOW_WIDTH  :: CANVAS_WIDTH  * CANVAS_SCALE;
-WINDOW_HEIGHT :: CANVAS_HEIGHT * CANVAS_SCALE;
-
-
-STACK_CAPACITY   :: 1<<20;
-STORAGE_CAPACITY :: 1<<20;
-
-DRAW_LIST_RESERVE :: 128;
-
-MAX_KEYS :: 256;
-
-Core :: struct {
-	stack:   ^Bank,
-	storage: ^Bank,
-
-	running:       bool,
-	key_modifiers: u32,
-	key_states:    [MAX_KEYS]byte,
-	key_deltas:    [MAX_KEYS]byte,
-
-	perf_frame,
-	perf_frame_inner,
-	perf_step,
-	perf_audio,
-	perf_blit,
-	perf_blit_cvt,
-	perf_blit_gdi: Perf_Span,
-
-	frame: i64,
-
-	canvas:    Canvas,
-	draw_list: ^Draw_List,
-}
-
-Perf_Span :: struct {
-	stamp: f64,
-	delta: f32,
-}
-
-Bank :: struct {
-	memory: []byte,
-	cursor: int,
-}
-
-Bank_State :: struct {
-	state: Bank,
-	bank: ^Bank,
-}
-
-
-Color :: raw_union {
-	using channels: struct{a, b, g, r: byte},
-	rgba: u32,
-}
-
-Palette :: struct {
-	colors: [256]Color,
-	colors_count: byte,
-}
-
-
-Rect :: raw_union {
-	using minmax: struct {min_x, min_y, max_x, max_y: int},
-	using pos: struct {left, top, right, bottom: int},
-	e: [4]int,
-}
-
-Bitmap :: struct {
-	pixels: []byte,
-	width:  int,
-	height: int,
-}
-
-Font :: struct {
-	using bitmap: Bitmap,
-	char_width:   int,
-	char_height:  int,
-}
-
-Canvas :: struct {
-	using bitmap: ^Bitmap,
-	palette:      Palette,
-	translate_x:  int,
-	translate_y:  int,
-	clip:         Rect,
-	font:         ^Font,
-}
-
-DrawFlag :: enum {
-	NONE   = 0,
-	FLIP_H = 1<<0,
-	FLIP_V = 1<<1,
-	MASK   = 1<<2,
-}
-
-Draw_Item :: struct {}
-Draw_List :: struct {
-	items: []Draw_Item,
-}
-
-Key :: enum {
-	MOD_SHIFT   = 0x0001,
-	MOD_CONTROL = 0x0002,
-	MOD_ALT     = 0x0004,
-	MOD_SUPER   = 0x0008,
-
-	UNKNOWN            =-1,
-	INVALID            =-2,
-
-	LBUTTON            = 1,
-	RBUTTON            = 2,
-	CANCEL             = 3,
-	MBUTTON            = 4,
-
-	BACK               = 8,
-	TAB                = 9,
-	CLEAR              = 12,
-	RETURN             = 13,
-	SHIFT              = 16,
-	CONTROL            = 17,
-	MENU               = 18,
-	PAUSE              = 19,
-	CAPITAL            = 20,
-	KANA               = 0x15,
-	HANGEUL            = 0x15,
-	HANGUL             = 0x15,
-	JUNJA              = 0x17,
-	FINAL              = 0x18,
-	HANJA              = 0x19,
-	KANJI              = 0x19,
-	ESCAPE             = 0x1B,
-	CONVERT            = 0x1C,
-	NONCONVERT         = 0x1D,
-	ACCEPT             = 0x1E,
-	MODECHANGE         = 0x1F,
-	SPACE              = 32,
-	PRIOR              = 33,
-	NEXT               = 34,
-	END                = 35,
-	HOME               = 36,
-	LEFT               = 37,
-	UP                 = 38,
-	RIGHT              = 39,
-	DOWN               = 40,
-	SELECT             = 41,
-	PRINT              = 42,
-	EXEC               = 43,
-	SNAPSHOT           = 44,
-	INSERT             = 45,
-	DELETE             = 46,
-	HELP               = 47,
-	LWIN               = 0x5B,
-	RWIN               = 0x5C,
-	APPS               = 0x5D,
-	SLEEP              = 0x5F,
-	NUMPAD0            = 0x60,
-	NUMPAD1            = 0x61,
-	NUMPAD2            = 0x62,
-	NUMPAD3            = 0x63,
-	NUMPAD4            = 0x64,
-	NUMPAD5            = 0x65,
-	NUMPAD6            = 0x66,
-	NUMPAD7            = 0x67,
-	NUMPAD8            = 0x68,
-	NUMPAD9            = 0x69,
-	MULTIPLY           = 0x6A,
-	ADD                = 0x6B,
-	SEPARATOR          = 0x6C,
-	SUBTRACT           = 0x6D,
-	DECIMAL            = 0x6E,
-	DIVIDE             = 0x6F,
-	F1                 = 0x70,
-	F2                 = 0x71,
-	F3                 = 0x72,
-	F4                 = 0x73,
-	F5                 = 0x74,
-	F6                 = 0x75,
-	F7                 = 0x76,
-	F8                 = 0x77,
-	F9                 = 0x78,
-	F10                = 0x79,
-	F11                = 0x7A,
-	F12                = 0x7B,
-	F13                = 0x7C,
-	F14                = 0x7D,
-	F15                = 0x7E,
-	F16                = 0x7F,
-	F17                = 0x80,
-	F18                = 0x81,
-	F19                = 0x82,
-	F20                = 0x83,
-	F21                = 0x84,
-	F22                = 0x85,
-	F23                = 0x86,
-	F24                = 0x87,
-	NUMLOCK            = 0x90,
-	SCROLL             = 0x91,
-	LSHIFT             = 0xA0,
-	RSHIFT             = 0xA1,
-	LCONTROL           = 0xA2,
-	RCONTROL           = 0xA3,
-	LMENU              = 0xA4,
-	RMENU              = 0xA5,
-
-	APOSTROPHE         = 39,  /* ' */
-	COMMA              = 44,  /* , */
-	MINUS              = 45,  /* - */
-	PERIOD             = 46,  /* . */
-	SLASH              = 47,  /* / */
-	NUM0               = 48,
-	NUM1               = 49,
-	NUM2               = 50,
-	NUM3               = 51,
-	NUM4               = 52,
-	NUM5               = 53,
-	NUM6               = 54,
-	NUM7               = 55,
-	NUM8               = 56,
-	NUM9               = 57,
-	SEMICOLON          = 59,  /* ; */
-	EQUAL              = 61,  /* = */
-	A                  = 65,
-	B                  = 66,
-	C                  = 67,
-	D                  = 68,
-	E                  = 69,
-	F                  = 70,
-	G                  = 71,
-	H                  = 72,
-	I                  = 73,
-	J                  = 74,
-	K                  = 75,
-	L                  = 76,
-	M                  = 77,
-	N                  = 78,
-	O                  = 79,
-	P                  = 80,
-	Q                  = 81,
-	R                  = 82,
-	S                  = 83,
-	T                  = 84,
-	U                  = 85,
-	V                  = 86,
-	W                  = 87,
-	X                  = 88,
-	Y                  = 89,
-	Z                  = 90,
-	LEFT_BRACKET       = 91,  /* [ */
-	BACKSLASH          = 92,  /* \ */
-	RIGHT_BRACKET      = 93,  /* ] */
-	GRAVE_ACCENT       = 96,  /* ` */
-};
-
-
-key_down :: proc(k: Key) -> bool {
-	return _core.key_states[k] != 0;
-}
-
-key_pressed :: proc(k: Key) -> bool {
-	return (_core.key_deltas[k] != 0) && key_down(k);
-}
-
-
-
-
-win32_perf_count_freq := win32.GetQueryPerformanceFrequency();
-time_now :: proc() -> f64 {
-	assert(win32_perf_count_freq != 0);
-
-	counter: i64;
-	win32.QueryPerformanceCounter(^counter);
-	result := cast(f64)counter / cast(f64)win32_perf_count_freq;
-	return result;
-}
-
-_core: Core;
-
-run :: proc(user_init, user_step: proc(c: ^Core)) {
-	using win32;
-
-	_core.running = true;
-
-	win32_proc :: proc(hwnd: win32.HWND, msg: u32, wparam: win32.WPARAM, lparam: win32.LPARAM) -> win32.LRESULT #no_inline #cc_c {
-		win32_app_key_mods :: proc() -> u32 {
-			mods: u32 = 0;
-
-			if is_key_down(Key_Code.SHIFT) {
-				mods |= cast(u32)Key.MOD_SHIFT;
-			}
-			if is_key_down(Key_Code.CONTROL) {
-				mods |= cast(u32)Key.MOD_CONTROL;
-			}
-			if is_key_down(Key_Code.MENU) {
-				mods |= cast(u32)Key.MOD_ALT;
-			}
-			if is_key_down(Key_Code.LWIN) || is_key_down(Key_Code.RWIN) {
-				mods |= cast(u32)Key.MOD_SUPER;
-			}
-
-			return mods;
-		}
-
-		match msg {
-		case WM_KEYDOWN:
-			_core.key_modifiers = win32_app_key_mods();
-			if wparam < MAX_KEYS {
-				_core.key_states[wparam] = 1;
-				_core.key_deltas[wparam] = 1;
-			}
-			return 0;
-
-		case WM_KEYUP:
-			_core.key_modifiers = win32_app_key_mods();
-			if wparam < MAX_KEYS {
-				_core.key_states[wparam] = 0;
-				_core.key_deltas[wparam] = 1;
-			}
-			return 0;
-
-		case WM_CLOSE:
-			PostQuitMessage(0);
-			_core.running = false;
-			return 0;
-		}
-
-		return DefWindowProcA(hwnd, msg, wparam, lparam);
-	}
-
-
-	window_class := WNDCLASSEXA{
-		class_name = (cast(string)"Punity\x00").data, // C-style string
-		size       = size_of(WNDCLASSEXA),
-		style      = CS_HREDRAW | CS_VREDRAW | CS_OWNDC,
-		instance   = cast(HINSTANCE)GetModuleHandleA(nil),
-		wnd_proc   = win32_proc,
-		// wnd_proc   = DefWindowProcA,
-		background = cast(HBRUSH)GetStockObject(BLACK_BRUSH),
-	};
-
-	if RegisterClassExA(^window_class) == 0 {
-		fmt.fprintln(os.stderr, "RegisterClassExA failed");
-		return;
-	}
-
-	screen_width  := GetSystemMetrics(SM_CXSCREEN);
-	screen_height := GetSystemMetrics(SM_CYSCREEN);
-
-	rc: RECT;
-	rc.left   = (screen_width - WINDOW_WIDTH)   / 2;
-	rc.top    = (screen_height - WINDOW_HEIGHT) / 2;
-	rc.right  = rc.left + WINDOW_WIDTH;
-	rc.bottom = rc.top + WINDOW_HEIGHT;
-
-	style: u32 = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
-	assert(AdjustWindowRect(^rc, style, 0) != 0);
-
-	wt := WINDOW_TITLE;
-
-	win32_window := CreateWindowExA(0,
-	                                window_class.class_name,
-	                                wt.data,
-	                                style,
-	                                rc.left, rc.top,
-	                                rc.right-rc.left, rc.bottom-rc.top,
-	                                nil, nil, window_class.instance,
-	                                nil);
-
-	if win32_window == nil {
-		fmt.fprintln(os.stderr, "CreateWindowExA failed");
-		return;
-	}
-
-
-	window_bmi: BITMAPINFO;
-	window_bmi.size        = size_of(BITMAPINFOHEADER);
-	window_bmi.width       = CANVAS_WIDTH;
-	window_bmi.height      = CANVAS_HEIGHT;
-	window_bmi.planes      = 1;
-	window_bmi.bit_count   = 32;
-	window_bmi.compression = BI_RGB;
-
-
-	user_init(^_core);
-
-	ShowWindow(win32_window, SW_SHOW);
-
-	window_buffer := new_slice(u32, CANVAS_WIDTH * CANVAS_HEIGHT);
-	defer free(window_buffer);
-
-
-	for i := 0; i < window_buffer.count; i += 1 {
-		window_buffer[i] = 0xff00ff;
-	}
-
-
-	dt: f64;
-	prev_time := time_now();
-	curr_time := time_now();
-	total_time : f64 = 0;
-	offset_x := 0;
-	offset_y := 0;
-
-	message: MSG;
-	for _core.running {
-		curr_time = time_now();
-		dt = curr_time - prev_time;
-		prev_time = curr_time;
-		total_time += dt;
-
-		offset_x += 1;
-		offset_y += 2;
-
-		{
-			data: [128]byte;
-			buf: fmt.Buffer;
-			buf.data = data[:];
-			fmt.bprintf(^buf, "Punity: %.4f ms\x00", dt*1000);
-			win32.SetWindowTextA(win32_window, ^buf[0]);
-		}
-
-
-		for y := 0; y < CANVAS_HEIGHT; y += 1 {
-			for x := 0; x < CANVAS_WIDTH; x += 1 {
-				g := (x % 32) * 8;
-				b := (y % 32) * 8;
-				window_buffer[x + y*CANVAS_WIDTH] = cast(u32)(g << 8 | b);
-			}
-		}
-
-		mem.zero(^_core.key_deltas[0], size_of_val(_core.key_deltas));
-
-		for PeekMessageA(^message, nil, 0, 0, PM_REMOVE) != 0 {
-			if message.message == WM_QUIT {
-				_core.running = false;
-			}
-			TranslateMessage(^message);
-			DispatchMessageA(^message);
-		}
-
-		user_step(^_core);
-
-		dc := GetDC(win32_window);
-		StretchDIBits(dc,
-		              0, 0, CANVAS_WIDTH * CANVAS_SCALE, CANVAS_HEIGHT * CANVAS_SCALE,
-		              0, 0, CANVAS_WIDTH, CANVAS_HEIGHT,
-		              window_buffer.data,
-		              ^window_bmi,
-		              DIB_RGB_COLORS,
-		              SRCCOPY);
-		ReleaseDC(win32_window, dc);
-
-
-		{
-			delta := time_now() - prev_time;
-			ms := cast(i32)((FRAME_TIME - delta) * 1000);
-			if ms > 0 {
-				win32.Sleep(ms);
-			}
-		}
-
-		_core.frame += 1;
-	}
-}
-
-
-main :: proc() {
-	user_init :: proc(c: ^Core) {
-
-	}
-
-	user_step :: proc(c: ^Core) {
-
-	}
-
-	run(user_init, user_step);
-}

code/sub/test.odin

@@ -1,5 +0,0 @@
-#import "fmt.odin" as fmt
-
-thing :: proc() {
-	fmt.println("Sub Hello!")
-}

code/test.odin

@@ -1,35 +0,0 @@
-/*#import "fmt.odin"
-
-thing :: proc() {
-	fmt.println("Hello1!")
-}*/
-
-
-#import "fmt.odin";
-
-main :: proc() {
-	fmt.println("hello, world!");
-}
-
-
-/*#import "fmt.odin" as .
-
-thing :: proc() {
-	println("Hello3!")
-}
-
-
-*/
-/*#import "fmt.odin" as _
-
-thing :: proc() {
-	// println("Hello4!")
-}
-*/
-
-/*
-#include "fmt.odin"
-
-thing :: proc() {
-	println("Hello5!")
-}*/

core/_soft_numbers.odin

@@ -1,26 +1,67 @@
-#shared_global_scope;
+#shared_global_scope
 
-__u128_mod :: proc(a, b: u128) -> u128 #cc_odin #link_name "__umodti3" {
+@(link_name="__multi3")
+__multi3 :: proc "c" (a, b: u128) -> u128 {
+	bits_in_dword_2 :: size_of(i64) * 4;
+	lower_mask :: u128(~u64(0) >> bits_in_dword_2);
+
+
+	when ODIN_ENDIAN == "big" {
+		TWords :: struct #raw_union {
+			all: u128,
+			using _: struct {lo, hi: u64},
+		};
+	} else {
+		TWords :: struct #raw_union {
+			all: u128,
+			using _: struct {hi, lo: 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(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.lo &= u64(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);
+	return r.all;
+}
+
+@(link_name="__umodti3")
+__u128_mod :: proc "c" (a, b: u128) -> u128 {
 	r: u128;
 	__u128_quo_mod(a, b, &r);
 	return r;
 }
 
-__u128_quo :: proc(a, b: u128) -> u128 #cc_odin #link_name "__udivti3" {
+@(link_name="__udivti3")
+__u128_quo :: proc "c" (a, b: u128) -> u128 {
 	return __u128_quo_mod(a, b, nil);
 }
 
-__i128_mod :: proc(a, b: i128) -> i128 #cc_odin #link_name "__modti3" {
+@(link_name="__modti3")
+__i128_mod :: proc "c" (a, b: i128) -> i128 {
 	r: i128;
 	__i128_quo_mod(a, b, &r);
 	return r;
 }
 
-__i128_quo :: proc(a, b: i128) -> i128 #cc_odin #link_name "__divti3" {
+@(link_name="__divti3")
+__i128_quo :: proc "c" (a, b: i128) -> i128 {
 	return __i128_quo_mod(a, b, nil);
 }
 
-__i128_quo_mod :: proc(a, b: i128, rem: ^i128) -> (quo: i128) #cc_odin #link_name "__divmodti4" {
+@(link_name="__divmodti4")
+__i128_quo_mod :: proc "c" (a, b: i128, rem: ^i128) -> (quo: i128) {
 	s: i128;
 	s = b >> 127;
 	b = (b~s) - s;
@@ -28,22 +69,23 @@ __i128_quo_mod :: proc(a, b: i128, rem: ^i128) -> (quo: i128) #cc_odin #link_nam
 	b = (a~s) - s;
 
 	uquo: u128;
-	urem := __u128_quo_mod(transmute(u128, a), transmute(u128, b), &uquo);
+	urem := __u128_quo_mod(transmute(u128)a, transmute(u128)b, &uquo);
-	iquo := transmute(i128, uquo);
+	iquo := transmute(i128)uquo;
-	irem := transmute(i128, urem);
+	irem := transmute(i128)urem;
 
 	iquo = (iquo~s) - s;
 	irem = (irem~s) - s;
-	if rem != nil { rem^ = irem; }
+	if rem != nil do rem^ = irem;
 	return iquo;
 }
 
 
-__u128_quo_mod :: proc(a, b: u128, rem: ^u128) -> (quo: u128) #cc_odin #link_name "__udivmodti4" {
+@(link_name="__udivmodti4")
-	alo, ahi := u64(a), u64(a>>64);
+__u128_quo_mod :: proc "c" (a, b: u128, rem: ^u128) -> (quo: u128) {
-	blo, bhi := u64(b), u64(b>>64);
+	alo := u64(a);
+	blo := u64(b);
 	if b == 0 {
-		if rem != nil { rem^ = 0; }
+		if rem != nil do rem^ = 0;
 		return u128(alo/blo);
 	}
 
@@ -63,130 +105,6 @@ __u128_quo_mod :: proc(a, b: u128, rem: ^u128) -> (quo: u128) #cc_odin #link_nam
 		d >>= 1;
 	}
 
-	if rem != nil { rem^ = r; }
+	if rem != nil do rem^ = r;
 	return q;
 }
-
-/*
-__f16_to_f32 :: proc(f: f16) -> f32 #cc_odin #no_inline #link_name "__gnu_h2f_ieee" {
-	when true {
-		// Source: https://fgiesen.wordpress.com/2012/03/28/half-to-float-done-quic/
-		FP32 :: raw_union {u: u32, f: f32};
-
-		magic, was_infnan: FP32;
-		magic.u = (254-15) << 23;
-		was_infnan.u = (127+16) << 23;
-
-		hu := transmute(u16, f);
-
-		o := FP32{};
-
-		o.u = u32((hu & 0x7fff) << 13);
-		o.f *= magic.f;
-		if o.f >= was_infnan.f {
-			o.u |= 255 << 23;
-		}
-		o.u |= u32(hu & 0x8000) << 16;
-		return o.f;
-	} else {
-		return 0;
-	}
-}
-__f32_to_f16 :: proc(f_: f32) -> f16 #cc_odin #no_inline #link_name "__gnu_f2h_ieee" {
-	when false {
-		// Source: https://gist.github.com/rygorous/2156668
-		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;
-
-		sign_mask :: u32(0x80000000);
-		round_mask :: ~u32(0x0fff);
-
-		f := transmute(FP32, f_);
-
-		o: FP16;
-		sign := f.u & sign_mask;
-		f.u ~= sign;
-
-		// NOTE all the integer compares in this function can be safely
-		// compiled into signed compares since all operands are below
-		// 0x80000000. Important if you want fast straight SSE2 code
-		// (since there's no unsigned PCMPGTD).
-
-		if f.u >= f32infty.u { // Inf or NaN (all exponent bits set)
-			o.u = f.u > f32infty.u ? 0x7e00 : 0x7c00; // NaN->qNaN and Inf->Inf
-		} else { // (De)normalized number or zero
-			f.u &= round_mask;
-			f.f *= magic.f;
-			f.u -= round_mask;
-			if f.u > f16infty.u {
-				f.u = f16infty.u; // Clamp to signed infinity if overflowed
-			}
-
-			o.u = u16(f.u >> 13); // Take the bits!
-		}
-
-		o.u |= u16(sign >> 16);
-		return o.f;
-	} else {
-		f := transmute(u32, f_);
-		h: u16;
-		hs, he, hf: u16;
-
-		fs := (f >> 31) & 1;
-		fe := (f >> 23) & 0b1111_1111;
-		ff := (f >> 0)  & 0b0111_1111_1111_1111_1111_1111;
-
-		add_one := false;
-
-		if (fe == 0) {
-			he = 0;
-		} else if (fe == 255) {
-			he = 31;
-			hf = ff != 0 ? 0x200 : 0;
-		} else {
-			ne := fe - 127 + 15;
-			if ne >= 31 {
-				he = 31;
-			} else if ne <= 0 {
-				if (14-ne) <= 24 {
-					mant := ff | 0x800000;
-					hf = u16(mant >> (14-ne));
-
-					if (mant >> (13-ne)) & 1 != 0 {
-						add_one = true;
-					}
-				}
-			} else {
-				he = u16(ne);
-				hf = u16(ff >> 13);
-				if ff&0x1000 != 0 {
-					add_one = true;
-				}
-			}
-		}
-
-
-		hs = u16(hs);
-		h |= (he&0b0001_1111)<<10;
-		h |= (hf&0b0011_1111_1111);
-		if add_one {
-			h++;
-		}
-		h |= (hs&1) << 15;
-		return transmute(f16, h);
-	}
-}
-
-__f64_to_f16 :: proc(f: f64) -> f16 #cc_odin #no_inline #link_name "__truncdfhf2" {
-	return __f32_to_f16(f32(f));
-}
-
-__f16_to_f64 :: proc(f: f16) -> f64 #cc_odin #no_inline {
-	return f64(__f16_to_f32(f));
-}
-*/

core/atomics.odin

@@ -1,8 +1,10 @@
 // TODO(bill): Use assembly instead here to implement atomics
 // Inline vs external file?
 
-#import win32 "sys/windows.odin" when ODIN_OS == "windows";
+when ODIN_OS == "windows" {
-_ := compile_assert(ODIN_ARCH == "amd64"); // TODO(bill): x86 version
+	import win32 "core:sys/windows.odin"
+}
+_ :: compile_assert(ODIN_ARCH == "amd64"); // TODO(bill): x86 version
 
 
 yield_thread :: proc() { win32.mm_pause(); }
@@ -37,7 +39,7 @@ spin_lock :: proc(a: ^i32, time_out: int) -> bool { // NOTE(bill) time_out = -1
 	old_value := compare_exchange(a, 1, 0);
 	counter := 0;
 	for old_value != 0 && (time_out < 0 || counter < time_out) {
-		counter++;
+		counter += 1;
 		yield_thread();
 		old_value = compare_exchange(a, 1, 0);
 		mfence();
@@ -81,7 +83,7 @@ spin_lock :: proc(a: ^i64, time_out: int) -> bool { // NOTE(bill) time_out = -1
 	old_value := compare_exchange(a, 1, 0);
 	counter := 0;
 	for old_value != 0 && (time_out < 0 || counter < time_out) {
-		counter++;
+		counter += 1;
 		yield_thread();
 		old_value = compare_exchange(a, 1, 0);
 		mfence();

core/bits.odin

@@ -4,37 +4,93 @@ 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);
-
 U8_MAX   ::   ~u8(0);
 U16_MAX  ::  ~u16(0);
 U32_MAX  ::  ~u32(0);
 U64_MAX  ::  ~u64(0);
 U128_MAX :: ~u128(0);
 
-I8_MAX   ::   i8(0x7f);
+I8_MIN   ::   i8(  ~u8(0) >> 1);
-I16_MAX  ::  i16(0x7fff);
+I16_MIN  ::  i16( ~u16(0) >> 1);
-I32_MAX  ::  i32(0x7fff_ffff);
+I32_MIN  ::  i32( ~u32(0) >> 1);
-I64_MAX  ::  i64(0x7fff_ffff_ffff_ffff);
+I64_MIN  ::  i64( ~u64(0) >> 1);
-I128_MAX :: i128(0x7fff_ffff_ffff_ffff_ffff_ffff_ffff_ffff);
+I128_MIN :: i128(~u128(0) >> 1);
 
+I8_MAX   ::   -I8_MIN - 1;
+I16_MAX  ::  -I16_MIN - 1;
+I32_MAX  ::  -I32_MIN - 1;
+I64_MAX  ::  -I64_MIN - 1;
+I128_MAX :: -I128_MIN - 1;
 
-count_ones :: proc(i:   u8) ->   u8 { __llvm_ctpop :: proc(u8)   ->   u8 #foreign __llvm_core "llvm.ctpop.i8";  return __llvm_ctpop(i); }
+foreign __llvm_core {
-count_ones :: proc(i:   i8) ->   i8 { __llvm_ctpop :: proc(i8)   ->   i8 #foreign __llvm_core "llvm.ctpop.i8";  return __llvm_ctpop(i); }
+	@(link_name="llvm.ctpop.i8")        __llvm_ctpop :: proc(u8)   ->   u8 ---;
-count_ones :: proc(i:  u16) ->  u16 { __llvm_ctpop :: proc(u16)  ->  u16 #foreign __llvm_core "llvm.ctpop.i16"; return __llvm_ctpop(i); }
+	@(link_name="llvm.ctpop.i8")        __llvm_ctpop :: proc(i8)   ->   i8 ---;
-count_ones :: proc(i:  i16) ->  i16 { __llvm_ctpop :: proc(i16)  ->  i16 #foreign __llvm_core "llvm.ctpop.i16"; return __llvm_ctpop(i); }
+	@(link_name="llvm.ctpop.i16")       __llvm_ctpop :: proc(u16)  ->  u16 ---;
-count_ones :: proc(i:  u32) ->  u32 { __llvm_ctpop :: proc(u32)  ->  u32 #foreign __llvm_core "llvm.ctpop.i32"; return __llvm_ctpop(i); }
+	@(link_name="llvm.ctpop.i16")       __llvm_ctpop :: proc(i16)  ->  i16 ---;
-count_ones :: proc(i:  i32) ->  i32 { __llvm_ctpop :: proc(i32)  ->  i32 #foreign __llvm_core "llvm.ctpop.i32"; return __llvm_ctpop(i); }
+	@(link_name="llvm.ctpop.i32")       __llvm_ctpop :: proc(u32)  ->  u32 ---;
-count_ones :: proc(i:  u64) ->  u64 { __llvm_ctpop :: proc(u64)  ->  u64 #foreign __llvm_core "llvm.ctpop.i64"; return __llvm_ctpop(i); }
+	@(link_name="llvm.ctpop.i32")       __llvm_ctpop :: proc(i32)  ->  i32 ---;
-count_ones :: proc(i:  i64) ->  i64 { __llvm_ctpop :: proc(i64)  ->  i64 #foreign __llvm_core "llvm.ctpop.i64"; return __llvm_ctpop(i); }
+	@(link_name="llvm.ctpop.i64")       __llvm_ctpop :: proc(u64)  ->  u64 ---;
-count_ones :: proc(i: u128) -> u128 { __llvm_ctpop :: proc(u128) -> u128 #foreign __llvm_core "llvm.ctpop.i128";return __llvm_ctpop(i); }
+	@(link_name="llvm.ctpop.i64")       __llvm_ctpop :: proc(i64)  ->  i64 ---;
-count_ones :: proc(i: i128) -> i128 { __llvm_ctpop :: proc(i128) -> i128 #foreign __llvm_core "llvm.ctpop.i128";return __llvm_ctpop(i); }
+	@(link_name="llvm.ctpop.i128")      __llvm_ctpop :: proc(u128) -> u128 ---;
+	@(link_name="llvm.ctpop.i128")      __llvm_ctpop :: proc(i128) -> i128 ---;
+
+	@(link_name="llvm.ctlz.i8")         __llvm_ctlz :: proc(u8,   bool) ->   u8 ---;
+	@(link_name="llvm.ctlz.i8")         __llvm_ctlz :: proc(i8,   bool) ->   i8 ---;
+	@(link_name="llvm.ctlz.i16")        __llvm_ctlz :: proc(u16,  bool) ->  u16 ---;
+	@(link_name="llvm.ctlz.i16")        __llvm_ctlz :: proc(i16,  bool) ->  i16 ---;
+	@(link_name="llvm.ctlz.i32")        __llvm_ctlz :: proc(u32,  bool) ->  u32 ---;
+	@(link_name="llvm.ctlz.i32")        __llvm_ctlz :: proc(i32,  bool) ->  i32 ---;
+	@(link_name="llvm.ctlz.i64")        __llvm_ctlz :: proc(u64,  bool) ->  u64 ---;
+	@(link_name="llvm.ctlz.i64")        __llvm_ctlz :: proc(i64,  bool) ->  i64 ---;
+	@(link_name="llvm.ctlz.i128")       __llvm_ctlz :: proc(u128, bool) -> u128 ---;
+	@(link_name="llvm.ctlz.i128")       __llvm_ctlz :: proc(i128, bool) -> i128 ---;
+
+	@(link_name="llvm.cttz.i8")         __llvm_cttz :: proc(u8,   bool) ->   u8 ---;
+	@(link_name="llvm.cttz.i8")         __llvm_cttz :: proc(i8,   bool) ->   i8 ---;
+	@(link_name="llvm.cttz.i16")        __llvm_cttz :: proc(u16,  bool) ->  u16 ---;
+	@(link_name="llvm.cttz.i16")        __llvm_cttz :: proc(i16,  bool) ->  i16 ---;
+	@(link_name="llvm.cttz.i32")        __llvm_cttz :: proc(u32,  bool) ->  u32 ---;
+	@(link_name="llvm.cttz.i32")        __llvm_cttz :: proc(i32,  bool) ->  i32 ---;
+	@(link_name="llvm.cttz.i64")        __llvm_cttz :: proc(u64,  bool) ->  u64 ---;
+	@(link_name="llvm.cttz.i64")        __llvm_cttz :: proc(i64,  bool) ->  i64 ---;
+	@(link_name="llvm.cttz.i128")       __llvm_cttz :: proc(u128, bool) -> u128 ---;
+	@(link_name="llvm.cttz.i128")       __llvm_cttz :: proc(i128, bool) -> i128 ---;
+
+	@(link_name="llvm.bitreverse.i8")   __llvm_bitreverse :: proc(u8)   ->   u8 ---;
+	@(link_name="llvm.bitreverse.i8")   __llvm_bitreverse :: proc(i8)   ->   i8 ---;
+	@(link_name="llvm.bitreverse.i16")  __llvm_bitreverse :: proc(u16)  ->  u16 ---;
+	@(link_name="llvm.bitreverse.i16")  __llvm_bitreverse :: proc(i16)  ->  i16 ---;
+	@(link_name="llvm.bitreverse.i32")  __llvm_bitreverse :: proc(u32)  ->  u32 ---;
+	@(link_name="llvm.bitreverse.i32")  __llvm_bitreverse :: proc(i32)  ->  i32 ---;
+	@(link_name="llvm.bitreverse.i64")  __llvm_bitreverse :: proc(u64)  ->  u64 ---;
+	@(link_name="llvm.bitreverse.i64")  __llvm_bitreverse :: proc(i64)  ->  i64 ---;
+	@(link_name="llvm.bitreverse.i128") __llvm_bitreverse :: proc(u128) -> u128 ---;
+	@(link_name="llvm.bitreverse.i128") __llvm_bitreverse :: proc(i128) -> i128 ---;
+
+	@(link_name="llvm.bswap.i16")  byte_swap :: proc(u16)  ->  u16 ---;
+	@(link_name="llvm.bswap.i16")  byte_swap :: proc(i16)  ->  i16 ---;
+	@(link_name="llvm.bswap.i32")  byte_swap :: proc(u32)  ->  u32 ---;
+	@(link_name="llvm.bswap.i32")  byte_swap :: proc(i32)  ->  i32 ---;
+	@(link_name="llvm.bswap.i64")  byte_swap :: proc(u64)  ->  u64 ---;
+	@(link_name="llvm.bswap.i64")  byte_swap :: proc(i64)  ->  i64 ---;
+	@(link_name="llvm.bswap.i128") byte_swap :: proc(u128) -> u128 ---;
+	@(link_name="llvm.bswap.i128") byte_swap :: proc(i128) -> i128 ---;
+}
+byte_swap :: proc(i: uint) -> uint { when size_of(uint) == size_of(u32) { return uint(byte_swap(u32(i))); } else { return uint(byte_swap(u64(i))); } }
+byte_swap :: proc(i:  int) ->  int { when size_of(int)  == size_of(i32) { return  int(byte_swap(i32(i))); } else { return  int(byte_swap(i64(i))); } }
+
+count_ones :: proc(i:   u8) ->   u8 { return __llvm_ctpop(i); }
+count_ones :: proc(i:   i8) ->   i8 { return __llvm_ctpop(i); }
+count_ones :: proc(i:  u16) ->  u16 { return __llvm_ctpop(i); }
+count_ones :: proc(i:  i16) ->  i16 { return __llvm_ctpop(i); }
+count_ones :: proc(i:  u32) ->  u32 { return __llvm_ctpop(i); }
+count_ones :: proc(i:  i32) ->  i32 { return __llvm_ctpop(i); }
+count_ones :: proc(i:  u64) ->  u64 { return __llvm_ctpop(i); }
+count_ones :: proc(i:  i64) ->  i64 { return __llvm_ctpop(i); }
+count_ones :: proc(i: u128) -> u128 { return __llvm_ctpop(i); }
+count_ones :: proc(i: i128) -> i128 { return __llvm_ctpop(i); }
 count_ones :: proc(i: uint) -> uint { when size_of(uint) == size_of(u32) { return uint(count_ones(u32(i))); } else { return uint(count_ones(u64(i))); } }
-count_ones :: proc(i:  int) ->  int { when size_of(int)  == size_of(i32) { return int(count_ones(i32(i))); } else { return int(count_ones(i64(i))); } }
+count_ones :: proc(i:  int) ->  int { when size_of(int)  == size_of(i32) { return int(count_ones(i32(i)));  } else { return int(count_ones(i64(i))); } }
 
 count_zeros :: proc(i:   u8) ->   u8 { return   8 - count_ones(i); }
 count_zeros :: proc(i:   i8) ->   i8 { return   8 - count_ones(i); }
@@ -77,60 +133,46 @@ rotate_right :: proc(i: i128, s: uint) -> i128 { return (i >> s)|(i << (8*size_o
 rotate_right :: proc(i: uint, s: uint) -> uint { when size_of(uint) == size_of(u32) { return uint(rotate_right(u32(i), s)); } else { return uint(rotate_right(u64(i), s)); } }
 rotate_right :: proc(i:  int, s: uint) ->  int { when size_of(int)  == size_of(i32) { return  int(rotate_right(i32(i), s)); } else { return  int(rotate_right(i64(i), s)); } }
 
-
+leading_zeros :: proc(i:   u8) ->   u8 { return __llvm_ctlz(i, false); }
-leading_zeros :: proc(i:   u8) ->   u8 { __llvm_ctlz :: proc(u8,   bool) ->   u8 #foreign __llvm_core "llvm.ctlz.i8";  return __llvm_ctlz(i, false); }
+leading_zeros :: proc(i:   i8) ->   i8 { return __llvm_ctlz(i, false); }
-leading_zeros :: proc(i:   i8) ->   i8 { __llvm_ctlz :: proc(i8,   bool) ->   i8 #foreign __llvm_core "llvm.ctlz.i8";  return __llvm_ctlz(i, false); }
+leading_zeros :: proc(i:  u16) ->  u16 { return __llvm_ctlz(i, false); }
-leading_zeros :: proc(i:  u16) ->  u16 { __llvm_ctlz :: proc(u16,  bool) ->  u16 #foreign __llvm_core "llvm.ctlz.i16"; return __llvm_ctlz(i, false); }
+leading_zeros :: proc(i:  i16) ->  i16 { return __llvm_ctlz(i, false); }
-leading_zeros :: proc(i:  i16) ->  i16 { __llvm_ctlz :: proc(i16,  bool) ->  i16 #foreign __llvm_core "llvm.ctlz.i16"; return __llvm_ctlz(i, false); }
+leading_zeros :: proc(i:  u32) ->  u32 { return __llvm_ctlz(i, false); }
-leading_zeros :: proc(i:  u32) ->  u32 { __llvm_ctlz :: proc(u32,  bool) ->  u32 #foreign __llvm_core "llvm.ctlz.i32"; return __llvm_ctlz(i, false); }
+leading_zeros :: proc(i:  i32) ->  i32 { return __llvm_ctlz(i, false); }
-leading_zeros :: proc(i:  i32) ->  i32 { __llvm_ctlz :: proc(i32,  bool) ->  i32 #foreign __llvm_core "llvm.ctlz.i32"; return __llvm_ctlz(i, false); }
+leading_zeros :: proc(i:  u64) ->  u64 { return __llvm_ctlz(i, false); }
-leading_zeros :: proc(i:  u64) ->  u64 { __llvm_ctlz :: proc(u64,  bool) ->  u64 #foreign __llvm_core "llvm.ctlz.i64"; return __llvm_ctlz(i, false); }
+leading_zeros :: proc(i:  i64) ->  i64 { return __llvm_ctlz(i, false); }
-leading_zeros :: proc(i:  i64) ->  i64 { __llvm_ctlz :: proc(i64,  bool) ->  i64 #foreign __llvm_core "llvm.ctlz.i64"; return __llvm_ctlz(i, false); }
+leading_zeros :: proc(i: u128) -> u128 { return __llvm_ctlz(i, false); }
-leading_zeros :: proc(i: u128) -> u128 { __llvm_ctlz :: proc(u128, bool) -> u128 #foreign __llvm_core "llvm.ctlz.i128";return __llvm_ctlz(i, false); }
+leading_zeros :: proc(i: i128) -> i128 { return __llvm_ctlz(i, false); }
-leading_zeros :: proc(i: i128) -> i128 { __llvm_ctlz :: proc(i128, bool) -> i128 #foreign __llvm_core "llvm.ctlz.i128";return __llvm_ctlz(i, false); }
 leading_zeros :: proc(i: uint) -> uint { when size_of(uint) == size_of(u32) { return uint(leading_zeros(u32(i))); } else { return uint(leading_zeros(u64(i))); } }
 leading_zeros :: proc(i:  int) ->  int { when size_of(int)  == size_of(i32) { return  int(leading_zeros(i32(i))); } else { return  int(leading_zeros(i64(i))); } }
 
-trailing_zeros :: proc(i:   u8) ->   u8 { __llvm_cttz :: proc(u8,   bool) ->   u8 #foreign __llvm_core "llvm.cttz.i8";  return __llvm_cttz(i, false); }
+trailing_zeros :: proc(i:   u8) ->   u8 { return __llvm_cttz(i, false); }
-trailing_zeros :: proc(i:   i8) ->   i8 { __llvm_cttz :: proc(i8,   bool) ->   i8 #foreign __llvm_core "llvm.cttz.i8";  return __llvm_cttz(i, false); }
+trailing_zeros :: proc(i:   i8) ->   i8 { return __llvm_cttz(i, false); }
-trailing_zeros :: proc(i:  u16) ->  u16 { __llvm_cttz :: proc(u16,  bool) ->  u16 #foreign __llvm_core "llvm.cttz.i16"; return __llvm_cttz(i, false); }
+trailing_zeros :: proc(i:  u16) ->  u16 { return __llvm_cttz(i, false); }
-trailing_zeros :: proc(i:  i16) ->  i16 { __llvm_cttz :: proc(i16,  bool) ->  i16 #foreign __llvm_core "llvm.cttz.i16"; return __llvm_cttz(i, false); }
+trailing_zeros :: proc(i:  i16) ->  i16 { return __llvm_cttz(i, false); }
-trailing_zeros :: proc(i:  u32) ->  u32 { __llvm_cttz :: proc(u32,  bool) ->  u32 #foreign __llvm_core "llvm.cttz.i32"; return __llvm_cttz(i, false); }
+trailing_zeros :: proc(i:  u32) ->  u32 { return __llvm_cttz(i, false); }
-trailing_zeros :: proc(i:  i32) ->  i32 { __llvm_cttz :: proc(i32,  bool) ->  i32 #foreign __llvm_core "llvm.cttz.i32"; return __llvm_cttz(i, false); }
+trailing_zeros :: proc(i:  i32) ->  i32 { return __llvm_cttz(i, false); }
-trailing_zeros :: proc(i:  u64) ->  u64 { __llvm_cttz :: proc(u64,  bool) ->  u64 #foreign __llvm_core "llvm.cttz.i64"; return __llvm_cttz(i, false); }
+trailing_zeros :: proc(i:  u64) ->  u64 { return __llvm_cttz(i, false); }
-trailing_zeros :: proc(i:  i64) ->  i64 { __llvm_cttz :: proc(i64,  bool) ->  i64 #foreign __llvm_core "llvm.cttz.i64"; return __llvm_cttz(i, false); }
+trailing_zeros :: proc(i:  i64) ->  i64 { return __llvm_cttz(i, false); }
-trailing_zeros :: proc(i: u128) -> u128 { __llvm_cttz :: proc(u128, bool) -> u128 #foreign __llvm_core "llvm.cttz.i128";return __llvm_cttz(i, false); }
+trailing_zeros :: proc(i: u128) -> u128 { return __llvm_cttz(i, false); }
-trailing_zeros :: proc(i: i128) -> i128 { __llvm_cttz :: proc(i128, bool) -> i128 #foreign __llvm_core "llvm.cttz.i128";return __llvm_cttz(i, false); }
+trailing_zeros :: proc(i: i128) -> i128 { return __llvm_cttz(i, false); }
 trailing_zeros :: proc(i: uint) -> uint { when size_of(uint) == size_of(u32) { return uint(trailing_zeros(u32(i))); } else { return uint(trailing_zeros(u64(i))); } }
 trailing_zeros :: proc(i:  int) ->  int { when size_of(int)  == size_of(i32) { return  int(trailing_zeros(i32(i))); } else { return  int(trailing_zeros(i64(i))); } }
 
 
-reverse_bits :: proc(i:   u8) ->   u8 { __llvm_bitreverse :: proc(u8)   ->   u8 #foreign __llvm_core "llvm.bitreverse.i8";  return __llvm_bitreverse(i); }
+reverse_bits :: proc(i:   u8) ->   u8 { return __llvm_bitreverse(i); }
-reverse_bits :: proc(i:   i8) ->   i8 { __llvm_bitreverse :: proc(i8)   ->   i8 #foreign __llvm_core "llvm.bitreverse.i8";  return __llvm_bitreverse(i); }
+reverse_bits :: proc(i:   i8) ->   i8 { return __llvm_bitreverse(i); }
-reverse_bits :: proc(i:  u16) ->  u16 { __llvm_bitreverse :: proc(u16)  ->  u16 #foreign __llvm_core "llvm.bitreverse.i16"; return __llvm_bitreverse(i); }
+reverse_bits :: proc(i:  u16) ->  u16 { return __llvm_bitreverse(i); }
-reverse_bits :: proc(i:  i16) ->  i16 { __llvm_bitreverse :: proc(i16)  ->  i16 #foreign __llvm_core "llvm.bitreverse.i16"; return __llvm_bitreverse(i); }
+reverse_bits :: proc(i:  i16) ->  i16 { return __llvm_bitreverse(i); }
-reverse_bits :: proc(i:  u32) ->  u32 { __llvm_bitreverse :: proc(u32)  ->  u32 #foreign __llvm_core "llvm.bitreverse.i32"; return __llvm_bitreverse(i); }
+reverse_bits :: proc(i:  u32) ->  u32 { return __llvm_bitreverse(i); }
-reverse_bits :: proc(i:  i32) ->  i32 { __llvm_bitreverse :: proc(i32)  ->  i32 #foreign __llvm_core "llvm.bitreverse.i32"; return __llvm_bitreverse(i); }
+reverse_bits :: proc(i:  i32) ->  i32 { return __llvm_bitreverse(i); }
-reverse_bits :: proc(i:  u64) ->  u64 { __llvm_bitreverse :: proc(u64)  ->  u64 #foreign __llvm_core "llvm.bitreverse.i64"; return __llvm_bitreverse(i); }
+reverse_bits :: proc(i:  u64) ->  u64 { return __llvm_bitreverse(i); }
-reverse_bits :: proc(i:  i64) ->  i64 { __llvm_bitreverse :: proc(i64)  ->  i64 #foreign __llvm_core "llvm.bitreverse.i64"; return __llvm_bitreverse(i); }
+reverse_bits :: proc(i:  i64) ->  i64 { return __llvm_bitreverse(i); }
-reverse_bits :: proc(i: u128) -> u128 { __llvm_bitreverse :: proc(u128) -> u128 #foreign __llvm_core "llvm.bitreverse.i128";return __llvm_bitreverse(i); }
+reverse_bits :: proc(i: u128) -> u128 { return __llvm_bitreverse(i); }
-reverse_bits :: proc(i: i128) -> i128 { __llvm_bitreverse :: proc(i128) -> i128 #foreign __llvm_core "llvm.bitreverse.i128";return __llvm_bitreverse(i); }
+reverse_bits :: proc(i: i128) -> i128 { return __llvm_bitreverse(i); }
 reverse_bits :: proc(i: uint) -> uint { when size_of(uint) == size_of(u32) { return uint(reverse_bits(u32(i))); } else { return uint(reverse_bits(u64(i))); } }
 reverse_bits :: proc(i:  int) ->  int { when size_of(int)  == size_of(i32) { return  int(reverse_bits(i32(i))); } else { return  int(reverse_bits(i64(i))); } }
 
-
-byte_swap :: proc(u16)  ->  u16 #foreign __llvm_core "llvm.bswap.i16";
-byte_swap :: proc(i16)  ->  i16 #foreign __llvm_core "llvm.bswap.i16";
-byte_swap :: proc(u32)  ->  u32 #foreign __llvm_core "llvm.bswap.i32";
-byte_swap :: proc(i32)  ->  i32 #foreign __llvm_core "llvm.bswap.i32";
-byte_swap :: proc(u64)  ->  u64 #foreign __llvm_core "llvm.bswap.i64";
-byte_swap :: proc(i64)  ->  i64 #foreign __llvm_core "llvm.bswap.i64";
-byte_swap :: proc(u128) -> u128 #foreign __llvm_core "llvm.bswap.i128";
-byte_swap :: proc(i128) -> i128 #foreign __llvm_core "llvm.bswap.i128";
-byte_swap :: proc(i: uint) -> uint { when size_of(uint) == size_of(u32) { return uint(byte_swap(u32(i))); } else { return uint(byte_swap(u64(i))); } }
-byte_swap :: proc(i:  int) ->  int { when size_of(int)  == size_of(i32) { return  int(byte_swap(i32(i))); } else { return  int(byte_swap(i64(i))); } }
-
-
 from_be :: proc(i:   u8) ->   u8 { return i; }
 from_be :: proc(i:   i8) ->   i8 { return i; }
 from_be :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
@@ -185,16 +227,16 @@ to_le :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i; } else
 to_le :: proc(i:  int) ->  int { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
 
 
-overflowing_add :: proc(lhs, rhs:   u8) -> (u8, bool)   { op :: proc(u8, u8)     -> (u8, bool)   #foreign __llvm_core "llvm.uadd.with.overflow.i8";   return op(lhs, rhs); }
+overflowing_add :: proc(lhs, rhs:   u8) -> (u8, bool)   { foreign __llvm_core @(link_name="llvm.uadd.with.overflow.i8")   op :: proc(u8, u8)     -> (u8, bool)   ---; return op(lhs, rhs); }
-overflowing_add :: proc(lhs, rhs:   i8) -> (i8, bool)   { op :: proc(i8, i8)     -> (i8, bool)   #foreign __llvm_core "llvm.sadd.with.overflow.i8";   return op(lhs, rhs); }
+overflowing_add :: proc(lhs, rhs:   i8) -> (i8, bool)   { foreign __llvm_core @(link_name="llvm.sadd.with.overflow.i8")   op :: proc(i8, i8)     -> (i8, bool)   ---; return op(lhs, rhs); }
-overflowing_add :: proc(lhs, rhs:  u16) -> (u16, bool)  { op :: proc(u16, u16)   -> (u16, bool)  #foreign __llvm_core "llvm.uadd.with.overflow.i16";  return op(lhs, rhs); }
+overflowing_add :: proc(lhs, rhs:  u16) -> (u16, bool)  { foreign __llvm_core @(link_name="llvm.uadd.with.overflow.i16")  op :: proc(u16, u16)   -> (u16, bool)  ---; return op(lhs, rhs); }
-overflowing_add :: proc(lhs, rhs:  i16) -> (i16, bool)  { op :: proc(i16, i16)   -> (i16, bool)  #foreign __llvm_core "llvm.sadd.with.overflow.i16";  return op(lhs, rhs); }
+overflowing_add :: proc(lhs, rhs:  i16) -> (i16, bool)  { foreign __llvm_core @(link_name="llvm.sadd.with.overflow.i16")  op :: proc(i16, i16)   -> (i16, bool)  ---; return op(lhs, rhs); }
-overflowing_add :: proc(lhs, rhs:  u32) -> (u32, bool)  { op :: proc(u32, u32)   -> (u32, bool)  #foreign __llvm_core "llvm.uadd.with.overflow.i32";  return op(lhs, rhs); }
+overflowing_add :: proc(lhs, rhs:  u32) -> (u32, bool)  { foreign __llvm_core @(link_name="llvm.uadd.with.overflow.i32")  op :: proc(u32, u32)   -> (u32, bool)  ---; return op(lhs, rhs); }
-overflowing_add :: proc(lhs, rhs:  i32) -> (i32, bool)  { op :: proc(i32, i32)   -> (i32, bool)  #foreign __llvm_core "llvm.sadd.with.overflow.i32";  return op(lhs, rhs); }
+overflowing_add :: proc(lhs, rhs:  i32) -> (i32, bool)  { foreign __llvm_core @(link_name="llvm.sadd.with.overflow.i32")  op :: proc(i32, i32)   -> (i32, bool)  ---; return op(lhs, rhs); }
-overflowing_add :: proc(lhs, rhs:  u64) -> (u64, bool)  { op :: proc(u64, u64)   -> (u64, bool)  #foreign __llvm_core "llvm.uadd.with.overflow.i64";  return op(lhs, rhs); }
+overflowing_add :: proc(lhs, rhs:  u64) -> (u64, bool)  { foreign __llvm_core @(link_name="llvm.uadd.with.overflow.i64")  op :: proc(u64, u64)   -> (u64, bool)  ---; return op(lhs, rhs); }
-overflowing_add :: proc(lhs, rhs:  i64) -> (i64, bool)  { op :: proc(i64, i64)   -> (i64, bool)  #foreign __llvm_core "llvm.sadd.with.overflow.i64";  return op(lhs, rhs); }
+overflowing_add :: proc(lhs, rhs:  i64) -> (i64, bool)  { foreign __llvm_core @(link_name="llvm.sadd.with.overflow.i64")  op :: proc(i64, i64)   -> (i64, bool)  ---; return op(lhs, rhs); }
-overflowing_add :: proc(lhs, rhs: u128) -> (u128, bool) { op :: proc(u128, u128) -> (u128, bool) #foreign __llvm_core "llvm.uadd.with.overflow.i128"; return op(lhs, rhs); }
+overflowing_add :: proc(lhs, rhs: u128) -> (u128, bool) { foreign __llvm_core @(link_name="llvm.uadd.with.overflow.i128") op :: proc(u128, u128) -> (u128, bool) ---; return op(lhs, rhs); }
-overflowing_add :: proc(lhs, rhs: i128) -> (i128, bool) { op :: proc(i128, i128) -> (i128, bool) #foreign __llvm_core "llvm.sadd.with.overflow.i128"; return op(lhs, rhs); }
+overflowing_add :: proc(lhs, rhs: i128) -> (i128, bool) { foreign __llvm_core @(link_name="llvm.sadd.with.overflow.i128") op :: proc(i128, i128) -> (i128, bool) ---; return op(lhs, rhs); }
 overflowing_add :: proc(lhs, rhs: uint) -> (uint, bool) {
 	when size_of(uint) == size_of(u32) {
 		x, ok := overflowing_add(u32(lhs), u32(rhs));
@@ -214,16 +256,16 @@ overflowing_add :: proc(lhs, rhs: int) -> (int, bool) {
 	}
 }
 
-overflowing_sub :: proc(lhs, rhs:   u8) -> (u8, bool)   { op :: proc(u8, u8)     -> (u8, bool)   #foreign __llvm_core "llvm.usub.with.overflow.i8";   return op(lhs, rhs); }
+overflowing_sub :: proc(lhs, rhs:   u8) -> (u8, bool)   { foreign __llvm_core @(link_name="llvm.usub.with.overflow.i8")   op :: proc(u8, u8)     -> (u8, bool)   ---; return op(lhs, rhs); }
-overflowing_sub :: proc(lhs, rhs:   i8) -> (i8, bool)   { op :: proc(i8, i8)     -> (i8, bool)   #foreign __llvm_core "llvm.ssub.with.overflow.i8";   return op(lhs, rhs); }
+overflowing_sub :: proc(lhs, rhs:   i8) -> (i8, bool)   { foreign __llvm_core @(link_name="llvm.ssub.with.overflow.i8")   op :: proc(i8, i8)     -> (i8, bool)   ---; return op(lhs, rhs); }
-overflowing_sub :: proc(lhs, rhs:  u16) -> (u16, bool)  { op :: proc(u16, u16)   -> (u16, bool)  #foreign __llvm_core "llvm.usub.with.overflow.i16";  return op(lhs, rhs); }
+overflowing_sub :: proc(lhs, rhs:  u16) -> (u16, bool)  { foreign __llvm_core @(link_name="llvm.usub.with.overflow.i16")  op :: proc(u16, u16)   -> (u16, bool)  ---; return op(lhs, rhs); }
-overflowing_sub :: proc(lhs, rhs:  i16) -> (i16, bool)  { op :: proc(i16, i16)   -> (i16, bool)  #foreign __llvm_core "llvm.ssub.with.overflow.i16";  return op(lhs, rhs); }
+overflowing_sub :: proc(lhs, rhs:  i16) -> (i16, bool)  { foreign __llvm_core @(link_name="llvm.ssub.with.overflow.i16")  op :: proc(i16, i16)   -> (i16, bool)  ---; return op(lhs, rhs); }
-overflowing_sub :: proc(lhs, rhs:  u32) -> (u32, bool)  { op :: proc(u32, u32)   -> (u32, bool)  #foreign __llvm_core "llvm.usub.with.overflow.i32";  return op(lhs, rhs); }
+overflowing_sub :: proc(lhs, rhs:  u32) -> (u32, bool)  { foreign __llvm_core @(link_name="llvm.usub.with.overflow.i32")  op :: proc(u32, u32)   -> (u32, bool)  ---; return op(lhs, rhs); }
-overflowing_sub :: proc(lhs, rhs:  i32) -> (i32, bool)  { op :: proc(i32, i32)   -> (i32, bool)  #foreign __llvm_core "llvm.ssub.with.overflow.i32";  return op(lhs, rhs); }
+overflowing_sub :: proc(lhs, rhs:  i32) -> (i32, bool)  { foreign __llvm_core @(link_name="llvm.ssub.with.overflow.i32")  op :: proc(i32, i32)   -> (i32, bool)  ---; return op(lhs, rhs); }
-overflowing_sub :: proc(lhs, rhs:  u64) -> (u64, bool)  { op :: proc(u64, u64)   -> (u64, bool)  #foreign __llvm_core "llvm.usub.with.overflow.i64";  return op(lhs, rhs); }
+overflowing_sub :: proc(lhs, rhs:  u64) -> (u64, bool)  { foreign __llvm_core @(link_name="llvm.usub.with.overflow.i64")  op :: proc(u64, u64)   -> (u64, bool)  ---; return op(lhs, rhs); }
-overflowing_sub :: proc(lhs, rhs:  i64) -> (i64, bool)  { op :: proc(i64, i64)   -> (i64, bool)  #foreign __llvm_core "llvm.ssub.with.overflow.i64";  return op(lhs, rhs); }
+overflowing_sub :: proc(lhs, rhs:  i64) -> (i64, bool)  { foreign __llvm_core @(link_name="llvm.ssub.with.overflow.i64")  op :: proc(i64, i64)   -> (i64, bool)  ---; return op(lhs, rhs); }
-overflowing_sub :: proc(lhs, rhs: u128) -> (u128, bool) { op :: proc(u128, u128) -> (u128, bool) #foreign __llvm_core "llvm.usub.with.overflow.i128"; return op(lhs, rhs); }
+overflowing_sub :: proc(lhs, rhs: u128) -> (u128, bool) { foreign __llvm_core @(link_name="llvm.usub.with.overflow.i128") op :: proc(u128, u128) -> (u128, bool) ---; return op(lhs, rhs); }
-overflowing_sub :: proc(lhs, rhs: i128) -> (i128, bool) { op :: proc(i128, i128) -> (i128, bool) #foreign __llvm_core "llvm.ssub.with.overflow.i128"; return op(lhs, rhs); }
+overflowing_sub :: proc(lhs, rhs: i128) -> (i128, bool) { foreign __llvm_core @(link_name="llvm.ssub.with.overflow.i128") op :: proc(i128, i128) -> (i128, bool) ---; return op(lhs, rhs); }
 overflowing_sub :: proc(lhs, rhs: uint) -> (uint, bool) {
 	when size_of(uint) == size_of(u32) {
 		x, ok := overflowing_sub(u32(lhs), u32(rhs));
@@ -243,16 +285,16 @@ overflowing_sub :: proc(lhs, rhs: int) -> (int, bool) {
 	}
 }
 
-overflowing_mul :: proc(lhs, rhs:   u8) -> (u8, bool)   { op :: proc(u8, u8)     -> (u8, bool)   #foreign __llvm_core "llvm.umul.with.overflow.i8";   return op(lhs, rhs); }
+overflowing_mul :: proc(lhs, rhs:   u8) -> (u8, bool)   { foreign __llvm_core @(link_name="llvm.umul.with.overflow.i8")   op :: proc(u8, u8)     -> (u8, bool)   ---; return op(lhs, rhs); }
-overflowing_mul :: proc(lhs, rhs:   i8) -> (i8, bool)   { op :: proc(i8, i8)     -> (i8, bool)   #foreign __llvm_core "llvm.smul.with.overflow.i8";   return op(lhs, rhs); }
+overflowing_mul :: proc(lhs, rhs:   i8) -> (i8, bool)   { foreign __llvm_core @(link_name="llvm.smul.with.overflow.i8")   op :: proc(i8, i8)     -> (i8, bool)   ---; return op(lhs, rhs); }
-overflowing_mul :: proc(lhs, rhs:  u16) -> (u16, bool)  { op :: proc(u16, u16)   -> (u16, bool)  #foreign __llvm_core "llvm.umul.with.overflow.i16";  return op(lhs, rhs); }
+overflowing_mul :: proc(lhs, rhs:  u16) -> (u16, bool)  { foreign __llvm_core @(link_name="llvm.umul.with.overflow.i16")  op :: proc(u16, u16)   -> (u16, bool)  ---; return op(lhs, rhs); }
-overflowing_mul :: proc(lhs, rhs:  i16) -> (i16, bool)  { op :: proc(i16, i16)   -> (i16, bool)  #foreign __llvm_core "llvm.smul.with.overflow.i16";  return op(lhs, rhs); }
+overflowing_mul :: proc(lhs, rhs:  i16) -> (i16, bool)  { foreign __llvm_core @(link_name="llvm.smul.with.overflow.i16")  op :: proc(i16, i16)   -> (i16, bool)  ---; return op(lhs, rhs); }
-overflowing_mul :: proc(lhs, rhs:  u32) -> (u32, bool)  { op :: proc(u32, u32)   -> (u32, bool)  #foreign __llvm_core "llvm.umul.with.overflow.i32";  return op(lhs, rhs); }
+overflowing_mul :: proc(lhs, rhs:  u32) -> (u32, bool)  { foreign __llvm_core @(link_name="llvm.umul.with.overflow.i32")  op :: proc(u32, u32)   -> (u32, bool)  ---; return op(lhs, rhs); }
-overflowing_mul :: proc(lhs, rhs:  i32) -> (i32, bool)  { op :: proc(i32, i32)   -> (i32, bool)  #foreign __llvm_core "llvm.smul.with.overflow.i32";  return op(lhs, rhs); }
+overflowing_mul :: proc(lhs, rhs:  i32) -> (i32, bool)  { foreign __llvm_core @(link_name="llvm.smul.with.overflow.i32")  op :: proc(i32, i32)   -> (i32, bool)  ---; return op(lhs, rhs); }
-overflowing_mul :: proc(lhs, rhs:  u64) -> (u64, bool)  { op :: proc(u64, u64)   -> (u64, bool)  #foreign __llvm_core "llvm.umul.with.overflow.i64";  return op(lhs, rhs); }
+overflowing_mul :: proc(lhs, rhs:  u64) -> (u64, bool)  { foreign __llvm_core @(link_name="llvm.umul.with.overflow.i64")  op :: proc(u64, u64)   -> (u64, bool)  ---; return op(lhs, rhs); }
-overflowing_mul :: proc(lhs, rhs:  i64) -> (i64, bool)  { op :: proc(i64, i64)   -> (i64, bool)  #foreign __llvm_core "llvm.smul.with.overflow.i64";  return op(lhs, rhs); }
+overflowing_mul :: proc(lhs, rhs:  i64) -> (i64, bool)  { foreign __llvm_core @(link_name="llvm.smul.with.overflow.i64")  op :: proc(i64, i64)   -> (i64, bool)  ---; return op(lhs, rhs); }
-overflowing_mul :: proc(lhs, rhs: u128) -> (u128, bool) { op :: proc(u128, u128) -> (u128, bool) #foreign __llvm_core "llvm.umul.with.overflow.i128"; return op(lhs, rhs); }
+overflowing_mul :: proc(lhs, rhs: u128) -> (u128, bool) { foreign __llvm_core @(link_name="llvm.umul.with.overflow.i128") op :: proc(u128, u128) -> (u128, bool) ---; return op(lhs, rhs); }
-overflowing_mul :: proc(lhs, rhs: i128) -> (i128, bool) { op :: proc(i128, i128) -> (i128, bool) #foreign __llvm_core "llvm.smul.with.overflow.i128"; return op(lhs, rhs); }
+overflowing_mul :: proc(lhs, rhs: i128) -> (i128, bool) { foreign __llvm_core @(link_name="llvm.smul.with.overflow.i128") op :: proc(i128, i128) -> (i128, bool) ---; return op(lhs, rhs); }
 overflowing_mul :: proc(lhs, rhs: uint) -> (uint, bool) {
 	when size_of(uint) == size_of(u32) {
 		x, ok := overflowing_mul(u32(lhs), u32(rhs));

core/c.odin

@@ -0,0 +1,38 @@
+CHAR_BIT :: 8;
+
+c_bool   :: #alias bool;
+c_char   :: #alias u8;
+c_byte   :: #alias u8;
+c_schar  :: #alias i8;
+c_uchar  :: #alias u8;
+c_short  :: #alias i16;
+c_ushort :: #alias u16;
+c_int    :: #alias i32;
+c_uint   :: #alias u32;
+
+when ODIN_OS == "windows" || size_of(rawptr) == 4 {
+	c_long :: #alias i32;
+} else {
+	c_long :: #alias i64;
+}
+
+when ODIN_OS == "windows" || size_of(rawptr) == 4 {
+	c_ulong :: #alias u32;
+} else {
+	c_ulong :: #alias u64;
+}
+
+c_longlong       :: #alias i64;
+c_ulonglong      :: #alias u64;
+c_float          :: #alias f32;
+c_double         :: #alias f64;
+c_complex_float  :: #alias complex64;
+c_complex_double :: #alias complex128;
+
+_ :: compile_assert(size_of(uintptr) == size_of(int));
+
+c_size_t    :: #alias uint;
+c_ssize_t   :: #alias int;
+c_ptrdiff_t :: #alias int;
+c_uintptr_t :: #alias uintptr;
+c_intptr_t  :: #alias int;

core/decimal.odin

@@ -1,4 +1,3 @@
-// #import "fmt.odin";
 // Multiple precision decimal numbers
 // NOTE: This is only for floating point printing and nothing else
 
@@ -11,9 +10,7 @@ Decimal :: struct {
 
 decimal_to_string :: proc(buf: []u8, a: ^Decimal) -> string {
 	digit_zero :: proc(buf: []u8) -> int {
-		for _, i in buf {
+		for _, i in buf do buf[i] = '0';
-			buf[i] = '0';
-		}
 		return len(buf);
 	}
 
@@ -22,35 +19,35 @@ decimal_to_string :: proc(buf: []u8, a: ^Decimal) -> string {
 
 	// TODO(bill): make this work with a buffer that's not big enough
 	assert(len(buf) >= n);
-	buf = buf[0..<n];
+	buf = buf[0..n];
 
 	if a.count == 0 {
 		buf[0] = '0';
-		return string(buf[0..<1]);
+		return string(buf[0..1]);
 	}
 
 	w := 0;
 	if a.decimal_point <= 0 {
-		buf[w] = '0'; w++;
+		buf[w] = '0'; w += 1;
-		buf[w] = '.'; w++;
+		buf[w] = '.'; w += 1;
-		w += digit_zero(buf[w ..< w-a.decimal_point]);
+		w += digit_zero(buf[w .. w-a.decimal_point]);
-		w += copy(buf[w..], a.digits[0..<a.count]);
+		w += copy(buf[w..], a.digits[0..a.count]);
 	} else if a.decimal_point < a.count {
-		w += copy(buf[w..], a.digits[0..<a.decimal_point]);
+		w += copy(buf[w..], a.digits[0..a.decimal_point]);
-		buf[w] = '.'; w++;
+		buf[w] = '.'; w += 1;
-		w += copy(buf[w..], a.digits[a.decimal_point ..< a.count]);
+		w += copy(buf[w..], a.digits[a.decimal_point .. a.count]);
 	} else {
-		w += copy(buf[w..], a.digits[0..<a.count]);
+		w += copy(buf[w..], a.digits[0..a.count]);
-		w += digit_zero(buf[w ..< w+a.decimal_point-a.count]);
+		w += digit_zero(buf[w .. w+a.decimal_point-a.count]);
 	}
 
-	return string(buf[0..<w]);
+	return string(buf[0..w]);
 }
 
 // trim trailing zeros
 trim :: proc(a: ^Decimal) {
 	for a.count > 0 && a.digits[a.count-1] == '0' {
-		a.count--;
+		a.count -= 1;
 	}
 	if a.count == 0 {
 		a.decimal_point = 0;
@@ -59,34 +56,33 @@ trim :: proc(a: ^Decimal) {
 
 
 assign :: proc(a: ^Decimal, i: u64) {
-	buf: [32]u8;
+	buf: [64]u8;
 	n := 0;
 	for i > 0 {
 		j := i/10;
 		i -= 10*j;
 		buf[n] = u8('0'+i);
-		n++;
+		n += 1;
 		i = j;
 	}
 
 	a.count = 0;
-	for n--; n >= 0; n-- {
+	for n -= 1; n >= 0; n -= 1 {
 		a.digits[a.count] = buf[n];
-		a.count++;
+		a.count += 1;
 	}
 	a.decimal_point = a.count;
 	trim(a);
 }
 
-uint_size :: 8*size_of(uint);
+
-max_shift :: uint_size-4;
 
 shift_right :: proc(a: ^Decimal, k: uint) {
 	r := 0; // read index
 	w := 0; // write index
 
 	n: uint;
-	for ; n>>k == 0; r++ {
+	for ; n>>k == 0; r += 1 {
 		if r >= a.count {
 			if n == 0 {
 				// Just in case
@@ -95,7 +91,7 @@ shift_right :: proc(a: ^Decimal, k: uint) {
 			}
 			for n>>k == 0 {
 				n = n * 10;
-				r++;
+				r += 1;
 			}
 			break;
 		}
@@ -106,12 +102,12 @@ shift_right :: proc(a: ^Decimal, k: uint) {
 
 	mask: uint = (1<<k) - 1;
 
-	for ; r < a.count; r++ {
+	for ; r < a.count; r += 1 {
 		c := uint(a.digits[r]);
 		dig := n>>k;
 		n &= mask;
 		a.digits[w] = u8('0' + dig);
-		w++;
+		w += 1;
 		n = n*10 + c - '0';
 	}
 
@@ -120,7 +116,7 @@ shift_right :: proc(a: ^Decimal, k: uint) {
 		n &= mask;
 		if w < len(a.digits) {
 			a.digits[w] = u8('0' + dig);
-			w++;
+			w += 1;
 		} else if dig > 0 {
 			a.trunc = true;
 		}
@@ -139,11 +135,11 @@ shift_left :: proc(a: ^Decimal, k: uint) {
 	w := a.count+delta; // write index
 
 	n: uint;
-	for r--; r >= 0; r-- {
+	for r -= 1; r >= 0; r -= 1 {
 		n += (uint(a.digits[r]) - '0') << k;
 		quo := n/10;
 		rem := n - 10*quo;
-		w--;
+		w -= 1;
 		if w < len(a.digits) {
 			a.digits[w] = u8('0' + rem);
 		} else if rem != 0 {
@@ -155,7 +151,7 @@ shift_left :: proc(a: ^Decimal, k: uint) {
 	for n > 0 {
 		quo := n/10;
 		rem := n - 10*quo;
-		w--;
+		w -= 1;
 		if 0 <= w && w < len(a.digits) {
 			a.digits[w] = u8('0' + rem);
 		} else if rem != 0 {
@@ -171,7 +167,10 @@ shift_left :: proc(a: ^Decimal, k: uint) {
 }
 
 shift :: proc(a: ^Decimal, k: int) {
-	match {
+	uint_size :: 8*size_of(uint);
+	max_shift :: uint_size-4;
+
+	switch {
 	case a.count == 0:
 		// no need to update
 	case k > 0:
@@ -194,9 +193,7 @@ shift :: proc(a: ^Decimal, k: int) {
 can_round_up :: proc(a: ^Decimal, nd: int) -> bool {
 	if nd < 0 || nd >= a.count { return false ; }
 	if a.digits[nd] == '5' && nd+1 == a.count {
-		if a.trunc {
+		if a.trunc do return true;
-			return true;
-		}
 		return nd > 0 && (a.digits[nd-1]-'0')%2 != 0;
 	}
 
@@ -215,9 +212,9 @@ round :: proc(a: ^Decimal, nd: int) {
 round_up :: proc(a: ^Decimal, nd: int) {
 	if nd < 0 || nd >= a.count { return; }
 
-	for i := nd-1; i >= 0; i-- {
+	for i := nd-1; i >= 0; i -= 1 {
 		if c := a.digits[i]; c < '9' {
-			a.digits[i]++;
+			a.digits[i] += 1;
 			a.count = i+1;
 			return;
 		}
@@ -226,7 +223,7 @@ round_up :: proc(a: ^Decimal, nd: int) {
 	// Number is just 9s
 	a.digits[0] = '1';
 	a.count = 1;
-	a.decimal_point++;
+	a.decimal_point += 1;
 }
 
 round_down :: proc(a: ^Decimal, nd: int) {
@@ -241,17 +238,17 @@ rounded_integer :: proc(a: ^Decimal) -> u64 {
 	if a.decimal_point > 20 {
 		return 0xffff_ffff_ffff_ffff;
 	}
-	i: int;
+	i: int = 0;
 	n: u64 = 0;
 	m := min(a.decimal_point, a.count);
-	for i = 0; i < m; i++ {
+	for ; i < m; i += 1 {
 		n = n*10 + u64(a.digits[i]-'0');
 	}
-	for ; i < a.decimal_point; i++ {
+	for ; i < a.decimal_point; i += 1 {
 		n *= 10;
 	}
 	if can_round_up(a, a.decimal_point) {
-		n++;
+		n += 1;
 	}
 	return n;
 }

core/hash.odin

@@ -1,3 +1,15 @@
+import "core:mem.odin"
+
+adler32 :: proc(data: []u8) -> u32 {
+	ADLER_CONST :: 65521;
+	a, b: u32 = 1, 0;
+	for x in data {
+		a = (a + u32(x)) % ADLER_CONST;
+		b = (b + a) % ADLER_CONST;
+	}
+	return (b << 16) | a;
+}
+
 crc32 :: proc(data: []u8) -> u32 {
 	result := ~u32(0);
 	for b in data {
@@ -55,7 +67,7 @@ murmur32 :: proc(data: []u8) -> u32 {
 	p1 := p + 4*nblocks;
 
 	for ; p < p1; p += 4 {
-		k1 := ^u32(p)^;
+		k1 := (cast(^u32)p)^;
 
 		k1 *= c1_32;
 		k1 = (k1 << 15) | (k1 >> 17);
@@ -67,9 +79,8 @@ murmur32 :: proc(data: []u8) -> u32 {
 	}
 
 	tail := data[nblocks*4 ..];
-
 	k1: u32;
-	match len(tail)&3 {
+	switch len(tail)&3 {
 	case 3:
 		k1 ~= u32(tail[2]) << 16;
 		fallthrough;
@@ -103,7 +114,7 @@ murmur64 :: proc(data: []u8) -> u64 {
 		r :: 47;
 
 		h: u64 = SEED ~ (u64(len(data)) * m);
-		data64 := slice_ptr(^u64(&data[0]), len(data)/size_of(u64));
+		data64 := mem.slice_ptr(cast(^u64)&data[0], len(data)/size_of(u64));
 
 		for _, i in data64 {
 			k := data64[i];
@@ -116,7 +127,7 @@ murmur64 :: proc(data: []u8) -> u64 {
 			h *= m;
 		}
 
-		match len(data)&7 {
+		switch len(data)&7 {
 		case 7: h ~= u64(data[6]) << 48; fallthrough;
 		case 6: h ~= u64(data[5]) << 40; fallthrough;
 		case 5: h ~= u64(data[4]) << 32; fallthrough;
@@ -139,14 +150,13 @@ murmur64 :: proc(data: []u8) -> u64 {
 
 		h1 := u32(SEED) ~ u32(len(data));
 		h2 := u32(SEED) >> 32;
-
+		data32 := mem.slice_ptr(cast(^u32)&data[0], len(data)/size_of(u32));
-		data32 := slice_ptr(cast(^u32)&data[0], len(data)/size_of(u32));
 		len := len(data);
-
 		i := 0;
+
 		for len >= 8 {
 			k1, k2: u32;
-			k1 = data32[i]; i++;
+			k1 = data32[i]; i += 1;
 			k1 *= m;
 			k1 ~= k1>>r;
 			k1 *= m;
@@ -154,7 +164,7 @@ murmur64 :: proc(data: []u8) -> u64 {
 			h1 ~= k1;
 			len -= 4;
 
-			k2 = data32[i]; i++;
+			k2 = data32[i]; i += 1;
 			k2 *= m;
 			k2 ~= k2>>r;
 			k2 *= m;
@@ -165,7 +175,7 @@ murmur64 :: proc(data: []u8) -> u64 {
 
 		if len >= 4 {
 			k1: u32;
-			k1 = data32[i]; i++;
+			k1 = data32[i]; i += 1;
 			k1 *= m;
 			k1 ~= k1>>r;
 			k1 *= m;
@@ -175,8 +185,8 @@ murmur64 :: proc(data: []u8) -> u64 {
 		}
 
 		// TODO(bill): Fix this
-		#no_bounds_check data8 := slice_to_bytes(data32[i..])[0..<3];
+		#no_bounds_check data8 := slice_to_bytes(data32[i..])[..3];
-		match len {
+		switch len {
 		case 3:
 			h2 ~= u32(data8[2]) << 16;
 			fallthrough;
@@ -197,13 +207,12 @@ murmur64 :: proc(data: []u8) -> u64 {
 		h2 ~= h1>>19;
 		h2 *= m;
 
-		h := cast(u64)(h1)<<32 | cast(u64)(h2);
+		return u64(h1)<<32 | u64(h2);
-		return h;
 	}
 }
 
 
-immutable _crc32_table := [256]u32{
+_crc32_table := [256]u32{
 	0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
 	0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
 	0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
@@ -269,7 +278,7 @@ immutable _crc32_table := [256]u32{
 	0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
 	0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
 };
-immutable _crc64_table := [256]u64{
+_crc64_table := [256]u64{
 	0x0000000000000000, 0x42f0e1eba9ea3693, 0x85e1c3d753d46d26, 0xc711223cfa3e5bb5,
 	0x493366450e42ecdf, 0x0bc387aea7a8da4c, 0xccd2a5925d9681f9, 0x8e224479f47cb76a,
 	0x9266cc8a1c85d9be, 0xd0962d61b56fef2d, 0x17870f5d4f51b498, 0x5577eeb6e6bb820b,

core/math.odin

@@ -16,9 +16,9 @@ EPSILON      :: 1.19209290e-7;
 τ :: TAU;
 π :: PI;
 
-Vec2 :: [vector 2]f32;
+Vec2 :: [2]f32;
-Vec3 :: [vector 3]f32;
+Vec3 :: [3]f32;
-Vec4 :: [vector 4]f32;
+Vec4 :: [4]f32;
 
 // Column major
 Mat2 :: [2][2]f32;
@@ -27,74 +27,89 @@ Mat4 :: [4][4]f32;
 
 Complex :: complex64;
 
-sqrt :: proc(x: f32) -> f32 #foreign __llvm_core "llvm.sqrt.f32";
+@(default_calling_convention="c")
-sqrt :: proc(x: f64) -> f64 #foreign __llvm_core "llvm.sqrt.f64";
+foreign __llvm_core {
+	@(link_name="llvm.sqrt.f32")
+	sqrt :: proc(x: f32) -> f32 ---;
+	@(link_name="llvm.sqrt.f64")
+	sqrt :: proc(x: f64) -> f64 ---;
 
-sin  :: proc(θ: f32) -> f32 #foreign __llvm_core "llvm.sin.f32";
+	@(link_name="llvm.sin.f32")
-sin  :: proc(θ: f64) -> f64 #foreign __llvm_core "llvm.sin.f64";
+	sin :: proc(θ: f32) -> f32 ---;
+	@(link_name="llvm.sin.f64")
+	sin :: proc(θ: f64) -> f64 ---;
 
-cos  :: proc(θ: f32) -> f32 #foreign __llvm_core "llvm.cos.f32";
+	@(link_name="llvm.cos.f32")
-cos  :: proc(θ: f64) -> f64 #foreign __llvm_core "llvm.cos.f64";
+	cos :: proc(θ: f32) -> f32 ---;
+	@(link_name="llvm.cos.f64")
+	cos :: proc(θ: f64) -> f64 ---;
 
-tan  :: proc(θ: f32) -> f32 #inline { return sin(θ)/cos(θ); }
+	@(link_name="llvm.pow.f32")
-tan  :: proc(θ: f64) -> f64 #inline { return sin(θ)/cos(θ); }
+	pow :: proc(x, power: f32) -> f32 ---;
+	@(link_name="llvm.pow.f64")
+	pow :: proc(x, power: f64) -> f64 ---;
 
-pow  :: proc(x, power: f32) -> f32 #foreign __llvm_core "llvm.pow.f32";
+	@(link_name="llvm.fmuladd.f32")
-pow  :: proc(x, power: f64) -> f64 #foreign __llvm_core "llvm.pow.f64";
+	fmuladd :: proc(a, b, c: f32) -> f32 ---;
+	@(link_name="llvm.fmuladd.f64")
+	fmuladd :: proc(a, b, c: f64) -> f64 ---;
+}
 
+tan :: proc "c" (θ: f32) -> f32 do return sin(θ)/cos(θ);
+tan :: proc "c" (θ: f64) -> f64 do return sin(θ)/cos(θ);
 
-lerp   :: proc(a, b, t: f32) -> (x: f32) { return a*(1-t) + b*t; }
+lerp   :: proc(a, b: $T, t: $E) -> (x: T) do return a*(1-t) + b*t;
-lerp   :: proc(a, b, t: f64) -> (x: f64) { return a*(1-t) + b*t; }
+
-unlerp :: proc(a, b, x: f32) -> (t: f32) { return (x-a)/(b-a); }
+unlerp :: proc(a, b, x: f32) -> (t: f32) do return (x-a)/(b-a);
-unlerp :: proc(a, b, x: f64) -> (t: f64) { return (x-a)/(b-a); }
+unlerp :: proc(a, b, x: f64) -> (t: f64) do return (x-a)/(b-a);
 
 
 sign :: proc(x: f32) -> f32 { return x >= 0 ? +1 : -1; }
 sign :: proc(x: f64) -> f64 { return x >= 0 ? +1 : -1; }
 
-fmuladd :: proc(a, b, c: f32) -> f32 #foreign __llvm_core "llvm.fmuladd.f32";
-fmuladd :: proc(a, b, c: f64) -> f64 #foreign __llvm_core "llvm.fmuladd.f64";
 
 
 copy_sign :: proc(x, y: f32) -> f32 {
-	ix := transmute(u32, x);
+	ix := transmute(u32)x;
-	iy := transmute(u32, y);
+	iy := transmute(u32)y;
 	ix &= 0x7fff_ffff;
 	ix |= iy & 0x8000_0000;
-	return transmute(f32, ix);
+	return transmute(f32)ix;
 }
 
 copy_sign :: proc(x, y: f64) -> f64 {
-	ix := transmute(u64, x);
+	ix := transmute(u64)x;
-	iy := transmute(u64, y);
+	iy := transmute(u64)y;
 	ix &= 0x7fff_ffff_ffff_ff;
 	ix |= iy & 0x8000_0000_0000_0000;
-	return transmute(f64, ix);
+	return transmute(f64)ix;
 }
 
-round     :: proc(x: f32) -> f32 { return x >= 0 ? floor(x + 0.5) : ceil(x - 0.5); }
+round :: proc(x: f32) -> f32 { return x >= 0 ? floor(x + 0.5) : ceil(x - 0.5); }
-round     :: proc(x: f64) -> f64 { return x >= 0 ? floor(x + 0.5) : ceil(x - 0.5); }
+round :: proc(x: f64) -> f64 { return x >= 0 ? floor(x + 0.5) : ceil(x - 0.5); }
 
-floor     :: proc(x: f32) -> f32 { return x >= 0 ? f32(i64(x)) : f32(i64(x-0.5)); } // TODO: Get accurate versions
+floor :: proc(x: f32) -> f32 { return x >= 0 ? f32(i64(x)) : f32(i64(x-0.5)); } // TODO: Get accurate versions
-floor     :: proc(x: f64) -> f64 { return x >= 0 ? f64(i64(x)) : f64(i64(x-0.5)); } // TODO: Get accurate versions
+floor :: proc(x: f64) -> f64 { return x >= 0 ? f64(i64(x)) : f64(i64(x-0.5)); } // TODO: Get accurate versions
 
-ceil      :: proc(x: f32) -> f32 { return x <  0 ? f32(i64(x)) : f32(i64(x+1)); } // TODO: Get accurate versions
+ceil :: proc(x: f32) -> f32 { return x < 0 ? f32(i64(x)) : f32(i64(x+1)); }// TODO: Get accurate versions
-ceil      :: proc(x: f64) -> f64 { return x <  0 ? f64(i64(x)) : f64(i64(x+1)); } // TODO: Get accurate versions
+ceil :: proc(x: f64) -> f64 { return x < 0 ? f64(i64(x)) : f64(i64(x+1)); }// TODO: Get accurate versions
 
-remainder :: proc(x, y: f32) -> f32 { return x - round(x/y) * y; }
+remainder :: proc(x, y: f32) -> f32 do return x - round(x/y) * y;
-remainder :: proc(x, y: f64) -> f64 { return x - round(x/y) * y; }
+remainder :: proc(x, y: f64) -> f64 do return x - round(x/y) * y;
 
 mod :: proc(x, y: f32) -> f32 {
+	result: f32;
 	y = abs(y);
-	result := remainder(abs(x), y);
+	result = remainder(abs(x), y);
 	if sign(result) < 0 {
 		result += y;
 	}
 	return copy_sign(result, x);
 }
 mod :: proc(x, y: f64) -> f64 {
+	result: f64;
 	y = abs(y);
-	result := remainder(abs(x), y);
+	result = remainder(abs(x), y);
 	if sign(result) < 0 {
 		result += y;
 	}
@@ -102,52 +117,31 @@ mod :: proc(x, y: f64) -> f64 {
 }
 
 
-to_radians :: proc(degrees: f32) -> f32 { return degrees * TAU / 360; }
+to_radians :: proc(degrees: f32) -> f32 do return degrees * TAU / 360;
-to_degrees :: proc(radians: f32) -> f32 { return radians * 360 / TAU; }
+to_degrees :: proc(radians: f32) -> f32 do return radians * 360 / TAU;
 
 
 
-dot :: proc(a, b: Vec2) -> f32 { c := a*b; return c.x + c.y; }
+dot :: proc(a, b: $T/[$N]$E) -> E {
-dot :: proc(a, b: Vec3) -> f32 { c := a*b; return c.x + c.y + c.z; }
+	res: E;
-dot :: proc(a, b: Vec4) -> f32 { c := a*b; return c.x + c.y + c.z + c.w; }
+	for i in 0..N do res += a[i] * b[i];
+	return res;
+}
 
-cross :: proc(x, y: Vec3) -> Vec3 {
+cross :: proc(x, y: $T/[3]$E) -> T {
 	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;
+	return T(a - b);
 }
 
 
-mag :: proc(v: Vec2) -> f32 { return sqrt(dot(v, v)); }
+mag :: proc(v: $T/[$N]$E) -> E do return sqrt(dot(v, v));
-mag :: proc(v: Vec3) -> f32 { return sqrt(dot(v, v)); }
-mag :: proc(v: Vec4) -> f32 { return sqrt(dot(v, v)); }
 
-norm :: proc(v: Vec2) -> Vec2 { return v / mag(v); }
+norm :: proc(v: $T/[$N]$E) -> T do return v / mag(v);
-norm :: proc(v: Vec3) -> Vec3 { return v / mag(v); }
-norm :: proc(v: Vec4) -> Vec4 { return v / mag(v); }
 
-norm0 :: proc(v: Vec2) -> Vec2 {
+norm0 :: proc(v: $T/[$N]$E) -> T {
 	m := mag(v);
-	if m == 0 {
+	return m == 0 ? 0 : v/m;
-		return 0;
-	}
-	return v / m;
-}
-
-norm0 :: proc(v: Vec3) -> Vec3 {
-	m := mag(v);
-	if m == 0 {
-		return 0;
-	}
-	return v / m;
-}
-
-norm0 :: proc(v: Vec4) -> Vec4 {
-	m := mag(v);
-	if m == 0 {
-		return 0;
-	}
-	return v / m;
 }
 
 
@@ -162,8 +156,8 @@ mat4_identity :: proc() -> Mat4 {
 }
 
 mat4_transpose :: proc(m: Mat4) -> Mat4 {
-	for j in 0..<4 {
+	for j in 0..4 {
-		for i in 0..<4 {
+		for i in 0..4 {
 			m[i][j], m[j][i] = m[j][i], m[i][j];
 		}
 	}
@@ -172,8 +166,8 @@ mat4_transpose :: proc(m: Mat4) -> Mat4 {
 
 mul :: proc(a, b: Mat4) -> Mat4 {
 	c: Mat4;
-	for j in 0..<4 {
+	for j in 0..4 {
-		for i in 0..<4 {
+		for i in 0..4 {
 			c[j][i] = a[0][i]*b[j][0] +
 			          a[1][i]*b[j][1] +
 			          a[2][i]*b[j][2] +
@@ -185,10 +179,10 @@ mul :: proc(a, b: Mat4) -> Mat4 {
 
 mul :: proc(m: Mat4, v: Vec4) -> Vec4 {
 	return Vec4{
-		m[0][0]*v.x + m[1][0]*v.y + m[2][0]*v.z + m[3][0]*v.w,
+		m[0][0]*v[0] + m[1][0]*v[1] + m[2][0]*v[2] + m[3][0]*v[3],
-		m[0][1]*v.x + m[1][1]*v.y + m[2][1]*v.z + m[3][1]*v.w,
+		m[0][1]*v[0] + m[1][1]*v[1] + m[2][1]*v[2] + m[3][1]*v[3],
-		m[0][2]*v.x + m[1][2]*v.y + m[2][2]*v.z + m[3][2]*v.w,
+		m[0][2]*v[0] + m[1][2]*v[1] + m[2][2]*v[2] + m[3][2]*v[3],
-		m[0][3]*v.x + m[1][3]*v.y + m[2][3]*v.z + m[3][3]*v.w,
+		m[0][3]*v[0] + m[1][3]*v[1] + m[2][3]*v[2] + m[3][3]*v[3],
 	};
 }
 
@@ -215,6 +209,7 @@ inverse :: proc(m: Mat4) -> Mat4 {
 	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);
 	o[0][2] = +(m[1][0] * sf01 - m[1][1] * sf03 + m[1][3] * sf05);
@@ -263,9 +258,9 @@ inverse :: proc(m: Mat4) -> Mat4 {
 
 mat4_translate :: proc(v: Vec3) -> Mat4 {
 	m := mat4_identity();
-	m[3][0] = v.x;
+	m[3][0] = v[0];
-	m[3][1] = v.y;
+	m[3][1] = v[1];
-	m[3][2] = v.z;
+	m[3][2] = v[2];
 	m[3][3] = 1;
 	return m;
 }
@@ -279,28 +274,28 @@ mat4_rotate :: proc(v: Vec3, angle_radians: f32) -> Mat4 {
 
 	rot := mat4_identity();
 
-	rot[0][0] = c + t.x*a.x;
+	rot[0][0] = c + t[0]*a[0];
-	rot[0][1] = 0 + t.x*a.y + s*a.z;
+	rot[0][1] = 0 + t[0]*a[1] + s*a[2];
-	rot[0][2] = 0 + t.x*a.z - s*a.y;
+	rot[0][2] = 0 + t[0]*a[2] - s*a[1];
 	rot[0][3] = 0;
 
-	rot[1][0] = 0 + t.y*a.x - s*a.z;
+	rot[1][0] = 0 + t[1]*a[0] - s*a[2];
-	rot[1][1] = c + t.y*a.y;
+	rot[1][1] = c + t[1]*a[1];
-	rot[1][2] = 0 + t.y*a.z + s*a.x;
+	rot[1][2] = 0 + t[1]*a[2] + s*a[0];
 	rot[1][3] = 0;
 
-	rot[2][0] = 0 + t.z*a.x + s*a.y;
+	rot[2][0] = 0 + t[2]*a[0] + s*a[1];
-	rot[2][1] = 0 + t.z*a.y - s*a.x;
+	rot[2][1] = 0 + t[2]*a[1] - s*a[0];
-	rot[2][2] = c + t.z*a.z;
+	rot[2][2] = c + t[2]*a[2];
 	rot[2][3] = 0;
 
 	return rot;
 }
 
 scale :: proc(m: Mat4, v: Vec3) -> Mat4 {
-	m[0][0] *= v.x;
+	m[0][0] *= v[0];
-	m[1][1] *= v.y;
+	m[1][1] *= v[1];
-	m[2][2] *= v.z;
+	m[2][2] *= v[2];
 	return m;
 }
 
@@ -318,9 +313,9 @@ look_at :: proc(eye, centre, up: Vec3) -> Mat4 {
 	u := cross(s, f);
 
 	return Mat4{
-		{+s.x, +u.x, -f.x, 0},
+		{+s[0], +u[0], -f[0], 0},
-		{+s.y, +u.y, -f.y, 0},
+		{+s[1], +u[1], -f[1], 0},
-		{+s.z, +u.z, -f.z, 0},
+		{+s[2], +u[2], -f[2], 0},
 		{-dot(s, eye), -dot(u, eye), dot(f, eye), 1},
 	};
 }
@@ -328,6 +323,7 @@ look_at :: proc(eye, centre, up: Vec3) -> Mat4 {
 perspective :: proc(fovy, aspect, near, far: f32) -> Mat4 {
 	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);
@@ -351,7 +347,6 @@ ortho3d :: proc(left, right, bottom, top, near, far: f32) -> Mat4 {
 
 
 
-
 F32_DIG        :: 6;
 F32_EPSILON    :: 1.192092896e-07;
 F32_GUARD      :: 0;

core/mem.odin

@@ -1,76 +1,95 @@
-#import "fmt.odin";
+import "core:raw.odin"
-#import "os.odin";
 
-swap :: proc(b: u16) -> u16 #foreign __llvm_core "llvm.bswap.i16";
+foreign __llvm_core {
-swap :: proc(b: u32) -> u32 #foreign __llvm_core "llvm.bswap.i32";
+	@(link_name = "llvm.bswap.i16") swap :: proc(b: u16) -> u16 ---;
-swap :: proc(b: u64) -> u64 #foreign __llvm_core "llvm.bswap.i64";
+	@(link_name = "llvm.bswap.i32") swap :: proc(b: u32) -> u32 ---;
+	@(link_name = "llvm.bswap.i64") swap :: proc(b: u64) -> u64 ---;
+}
 
-
+set :: proc "contextless" (data: rawptr, value: i32, len: int) -> rawptr {
-set :: proc(data: rawptr, value: i32, len: int) -> rawptr {
 	return __mem_set(data, value, len);
 }
-zero :: proc(data: rawptr, len: int) -> rawptr {
+zero :: proc "contextless" (data: rawptr, len: int) -> rawptr {
 	return __mem_zero(data, len);
 }
-copy :: proc(dst, src: rawptr, len: int) -> rawptr {
+copy :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr {
 	return __mem_copy(dst, src, len);
 }
-copy_non_overlapping :: proc(dst, src: rawptr, len: int) -> rawptr {
+copy_non_overlapping :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr {
 	return __mem_copy_non_overlapping(dst, src, len);
 }
-compare :: proc(a, b: []u8) -> int {
+compare :: proc "contextless" (a, b: []u8) -> int {
 	return __mem_compare(&a[0], &b[0], min(len(a), len(b)));
 }
 
 
+slice_ptr :: proc "contextless" (ptr: ^$T, len: int) -> []T {
+	assert(len >= 0);
+	slice := raw.Slice{data = ptr, len = len, cap = len};
+	return transmute([]T)slice;
+}
+slice_ptr :: proc "contextless" (ptr: ^$T, len, cap: int) -> []T {
+	assert(0 <= len && len <= cap);
+	slice := raw.Slice{data = ptr, len = len, cap = cap};
+	return transmute([]T)slice;
+}
 
-kilobytes :: proc(x: int) -> int #inline { return          (x) * 1024; }
+slice_to_bytes :: proc "contextless" (slice: $E/[]$T) -> []u8 {
-megabytes :: proc(x: int) -> int #inline { return kilobytes(x) * 1024; }
+	s := transmute(raw.Slice)slice;
-gigabytes :: proc(x: int) -> int #inline { return megabytes(x) * 1024; }
+	s.len *= size_of(T);
-terabytes :: proc(x: int) -> int #inline { return gigabytes(x) * 1024; }
+	s.cap *= size_of(T);
+	return transmute([]u8)s;
+}
 
-is_power_of_two :: proc(x: int) -> bool {
+ptr_to_bytes :: proc "contextless" (ptr: ^$T, len := 1) -> []u8 {
-	if x <= 0 {
+    assert(len >= 0);
-		return false;
+    return transmute([]u8)raw.Slice{ptr, len*size_of(T), len*size_of(T)};
-	}
+}
+
+ptr_to_bytes :: proc "contextless" (ptr: ^$T, len, cap: int) -> []u8 {
+    assert(0 <= len && len <= cap);
+    return transmute([]u8)raw.Slice{ptr, len*size_of(T), cap*size_of(T)};
+}
+
+
+kilobytes :: inline proc "contextless" (x: int) -> int do return          (x) * 1024;
+megabytes :: inline proc "contextless" (x: int) -> int do return kilobytes(x) * 1024;
+gigabytes :: inline proc "contextless" (x: int) -> int do return megabytes(x) * 1024;
+terabytes :: inline proc "contextless" (x: int) -> int do return gigabytes(x) * 1024;
+
+is_power_of_two :: proc(x: uintptr) -> bool {
+	if x <= 0 do return false;
 	return (x & (x-1)) == 0;
 }
 
-align_forward :: proc(ptr: rawptr, align: int) -> rawptr {
+align_forward :: proc(ptr: rawptr, align: uintptr) -> rawptr {
 	assert(is_power_of_two(align));
 
-	a := uint(align);
+	a := uintptr(align);
-	p := uint(ptr);
+	p := uintptr(ptr);
 	modulo := p & (a-1);
-	if modulo != 0 {
+	if modulo != 0 do p += a - modulo;
-		p += a - modulo;
-	}
 	return rawptr(p);
 }
 
 
 
-AllocationHeader :: struct {
+AllocationHeader :: struct {size: int};
-	size: int,
-}
 
 allocation_header_fill :: proc(header: ^AllocationHeader, data: rawptr, size: int) {
 	header.size = size;
-	ptr := ^int(header+1);
+	ptr := cast(^uint)(header+1);
+	n := cast(^uint)data - ptr;
 
-	for i := 0; rawptr(ptr) < data; i++ {
+	for i in 0..n {
-		(ptr+i)^ = -1;
+		(ptr+i)^ = ~uint(0);
 	}
 }
 allocation_header :: proc(data: rawptr) -> ^AllocationHeader {
-	if data == nil {
+	if data == nil do return nil;
-		return nil;
+	p := cast(^uint)data;
-	}
+	for (p-1)^ == ~uint(0) do p = (p-1);
-	p := ^int(data);
+	return cast(^AllocationHeader)(p-1);
-	for (p-1)^ == -1 {
-		p = (p-1);
-	}
-	return ^AllocationHeader(p-1);
 }
 
 
@@ -78,9 +97,9 @@ allocation_header :: proc(data: rawptr) -> ^AllocationHeader {
 
 
 // Custom allocators
+
 Arena :: struct {
 	backing:    Allocator,
-	offset:     int,
 	memory:     []u8,
 	temp_count: int,
 }
@@ -96,22 +115,28 @@ ArenaTempMemory :: struct {
 
 init_arena_from_memory :: proc(using a: ^Arena, data: []u8) {
 	backing    = Allocator{};
-	memory     = data[0..<0];
+	memory     = data[..0];
 	temp_count = 0;
 }
 
 init_arena_from_context :: proc(using a: ^Arena, size: int) {
 	backing = context.allocator;
-	memory = make([]u8, size);
+	memory = make([]u8, 0, size);
 	temp_count = 0;
 }
 
-free_arena :: proc(using a: ^Arena) {
+
+context_from_allocator :: proc(a: Allocator) -> Context {
+	c := context;
+	c.allocator = a;
+	return c;
+}
+
+destroy_arena :: proc(using a: ^Arena) {
 	if backing.procedure != nil {
-		push_allocator backing {
+		context <- context_from_allocator(backing) {
 			free(memory);
 			memory = nil;
-			offset = 0;
 		}
 	}
 }
@@ -123,25 +148,25 @@ arena_allocator :: proc(arena: ^Arena) -> Allocator {
 	};
 }
 
-arena_allocator_proc :: proc(allocator_data: rawptr, mode: AllocatorMode,
+arena_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
-                          size, alignment: int,
+                             size, alignment: int,
-                          old_memory: rawptr, old_size: int, flags: u64) -> rawptr {
+                             old_memory: rawptr, old_size: int, flags: u64, location := #caller_location) -> rawptr {
-	using AllocatorMode;
+	using Allocator_Mode;
-	arena := ^Arena(allocator_data);
+	arena := cast(^Arena)allocator_data;
 
-	match mode {
+
+	switch mode {
 	case Alloc:
 		total_size := size + alignment;
 
-		if arena.offset + total_size > len(arena.memory) {
+		if len(arena.memory) + total_size > cap(arena.memory) {
-			fmt.fprintln(os.stderr, "Arena out of memory");
 			return nil;
 		}
 
-		#no_bounds_check end := &arena.memory[arena.offset];
+		#no_bounds_check end := &arena.memory[len(arena.memory)];
 
-		ptr := align_forward(end, alignment);
+		ptr := align_forward(end, uintptr(alignment));
-		arena.offset += total_size;
+		(^raw.Slice)(&arena.memory).len += total_size;
 		return zero(ptr, size);
 
 	case Free:
@@ -149,7 +174,7 @@ arena_allocator_proc :: proc(allocator_data: rawptr, mode: AllocatorMode,
 		// Use ArenaTempMemory if you want to free a block
 
 	case FreeAll:
-		arena.offset = 0;
+		(^raw.Slice)(&arena.memory).len = 0;
 
 	case Resize:
 		return default_resize_align(old_memory, old_size, size, alignment);
@@ -162,15 +187,15 @@ begin_arena_temp_memory :: proc(a: ^Arena) -> ArenaTempMemory {
 	tmp: ArenaTempMemory;
 	tmp.arena = a;
 	tmp.original_count = len(a.memory);
-	a.temp_count++;
+	a.temp_count += 1;
 	return tmp;
 }
 
 end_arena_temp_memory :: proc(using tmp: ArenaTempMemory) {
 	assert(len(arena.memory) >= original_count);
 	assert(arena.temp_count > 0);
-	arena.memory = arena.memory[0..<original_count];
+	arena.memory = arena.memory[..original_count];
-	arena.temp_count--;
+	arena.temp_count -= 1;
 }
 
 
@@ -179,11 +204,9 @@ end_arena_temp_memory :: proc(using tmp: ArenaTempMemory) {
 
 
 
-align_of_type_info :: proc(type_info: ^TypeInfo) -> int {
+align_of_type_info :: proc(type_info: ^Type_Info) -> int {
 	prev_pow2 :: proc(n: i64) -> i64 {
-		if n <= 0 {
+		if n <= 0 do return 0;
-			return 0;
-		}
 		n |= n >> 1;
 		n |= n >> 2;
 		n |= n >> 4;
@@ -195,46 +218,45 @@ align_of_type_info :: proc(type_info: ^TypeInfo) -> int {
 
 	WORD_SIZE :: size_of(int);
 	MAX_ALIGN :: size_of([vector 64]f64); // TODO(bill): Should these constants be builtin constants?
-	using TypeInfo;
+	switch info in type_info.variant {
-	match info in type_info {
+	case Type_Info_Named:
-	case Named:
 		return align_of_type_info(info.base);
-	case Integer:
+	case Type_Info_Integer:
-		return info.size;
+		return type_info.align;
-	case Float:
+	case Type_Info_Rune:
-		return info.size;
+		return type_info.align;
-	case String:
+	case Type_Info_Float:
+		return type_info.align;
+	case Type_Info_String:
 		return WORD_SIZE;
-	case Boolean:
+	case Type_Info_Boolean:
 		return 1;
-	case Any:
+	case Type_Info_Any:
 		return WORD_SIZE;
-	case Pointer:
+	case Type_Info_Pointer:
 		return WORD_SIZE;
-	case Procedure:
+	case Type_Info_Procedure:
 		return WORD_SIZE;
-	case Array:
+	case Type_Info_Array:
 		return align_of_type_info(info.elem);
-	case DynamicArray:
+	case Type_Info_Dynamic_Array:
 		return WORD_SIZE;
-	case Slice:
+	case Type_Info_Slice:
 		return WORD_SIZE;
-	case Vector:
+	case Type_Info_Vector:
-		size := size_of_type_info(info.elem);
+		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:
+	case Type_Info_Tuple:
-		return info.align;
+		return type_info.align;
-	case Struct:
+	case Type_Info_Struct:
-		return info.align;
+		return type_info.align;
-	case Union:
+	case Type_Info_Union:
-		return info.align;
+		return type_info.align;
-	case RawUnion:
+	case Type_Info_Enum:
-		return info.align;
-	case Enum:
 		return align_of_type_info(info.base);
-	case Map:
+	case Type_Info_Map:
 		return align_of_type_info(info.generated_struct);
 	}
 
@@ -246,57 +268,52 @@ align_formula :: proc(size, align: int) -> int {
 	return result - result%align;
 }
 
-size_of_type_info :: proc(type_info: ^TypeInfo) -> int {
+size_of_type_info :: proc(type_info: ^Type_Info) -> int {
 	WORD_SIZE :: size_of(int);
-	using TypeInfo;
+	switch info in type_info.variant {
-	match info in type_info {
+	case Type_Info_Named:
-	case Named:
 		return size_of_type_info(info.base);
-	case Integer:
+	case Type_Info_Integer:
-		return info.size;
+		return type_info.size;
-	case Float:
+	case Type_Info_Rune:
-		return info.size;
+		return type_info.size;
-	case String:
+	case Type_Info_Float:
+		return type_info.size;
+	case Type_Info_String:
 		return 2*WORD_SIZE;
-	case Boolean:
+	case Type_Info_Boolean:
 		return 1;
-	case Any:
+	case Type_Info_Any:
 		return 2*WORD_SIZE;
-	case Pointer:
+	case Type_Info_Pointer:
 		return WORD_SIZE;
-	case Procedure:
+	case Type_Info_Procedure:
 		return WORD_SIZE;
-	case Array:
+	case Type_Info_Array:
 		count := info.count;
-		if count == 0 {
+		if count == 0 do return 0;
-			return 0;
-		}
 		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:
+	case Type_Info_Dynamic_Array:
 		return size_of(rawptr) + 2*size_of(int) + size_of(Allocator);
-	case Slice:
+	case Type_Info_Slice:
 		return 2*WORD_SIZE;
-	case Vector:
+	case Type_Info_Vector:
 		count := info.count;
-		if count == 0 {
+		if count == 0 do return 0;
-			return 0;
-		}
 		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:
+	case Type_Info_Struct:
-		return info.size;
+		return type_info.size;
-	case Union:
+	case Type_Info_Union:
-		return info.size;
+		return type_info.size;
-	case RawUnion:
+	case Type_Info_Enum:
-		return info.size;
-	case Enum:
 		return size_of_type_info(info.base);
-	case Map:
+	case Type_Info_Map:
 		return size_of_type_info(info.generated_struct);
 	}
 

core/opengl.odin

@@ -1,43 +1,52 @@
-#foreign_system_library lib "opengl32.lib" when ODIN_OS == "windows";
+when ODIN_OS == "windows" {
-#foreign_system_library lib "gl" when ODIN_OS == "linux";
+	foreign import lib "system:opengl32.lib"
-#import win32 "sys/windows.odin" when ODIN_OS == "windows";
+	import win32 "core:sys/windows.odin"
-#import "sys/wgl.odin" when ODIN_OS == "windows";
+	import "core:sys/wgl.odin"
-#load "opengl_constants.odin";
+} else when ODIN_OS == "linux" {
+	foreign import lib "system:gl"
+}
 
-Clear         :: proc(mask: u32)                                #foreign lib "glClear";
+export "core:opengl_constants.odin"
-ClearColor    :: proc(r, g, b, a: f32)                          #foreign lib "glClearColor";
+
-Begin         :: proc(mode: i32)                                #foreign lib "glBegin";
+_ := compile_assert(ODIN_OS != "osx");
-End           :: proc()                                         #foreign lib "glEnd";
+
-Finish        :: proc()                                         #foreign lib "glFinish";
+@(default_calling_convention="c", link_prefix="gl")
-BlendFunc     :: proc(sfactor, dfactor: i32)                    #foreign lib "glBlendFunc";
+foreign lib {
-Enable        :: proc(cap: i32)                                 #foreign lib "glEnable";
+	Clear          :: proc(mask: u32) ---;
-Disable       :: proc(cap: i32)                                 #foreign lib "glDisable";
+	ClearColor     :: proc(r, g, b, a: f32) ---;
-GenTextures   :: proc(count: i32, result: ^u32)                 #foreign lib "glGenTextures";
+	Begin          :: proc(mode: i32) ---;
-DeleteTextures:: proc(count: i32, result: ^u32)                 #foreign lib "glDeleteTextures";
+	End            :: proc() ---;
-TexParameteri :: proc(target, pname, param: i32)                #foreign lib "glTexParameteri";
+	Finish         :: proc() ---;
-TexParameterf :: proc(target: i32, pname: i32, param: f32)      #foreign lib "glTexParameterf";
+	BlendFunc      :: proc(sfactor, dfactor: i32) ---;
-BindTexture   :: proc(target: i32, texture: u32)                #foreign lib "glBindTexture";
+	Enable         :: proc(cap: i32) ---;
-LoadIdentity  :: proc()                                         #foreign lib "glLoadIdentity";
+	Disable        :: proc(cap: i32) ---;
-Viewport      :: proc(x, y, width, height: i32)                 #foreign lib "glViewport";
+	GenTextures    :: proc(count: i32, result: ^u32) ---;
-Ortho         :: proc(left, right, bottom, top, near, far: f64) #foreign lib "glOrtho";
+	DeleteTextures :: proc(count: i32, result: ^u32) ---;
-Color3f       :: proc(r, g, b: f32)                             #foreign lib "glColor3f";
+	TexParameteri  :: proc(target, pname, param: i32) ---;
-Vertex3f      :: proc(x, y, z: f32)                             #foreign lib "glVertex3f";
+	TexParameterf  :: proc(target: i32, pname: i32, param: f32) ---;
-GetError      :: proc() -> i32                                  #foreign lib "glGetError";
+	BindTexture    :: proc(target: i32, texture: u32) ---;
-GetString     :: proc(name: i32) -> ^u8                       #foreign lib "glGetString";
+	LoadIdentity   :: proc() ---;
-GetIntegerv   :: proc(name: i32, v: ^i32)                       #foreign lib "glGetIntegerv";
+	Viewport       :: proc(x, y, width, height: i32) ---;
-TexCoord2f    :: proc(x, y: f32)                                #foreign lib "glTexCoord2f";
+	Ortho          :: proc(left, right, bottom, top, near, far: f64) ---;
-TexImage2D    :: proc(target, level, internal_format,
+	Color3f        :: proc(r, g, b: f32) ---;
-                      width, height, border,
+	Vertex3f       :: proc(x, y, z: f32) ---;
-                      format, type: i32, pixels: rawptr)        #foreign lib "glTexImage2D";
+	GetError       :: proc() -> i32 ---;
+	GetString      :: proc(name: i32) -> ^u8 ---;
+	GetIntegerv    :: proc(name: i32, v: ^i32) ---;
+	TexCoord2f     :: proc(x, y: f32) ---;
+	TexImage2D     :: proc(target, level, internal_format: i32,
+	                       width, height, border: i32,
+	                       format, type_: i32, pixels: rawptr) ---;
+}
 
 
-_string_data :: proc(s: string) -> ^u8 #inline { return &s[0]; }
+_string_data :: inline proc(s: string) -> ^u8 do return &s[0];
 
 _libgl := win32.load_library_a(_string_data("opengl32.dll\x00"));
 
-get_proc_address :: proc(name: string) -> proc() #cc_c {
+get_proc_address :: proc(name: string) -> rawptr {
 	if name[len(name)-1] == 0 {
-		name = name[0..<len(name)-1];
+		name = name[..len(name)-1];
 	}
 	// NOTE(bill): null terminated
 	assert((&name[0] + len(name))^ == 0);
@@ -45,72 +54,74 @@ get_proc_address :: proc(name: string) -> proc() #cc_c {
 	if res == nil {
 		res = win32.get_proc_address(_libgl, &name[0]);
 	}
-	return res;
+	return rawptr(res);
 }
 
-GenBuffers:               proc(count: i32, buffers: ^u32) #cc_c;
+// Procedures
-GenVertexArrays:          proc(count: i32, buffers: ^u32) #cc_c;
+	GenBuffers:               proc "c" (count: i32, buffers: ^u32);
-GenSamplers:              proc(count: i32, buffers: ^u32) #cc_c;
+	GenVertexArrays:          proc "c" (count: i32, buffers: ^u32);
-DeleteBuffers:            proc(count: i32, buffers: ^u32) #cc_c;
+	GenSamplers:              proc "c" (count: i32, buffers: ^u32);
-BindBuffer:               proc(target: i32, buffer: u32) #cc_c;
+	DeleteBuffers:            proc "c" (count: i32, buffers: ^u32);
-BindVertexArray:          proc(buffer: u32) #cc_c;
+	BindBuffer:               proc "c" (target: i32, buffer: u32);
-DeleteVertexArrays:       proc(count: i32, arrays: ^u32) #cc_c;
+	BindVertexArray:          proc "c" (buffer: u32);
-BindSampler:              proc(position: i32, sampler: u32) #cc_c;
+	DeleteVertexArrays:       proc "c" (count: i32, arrays: ^u32);
-BufferData:               proc(target: i32, size: int, data: rawptr, usage: i32) #cc_c;
+	BindSampler:              proc "c" (position: i32, sampler: u32);
-BufferSubData:            proc(target: i32, offset, size: int, data: rawptr) #cc_c;
+	BufferData:               proc "c" (target: i32, size: int, data: rawptr, usage: i32);
+	BufferSubData:            proc "c" (target: i32, offset, size: int, data: rawptr);
 
-DrawArrays:               proc(mode, first: i32, count: u32) #cc_c;
+	DrawArrays:               proc "c" (mode, first: i32, count: u32);
-DrawElements:             proc(mode: i32, count: u32, type_: i32, indices: rawptr) #cc_c;
+	DrawElements:             proc "c" (mode: i32, count: u32, type_: i32, indices: rawptr);
 
-MapBuffer:                proc(target, access: i32) -> rawptr #cc_c;
+	MapBuffer:                proc "c" (target, access: i32) -> rawptr;
-UnmapBuffer:              proc(target: i32) #cc_c;
+	UnmapBuffer:              proc "c" (target: i32);
 
-VertexAttribPointer:      proc(index: u32, size, type_: i32, normalized: i32, stride: u32, pointer: rawptr) #cc_c;
+	VertexAttribPointer:      proc "c" (index: u32, size, type_: i32, normalized: i32, stride: u32, pointer: rawptr);
-EnableVertexAttribArray:  proc(index: u32) #cc_c;
+	EnableVertexAttribArray:  proc "c" (index: u32);
 
-CreateShader:             proc(shader_type: i32) -> u32 #cc_c;
+	CreateShader:             proc "c" (shader_type: i32) -> u32;
-ShaderSource:             proc(shader: u32, count: u32, str: ^^u8, length: ^i32) #cc_c;
+	ShaderSource:             proc "c" (shader: u32, count: u32, str: ^^u8, length: ^i32);
-CompileShader:            proc(shader: u32) #cc_c;
+	CompileShader:            proc "c" (shader: u32);
-CreateProgram:            proc() -> u32 #cc_c;
+	CreateProgram:            proc "c" () -> u32;
-AttachShader:             proc(program, shader: u32) #cc_c;
+	AttachShader:             proc "c" (program, shader: u32);
-DetachShader:             proc(program, shader: u32) #cc_c;
+	DetachShader:             proc "c" (program, shader: u32);
-DeleteShader:             proc(shader:  u32) #cc_c;
+	DeleteShader:             proc "c" (shader:  u32);
-LinkProgram:              proc(program: u32) #cc_c;
+	LinkProgram:              proc "c" (program: u32);
-UseProgram:               proc(program: u32) #cc_c;
+	UseProgram:               proc "c" (program: u32);
-DeleteProgram:            proc(program: u32) #cc_c;
+	DeleteProgram:            proc "c" (program: u32);
 
 
-GetShaderiv:              proc(shader:  u32, pname: i32, params: ^i32) #cc_c;
+	GetShaderiv:              proc "c" (shader:  u32, pname: i32, params: ^i32);
-GetProgramiv:             proc(program: u32, pname: i32, params: ^i32) #cc_c;
+	GetProgramiv:             proc "c" (program: u32, pname: i32, params: ^i32);
-GetShaderInfoLog:         proc(shader:  u32, max_length: u32, length: ^u32, info_long: ^u8) #cc_c;
+	GetShaderInfoLog:         proc "c" (shader:  u32, max_length: u32, length: ^u32, info_long: ^u8);
-GetProgramInfoLog:        proc(program: u32, max_length: u32, length: ^u32, info_long: ^u8) #cc_c;
+	GetProgramInfoLog:        proc "c" (program: u32, max_length: u32, length: ^u32, info_long: ^u8);
 
-ActiveTexture:            proc(texture: i32) #cc_c;
+	ActiveTexture:            proc "c" (texture: i32);
-GenerateMipmap:           proc(target:  i32) #cc_c;
+	GenerateMipmap:           proc "c" (target:  i32);
 
-SamplerParameteri:        proc(sampler: u32, pname: i32, param: i32) #cc_c;
+	SamplerParameteri:        proc "c" (sampler: u32, pname: i32, param: i32);
-SamplerParameterf:        proc(sampler: u32, pname: i32, param: f32) #cc_c;
+	SamplerParameterf:        proc "c" (sampler: u32, pname: i32, param: f32);
-SamplerParameteriv:       proc(sampler: u32, pname: i32, params: ^i32) #cc_c;
+	SamplerParameteriv:       proc "c" (sampler: u32, pname: i32, params: ^i32);
-SamplerParameterfv:       proc(sampler: u32, pname: i32, params: ^f32) #cc_c;
+	SamplerParameterfv:       proc "c" (sampler: u32, pname: i32, params: ^f32);
-SamplerParameterIiv:      proc(sampler: u32, pname: i32, params: ^i32) #cc_c;
+	SamplerParameterIiv:      proc "c" (sampler: u32, pname: i32, params: ^i32);
-SamplerParameterIuiv:     proc(sampler: u32, pname: i32, params: ^u32) #cc_c;
+	SamplerParameterIuiv:     proc "c" (sampler: u32, pname: i32, params: ^u32);
 
 
-Uniform1i:                proc(loc: i32, v0: i32) #cc_c;
+	Uniform1i:                proc "c" (loc: i32, v0: i32);
-Uniform2i:                proc(loc: i32, v0, v1: i32) #cc_c;
+	Uniform2i:                proc "c" (loc: i32, v0, v1: i32);
-Uniform3i:                proc(loc: i32, v0, v1, v2: i32) #cc_c;
+	Uniform3i:                proc "c" (loc: i32, v0, v1, v2: i32);
-Uniform4i:                proc(loc: i32, v0, v1, v2, v3: i32) #cc_c;
+	Uniform4i:                proc "c" (loc: i32, v0, v1, v2, v3: i32);
-Uniform1f:                proc(loc: i32, v0: f32) #cc_c;
+	Uniform1f:                proc "c" (loc: i32, v0: f32);
-Uniform2f:                proc(loc: i32, v0, v1: f32) #cc_c;
+	Uniform2f:                proc "c" (loc: i32, v0, v1: f32);
-Uniform3f:                proc(loc: i32, v0, v1, v2: f32) #cc_c;
+	Uniform3f:                proc "c" (loc: i32, v0, v1, v2: f32);
-Uniform4f:                proc(loc: i32, v0, v1, v2, v3: f32) #cc_c;
+	Uniform4f:                proc "c" (loc: i32, v0, v1, v2, v3: f32);
-UniformMatrix4fv:         proc(loc: i32, count: u32, transpose: i32, value: ^f32) #cc_c;
+	UniformMatrix4fv:         proc "c" (loc: i32, count: u32, transpose: i32, value: ^f32);
+
+	GetUniformLocation:       proc "c" (program: u32, name: ^u8) -> i32;
 
-GetUniformLocation:       proc(program: u32, name: ^u8) -> i32 #cc_c;
 
 init :: proc() {
-	set_proc_address :: proc(p: rawptr, name: string) #inline {
+	set_proc_address :: proc(p: rawptr, name: string) {
-		x := ^(proc() #cc_c)(p);
+		x := cast(^rawptr)p;
 		x^ = get_proc_address(name);
 	}
 

core/opengl_constants.odin

@@ -1,4 +1,3 @@
-
 FALSE                          :: 0;
 TRUE                           :: 1;
 
@@ -1383,3 +1382,26 @@ DEBUG_SEVERITY_HIGH_ARB        :: 0x9146;
 DEBUG_SEVERITY_MEDIUM_ARB      :: 0x9147;
 DEBUG_SEVERITY_LOW_ARB         :: 0x9148;
 
+
+SHADER_BINARY_FORMAT_SPIR_V    :: 0x9551;
+SPIR_V_BINARY                  :: 0x9552;
+PARAMETER_BUFFER               :: 0x80EE;
+PARAMETER_BUFFER_BINDING       :: 0x80EF;
+CONTEXT_FLAG_NO_ERROR_BIT      :: 0x00000008;
+VERTICES_SUBMITTED             :: 0x82EE;
+PRIMITIVES_SUBMITTED           :: 0x82EF;
+VERTEX_SHADER_INVOCATIONS      :: 0x82F0;
+TESS_CONTROL_SHADER_PATCHES    :: 0x82F1;
+TESS_EVALUATION_SHADER_INVOCATIONS :: 0x82F2;
+GEOMETRY_SHADER_PRIMITIVES_EMITTED :: 0x82F3;
+FRAGMENT_SHADER_INVOCATIONS    :: 0x82F4;
+COMPUTE_SHADER_INVOCATIONS     :: 0x82F5;
+CLIPPING_INPUT_PRIMITIVES      :: 0x82F6;
+CLIPPING_OUTPUT_PRIMITIVES     :: 0x82F7;
+POLYGON_OFFSET_CLAMP           :: 0x8E1B;
+SPIR_V_EXTENSIONS              :: 0x9553;
+NUM_SPIR_V_EXTENSIONS          :: 0x9554;
+TEXTURE_MAX_ANISOTROPY         :: 0x84FE;
+MAX_TEXTURE_MAX_ANISOTROPY     :: 0x84FF;
+TRANSFORM_FEEDBACK_OVERFLOW    :: 0x82EC;
+TRANSFORM_FEEDBACK_STREAM_OVERFLOW :: 0x82ED;

core/os.odin

@@ -1,12 +1,14 @@
-#load "os_windows.odin" when ODIN_OS == "windows";
+when ODIN_OS == "windows" do export "core:os_windows.odin";
-#load "os_x.odin"       when ODIN_OS == "osx";
+when ODIN_OS == "osx"     do export "core:os_x.odin";
-#load "os_linux.odin"   when ODIN_OS == "linux";
+when ODIN_OS == "linux"   do export "core:os_linux.odin";
+
+import "mem.odin";
 
 write_string :: proc(fd: Handle, str: string) -> (int, Errno) {
-	return write(fd, []u8(str));
+	return write(fd, cast([]u8)str);
 }
 
-read_entire_file :: proc(name: string) -> ([]u8, bool) {
+read_entire_file :: proc(name: string) -> (data: []u8, success: bool) {
 	fd, err := open(name, O_RDONLY, 0);
 	if err != 0 {
 		return nil, false;
@@ -18,11 +20,11 @@ read_entire_file :: proc(name: string) -> ([]u8, bool) {
 		return nil, false;
 	}
 
-	if length == 0 {
+	if length <= 0 {
 		return nil, true;
 	}
 
-	data := make([]u8, length);
+	data := make([]u8, int(length));
 	if data == nil {
 		return nil, false;
 	}
@@ -32,11 +34,15 @@ read_entire_file :: proc(name: string) -> ([]u8, bool) {
 		free(data);
 		return nil, false;
 	}
-	return data[0..<bytes_read], true;
+	return data[0..bytes_read], true;
 }
 
-write_entire_file :: proc(name: string, data: []u8) -> bool {
+write_entire_file :: proc(name: string, data: []u8, truncate := true) -> (success: bool) {
-	fd, err := open(name, O_WRONLY, 0);
+	flags: int = O_WRONLY|O_CREATE;
+	if truncate {
+		flags |= O_TRUNC;
+	}
+	fd, err := open(name, flags, 0);
 	if err != 0 {
 		return false;
 	}
@@ -45,3 +51,11 @@ write_entire_file :: proc(name: string, data: []u8) -> bool {
 	bytes_written, write_err := write(fd, data);
 	return write_err != 0;
 }
+
+write :: proc(fd: Handle, data: rawptr, len: int) -> (int, Errno) {
+	return write(fd, mem.slice_ptr(cast(^u8)data, len));
+}
+
+read :: proc(fd: Handle, data: rawptr, len: int) -> (int, Errno) {
+	return read(fd, mem.slice_ptr(cast(^u8)data, len));
+}

core/os_linux.odin

@@ -1,16 +1,18 @@
-// #import "fmt.odin";
+foreign import dl   "system:dl"
-#import "strings.odin";
+foreign import libc "system:c"
+
+import "core:strings.odin"
+import "core:mem.odin"
 
 Handle    :: i32;
-FileTime :: u64;
+File_Time :: u64;
 Errno     :: i32;
 
-// INVALID_HANDLE: Handle : -1;
 
 O_RDONLY   :: 0x00000;
 O_WRONLY   :: 0x00001;
 O_RDWR     :: 0x00002;
-O_CREAT    :: 0x00040;
+O_CREATE   :: 0x00040;
 O_EXCL     :: 0x00080;
 O_NOCTTY   :: 0x00100;
 O_TRUNC    :: 0x00200;
@@ -19,6 +21,8 @@ O_APPEND   :: 0x00400;
 O_SYNC     :: 0x01000;
 O_ASYNC    :: 0x02000;
 O_CLOEXEC  :: 0x80000;
+
+
 SEEK_SET   :: 0;
 SEEK_CUR   :: 1;
 SEEK_END   :: 2;
@@ -34,9 +38,9 @@ RTLD_BINDING_MASK :: 0x3;
 RTLD_GLOBAL       :: 0x100;
 
 // "Argv" arguments converted to Odin strings
-immutable args := _alloc_command_line_arguments();
+args := _alloc_command_line_arguments();
 
-_FileTime :: struct #ordered {
+_File_Time :: struct #ordered {
 	seconds:     i64,
 	nanoseconds: i32,
 	reserved:    i32,
@@ -59,9 +63,9 @@ Stat :: struct #ordered {
 	block_size:    i64, // Optimal bllocksize for I/O
 	blocks:        i64, // Number of 512-byte blocks allocated
 
-	last_access:   _FileTime, // Time of last access
+	last_access:   _File_Time, // Time of last access
-	modified:      _FileTime, // Time of last modification
+	modified:      _File_Time, // Time of last modification
-	status_change: _FileTime, // Time of last status change
+	status_change: _File_Time, // Time of last status change
 
 	_reserve1,
 	_reserve2,
@@ -71,7 +75,6 @@ Stat :: struct #ordered {
 };
 
 // File type
-
 S_IFMT   :: 0170000; // Type of file mask
 S_IFIFO  :: 0010000; // Named pipe (fifo)
 S_IFCHR  :: 0020000; // Character special
@@ -83,21 +86,18 @@ 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
 
-// Read, write, execute/search by 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
+	// 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
@@ -107,42 +107,44 @@ S_ISUID :: 0004000; // Set user id on execution
 S_ISGID :: 0002000; // Set group id on execution
 S_ISVTX :: 0001000; // Directory restrcted delete
 
-S_ISLNK  :: proc(m: u32) -> bool #inline  {return ((m) & S_IFMT) == S_IFLNK; }
-S_ISREG  :: proc(m: u32) -> bool #inline  {return ((m) & S_IFMT) == S_IFREG; }
-S_ISDIR  :: proc(m: u32) -> bool #inline  {return ((m) & S_IFMT) == S_IFDIR; }
-S_ISCHR  :: proc(m: u32) -> bool #inline  {return ((m) & S_IFMT) == S_IFCHR; }
-S_ISBLK  :: proc(m: u32) -> bool #inline  {return ((m) & S_IFMT) == S_IFBLK; }
-S_ISFIFO :: proc(m: u32) -> bool #inline  {return ((m) & S_IFMT) == S_IFIFO; }
-S_ISSOCK :: proc(m: u32) -> bool #inline  {return ((m) & S_IFMT) == S_IFSOCK;}
 
-R_OK :: 4; // Test for read permission
+S_ISLNK  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFLNK;
-W_OK :: 2; // Test for write permission
+S_ISREG  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFREG;
-X_OK :: 1; // Test for execute permission
+S_ISDIR  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFDIR;
+S_ISCHR  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFCHR;
+S_ISBLK  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFBLK;
+S_ISFIFO :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFIFO;
+S_ISSOCK :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFSOCK;
+
 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_system_library dl   "dl";
+foreign libc {
-#foreign_system_library libc "c";
+	@(link_name="open")    _unix_open    :: proc(path: ^u8, mode: int) -> Handle ---;
+	@(link_name="close")   _unix_close   :: proc(fd: Handle) -> i32 ---;
+	@(link_name="read")    _unix_read    :: proc(fd: Handle, buf: rawptr, size: int) -> int ---;
+	@(link_name="write")   _unix_write   :: proc(fd: Handle, buf: rawptr, size: int) -> int ---;
+	@(link_name="lseek64") _unix_seek    :: proc(fd: Handle, offset: i64, whence: i32) -> i64 ---;
+	@(link_name="gettid")  _unix_gettid  :: proc() -> u64 ---;
+	@(link_name="stat")    _unix_stat    :: proc(path: ^u8, stat: ^Stat) -> i32 ---;
+	@(link_name="access")  _unix_access  :: proc(path: ^u8, mask: int) -> i32 ---;
 
-_unix_open   :: proc(path: ^u8, mode: int) -> Handle                               #foreign libc "open";
+	@(link_name="malloc")  _unix_malloc  :: proc(size: int) -> rawptr ---;
-_unix_close  :: proc(fd: Handle) -> i32                                            #foreign libc "close";
+	@(link_name="calloc")  _unix_calloc  :: proc(num, size: int) -> rawptr ---;
-_unix_read   :: proc(fd: Handle, buf: rawptr, size: int) -> int                    #foreign libc "read";
+	@(link_name="free")    _unix_free    :: proc(ptr: rawptr) ---;
-_unix_write  :: proc(fd: Handle, buf: rawptr, size: int) -> int                    #foreign libc "write";
+	@(link_name="realloc") _unix_realloc :: proc(ptr: rawptr, size: int) -> rawptr ---;
-_unix_seek   :: proc(fd: Handle, offset: i64, whence: i32) -> i64                  #foreign libc "lseek64";
+	@(link_name="getenv")  _unix_getenv  :: proc(^u8) -> ^u8 ---;
-_unix_gettid :: proc() -> u64                                                      #foreign libc "gettid";
-_unix_stat   :: proc(path: ^u8, stat: ^Stat) -> i32                                #foreign libc "stat";
-_unix_access :: proc(path: ^u8, mask: int) -> i32                                  #foreign libc "access";
 
-_unix_malloc  :: proc(size: int) -> rawptr                                         #foreign libc "malloc";
+	@(link_name="exit")    _unix_exit    :: proc(status: int) ---;
-_unix_free    :: proc(ptr: rawptr)                                                 #foreign libc "free";
+}
-_unix_realloc :: proc(ptr: rawptr, size: int) -> rawptr                            #foreign libc "realloc";
+foreign dl {
-_unix_getenv  :: proc(^u8) -> ^u8                                                  #foreign libc "getenv";
+	@(link_name="dlopen")  _unix_dlopen  :: proc(filename: ^u8, flags: int) -> rawptr ---;
-
+	@(link_name="dlsym")   _unix_dlsym   :: proc(handle: rawptr, symbol: ^u8) -> rawptr ---;
-_unix_exit :: proc(status: int)                                                    #foreign libc "exit";
+	@(link_name="dlclose") _unix_dlclose :: proc(handle: rawptr) -> int ---;
-
+	@(link_name="dlerror") _unix_dlerror :: proc() -> ^u8 ---;
-_unix_dlopen  :: proc(filename: ^u8, flags: int) -> rawptr                         #foreign dl   "dlopen";
+}
-_unix_dlsym   :: proc(handle: rawptr, symbol: ^u8) ->  (proc() #cc_c)              #foreign dl   "dlsym";
-_unix_dlclose :: proc(handle: rawptr) -> int                                       #foreign dl   "dlclose";
-_unix_dlerror :: proc() -> ^u8                                                     #foreign dl   "dlerror";
 
 // TODO(zangent): Change this to just `open` when Bill fixes overloading.
 open_simple :: proc(path: string, mode: int) -> (Handle, Errno) {
@@ -156,7 +158,7 @@ open_simple :: proc(path: string, mode: int) -> (Handle, Errno) {
 	return handle, 0;
 }
 // NOTE(zangent): This is here for compatability reasons. Should this be here?
-open :: proc(path: string, mode: int, perm: u32) -> (Handle, Errno) {
+open :: proc(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errno) {
 	return open_simple(path, mode);
 }
 
@@ -180,7 +182,7 @@ seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
 }
 
 file_size :: proc(fd: Handle) -> (i64, Errno) {
-	prev, _ := seek(fd, 0, SEEK_CUR);
+	prev, _   := seek(fd, 0, SEEK_CUR);
 	size, err := seek(fd, 0, SEEK_END);
 	seek(fd, prev, SEEK_SET);
 	return size, err;
@@ -188,16 +190,17 @@ file_size :: proc(fd: Handle) -> (i64, Errno) {
 
 
 // NOTE(bill): Uses startup to initialize it
+
 stdin:  Handle = 0;
 stdout: Handle = 1;
 stderr: Handle = 2;
 
 /* TODO(zangent): Implement these!
-last_write_time :: proc(fd: Handle) -> FileTime {}
+last_write_time :: proc(fd: Handle) -> File_Time {}
-last_write_time_by_name :: proc(name: string) -> FileTime {}
+last_write_time_by_name :: proc(name: string) -> File_Time {}
 */
 
-stat :: proc(path: string) -> (Stat, int) #inline {
+stat :: inline proc(path: string) -> (Stat, int) {
 	s: Stat;
 	cstr := strings.new_c_string(path);
 	defer free(cstr);
@@ -205,56 +208,15 @@ stat :: proc(path: string) -> (Stat, int) #inline {
 	return s, int(ret_int);
 }
 
-access :: proc(path: string, mask: int) -> bool #inline {
+access :: inline proc(path: string, mask: int) -> bool {
 	cstr := strings.new_c_string(path);
 	defer free(cstr);
 	return _unix_access(cstr, mask) == 0;
 }
 
-
-
-// read_entire_file :: proc(name: string) -> ([]u8, bool) {
-// 	fd: Handle;
-// 	err: Errno;
-// 	size: i64;
-
-// 	fd, err = open_simple(name, O_RDONLY);
-// 	if(err != 0) {
-// 		fmt.println("Failed to open file.");
-// 		return nil, false;
-// 	}
-// 	defer close(fd);
-
-// 	// We have a file
-// 	size, err = seek(fd, 0, SEEK_END);
-// 	if(err != 0) {
-// 		fmt.println("Failed to seek to end of file.");
-// 		return nil, false;
-// 	}
-
-// 	_, err = seek(fd, 0, SEEK_SET);
-// 	if(err != 0) {
-// 		fmt.println("Failed to seek to beginning of file.");
-// 		return nil, false;
-// 	}
-
-// 	// We have a file size!
-
-// 	data := make([]u8, size+1);
-// 	if data == nil {
-// 		fmt.println("Failed to allocate file buffer.");
-// 		return nil, false;
-// 	}
-
-// 	read(fd, data);
-// 	data[size] = 0;
-
-// 	return data, true;
-// }
-
 heap_alloc :: proc(size: int) -> rawptr {
 	assert(size > 0);
-	return _unix_malloc(size);
+	return _unix_calloc(1, size);
 }
 
 heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
@@ -284,20 +246,20 @@ current_thread_id :: proc() -> int {
 	return 0;
 }
 
-dlopen :: proc(filename: string, flags: int) -> rawptr #inline {
+dlopen :: inline proc(filename: string, flags: int) -> rawptr {
 	cstr := strings.new_c_string(filename);
 	handle := _unix_dlopen(cstr, flags);
 	free(cstr);
 	return handle;
 }
-dlsym :: proc(handle: rawptr, symbol: string) -> (proc() #cc_c) #inline {
+dlsym :: inline proc(handle: rawptr, symbol: string) -> rawptr {
 	assert(handle != nil);
 	cstr := strings.new_c_string(symbol);
 	proc_handle := _unix_dlsym(handle, cstr);
 	free(cstr);
 	return proc_handle;
 }
-dlclose :: proc(handle: rawptr) -> bool #inline {
+dlclose :: inline proc(handle: rawptr) -> bool {
 	assert(handle != nil);
 	return _unix_dlclose(handle) == 0;
 }
@@ -307,6 +269,9 @@ dlerror :: proc() -> string {
 
 
 _alloc_command_line_arguments :: proc() -> []string {
-	// TODO(bill):
+	args := make([]string, __argc__);
-	return nil;
+	for i in 0..__argc__ {
+		args[i] = strings.to_odin_string((__argv__+i)^);
+	}
+	return args;
 }

core/os_windows.odin

@@ -1,16 +1,18 @@
-#import win32 "sys/windows.odin";
+import win32 "core:sys/windows.odin"
+import "core:mem.odin"
 
-Handle    :: int;
+Handle    :: uintptr;
-FileTime :: u64;
+File_Time :: u64;
-Errno     :: int;
+
+
+INVALID_HANDLE :: ~Handle(0);
 
-INVALID_HANDLE: Handle : -1;
 
 
 O_RDONLY   :: 0x00000;
 O_WRONLY   :: 0x00001;
 O_RDWR     :: 0x00002;
-O_CREAT    :: 0x00040;
+O_CREATE   :: 0x00040;
 O_EXCL     :: 0x00080;
 O_NOCTTY   :: 0x00100;
 O_TRUNC    :: 0x00200;
@@ -20,51 +22,51 @@ O_SYNC     :: 0x01000;
 O_ASYNC    :: 0x02000;
 O_CLOEXEC  :: 0x80000;
 
-ERROR_NONE:                Errno : 0;
+Errno :: int;
-ERROR_FILE_NOT_FOUND:      Errno : 2;
+
-ERROR_PATH_NOT_FOUND:      Errno : 3;
+ERROR_NONE:                   Errno : 0;
-ERROR_ACCESS_DENIED:       Errno : 5;
+ERROR_FILE_NOT_FOUND:         Errno : 2;
-ERROR_NO_MORE_FILES:       Errno : 18;
+ERROR_PATH_NOT_FOUND:         Errno : 3;
-ERROR_HANDLE_EOF:          Errno : 38;
+ERROR_ACCESS_DENIED:          Errno : 5;
-ERROR_NETNAME_DELETED:     Errno : 64;
+ERROR_NO_MORE_FILES:          Errno : 18;
-ERROR_FILE_EXISTS:         Errno : 80;
+ERROR_HANDLE_EOF:             Errno : 38;
-ERROR_BROKEN_PIPE:         Errno : 109;
+ERROR_NETNAME_DELETED:        Errno : 64;
-ERROR_BUFFER_OVERFLOW:     Errno : 111;
+ERROR_FILE_EXISTS:            Errno : 80;
-ERROR_INSUFFICIENT_BUFFER: Errno : 122;
+ERROR_BROKEN_PIPE:            Errno : 109;
-ERROR_MOD_NOT_FOUND:       Errno : 126;
+ERROR_BUFFER_OVERFLOW:        Errno : 111;
-ERROR_PROC_NOT_FOUND:      Errno : 127;
+ERROR_INSUFFICIENT_BUFFER:    Errno : 122;
-ERROR_DIR_NOT_EMPTY:       Errno : 145;
+ERROR_MOD_NOT_FOUND:          Errno : 126;
-ERROR_ALREADY_EXISTS:      Errno : 183;
+ERROR_PROC_NOT_FOUND:         Errno : 127;
-ERROR_ENVVAR_NOT_FOUND:    Errno : 203;
+ERROR_DIR_NOT_EMPTY:          Errno : 145;
-ERROR_MORE_DATA:           Errno : 234;
+ERROR_ALREADY_EXISTS:         Errno : 183;
-ERROR_OPERATION_ABORTED:   Errno : 995;
+ERROR_ENVVAR_NOT_FOUND:       Errno : 203;
-ERROR_IO_PENDING:          Errno : 997;
+ERROR_MORE_DATA:              Errno : 234;
-ERROR_NOT_FOUND:           Errno : 1168;
+ERROR_OPERATION_ABORTED:      Errno : 995;
-ERROR_PRIVILEGE_NOT_HELD:  Errno : 1314;
+ERROR_IO_PENDING:             Errno : 997;
-WSAEACCES:                 Errno : 10013;
+ERROR_NOT_FOUND:              Errno : 1168;
-WSAECONNRESET:             Errno : 10054;
+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;
+ERROR_FILE_IS_PIPE:           Errno : 1<<29 + 0;
 
 
 // "Argv" arguments converted to Odin strings
-immutable args := _alloc_command_line_arguments();
+args := _alloc_command_line_arguments();
 
 
-open :: proc(path: string, mode: int, perm: u32) -> (Handle, Errno) {
+open :: proc(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errno) {
-	if len(path) == 0 {
+	if len(path) == 0 do return INVALID_HANDLE, ERROR_FILE_NOT_FOUND;
-		return INVALID_HANDLE, ERROR_FILE_NOT_FOUND;
-	}
 
 	access: u32;
-	match mode & (O_RDONLY|O_WRONLY|O_RDWR) {
+	switch mode & (O_RDONLY|O_WRONLY|O_RDWR) {
 	case O_RDONLY: access = win32.FILE_GENERIC_READ;
 	case O_WRONLY: access = win32.FILE_GENERIC_WRITE;
 	case O_RDWR:   access = win32.FILE_GENERIC_READ | win32.FILE_GENERIC_WRITE;
 	}
 
-	if mode&O_CREAT != 0 {
+	if mode&O_CREATE != 0 {
 		access |= win32.FILE_GENERIC_WRITE;
 	}
 	if mode&O_APPEND != 0 {
@@ -80,12 +82,12 @@ open :: proc(path: string, mode: int, perm: u32) -> (Handle, Errno) {
 	}
 
 	create_mode: u32;
-	match {
+	switch {
-	case mode&(O_CREAT|O_EXCL) == (O_CREAT | O_EXCL):
+	case mode&(O_CREATE|O_EXCL) == (O_CREATE | O_EXCL):
 		create_mode = win32.CREATE_NEW;
-	case mode&(O_CREAT|O_TRUNC) == (O_CREAT | O_TRUNC):
+	case mode&(O_CREATE|O_TRUNC) == (O_CREATE | O_TRUNC):
 		create_mode = win32.CREATE_ALWAYS;
-	case mode&O_CREAT == O_CREAT:
+	case mode&O_CREATE == O_CREATE:
 		create_mode = win32.OPEN_ALWAYS;
 	case mode&O_TRUNC == O_TRUNC:
 		create_mode = win32.TRUNCATE_EXISTING;
@@ -94,14 +96,13 @@ open :: proc(path: string, mode: int, perm: u32) -> (Handle, Errno) {
 	}
 
 	buf: [300]u8;
-	copy(buf[..], []u8(path));
+	copy(buf[..], cast([]u8)path);
 
 	handle := Handle(win32.create_file_a(&buf[0], access, share_mode, sa, create_mode, win32.FILE_ATTRIBUTE_NORMAL, nil));
-	if handle != INVALID_HANDLE {
+	if handle != INVALID_HANDLE do return handle, ERROR_NONE;
-		return handle, ERROR_NONE;
+
-	}
+	err := Errno(win32.get_last_error());
-	err := win32.get_last_error();
+	return INVALID_HANDLE, err;
-	return INVALID_HANDLE, Errno(err);
 }
 
 close :: proc(fd: Handle) {
@@ -110,26 +111,21 @@ close :: proc(fd: Handle) {
 
 
 write :: proc(fd: Handle, data: []u8) -> (int, Errno) {
-	if len(data) == 0 {
+	if len(data) == 0 do return 0, ERROR_NONE;
-		return 0, ERROR_NONE;
+
-	}
 	single_write_length: i32;
 	total_write: i64;
 	length := i64(len(data));
 
 	for total_write < length {
 		remaining := length - total_write;
-		to_read: i32;
 		MAX :: 1<<31-1;
-		if remaining <= MAX {
+		to_write: i32 = min(i32(remaining), MAX);
-			to_read = i32(remaining);
+
-		} else {
+		e := win32.write_file(win32.Handle(fd), &data[total_write], to_write, &single_write_length, nil);
-			to_read = MAX;
-		}
-		e := win32.write_file(win32.Handle(fd), &data[total_write], to_read, &single_write_length, nil);
 		if single_write_length <= 0 || e == win32.FALSE {
-			err := win32.get_last_error();
+			err := Errno(win32.get_last_error());
-			return int(total_write), Errno(e);
+			return int(total_write), err;
 		}
 		total_write += i64(single_write_length);
 	}
@@ -137,9 +133,7 @@ write :: proc(fd: Handle, data: []u8) -> (int, Errno) {
 }
 
 read :: proc(fd: Handle, data: []u8) -> (int, Errno) {
-	if len(data) == 0 {
+	if len(data) == 0 do return 0, ERROR_NONE;
-		return 0, ERROR_NONE;
-	}
 
 	single_read_length: i32;
 	total_read: i64;
@@ -147,18 +141,13 @@ read :: proc(fd: Handle, data: []u8) -> (int, Errno) {
 
 	for total_read < length {
 		remaining := length - total_read;
-		to_read: u32;
 		MAX :: 1<<32-1;
-		if remaining <= MAX {
+		to_read: u32 = min(u32(remaining), MAX);
-			to_read = u32(remaining);
-		} else {
-			to_read = MAX;
-		}
 
 		e := win32.read_file(win32.Handle(fd), &data[total_read], to_read, &single_read_length, nil);
 		if single_read_length <= 0 || e == win32.FALSE {
-			err := win32.get_last_error();
+			err := Errno(win32.get_last_error());
-			return int(total_read), Errno(e);
+			return int(total_read), err;
 		}
 		total_read += i64(single_read_length);
 	}
@@ -167,7 +156,7 @@ read :: proc(fd: Handle, data: []u8) -> (int, Errno) {
 
 seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
 	w: u32;
-	match whence {
+	switch whence {
 	case 0: w = win32.FILE_BEGIN;
 	case 1: w = win32.FILE_CURRENT;
 	case 2: w = win32.FILE_END;
@@ -175,13 +164,12 @@ seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
 	hi := i32(offset>>32);
 	lo := i32(offset);
 	ft := win32.get_file_type(win32.Handle(fd));
-	if ft == win32.FILE_TYPE_PIPE {
+	if ft == win32.FILE_TYPE_PIPE do return 0, ERROR_FILE_IS_PIPE;
-		return 0, ERROR_FILE_IS_PIPE;
+
-	}
 	dw_ptr := win32.set_file_pointer(win32.Handle(fd), lo, &hi, w);
 	if dw_ptr == win32.INVALID_SET_FILE_POINTER {
-		err := win32.get_last_error();
+		err := Errno(win32.get_last_error());
-		return 0, Errno(err);
+		return 0, err;
 	}
 	return i64(hi)<<32 + i64(dw_ptr), ERROR_NONE;
 }
@@ -214,29 +202,29 @@ get_std_handle :: proc(h: int) -> Handle {
 
 
 
-last_write_time :: proc(fd: Handle) -> FileTime {
+last_write_time :: proc(fd: Handle) -> File_Time {
-	file_info: win32.ByHandleFileInformation;
+	file_info: win32.By_Handle_File_Information;
 	win32.get_file_information_by_handle(win32.Handle(fd), &file_info);
-	lo := FileTime(file_info.last_write_time.lo);
+	lo := File_Time(file_info.last_write_time.lo);
-	hi := FileTime(file_info.last_write_time.hi);
+	hi := File_Time(file_info.last_write_time.hi);
 	return lo | hi << 32;
 }
 
-last_write_time_by_name :: proc(name: string) -> FileTime {
+last_write_time_by_name :: proc(name: string) -> File_Time {
 	last_write_time: win32.Filetime;
-	data: win32.FileAttributeData;
+	data: win32.File_Attribute_Data;
 	buf: [1024]u8;
 
 	assert(len(buf) > len(name));
 
-	copy(buf[..], []u8(name));
+	copy(buf[..], cast([]u8)name);
 
 	if win32.get_file_attributes_ex_a(&buf[0], win32.GetFileExInfoStandard, &data) != 0 {
 		last_write_time = data.last_write_time;
 	}
 
-	l := FileTime(last_write_time.lo);
+	l := File_Time(last_write_time.lo);
-	h := FileTime(last_write_time.hi);
+	h := File_Time(last_write_time.hi);
 	return l | h << 32;
 }
 
@@ -250,15 +238,12 @@ heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
 		heap_free(ptr);
 		return nil;
 	}
-	if ptr == nil {
+	if ptr == nil do return heap_alloc(new_size);
-		return heap_alloc(new_size);
+
-	}
 	return win32.heap_realloc(win32.get_process_heap(), win32.HEAP_ZERO_MEMORY, ptr, new_size);
 }
 heap_free :: proc(ptr: rawptr) {
-	if ptr == nil {
+	if ptr == nil do return;
-		return;
-	}
 	win32.heap_free(win32.get_process_heap(), 0, ptr);
 }
 
@@ -279,61 +264,50 @@ current_thread_id :: proc() -> int {
 _alloc_command_line_arguments :: proc() -> []string {
 	alloc_ucs2_to_utf8 :: proc(wstr: ^u16) -> string {
 		wstr_len := 0;
-		for (wstr+wstr_len)^ != 0 {
+		for (wstr+wstr_len)^ != 0 do wstr_len += 1;
-			wstr_len++;
+
-		}
 		len := 2*wstr_len-1;
 		buf := make([]u8, len+1);
-		str := slice_ptr(wstr, wstr_len+1);
+		str := mem.slice_ptr(wstr, wstr_len+1);
 
 		i, j := 0, 0;
 		for str[j] != 0 {
-			match {
+			switch {
 			case str[j] < 0x80:
-				if i+1 > len {
+				if i+1 > len do return "";
-					return "";
+				buf[i] = u8(str[j]); i += 1;
-				}
+				j += 1;
-				buf[i] = u8(str[j]); i++;
-				j++;
 			case str[j] < 0x800:
-				if i+2 > len {
+				if i+2 > len do return "";
-					return "";
+				buf[i] = u8(0xc0 + (str[j]>>6));   i += 1;
-				}
+				buf[i] = u8(0x80 + (str[j]&0x3f)); i += 1;
-				buf[i] = u8(0xc0 + (str[j]>>6));   i++;
+				j += 1;
-				buf[i] = u8(0x80 + (str[j]&0x3f)); i++;
-				j++;
 			case 0xd800 <= str[j] && str[j] < 0xdc00:
-				if i+4 > len {
+				if i+4 > len do return "";
-					return "";
+			c := rune((str[j] - 0xd800) << 10) + rune((str[j+1]) - 0xdc00) + 0x10000;
-				}
+				buf[i] = u8(0xf0 +  (c >> 18));         i += 1;
-				c := rune((str[j] - 0xd800) << 10) + rune((str[j+1]) - 0xdc00) + 0x10000;
+				buf[i] = u8(0x80 + ((c >> 12) & 0x3f)); i += 1;
-				buf[i] = u8(0xf0 +  (c >> 18));         i++;
+				buf[i] = u8(0x80 + ((c >>  6) & 0x3f)); i += 1;
-				buf[i] = u8(0x80 + ((c >> 12) & 0x3f)); i++;
+				buf[i] = u8(0x80 + ((c      ) & 0x3f)); i += 1;
-				buf[i] = u8(0x80 + ((c >>  6) & 0x3f)); i++;
-				buf[i] = u8(0x80 + ((c      ) & 0x3f)); i++;
 				j += 2;
 			case 0xdc00 <= str[j] && str[j] < 0xe000:
 				return "";
 			case:
-				if i+3 > len {
+				if i+3 > len do return "";
-					return "";
+				buf[i] = 0xe0 + u8 (str[j] >> 12);         i += 1;
-				}
+				buf[i] = 0x80 + u8((str[j] >>  6) & 0x3f); i += 1;
-				buf[i] = 0xe0 + u8 (str[j] >> 12);         i++;
+				buf[i] = 0x80 + u8((str[j]      ) & 0x3f); i += 1;
-				buf[i] = 0x80 + u8((str[j] >>  6) & 0x3f); i++;
+				j += 1;
-				buf[i] = 0x80 + u8((str[j]      ) & 0x3f); i++;
-				j++;
 			}
 		}
 
-		return string(buf[0..<i]);
+		return string(buf[..i]);
 	}
 
 	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);
+	arg_list := make([]string, int(arg_count));
-	for _, i in arg_list {
+	for _, i in arg_list do arg_list[i] = alloc_ucs2_to_utf8((arg_list_ptr+i)^);
-		arg_list[i] = alloc_ucs2_to_utf8((arg_list_ptr+i)^);
-	}
 	return arg_list;
 }
 

core/os_x.odin

@@ -1,19 +1,18 @@
-#import "fmt.odin";
+foreign import dl   "system:dl"
-#import "strings.odin";
+foreign import libc "system:c"
+
+import "core:strings.odin"
+import "core:mem.odin"
 
 Handle    :: i32;
-FileTime :: u64;
+File_Time :: u64;
 Errno     :: int;
 
-// TODO(zangent): Find out how to make this work on x64 and x32.
-AddressSize :: i64;
-
-// INVALID_HANDLE: Handle : -1;
 
 O_RDONLY   :: 0x00000;
 O_WRONLY   :: 0x00001;
 O_RDWR     :: 0x00002;
-O_CREAT    :: 0x00040;
+O_CREATE   :: 0x00040;
 O_EXCL     :: 0x00080;
 O_NOCTTY   :: 0x00100;
 O_TRUNC    :: 0x00200;
@@ -22,6 +21,8 @@ O_APPEND   :: 0x00400;
 O_SYNC     :: 0x01000;
 O_ASYNC    :: 0x02000;
 O_CLOEXEC  :: 0x80000;
+
+
 SEEK_SET   :: 0;
 SEEK_CUR   :: 1;
 SEEK_END   :: 2;
@@ -29,6 +30,8 @@ SEEK_DATA  :: 3;
 SEEK_HOLE  :: 4;
 SEEK_MAX   :: SEEK_HOLE;
 
+
+
 // NOTE(zangent): These are OS specific!
 // Do not mix these up!
 RTLD_LAZY     :: 0x1;
@@ -39,39 +42,40 @@ RTLD_NODELETE :: 0x80;
 RTLD_NOLOAD   :: 0x10;
 RTLD_FIRST    :: 0x100;
 
-args: [dynamic]string;
 
-_FileTime :: struct #ordered {
+// "Argv" arguments converted to Odin strings
+args := _alloc_command_line_arguments();
+
+_File_Time :: struct #ordered {
 	seconds: i64,
-	nanoseconds: i64
+	nanoseconds: i64,
 }
 
 Stat :: struct #ordered {
-	device_id : i32, // ID of device containing file
+	device_id:     i32, // ID of device containing file
-	mode      : u16, // Mode of the file
+	mode:          u16, // Mode of the file
-	nlink     : u16, // Number of hard links
+	nlink:         u16, // Number of hard links
-	serial    : u64, // File serial number
+	serial:        u64, // File serial number
-	uid       : u32, // User ID of the file's owner
+	uid:           u32, // User ID of the file's owner
-	gid       : u32, // Group ID of the file's group
+	gid:           u32, // Group ID of the file's group
-	rdev      : i32, // Device ID, if device
+	rdev:          i32, // Device ID, if device
 
-	last_access   : FileTime, // Time of last access
+	last_access:   File_Time, // Time of last access
-	modified      : FileTime, // Time of last modification
+	modified:      File_Time, // Time of last modification
-	status_change : FileTime, // Time of last status change
+	status_change: File_Time, // Time of last status change
-	created       : FileTime, // Time of creation
+	created:       File_Time, // Time of creation
 
-	size      : i64,  // Size of the file, in bytes
+	size:          i64,  // Size of the file, in bytes
-	blocks    : i64,  // Number of blocks allocated for the file
+	blocks:        i64,  // Number of blocks allocated for the file
-	block_size: i32,  // Optimal blocksize for I/O
+	block_size:    i32,  // Optimal blocksize for I/O
-	flags     : u32,  // User-defined flags for the file
+	flags:         u32,  // User-defined flags for the file
-	gen_num   : u32,  // File generation number ...?
+	gen_num:       u32,  // File generation number ...?
-	_spare    : i32,  // RESERVED
+	_spare:        i32,  // RESERVED
 	_reserve1,
-	_reserve2 : i64,  // RESERVED
+	_reserve2:     i64,  // RESERVED
 };
 
 // File type
-
 S_IFMT   :: 0170000; // Type of file mask
 S_IFIFO  :: 0010000; // Named pipe (fifo)
 S_IFCHR  :: 0020000; // Character special
@@ -83,21 +87,18 @@ 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
 
 // 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
@@ -107,49 +108,50 @@ S_ISUID :: 0004000; // Set user id on execution
 S_ISGID :: 0002000; // Set group id on execution
 S_ISVTX :: 0001000; // Directory restrcted delete
 
-S_ISLNK  :: proc(m: u32) -> bool #inline  {return ((m) & S_IFMT) == S_IFLNK; }
+S_ISLNK  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFLNK;
-S_ISREG  :: proc(m: u32) -> bool #inline  {return ((m) & S_IFMT) == S_IFREG; }
+S_ISREG  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFREG;
-S_ISDIR  :: proc(m: u32) -> bool #inline  {return ((m) & S_IFMT) == S_IFDIR; }
+S_ISDIR  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFDIR;
-S_ISCHR  :: proc(m: u32) -> bool #inline  {return ((m) & S_IFMT) == S_IFCHR; }
+S_ISCHR  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFCHR;
-S_ISBLK  :: proc(m: u32) -> bool #inline  {return ((m) & S_IFMT) == S_IFBLK; }
+S_ISBLK  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFBLK;
-S_ISFIFO :: proc(m: u32) -> bool #inline  {return ((m) & S_IFMT) == S_IFIFO; }
+S_ISFIFO :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFIFO;
-S_ISSOCK :: proc(m: u32) -> bool #inline  {return ((m) & S_IFMT) == S_IFSOCK;}
+S_ISSOCK :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFSOCK;
 
 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_system_library dl   "dl";
+foreign libc {
-#foreign_system_library libc "c";
+	@(link_name="open")    _unix_open    :: proc(path: ^u8, mode: int) -> Handle ---;
+	@(link_name="close")   _unix_close   :: proc(handle: Handle) ---;
+	@(link_name="read")    _unix_read    :: proc(handle: Handle, buffer: rawptr, count: int) -> int ---;
+	@(link_name="write")   _unix_write   :: proc(handle: Handle, buffer: rawptr, count: int) -> int ---;
+	@(link_name="lseek")   _unix_lseek   :: proc(fs: Handle, offset: int, whence: int) -> int ---;
+	@(link_name="gettid")  _unix_gettid  :: proc() -> u64 ---;
+	@(link_name="stat")    _unix_stat    :: proc(path: ^u8, stat: ^Stat) -> int ---;
+	@(link_name="access")  _unix_access  :: proc(path: ^u8, mask: int) -> int ---;
 
-unix_open   :: proc(path: ^u8, mode: int) -> Handle                               #foreign libc "open";
+	@(link_name="malloc")  _unix_malloc  :: proc(size: int) -> rawptr ---;
-unix_close  :: proc(handle: Handle)                                               #foreign libc "close";
+	@(link_name="calloc")  _unix_calloc  :: proc(num, size: int) -> rawptr ---;
-unix_read   :: proc(handle: Handle, buffer: rawptr, count: int) -> AddressSize    #foreign libc "read";
+	@(link_name="free")    _unix_free    :: proc(ptr: rawptr) ---;
-unix_write  :: proc(handle: Handle, buffer: rawptr, count: int) -> AddressSize    #foreign libc "write";
+	@(link_name="realloc") _unix_realloc :: proc(ptr: rawptr, size: int) -> rawptr ---;
-unix_lseek  :: proc(fs: Handle, offset: AddressSize, whence: int) -> AddressSize  #foreign libc "lseek";
+	@(link_name="getenv")  _unix_getenv  :: proc(^u8) -> ^u8 ---;
-unix_gettid :: proc() -> u64                                                      #foreign libc "gettid";
-unix_stat   :: proc(path: ^u8, stat: ^Stat) -> int                                #foreign libc "stat";
-unix_access :: proc(path: ^u8, mask: int) -> int                                  #foreign libc "access";
 
-unix_malloc  :: proc(size: int) -> rawptr                                         #foreign libc "malloc";
+	@(link_name="exit")    _unix_exit    :: proc(status: int) ---;
-unix_free    :: proc(ptr: rawptr)                                                 #foreign libc "free";
+}
-unix_realloc :: proc(ptr: rawptr, size: int) -> rawptr                            #foreign libc "realloc";
-unix_getenv  :: proc(^u8) -> ^u8                                                  #foreign libc "getenv";
-
-unix_exit :: proc(status: int)                                                    #foreign libc "exit";
-
-unix_dlopen  :: proc(filename: ^u8, flags: int) -> rawptr                         #foreign dl   "dlopen";
-unix_dlsym   :: proc(handle: rawptr, symbol: ^u8) ->  (proc() #cc_c)              #foreign dl   "dlsym";
-unix_dlclose :: proc(handle: rawptr) -> int                                       #foreign dl   "dlclose";
-unix_dlerror :: proc() -> ^u8                                                     #foreign dl   "dlerror";
 
+foreign dl {
+	@(link_name="dlopen")  _unix_dlopen  :: proc(filename: ^u8, flags: int) -> rawptr ---;
+	@(link_name="dlsym")   _unix_dlsym   :: proc(handle: rawptr, symbol: ^u8) -> rawptr ---;
+	@(link_name="dlclose") _unix_dlclose :: proc(handle: rawptr) -> int ---;
+	@(link_name="dlerror") _unix_dlerror :: proc() -> ^u8 ---;
+}
 
 // TODO(zangent): Change this to just `open` when Bill fixes overloading.
 open_simple :: proc(path: string, mode: int) -> (Handle, Errno) {
 
 	cstr := strings.new_c_string(path);
-	handle := unix_open(cstr, mode);
+	handle := _unix_open(cstr, mode);
 	free(cstr);
 	if(handle == -1) {
 		return 0, 1;
@@ -158,38 +160,38 @@ open_simple :: proc(path: string, mode: int) -> (Handle, Errno) {
 }
 
 // NOTE(zangent): This is here for compatability reasons. Should this be here?
-open :: proc(path: string, mode: int, perm: u32) -> (Handle, Errno) {
+open :: proc(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errno) {
 	return open_simple(path, mode);
 }
 
 close :: proc(fd: Handle) {
-	unix_close(fd);
+	_unix_close(fd);
 }
 
-write :: proc(fd: Handle, data: []u8) -> (AddressSize, Errno) {
+write :: proc(fd: Handle, data: []u8) -> (int, Errno) {
 	assert(fd != -1);
 
-	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;
 	}
 	return bytes_written, 0;
 }
 
-read :: proc(fd: Handle, data: []u8) -> (AddressSize, Errno) {
+read :: proc(fd: Handle, data: []u8) -> (int, Errno) {
 	assert(fd != -1);
 
-	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;
 	}
 	return bytes_read, 0;
 }
 
-seek :: proc(fd: Handle, offset: AddressSize, whence: int) -> (AddressSize, Errno) {
+seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
 	assert(fd != -1);
 
-	final_offset := unix_lseek(fd, offset, whence);
+	final_offset := i64(_unix_lseek(fd, int(offset), whence));
 	if(final_offset == -1) {
 		return 0, 1;
 	}
@@ -197,10 +199,10 @@ seek :: proc(fd: Handle, offset: AddressSize, whence: int) -> (AddressSize, Errn
 }
 
 file_size :: proc(fd: Handle) -> (i64, Errno) {
-	prev, _ := seek(fd, 0, SEEK_CUR);
+	prev, _   := seek(fd, 0, SEEK_CUR);
 	size, err := seek(fd, 0, SEEK_END);
 	seek(fd, prev, SEEK_SET);
-	return size, err;
+	return i64(size), err;
 }
 
 
@@ -211,76 +213,38 @@ stdout: Handle = 1; // get_std_handle(win32.STD_OUTPUT_HANDLE);
 stderr: Handle = 2; // get_std_handle(win32.STD_ERROR_HANDLE);
 
 /* TODO(zangent): Implement these!
-last_write_time :: proc(fd: Handle) -> FileTime {}
+last_write_time :: proc(fd: Handle) -> File_Time {}
-last_write_time_by_name :: proc(name: string) -> FileTime {}
+last_write_time_by_name :: proc(name: string) -> File_Time {}
 */
 
-stat :: proc(path: string) -> (Stat, bool) #inline {
+stat :: inline proc(path: string) -> (Stat, bool) {
 	s: Stat;
 	cstr := strings.new_c_string(path);
 	defer free(cstr);
-	ret_int := unix_stat(cstr, &s);
+	ret_int := _unix_stat(cstr, &s);
 	return s, ret_int==0;
 }
 
-access :: proc(path: string, mask: int) -> bool #inline {
+access :: inline proc(path: string, mask: int) -> bool {
 	cstr := strings.new_c_string(path);
 	defer free(cstr);
-	return unix_access(cstr, mask) == 0;
+	return _unix_access(cstr, mask) == 0;
 }
 
-// read_entire_file :: proc(name: string) -> ([]u8, bool) {
+heap_alloc :: inline proc(size: int) -> rawptr {
-
-// 	handle, err := open_simple(name, O_RDONLY);
-// 	if(err != 0) {
-// 		fmt.println("Failed to open file.");
-// 		return nil, false;
-// 	}
-// 	defer(close(handle));
-
-// 	// We have a file!
-
-// 	size: AddressSize;
-// 	size, err = seek(handle, 0, SEEK_END);
-// 	if(err != 0) {
-// 		fmt.println("Failed to seek to end of file.");
-// 		return nil, false;
-// 	}
-
-// 	_, err = seek(handle, 0, SEEK_SET);
-// 	if(err != 0) {
-// 		fmt.println("Failed to seek to beginning of file.");
-// 		return nil, false;
-// 	}
-
-// 	// We have a file size!
-
-// 	data := make([]u8, size+1);
-// 	if data == nil {
-// 		fmt.println("Failed to allocate file buffer.");
-// 		return nil, false;
-// 	}
-
-// 	read(handle, data);
-// 	data[size] = 0;
-
-// 	return data, true;
-// }
-
-heap_alloc :: proc(size: int) -> rawptr #inline {
 	assert(size > 0);
-	return unix_malloc(size);
+	return _unix_calloc(1, size);
 }
-heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr #inline {
+heap_resize :: inline proc(ptr: rawptr, new_size: int) -> rawptr {
-	return unix_realloc(ptr, new_size);
+	return _unix_realloc(ptr, new_size);
 }
-heap_free :: proc(ptr: rawptr) #inline {
+heap_free :: inline proc(ptr: rawptr) {
-	unix_free(ptr);
+	_unix_free(ptr);
 }
 
 getenv :: proc(name: string) -> (string, bool) {
 	path_str := strings.new_c_string(name);
-	cstr: ^u8 = unix_getenv(path_str);
+	cstr: ^u8 = _unix_getenv(path_str);
 	free(path_str);
 	if(cstr == nil) {
 		return "", false;
@@ -288,33 +252,42 @@ getenv :: proc(name: string) -> (string, bool) {
 	return strings.to_odin_string(cstr), true;
 }
 
-exit :: proc(code: int) #inline {
+exit :: inline proc(code: int) {
-	unix_exit(code);
+	_unix_exit(code);
 }
 
 
 current_thread_id :: proc() -> int {
-	// return cast(int) unix_gettid();
+	// return cast(int) _unix_gettid();
 	return 0;
 }
 
-dlopen :: proc(filename: string, flags: int) -> rawptr #inline {
+dlopen :: inline proc(filename: string, flags: int) -> rawptr {
 	cstr := strings.new_c_string(filename);
-	handle := unix_dlopen(cstr, flags);
+	handle := _unix_dlopen(cstr, flags);
 	free(cstr);
 	return handle;
 }
-dlsym :: proc(handle: rawptr, symbol: string) -> (proc() #cc_c) #inline {
+dlsym :: inline proc(handle: rawptr, symbol: string) -> rawptr {
 	assert(handle != nil);
 	cstr := strings.new_c_string(symbol);
-	proc_handle := unix_dlsym(handle, cstr);
+	proc_handle := _unix_dlsym(handle, cstr);
 	free(cstr);
 	return proc_handle;
 }
-dlclose :: proc(handle: rawptr) -> bool #inline {
+dlclose :: inline proc(handle: rawptr) -> bool {
 	assert(handle != nil);
-	return unix_dlclose(handle) == 0;
+	return _unix_dlclose(handle) == 0;
 }
 dlerror :: proc() -> string {
-	return strings.to_odin_string(unix_dlerror());
+	return strings.to_odin_string(_unix_dlerror());
+}
+
+
+_alloc_command_line_arguments :: proc() -> []string {
+	args := make([]string, __argc__);
+	for i in 0..__argc__ {
+		args[i] = strings.to_odin_string((__argv__+i)^);
+	}
+	return args;
 }

core/raw.odin

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

core/sort.odin

@@ -0,0 +1,213 @@
+bubble_sort :: proc(array: $A/[]$T, f: proc(T, T) -> int) {
+	assert(f != nil);
+	count := len(array);
+
+	init_j, last_j := 0, count-1;
+
+	for {
+		init_swap, prev_swap := -1, -1;
+
+		for j in init_j..last_j {
+			if f(array[j], array[j+1]) > 0 {
+				array[j], array[j+1] = array[j+1], array[j];
+				prev_swap = j;
+				if init_swap == -1 do init_swap = j;
+			}
+		}
+
+		if prev_swap == -1 do return;
+
+		init_j = max(init_swap-1, 0);
+		last_j = prev_swap;
+	}
+}
+
+bubble_sort :: proc(array: $A/[]$T) {
+	count := len(array);
+
+	init_j, last_j := 0, count-1;
+
+	for {
+		init_swap, prev_swap := -1, -1;
+
+		for j in init_j..last_j {
+			if array[j] > array[j+1] {
+				array[j], array[j+1] = array[j+1], array[j];
+				prev_swap = j;
+				if init_swap == -1 do init_swap = j;
+			}
+		}
+
+		if prev_swap == -1 do return;
+
+		init_j = max(init_swap-1, 0);
+		last_j = prev_swap;
+	}
+}
+
+quick_sort :: proc(array: $A/[]$T, f: proc(T, T) -> int) {
+	assert(f != nil);
+	a := array;
+	n := len(a);
+	if n < 2 do return;
+
+	p := a[n/2];
+	i, j := 0, n-1;
+
+	loop: for {
+		for f(a[i], p) < 0 do i += 1;
+		for f(p, a[j]) < 0 do j -= 1;
+
+		if i >= j do break loop;
+
+		a[i], a[j] = a[j], a[i];
+		i += 1;
+		j -= 1;
+	}
+
+	quick_sort(a[0..i], f);
+	quick_sort(a[i..n], f);
+}
+
+quick_sort :: proc(array: $A/[]$T) {
+	a := array;
+	n := len(a);
+	if n < 2 do return;
+
+	p := a[n/2];
+	i, j := 0, n-1;
+
+	loop: for {
+		for a[i] < p do i += 1;
+		for p < a[j] do j -= 1;
+
+		if i >= j do break loop;
+
+		a[i], a[j] = a[j], a[i];
+		i += 1;
+		j -= 1;
+	}
+
+	quick_sort(a[0..i]);
+	quick_sort(a[i..n]);
+}
+
+_log2 :: proc(n: int) -> int {
+	res := 0;
+	for ; n != 0; n >>= 1 do res += 1;
+	return res;
+}
+
+merge_sort :: proc(array: $A/[]$T, f: proc(T, T) -> int) {
+	merge_slices :: proc(arr1, arr2, out: A, f: proc(T, T) -> int) {
+		N1, N2 := len(arr1), len(arr2);
+		i, j := 0, 0;
+		for k in 0..N1+N2 {
+			if j == N2 || i < N1 && j < N2 && f(arr1[i], arr2[j]) < 0 {
+				out[k] = arr1[i];
+				i += 1;
+			} else {
+				out[k] = arr2[j];
+				j += 1;
+			}
+		}
+	}
+
+	assert(f != nil);
+
+	arr1 := array;
+	N := len(arr1);
+	arr2 := make([]T, N);
+	defer free(arr2);
+
+	a, b, m, M := N/2, N, 1, _log2(N);
+
+	for i in 0..M+1 {
+		for j in 0..a {
+			k := 2*j*m;
+			merge_slices(arr1[k..k+m], arr1[k+m..k+m+m], arr2[k..], f);
+		}
+		if N-b > m {
+			k := 2*a*m;
+			merge_slices(arr1[k..k+m], arr1[k+m..k+m+(N-b)&(m-1)], arr2[k..], f);
+		} else {
+			copy(arr2[b..N], arr1[b..N]);
+		}
+		arr1, arr2 = arr2, arr1;
+		m <<= 1;
+		a >>= 1;
+		b = a << uint(i) << 2;
+	}
+
+	if M & 1 == 0 do copy(arr2, arr1);
+}
+
+merge_sort :: proc(array: $A/[]$T) {
+	merge_slices :: proc(arr1, arr2, out: A) {
+		N1, N2 := len(arr1), len(arr2);
+		i, j := 0, 0;
+		for k in 0..N1+N2 {
+			if j == N2 || i < N1 && j < N2 && arr1[i] < arr2[j] {
+				out[k] = arr1[i];
+				i += 1;
+			} else {
+				out[k] = arr2[j];
+				j += 1;
+			}
+		}
+	}
+
+	arr1 := array;
+	N := len(arr1);
+	arr2 := make([]T, N);
+	defer free(arr2);
+
+	a, b, m, M := N/2, N, 1, _log2(N);
+
+	for i in 0..M+1 {
+		for j in 0..a {
+			k := 2*j*m;
+			merge_slices(arr1[k..k+m], arr1[k+m..k+m+m], arr2[k..]);
+		}
+		if N-b > m {
+			k := 2*a*m;
+			merge_slices(arr1[k..k+m], arr1[k+m..k+m+(N-b)&(m-1)], arr2[k..]);
+		} else {
+			copy(arr2[b..N], arr1[b..N]);
+		}
+		arr1, arr2 = arr2, arr1;
+		m <<= 1;
+		a >>= 1;
+		b = a << uint(i) << 2;
+	}
+
+	if M & 1 == 0 do copy(arr2, arr1);
+}
+
+
+
+compare_ints :: proc(a, b: int) -> int {
+	switch delta := a - b; {
+	case delta < 0: return -1;
+	case delta > 0: return +1;
+	}
+	return 0;
+}
+
+compare_f32s :: proc(a, b: f32) -> int {
+	switch delta := a - b; {
+	case delta < 0: return -1;
+	case delta > 0: return +1;
+	}
+	return 0;
+}
+compare_f64s :: proc(a, b: f64) -> int {
+	switch delta := a - b; {
+	case delta < 0: return -1;
+	case delta > 0: return +1;
+	}
+	return 0;
+}
+compare_strings :: proc(a, b: string) -> int {
+	return __string_cmp(a, b);
+}

core/strconv.odin

@@ -1,29 +1,29 @@
-#import . "decimal.odin";
+using import "core:decimal.odin"
 
-IntFlag :: enum {
+Int_Flag :: enum {
 	Prefix = 1<<0,
 	Plus   = 1<<1,
 	Space  = 1<<2,
 }
 
 
-parse_bool :: proc(s: string) -> (result: bool, ok: bool) {
+parse_bool :: proc(s: string) -> (result: bool = false, ok: bool) {
-	match s {
+	switch s {
 	case "1", "t", "T", "true", "TRUE", "True":
 		return true, true;
 	case "0", "f", "F", "false", "FALSE", "False":
 		return false, true;
 	}
-	return false, false;
+	return ok = false;
 }
 
-_digit_value :: proc(r: rune) -> (int) {
+_digit_value :: proc(r: rune) -> int {
 	ri := int(r);
 	v: int = 16;
-	match r {
+	switch r {
-	case '0'..'9': v = ri-'0';
+	case '0'...'9': v = ri-'0';
-	case 'a'..'z': v = ri-'a'+10;
+	case 'a'...'z': v = ri-'a'+10;
-	case 'A'..'Z': v = ri-'A'+10;
+	case 'A'...'Z': v = ri-'A'+10;
 	}
 	return v;
 }
@@ -31,7 +31,7 @@ _digit_value :: proc(r: rune) -> (int) {
 parse_i128 :: proc(s: string) -> i128 {
 	neg := false;
 	if len(s) > 1 {
-		match s[0] {
+		switch s[0] {
 		case '-':
 			neg = true;
 			s = s[1..];
@@ -43,7 +43,7 @@ parse_i128 :: proc(s: string) -> i128 {
 
 	base: i128 = 10;
 	if len(s) > 2 && s[0] == '0' {
-		match s[1] {
+		switch s[1] {
 		case 'b': base =  2;  s = s[2..];
 		case 'o': base =  8;  s = s[2..];
 		case 'd': base = 10;  s = s[2..];
@@ -67,7 +67,8 @@ parse_i128 :: proc(s: string) -> i128 {
 		value += v;
 	}
 
-	return neg ? -value : value;
+	if neg do return -value;
+	return value;
 }
 
 parse_u128 :: proc(s: string) -> u128 {
@@ -77,9 +78,9 @@ parse_u128 :: proc(s: string) -> u128 {
 	}
 
 
-	base: = u128(10);
+	base := u128(10);
 	if len(s) > 2 && s[0] == '0' {
-		match s[1] {
+		switch s[1] {
 		case 'b': base =  2;  s = s[2..];
 		case 'o': base =  8;  s = s[2..];
 		case 'd': base = 10;  s = s[2..];
@@ -91,19 +92,15 @@ parse_u128 :: proc(s: string) -> u128 {
 
 	value: u128;
 	for r in s {
-		if r == '_' {
+		if r == '_' do continue;
-			continue;
-		}
-
 		v := u128(_digit_value(r));
-		if v >= base {
+		if v >= base do break;
-			break;
-		}
 		value *= base;
 		value += u128(v);
 	}
 
-	return neg ? -value : value;
+	if neg do return -value;
+	return value;
 }
 
 
@@ -118,38 +115,32 @@ parse_f64 :: proc(s: string) -> f64 {
 	i := 0;
 
 	sign: f64 = 1;
-	match s[i] {
+	switch s[i] {
-	case '-': i++; sign = -1;
+	case '-': i += 1; sign = -1;
-	case '+': i++;
+	case '+': i += 1;
 	}
 
 	value: f64 = 0;
-	for ; i < len(s); i++ {
+	for ; i < len(s); i += 1 {
 		r := rune(s[i]);
-		if r == '_' {
+		if r == '_' do continue;
-			continue;
+
-		}
 		v := _digit_value(r);
-		if v >= 10 {
+		if v >= 10 do break;
-			break;
-		}
 		value *= 10;
 		value += f64(v);
 	}
 
-	if s[i] == '.' {
+	if i < len(s) && s[i] == '.' {
 		pow10: f64 = 10;
-		i++;
+		i += 1;
 
-		for ; i < len(s); i++ {
+		for ; i < len(s); i += 1 {
 			r := rune(s[i]);
-			if r == '_' {
+			if r == '_' do continue;
-				continue;
+
-			}
 			v := _digit_value(r);
-			if v >= 10 {
+			if v >= 10 do break;
-				break;
-			}
 			value += f64(v)/pow10;
 			pow10 *= 10;
 		}
@@ -158,40 +149,40 @@ parse_f64 :: proc(s: string) -> f64 {
 	frac := false;
 	scale: f64 = 1;
 
-	if s[i] == 'e' || s[i] == 'E' {
+	if i < len(s) && (s[i] == 'e' || s[i] == 'E') {
-		i++;
+		i += 1;
 
-		match s[i] {
+		if i < len(s) {
-		case '-': i++; frac = true;
+			switch s[i] {
-		case '+': i++;
+			case '-': i += 1; frac = true;
-		}
+			case '+': i += 1;
-
-		exp: u32 = 0;
-		for ; i < len(s); i++ {
-			r := rune(s[i]);
-			if r == '_' {
-				continue;
 			}
-			d := u32(_digit_value(r));
-			if d >= 10 {
-				break;
-			}
-			exp = exp * 10 + d;
-		}
-		if exp > 308 { exp = 308; }
 
-		for exp >= 50 { scale *= 1e50; exp -= 50; }
+			exp: u32 = 0;
-		for exp >=  8 { scale *=  1e8; exp -=  8; }
+			for ; i < len(s); i += 1 {
-		for exp >   0 { scale *=   10; exp -=  1; }
+				r := rune(s[i]);
+				if r == '_' do continue;
+
+				d := u32(_digit_value(r));
+				if d >= 10 do break;
+				exp = exp * 10 + d;
+			}
+			if exp > 308 { exp = 308; }
+
+			for exp >= 50 { scale *= 1e50; exp -= 50; }
+			for exp >=  8 { scale *=  1e8; exp -=  8; }
+			for exp >   0 { scale *=   10; exp -=  1; }
+		}
 	}
 
-	return sign * (frac ? (value/scale) : (value*scale));
+	if frac do return sign * (value/scale);
+	return sign * (value*scale);
 }
 
 
 append_bool :: proc(buf: []u8, b: bool) -> string {
-	s := b ? "true" : "false";
+	if b do append(&buf, "true");
-	append(buf, ..[]u8(s));
+	else do append(&buf, "false");
 	return string(buf);
 }
 
@@ -201,7 +192,7 @@ append_uint :: proc(buf: []u8, u: u64, base: int) -> string {
 append_int :: proc(buf: []u8, i: i64, base: int) -> string {
 	return append_bits(buf, u128(i), base, true, 8*size_of(int), digits, 0);
 }
-itoa :: proc(buf: []u8, i: int) -> string { return append_int(buf, i64(i), 10); }
+itoa :: proc(buf: []u8, i: int) -> string do return append_int(buf, i64(i), 10);
 
 append_float :: proc(buf: []u8, f: f64, fmt: u8, prec, bit_size: int) -> string {
 	return string(generic_ftoa(buf, f, fmt, prec, bit_size));
@@ -217,36 +208,37 @@ DecimalSlice :: struct {
 	neg:           bool,
 }
 
-Float_Info :: struct {
+FloatInfo :: struct {
 	mantbits: uint,
 	expbits:  uint,
 	bias:     int,
 }
 
-_f16_info := Float_Info{10, 5,   -15};
+
-_f32_info := Float_Info{23, 8,  -127};
+_f16_info := FloatInfo{10, 5,   -15};
-_f64_info := Float_Info{52, 11, -1023};
+_f32_info := FloatInfo{23, 8,  -127};
+_f64_info := FloatInfo{52, 11, -1023};
 
 
 generic_ftoa :: proc(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8 {
 	bits: u64;
-	flt: ^Float_Info;
+	flt: ^FloatInfo;
-	match bit_size {
+	switch bit_size {
 	case 32:
-		bits = u64(transmute(u32, f32(val)));
+		bits = u64(transmute(u32)f32(val));
 		flt = &_f32_info;
 	case 64:
-		bits = transmute(u64, val);
+		bits = transmute(u64)val;
 		flt = &_f64_info;
 	case:
 		panic("strconv: invalid bit_size");
 	}
 
-	neg := bits>>(flt.expbits+flt.mantbits) != 0;
+	neg  := bits>>(flt.expbits+flt.mantbits) != 0;
-	exp := int(bits>>flt.mantbits) & (1<<flt.expbits - 1);
+	exp  := int(bits>>flt.mantbits) & (1<<flt.expbits - 1);
 	mant := bits & (u64(1) << flt.mantbits - 1);
 
-	match exp {
+	switch exp {
 	case 1<<flt.expbits - 1:
 		s: string;
 		if mant != 0 {
@@ -256,11 +248,11 @@ generic_ftoa :: proc(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8
 		} else {
 			s = "+Inf";
 		}
-		append(buf, ..[]u8(s));
+		append(&buf, ...cast([]u8)s);
 		return buf;
 
 	case 0: // denormalized
-		exp++;
+		exp += 1;
 
 	case:
 		mant |= u64(1) << flt.mantbits;
@@ -277,13 +269,13 @@ generic_ftoa :: proc(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8
 	if shortest {
 		round_shortest(d, mant, exp, flt);
 		digs = DecimalSlice{digits = d.digits[..], count = d.count, decimal_point = d.decimal_point};
-		match fmt {
+		switch fmt {
 		case 'e', 'E': prec = digs.count-1;
 		case 'f', 'F': prec = max(digs.count-digs.decimal_point, 0);
 		case 'g', 'G': prec = digs.count;
 		}
 	} else {
-		match fmt {
+		switch fmt {
 		case 'e', 'E': round(d, prec+1);
 		case 'f', 'F': round(d, d.decimal_point+prec);
 		case 'g', 'G':
@@ -301,34 +293,33 @@ generic_ftoa :: proc(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8
 
 
 format_digits :: proc(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice, prec: int, fmt: u8) -> []u8 {
-	match fmt {
+	switch fmt {
 	case 'f', 'F':
-		append(buf, neg ? '-' : '+');
+		append(&buf, neg ? '-' : '+');
 
 		// integer, padded with zeros when needed
 		if digs.decimal_point > 0 {
 			m := min(digs.count, digs.decimal_point);
-			append(buf, ..digs.digits[0..<m]);
+			append(&buf, ...digs.digits[0..m]);
-			for ; m < digs.decimal_point; m++ {
+			for ; m < digs.decimal_point; m += 1 {
-				append(buf, '0');
+				append(&buf, '0');
 			}
 		} else {
-			append(buf, '0');
+			append(&buf, '0');
 		}
 
 
 		// fractional part
 		if prec > 0 {
-			append(buf, '.');
+			append(&buf, '.');
-			for i in 0..<prec {
+			for i in 0..prec {
 				c: u8 = '0';
 				if j := digs.decimal_point + i; 0 <= j && j < digs.count {
 					c = digs.digits[j];
 				}
-				append(buf, c);
+				append(&buf, c);
 			}
 		}
-
 		return buf;
 
 	case 'e', 'E':
@@ -340,14 +331,12 @@ format_digits :: proc(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice,
 		return buf; // TODO
 	}
 
-	c: [2]u8;
+	c := [2]u8{'%', fmt};
-	c[0] = '%';
+	append(&buf, ...c[..]);
-	c[1] = fmt;
-	append(buf, ..c[..]);
 	return buf;
 }
 
-round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
+round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^FloatInfo) {
 	if mant == 0 { // If mantissa is zero, the number is zero
 		d.count = 0;
 		return;
@@ -365,7 +354,7 @@ round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
 		return;
 	}
 
-	upper_: Decimal; upper: = &upper_;
+	upper_: Decimal; upper := &upper_;
 	assign(upper, 2*mant - 1);
 	shift(upper, exp - int(flt.mantbits) - 1);
 
@@ -378,13 +367,13 @@ round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
 		mantlo = 2*mant - 1;
 		explo = exp-1;
 	}
-	lower_: Decimal; lower: = &lower_;
+	lower_: Decimal; lower := &lower_;
 	assign(lower, 2*mantlo + 1);
 	shift(lower, explo - int(flt.mantbits) - 1);
 
 	inclusive := mant%2 == 0;
 
-	for i in 0..<d.count {
+	for i in 0..d.count {
 		l: u8 = '0'; // lower digit
 		if i < lower.count {
 			l = lower.digits[i];
@@ -398,15 +387,15 @@ round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
 		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) {
+		if ok_round_down && ok_round_up {
 			round(d, i+1);
 			return;
 		}
-		if (ok_round_down) {
+		if ok_round_down {
 			round_down(d, i+1);
 			return;
 		}
-		if (ok_round_up) {
+		if ok_round_up {
 			round_up(d, i+1);
 			return;
 		}
@@ -415,38 +404,33 @@ round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
 }
 
 MAX_BASE :: 32;
-immutable digits := "0123456789abcdefghijklmnopqrstuvwxyz";
+digits := "0123456789abcdefghijklmnopqrstuvwxyz";
 
 
 is_integer_negative :: proc(u: u128, is_signed: bool, bit_size: int) -> (unsigned: u128, neg: bool) {
 	neg := false;
 	if is_signed {
-		match bit_size {
+		switch bit_size {
 		case 8:
 			i := i8(u);
 			neg = i < 0;
-			if neg { i = -i; }
+			u = u128(abs(i));
-			u = u128(i);
 		case 16:
 			i := i16(u);
 			neg = i < 0;
-			if neg { i = -i; }
+			u = u128(abs(i));
-			u = u128(i);
 		case 32:
 			i := i32(u);
 			neg = i < 0;
-			if neg { i = -i; }
+			u = u128(abs(i));
-			u = u128(i);
 		case 64:
 			i := i64(u);
 			neg = i < 0;
-			if neg { i = -i; }
+			u = u128(abs(i));
-			u = u128(i);
 		case 128:
 			i := i128(u);
 			neg = i < 0;
-			if neg { i = -i; }
+			u = u128(abs(i));
-			u = u128(i);
 		case:
 			panic("is_integer_negative: Unknown integer size");
 		}
@@ -454,45 +438,46 @@ is_integer_negative :: proc(u: u128, is_signed: bool, bit_size: int) -> (unsigne
 	return u, neg;
 }
 
-append_bits :: proc(buf: []u8, u_: u128, base: int, is_signed: bool, bit_size: int, digits: string, flags: IntFlag) -> string {
+append_bits :: proc(buf: []u8, u: u128, base: int, is_signed: bool, bit_size: int, digits: string, flags: Int_Flag) -> string {
 	if base < 2 || base > MAX_BASE {
 		panic("strconv: illegal base passed to append_bits");
 	}
 
+	neg: bool;
 	a: [129]u8;
 	i := len(a);
-	u, neg := is_integer_negative(u_, is_signed, bit_size);
+	u, neg = is_integer_negative(u, is_signed, bit_size);
 	b := u128(base);
 	for u >= b {
-		i--; a[i] = digits[uint(u % b)];
+		i-=1; a[i] = digits[uint(u % b)];
 		u /= b;
 	}
-	i--; a[i] = digits[uint(u % b)];
+	i-=1; a[i] = digits[uint(u % b)];
 
-	if flags&IntFlag.Prefix != 0 {
+	if flags&Int_Flag.Prefix != 0 {
 		ok := true;
-		match base {
+		switch base {
-		case  2: i--; a[i] = 'b';
+		case  2: i-=1; a[i] = 'b';
-		case  8: i--; a[i] = 'o';
+		case  8: i-=1; a[i] = 'o';
-		case 10: i--; a[i] = 'd';
+		case 10: i-=1; a[i] = 'd';
-		case 12: i--; a[i] = 'z';
+		case 12: i-=1; a[i] = 'z';
-		case 16: i--; a[i] = 'x';
+		case 16: i-=1; a[i] = 'x';
 		case: ok = false;
 		}
 		if ok {
-			i--; a[i] = '0';
+			i-=1; a[i] = '0';
 		}
 	}
 
 	if neg {
-		i--; a[i] = '-';
+		i-=1; a[i] = '-';
-	} else if flags&IntFlag.Plus != 0 {
+	} else if flags&Int_Flag.Plus != 0 {
-		i--; a[i] = '+';
+		i-=1; a[i] = '+';
-	} else if flags&IntFlag.Space != 0 {
+	} else if flags&Int_Flag.Space != 0 {
-		i--; a[i] = ' ';
+		i-=1; a[i] = ' ';
 	}
 
-	append(buf, ..a[i..]);
+	append(&buf, ...a[i..]);
 	return string(buf);
 }
 

core/strings.odin

@@ -1,14 +1,22 @@
+import "core:mem.odin"
+
+new_string :: proc(s: string) -> string {
+	c := make([]u8, len(s)+1);
+	copy(c, cast([]u8)s);
+	c[len(s)] = 0;
+	return string(c[..len(s)]);
+}
+
 new_c_string :: proc(s: string) -> ^u8 {
 	c := make([]u8, len(s)+1);
-	copy(c, []u8(s));
+	copy(c, cast([]u8)s);
 	c[len(s)] = 0;
 	return &c[0];
 }
 
-to_odin_string :: proc(c: ^u8) -> string {
+to_odin_string :: proc(str: ^u8) -> string {
-	len := 0;
+	if str == nil do return "";
-	for (c+len)^ != 0 {
+	end := str;
-		len++;
+	for end^ != 0 do end+=1;
-	}
+	return string(mem.slice_ptr(str, end-str));
-	return string(slice_ptr(c, len));
 }

core/sync.odin

@@ -1,2 +1,2 @@
-#load "sync_windows.odin" when ODIN_OS == "windows";
+when ODIN_OS == "windows" do export "core:sync_windows.odin";
-#load "sync_linux.odin" when ODIN_OS == "linux";
+when ODIN_OS == "linux"   do export "core:sync_linux.odin";

core/sync_linux.odin

@@ -1,5 +1,5 @@
-#import "atomics.odin";
+import "core:atomics.odin"
-#import "os.odin";
+import "core:os.odin"
 
 Semaphore :: struct {
 	// _handle: win32.Handle,
@@ -28,7 +28,7 @@ semaphore_post :: proc(s: ^Semaphore, count: int) {
 	// win32.ReleaseSemaphore(s._handle, cast(i32)count, nil);
 }
 
-semaphore_release :: proc(s: ^Semaphore) #inline {
+semaphore_release :: inline proc(s: ^Semaphore) {
 	semaphore_post(s, 1);
 }
 
@@ -54,7 +54,7 @@ mutex_lock :: proc(m: ^Mutex) {
 		}
 	}
 	atomics.store(&m._owner, thread_id);
-	m._recursion++;
+	m._recursion += 1;
 }
 mutex_try_lock :: proc(m: ^Mutex) -> bool {
 	thread_id := current_thread_id();
@@ -70,7 +70,7 @@ mutex_try_lock :: proc(m: ^Mutex) -> bool {
 		}
 		atomics.store(&m._owner, thread_id);
 	}
-	m._recursion++;
+	m._recursion += 1;
 	return true;
 }
 mutex_unlock :: proc(m: ^Mutex) {
@@ -78,7 +78,7 @@ mutex_unlock :: proc(m: ^Mutex) {
 	thread_id := current_thread_id();
 	assert(thread_id == atomics.load(&m._owner));
 
-	m._recursion--;
+	m._recursion -= 1;
 	recursion = m._recursion;
 	if recursion == 0 {
 		atomics.store(&m._owner, thread_id);

core/sync_windows.odin

@@ -1,16 +1,24 @@
-#import win32 "sys/windows.odin" when ODIN_OS == "windows";
+when ODIN_OS == "windows" {
-#import "atomics.odin";
+	import win32 "core:sys/windows.odin";
+}
+import "core:atomics.odin"
 
 Semaphore :: struct {
 	_handle: win32.Handle,
 }
 
+/*
 Mutex :: struct {
 	_semaphore: Semaphore,
 	_counter:   i32,
 	_owner:     i32,
 	_recursion: i32,
 }
+*/
+
+Mutex :: struct {
+	_critical_section: win32.Critical_Section,
+}
 
 current_thread_id :: proc() -> i32 {
 	return i32(win32.get_current_thread_id());
@@ -28,13 +36,38 @@ semaphore_post :: proc(s: ^Semaphore, count: int) {
 	win32.release_semaphore(s._handle, i32(count), nil);
 }
 
-semaphore_release :: proc(s: ^Semaphore) #inline { semaphore_post(s, 1); }
+semaphore_release :: inline proc(s: ^Semaphore) {
+	semaphore_post(s, 1);
+}
 
 semaphore_wait :: proc(s: ^Semaphore) {
 	win32.wait_for_single_object(s._handle, win32.INFINITE);
 }
 
 
+mutex_init :: proc(m: ^Mutex, spin_count := 0) {
+	win32.initialize_critical_section_and_spin_count(&m._critical_section, u32(spin_count));
+}
+
+mutex_destroy :: proc(m: ^Mutex) {
+	win32.delete_critical_section(&m._critical_section);
+}
+
+mutex_lock :: proc(m: ^Mutex) {
+	win32.enter_critical_section(&m._critical_section);
+}
+
+mutex_try_lock :: proc(m: ^Mutex) -> bool {
+	return win32.try_enter_critical_section(&m._critical_section) != 0;
+}
+
+mutex_unlock :: proc(m: ^Mutex) {
+	win32.leave_critical_section(&m._critical_section);
+}
+
+
+
+/*
 mutex_init :: proc(m: ^Mutex) {
 	atomics.store(&m._counter, 0);
 	atomics.store(&m._owner, current_thread_id());
@@ -88,4 +121,4 @@ mutex_unlock :: proc(m: ^Mutex) {
 		}
 	}
 }
-
+*/

core/sys/wgl.odin

@@ -1,18 +1,21 @@
-#foreign_system_library "opengl32.lib" when ODIN_OS == "windows";
+when ODIN_OS == "windows" {
-#import . "windows.odin";
+	foreign import "system:opengl32.lib"
+	using import "core:sys/windows.odin"
+}
 
-CONTEXT_MAJOR_VERSION_ARB          :: 0x2091;
+
-CONTEXT_MINOR_VERSION_ARB          :: 0x2092;
+CONTEXT_MAJOR_VERSION_ARB             :: 0x2091;
-CONTEXT_FLAGS_ARB                  :: 0x2094;
+CONTEXT_MINOR_VERSION_ARB             :: 0x2092;
-CONTEXT_PROFILE_MASK_ARB           :: 0x9126;
+CONTEXT_FLAGS_ARB                     :: 0x2094;
-CONTEXT_FORWARD_COMPATIBLE_BIT_ARB :: 0x0002;
+CONTEXT_PROFILE_MASK_ARB              :: 0x9126;
-CONTEXT_CORE_PROFILE_BIT_ARB       :: 0x00000001;
+CONTEXT_FORWARD_COMPATIBLE_BIT_ARB    :: 0x0002;
+CONTEXT_CORE_PROFILE_BIT_ARB          :: 0x00000001;
 CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB :: 0x00000002;
 
-Hglrc :: Handle;
+Hglrc     :: Handle;
-ColorRef :: u32;
+Color_Ref :: u32;
 
-LayerPlaneDescriptor :: struct {
+Layer_Plane_Descriptor :: struct {
 	size:             u16,
 	version:          u16,
 	flags:            u32,
@@ -36,47 +39,77 @@ LayerPlaneDescriptor :: struct {
 	aux_buffers:      u8,
 	layer_type:       u8,
 	reserved:         u8,
-	transparent:      ColorRef,
+	transparent:      Color_Ref,
 }
 
-PointFloat :: struct {
+Point_Float :: struct {x, y: f32};
-	x, y: f32,
-}
 
-Glyph_MetricsFloat :: struct {
+Glyph_Metrics_Float :: struct {
 	black_box_x:  f32,
 	black_box_y:  f32,
-	glyph_origin: PointFloat,
+	glyph_origin: Point_Float,
 	cell_inc_x:   f32,
 	cell_inc_y:   f32,
 }
 
-CreateContextAttribsARBType :: #type proc(hdc: Hdc, h_share_context: rawptr, attribList: ^i32) -> Hglrc;
+Create_Context_Attribs_ARB_Type :: #type proc "c" (hdc: Hdc, h_share_context: rawptr, attribList: ^i32) -> Hglrc;
-ChoosePixelFormatARBType    :: #type proc(hdc: Hdc, attrib_i_list: ^i32, attrib_f_list: ^f32, max_formats: u32, formats: ^i32, num_formats : ^u32) -> Bool #cc_c;
+Choose_Pixel_Format_ARB_Type    :: #type proc "c" (hdc: Hdc, attrib_i_list: ^i32, attrib_f_list: ^f32, max_formats: u32, formats: ^i32, num_formats : ^u32) -> Bool;
-SwapIntervalEXTType         :: #type proc(interval: i32) -> bool #cc_c;
+Swap_Interval_EXT_Type          :: #type proc "c" (interval: i32) -> bool;
-GetExtensionsStringARBType  :: #type proc(Hdc) -> ^u8 #cc_c;
+Get_Extensions_String_ARB_Type  :: #type proc "c" (Hdc) -> ^u8;
+
+// Procedures
+	create_context_attribs_arb: Create_Context_Attribs_ARB_Type;
+	choose_pixel_format_arb:    Choose_Pixel_Format_ARB_Type;
+	swap_interval_ext:          Swap_Interval_EXT_Type;
+	get_extensions_string_arb:  Get_Extensions_String_ARB_Type;
 
 
-create_context_attribs_arb: CreateContextAttribsARBType;
+foreign opengl32 {
-choose_pixel_format_arb:    ChoosePixelFormatARBType;
+	@(link_name="wglCreateContext")
-swap_interval_ext:          SwapIntervalEXTType;
+	create_context :: proc(hdc: Hdc) -> Hglrc ---;
-get_extensions_string_arb:  GetExtensionsStringARBType;
 
+	@(link_name="wglMakeCurrent")
+	make_current :: proc(hdc: Hdc, hglrc: Hglrc) -> Bool ---;
 
+	@(link_name="wglGetProcAddress")
+	get_proc_address :: proc(c_str: ^u8) -> rawptr ---;
 
-create_context            :: proc(hdc: Hdc) -> Hglrc                                                                                                 #foreign opengl32 "wglCreateContext";
+	@(link_name="wglDeleteContext")
-make_current              :: proc(hdc: Hdc, hglrc: Hglrc) -> Bool                                                                                    #foreign opengl32 "wglMakeCurrent";
+	delete_context :: proc(hglrc: Hglrc) -> Bool ---;
-get_proc_address          :: proc(c_str: ^u8) -> Proc                                                                                                #foreign opengl32 "wglGetProcAddress";
+
-delete_context            :: proc(hglrc: Hglrc) -> Bool                                                                                              #foreign opengl32 "wglDeleteContext";
+	@(link_name="wglCopyContext")
-copy_context              :: proc(src, dst: Hglrc, mask: u32) -> Bool                                                                                #foreign opengl32 "wglCopyContext";
+	copy_context :: proc(src, dst: Hglrc, mask: u32) -> Bool ---;
-create_layer_context      :: proc(hdc: Hdc, layer_plane: i32) -> Hglrc                                                                               #foreign opengl32 "wglCreateLayerContext";
+
-describe_layer_plane      :: proc(hdc: Hdc, pixel_format, layer_plane: i32, bytes: u32, pd: ^LayerPlaneDescriptor) -> Bool                           #foreign opengl32 "wglDescribeLayerPlane";
+	@(link_name="wglCreateLayerContext")
-get_current_context       :: proc() -> Hglrc                                                                                                         #foreign opengl32 "wglGetCurrentContext";
+	create_layer_context :: proc(hdc: Hdc, layer_plane: i32) -> Hglrc ---;
-get_current_dc            :: proc() -> Hdc                                                                                                           #foreign opengl32 "wglGetCurrentDC";
+
-get_layer_palette_entries :: proc(hdc: Hdc, layer_plane, start, entries: i32, cr: ^ColorRef) -> i32                                                 #foreign opengl32 "wglGetLayerPaletteEntries";
+	@(link_name="wglDescribeLayerPlane")
-realize_layer_palette     :: proc(hdc: Hdc, layer_plane: i32, realize: Bool) -> Bool                                                                 #foreign opengl32 "wglRealizeLayerPalette";
+	describe_layer_plane :: proc(hdc: Hdc, pixel_format, layer_plane: i32, bytes: u32, pd: ^Layer_Plane_Descriptor) -> Bool ---;
-set_layer_palette_entries :: proc(hdc: Hdc, layer_plane, start, entries: i32, cr: ^ColorRef) -> i32                                                 #foreign opengl32 "wglSetLayerPaletteEntries";
+
-share_lists               :: proc(hglrc1, hglrc2: Hglrc) -> Bool                                                                                     #foreign opengl32 "wglShareLists";
+	@(link_name="wglGetCurrentContext")
-swap_layer_buffers        :: proc(hdc: Hdc, planes: u32) -> Bool                                                                                     #foreign opengl32 "wglSwapLayerBuffers";
+	get_current_context :: proc() -> Hglrc ---;
-use_font_bitmaps          :: proc(hdc: Hdc, first, count, list_base: u32) -> Bool                                                                    #foreign opengl32 "wglUseFontBitmaps";
+
-use_font_outlines         :: proc(hdc: Hdc, first, count, list_base: u32, deviation, extrusion: f32, format: i32, gmf: ^Glyph_MetricsFloat) -> Bool  #foreign opengl32 "wglUseFontOutlines";
+	@(link_name="wglGetCurrentDC")
+	get_current_dc :: proc() -> Hdc ---;
+
+	@(link_name="wglGetLayerPaletteEntries")
+	get_layer_palette_entries :: proc(hdc: Hdc, layer_plane, start, entries: i32, cr: ^Color_Ref) -> i32 ---;
+
+	@(link_name="wglRealizeLayerPalette")
+	realize_layer_palette :: proc(hdc: Hdc, layer_plane: i32, realize: Bool) -> Bool ---;
+
+	@(link_name="wglSetLayerPaletteEntries")
+	set_layer_palette_entries :: proc(hdc: Hdc, layer_plane, start, entries: i32, cr: ^Color_Ref) -> i32 ---;
+
+	@(link_name="wglShareLists")
+	share_lists :: proc(hglrc1, hglrc2: Hglrc) -> Bool ---;
+
+	@(link_name="wglSwapLayerBuffers")
+	swap_layer_buffers :: proc(hdc: Hdc, planes: u32) -> Bool ---;
+
+	@(link_name="wglUseFontBitmaps")
+	use_font_bitmaps :: proc(hdc: Hdc, first, count, list_base: u32) -> Bool ---;
+
+	@(link_name="wglUseFontOutlines")
+	use_font_outlines :: proc(hdc: Hdc, first, count, list_base: u32, deviation, extrusion: f32, format: i32, gmf: ^Glyph_Metrics_Float) -> Bool ---;
+}

core/thread.odin

@@ -0,0 +1,75 @@
+_ :: compile_assert(ODIN_OS == "windows");
+
+when ODIN_OS == "windows" {
+	import win32 "core:sys/windows.odin"
+}
+
+Thread_Proc :: #type proc(^Thread) -> int;
+
+Thread_Os_Specific :: struct {
+	win32_thread:    win32.Handle,
+	win32_thread_id: u32,
+}
+
+Thread :: struct {
+	using specific:   Thread_Os_Specific,
+	procedure:        Thread_Proc,
+	data:             any,
+	user_index:       int,
+
+	init_context:     Context,
+	use_init_context: bool,
+}
+
+
+create :: proc(procedure: Thread_Proc) -> ^Thread {
+	win32_thread_id: u32;
+
+	__windows_thread_entry_proc :: proc "c" (t: ^Thread) -> i32 {
+		c := context;
+		if t.use_init_context {
+			c = t.init_context;
+		}
+
+		exit := 0;
+		context <- c {
+			exit = t.procedure(t);
+		}
+
+		return i32(exit);
+	}
+
+
+	win32_thread_proc := rawptr(__windows_thread_entry_proc);
+	thread := new(Thread);
+
+	win32_thread := win32.create_thread(nil, 0, win32_thread_proc, thread, win32.CREATE_SUSPENDED, &win32_thread_id);
+	if win32_thread == nil {
+		free(thread);
+		return nil;
+	}
+	thread.procedure       = procedure;
+	thread.win32_thread    = win32_thread;
+	thread.win32_thread_id = win32_thread_id;
+
+	return thread;
+}
+
+start :: proc(using thread: ^Thread) {
+	win32.resume_thread(win32_thread);
+}
+
+is_done :: proc(using thread: ^Thread) -> bool {
+	res := win32.wait_for_single_object(win32_thread, 0);
+	return res != win32.WAIT_TIMEOUT;
+}
+
+join :: proc(using thread: ^Thread) {
+	win32.wait_for_single_object(win32_thread, win32.INFINITE);
+	win32.close_handle(win32_thread);
+	win32_thread = win32.INVALID_HANDLE;
+}
+destroy :: proc(thread: ^Thread) {
+	join(thread);
+	free(thread);
+}

core/types.odin

@@ -1,98 +1,263 @@
-is_signed :: proc(info: ^TypeInfo) -> bool {
+are_types_identical :: proc(a, b: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if a == b do return true;
-	match i in type_info_base(info) {
+
-	case TypeInfo.Integer: return i.signed;
+	if (a == nil && b != nil) ||
-	case TypeInfo.Float:   return true;
+	   (a != nil && b == nil) {
+		return false;
+	}
+
+
+	switch {
+	case a.size != b.size, a.align != b.align:
+		return false;
+	}
+
+	switch x in a.variant {
+	case Type_Info_Named:
+		y, ok := b.variant.(Type_Info_Named);
+		if !ok do return false;
+		return x.base == y.base;
+
+	case Type_Info_Integer:
+		y, ok := b.variant.(Type_Info_Integer);
+		if !ok do return false;
+		return x.signed == y.signed;
+
+	case Type_Info_Rune:
+		_, ok := b.variant.(Type_Info_Rune);
+		return ok;
+
+	case Type_Info_Float:
+		_, ok := b.variant.(Type_Info_Float);
+		return ok;
+
+	case Type_Info_Complex:
+		_, ok := b.variant.(Type_Info_Complex);
+		return ok;
+
+	case Type_Info_String:
+		_, ok := b.variant.(Type_Info_String);
+		return ok;
+
+	case Type_Info_Boolean:
+		_, ok := b.variant.(Type_Info_Boolean);
+		return ok;
+
+	case Type_Info_Any:
+		_, ok := b.variant.(Type_Info_Any);
+		return ok;
+
+	case Type_Info_Pointer:
+		y, ok := b.variant.(Type_Info_Pointer);
+		return are_types_identical(x.elem, y.elem);
+
+	case Type_Info_Procedure:
+		y, ok := b.variant.(Type_Info_Procedure);
+		if !ok do return false;
+		switch {
+		case x.variadic   != y.variadic,
+		     x.convention != y.convention:
+			return false;
+		}
+
+		return are_types_identical(x.params, y.params) && are_types_identical(x.results, y.results);
+
+	case Type_Info_Array:
+		y, ok := b.variant.(Type_Info_Array);
+		if !ok do return false;
+		if x.count != y.count do return false;
+		return are_types_identical(x.elem, y.elem);
+
+	case Type_Info_Dynamic_Array:
+		y, ok := b.variant.(Type_Info_Dynamic_Array);
+		if !ok do return false;
+		return are_types_identical(x.elem, y.elem);
+
+	case Type_Info_Slice:
+		y, ok := b.variant.(Type_Info_Slice);
+		if !ok do return false;
+		return are_types_identical(x.elem, y.elem);
+
+	case Type_Info_Vector:
+		y, ok := b.variant.(Type_Info_Vector);
+		if !ok do return false;
+		if x.count != y.count do return false;
+		return are_types_identical(x.elem, y.elem);
+
+	case Type_Info_Tuple:
+		y, ok := b.variant.(Type_Info_Tuple);
+		if !ok do return false;
+		if len(x.types) != len(y.types) do return false;
+		for _, i in x.types {
+			xt, yt := x.types[i], y.types[i];
+			if !are_types_identical(xt, yt) {
+				return false;
+			}
+		}
+		return true;
+
+	case Type_Info_Struct:
+		y, ok := b.variant.(Type_Info_Struct);
+		if !ok do return false;
+	   	switch {
+		case len(x.types)   != len(y.types),
+		     x.is_packed    != y.is_packed,
+		     x.is_ordered   != y.is_ordered,
+		     x.is_raw_union != y.is_raw_union,
+		     x.custom_align != y.custom_align:
+		     return false;
+		}
+		for _, i in x.types {
+			xn, yn := x.names[i], y.names[i];
+			xt, yt := x.types[i], y.types[i];
+
+			if xn != yn do return false;
+			if !are_types_identical(xt, yt) do return false;
+		}
+		return true;
+
+	case Type_Info_Union:
+		y, ok := b.variant.(Type_Info_Union);
+		if !ok do return false;
+		if len(x.variants) != len(y.variants) do return false;
+
+		for _, i in x.variants {
+			xv, yv := x.variants[i], y.variants[i];
+			if !are_types_identical(xv, yv) do return false;
+		}
+		return true;
+
+	case Type_Info_Enum:
+		// NOTE(bill): Should be handled above
+		return false;
+
+	case Type_Info_Map:
+		y, ok := b.variant.(Type_Info_Map);
+		if !ok do return false;
+		return are_types_identical(x.key, y.key) && are_types_identical(x.value, y.value);
+
+	case Type_Info_Bit_Field:
+		y, ok := b.variant.(Type_Info_Bit_Field);
+		if !ok do return false;
+		if len(x.names) != len(y.names) do return false;
+
+		for _, i in x.names {
+			xb, yb := x.bits[i], y.bits[i];
+			xo, yo := x.offsets[i], y.offsets[i];
+			xn, yn := x.names[i], y.names[i];
+
+			if xb != yb do return false;
+			if xo != yo do return false;
+			if xn != yn do return false;
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+
+is_signed :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	switch i in type_info_base(info).variant {
+	case Type_Info_Integer: return i.signed;
+	case Type_Info_Float:   return true;
 	}
 	return false;
 }
-is_integer :: proc(info: ^TypeInfo) -> bool {
+is_integer :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.Integer);
+	_, ok := type_info_base(info).variant.(Type_Info_Integer);
 	return ok;
 }
-is_float :: proc(info: ^TypeInfo) -> bool {
+is_rune :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.Float);
+	_, ok := type_info_base(info).variant.(Type_Info_Rune);
 	return ok;
 }
-is_complex :: proc(info: ^TypeInfo) -> bool {
+is_float :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.Complex);
+	_, ok := type_info_base(info).variant.(Type_Info_Float);
 	return ok;
 }
-is_any :: proc(info: ^TypeInfo) -> bool {
+is_complex :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.Any);
+	_, ok := type_info_base(info).variant.(Type_Info_Complex);
 	return ok;
 }
-is_string :: proc(info: ^TypeInfo) -> bool {
+is_any :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.String);
+	_, ok := type_info_base(info).variant.(Type_Info_Any);
 	return ok;
 }
-is_boolean :: proc(info: ^TypeInfo) -> bool {
+is_string :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.Boolean);
+	_, ok := type_info_base(info).variant.(Type_Info_String);
 	return ok;
 }
-is_pointer :: proc(info: ^TypeInfo) -> bool {
+is_boolean :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.Pointer);
+	_, ok := type_info_base(info).variant.(Type_Info_Boolean);
 	return ok;
 }
-is_procedure :: proc(info: ^TypeInfo) -> bool {
+is_pointer :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.Procedure);
+	_, ok := type_info_base(info).variant.(Type_Info_Pointer);
 	return ok;
 }
-is_array :: proc(info: ^TypeInfo) -> bool {
+is_procedure :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.Array);
+	_, ok := type_info_base(info).variant.(Type_Info_Procedure);
 	return ok;
 }
-is_dynamic_array :: proc(info: ^TypeInfo) -> bool {
+is_array :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.DynamicArray);
+	_, ok := type_info_base(info).variant.(Type_Info_Array);
 	return ok;
 }
-is_dynamic_map :: proc(info: ^TypeInfo) -> bool {
+is_dynamic_array :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.Map);
+	_, ok := type_info_base(info).variant.(Type_Info_Dynamic_Array);
 	return ok;
 }
-is_slice :: proc(info: ^TypeInfo) -> bool {
+is_dynamic_map :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.Slice);
+	_, ok := type_info_base(info).variant.(Type_Info_Map);
 	return ok;
 }
-is_vector :: proc(info: ^TypeInfo) -> bool {
+is_slice :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.Vector);
+	_, ok := type_info_base(info).variant.(Type_Info_Slice);
 	return ok;
 }
-is_tuple :: proc(info: ^TypeInfo) -> bool {
+is_vector :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.Tuple);
+	_, ok := type_info_base(info).variant.(Type_Info_Vector);
 	return ok;
 }
-is_struct :: proc(info: ^TypeInfo) -> bool {
+is_tuple :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.Struct);
+	_, ok := type_info_base(info).variant.(Type_Info_Tuple);
 	return ok;
 }
-is_union :: proc(info: ^TypeInfo) -> bool {
+is_struct :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.Union);
+	s, ok := type_info_base(info).variant.(Type_Info_Struct);
+	return ok && !s.is_raw_union;
+}
+is_raw_union :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	s, ok := type_info_base(info).variant.(Type_Info_Struct);
+	return ok && s.is_raw_union;
+}
+is_union :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Union);
 	return ok;
 }
-is_raw_union :: proc(info: ^TypeInfo) -> bool {
+is_enum :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
-	_, ok := type_info_base(info).(^TypeInfo.RawUnion);
+	_, ok := type_info_base(info).variant.(Type_Info_Enum);
-	return ok;
-}
-is_enum :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
-	_, ok := type_info_base(info).(^TypeInfo.Enum);
 	return ok;
 }

core/utf16.odin

@@ -1,3 +1,5 @@
+import "utf8.odin"
+
 REPLACEMENT_CHAR :: '\uFFFD';
 MAX_RUNE         :: '\U0010FFFF';
 
@@ -27,22 +29,18 @@ encode_surrogate_pair :: proc(r: rune) -> (r1, r2: rune) {
 	return _surr1 + (r>>10)&0x3ff, _surr2 + r&0x3ff;
 }
 
-encode :: proc(d: []u16, s: []rune) {
+encode :: proc(d: []u16, s: []rune) -> int {
 	n := len(s);
-	for r in s {
+	for r in s do if r >= _surr_self do n += 1;
-		if r >= _surr_self {
-			n++;
-		}
-	}
 
 	max_n := min(len(d), n);
 	n = 0;
 
 	for r in s {
-		match r {
+		switch r {
-		case 0..<_surr1, _surr3..<_surr_self:
+		case 0.._surr1, _surr3.._surr_self:
 			d[n] = u16(r);
-			n++;
+			n += 1;
 
 		case _surr_self..MAX_RUNE:
 			r1, r2 := encode_surrogate_pair(r);
@@ -52,7 +50,36 @@ encode :: proc(d: []u16, s: []rune) {
 
 		case:
 			d[n] = u16(REPLACEMENT_CHAR);
-			n++;
+			n += 1;
 		}
 	}
+	return n;
+}
+
+
+encode :: proc(d: []u16, s: string) -> int {
+	n := utf8.rune_count(s);
+	for r in s do if r >= _surr_self do n += 1;
+
+	max_n := min(len(d), n);
+	n = 0;
+
+	for r in s {
+		switch r {
+		case 0.._surr1, _surr3.._surr_self:
+			d[n] = u16(r);
+			n += 1;
+
+		case _surr_self..MAX_RUNE:
+			r1, r2 := encode_surrogate_pair(r);
+			d[n]    = u16(r1);
+			d[n+1]  = u16(r2);
+			n += 2;
+
+		case:
+			d[n] = u16(REPLACEMENT_CHAR);
+			n += 1;
+		}
+	}
+	return n;
 }

core/utf8.odin

@@ -24,13 +24,13 @@ RUNE1_MAX :: 1<<7 - 1;
 RUNE2_MAX :: 1<<11 - 1;
 RUNE3_MAX :: 1<<16 - 1;
 
-// The default lowest and highest continuation byte.
+	// The default lowest and highest continuation byte.
 LOCB :: 0b1000_0000;
 HICB :: 0b1011_1111;
 
-AcceptRange :: struct { lo, hi: u8 }
+Accept_Range :: struct {lo, hi: u8};
 
-immutable accept_ranges := [5]AcceptRange{
+accept_ranges := [5]Accept_Range{
 	{0x80, 0xbf},
 	{0xa0, 0xbf},
 	{0x80, 0x9f},
@@ -38,7 +38,7 @@ immutable accept_ranges := [5]AcceptRange{
 	{0x80, 0x8f},
 };
 
-immutable accept_sizes := [256]u8{
+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
@@ -61,7 +61,7 @@ immutable accept_sizes := [256]u8{
 encode_rune :: proc(r: rune) -> ([4]u8, int) {
 	buf: [4]u8;
 	i := u32(r);
-	mask: u8 : 0x3f;
+	mask :: u8(0x3f);
 	if i <= 1<<7-1 {
 		buf[0] = u8(r);
 		return buf, 1;
@@ -92,7 +92,7 @@ encode_rune :: proc(r: rune) -> ([4]u8, int) {
 	return buf, 4;
 }
 
-decode_rune :: proc(s: string) -> (rune, int) #inline { return decode_rune([]u8(s)); }
+decode_rune :: inline proc(s: string) -> (rune, int) do return decode_rune(cast([]u8)s);
 decode_rune :: proc(s: []u8) -> (rune, int) {
 	n := len(s);
 	if n < 1 {
@@ -132,7 +132,7 @@ decode_rune :: proc(s: []u8) -> (rune, int) {
 
 
 
-decode_last_rune :: proc(s: string) -> (rune, int) #inline { return decode_last_rune([]u8(s)); }
+decode_last_rune :: inline proc(s: string) -> (rune, int) do return decode_last_rune(cast([]u8)s);
 decode_last_rune :: proc(s: []u8) -> (rune, int) {
 	r: rune;
 	size: int;
@@ -151,16 +151,12 @@ decode_last_rune :: proc(s: []u8) -> (rune, int) {
 
 	limit = max(end - UTF_MAX, 0);
 
-	start--;
+	for start-=1; start >= limit; start-=1 {
-	for start >= limit {
+		if rune_start(s[start]) do break;
-		if rune_start(s[start]) {
-			break;
-		}
-		start--;
 	}
 
 	start = max(start, 0);
-	r, size = decode_rune(s[start..<end]);
+	r, size = decode_rune(s[start..end]);
 	if start+size != end {
 		return RUNE_ERROR, 1;
 	}
@@ -187,7 +183,7 @@ valid_string :: proc(s: string) -> bool {
 	for i := 0; i < n; {
 		si := s[i];
 		if si < RUNE_SELF { // ascii
-			i++;
+			i += 1;
 			continue;
 		}
 		x := accept_sizes[si];
@@ -215,28 +211,28 @@ valid_string :: proc(s: string) -> bool {
 	return true;
 }
 
-rune_start :: proc(b: u8) -> bool #inline { return b&0xc0 != 0x80; }
+rune_start :: inline proc(b: u8) -> bool do return b&0xc0 != 0x80;
 
-rune_count :: proc(s: string) -> int #inline { return rune_count([]u8(s)); }
+rune_count :: inline proc(s: string) -> int do return rune_count(cast([]u8)s);
 rune_count :: proc(s: []u8) -> int {
 	count := 0;
 	n := len(s);
 
 	for i := 0; i < n; {
-		defer count++;
+		defer count += 1;
 		si := s[i];
 		if si < RUNE_SELF { // ascii
-			i++;
+			i += 1;
 			continue;
 		}
 		x := accept_sizes[si];
 		if x == 0xf1 {
-			i++;
+			i += 1;
 			continue;
 		}
 		size := int(x & 7);
 		if i+size > n {
-			i++;
+			i += 1;
 			continue;
 		}
 		ar := accept_ranges[x>>4];
@@ -258,7 +254,7 @@ rune_count :: proc(s: []u8) -> int {
 
 
 rune_size :: proc(r: rune) -> int {
-	match {
+	switch {
 	case r < 0:          return -1;
 	case r <= 1<<7  - 1: return 1;
 	case r <= 1<<11 - 1: return 2;

examples/demo.odin

@@ -0,0 +1,570 @@
+import "core:fmt.odin"
+import "core:strconv.odin"
+import "core:mem.odin"
+import "core:bits.odin"
+import "core:hash.odin"
+import "core:math.odin"
+import "core:os.odin"
+import "core:raw.odin"
+import "core:sort.odin"
+import "core:strings.odin"
+import "core:types.odin"
+import "core:utf16.odin"
+import "core:utf8.odin"
+
+when ODIN_OS == "windows" {
+	import "core:atomics.odin"
+	import "core:opengl.odin"
+	import "core:thread.odin"
+	import win32 "core:sys/windows.odin"
+}
+
+general_stuff :: proc() {
+	{ // `do` for inline statmes rather than block
+		foo :: proc() do fmt.println("Foo!");
+		if   false do foo();
+		for  false do foo();
+		when false do foo();
+
+		if false do foo();
+		else     do foo();
+	}
+
+	{ // Removal of `++` and `--` (again)
+		x: int;
+		x += 1;
+		x -= 1;
+	}
+	{ // Casting syntaxes
+		i := i32(137);
+		ptr := &i;
+
+		fp1 := (^f32)(ptr);
+		// ^f32(ptr) == ^(f32(ptr))
+		fp2 := cast(^f32)ptr;
+
+		f1 := (^f32)(ptr)^;
+		f2 := (cast(^f32)ptr)^;
+
+		// Questions: Should there be two ways to do it?
+	}
+
+	/*
+	 * Remove *_val_of built-in procedures
+	 * size_of, align_of, offset_of
+	 * type_of, type_info_of
+	 */
+
+	{ // `expand_to_tuple` built-in procedure
+		Foo :: struct {
+			x: int,
+			b: bool,
+		}
+		f := Foo{137, true};
+		x, b := expand_to_tuple(f);
+		fmt.println(f);
+		fmt.println(x, b);
+		fmt.println(expand_to_tuple(f));
+	}
+
+	{
+		// ..  half-closed range
+		// ... open range
+
+		for in 0..2  {} // 0, 1
+		for in 0...2 {} // 0, 1, 2
+	}
+}
+
+default_struct_values :: proc() {
+	{
+		Vector3 :: struct {
+			x: f32,
+			y: f32,
+			z: f32,
+		}
+		v: Vector3;
+		fmt.println(v);
+	}
+	{
+		// Default values must be constants
+		Vector3 :: struct {
+			x: f32 = 1,
+			y: f32 = 4,
+			z: f32 = 9,
+		}
+		v: Vector3;
+		fmt.println(v);
+
+		v = Vector3{};
+		fmt.println(v);
+
+		// Uses the same semantics as a default values in a procedure
+		v = Vector3{137};
+		fmt.println(v);
+
+		v = Vector3{z = 137};
+		fmt.println(v);
+	}
+
+	{
+		Vector3 :: struct {
+			x := 1.0,
+			y := 4.0,
+			z := 9.0,
+		}
+		stack_default: Vector3;
+		stack_literal := Vector3{};
+		heap_one      := new(Vector3);         defer free(heap_one);
+		heap_two      := new_clone(Vector3{}); defer free(heap_two);
+
+		fmt.println("stack_default - ", stack_default);
+		fmt.println("stack_literal - ", stack_literal);
+		fmt.println("heap_one      - ", heap_one^);
+		fmt.println("heap_two      - ", heap_two^);
+
+
+		N :: 4;
+		stack_array: [N]Vector3;
+		heap_array := new([N]Vector3);    defer free(heap_array);
+		heap_slice := make([]Vector3, N); defer free(heap_slice);
+		fmt.println("stack_array[1] - ", stack_array[1]);
+		fmt.println("heap_array[1]  - ", heap_array[1]);
+		fmt.println("heap_slice[1]  - ", heap_slice[1]);
+	}
+}
+
+
+
+
+union_type :: proc() {
+	{
+		val: union{int, bool};
+		val = 137;
+		if i, ok := val.(int); ok {
+			fmt.println(i);
+		}
+		val = true;
+		fmt.println(val);
+
+		val = nil;
+
+		switch v in val {
+		case int:  fmt.println("int",  v);
+		case bool: fmt.println("bool", v);
+		case:      fmt.println("nil");
+		}
+	}
+	{
+		// There is a duality between `any` and `union`
+		// An `any` has a pointer to the data and allows for any type (open)
+		// A `union` has as binary blob to store the data and allows only certain types (closed)
+		// The following code is with `any` but has the same syntax
+		val: any;
+		val = 137;
+		if i, ok := val.(int); ok {
+			fmt.println(i);
+		}
+		val = true;
+		fmt.println(val);
+
+		val = nil;
+
+		switch v in val {
+		case int:  fmt.println("int",  v);
+		case bool: fmt.println("bool", v);
+		case:      fmt.println("nil");
+		}
+	}
+
+	Vector3 :: struct {x, y, z: f32};
+	Quaternion :: struct {x, y, z: f32, w: f32 = 1};
+
+	// More realistic examples
+	{
+		// NOTE(bill): For the above basic examples, you may not have any
+		// particular use for it. However, my main use for them is not for these
+		// simple cases. My main use is for hierarchical types. Many prefer
+		// subtyping, embedding the base data into the derived types. Below is
+		// an example of this for a basic game Entity.
+
+		Entity :: struct {
+			id:          u64,
+			name:        string,
+			position:    Vector3,
+			orientation: Quaternion,
+
+			derived: any,
+		}
+
+		Frog :: struct {
+			using entity: Entity,
+			jump_height:  f32,
+		}
+
+		Monster :: struct {
+			using entity: Entity,
+			is_robot:     bool,
+			is_zombie:    bool,
+		}
+
+		// See `parametric_polymorphism` procedure for details
+		new_entity :: proc(T: type) -> ^Entity {
+			t := new(T);
+			t.derived = t^;
+			return t;
+		}
+
+		entity := new_entity(Monster);
+
+		switch e in entity.derived {
+		case Frog:
+			fmt.println("Ribbit");
+		case Monster:
+			if e.is_robot  do fmt.println("Robotic");
+			if e.is_zombie do fmt.println("Grrrr!");
+		}
+	}
+
+	{
+		// NOTE(bill): A union can be used to achieve something similar. Instead
+		// of embedding the base data into the derived types, the derived data
+		// in embedded into the base type. Below is the same example of the
+		// basic game Entity but using an union.
+
+		Entity :: struct {
+			id:          u64,
+			name:        string,
+			position:    Vector3,
+			orientation: Quaternion,
+
+			derived: union {Frog, Monster},
+		}
+
+		Frog :: struct {
+			using entity: ^Entity,
+			jump_height:  f32,
+		}
+
+		Monster :: struct {
+			using entity: ^Entity,
+			is_robot:     bool,
+			is_zombie:    bool,
+		}
+
+		// See `parametric_polymorphism` procedure for details
+		new_entity :: proc(T: type) -> ^Entity {
+			t := new(Entity);
+			t.derived = T{entity = t};
+			return t;
+		}
+
+		entity := new_entity(Monster);
+
+		switch e in entity.derived {
+		case Frog:
+			fmt.println("Ribbit");
+		case Monster:
+			if e.is_robot  do fmt.println("Robotic");
+			if e.is_zombie do fmt.println("Grrrr!");
+		}
+
+		// NOTE(bill): As you can see, the usage code has not changed, only its
+		// memory layout. Both approaches have their own advantages but they can
+		// be used together to achieve different results. The subtyping approach
+		// can allow for a greater control of the memory layout and memory
+		// allocation, e.g. storing the derivatives together. However, this is
+		// also its disadvantage. You must either preallocate arrays for each
+		// derivative separation (which can be easily missed) or preallocate a
+		// bunch of "raw" memory; determining the maximum size of the derived
+		// types would require the aid of metaprogramming. Unions solve this
+		// particular problem as the data is stored with the base data.
+		// Therefore, it is possible to preallocate, e.g. [100]Entity.
+
+		// It should be noted that the union approach can have the same memory
+		// layout as the any and with the same type restrictions by using a
+		// pointer type for the derivatives.
+
+		/*
+			Entity :: struct {
+				...
+				derived: union{^Frog, ^Monster};
+			}
+
+			Frog :: struct {
+				using entity: Entity;
+				...
+			}
+			Monster :: struct {
+				using entity: Entity;
+				...
+
+			}
+			new_entity :: proc(T: type) -> ^Entity {
+				t := new(T);
+				t.derived = t;
+				return t;
+			}
+		*/
+	}
+}
+
+parametric_polymorphism :: proc() {
+	print_value :: proc(value: $T) {
+		fmt.printf("print_value: %T %v\n", value, value);
+	}
+
+	v1: int    = 1;
+	v2: f32    = 2.1;
+	v3: f64    = 3.14;
+	v4: string = "message";
+
+	print_value(v1);
+	print_value(v2);
+	print_value(v3);
+	print_value(v4);
+
+	fmt.println();
+
+	add :: proc(p, q: $T) -> T {
+		x: T = p + q;
+		return x;
+	}
+
+	a := add(3, 4);
+	fmt.printf("a: %T = %v\n", a, a);
+
+	b := add(3.2, 4.3);
+	fmt.printf("b: %T = %v\n", b, b);
+
+	// This is how `new` is implemented
+	alloc_type :: proc(T: type) -> ^T {
+		t := cast(^T)alloc(size_of(T), align_of(T));
+		t^ = T{}; // Use default initialization value
+		return t;
+	}
+
+	copy_slice :: proc(dst, src: []$T) -> int {
+		n := min(len(dst), len(src));
+		if n > 0 {
+			mem.copy(&dst[0], &src[0], n*size_of(T));
+		}
+		return n;
+	}
+
+	double_params :: proc(a: $A, b: $B) -> A {
+		return a + A(b);
+	}
+
+	fmt.println(double_params(12, 1.345));
+
+
+
+	{ // Polymorphic Types and Type Specialization
+		Table_Slot :: struct(Key, Value: type) {
+			occupied: bool,
+			hash:     u32,
+			key:      Key,
+			value:    Value,
+		}
+		TABLE_SIZE_MIN :: 32;
+		Table :: struct(Key, Value: type) {
+			count:     int,
+			allocator: Allocator,
+			slots:     []Table_Slot(Key, Value),
+		}
+
+		// Only allow types that are specializations of a (polymorphic) slice
+		make_slice :: proc(T: type/[]$E, len: int) -> T {
+			return make(T, len);
+		}
+
+
+		// Only allow types that are specializations of `Table`
+		allocate :: proc(table: ^$T/Table, capacity: int) {
+			c := context;
+			if table.allocator.procedure != nil do c.allocator = table.allocator;
+
+			context <- c {
+				table.slots = make_slice(type_of(table.slots), max(capacity, TABLE_SIZE_MIN));
+			}
+		}
+
+		expand :: proc(table: ^$T/Table) {
+			c := context;
+			if table.allocator.procedure != nil do c.allocator = table.allocator;
+
+			context <- c {
+				old_slots := table.slots;
+
+				cap := max(2*cap(table.slots), TABLE_SIZE_MIN);
+				allocate(table, cap);
+
+				for s in old_slots do if s.occupied {
+					put(table, s.key, s.value);
+				}
+
+				free(old_slots);
+			}
+		}
+
+		// Polymorphic determination of a polymorphic struct
+		// put :: proc(table: ^$T/Table, key: T.Key, value: T.Value) {
+		put :: proc(table: ^Table($Key, $Value), key: Key, value: Value) {
+			hash := get_hash(key); // Ad-hoc method which would fail in a different scope
+			index := find_index(table, key, hash);
+			if index < 0 {
+				if f64(table.count) >= 0.75*f64(cap(table.slots)) {
+					expand(table);
+				}
+				assert(table.count <= cap(table.slots));
+
+				hash := get_hash(key);
+				index = int(hash % u32(cap(table.slots)));
+
+				for table.slots[index].occupied {
+					if index += 1; index >= cap(table.slots) {
+						index = 0;
+					}
+				}
+
+				table.count += 1;
+			}
+
+			slot := &table.slots[index];
+			slot.occupied = true;
+			slot.hash     = hash;
+			slot.key      = key;
+			slot.value    = value;
+		}
+
+
+		// find :: proc(table: ^$T/Table, key: T.Key) -> (T.Value, bool) {
+		find :: proc(table: ^Table($Key, $Value), key: Key) -> (Value, bool) {
+			hash := get_hash(key);
+			index := find_index(table, key, hash);
+			if index < 0 {
+				return Value{}, false;
+			}
+			return table.slots[index].value, true;
+		}
+
+		find_index :: proc(table: ^Table($Key, $Value), key: Key, hash: u32) -> int {
+			if cap(table.slots) <= 0 do return -1;
+
+			index := int(hash % u32(cap(table.slots)));
+			for table.slots[index].occupied {
+				if table.slots[index].hash == hash {
+					if table.slots[index].key == key {
+						return index;
+					}
+				}
+
+				if index += 1; index >= cap(table.slots) {
+					index = 0;
+				}
+			}
+
+			return -1;
+		}
+
+		get_hash :: proc(s: string) -> u32 { // fnv32a
+			h: u32 = 0x811c9dc5;
+			for i in 0..len(s) {
+				h = (h ~ u32(s[i])) * 0x01000193;
+			}
+			return h;
+		}
+
+
+		table: Table(string, int);
+
+		for i in 0..36 do put(&table, "Hellope", i);
+		for i in 0..42 do put(&table, "World!",  i);
+
+		found, _ := find(&table, "Hellope");
+		fmt.printf("`found` is %v\n", found);
+
+		found, _ = find(&table, "World!");
+		fmt.printf("`found` is %v\n", found);
+
+		// I would not personally design a hash table like this in production
+		// but this is a nice basic example
+		// A better approach would either use a `u64` or equivalent for the key
+		// and let the user specify the hashing function or make the user store
+		// the hashing procedure with the table
+	}
+}
+
+
+
+
+prefix_table := [...]string{
+	"White",
+	"Red",
+	"Green",
+	"Blue",
+	"Octarine",
+	"Black",
+};
+
+threading_example :: proc() {
+	when ODIN_OS == "windows" {
+		unordered_remove :: proc(array: ^[]$T, index: int, loc := #caller_location) {
+			__bounds_check_error_loc(loc, index, len(array));
+			array[index] = array[len(array)-1];
+			pop(array);
+		}
+		ordered_remove :: proc(array: ^[]$T, index: int, loc := #caller_location) {
+			__bounds_check_error_loc(loc, index, len(array));
+			copy(array[index..], array[index+1..]);
+			pop(array);
+		}
+
+		worker_proc :: proc(t: ^thread.Thread) -> int {
+			for iteration in 1...5 {
+				fmt.printf("Thread %d is on iteration %d\n", t.user_index, iteration);
+				fmt.printf("`%s`: iteration %d\n", prefix_table[t.user_index], iteration);
+				// win32.sleep(1);
+			}
+			return 0;
+		}
+
+		threads := make([]^thread.Thread, 0, len(prefix_table));
+		defer free(threads);
+
+		for i in 0..len(prefix_table) {
+			if t := thread.create(worker_proc); t != nil {
+				t.init_context = context;
+				t.use_init_context = true;
+				t.user_index = len(threads);
+				append(&threads, t);
+				thread.start(t);
+			}
+		}
+
+		for len(threads) > 0 {
+			for i := 0; i < len(threads); /**/ {
+				if t := threads[i]; thread.is_done(t) {
+					fmt.printf("Thread %d is done\n", t.user_index);
+					thread.destroy(t);
+
+					ordered_remove(&threads, i);
+				} else {
+					i += 1;
+				}
+			}
+		}
+	}
+}
+
+main :: proc() {
+	when false {
+		fmt.println("\n# general_stuff");              general_stuff();
+		fmt.println("\n# default_struct_values");      default_struct_values();
+		fmt.println("\n# union_type");                 union_type();
+		fmt.println("\n# parametric_polymorphism");    parametric_polymorphism();
+		fmt.println("\n# threading_example");          threading_example();
+	}
+}
+

examples/factorial.odin

@@ -0,0 +1,20 @@
+import "core:fmt.odin";
+
+main :: proc() {
+	recursive_factorial :: proc(i: u64) -> u64 {
+		if i < 2 do return 1;
+		return i * recursive_factorial(i-1);
+	}
+
+	loop_factorial :: proc(i: u64) -> u64 {
+		result: u64 = 1;
+		for n in 2..i {
+			result *= n;
+		}
+		return result;
+	}
+
+
+	fmt.println(recursive_factorial(12));
+	fmt.println(loop_factorial(12));
+}

examples/game.odin

@@ -1,32 +1,31 @@
-#import win32 "sys/windows.odin" when ODIN_OS == "windows";
+import win32 "core:sys/windows.odin" when ODIN_OS == "windows";
-#import wgl "sys/wgl.odin" when ODIN_OS == "windows";
+import wgl "core:sys/wgl.odin" when ODIN_OS == "windows";
-#import "fmt.odin";
+import "core:fmt.odin";
-#import "math.odin";
+import "core:math.odin";
-#import "os.odin";
+import "core:os.odin";
-#import gl "opengl.odin";
+import gl "core:opengl.odin";
 
 TWO_HEARTS :: '💕';
 
-win32_perf_count_freq := win32.GetQueryPerformanceFrequency();
+win32_perf_count_freq := win32.get_query_performance_frequency();
 time_now :: proc() -> f64 {
 	assert(win32_perf_count_freq != 0);
 
 	counter: i64;
-	win32.QueryPerformanceCounter(^counter);
+	win32.query_performance_counter(&counter);
-	result := cast(f64)counter / cast(f64)win32_perf_count_freq;
+	return f64(counter) / f64(win32_perf_count_freq);
-	return result;
 }
 win32_print_last_error :: proc() {
-	err_code := cast(int)win32.GetLastError();
+	err_code := win32.get_last_error();
 	if err_code != 0 {
-		fmt.println("GetLastError: %", err_code);
+		fmt.println("get_last_error: ", err_code);
 	}
 }
 
 // Yuk!
 to_c_string :: proc(s: string) -> []u8 {
 	c_str := make([]u8, len(s)+1);
-	copy(c_str, cast([]byte)s);
+	copy(c_str, cast([]u8)s);
 	c_str[len(s)] = 0;
 	return c_str;
 }
@@ -34,7 +33,7 @@ to_c_string :: proc(s: string) -> []u8 {
 
 Window :: struct {
 	width, height:      int,
-	wc:                 win32.WndClassExA,
+	wc:                 win32.Wnd_Class_Ex_A,
 	dc:                 win32.Hdc,
 	hwnd:               win32.Hwnd,
 	opengl_context, rc: wgl.Hglrc,
@@ -48,45 +47,45 @@ make_window :: proc(title: string, msg, height: int, window_proc: win32.Wnd_Proc
 	w.width, w.height = msg, height;
 
 	class_name := "Win32-Odin-Window\x00";
-	c_class_name := ^class_name[0];
+	c_class_name := &class_name[0];
 	if title[len(title)-1] != 0 {
 		w.c_title = to_c_string(title);
 	} else {
 		w.c_title = cast([]u8)title;
 	}
 
-	instance := GetModuleHandleA(nil);
+	instance := get_module_handle_a(nil);
 
-	w.wc = WndClassExA{
+	w.wc = Wnd_Class_Ex_A{
-		size       = size_of(WndClassExA),
+		size       = size_of(Wnd_Class_Ex_A),
 		style      = CS_VREDRAW | CS_HREDRAW,
-		instance   = cast(Hinstance)instance,
+		instance   = Hinstance(instance),
 		class_name = c_class_name,
 		wnd_proc   = window_proc,
 	};
 
-	if RegisterClassExA(^w.wc) == 0 {
+	if register_class_ex_a(&w.wc) == 0 {
 		win32_print_last_error();
 		return w, false;
 	}
 
-	w.hwnd = CreateWindowExA(0,
+	w.hwnd = create_window_ex_a(0,
-	                         c_class_name, ^w.c_title[0],
+	                            c_class_name, &w.c_title[0],
-	                         WS_VISIBLE | WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
+	                            WS_VISIBLE | WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
-	                         CW_USEDEFAULT, CW_USEDEFAULT,
+	                            CW_USEDEFAULT, CW_USEDEFAULT,
-	                         cast(i32)w.width, cast(i32)w.height,
+	                            i32(w.width), i32(w.height),
-	                         nil, nil, instance, nil);
+	                            nil, nil, instance, nil);
 
 	if w.hwnd == nil {
 		win32_print_last_error();
 		return w, false;
 	}
 
-	w.dc = GetDC(w.hwnd);
+	w.dc = get_dc(w.hwnd);
 
 	{
-		pfd := PIXELFORMATDESCRIPTOR{
+		pfd := Pixel_Format_Descriptor{
-			size         = size_of(PIXELFORMATDESCRIPTOR),
+			size         = size_of(Pixel_Format_Descriptor),
 			version      = 1,
 			flags        = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
 			pixel_type   = PFD_TYPE_RGBA,
@@ -97,22 +96,22 @@ make_window :: proc(title: string, msg, height: int, window_proc: win32.Wnd_Proc
 			layer_type   = PFD_MAIN_PLANE,
 		};
 
-		SetPixelFormat(w.dc, ChoosePixelFormat(w.dc, ^pfd), nil);
+		set_pixel_format(w.dc, choose_pixel_format(w.dc, &pfd), nil);
-		w.opengl_context = wgl.CreateContext(w.dc);
+		w.opengl_context = wgl.create_context(w.dc);
-		wgl.MakeCurrent(w.dc, w.opengl_context);
+		wgl.make_current(w.dc, w.opengl_context);
 
 		attribs := [8]i32{
 			wgl.CONTEXT_MAJOR_VERSION_ARB, 2,
 			wgl.CONTEXT_MINOR_VERSION_ARB, 1,
 			wgl.CONTEXT_PROFILE_MASK_ARB, wgl.CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
-			0, // NOTE(bill): tells the proc that this is the end of attribs
+			0, // NOTE(bill): tells the that :: proc this is the end of attribs
 		};
 
 		wgl_str := "wglCreateContextAttribsARB\x00";
-		wglCreateContextAttribsARB := cast(wgl.Create_Context_Attribs_ARB_Type)wgl.GetProcAddress(^wgl_str[0]);
+		wglCreateContextAttribsARB := cast(wgl.Create_Context_Attribs_ARB_Type)wgl.get_proc_address(&wgl_str[0]);
-		w.rc = wglCreateContextAttribsARB(w.dc, nil, ^attribs[0]);
+		w.rc = wglCreateContextAttribsARB(w.dc, nil, &attribs[0]);
-		wgl.MakeCurrent(w.dc, w.rc);
+		wgl.make_current(w.dc, w.rc);
-		SwapBuffers(w.dc);
+		swap_buffers(w.dc);
 	}
 
 	return w, true;
@@ -123,30 +122,31 @@ destroy_window :: proc(w: ^Window) {
 }
 
 display_window :: proc(w: ^Window) {
-	win32.SwapBuffers(w.dc);
+	win32.swap_buffers(w.dc);
 }
 
 
 run :: proc() {
-	using win32;
 	using math;
 
 	win32_proc :: proc(hwnd: win32.Hwnd, msg: u32, wparam: win32.Wparam, lparam: win32.Lparam) -> win32.Lresult #no_inline {
+		using win32;
 		if msg == WM_DESTROY || msg == WM_CLOSE || msg == WM_QUIT {
 			os.exit(0);
 			return 0;
 		}
-		return DefWindowProcA(hwnd, msg, wparam, lparam);
+		return def_window_proc_a(hwnd, msg, wparam, lparam);
 	}
 
-	window, window_success := make_window("Odin Language Demo", 854, 480, cast(Wnd_Proc)win32_proc);
+	window, window_success := make_window("Odin Language Demo", 854, 480, cast(win32.Wnd_Proc)win32_proc);
 	if !window_success {
 		return;
 	}
-	defer destroy_window(^window);
+	defer destroy_window(&window);
 
 	gl.init();
 
+	using win32;
 
 	prev_time := time_now();
 	running := true;
@@ -155,19 +155,19 @@ run :: proc() {
 
 	for running {
 		curr_time := time_now();
-		dt := cast(f32)(curr_time - prev_time);
+		dt := f32(curr_time - prev_time);
 		prev_time = curr_time;
 
 		msg: Msg;
-		for PeekMessageA(^msg, nil, 0, 0, PM_REMOVE) > 0 {
+		for peek_message_a(&msg, nil, 0, 0, PM_REMOVE) > 0 {
 			if msg.message == WM_QUIT {
 				running = false;
 			}
-			TranslateMessage(^msg);
+			translate_message(&msg);
-			DispatchMessageA(^msg);
+			dispatch_message_a(&msg);
 		}
 
-		if is_key_down(Key_Code.ESCAPE) {
+		if is_key_down(Key_Code.Escape) {
 			running = false;
 		}
 
@@ -175,10 +175,10 @@ run :: proc() {
 			SPEED :: 500;
 			v: Vec2;
 
-			if is_key_down(Key_Code.RIGHT) { v[0] += 1; }
+			if is_key_down(Key_Code.Right) do v[0] += 1;
-			if is_key_down(Key_Code.LEFT)  { v[0] -= 1; }
+			if is_key_down(Key_Code.Left)  do v[0] -= 1;
-			if is_key_down(Key_Code.UP)    { v[1] += 1; }
+			if is_key_down(Key_Code.Up)    do v[1] += 1;
-			if is_key_down(Key_Code.DOWN)  { v[1] -= 1; }
+			if is_key_down(Key_Code.Down)  do v[1] -= 1;
 
 			v = norm(v);
 
@@ -190,8 +190,8 @@ run :: proc() {
 		gl.Clear(gl.COLOR_BUFFER_BIT);
 
 		gl.LoadIdentity();
-		gl.Ortho(0, cast(f64)window.width,
+		gl.Ortho(0, f64(window.width),
-		         0, cast(f64)window.height, 0, 1);
+		         0, f64(window.height), 0, 1);
 
 		draw_rect :: proc(x, y, w, h: f32) {
 			gl.Begin(gl.TRIANGLES);
@@ -208,10 +208,9 @@ run :: proc() {
 
 		draw_rect(pos.x, pos.y, 50, 50);
 
-		display_window(^window);
+		display_window(&window);
-		ms_to_sleep := cast(i32)(16 - 1000*dt);
+		if ms_to_sleep := i32(16 - 1000*dt); ms_to_sleep > 0 {
-		if ms_to_sleep > 0 {
+			win32.sleep(ms_to_sleep);
-			win32.Sleep(ms_to_sleep);
 		}
 	}
 }

examples/hello.odin

@@ -0,0 +1,5 @@
+import "core:fmt.odin";
+
+main :: proc() {
+	fmt.println("Hellope, world!");
+}

examples/old_demos/demo001.odin

@@ -1,9 +1,9 @@
-#import "fmt.odin";
+import "core:fmt.odin";
-#import "os.odin";
+import "core:os.odin";
-#import "mem.odin";
+import "core:mem.odin";
-// #import "http_test.odin" as ht;
+// import "http_test.odin" as ht;
-// #import "game.odin" as game;
+// import "game.odin" as game;
-// #import "punity.odin" as pn;
+// import "punity.odin" as pn;
 
 main :: proc() {
 	struct_padding();
@@ -160,21 +160,21 @@ type_introspection :: proc() {
 		info: ^Type_Info;
 		x: int;
 
-		info = type_info(int); // by type
+		info = type_info_of(int); // by type
-		info = type_info_of_val(x); // by value
+		info = type_info_of(x);   // by value
 		// See: runtime.odin
 
-		match i in info {
+		match i in info.variant {
-		case Type_Info.Integer:
+		case Type_Info_Integer:
 			fmt.println("integer!");
-		case Type_Info.Float:
+		case Type_Info_Float:
 			fmt.println("float!");
-		default:
+		case:
 			fmt.println("potato!");
 		}
 
 		// Unsafe cast
-		integer_info := cast(^Type_Info.Integer)cast(rawptr)info;
+		integer_info := cast(^Type_Info_Integer)cast(rawptr)info;
 	}
 
 	{
@@ -185,9 +185,9 @@ type_introspection :: proc() {
 		v2: Vector3;
 		v3: Vector3;
 
-		t1 := type_info_of_val(v1);
+		t1 := type_info_of(v1);
-		t2 := type_info_of_val(v2);
+		t2 := type_info_of(v2);
-		t3 := type_info_of_val(v3);
+		t3 := type_info_of(v3);
 
 		fmt.println();
 		fmt.print("Type of v1 is:\n\t", t1);
@@ -262,12 +262,12 @@ crazy_introspection :: proc() {
 			TOMATO,
 		}
 
-		fruit_ti := type_info(Fruit);
+		fruit_ti := type_info_of(Fruit);
-		name := (union_cast(^Type_Info.Named)fruit_ti).name; // Unsafe casts
+		name := fruit_ti.variant.(Type_Info_Named).name;
-		info, _ := union_cast(^Type_Info.Enum)type_info_base(fruit_ti); // Unsafe casts
+		info, _ := type_info_base(fruit_ti).variant.(Type_Info_Enum);
 
 		fmt.printf("%s :: enum %T {\n", name, info.base);
-		for i := 0; i < len(info.values); i++ {
+		for _, i in info.values {
 			fmt.printf("\t%s\t= %v,\n", info.names[i], info.values[i]);
 		}
 		fmt.printf("}\n");

examples/old_demos/demo002.odin

@@ -1,7 +1,8 @@
 // Demo 002
-#load "fmt.odin";
+export "core:fmt.odin";
-#load "math.odin";
+export "core:math.odin";
-// #load "game.odin"
+export "core:mem.odin";
+// export "game.odin"
 
 #thread_local tls_int: int;
 
@@ -94,11 +95,9 @@ enumerations :: proc() {
 }
 
 variadic_procedures :: proc() {
-	print_ints :: proc(args: ..int) {
+	print_ints :: proc(args: ...int) {
 		for arg, i in args {
-			if i > 0 {
+			if i > 0 do print(", ");
-				print(", ");
-			}
 			print(arg);
 		}
 	}
@@ -107,13 +106,11 @@ variadic_procedures :: proc() {
 	print_ints(1); nl();
 	print_ints(1, 2, 3); nl();
 
-	print_prefix_f32s :: proc(prefix: string, args: ..f32) {
+	print_prefix_f32s :: proc(prefix: string, args: ...f32) {
 		print(prefix);
 		print(": ");
 		for arg, i in args {
-			if i > 0 {
+			if i > 0 do print(", ");
-				print(", ");
-			}
 			print(arg);
 		}
 	}
@@ -147,13 +144,7 @@ new_builtins :: proc() {
 
 		// Q: Should this be `free` rather than `free` and should I overload it for slices too?
 
-		{
+		push_allocator default_allocator() {
-			prev_context := context;
-			defer __context = prev_context;
-			// Q: Should I add a `push_context` feature to the language?
-
-			__context.allocator = default_allocator();
-
 			a := new(int);
 			defer free(a);
 
@@ -164,7 +155,7 @@ new_builtins :: proc() {
 
 	{
 		a: int = 123;
-		b: type_of_val(a) = 321;
+		b: type_of(a) = 321;
 
 		// NOTE(bill): This matches the current naming scheme
 		// size_of
@@ -205,7 +196,7 @@ new_builtins :: proc() {
 
 		a: [16]int;
 		a[1] = 1;
-		b := ^a;
+		b := &a;
 		// Auto pointer deref
 		// consistent with record members
 		assert(b[1] == 1);
@@ -255,7 +246,7 @@ match_statement :: proc() {
 			print("5!\n");
 			fallthrough; // explicit fallthrough
 
-		default:
+		case:
 			print("default!\n");
 		}
 
@@ -267,7 +258,7 @@ match_statement :: proc() {
 			// break by default
 		case TAU:
 			print("τ!\n");
-		default:
+		case:
 			print("default!\n");
 		}
 
@@ -279,7 +270,7 @@ match_statement :: proc() {
 			// break by default
 		case "Goodbye":
 			print("farewell\n");
-		default:
+		case:
 			print("???\n");
 		}
 
@@ -302,7 +293,7 @@ match_statement :: proc() {
 			print("dozens\n");
 		case a >= 100 && a < 1000:
 			print("hundreds\n");
-		default:
+		case:
 			print("a fuck ton\n");
 		}
 
@@ -332,11 +323,9 @@ match_statement :: proc() {
 
 Vector3 :: struct {x, y, z: f32}
 
-print_floats :: proc(args: ..f32) {
+print_floats :: proc(args: ...f32) {
 	for arg, i in args {
-		if i > 0 {
+		if i > 0 do print(", ");
-			print(", ");
-		}
 		print(arg);
 	}
 	println();
@@ -355,7 +344,7 @@ namespacing :: proc() {
 			Thing :: #type struct {
 				y: int,
 				test: bool,
-			}
+			};
 
 			b: Thing; // Uses this scope's Thing
 			b.test = true;
@@ -473,10 +462,10 @@ namespacing :: proc() {
 		}
 
 		e := Entity{position = Vector3{1, 2, 3}};
-		print_pos_1(^e);
+		print_pos_1(&e);
-		print_pos_2(^e);
+		print_pos_2(&e);
-		print_pos_3(^e);
+		print_pos_3(&e);
-		print_pos_4(^e);
+		print_pos_4(&e);
 
 		// This is similar to C++'s `this` pointer that is implicit and only available in methods
 	}
@@ -574,20 +563,20 @@ subtyping :: proc() {
 		entity_count := 0;
 
 		next_entity :: proc(entities: []Entity, entity_count: ^int) -> ^Entity {
-			e := ^entities[entity_count^];
+			e := &entities[entity_count^];
-			entity_count^++;
+			entity_count^ += 1;
 			return e;
 		}
 
 		f: Frog;
-		f.entity = next_entity(entities[..], ^entity_count);
+		f.entity = next_entity(entities[..], &entity_count);
 		f.position = Vector3{3, 4, 6};
 
 		using f.position;
 		print_floats(x, y, z);
 	}
 
-	{
+	/*{
 		// Down casting
 
 		Entity :: struct {
@@ -609,7 +598,7 @@ subtyping :: proc() {
 
 		// NOTE(bill): `down_cast` is unsafe and there are not check are compile time or run time
 		// Q: Should I completely remove `down_cast` as I added it in about 30 minutes
-	}
+	}*/
 
 	{
 		// Multiple "inheritance"/subclassing
@@ -630,7 +619,7 @@ subtyping :: proc() {
 
 tagged_unions :: proc() {
 	{
-		EntityKind :: enum {
+		Entity_Kind :: enum {
 			INVALID,
 			FROG,
 			GIRAFFE,
@@ -638,8 +627,8 @@ tagged_unions :: proc() {
 		}
 
 		Entity :: struct {
-			kind: EntityKind
+			kind: Entity_Kind
-			using data: raw_union {
+			using data: struct #raw_union {
 				frog: struct {
 					jump_height: f32,
 					colour: u32,
@@ -657,33 +646,31 @@ tagged_unions :: proc() {
 		}
 
 		e: Entity;
-		e.kind = EntityKind.FROG;
+		e.kind = Entity_Kind.FROG;
 		e.frog.jump_height = 12;
 
-		f: type_of_val(e.frog);
+		f: type_of(e.frog);
 
 		// But this is very unsafe and extremely cumbersome to write
 		// In C++, I use macros to alleviate this but it's not a solution
 	}
 
 	{
-		Entity :: union {
+		Frog :: struct {
-			Frog{
+			jump_height: f32,
-				jump_height: f32,
+			colour: u32,
-				colour: u32,
-			},
-			Giraffe{
-				neck_length: f32,
-				spot_count: int,
-			},
-			Helicopter{
-				blade_count: int,
-				weight: f32,
-				pilot_name: string,
-			},
 		}
+		Giraffe :: struct {
+			neck_length: f32,
+			spot_count: int,
+		}
+		Helicopter :: struct {
+			blade_count: int,
+			weight: f32,
+			pilot_name: string,
+		}
+		Entity :: union {Frog, Giraffe, Helicopter};
 
-		using Entity;
 		f1: Frog = Frog{12, 0xff9900};
 		f2: Entity = Frog{12, 0xff9900}; // Implicit cast
 		f3 := cast(Entity)Frog{12, 0xff9900}; // Explicit cast
@@ -703,7 +690,7 @@ tagged_unions :: proc() {
 		// Requires a pointer to the union
 		// `x` will be a pointer to type of the case
 
-		match x in ^f {
+		match x in &f {
 		case Frog:
 			print("Frog!\n");
 			print(x.jump_height); nl();
@@ -713,7 +700,7 @@ tagged_unions :: proc() {
 			print("Giraffe!\n");
 		case Helicopter:
 			print("ROFLCOPTER!\n");
-		default:
+		case:
 			print("invalid entity\n");
 		}
 
@@ -755,11 +742,11 @@ tagged_unions :: proc() {
 		AstNode    :: struct {};
 		ExactValue :: struct {};
 
-		EntityKind :: enum {
+		Entity_Kind :: enum {
 			Invalid,
 			Constant,
 			Variable,
-			UsingVariable,
+			Using_Variable,
 			TypeName,
 			Procedure,
 			Builtin,
@@ -769,14 +756,14 @@ tagged_unions :: proc() {
 		Guid :: i64;
 		Entity :: struct {
 
-			kind: EntityKind,
+			kind: Entity_Kind,
 			guid: Guid,
 
 			scope: ^Scope,
 			token: Token,
 			type_: ^Type,
 
-			using data: raw_union {
+			using data: struct #raw_union {
 				Constant: struct {
 					value: ExactValue,
 				},
@@ -786,7 +773,7 @@ tagged_unions :: proc() {
 					is_field:  bool, // Is struct field
 					anonymous: bool, // Variable is an anonymous
 				},
-				UsingVariable: struct {
+				Using_Variable: struct {
 				},
 				TypeName: struct {
 				},
@@ -813,44 +800,44 @@ tagged_unions :: proc() {
 
 		Guid :: i64;
 		Entity_Base :: struct {
-
 		}
 
-		Entity :: union {
+
+		Constant :: struct {
+			value: ExactValue,
+		}
+		Variable :: struct {
+			visited:   bool, // Cycle detection
+			used:      bool, // Variable is used
+			is_field:  bool, // Is struct field
+			anonymous: bool, // Variable is an anonymous
+		}
+		Using_Variable :: struct {
+		}
+		TypeName :: struct {
+		}
+		Procedure :: struct {
+			used: bool,
+		}
+		Builtin :: struct {
+			id: int,
+		}
+
+		Entity :: struct {
 			guid: Guid,
 
 			scope: ^Scope,
 			token: Token,
 			type_: ^Type,
 
-			Constant{
+			variant: union {Constant, Variable, Using_Variable, TypeName, Procedure, Builtin},
-				value: ExactValue,
-			},
-			Variable{
-				visited:   bool, // Cycle detection
-				used:      bool, // Variable is used
-				is_field:  bool, // Is struct field
-				anonymous: bool, // Variable is an anonymous
-			},
-			UsingVariable{
-			},
-			TypeName{
-			},
-			Procedure{
-				used: bool,
-			},
-			Builtin{
-				id: int,
-			},
 		}
 
-		using Entity;
+		e := Entity{
-
+			variant = Variable{
-		e: Entity;
+				used = true,
-
+				anonymous = false,
-		e = Variable{
+			},
-			used = true,
-			anonymous = false,
 		};
 
 
@@ -863,13 +850,13 @@ tagged_unions :: proc() {
 	{
 		// `Raw` unions still have uses, especially for mathematic types
 
-		Vector2 :: raw_union {
+		Vector2 :: struct #raw_union {
 			using xy_: struct { x, y: f32 },
 			e: [2]f32,
 			v: [vector 2]f32,
 		}
 
-		Vector3 :: raw_union {
+		Vector3 :: struct #raw_union {
 			using xyz_: struct { x, y, z: f32 },
 			xy: Vector2,
 			e: [3]f32,

examples/old_demos/demo004.odin

@@ -1,14 +1,14 @@
-#import "fmt.odin";
+import "core:fmt.odin";
-#import "utf8.odin";
+import "core:utf8.odin";
-#import "hash.odin";
+import "core:hash.odin";
-#import "mem.odin";
+import "core:mem.odin";
 
 main :: proc() {
 	{ // New Standard Library stuff
 		s := "Hello";
 		fmt.println(s,
 		            utf8.valid_string(s),
-		            hash.murmur64(cast([]byte)s));
+		            hash.murmur64(cast([]u8)s));
 
 		// utf8.odin
 		// hash.odin
@@ -20,10 +20,10 @@ main :: proc() {
 
 	{
 		arena: mem.Arena;
-		mem.init_arena_from_context(^arena, mem.megabytes(16)); // Uses default allocator
+		mem.init_arena_from_context(&arena, mem.megabytes(16)); // Uses default allocator
-		defer mem.free_arena(^arena);
+		defer mem.destroy_arena(&arena);
 
-		push_allocator mem.arena_allocator(^arena) {
+		push_allocator mem.arena_allocator(&arena) {
 			x := new(int);
 			x^ = 1337;
 
@@ -49,7 +49,7 @@ main :: proc() {
 		// You can also "push" a context
 
 		c := context; // Create copy of the allocator
-		c.allocator = mem.arena_allocator(^arena);
+		c.allocator = mem.arena_allocator(&arena);
 
 		push_context c {
 			x := new(int);

examples/old_demos/demo005.odin

@@ -1,13 +1,13 @@
-#import "fmt.odin";
+import "core:fmt.odin";
-#import "utf8.odin";
+import "core:utf8.odin";
-// #import "atomic.odin";
+// import "core:atomic.odin";
-// #import "hash.odin";
+// import "core:hash.odin";
-// #import "math.odin";
+// import "core:math.odin";
-// #import "mem.odin";
+// import "core:mem.odin";
-// #import "opengl.odin";
+// import "core:opengl.odin";
-// #import "os.odin";
+// import "core:os.odin";
-// #import "sync.odin";
+// import "core:sync.odin";
-// #import win32 "sys/windows.odin";
+// import win32 "core:sys/windows.odin";
 
 main :: proc() {
 	// syntax();
@@ -43,7 +43,7 @@ syntax :: proc() {
 	Thing2 :: struct {x: f32, y: int, z: ^[]int};
 
 	// Slice interals are now just a `ptr+len+cap`
-	slice: []int; compile_assert(size_of_val(slice) == 3*size_of(int));
+	slice: []int; compile_assert(size_of(slice) == 3*size_of(int));
 
 	// Helper type - Help the reader understand what it is quicker
 	My_Int  :: #type int;
@@ -90,22 +90,17 @@ Prefix_Type :: struct {x: int, y: f32, z: rawptr};
 
 prefixes :: proc() {
 	using var: Prefix_Type;
-	immutable const := Prefix_Type{1, 2, nil};
 	var.x = 123;
 	x = 123;
-	// const.x = 123; // const is immutable
 
 
-
+	foo :: proc(using pt: Prefix_Type) {
-	foo :: proc(using immutable pt: Prefix_Type, immutable int_ptr: ^int) {
-		// int_ptr = nil; // Not valid
-		// int_ptr^ = 123; // Not valid
 	}
 
 
 
 	// Same as C99's `restrict`
-	bar :: proc(no_alias a, b: ^int) {
+	bar :: proc(#no_alias a, b: ^int) {
 		// Assumes a never equals b so it can perform optimizations with that fact
 	}
 
@@ -138,14 +133,18 @@ when_statements :: proc() {
 	foreign_procedures();
 }
 
-#foreign_system_library win32_user "user32.lib" when ODIN_OS == "windows";
+when ODIN_OS == "windows" {
+	foreign_system_library win32_user "user32.lib";
+}
 // NOTE: This is done on purpose for two reasons:
 // * Makes it clear where the platform specific stuff is
 // * Removes the need to solve the travelling salesman problem when importing files :P
 
 foreign_procedures :: proc() {
-	ShowWindow  :: proc(hwnd: rawptr, cmd_show: i32) -> i32 #foreign win32_user;
+	foreign win32_user {
-	show_window :: proc(hwnd: rawptr, cmd_show: i32) -> i32 #foreign win32_user "ShowWindow";
+		ShowWindow  :: proc(hwnd: rawptr, cmd_show: i32) -> i32 ---;
+		show_window :: proc(hwnd: rawptr, cmd_show: i32) -> i32 #link_name "ShowWindow" ---;
+	}
 	// NOTE: If that library doesn't get used, it doesn't get linked with
 	// NOTE: There is not link checking yet to see if that procedure does come from that library
 
@@ -203,14 +202,14 @@ loops :: proc() {
 		fmt.println(val, idx);
 	}
 
-	primes := [..]int{2, 3, 5, 7, 11, 13, 17, 19};
+	primes := [...]int{2, 3, 5, 7, 11, 13, 17, 19};
 
 	for p in primes {
 		fmt.println(p);
 	}
 
 	// Pointers to arrays, slices, or strings are allowed
-	for _ in ^primes {
+	for _ in &primes {
 		// ignore the value and just iterate across it
 	}
 
@@ -219,7 +218,7 @@ loops :: proc() {
 	name := "你好，世界";
 	fmt.println(name);
 	for r in name {
-		compile_assert(type_of_val(r) == rune);
+		compile_assert(type_of(r) == rune);
 		fmt.printf("%r\n", r);
 	}
 
@@ -270,8 +269,8 @@ procedure_overloading :: proc() {
 	a: i32 = 123;
 	b: f32;
 	c: rawptr;
-	fmt.println(foo(^a));
+	fmt.println(foo(&a));
-	foo(^b);
+	foo(&b);
 	foo(c);
 	// foo(nil); // nil could go to numerous types thus the ambiguity
 

examples/old_demos/demo006.odin

@@ -0,0 +1,310 @@
+// import "core:atomic.odin";
+import "core:hash.odin";
+import "core:mem.odin";
+import "core:opengl.odin";
+import "core:strconv.odin";
+import "core:sync.odin";
+import win32 "core:sys/windows.odin";
+
+import "core:fmt.odin";
+import "core:os.odin";
+import "core:math.odin";
+
+
+main :: proc() {
+when true {
+/*
+	Added:
+		* Unexported entities and fields using an underscore prefix
+			- See `sync.odin` and explain
+
+	Removed:
+	 * Maybe/option types
+	 * Remove `type` keyword and other "reserved" keywords
+	 * ..< and ... removed and replace with .. (half-closed range)
+
+	Changed:
+	 * `compile_assert` and `assert` return the value of the condition for semantic reasons
+	 * thread_local -> #thread_local
+	 * #include -> #load
+	 * Files only get checked if they are actually used
+	 * match x in y {} // For type match statements
+	 * Version numbering now starts from 0.1.0 and uses the convention:
+	 	- major.minor.patch
+	 * Core library additions to Windows specific stuff
+ */
+
+	{
+		Fruit :: enum {
+			APPLE,
+			BANANA,
+			COCONUT,
+		}
+		fmt.println(Fruit.names);
+	}
+
+	{
+		A :: struct           {x, y: f32};
+		B :: struct #align 16 {x, y: f32};
+		fmt.println("align_of(A) =", align_of(A));
+		fmt.println("align_of(B) =", align_of(B));
+	}
+
+	{
+		// Removal of ..< and ...
+		for i in 0..16 {
+		}
+		// Is similar to
+		for i := 0; i < 16; i += 1 {
+		}
+	}
+
+	{
+		thing: for i in 0..10 {
+			for j in i+1..10 {
+				if j == 2 {
+					fmt.println(i, j);
+					continue thing;
+				}
+				if j == 3 {
+					break thing;
+				}
+			}
+		}
+
+		// Works with, `for`, `for in`, `match`, `match in`
+		// NOTE(bill): This solves most of the problems I need `goto` for
+	}
+
+	{
+		t := type_info_of(int);
+		match i in t.variant {
+		case Type_Info_Integer, Type_Info_Float:
+			fmt.println("It's a number");
+		}
+
+
+		x: any = 123;
+		foo: match i in x {
+		case int, f32:
+			fmt.println("It's an int or f32");
+			break foo;
+		}
+	}
+
+	{
+		cond := true;
+		x: int;
+		if cond {
+			x = 3;
+		} else {
+			x = 4;
+		}
+
+
+		// Ternary operator
+		y := cond ? 3 : 4;
+
+		FOO :: true ? 123 : 432; // Constant ternary expression
+		fmt.println("Ternary values:", y, FOO);
+	}
+
+	{
+		// Slices now store a capacity
+		buf: [256]u8;
+		s: []u8;
+		s = buf[..0]; // == buf[0..0];
+		fmt.println("count =", len(s));
+		fmt.println("capacity =", cap(s));
+		append(&s, 1, 2, 3);
+		fmt.println(s);
+
+		s = buf[1..2..3];
+		fmt.println("count =", len(s));
+		fmt.println("capacity =", cap(s));
+		fmt.println(s);
+
+		clear(&s); // Sets count to zero
+	}
+
+	{
+		Foo :: struct {
+			x, y, z: f32,
+			ok:      bool,
+			flags:   u32,
+		}
+		foo_array: [256]Foo;
+		foo_as_bytes: []u8 = mem.slice_to_bytes(foo_array[..]);
+		// Useful for things like
+		// os.write(handle, foo_as_bytes);
+
+		foo_slice := mem.slice_ptr(cast(^Foo)&foo_as_bytes[0], len(foo_as_bytes)/size_of(Foo), cap(foo_as_bytes)/size_of(Foo));
+		// Question: Should there be a bytes_to_slice procedure or is it clearer to do this even if it is error prone?
+		// And if so what would the syntax be?
+		// slice_transmute([]Foo, foo_as_bytes);
+	}
+
+	{
+		Vec3 :: [vector 3]f32;
+
+		x := Vec3{1, 2, 3};
+		y := Vec3{4, 5, 6};
+		fmt.println(x < y);
+		fmt.println(x + y);
+		fmt.println(x - y);
+		fmt.println(x * y);
+		fmt.println(x / y);
+
+		for i in x {
+			fmt.println(i);
+		}
+
+		compile_assert(size_of([vector 7]bool) >= size_of([7]bool));
+		compile_assert(size_of([vector 7]i32) >= size_of([7]i32));
+		// align_of([vector 7]i32) != align_of([7]i32) // this may be the case
+	}
+
+	{
+		// fmt.* changes
+		// bprint* returns `string`
+
+		data: [256]u8;
+		str := fmt.bprintf(data[..], "Hellope %d %s %c", 123, "others", '!');
+		fmt.println(str);
+	}
+
+	{
+		x: [dynamic]f64;
+		reserve(&x, 16);
+		defer free(x); // `free` is overloaded for numerous types
+		// Number literals can have underscores in them for readability
+		append(&x, 2_000_000.500_000, 123, 5, 7); // variadic append
+
+		for p, i in x {
+			if i > 0 { fmt.print(", "); }
+			fmt.print(p);
+		}
+		fmt.println();
+	}
+
+	{
+		// Dynamic array "literals"
+		x := [dynamic]f64{2_000_000.500_000, 3, 5, 7};
+		defer free(x);
+		fmt.println(x); // fmt.print* supports printing of dynamic types
+		clear(&x);
+		fmt.println(x);
+	}
+
+	{
+		m: map[f32]int;
+		reserve(&m, 16);
+		defer free(m);
+
+		m[1.0] = 1278;
+		m[2.0] = 7643;
+		m[3.0] = 564;
+		_, ok := m[3.0];
+		c := m[3.0];
+		assert(ok && c == 564);
+
+		fmt.print("map[");
+		i := 0;
+		for val, key in m {
+			if i > 0 {
+				fmt.print(", ");
+			}
+			fmt.printf("%v=%v", key, val);
+			i += 1;
+		}
+		fmt.println("]");
+	}
+	{
+		m := map[string]u32{
+			"a" = 56,
+			"b" = 13453,
+			"c" = 7654,
+		};
+		defer free(m);
+
+		c := m["c"];
+		_, ok := m["c"];
+		assert(ok && c == 7654);
+		fmt.println(m);
+
+		delete(&m, "c"); // deletes entry with key "c"
+		_, found := m["c"];
+		assert(!found);
+
+		fmt.println(m);
+		clear(&m);
+		fmt.println(m);
+
+		// NOTE: Fixed size maps are planned but we have not yet implemented
+		// them as we have had no need for them as of yet
+	}
+
+	{
+		Vector3 :: struct{x, y, z: f32};
+		Quaternion :: struct{x, y, z, w: f32};
+
+		// Variants
+		Frog :: struct {
+			ribbit_volume: f32,
+			jump_height:   f32,
+		}
+		Door :: struct {
+			openness: f32,
+		}
+		Map :: struct {
+			width, height:   f32,
+			place_positions: []Vector3,
+			place_names:     []string,
+		}
+
+		Entity :: struct {
+			// Common Fields
+			id:             u64,
+			name:           string,
+			using position: Vector3,
+			orientation:    Quaternion,
+			flags:          u32,
+
+			variant: union { Frog, Door, Map },
+		}
+
+		entity: Entity;
+		entity.id = 1337;
+		// implicit conversion from variant to base type
+		entity.variant = Frog{
+			ribbit_volume = 0.5,
+			jump_height = 2.1,
+			/*other data */
+		};
+
+		entity.name = "Frank";
+		entity.position = Vector3{1, 4, 9};
+
+		match e in entity.variant {
+		case Frog:
+			fmt.println("Ribbit");
+		case Door:
+			fmt.println("Creak");
+		case Map:
+			fmt.println("Rustle");
+		case:
+			fmt.println("Just a normal entity");
+		}
+
+		if frog, ok := entity.variant.(Frog); ok {
+			fmt.printf("The frog jumps %f feet high at %v\n", frog.jump_height, entity.position);
+		}
+
+		// Panics if not the correct type
+		frog: Frog;
+		frog = entity.variant.(Frog);
+		frog, _ = entity.variant.(Frog); // ignore error and force cast
+	}
+}
+}
+

examples/old_stuff/demo_backup.odin

@@ -0,0 +1,430 @@
+import (
+	"fmt.odin";
+	"atomics.odin";
+	"bits.odin";
+	"decimal.odin";
+	"hash.odin";
+	"math.odin";
+	"mem.odin";
+	"opengl.odin";
+	"os.odin";
+	"raw.odin";
+	"strconv.odin";
+	"strings.odin";
+	"sync.odin";
+	"sort.odin";
+	"types.odin";
+	"utf8.odin";
+	"utf16.odin";
+/*
+*/
+)
+
+
+general_stuff :: proc() {
+	// Complex numbers
+	a := 3 + 4i;
+	b: complex64 = 3 + 4i;
+	c: complex128 = 3 + 4i;
+	d := complex(2, 3);
+
+	e := a / conj(a);
+	fmt.println("(3+4i)/(3-4i) =", e);
+	fmt.println(real(e), "+", imag(e), "i");
+
+
+	// C-style variadic procedures
+	foreign __llvm_core {
+		// The variadic part allows for extra type checking too which C does not provide
+		c_printf :: proc(fmt: ^u8, #c_vararg args: ...any) -> i32 #link_name "printf" ---;
+	}
+	str := "%d\n\x00";
+	// c_printf(&str[0], i32(789456123));
+
+
+	Foo :: struct {
+		x: int;
+		y: f32;
+		z: string;
+	}
+	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);
+	compile_assert(type_of(z) == string);
+
+
+	// By default, all variables are zeroed
+	// This can be overridden with the "uninitialized value"
+	// This is similar to `nil` but applied to everything
+	undef_int: int = ---;
+
+
+	// Context system is now implemented using Implicit Parameter Passing (IPP)
+	// The previous implementation was Thread Local Storage (TLS)
+	// IPP has the advantage that it works on systems without TLS and that you can
+	// link the context to the stack frame and thus look at previous contexts
+	//
+	// It does mean that a pointer is implicitly passed procedures with the default
+	// Odin calling convention (#cc_odin)
+	// This can be overridden with something like #cc_contextless or #cc_c if performance
+	// is worried about
+
+}
+
+foreign_blocks :: proc() {
+	// See sys/windows.odin
+}
+
+default_arguments :: proc() {
+	hello :: proc(a: int = 9, b: int = 9) do fmt.printf("a is %d; b is %d\n", a, b);
+	fmt.println("\nTesting default arguments:");
+	hello(1, 2);
+	hello(1);
+	hello();
+}
+
+named_arguments :: proc() {
+	Colour :: enum {
+		Red,
+		Orange,
+		Yellow,
+		Green,
+		Blue,
+		Octarine,
+	};
+	using Colour;
+
+	make_character :: proc(name, catch_phrase: string, favourite_colour, least_favourite_colour: Colour) {
+		fmt.println();
+		fmt.printf("My name is %v and I like %v.  %v\n", name, favourite_colour, catch_phrase);
+	}
+
+	make_character("Frank", "¡Ay, caramba!", Blue, Green);
+
+
+	// As the procedures have more and more parameters, it is very easy
+	// to get many of the arguments in the wrong order especialy if the
+	// types are the same
+	make_character("¡Ay, caramba!", "Frank", Green, Blue);
+
+	// Named arguments help to disambiguate this problem
+	make_character(catch_phrase = "¡Ay, caramba!", name = "Frank",
+	               least_favourite_colour = Green, favourite_colour = Blue);
+
+
+	// The named arguments can be specifed in any order.
+	make_character(favourite_colour = Octarine, catch_phrase = "U wot m8!",
+	               least_favourite_colour = Green, name = "Dennis");
+
+
+	// NOTE: You cannot mix named arguments with normal values
+	/*
+	make_character("Dennis",
+	               favourite_colour = Octarine, catch_phrase = "U wot m8!",
+	               least_favourite_colour = Green);
+	*/
+
+
+	// Named arguments can also aid with default arguments
+	numerous_things :: proc(s: string, a := 1, b := 2, c := 3.14,
+	                        d := "The Best String!", e := false, f := 10.3/3.1, g := false) {
+		g_str := g ? "true" : "false";
+		fmt.printf("How many?! %s: %v\n", s, g_str);
+	}
+
+	numerous_things("First");
+	numerous_things(s = "Second", g = true);
+
+
+	// Default values can be placed anywhere, not just at the end like in other languages
+	weird :: proc(pre: string, mid: int = 0, post: string) {
+		fmt.println(pre, mid, post);
+	}
+
+	weird("How many things", 42, "huh?");
+	weird(pre = "Prefix", post = "Pat");
+
+}
+
+
+default_return_values :: proc() {
+	foo :: proc(x: int) -> (first: string = "Hellope", second := "world!") {
+		match x {
+		case 0: return;
+		case 1: return "Goodbye";
+		case 2: return "Goodbye", "cruel world...";
+		case 3: return second = "cruel world...", first = "Goodbye";
+		}
+
+		return second = "my old friend.";
+	}
+
+	fmt.printf("%s %s\n", foo(0));
+	fmt.printf("%s %s\n", foo(1));
+	fmt.printf("%s %s\n", foo(2));
+	fmt.printf("%s %s\n", foo(3));
+	fmt.printf("%s %s\n", foo(4));
+	fmt.println();
+
+
+	// A more "real" example
+	Error :: enum {
+		None,
+		WhyTheNumberThree,
+		TenIsTooBig,
+	};
+
+	Entity :: struct {
+		name: string;
+		id:   u32;
+	}
+
+	some_thing :: proc(input: int) -> (result: ^Entity = nil, err := Error.None) {
+		match {
+		case input == 3:  return err = Error.WhyTheNumberThree;
+		case input >= 10: return err = Error.TenIsTooBig;
+		}
+
+		e := new(Entity);
+		e.id = u32(input);
+
+		return result = e;
+	}
+}
+
+call_location :: proc() {
+	amazing :: proc(n: int, using loc := #caller_location) {
+		fmt.printf("%s(%d:%d) just asked to do something amazing.\n",
+				   fully_pathed_filename, line, column);
+		fmt.printf("Normal -> %d\n", n);
+		fmt.printf("Amazing -> %d\n", n+1);
+		fmt.println();
+	}
+
+	loc := #location(main);
+	fmt.println("`main` is located at", loc);
+
+	fmt.println("This line is located at", #location());
+	fmt.println();
+
+	amazing(3);
+	amazing(4, #location(call_location));
+
+	// See _preload.odin for the implementations of `assert` and `panic`
+
+}
+
+
+explicit_parametric_polymorphic_procedures :: proc() {
+	// This is how `new` is actually implemented, see _preload.odin
+	alloc_type :: proc(T: type) -> ^T do return cast(^T)alloc(size_of(T), align_of(T));
+
+	int_ptr := alloc_type(int);
+	defer free(int_ptr);
+	int_ptr^ = 137;
+	fmt.println(int_ptr, int_ptr^);
+
+	// Named arguments work too!
+	another_ptr := alloc_type(T = f32);
+	defer free(another_ptr);
+
+
+	add :: proc(T: type, args: ...T) -> T {
+		res: T;
+		for arg in args do res += arg;
+		return res;
+	}
+
+	fmt.println("add =", add(int, 1, 2, 3, 4, 5, 6));
+
+	swap :: proc(T: type, a, b: ^T) {
+		tmp := a^;
+		a^ = b^;
+		b^ = tmp;
+	}
+
+	a, b: int = 3, 4;
+	fmt.println("Pre-swap:", a, b);
+	swap(int, &a, &b);
+	fmt.println("Post-swap:", a, b);
+	a, b = b, a; // Or use this syntax for this silly example case
+
+
+	Vector2 :: struct {x, y: f32;};
+	{
+		// A more complicated example using subtyping
+		// Something like this could be used in a game
+
+		Entity :: struct {
+			using position: Vector2;
+			flags:          u64;
+			id:             u64;
+			derived:        any;
+		}
+
+		Rock :: struct {
+			using entity: Entity;
+			heavy: bool;
+		}
+		Door :: struct {
+			using entity: Entity;
+			open:         bool;
+		}
+		Monster :: struct {
+			using entity: Entity;
+			is_robot:     bool;
+			is_zombie:    bool;
+		}
+
+		new_entity :: proc(T: type, x, y: f32) -> ^T {
+			result := new(T);
+			result.derived = result^;
+			result.x = x;
+			result.y = y;
+
+			return result;
+		}
+
+		entities: [dynamic]^Entity;
+
+		rock := new_entity(Rock, 3, 5);
+
+		// Named arguments work too!
+		door := new_entity(T = Door, x = 3, y = 6);
+
+		// And named arguments can be any order
+		monster := new_entity(
+			y = 1,
+			x = 2,
+			T = Monster,
+		);
+
+		append(&entities, rock, door, monster);
+
+		fmt.println("Subtyping");
+		for entity in entities {
+			match e in entity.derived {
+			case Rock:    fmt.println("Rock",    e.x, e.y);
+			case Door:    fmt.println("Door",    e.x, e.y);
+			case Monster: fmt.println("Monster", e.x, e.y);
+			}
+		}
+	}
+	{
+		Entity :: struct {
+			using position: Vector2;
+			flags:          u64;
+			id:             u64;
+			variant: union { Rock, Door, Monster };
+		}
+
+		Rock :: struct {
+			using entity: ^Entity;
+			heavy: bool;
+		}
+		Door :: struct {
+			using entity: ^Entity;
+			open:         bool;
+		}
+		Monster :: struct {
+			using entity: ^Entity;
+			is_robot:     bool;
+			is_zombie:    bool;
+		}
+
+		new_entity :: proc(T: type, x, y: f32) -> ^T {
+			result := new(Entity);
+			result.variant = T{entity = result};
+			result.x = x;
+			result.y = y;
+
+			return cast(^T)&result.variant;
+		}
+
+		entities: [dynamic]^Entity;
+
+		rock := new_entity(Rock, 3, 5);
+
+		// Named arguments work too!
+		door := new_entity(T = Door, x = 3, y = 6);
+
+		// And named arguments can be any order
+		monster := new_entity(
+			y = 1,
+			x = 2,
+			T = Monster,
+		);
+
+		append(&entities, rock, door, monster);
+
+		fmt.println("Union");
+		for entity in entities {
+			match e in entity.variant {
+			case Rock:    fmt.println("Rock",    e.x, e.y);
+			case Door:    fmt.println("Door",    e.x, e.y);
+			case Monster: fmt.println("Monster", e.x, e.y);
+			}
+		}
+	}
+}
+
+
+implicit_polymorphic_assignment :: proc() {
+	yep :: proc(p: proc(x: int)) {
+		p(123);
+	}
+
+	frank :: proc(x: $T)    do fmt.println("frank ->", x);
+	tim   :: proc(x, y: $T) do fmt.println("tim ->", x, y);
+	yep(frank);
+	// yep(tim);
+}
+
+
+
+
+main :: proc() {
+/*
+	foo :: proc(x: i64,  y: f32) do fmt.println("#1", x, y);
+	foo :: proc(x: type, y: f32) do fmt.println("#2", type_info(x), y);
+	foo :: proc(x: type)         do fmt.println("#3", type_info(x));
+
+	f :: foo;
+
+	f(y = 3785.1546, x = 123);
+	f(x = int, y = 897.513);
+	f(x = f32);
+
+	general_stuff();
+	foreign_blocks();
+	default_arguments();
+	named_arguments();
+	default_return_values();
+	call_location();
+	explicit_parametric_polymorphic_procedures();
+	implicit_polymorphic_assignment();
+
+
+	// Command line argument(s)!
+	// -opt=0,1,2,3
+*/
+/*
+	program := "+ + * - /";
+	accumulator := 0;
+
+	for token in program {
+		match token {
+		case '+': accumulator += 1;
+		case '-': accumulator -= 1;
+		case '*': accumulator *= 2;
+		case '/': accumulator /= 2;
+		case: // Ignore everything else
+		}
+	}
+
+	fmt.printf("The program \"%s\" calculates the value %d\n",
+			   program, accumulator);
+*/
+}

examples/punity.odin

@@ -0,0 +1,479 @@
+import win32 "core:sys/windows.odin";
+import "core:fmt.odin";
+import "core:os.odin";
+import "core:mem.odin";
+
+
+CANVAS_WIDTH  :: 128;
+CANVAS_HEIGHT :: 128;
+CANVAS_SCALE  :: 3;
+FRAME_TIME    :: 1.0/30.0;
+WINDOW_TITLE  :: "Punity\x00";
+
+_ :: compile_assert(CANVAS_WIDTH % 16 == 0);
+
+
+WINDOW_WIDTH  :: CANVAS_WIDTH  * CANVAS_SCALE;
+WINDOW_HEIGHT :: CANVAS_HEIGHT * CANVAS_SCALE;
+
+
+STACK_CAPACITY   :: 1<<20;
+STORAGE_CAPACITY :: 1<<20;
+
+DRAW_LIST_RESERVE :: 128;
+
+MAX_KEYS :: 256;
+
+Core :: struct {
+	stack:   ^Bank,
+	storage: ^Bank,
+
+	running:       bool,
+	key_modifiers: u32,
+	key_states:    [MAX_KEYS]u8,
+	key_deltas:    [MAX_KEYS]u8,
+
+	perf_frame,
+	perf_frame_inner,
+	perf_step,
+	perf_audio,
+	perf_blit,
+	perf_blit_cvt,
+	perf_blit_gdi: Perf_Span,
+
+	frame: i64,
+
+	canvas:    Canvas,
+	draw_list: ^Draw_List,
+}
+
+Perf_Span :: struct {
+	stamp: f64,
+	delta: f32,
+}
+
+Bank :: struct {
+	memory: []u8,
+	cursor: int,
+}
+
+Bank_State :: struct {
+	state: Bank,
+	bank: ^Bank,
+}
+
+
+Color :: struct #raw_union {
+	using channels: struct{a, b, g, r: u8},
+	rgba: u32,
+}
+
+Palette :: struct {
+	colors: [256]Color,
+	colors_count: u8,
+}
+
+
+Rect :: struct #raw_union {
+	using minmax: struct {min_x, min_y, max_x, max_y: int},
+	using pos: struct {left, top, right, bottom: int},
+	e: [4]int,
+}
+
+Bitmap :: struct {
+	pixels: []u8,
+	width:  int,
+	height: int,
+}
+
+Font :: struct {
+	using bitmap: Bitmap,
+	char_width:   int,
+	char_height:  int,
+}
+
+Canvas :: struct {
+	using bitmap: ^Bitmap,
+	palette:      Palette,
+	translate_x:  int,
+	translate_y:  int,
+	clip:         Rect,
+	font:         ^Font,
+}
+
+DrawFlag :: enum {
+	NONE   = 0,
+	FLIP_H = 1<<0,
+	FLIP_V = 1<<1,
+	MASK   = 1<<2,
+}
+
+Draw_Item :: struct {}
+Draw_List :: struct {
+	items: []Draw_Item,
+}
+
+Key :: enum {
+	Mod_Shift   = 0x0001,
+	Mod_Control = 0x0002,
+	Mod_Alt     = 0x0004,
+	Mod_Super   = 0x0008,
+
+
+	Unknown            =-1,
+	Invalid            =-2,
+
+
+	Lbutton            = 1,
+	Rbutton            = 2,
+	Cancel             = 3,
+	Mbutton            = 4,
+
+
+	Back               = 8,
+	Tab                = 9,
+	Clear              = 12,
+	Return             = 13,
+	Shift              = 16,
+	Control            = 17,
+	Menu               = 18,
+	Pause              = 19,
+	Capital            = 20,
+	Kana               = 0x15,
+	Hangeul            = 0x15,
+	Hangul             = 0x15,
+	Junja              = 0x17,
+	Final              = 0x18,
+	Hanja              = 0x19,
+	Kanji              = 0x19,
+	Escape             = 0x1B,
+	Convert            = 0x1C,
+	Non_Convert        = 0x1D,
+	Accept             = 0x1E,
+	Mode_Change        = 0x1F,
+	Space              = 32,
+	Prior              = 33,
+	Next               = 34,
+	End                = 35,
+	Home               = 36,
+	Left               = 37,
+	Up                 = 38,
+	Right              = 39,
+	Down               = 40,
+	Select             = 41,
+	Print              = 42,
+	Exec               = 43,
+	Snapshot           = 44,
+	Insert             = 45,
+	Delete             = 46,
+	Help               = 47,
+	Lwin               = 0x5B,
+	Rwin               = 0x5C,
+	Apps               = 0x5D,
+	Sleep              = 0x5F,
+	Numpad0            = 0x60,
+	Numpad1            = 0x61,
+	Numpad2            = 0x62,
+	Numpad3            = 0x63,
+	Numpad4            = 0x64,
+	Numpad5            = 0x65,
+	Numpad6            = 0x66,
+	Numpad7            = 0x67,
+	Numpad8            = 0x68,
+	Numpad9            = 0x69,
+	Multiply           = 0x6A,
+	Add                = 0x6B,
+	Separator          = 0x6C,
+	Subtract           = 0x6D,
+	Decimal            = 0x6E,
+	Divide             = 0x6F,
+	F1                 = 0x70,
+	F2                 = 0x71,
+	F3                 = 0x72,
+	F4                 = 0x73,
+	F5                 = 0x74,
+	F6                 = 0x75,
+	F7                 = 0x76,
+	F8                 = 0x77,
+	F9                 = 0x78,
+	F10                = 0x79,
+	F11                = 0x7A,
+	F12                = 0x7B,
+	F13                = 0x7C,
+	F14                = 0x7D,
+	F15                = 0x7E,
+	F16                = 0x7F,
+	F17                = 0x80,
+	F18                = 0x81,
+	F19                = 0x82,
+	F20                = 0x83,
+	F21                = 0x84,
+	F22                = 0x85,
+	F23                = 0x86,
+	F24                = 0x87,
+	Numlock            = 0x90,
+	Scroll             = 0x91,
+	Lshift             = 0xA0,
+	Rshift             = 0xA1,
+	Lcontrol           = 0xA2,
+	Rcontrol           = 0xA3,
+	Lmenu              = 0xA4,
+	Rmenu              = 0xA5,
+
+
+	Apostrophe         = 39,  /* ' */
+	Comma              = 44,  /* , */
+	Minus              = 45,  /* - */
+	Period             = 46,  /* . */
+	Slash              = 47,  /* / */
+	Num0               = 48,
+	Num1               = 49,
+	Num2               = 50,
+	Num3               = 51,
+	Num4               = 52,
+	Num5               = 53,
+	Num6               = 54,
+	Num7               = 55,
+	Num8               = 56,
+	Num9               = 57,
+	Semicolon          = 59,  /* ; */
+	Equal              = 61,  /* = */
+	A                  = 65,
+	B                  = 66,
+	C                  = 67,
+	D                  = 68,
+	E                  = 69,
+	F                  = 70,
+	G                  = 71,
+	H                  = 72,
+	I                  = 73,
+	J                  = 74,
+	K                  = 75,
+	L                  = 76,
+	M                  = 77,
+	N                  = 78,
+	O                  = 79,
+	P                  = 80,
+	Q                  = 81,
+	R                  = 82,
+	S                  = 83,
+	T                  = 84,
+	U                  = 85,
+	V                  = 86,
+	W                  = 87,
+	X                  = 88,
+	Y                  = 89,
+	Z                  = 90,
+	Left_Bracket       = 91,  /* [ */
+	Backslash          = 92,  /* \ */
+	Right_Bracket      = 93,  /* ] */
+	Grave_Accent       = 96,  /* ` */
+};
+
+
+key_down :: proc(k: Key) -> bool {
+	return _core.key_states[k] != 0;
+}
+
+key_pressed :: proc(k: Key) -> bool {
+	return (_core.key_deltas[k] != 0) && key_down(k);
+}
+
+
+
+
+win32_perf_count_freq := win32.get_query_performance_frequency();
+time_now :: proc() -> f64 {
+	assert(win32_perf_count_freq != 0);
+
+	counter: i64;
+	win32.query_performance_counter(&counter);
+	return f64(counter) / f64(win32_perf_count_freq);
+}
+
+_core: Core;
+
+run :: proc(user_init, user_step: proc(c: ^Core)) {
+	using win32;
+
+	_core.running = true;
+
+	win32_proc :: proc(hwnd: win32.Hwnd, msg: u32, wparam: win32.Wparam, lparam: win32.Lparam) -> win32.Lresult #no_inline #cc_c {
+		win32_app_key_mods :: proc() -> u32 {
+			mods: u32 = 0;
+
+			if is_key_down(Key_Code.Shift)   do mods |= u32(Key.Mod_Shift);
+			if is_key_down(Key_Code.Control) do mods |= u32(Key.Mod_Control);
+			if is_key_down(Key_Code.Menu)    do mods |= u32(Key.Mod_Alt);
+			if is_key_down(Key_Code.Lwin)    do mods |= u32(Key.Mod_Super);
+			if is_key_down(Key_Code.Rwin)    do mods |= u32(Key.Mod_Super);
+
+			return mods;
+		}
+
+		match msg {
+		case WM_KEYDOWN:
+			_core.key_modifiers = win32_app_key_mods();
+			if wparam < MAX_KEYS {
+				_core.key_states[wparam] = 1;
+				_core.key_deltas[wparam] = 1;
+			}
+			return 0;
+
+		case WM_KEYUP:
+			_core.key_modifiers = win32_app_key_mods();
+			if wparam < MAX_KEYS {
+				_core.key_states[wparam] = 0;
+				_core.key_deltas[wparam] = 1;
+			}
+			return 0;
+
+		case WM_CLOSE:
+			post_quit_message(0);
+			_core.running = false;
+			return 0;
+		}
+
+		return def_window_proc_a(hwnd, msg, wparam, lparam);
+	}
+
+
+	class_name := "Punity\x00";
+	window_class := Wnd_Class_Ex_A{
+		class_name = &class_name[0],
+		size       = size_of(Wnd_Class_Ex_A),
+		style      = CS_HREDRAW | CS_VREDRAW | CS_OWNDC,
+		instance   = Hinstance(get_module_handle_a(nil)),
+		wnd_proc   = win32_proc,
+		background = Hbrush(get_stock_object(BLACK_BRUSH)),
+	};
+
+	if register_class_ex_a(&window_class) == 0 {
+		fmt.fprintln(os.stderr, "register_class_ex_a failed");
+		return;
+	}
+
+	screen_width  := get_system_metrics(SM_CXSCREEN);
+	screen_height := get_system_metrics(SM_CYSCREEN);
+
+	rc: Rect;
+	rc.left   = (screen_width - WINDOW_WIDTH)   / 2;
+	rc.top    = (screen_height - WINDOW_HEIGHT) / 2;
+	rc.right  = rc.left + WINDOW_WIDTH;
+	rc.bottom = rc.top + WINDOW_HEIGHT;
+
+	style: u32 = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
+	assert(adjust_window_rect(&rc, style, 0) != 0);
+
+	wt := WINDOW_TITLE;
+
+	win32_window := create_window_ex_a(0,
+	                                   window_class.class_name,
+	                                   &wt[0],
+	                                   style,
+	                                   rc.left, rc.top,
+	                                   rc.right-rc.left, rc.bottom-rc.top,
+	                                   nil, nil, window_class.instance,
+	                                   nil);
+
+	if win32_window == nil {
+		fmt.fprintln(os.stderr, "create_window_ex_a failed");
+		return;
+	}
+
+
+	window_bmi: Bitmap_Info;
+	window_bmi.size        = size_of(Bitmap_Info_Header);
+	window_bmi.width       = CANVAS_WIDTH;
+	window_bmi.height      = CANVAS_HEIGHT;
+	window_bmi.planes      = 1;
+	window_bmi.bit_count   = 32;
+	window_bmi.compression = BI_RGB;
+
+
+	user_init(&_core);
+
+	show_window(win32_window, SW_SHOW);
+
+	window_buffer := make([]u32, CANVAS_WIDTH * CANVAS_HEIGHT);
+	defer free(window_buffer);
+
+	for _, i in window_buffer do window_buffer[i] = 0xff00ff;
+
+	dt: f64;
+	prev_time := time_now();
+	curr_time := time_now();
+	total_time: f64 = 0;
+	offset_x := 0;
+	offset_y := 0;
+
+	message: Msg;
+	for _core.running {
+		curr_time = time_now();
+		dt = curr_time - prev_time;
+		prev_time = curr_time;
+		total_time += dt;
+
+		offset_x += 1;
+		offset_y += 2;
+
+		{
+			buf: [128]u8;
+			s := fmt.bprintf(buf[..], "Punity: %.4f ms\x00", dt*1000);
+			win32.set_window_text_a(win32_window, &s[0]);
+		}
+
+
+		for y in 0..CANVAS_HEIGHT {
+			for x in 0..CANVAS_WIDTH {
+				g := (x % 32) * 8;
+				b := (y % 32) * 8;
+				window_buffer[x + y*CANVAS_WIDTH] = u32(g << 8 | b);
+			}
+		}
+
+		mem.zero(&_core.key_deltas[0], size_of(_core.key_deltas));
+
+		for peek_message_a(&message, nil, 0, 0, PM_REMOVE) != 0 {
+			if message.message == WM_QUIT {
+				_core.running = false;
+			}
+			translate_message(&message);
+			dispatch_message_a(&message);
+		}
+
+		user_step(&_core);
+
+		dc := get_dc(win32_window);
+		stretch_dibits(dc,
+		               0, 0, CANVAS_WIDTH * CANVAS_SCALE, CANVAS_HEIGHT * CANVAS_SCALE,
+		               0, 0, CANVAS_WIDTH, CANVAS_HEIGHT,
+		               &window_buffer[0],
+		               &window_bmi,
+		               DIB_RGB_COLORS,
+		               SRCCOPY);
+		release_dc(win32_window, dc);
+
+
+
+		delta := time_now() - prev_time;
+		if ms := i32((FRAME_TIME - delta) * 1000); ms > 0 {
+			win32.sleep(ms);
+		}
+
+		_core.frame += 1;
+	}
+}
+
+
+main :: proc() {
+	user_init :: proc(c: ^Core) {
+
+	}
+
+	user_step :: proc(c: ^Core) {
+
+	}
+
+	run(user_init, user_step);
+}

misc/shell.bat

@@ -1,7 +1,10 @@
 @echo off
 
+rem call "C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\vcvarsall.bat" x86 1> NUL
+rem call "C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\vcvarsall.bat" x64 1> NUL
 call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" x64 1> NUL
 rem call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvarsall.bat" x86 1> NUL
+rem call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvarsall.bat" x64 1> NUL
 set _NO_DEBUG_HEAP=1
 
 set path=w:\Odin\misc;%path%

src/array.cpp

@@ -1,98 +1,7 @@
 #define ARRAY_GROW_FORMULA(x) (2*(x) + 8)
 GB_STATIC_ASSERT(ARRAY_GROW_FORMULA(0) > 0);
 
-#define Array(Type_) struct { \
+#if 1
-	gbAllocator allocator; \
-	Type_ *     e; \
-	isize       count; \
-	isize       capacity; \
-}
-
-typedef Array(void) ArrayVoid;
-
-#define array_init_reserve(x_, allocator_, init_capacity_) do { \
-	void **e = cast(void **)&((x_)->e); \
-	GB_ASSERT((x_) != NULL); \
-	(x_)->allocator = (allocator_); \
-	(x_)->count = 0; \
-	(x_)->capacity = (init_capacity_); \
-	*e = gb_alloc((allocator_), gb_size_of(*(x_)->e)*(init_capacity_)); \
-} while (0)
-
-#define array_init_count(x_, allocator_, init_count_) do { \
-	void **e = cast(void **)&((x_)->e); \
-	GB_ASSERT((x_) != NULL); \
-	(x_)->allocator = (allocator_); \
-	(x_)->count = (init_count_); \
-	(x_)->capacity = (init_count_); \
-	*e = gb_alloc((allocator_), gb_size_of(*(x_)->e)*(init_count_)); \
-} while (0)
-
-#define array_init(x_, allocator_)        do { array_init_reserve(x_, allocator_, ARRAY_GROW_FORMULA(0)); } while (0)
-#define array_free(x_)                    do { gb_free((x_)->allocator, (x_)->e); } while (0)
-#define array_set_capacity(x_, capacity_) do { array__set_capacity((x_), (capacity_), gb_size_of(*(x_)->e)); } while (0)
-
-#define array_grow(x_, min_capacity_) do { \
-	isize new_capacity = ARRAY_GROW_FORMULA((x_)->capacity); \
-	if (new_capacity < (min_capacity_)) { \
-		new_capacity = (min_capacity_); \
-	} \
-	array_set_capacity(x_, new_capacity); \
-} while (0)
-
-#define array_add(x_, item_) do { \
-	if ((x_)->capacity < (x_)->count+1) { \
-		array_grow(x_, 0); \
-	} \
-	(x_)->e[(x_)->count++] = item_; \
-} while (0)
-
-#define array_pop(x_)   do { GB_ASSERT((x_)->count > 0); (x_)->count--; } while (0)
-#define array_clear(x_) do { (x_)->count = 0; } while (0)
-
-#define array_resize(x_, new_count_) do { \
-	if ((x_)->capacity < (new_count_)) { \
-		array_grow((x_), (new_count_)); \
-	} \
-	(x_)->count = (new_count_); \
-} while (0)
-
-#define array_reserve(x_, new_capacity_) do { \
-	if ((x_)->capacity < (new_capacity_)) { \
-		array_set_capacity((x_), (new_capacity_)); \
-	} \
-} while (0)
-
-
-
-
-void array__set_capacity(void *ptr, isize capacity, isize element_size) {
-	ArrayVoid *x = cast(ArrayVoid *)ptr;
-	GB_ASSERT(ptr != NULL);
-
-	GB_ASSERT(element_size > 0);
-
-	if (capacity == x->capacity) {
-		return;
-	}
-
-	if (capacity < x->count) {
-		if (x->capacity < capacity) {
-			isize new_capacity = ARRAY_GROW_FORMULA(x->capacity);
-			if (new_capacity < capacity) {
-				new_capacity = capacity;
-			}
-			array__set_capacity(ptr, new_capacity, element_size);
-		}
-		x->count = capacity;
-	}
-
-	x->e = gb_resize(x->allocator, x->e, element_size*x->capacity, element_size*capacity);
-	x->capacity = capacity;
-}
-
-
-#if 0
 template <typename T>
 struct Array {
 	gbAllocator allocator;
@@ -101,12 +10,16 @@ struct Array {
 	isize       capacity;
 
 	T &operator[](isize index) {
-		GB_ASSERT_MSG(0 <= index && index < count, "Index out of bounds");
+		#if !defined(NO_ARRAY_BOUNDS_CHECK)
+			GB_ASSERT_MSG(0 <= index && index < count, "Index %td is out of bounds ranges 0..<%td", index, count);
+		#endif
 		return data[index];
 	}
 
 	T const &operator[](isize index) const {
-		GB_ASSERT_MSG(0 <= index && index < count, "Index out of bounds");
+		#if !defined(NO_ARRAY_BOUNDS_CHECK)
+			GB_ASSERT_MSG(0 <= index && index < count, "Index %td is out of bounds ranges 0..<%td", index, count);
+		#endif
 		return data[index];
 	}
 };
@@ -122,7 +35,6 @@ template <typename T> void     array_reserve     (Array<T> *array, isize capacit
 template <typename T> void     array_resize      (Array<T> *array, isize count);
 template <typename T> void     array_set_capacity(Array<T> *array, isize capacity);
 
-
 template <typename T>
 void array_init(Array<T> *array, gbAllocator a, isize init_capacity) {
 	array->allocator = a;
@@ -152,7 +64,7 @@ Array<T> array_make(T *data, isize count, isize capacity) {
 
 template <typename T>
 void array_free(Array<T> *array) {
-	if (array->allocator.proc != NULL) {
+	if (array->allocator.proc != nullptr) {
 		gb_free(array->allocator, array->data);
 	}
 	array->count = 0;
@@ -214,7 +126,7 @@ void array_set_capacity(Array<T> *array, isize capacity) {
 		array_resize(array, capacity);
 	}
 
-	T *new_data = NULL;
+	T *new_data = nullptr;
 	if (capacity > 0) {
 		new_data = gb_alloc_array(array->allocator, T, capacity);
 		gb_memmove(new_data, array->data, gb_size_of(T) * array->capacity);
@@ -224,6 +136,97 @@ void array_set_capacity(Array<T> *array, isize capacity) {
 	array->capacity = capacity;
 }
 
-
-
 #endif
+
+#if 0
+#define Array(Type_) struct { \
+	gbAllocator allocator; \
+	Type_ *     e; \
+	isize       count; \
+	isize       capacity; \
+}
+
+typedef Array(void) ArrayVoid;
+
+#define array_init_reserve(x_, allocator_, init_capacity_) do { \
+	void **e = cast(void **)&((x_)->e); \
+	GB_ASSERT((x_) != nullptr); \
+	(x_)->allocator = (allocator_); \
+	(x_)->count = 0; \
+	(x_)->capacity = (init_capacity_); \
+	*e = gb_alloc((allocator_), gb_size_of(*(x_)->e)*(init_capacity_)); \
+} while (0)
+
+#define array_init_count(x_, allocator_, init_count_) do { \
+	void **e = cast(void **)&((x_)->e); \
+	GB_ASSERT((x_) != nullptr); \
+	(x_)->allocator = (allocator_); \
+	(x_)->count = (init_count_); \
+	(x_)->capacity = (init_count_); \
+	*e = gb_alloc((allocator_), gb_size_of(*(x_)->e)*(init_count_)); \
+} while (0)
+
+#define array_init(x_, allocator_)        do { array_init_reserve(x_, allocator_, ARRAY_GROW_FORMULA(0)); } while (0)
+#define array_free(x_)                    do { gb_free((x_)->allocator, (x_)->e); } while (0)
+#define array_set_capacity(x_, capacity_) do { array__set_capacity((x_), (capacity_), gb_size_of(*(x_)->e)); } while (0)
+
+#define array_grow(x_, min_capacity_) do { \
+	isize new_capacity = ARRAY_GROW_FORMULA((x_)->capacity); \
+	if (new_capacity < (min_capacity_)) { \
+		new_capacity = (min_capacity_); \
+	} \
+	array_set_capacity(x_, new_capacity); \
+} while (0)
+
+#define array_add(x_, item_) do { \
+	if ((x_)->capacity < (x_)->count+1) { \
+		array_grow(x_, 0); \
+	} \
+	(x_)->e[(x_)->count++] = item_; \
+} while (0)
+
+#define array_pop(x_)   do { GB_ASSERT((x_)->count > 0); (x_)->count--; } while (0)
+#define array_clear(x_) do { (x_)->count = 0; } while (0)
+
+#define array_resize(x_, new_count_) do { \
+	if ((x_)->capacity < (new_count_)) { \
+		array_grow((x_), (new_count_)); \
+	} \
+	(x_)->count = (new_count_); \
+} while (0)
+
+#define array_reserve(x_, new_capacity_) do { \
+	if ((x_)->capacity < (new_capacity_)) { \
+		array_set_capacity((x_), (new_capacity_)); \
+	} \
+} while (0)
+
+
+
+
+void array__set_capacity(void *ptr, isize capacity, isize element_size) {
+	ArrayVoid *x = cast(ArrayVoid *)ptr;
+	GB_ASSERT(ptr != nullptr);
+
+	GB_ASSERT(element_size > 0);
+
+	if (capacity == x->capacity) {
+		return;
+	}
+
+	if (capacity < x->count) {
+		if (x->capacity < capacity) {
+			isize new_capacity = ARRAY_GROW_FORMULA(x->capacity);
+			if (new_capacity < capacity) {
+				new_capacity = capacity;
+			}
+			array__set_capacity(ptr, new_capacity, element_size);
+		}
+		x->count = capacity;
+	}
+
+	x->e = gb_resize(x->allocator, x->e, element_size*x->capacity, element_size*capacity);
+	x->capacity = capacity;
+}
+#endif
+

src/build_settings.cpp

@@ -1,5 +1,5 @@
 // This stores the information for the specify architecture of this build
-typedef struct BuildContext {
+struct BuildContext {
 	// Constants
 	String ODIN_OS;      // target operating system
 	String ODIN_ARCH;    // target architecture
@@ -12,15 +12,48 @@ typedef struct BuildContext {
 	i64    word_size; // Size of a pointer, must be >= 4
 	i64    max_align; // max alignment, must be >= 1 (and typically >= word_size)
 
+	String command;
+
+	String opt_flags;
 	String llc_flags;
 	String link_flags;
 	bool   is_dll;
-} BuildContext;
+	bool   generate_docs;
+	i32    optimization_level;
+	bool   show_timings;
+	bool   keep_temp_files;
+
+	gbAffinity affinity;
+	isize      thread_count;
+};
 
 
 gb_global BuildContext build_context = {0};
 
 
+struct LibraryCollections {
+	String name;
+	String path;
+};
+
+gb_global Array<LibraryCollections> library_collections = {0};
+
+void add_library_collection(String name, String path) {
+	// TODO(bill): Check the path is valid and a directory
+	LibraryCollections lc = {name, string_trim_whitespace(path)};
+	array_add(&library_collections, lc);
+}
+
+bool find_library_collection_path(String name, String *path) {
+	for_array(i, library_collections) {
+		if (library_collections[i].name == name) {
+			if (path) *path = library_collections[i].path;
+			return true;
+		}
+	}
+	return false;
+}
+
 
 // TODO(bill): OS dependent versions for the BuildContext
 // join_path
@@ -35,7 +68,7 @@ String const NIX_SEPARATOR_STRING   = {cast(u8 *)"/",  1};
 #if defined(GB_SYSTEM_WINDOWS)
 String odin_root_dir(void) {
 	String path = global_module_path;
-	Array(wchar_t) path_buf;
+	Array<wchar_t> path_buf;
 	isize len, i;
 	gbTempArenaMemory tmp;
 	wchar_t *text;
@@ -48,24 +81,30 @@ String odin_root_dir(void) {
 
 	len = 0;
 	for (;;) {
-		len = GetModuleFileNameW(NULL, &path_buf.e[0], path_buf.count);
+		len = GetModuleFileNameW(nullptr, &path_buf[0], cast(int)path_buf.count);
 		if (len == 0) {
-			return make_string(NULL, 0);
+			return make_string(nullptr, 0);
 		}
 		if (len < path_buf.count) {
 			break;
 		}
 		array_resize(&path_buf, 2*path_buf.count + 300);
 	}
+	len += 1; // NOTE(bill): It needs an extra 1 for some reason
+
+	gb_mutex_lock(&string_buffer_mutex);
+	defer (gb_mutex_unlock(&string_buffer_mutex));
 
 	tmp = gb_temp_arena_memory_begin(&string_buffer_arena);
+	defer (gb_temp_arena_memory_end(tmp));
 
 	text = gb_alloc_array(string_buffer_allocator, wchar_t, len+1);
 
-	GetModuleFileNameW(NULL, text, len);
+	GetModuleFileNameW(nullptr, text, cast(int)len);
 	path = string16_to_string(heap_allocator(), make_string16(text, len));
+
 	for (i = path.len-1; i >= 0; i--) {
-		u8 c = path.text[i];
+		u8 c = path[i];
 		if (c == '/' || c == '\\') {
 			break;
 		}
@@ -75,7 +114,6 @@ String odin_root_dir(void) {
 	global_module_path = path;
 	global_module_path_set = true;
 
-	gb_temp_arena_memory_end(tmp);
 
 	array_free(&path_buf);
 
@@ -88,60 +126,7 @@ String odin_root_dir(void) {
 
 String odin_root_dir(void) {
 	String path = global_module_path;
-	Array(char) path_buf;
+	Array<char> path_buf;
-	isize len, i;
-	gbTempArenaMemory tmp;
-	wchar_t *text;
-
-	if (global_module_path_set) {
-		return global_module_path;
-	}
-
-	array_init_count(&path_buf, heap_allocator(), 300);
-
-	len = 0;
-	for (;;) {
-		int sz = path_buf.count;
-		int res = _NSGetExecutablePath(&path_buf.e[0], &sz);
-		if(res == 0) {
-			len = sz;
-			break;
-		} else {
-			array_resize(&path_buf, sz + 1);
-		}
-	}
-
-
-	tmp = gb_temp_arena_memory_begin(&string_buffer_arena);
-	text = gb_alloc_array(string_buffer_allocator, u8, len + 1);
-	gb_memmove(text, &path_buf.e[0], len);
-
-	path = make_string(text, len);
-	for (i = path.len-1; i >= 0; i--) {
-		u8 c = path.text[i];
-		if (c == '/' || c == '\\') {
-			break;
-		}
-		path.len--;
-	}
-
-	global_module_path = path;
-	global_module_path_set = true;
-
-	gb_temp_arena_memory_end(tmp);
-
-	// array_free(&path_buf);
-
-	return path;
-}
-#else
-
-// NOTE: Linux / Unix is unfinished and not tested very well.
-#include <sys/stat.h>
-
-String odin_root_dir(void) {
-	String path = global_module_path;
-	Array(char) path_buf;
 	isize len, i;
 	gbTempArenaMemory tmp;
 	u8 *text;
@@ -154,28 +139,28 @@ String odin_root_dir(void) {
 
 	len = 0;
 	for (;;) {
-		// This is not a 100% reliable system, but for the purposes
+		u32 sz = path_buf.count;
-		// of this compiler, it should be _good enough_.
+		int res = _NSGetExecutablePath(&path_buf[0], &sz);
-		// That said, there's no solid 100% method on Linux to get the program's
+		if(res == 0) {
-		// path without checking this link. Sorry.
+			len = sz;
-		len = readlink("/proc/self/exe", &path_buf.e[0], path_buf.count);
-		if(len == 0) {
-			return make_string(NULL, 0);
-		}
-		if (len < path_buf.count) {
 			break;
+		} else {
+			array_resize(&path_buf, sz + 1);
 		}
-		array_resize(&path_buf, 2*path_buf.count + 300);
 	}
 
+	gb_mutex_lock(&string_buffer_mutex);
+	defer (gb_mutex_unlock(&string_buffer_mutex));
 
 	tmp = gb_temp_arena_memory_begin(&string_buffer_arena);
+	defer (gb_temp_arena_memory_end(tmp));
+
 	text = gb_alloc_array(string_buffer_allocator, u8, len + 1);
-	gb_memmove(text, &path_buf.e[0], len);
+	gb_memmove(text, &path_buf[0], len);
 
 	path = make_string(text, len);
 	for (i = path.len-1; i >= 0; i--) {
-		u8 c = path.text[i];
+		u8 c = path[i];
 		if (c == '/' || c == '\\') {
 			break;
 		}
@@ -185,9 +170,67 @@ String odin_root_dir(void) {
 	global_module_path = path;
 	global_module_path_set = true;
 
-	gb_temp_arena_memory_end(tmp);
 
-	array_free(&path_buf);
+	// array_free(&path_buf);
+
+	return path;
+}
+#else
+
+// NOTE: Linux / Unix is unfinished and not tested very well.
+#include <sys/stat.h>
+
+String odin_root_dir(void) {
+	String path = global_module_path;
+	Array<char> path_buf;
+	isize len, i;
+	gbTempArenaMemory tmp;
+	u8 *text;
+
+	if (global_module_path_set) {
+		return global_module_path;
+	}
+
+	array_init_count(&path_buf, heap_allocator(), 300);
+	defer (array_free(&path_buf));
+
+	len = 0;
+	for (;;) {
+		// This is not a 100% reliable system, but for the purposes
+		// of this compiler, it should be _good enough_.
+		// That said, there's no solid 100% method on Linux to get the program's
+		// path without checking this link. Sorry.
+		len = readlink("/proc/self/exe", &path_buf[0], path_buf.count);
+		if(len == 0) {
+			return make_string(nullptr, 0);
+		}
+		if (len < path_buf.count) {
+			break;
+		}
+		array_resize(&path_buf, 2*path_buf.count + 300);
+	}
+
+	gb_mutex_lock(&string_buffer_mutex);
+	defer (gb_mutex_unlock(&string_buffer_mutex));
+
+	tmp = gb_temp_arena_memory_begin(&string_buffer_arena);
+	defer (gb_temp_arena_memory_end(tmp));
+
+	text = gb_alloc_array(string_buffer_allocator, u8, len + 1);
+
+	gb_memmove(text, &path_buf[0], len);
+
+	path = make_string(text, len);
+	for (i = path.len-1; i >= 0; i--) {
+		u8 c = path[i];
+		if (c == '/' || c == '\\') {
+			break;
+		}
+		path.len--;
+	}
+
+	global_module_path = path;
+	global_module_path_set = true;
 
 	return path;
 }
@@ -196,14 +239,17 @@ String odin_root_dir(void) {
 
 #if defined(GB_SYSTEM_WINDOWS)
 String path_to_fullpath(gbAllocator a, String s) {
+	String result = {};
+	gb_mutex_lock(&string_buffer_mutex);
+	defer (gb_mutex_unlock(&string_buffer_mutex));
+
 	gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&string_buffer_arena);
 	String16 string16 = string_to_string16(string_buffer_allocator, s);
-	String result = {0};
 
-	DWORD len = GetFullPathNameW(string16.text, 0, NULL, NULL);
+	DWORD len = GetFullPathNameW(&string16[0], 0, nullptr, nullptr);
 	if (len != 0) {
 		wchar_t *text = gb_alloc_array(string_buffer_allocator, wchar_t, len+1);
-		GetFullPathNameW(string16.text, len, text, NULL);
+		GetFullPathNameW(&string16[0], len, text, nullptr);
 		text[len] = 0;
 		result = string16_to_string(a, make_string16(text, len));
 	}
@@ -212,9 +258,11 @@ String path_to_fullpath(gbAllocator a, String s) {
 }
 #elif defined(GB_SYSTEM_OSX) || defined(GB_SYSTEM_UNIX)
 String path_to_fullpath(gbAllocator a, String s) {
-	char *p = realpath(cast(char *)s.text, 0);
+	char *p;
-	if(p == NULL) return make_string_c("");
+	gb_mutex_lock(&string_buffer_mutex);
-
+	p = realpath(cast(char *)s.text, 0);
+	gb_mutex_unlock(&string_buffer_mutex);
+	if(p == nullptr) return make_string_c("");
 	return make_string_c(p);
 }
 #else
@@ -223,106 +271,137 @@ String path_to_fullpath(gbAllocator a, String s) {
 
 
 String get_fullpath_relative(gbAllocator a, String base_dir, String path) {
-	String res = {0};
+	u8 *str = gb_alloc_array(heap_allocator(), u8, base_dir.len+1+path.len+1);
-	isize str_len = base_dir.len+path.len;
+	defer (gb_free(heap_allocator(), str));
-
-	u8 *str = gb_alloc_array(heap_allocator(), u8, str_len+1);
 
 	isize i = 0;
 	gb_memmove(str+i, base_dir.text, base_dir.len); i += base_dir.len;
-	gb_memmove(str+i, path.text, path.len);
+	gb_memmove(str+i, "/", 1);                      i += 1;
-	str[str_len] = '\0';
+	gb_memmove(str+i, path.text,     path.len);     i += path.len;
-	res = path_to_fullpath(a, make_string(str, str_len));
+	str[i] = 0;
-	gb_free(heap_allocator(), str);
+
-	return res;
+	String res = make_string(str, i);
+	res = string_trim_whitespace(res);
+	return path_to_fullpath(a, res);
 }
 
+
 String get_fullpath_core(gbAllocator a, String path) {
 	String module_dir = odin_root_dir();
-	String res = {0};
 
-	char core[] = "core/";
+	String core = str_lit("core/");
-	isize core_len = gb_size_of(core)-1;
 
-	isize str_len = module_dir.len + core_len + path.len;
+	isize str_len = module_dir.len + core.len + path.len;
 	u8 *str = gb_alloc_array(heap_allocator(), u8, str_len+1);
+	defer (gb_free(heap_allocator(), str));
 
-	gb_memmove(str, module_dir.text, module_dir.len);
+	isize i = 0;
-	gb_memmove(str+module_dir.len, core, core_len);
+	gb_memmove(str+i, module_dir.text, module_dir.len); i += module_dir.len;
-	gb_memmove(str+module_dir.len+core_len, path.text, path.len);
+	gb_memmove(str+i, core.text, core.len);             i += core.len;
-	str[str_len] = '\0';
+	gb_memmove(str+i, path.text, path.len);             i += path.len;
+	str[i] = 0;
 
-	res = path_to_fullpath(a, make_string(str, str_len));
+	String res = make_string(str, i);
-	gb_free(heap_allocator(), str);
+	res = string_trim_whitespace(res);
-	return res;
+	return path_to_fullpath(a, res);
 }
 
 
-
+String const ODIN_VERSION = str_lit("0.7.1");
 
 void init_build_context(void) {
 	BuildContext *bc = &build_context;
+
+	gb_affinity_init(&bc->affinity);
+	if (bc->thread_count == 0) {
+		bc->thread_count = gb_max(bc->affinity.thread_count, 1);
+	}
+
 	bc->ODIN_VENDOR  = str_lit("odin");
-	bc->ODIN_VERSION = str_lit("0.3.0");
+	bc->ODIN_VERSION = ODIN_VERSION;
 	bc->ODIN_ROOT    = odin_root_dir();
 
 #if defined(GB_SYSTEM_WINDOWS)
 	bc->ODIN_OS      = str_lit("windows");
-	bc->ODIN_ARCH    = str_lit("amd64");
-	bc->ODIN_ENDIAN  = str_lit("little");
 #elif defined(GB_SYSTEM_OSX)
 	bc->ODIN_OS      = str_lit("osx");
-	bc->ODIN_ARCH    = str_lit("amd64");
-	bc->ODIN_ENDIAN  = str_lit("little");
 #else
 	bc->ODIN_OS      = str_lit("linux");
-	bc->ODIN_ARCH    = str_lit("amd64");
-	bc->ODIN_ENDIAN  = str_lit("little");
 #endif
 
+#if defined(GB_ARCH_64_BIT)
+	bc->ODIN_ARCH = str_lit("amd64");
+#else
+	bc->ODIN_ARCH = str_lit("x86");
+#endif
+
+	{
+		u16 x = 1;
+		bool big = !(*cast(u8 *)&x);
+		bc->ODIN_ENDIAN = big ? str_lit("big") : str_lit("little");
+	}
 
 
 	// NOTE(zangent): The linker flags to set the build architecture are different
 	// across OSs. It doesn't make sense to allocate extra data on the heap
 	// here, so I just #defined the linker flags to keep things concise.
 	#if defined(GB_SYSTEM_WINDOWS)
-
+		#define LINK_FLAG_X64 "/machine:x64"
-	#define LINK_FLAG_X64 "/machine:x64"
+		#define LINK_FLAG_X86 "/machine:x86"
-	#define LINK_FLAG_X86 "/machine:x86"
 
 	#elif defined(GB_SYSTEM_OSX)
+		// NOTE(zangent): MacOS systems are x64 only, so ld doesn't have
+		// an architecture option. All compilation done on MacOS must be x64.
+		GB_ASSERT(bc->ODIN_ARCH == "amd64");
 
-	// NOTE(zangent): MacOS systems are x64 only, so ld doesn't have
+		#define LINK_FLAG_X64 ""
-	// an architecture option. All compilation done on MacOS must be x64.
+		#define LINK_FLAG_X86 ""
-	GB_ASSERT(str_eq(bc->ODIN_ARCH, str_lit("amd64")));
-
-	#define LINK_FLAG_X64 ""
-	#define LINK_FLAG_X86 ""
 	#else
-	// Linux, but also BSDs and the like.
+		// Linux, but also BSDs and the like.
-	// NOTE(zangent): When clang is swapped out with ld as the linker,
+		// NOTE(zangent): When clang is swapped out with ld as the linker,
-	//   the commented flags here should be used. Until then, we'll have
+		//   the commented flags here should be used. Until then, we'll have
-	//   to use alternative build flags made for clang.
+		//   to use alternative build flags made for clang.
-	/*
+		/*
-		#define LINK_FLAG_X64 "-m elf_x86_64"
+			#define LINK_FLAG_X64 "-m elf_x86_64"
-		#define LINK_FLAG_X86 "-m elf_i386"
+			#define LINK_FLAG_X86 "-m elf_i386"
-	*/
+		*/
-	#define LINK_FLAG_X64 "-arch x86-64"
+		#define LINK_FLAG_X64 "-arch x86-64"
-	#define LINK_FLAG_X86 "-arch x86"
+		#define LINK_FLAG_X86 "-arch x86"
 	#endif
 
-	if (str_eq(bc->ODIN_ARCH, str_lit("amd64"))) {
+
+	if (bc->ODIN_ARCH == "amd64") {
 		bc->word_size = 8;
 		bc->max_align = 16;
+
 		bc->llc_flags = str_lit("-march=x86-64 ");
 		bc->link_flags = str_lit(LINK_FLAG_X64 " ");
-	} else if (str_eq(bc->ODIN_ARCH, str_lit("x86"))) {
+	} else if (bc->ODIN_ARCH == "x86") {
 		bc->word_size = 4;
 		bc->max_align = 8;
 		bc->llc_flags = str_lit("-march=x86 ");
 		bc->link_flags = str_lit(LINK_FLAG_X86 " ");
+	} else {
+		gb_printf_err("This current architecture is not supported");
+		gb_exit(1);
 	}
 
+
+	isize opt_max = 1023;
+	char *opt_flags_string = gb_alloc_array(heap_allocator(), char, opt_max+1);
+	isize opt_len = 0;
+	bc->optimization_level = gb_clamp(bc->optimization_level, 0, 3);
+	if (bc->optimization_level != 0) {
+		opt_len = gb_snprintf(opt_flags_string, opt_max, "-O%d", bc->optimization_level);
+	} else {
+		opt_len = gb_snprintf(opt_flags_string, opt_max, "");
+	}
+	if (opt_len > 0) {
+		opt_len--;
+	}
+	bc->opt_flags = make_string(cast(u8 *)opt_flags_string, opt_len);
+
+
 	#undef LINK_FLAG_X64
 	#undef LINK_FLAG_X86
 }

src/check_decl.c

@@ -1,566 +0,0 @@
-bool check_is_terminating(AstNode *node);
-void check_stmt          (Checker *c, AstNode *node, u32 flags);
-
-// NOTE(bill): `content_name` is for debugging and error messages
-Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String context_name) {
-	if (operand->mode == Addressing_Invalid ||
-		operand->type == t_invalid ||
-		e->type == t_invalid) {
-
-		if (operand->mode == Addressing_Builtin) {
-			gbString expr_str = expr_to_string(operand->expr);
-
-			// TODO(bill): is this a good enough error message?
-			// TODO(bill): Actually allow built in procedures to be passed around and thus be created on use
-			error_node(operand->expr,
-				  "Cannot assign builtin procedure `%s` in %.*s",
-				  expr_str,
-				  LIT(context_name));
-
-			operand->mode = Addressing_Invalid;
-
-			gb_string_free(expr_str);
-		}
-
-
-		if (e->type == NULL) {
-			e->type = t_invalid;
-		}
-		return NULL;
-	}
-
-	if (e->type == NULL) {
-		// NOTE(bill): Use the type of the operand
-		Type *t = operand->type;
-		if (is_type_untyped(t)) {
-			if (t == t_invalid || is_type_untyped_nil(t)) {
-				error(e->token, "Use of untyped nil in %.*s", LIT(context_name));
-				e->type = t_invalid;
-				return NULL;
-			}
-			t = default_type(t);
-		}
-		if (is_type_bit_field_value(t)) {
-			t = default_bit_field_value_type(t);
-		}
-
-		GB_ASSERT(is_type_typed(t));
-		e->type = t;
-	}
-
-	e->parent_proc_decl = c->context.curr_proc_decl;
-
-	check_assignment(c, operand, e->type, context_name);
-	if (operand->mode == Addressing_Invalid) {
-		return NULL;
-	}
-
-	return e->type;
-}
-
-void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, AstNodeArray inits, String context_name) {
-	if ((lhs == NULL || lhs_count == 0) && inits.count == 0) {
-		return;
-	}
-
-	gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena);
-
-	// NOTE(bill): If there is a bad syntax error, rhs > lhs which would mean there would need to be
-	// an extra allocation
-	ArrayOperand operands = {0};
-	array_init_reserve(&operands, c->tmp_allocator, 2*lhs_count);
-	check_unpack_arguments(c, lhs_count, &operands, inits, true);
-
-	isize rhs_count = operands.count;
-	for_array(i, operands) {
-		if (operands.e[i].mode == Addressing_Invalid) {
-			rhs_count--;
-		}
-	}
-
-	isize max = gb_min(lhs_count, rhs_count);
-	for (isize i = 0; i < max; i++) {
-		check_init_variable(c, lhs[i], &operands.e[i], context_name);
-	}
-	if (rhs_count > 0 && lhs_count != rhs_count) {
-		error(lhs[0]->token, "Assignment count mismatch `%td` = `%td`", lhs_count, rhs_count);
-	}
-
-	gb_temp_arena_memory_end(tmp);
-}
-
-void check_init_constant(Checker *c, Entity *e, Operand *operand) {
-	if (operand->mode == Addressing_Invalid ||
-		operand->type == t_invalid ||
-		e->type == t_invalid) {
-		if (e->type == NULL) {
-			e->type = t_invalid;
-		}
-		return;
-	}
-
-	if (operand->mode != Addressing_Constant) {
-		// TODO(bill): better error
-		gbString str = expr_to_string(operand->expr);
-		error_node(operand->expr, "`%s` is not a constant", str);
-		gb_string_free(str);
-		if (e->type == NULL) {
-			e->type = t_invalid;
-		}
-		return;
-	}
-	if (!is_type_constant_type(operand->type)) {
-		gbString type_str = type_to_string(operand->type);
-		error_node(operand->expr, "Invalid constant type: `%s`", type_str);
-		gb_string_free(type_str);
-		if (e->type == NULL) {
-			e->type = t_invalid;
-		}
-		return;
-	}
-
-	if (e->type == NULL) { // NOTE(bill): type inference
-		e->type = operand->type;
-	}
-
-	check_assignment(c, operand, e->type, str_lit("constant declaration"));
-	if (operand->mode == Addressing_Invalid) {
-		return;
-	}
-
-	e->parent_proc_decl = c->context.curr_proc_decl;
-
-	e->Constant.value = operand->value;
-}
-
-void check_type_decl(Checker *c, Entity *e, AstNode *type_expr, Type *def) {
-	GB_ASSERT(e->type == NULL);
-	String name = e->token.string;
-	Type *named = make_type_named(c->allocator, name, NULL, e);
-	named->Named.type_name = e;
-	if (def != NULL && def->kind == Type_Named) {
-		def->Named.base = named;
-	}
-	e->type = named;
-
-	// gb_printf_err("%.*s %p\n", LIT(e->token.string), e);
-
-	Type *bt = check_type_extra(c, type_expr, named);
-	named->Named.base = base_type(bt);
-	if (named->Named.base == t_invalid) {
-		// gb_printf("check_type_decl: %s\n", type_to_string(named));
-	}
-}
-
-void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init, Type *named_type) {
-	GB_ASSERT(e->type == NULL);
-	GB_ASSERT(e->kind == Entity_Constant);
-
-	if (e->flags & EntityFlag_Visited) {
-		e->type = t_invalid;
-		return;
-	}
-	e->flags |= EntityFlag_Visited;
-
-	if (type_expr) {
-		Type *t = check_type(c, type_expr);
-		if (!is_type_constant_type(t)) {
-			gbString str = type_to_string(t);
-			error_node(type_expr, "Invalid constant type `%s`", str);
-			gb_string_free(str);
-			e->type = t_invalid;
-			return;
-		}
-		e->type = t;
-	}
-
-	Operand operand = {0};
-	if (init != NULL) {
-		check_expr_or_type(c, &operand, init);
-	}
-	if (operand.mode == Addressing_Type) {
-		e->kind = Entity_TypeName;
-
-		DeclInfo *d = c->context.decl;
-		d->type_expr = d->init_expr;
-		check_type_decl(c, e, d->type_expr, named_type);
-		return;
-	}
-
-	check_init_constant(c, e, &operand);
-
-	if (operand.mode == Addressing_Invalid ||
-		base_type(operand.type) == t_invalid) {
-		error(e->token, "Invalid declaration type");
-	}
-}
-
-
-
-bool are_signatures_similar_enough(Type *a_, Type *b_) {
-	GB_ASSERT(a_->kind == Type_Proc);
-	GB_ASSERT(b_->kind == Type_Proc);
-	TypeProc *a = &a_->Proc;
-	TypeProc *b = &b_->Proc;
-
-	if (a->param_count != b->param_count) {
-		return false;
-	}
-	if (a->result_count != b->result_count) {
-		return false;
-	}
-	for (isize i = 0; i < a->param_count; i++) {
-		Type *x = core_type(a->params->Tuple.variables[i]->type);
-		Type *y = core_type(b->params->Tuple.variables[i]->type);
-		if (is_type_pointer(x) && is_type_pointer(y)) {
-			continue;
-		}
-
-		if (is_type_integer(x) && is_type_integer(y)) {
-			GB_ASSERT(x->kind == Type_Basic);
-			GB_ASSERT(y->kind == Type_Basic);
-			if (x->Basic.size == y->Basic.size) {
-				continue;
-			}
-		}
-
-		if (!are_types_identical(x, y)) {
-			return false;
-		}
-	}
-	for (isize i = 0; i < a->result_count; i++) {
-		Type *x = base_type(a->results->Tuple.variables[i]->type);
-		Type *y = base_type(b->results->Tuple.variables[i]->type);
-		if (is_type_pointer(x) && is_type_pointer(y)) {
-			continue;
-		}
-
-		if (is_type_integer(x) && is_type_integer(y)) {
-			GB_ASSERT(x->kind == Type_Basic);
-			GB_ASSERT(y->kind == Type_Basic);
-			if (x->Basic.size == y->Basic.size) {
-				continue;
-			}
-		}
-
-		if (!are_types_identical(x, y)) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-void check_proc_lit(Checker *c, Entity *e, DeclInfo *d) {
-	GB_ASSERT(e->type == NULL);
-	if (d->proc_lit->kind != AstNode_ProcLit) {
-		// TOOD(bill): Better error message
-		error_node(d->proc_lit, "Expected a procedure to check");
-		return;
-	}
-
-	Type *proc_type = make_type_proc(c->allocator, e->scope, NULL, 0, NULL, 0, false, ProcCC_Odin);
-	e->type = proc_type;
-	ast_node(pd, ProcLit, d->proc_lit);
-
-	check_open_scope(c, pd->type);
-	check_procedure_type(c, proc_type, pd->type);
-
-	bool is_foreign         = (pd->tags & ProcTag_foreign)   != 0;
-	bool is_link_name       = (pd->tags & ProcTag_link_name) != 0;
-	bool is_export          = (pd->tags & ProcTag_export)    != 0;
-	bool is_inline          = (pd->tags & ProcTag_inline)    != 0;
-	bool is_no_inline       = (pd->tags & ProcTag_no_inline) != 0;
-	bool is_require_results = (pd->tags & ProcTag_require_results) != 0;
-
-
-	if (d->scope->is_file && str_eq(e->token.string, str_lit("main"))) {
-		if (proc_type != NULL) {
-			TypeProc *pt = &proc_type->Proc;
-			if (pt->param_count != 0 ||
-			    pt->result_count != 0) {
-				gbString str = type_to_string(proc_type);
-				error(e->token, "Procedure type of `main` was expected to be `proc()`, got %s", str);
-				gb_string_free(str);
-			}
-		}
-	}
-
-	if (is_inline && is_no_inline) {
-		error_node(pd->type, "You cannot apply both `inline` and `no_inline` to a procedure");
-	}
-
-	if (is_foreign && is_link_name) {
-		error_node(pd->type, "You cannot apply both `foreign` and `link_name` to a procedure");
-	} else if (is_foreign && is_export) {
-		error_node(pd->type, "You cannot apply both `foreign` and `export` to a procedure");
-	}
-
-
-	if (pd->body != NULL) {
-		if (is_foreign) {
-			error_node(pd->body, "A procedure tagged as `#foreign` cannot have a body");
-		}
-
-		d->scope = c->context.scope;
-
-		GB_ASSERT(pd->body->kind == AstNode_BlockStmt);
-		check_procedure_later(c, c->curr_ast_file, e->token, d, proc_type, pd->body, pd->tags);
-	}
-
-
-	if (proc_type != NULL && is_type_proc(proc_type)) {
-		TypeProc *tp = &proc_type->Proc;
-		if (tp->result_count == 0 && is_require_results) {
-			error_node(pd->type, "`#require_results` is not needed on a procedure with no results");
-		} else {
-			tp->require_results = is_require_results;
-		}
-	}
-
-	if (is_foreign) {
-		MapEntity *fp = &c->info.foreigns;
-		String name = e->token.string;
-		if (pd->foreign_name.len > 0) {
-			name = pd->foreign_name;
-		}
-
-		AstNode *foreign_library = d->proc_lit->ProcLit.foreign_library;
-		if (foreign_library == NULL) {
-			error(e->token, "#foreign procedures must declare which library they are from");
-		} else if (foreign_library->kind != AstNode_Ident) {
-			error_node(foreign_library, "#foreign library names must be an identifier");
-		} else {
-			String name = foreign_library->Ident.string;
-			Entity *found = scope_lookup_entity(c->context.scope, name);
-			if (found == NULL) {
-				if (str_eq(name, str_lit("_"))) {
-					error_node(foreign_library, "`_` cannot be used as a value type");
-				} else {
-					error_node(foreign_library, "Undeclared name: %.*s", LIT(name));
-				}
-			} else if (found->kind != Entity_LibraryName) {
-				error_node(foreign_library, "`_` cannot be used as a library name");
-			} else {
-				// TODO(bill): Extra stuff to do with library names?
-				e->Procedure.foreign_library = found;
-				add_entity_use(c, foreign_library, found);
-			}
-		}
-
-		e->Procedure.is_foreign = true;
-		e->Procedure.foreign_name = name;
-
-		HashKey key = hash_string(name);
-		Entity **found = map_entity_get(fp, key);
-		if (found) {
-			Entity *f = *found;
-			TokenPos pos = f->token.pos;
-			Type *this_type = base_type(e->type);
-			Type *other_type = base_type(f->type);
-			if (!are_signatures_similar_enough(this_type, other_type)) {
-				error_node(d->proc_lit,
-						   "Redeclaration of #foreign procedure `%.*s` with different type signatures\n"
-						   "\tat %.*s(%td:%td)",
-						   LIT(name), LIT(pos.file), pos.line, pos.column);
-			}
-		} else {
-			map_entity_set(fp, key, e);
-		}
-	} else {
-		String name = e->token.string;
-		if (is_link_name) {
-			name = pd->link_name;
-		}
-
-		if (is_link_name || is_export) {
-			MapEntity *fp = &c->info.foreigns;
-
-			e->Procedure.link_name = name;
-
-			HashKey key = hash_string(name);
-			Entity **found = map_entity_get(fp, key);
-			if (found) {
-				Entity *f = *found;
-				TokenPos pos = f->token.pos;
-				// TODO(bill): Better error message?
-				error_node(d->proc_lit,
-						   "Non unique linking name for procedure `%.*s`\n"
-						   "\tother at %.*s(%td:%td)",
-						   LIT(name), LIT(pos.file), pos.line, pos.column);
-			} else {
-				map_entity_set(fp, key, e);
-			}
-		}
-	}
-
-	check_close_scope(c);
-}
-
-void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count, AstNode *type_expr, AstNode *init_expr) {
-	GB_ASSERT(e->type == NULL);
-	GB_ASSERT(e->kind == Entity_Variable);
-
-	if (e->flags & EntityFlag_Visited) {
-		e->type = t_invalid;
-		return;
-	}
-	e->flags |= EntityFlag_Visited;
-
-	if (type_expr != NULL) {
-		e->type = check_type_extra(c, type_expr, NULL);
-	}
-
-	if (init_expr == NULL) {
-		if (type_expr == NULL) {
-			e->type = t_invalid;
-		}
-		return;
-	}
-
-	if (entities == NULL || entity_count == 1) {
-		GB_ASSERT(entities == NULL || entities[0] == e);
-		Operand operand = {0};
-		check_expr(c, &operand, init_expr);
-		check_init_variable(c, e, &operand, str_lit("variable declaration"));
-	}
-
-	if (type_expr != NULL) {
-		for (isize i = 0; i < entity_count; i++) {
-			entities[i]->type = e->type;
-		}
-	}
-
-	AstNodeArray inits;
-	array_init_reserve(&inits, c->allocator, 1);
-	array_add(&inits, init_expr);
-	check_init_variables(c, entities, entity_count, inits, str_lit("variable declaration"));
-}
-
-void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type) {
-	if (e->type != NULL) {
-		return;
-	}
-
-	if (d == NULL) {
-		DeclInfo **found = map_decl_info_get(&c->info.entities, hash_pointer(e));
-		if (found) {
-			d = *found;
-		} else {
-			// TODO(bill): Err here?
-			e->type = t_invalid;
-			set_base_type(named_type, t_invalid);
-			return;
-			// GB_PANIC("`%.*s` should been declared!", LIT(e->token.string));
-		}
-	}
-
-	CheckerContext prev = c->context;
-	c->context.scope = d->scope;
-	c->context.decl  = d;
-
-	e->parent_proc_decl = c->context.curr_proc_decl;
-
-	switch (e->kind) {
-	case Entity_Variable:
-		check_var_decl(c, e, d->entities, d->entity_count, d->type_expr, d->init_expr);
-		break;
-	case Entity_Constant:
-		check_const_decl(c, e, d->type_expr, d->init_expr, named_type);
-		break;
-	case Entity_TypeName:
-		check_type_decl(c, e, d->type_expr, named_type);
-		break;
-	case Entity_Procedure:
-		check_proc_lit(c, e, d);
-		break;
-	}
-
-	c->context = prev;
-}
-
-
-
-void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNode *body) {
-	GB_ASSERT(body->kind == AstNode_BlockStmt);
-
-	String proc_name = {0};
-	if (token.kind == Token_Ident) {
-		proc_name = token.string;
-	} else {
-		// TODO(bill): Better name
-		proc_name = str_lit("(anonymous-procedure)");
-	}
-
-	CheckerContext old_context = c->context;
-	c->context.scope = decl->scope;
-	c->context.decl = decl;
-	c->context.proc_name = proc_name;
-	c->context.curr_proc_decl = decl;
-
-	GB_ASSERT(type->kind == Type_Proc);
-	if (type->Proc.param_count > 0) {
-		TypeTuple *params = &type->Proc.params->Tuple;
-		for (isize i = 0; i < params->variable_count; i++) {
-			Entity *e = params->variables[i];
-			GB_ASSERT(e->kind == Entity_Variable);
-			if (!(e->flags & EntityFlag_Using)) {
-				continue;
-			}
-			bool is_immutable = e->Variable.is_immutable;
-			String name = e->token.string;
-			Type *t = base_type(type_deref(e->type));
-			if (is_type_struct(t) || is_type_raw_union(t)) {
-				Scope **found = map_scope_get(&c->info.scopes, hash_pointer(t->Record.node));
-				GB_ASSERT(found != NULL);
-				for_array(i, (*found)->elements.entries) {
-					Entity *f = (*found)->elements.entries.e[i].value;
-					if (f->kind == Entity_Variable) {
-						Entity *uvar = make_entity_using_variable(c->allocator, e, f->token, f->type);
-						uvar->Variable.is_immutable = is_immutable;
-						Entity *prev = scope_insert_entity(c->context.scope, uvar);
-						if (prev != NULL) {
-							error(e->token, "Namespace collision while `using` `%.*s` of: %.*s", LIT(name), LIT(prev->token.string));
-							break;
-						}
-					}
-				}
-			} else {
-				error(e->token, "`using` can only be applied to variables of type struct or raw_union");
-				break;
-			}
-		}
-	}
-
-	push_procedure(c, type);
-	{
-		ast_node(bs, BlockStmt, body);
-		check_stmt_list(c, bs->stmts, Stmt_CheckScopeDecls);
-		if (type->Proc.result_count > 0) {
-			if (!check_is_terminating(body)) {
-				if (token.kind == Token_Ident) {
-					error(bs->close, "Missing return statement at the end of the procedure `%.*s`", LIT(token.string));
-				} else {
-					error(bs->close, "Missing return statement at the end of the procedure");
-				}
-			}
-		}
-	}
-	pop_procedure(c);
-
-
-	check_scope_usage(c, c->context.scope);
-	c->context = old_context;
-
-	if (decl->parent != NULL) {
-		// NOTE(bill): Add the dependencies from the procedure literal (lambda)
-		for_array(i, decl->deps.entries) {
-			HashKey key = decl->deps.entries.e[i].key;
-			Entity *e = cast(Entity *)key.ptr;
-			map_bool_set(&decl->parent->deps, key, true);
-		}
-	}
-}
-
-
-

src/check_decl.cpp

@@ -0,0 +1,844 @@
+bool check_is_terminating(AstNode *node);
+void check_stmt          (Checker *c, AstNode *node, u32 flags);
+
+// NOTE(bill): 'content_name' is for debugging and error messages
+Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String context_name) {
+	if (operand->mode == Addressing_Invalid ||
+		operand->type == t_invalid ||
+		e->type == t_invalid) {
+
+		if (operand->mode == Addressing_Builtin) {
+			gbString expr_str = expr_to_string(operand->expr);
+
+			// TODO(bill): is this a good enough error message?
+			// TODO(bill): Actually allow built in procedures to be passed around and thus be created on use
+			error(operand->expr,
+				  "Cannot assign built-in procedure '%s' in %.*s",
+				  expr_str,
+				  LIT(context_name));
+
+			operand->mode = Addressing_Invalid;
+
+			gb_string_free(expr_str);
+		}
+
+
+		if (operand->mode == Addressing_Overload) {
+			if (e->type == nullptr) {
+				error(operand->expr, "Cannot determine type from overloaded procedure '%.*s'", LIT(operand->overload_entities[0]->token.string));
+			} else {
+				check_assignment(c, operand, e->type, str_lit("variable assignment"));
+				if (operand->mode != Addressing_Type) {
+					return operand->type;
+				}
+			}
+		}
+
+		if (e->type == nullptr) {
+			e->type = t_invalid;
+		}
+		return nullptr;
+	}
+
+
+
+	if (e->type == nullptr) {
+
+		// NOTE(bill): Use the type of the operand
+		Type *t = operand->type;
+		if (is_type_untyped(t)) {
+			if (t == t_invalid || is_type_untyped_nil(t)) {
+				error(e->token, "Invalid use of untyped nil in %.*s", LIT(context_name));
+				e->type = t_invalid;
+				return nullptr;
+			}
+			if (t == t_invalid || is_type_untyped_undef(t)) {
+				error(e->token, "Invalid use of --- in %.*s", LIT(context_name));
+				e->type = t_invalid;
+				return nullptr;
+			}
+			t = default_type(t);
+		}
+		if (is_type_polymorphic(t)) {
+			gbString str = type_to_string(t);
+			defer (gb_string_free(str));
+			error(e->token, "Invalid use of a polymorphic type '%s' in %.*s", str, LIT(context_name));
+			e->type = t_invalid;
+			return nullptr;
+		} else if (is_type_empty_union(t)) {
+			gbString str = type_to_string(t);
+			defer (gb_string_free(str));
+			error(e->token, "An empty union '%s' cannot be instantiated in %.*s", str, LIT(context_name));
+			e->type = t_invalid;
+			return nullptr;
+		}
+		if (is_type_bit_field_value(t)) {
+			t = default_bit_field_value_type(t);
+		}
+		GB_ASSERT(is_type_typed(t));
+		e->type = t;
+	}
+
+	e->parent_proc_decl = c->context.curr_proc_decl;
+
+	check_assignment(c, operand, e->type, context_name);
+	if (operand->mode == Addressing_Invalid) {
+		return nullptr;
+	}
+
+	return e->type;
+}
+
+void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, Array<AstNode *> inits, String context_name) {
+	if ((lhs == nullptr || lhs_count == 0) && inits.count == 0) {
+		return;
+	}
+
+
+	gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena);
+	defer (gb_temp_arena_memory_end(tmp));
+
+	// NOTE(bill): If there is a bad syntax error, rhs > lhs which would mean there would need to be
+	// an extra allocation
+	Array<Operand> operands = {};
+	array_init(&operands, c->tmp_allocator, 2*lhs_count);
+	check_unpack_arguments(c, lhs, lhs_count, &operands, inits, true);
+
+	isize rhs_count = operands.count;
+	for_array(i, operands) {
+		if (operands[i].mode == Addressing_Invalid) {
+			rhs_count--;
+		}
+	}
+
+	isize max = gb_min(lhs_count, rhs_count);
+	for (isize i = 0; i < max; i++) {
+		Entity *e = lhs[i];
+		DeclInfo *d = decl_info_of_entity(&c->info, e);
+		Operand *o = &operands[i];
+		check_init_variable(c, e, o, context_name);
+		if (d != nullptr) {
+			d->init_expr = o->expr;
+		}
+	}
+	if (rhs_count > 0 && lhs_count != rhs_count) {
+		error(lhs[0]->token, "Assignment count mismatch '%td' = '%td'", lhs_count, rhs_count);
+	}
+}
+
+void check_init_constant(Checker *c, Entity *e, Operand *operand) {
+	if (operand->mode == Addressing_Invalid ||
+		operand->type == t_invalid ||
+		e->type == t_invalid) {
+		if (e->type == nullptr) {
+			e->type = t_invalid;
+		}
+		return;
+	}
+
+	if (operand->mode != Addressing_Constant) {
+		// TODO(bill): better error
+		gbString str = expr_to_string(operand->expr);
+		error(operand->expr, "'%s' is not a constant", str);
+		gb_string_free(str);
+		if (e->type == nullptr) {
+			e->type = t_invalid;
+		}
+		return;
+	}
+	if (!is_type_constant_type(operand->type)) {
+		gbString type_str = type_to_string(operand->type);
+		error(operand->expr, "Invalid constant type: '%s'", type_str);
+		gb_string_free(type_str);
+		if (e->type == nullptr) {
+			e->type = t_invalid;
+		}
+		return;
+	}
+
+	if (e->type == nullptr) { // NOTE(bill): type inference
+		e->type = operand->type;
+	}
+
+	check_assignment(c, operand, e->type, str_lit("constant declaration"));
+	if (operand->mode == Addressing_Invalid) {
+		return;
+	}
+
+	e->parent_proc_decl = c->context.curr_proc_decl;
+
+	e->Constant.value = operand->value;
+}
+
+AstNode *remove_type_alias(AstNode *node) {
+	for (;;) {
+		if (node == nullptr) {
+			return nullptr;
+		}
+		if (node->kind == AstNode_ParenExpr) {
+			node = node->ParenExpr.expr;
+		} else if (node->kind == AstNode_AliasType) {
+			node = node->AliasType.type;
+		} else {
+			return node;
+		}
+	}
+}
+
+void check_type_decl(Checker *c, Entity *e, AstNode *type_expr, Type *def, bool is_alias) {
+	GB_ASSERT(e->type == nullptr);
+
+	DeclInfo *decl = decl_info_of_entity(&c->info, e);
+	if (decl != nullptr && decl->attributes.count > 0) {
+		error(decl->attributes[0], "Attributes are not allowed on type declarations");
+	}
+
+	AstNode *te = remove_type_alias(type_expr);
+	e->type = t_invalid;
+	String name = e->token.string;
+	Type *named = make_type_named(c->allocator, name, nullptr, e);
+	named->Named.type_name = e;
+	if (def != nullptr && def->kind == Type_Named) {
+		def->Named.base = named;
+	}
+	e->type = named;
+
+	Type *bt = check_type(c, te, named);
+	named->Named.base = base_type(bt);
+	if (is_alias) {
+		if (is_type_named(bt)) {
+			e->type = bt;
+			e->TypeName.is_type_alias = true;
+		} else {
+			gbString str = type_to_string(bt);
+			error(type_expr, "Type alias declaration with a non-named type '%s'", str);
+			gb_string_free(str);
+		}
+	}
+}
+
+void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init, Type *named_type) {
+	GB_ASSERT(e->type == nullptr);
+	GB_ASSERT(e->kind == Entity_Constant);
+
+	if (e->flags & EntityFlag_Visited) {
+		e->type = t_invalid;
+		return;
+	}
+	e->flags |= EntityFlag_Visited;
+
+	if (type_expr) {
+		Type *t = check_type(c, type_expr);
+		if (!is_type_constant_type(t)) {
+			gbString str = type_to_string(t);
+			error(type_expr, "Invalid constant type '%s'", str);
+			gb_string_free(str);
+			e->type = t_invalid;
+			return;
+		}
+		e->type = t;
+	}
+
+	Operand operand = {};
+
+	if (init != nullptr) {
+		Entity *entity = nullptr;
+		if (init->kind == AstNode_Ident) {
+			entity = check_ident(c, &operand, init, nullptr, e->type, true);
+		} else if (init->kind == AstNode_SelectorExpr) {
+			entity = check_selector(c, &operand, init, e->type);
+		} else {
+			check_expr_or_type(c, &operand, init, e->type);
+		}
+
+		switch (operand.mode) {
+		case Addressing_Type: {
+			e->kind = Entity_TypeName;
+
+			DeclInfo *d = c->context.decl;
+			if (d->type_expr != nullptr) {
+				error(e->token, "A type declaration cannot have an type parameter");
+			}
+			d->type_expr = d->init_expr;
+			check_type_decl(c, e, d->type_expr, named_type, false);
+			return;
+		}
+
+	// NOTE(bill): Check to see if the expression it to be aliases
+	#if 1
+		case Addressing_Builtin:
+			if (e->type != nullptr) {
+				error(type_expr, "A constant alias of a built-in procedure may not have a type initializer");
+			}
+			e->kind = Entity_Builtin;
+			e->Builtin.id = operand.builtin_id;
+			e->type = t_invalid;
+			return;
+
+		case Addressing_Overload:
+			e->kind = Entity_Alias;
+			e->Alias.base = operand.overload_entities[0];
+			e->type = t_invalid;
+			return;
+	#endif
+		}
+	#if 1
+		if (entity != nullptr) {
+			switch (entity->kind) {
+			case Entity_Alias:
+				e->kind = Entity_Alias;
+				e->type = entity->type;
+				e->Alias.base = entity->Alias.base;
+				return;
+			case Entity_Procedure:
+				e->kind = Entity_Alias;
+				e->type = entity->type;
+				e->Alias.base = entity;
+				return;
+			case Entity_ImportName:
+				e->kind = Entity_ImportName;
+				e->type = entity->type;
+				e->ImportName.path  = entity->ImportName.path;
+				e->ImportName.name  = entity->ImportName.path;
+				e->ImportName.scope = entity->ImportName.scope;
+				e->ImportName.used  = false;
+				return;
+			case Entity_LibraryName:
+				e->kind = Entity_LibraryName;
+				e->type = entity->type;
+				e->LibraryName.path  = entity->LibraryName.path;
+				e->LibraryName.name  = entity->LibraryName.path;
+				e->LibraryName.used  = false;
+				return;
+			}
+		}
+	#endif
+	}
+
+	if (init != nullptr) {
+		check_expr_or_type(c, &operand, init, e->type);
+	}
+
+	check_init_constant(c, e, &operand);
+
+	if (operand.mode == Addressing_Invalid ||
+		base_type(operand.type) == t_invalid) {
+		gbString str = expr_to_string(init);
+		error(e->token, "Invalid declaration type '%s'", str);
+		gb_string_free(str);
+	}
+
+
+	DeclInfo *decl = decl_info_of_entity(&c->info, e);
+	if (decl != nullptr && decl->attributes.count > 0) {
+		error(decl->attributes[0], "Attributes are not allowed on constant value declarations");
+	}
+}
+
+
+
+bool are_signatures_similar_enough(Type *a_, Type *b_) {
+	GB_ASSERT(a_->kind == Type_Proc);
+	GB_ASSERT(b_->kind == Type_Proc);
+	TypeProc *a = &a_->Proc;
+	TypeProc *b = &b_->Proc;
+
+	if (a->param_count != b->param_count) {
+		return false;
+	}
+	if (a->result_count != b->result_count) {
+		return false;
+	}
+	for (isize i = 0; i < a->param_count; i++) {
+		Type *x = core_type(a->params->Tuple.variables[i]->type);
+		Type *y = core_type(b->params->Tuple.variables[i]->type);
+		if (is_type_pointer(x) && is_type_pointer(y)) {
+			continue;
+		}
+
+		if (is_type_integer(x) && is_type_integer(y)) {
+			GB_ASSERT(x->kind == Type_Basic);
+			GB_ASSERT(y->kind == Type_Basic);
+			i64 sx = type_size_of(heap_allocator(), x);
+			i64 sy = type_size_of(heap_allocator(), y);
+			if (sx == sy) continue;
+		}
+
+		if (!are_types_identical(x, y)) return false;
+	}
+	for (isize i = 0; i < a->result_count; i++) {
+		Type *x = base_type(a->results->Tuple.variables[i]->type);
+		Type *y = base_type(b->results->Tuple.variables[i]->type);
+		if (is_type_pointer(x) && is_type_pointer(y)) {
+			continue;
+		}
+
+		if (is_type_integer(x) && is_type_integer(y)) {
+			GB_ASSERT(x->kind == Type_Basic);
+			GB_ASSERT(y->kind == Type_Basic);
+			i64 sx = type_size_of(heap_allocator(), x);
+			i64 sy = type_size_of(heap_allocator(), y);
+			if (sx == sy) continue;
+		}
+
+		if (!are_types_identical(x, y)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+void init_entity_foreign_library(Checker *c, Entity *e) {
+	AstNode *ident = nullptr;
+	Entity **foreign_library = nullptr;
+
+	switch (e->kind) {
+	case Entity_Procedure:
+		ident = e->Procedure.foreign_library_ident;
+		foreign_library = &e->Procedure.foreign_library;
+		break;
+	case Entity_Variable:
+		ident = e->Variable.foreign_library_ident;
+		foreign_library = &e->Variable.foreign_library;
+		break;
+	default:
+		return;
+	}
+
+	if (ident == nullptr) {
+		error(e->token, "foreign entiies must declare which library they are from");
+	} else if (ident->kind != AstNode_Ident) {
+		error(ident, "foreign library names must be an identifier");
+	} else {
+		String name = ident->Ident.token.string;
+		Entity *found = scope_lookup_entity(c->context.scope, name);
+		if (found == nullptr) {
+			if (is_blank_ident(name)) {
+				error(ident, "'_' cannot be used as a value type");
+			} else {
+				error(ident, "Undeclared name: %.*s", LIT(name));
+			}
+		} else if (found->kind != Entity_LibraryName) {
+			error(ident, "'%.*s' cannot be used as a library name", LIT(name));
+		} else {
+			// TODO(bill): Extra stuff to do with library names?
+			*foreign_library = found;
+			add_entity_use(c, ident, found);
+		}
+	}
+}
+
+String handle_link_name(Checker *c, Token token, String link_name, String link_prefix) {
+	if (link_prefix.len > 0) {
+		if (link_name.len > 0) {
+			error(token, "'link_name' and 'link_prefix' cannot be used together");
+		} else {
+			isize len = link_prefix.len + token.string.len;
+			u8 *name = gb_alloc_array(c->allocator, u8, len+1);
+			gb_memmove(name, &link_prefix[0], link_prefix.len);
+			gb_memmove(name+link_prefix.len, &token.string[0], token.string.len);
+			name[len] = 0;
+
+			link_name = make_string(name, len);
+		}
+	}
+	return link_name;
+}
+
+void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) {
+	GB_ASSERT(e->type == nullptr);
+	if (d->proc_lit->kind != AstNode_ProcLit) {
+		// TOOD(bill): Better error message
+		error(d->proc_lit, "Expected a procedure to check");
+		return;
+	}
+
+	Type *proc_type = e->type;
+	if (d->gen_proc_type != nullptr) {
+		proc_type = d->gen_proc_type;
+	} else {
+		proc_type = make_type_proc(c->allocator, e->scope, nullptr, 0, nullptr, 0, false, ProcCC_Odin);
+	}
+	e->type = proc_type;
+	ast_node(pl, ProcLit, d->proc_lit);
+
+	check_open_scope(c, pl->type);
+	defer (check_close_scope(c));
+
+
+	auto prev_context = c->context;
+	c->context.allow_polymorphic_types = true;
+	check_procedure_type(c, proc_type, pl->type);
+	c->context = prev_context;
+
+	TypeProc *pt = &proc_type->Proc;
+
+	bool is_foreign         = e->Procedure.is_foreign;
+	bool is_export          = e->Procedure.is_export;
+	bool is_require_results = (pl->tags & ProcTag_require_results) != 0;
+
+	AttributeContext ac = make_attribute_context(e->Procedure.link_prefix);
+
+	if (d != nullptr) {
+		check_decl_attributes(c, d->attributes, proc_decl_attribute, &ac);
+	}
+
+
+	ac.link_name = handle_link_name(c, e->token, ac.link_name, ac.link_prefix);
+
+	if (d->scope->file != nullptr && e->token.string == "main") {
+		if (pt->param_count != 0 ||
+		    pt->result_count != 0) {
+			gbString str = type_to_string(proc_type);
+			error(e->token, "Procedure type of 'main' was expected to be 'proc()', got %s", str);
+			gb_string_free(str);
+		}
+		if (pt->calling_convention != ProcCC_Odin &&
+		    pt->calling_convention != ProcCC_Contextless) {
+			error(e->token, "Procedure 'main' cannot have a custom calling convention");
+		}
+		pt->calling_convention = ProcCC_Contextless;
+		if (d->scope->is_init) {
+			if (c->info.entry_point != nullptr) {
+				error(e->token, "Redeclaration of the entry pointer procedure 'main'");
+			} else {
+				c->info.entry_point = e;
+			}
+		}
+	}
+
+	if (is_foreign && is_export) {
+		error(pl->type, "A foreign procedure cannot have an 'export' tag");
+	}
+
+	if (pt->is_polymorphic) {
+		if (pl->body == nullptr) {
+			error(e->token, "Polymorphic procedures must have a body");
+		}
+
+		if (is_foreign) {
+			error(e->token, "A foreign procedure cannot be a polymorphic");
+			return;
+		}
+	}
+
+	if (pl->body != nullptr) {
+		if (is_foreign) {
+			error(pl->body, "A foreign procedure cannot have a body");
+		}
+		if (proc_type->Proc.c_vararg) {
+			error(pl->body, "A procedure with a '#c_vararg' field cannot have a body and must be foreign");
+		}
+
+		d->scope = c->context.scope;
+
+		GB_ASSERT(pl->body->kind == AstNode_BlockStmt);
+		if (!pt->is_polymorphic) {
+			check_procedure_later(c, c->curr_ast_file, e->token, d, proc_type, pl->body, pl->tags);
+		}
+	} else if (!is_foreign) {
+		if (e->Procedure.is_export) {
+			error(e->token, "Foreign export procedures must have a body");
+		} else {
+			error(e->token, "Only a foreign procedure cannot have a body");
+		}
+	}
+
+	if (pt->result_count == 0 && is_require_results) {
+		error(pl->type, "'#require_results' is not needed on a procedure with no results");
+	} else {
+		pt->require_results = is_require_results;
+	}
+
+	if (ac.link_name.len > 0) {
+		e->Procedure.link_name = ac.link_name;
+	}
+
+	if (is_foreign) {
+		String name = e->token.string;
+		if (e->Procedure.link_name.len > 0) {
+			name = e->Procedure.link_name;
+		}
+		e->Procedure.is_foreign = true;
+		e->Procedure.link_name = name;
+
+		init_entity_foreign_library(c, e);
+
+		auto *fp = &c->info.foreigns;
+		HashKey key = hash_string(name);
+		Entity **found = map_get(fp, key);
+		if (found) {
+			Entity *f = *found;
+			TokenPos pos = f->token.pos;
+			Type *this_type = base_type(e->type);
+			Type *other_type = base_type(f->type);
+			if (is_type_proc(this_type) && is_type_proc(other_type)) {
+				if (!are_signatures_similar_enough(this_type, other_type)) {
+					error(d->proc_lit,
+					      "Redeclaration of foreign procedure '%.*s' with different type signatures\n"
+					      "\tat %.*s(%td:%td)",
+					      LIT(name), LIT(pos.file), pos.line, pos.column);
+				}
+			} else if (!are_types_identical(this_type, other_type)) {
+				error(d->proc_lit,
+				      "Foreign entity '%.*s' previously declared elsewhere with a different type\n"
+				      "\tat %.*s(%td:%td)",
+				      LIT(name), LIT(pos.file), pos.line, pos.column);
+			}
+		} else if (name == "main") {
+			error(d->proc_lit, "The link name 'main' is reserved for internal use");
+		} else {
+			map_set(fp, key, e);
+		}
+	} else {
+		String name = e->token.string;
+		if (e->Procedure.link_name.len > 0) {
+			name = e->Procedure.link_name;
+		}
+		if (e->Procedure.link_name.len > 0 || is_export) {
+			auto *fp = &c->info.foreigns;
+			HashKey key = hash_string(name);
+			Entity **found = map_get(fp, key);
+			if (found) {
+				Entity *f = *found;
+				TokenPos pos = f->token.pos;
+				// TODO(bill): Better error message?
+				error(d->proc_lit,
+				      "Non unique linking name for procedure '%.*s'\n"
+				      "\tother at %.*s(%td:%td)",
+				      LIT(name), LIT(pos.file), pos.line, pos.column);
+			} else if (name == "main") {
+				error(d->proc_lit, "The link name 'main' is reserved for internal use");
+			} else {
+				map_set(fp, key, e);
+			}
+		}
+	}
+}
+
+void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count, AstNode *type_expr, Array<AstNode *> init_expr_list) {
+	GB_ASSERT(e->type == nullptr);
+	GB_ASSERT(e->kind == Entity_Variable);
+
+	if (e->flags & EntityFlag_Visited) {
+		e->type = t_invalid;
+		return;
+	}
+	e->flags |= EntityFlag_Visited;
+
+	AttributeContext ac = make_attribute_context(e->Variable.link_prefix);
+	ac.init_expr_list_count = init_expr_list.count;
+
+	DeclInfo *decl = decl_info_of_entity(&c->info, e);
+	if (decl != nullptr) {
+		check_decl_attributes(c, decl->attributes, var_decl_attribute, &ac);
+	}
+
+	ac.link_name = handle_link_name(c, e->token, ac.link_name, ac.link_prefix);
+	e->Variable.thread_local_model = ac.thread_local_model;
+
+	String context_name = str_lit("variable declaration");
+
+	if (type_expr != nullptr) {
+		e->type = check_type(c, type_expr);
+	}
+	if (e->type != nullptr) {
+		if (is_type_polymorphic(base_type(e->type))) {
+			gbString str = type_to_string(e->type);
+			defer (gb_string_free(str));
+			error(e->token, "Invalid use of a polymorphic type '%s' in %.*s", str, LIT(context_name));
+			e->type = t_invalid;
+		} else if (is_type_empty_union(e->type)) {
+			gbString str = type_to_string(e->type);
+			defer (gb_string_free(str));
+			error(e->token, "An empty union '%s' cannot be instantiated in %.*s", str, LIT(context_name));
+			e->type = t_invalid;
+		}
+	}
+
+
+	if (e->Variable.is_foreign) {
+		if (init_expr_list.count > 0) {
+			error(e->token, "A foreign variable declaration cannot have a default value");
+		}
+		init_entity_foreign_library(c, e);
+	}
+	if (ac.link_name.len > 0) {
+		e->Variable.link_name = ac.link_name;
+	}
+
+	if (e->Variable.is_foreign || e->Variable.is_export) {
+		String name = e->token.string;
+		if (e->Variable.link_name.len > 0) {
+			name = e->Variable.link_name;
+		}
+		auto *fp = &c->info.foreigns;
+		HashKey key = hash_string(name);
+		Entity **found = map_get(fp, key);
+		if (found) {
+			Entity *f = *found;
+			TokenPos pos = f->token.pos;
+			Type *this_type = base_type(e->type);
+			Type *other_type = base_type(f->type);
+			if (!are_types_identical(this_type, other_type)) {
+				error(e->token,
+				      "Foreign entity '%.*s' previously declared elsewhere with a different type\n"
+				      "\tat %.*s(%td:%td)",
+				      LIT(name), LIT(pos.file), pos.line, pos.column);
+			}
+		} else {
+			map_set(fp, key, e);
+		}
+	}
+
+	if (init_expr_list.count == 0) {
+		if (type_expr == nullptr) {
+			e->type = t_invalid;
+		}
+		return;
+	}
+
+	if (type_expr != nullptr) {
+		for (isize i = 0; i < entity_count; i++) {
+			entities[i]->type = e->type;
+		}
+	}
+
+	check_init_variables(c, entities, entity_count, init_expr_list, context_name);
+}
+
+void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type) {
+	if (e->type != nullptr) {
+		return;
+	}
+
+	if (d == nullptr) {
+		d = decl_info_of_entity(&c->info, e);
+		if (d == nullptr) {
+			// TODO(bill): Err here?
+			e->type = t_invalid;
+			set_base_type(named_type, t_invalid);
+			return;
+			// GB_PANIC("'%.*s' should been declared!", LIT(e->token.string));
+		}
+	}
+
+	CheckerContext prev = c->context;
+	c->context.scope = d->scope;
+	c->context.decl  = d;
+
+	e->parent_proc_decl = c->context.curr_proc_decl;
+
+	switch (e->kind) {
+	case Entity_Variable:
+		check_var_decl(c, e, d->entities, d->entity_count, d->type_expr, d->init_expr_list);
+		break;
+	case Entity_Constant:
+		check_const_decl(c, e, d->type_expr, d->init_expr, named_type);
+		break;
+	case Entity_TypeName: {
+		bool is_alias = unparen_expr(d->type_expr)->kind == AstNode_AliasType;
+		check_type_decl(c, e, d->type_expr, named_type, is_alias);
+		break;
+	}
+	case Entity_Procedure:
+		check_proc_decl(c, e, d);
+		break;
+	}
+
+	c->context = prev;
+}
+
+
+
+void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNode *body) {
+	if (body == nullptr) {
+		return;
+	}
+	GB_ASSERT(body->kind == AstNode_BlockStmt);
+
+	String proc_name = {};
+	if (token.kind == Token_Ident) {
+		proc_name = token.string;
+	} else {
+		// TODO(bill): Better name
+		proc_name = str_lit("(anonymous-procedure)");
+	}
+
+	CheckerContext old_context = c->context;
+	defer (c->context = old_context);
+
+	c->context.scope = decl->scope;
+	c->context.decl = decl;
+	c->context.proc_name = proc_name;
+	c->context.curr_proc_decl = decl;
+
+	GB_ASSERT(type->kind == Type_Proc);
+	if (type->Proc.param_count > 0) {
+		TypeTuple *params = &type->Proc.params->Tuple;
+		for_array(i, params->variables) {
+			Entity *e = params->variables[i];
+			if (e->kind != Entity_Variable) {
+				continue;
+			}
+			if (!(e->flags & EntityFlag_Using)) {
+				continue;
+			}
+			bool is_immutable = e->Variable.is_immutable;
+			String name = e->token.string;
+			Type *t = base_type(type_deref(e->type));
+			if (t->kind == Type_Struct) {
+				Scope *scope = t->Struct.scope;
+				if (scope == nullptr) {
+					scope = scope_of_node(&c->info, t->Struct.node);
+				}
+				GB_ASSERT(scope != nullptr);
+				for_array(i, scope->elements.entries) {
+					Entity *f = scope->elements.entries[i].value;
+					if (f->kind == Entity_Variable) {
+						Entity *uvar = make_entity_using_variable(c->allocator, e, f->token, f->type);
+						uvar->Variable.is_immutable = is_immutable;
+						Entity *prev = scope_insert_entity(c->context.scope, uvar);
+						if (prev != nullptr) {
+							error(e->token, "Namespace collision while 'using' '%.*s' of: %.*s", LIT(name), LIT(prev->token.string));
+							break;
+						}
+					}
+				}
+			} else {
+				error(e->token, "'using' can only be applied to variables of type struct");
+				break;
+			}
+		}
+	}
+
+	push_procedure(c, type);
+	{
+		ast_node(bs, BlockStmt, body);
+		check_stmt_list(c, bs->stmts, Stmt_CheckScopeDecls);
+		if (type->Proc.result_count > 0) {
+			if (!check_is_terminating(body)) {
+				if (token.kind == Token_Ident) {
+					error(bs->close, "Missing return statement at the end of the procedure '%.*s'", LIT(token.string));
+				} else {
+					error(bs->close, "Missing return statement at the end of the procedure");
+				}
+			}
+		}
+	}
+	pop_procedure(c);
+
+	check_scope_usage(c, c->context.scope);
+
+	if (decl->parent != nullptr) {
+		// NOTE(bill): Add the dependencies from the procedure literal (lambda)
+		for_array(i, decl->deps.entries) {
+			Entity *e = decl->deps.entries[i].ptr;
+			ptr_set_add(&decl->parent->deps, e);
+		}
+	}
+}
+
+
+

src/common.c

@@ -1,262 +0,0 @@
-#if defined(GB_SYSTEM_UNIX)
-// Required for intrinsics on GCC
-#include <xmmintrin.h>
-#endif
-
-#define GB_NO_DEFER
-#define GB_IMPLEMENTATION
-#include "gb/gb.h"
-
-#include <math.h>
-
-gbAllocator heap_allocator(void) {
-	return gb_heap_allocator();
-}
-
-#include "unicode.c"
-#include "string.c"
-#include "array.c"
-#include "integer128.c"
-#include "murmurhash3.c"
-
-u128 fnv128a(void const *data, isize len) {
-	u128 o = u128_lo_hi(0x13bull, 0x1000000ull);
-	u128 h = u128_lo_hi(0x62b821756295c58dull, 0x6c62272e07bb0142ull);
-	u8 const *bytes = cast(u8 const *)data;
-	for (isize i = 0; i < len; i++) {
-		h = u128_mul(u128_xor(h, u128_from_u64(bytes[i])), o);
-	}
-	return h;
-}
-
-gb_global String global_module_path = {0};
-gb_global bool global_module_path_set = false;
-
-gb_global gbScratchMemory scratch_memory = {0};
-
-void init_scratch_memory(isize size) {
-	void *memory = gb_alloc(heap_allocator(), size);
-	gb_scratch_memory_init(&scratch_memory, memory, size);
-}
-
-gbAllocator scratch_allocator(void) {
-	return gb_scratch_allocator(&scratch_memory);
-}
-
-typedef struct DynamicArenaBlock DynamicArenaBlock;
-typedef struct DynamicArena      DynamicArena;
-
-struct DynamicArenaBlock {
-	DynamicArenaBlock *prev;
-	DynamicArenaBlock *next;
-	u8 *               start;
-	isize              count;
-	isize              capacity;
-
-	gbVirtualMemory    vm;
-};
-
-struct DynamicArena {
-	DynamicArenaBlock *start_block;
-	DynamicArenaBlock *current_block;
-	isize              block_size;
-};
-
-DynamicArenaBlock *add_dynamic_arena_block(DynamicArena *a) {
-	GB_ASSERT(a != NULL);
-	GB_ASSERT(a->block_size > 0);
-
-	gbVirtualMemory vm = gb_vm_alloc(NULL, a->block_size);
-	DynamicArenaBlock *block = cast(DynamicArenaBlock *)vm.data;
-
-	u8 *start = cast(u8 *)gb_align_forward(cast(u8 *)(block + 1), GB_DEFAULT_MEMORY_ALIGNMENT);
-	u8 *end = cast(u8 *)vm.data + vm.size;
-
-	block->vm       = vm;
-	block->start    = start;
-	block->count    = 0;
-	block->capacity = end-start;
-
-	if (a->current_block != NULL) {
-		a->current_block->next = block;
-		block->prev = a->current_block;
-	}
-	a->current_block = block;
-	return block;
-}
-
-void init_dynamic_arena(DynamicArena *a, isize block_size) {
-	isize size = gb_size_of(DynamicArenaBlock) + block_size;
-	size = cast(isize)gb_align_forward(cast(void *)cast(uintptr)size, GB_DEFAULT_MEMORY_ALIGNMENT);
-	a->block_size = size;
-	a->start_block = add_dynamic_arena_block(a);
-}
-
-void destroy_dynamic_arena(DynamicArena *a) {
-	DynamicArenaBlock *b = a->current_block;
-	while (b != NULL) {
-		gbVirtualMemory vm = b->vm;
-		b = b->prev;
-		gb_vm_free(b->vm);
-	}
-}
-
-GB_ALLOCATOR_PROC(dynamic_arena_allocator_proc) {
-	DynamicArena *a = cast(DynamicArena *)allocator_data;
-	void *ptr = NULL;
-
-	switch (type) {
-	case gbAllocation_Alloc: {
-
-	} break;
-
-	case gbAllocation_Free: {
-	} break;
-
-	case gbAllocation_Resize: {
-	} break;
-
-	case gbAllocation_FreeAll:
-		GB_PANIC("free_all is not supported by this allocator");
-		break;
-	}
-
-	return ptr;
-}
-
-gbAllocator dynamic_arena_allocator(DynamicArena *a) {
-	gbAllocator allocator = {dynamic_arena_allocator_proc, a};
-	return allocator;
-}
-
-
-
-
-i64 next_pow2(i64 n) {
-	if (n <= 0) {
-		return 0;
-	}
-	n--;
-	n |= n >> 1;
-	n |= n >> 2;
-	n |= n >> 4;
-	n |= n >> 8;
-	n |= n >> 16;
-	n |= n >> 32;
-	n++;
-	return n;
-}
-
-i64 prev_pow2(i64 n) {
-	if (n <= 0) {
-		return 0;
-	}
-	n |= n >> 1;
-	n |= n >> 2;
-	n |= n >> 4;
-	n |= n >> 8;
-	n |= n >> 16;
-	n |= n >> 32;
-	return n - (n >> 1);
-}
-
-i16 f32_to_f16(f32 value) {
-	union { u32 i; f32 f; } v;
-	i32 i, s, e, m;
-
-	v.f = value;
-	i = (i32)v.i;
-
-	s =  (i >> 16) & 0x00008000;
-	e = ((i >> 23) & 0x000000ff) - (127 - 15);
-	m =   i        & 0x007fffff;
-
-
-	if (e <= 0) {
-		if (e < -10) return cast(i16)s;
-		m = (m | 0x00800000) >> (1 - e);
-
-		if (m & 0x00001000)
-			m += 0x00002000;
-
-		return cast(i16)(s | (m >> 13));
-	} else if (e == 0xff - (127 - 15)) {
-		if (m == 0) {
-			return cast(i16)(s | 0x7c00); /* NOTE(bill): infinity */
-		} else {
-			/* NOTE(bill): NAN */
-			m >>= 13;
-			return cast(i16)(s | 0x7c00 | m | (m == 0));
-		}
-	} else {
-		if (m & 0x00001000) {
-			m += 0x00002000;
-			if (m & 0x00800000) {
-				m = 0;
-				e += 1;
-			}
-		}
-
-		if (e > 30) {
-			float volatile f = 1e12f;
-			int j;
-			for (j = 0; j < 10; j++) {
-				f *= f; /* NOTE(bill): Cause overflow */
-			}
-
-			return cast(i16)(s | 0x7c00);
-		}
-
-		return cast(i16)(s | (e << 10) | (m >> 13));
-	}
-}
-
-f64 gb_sqrt(f64 x) {
-	return sqrt(x);
-}
-
-
-
-#define for_array(index_, array_) for (isize index_ = 0; index_ < (array_).count; index_++)
-
-
-// Doubly Linked Lists
-
-#define DLIST_SET(curr_element, next_element)  do { \
-	(curr_element)->next = (next_element);             \
-	(curr_element)->next->prev = (curr_element);       \
-	(curr_element) = (curr_element)->next;             \
-} while (0)
-
-#define DLIST_APPEND(root_element, curr_element, next_element) do { \
-	if ((root_element) == NULL) { \
-		(root_element) = (curr_element) = (next_element); \
-	} else { \
-		DLIST_SET(curr_element, next_element); \
-	} \
-} while (0)
-
-////////////////////////////////////////////////////////////////
-//
-// Generic Data Structures
-//
-////////////////////////////////////////////////////////////////
-
-typedef Array(i32)   Array_i32;
-typedef Array(isize) Array_isize;
-
-
-#define MAP_TYPE String
-#define MAP_PROC map_string_
-#define MAP_NAME MapString
-#include "map.c"
-
-#define MAP_TYPE bool
-#define MAP_PROC map_bool_
-#define MAP_NAME MapBool
-#include "map.c"
-
-#define MAP_TYPE isize
-#define MAP_PROC map_isize_
-#define MAP_NAME MapIsize
-#include "map.c"

src/common.cpp

@@ -0,0 +1,562 @@
+#if defined(GB_SYSTEM_UNIX)
+// Required for intrinsics on GCC
+#include <xmmintrin.h>
+#endif
+
+#define GB_IMPLEMENTATION
+#include "gb/gb.h"
+
+
+#include <wchar.h>
+#include <stdio.h>
+
+#include <math.h>
+
+GB_ALLOCATOR_PROC(heap_allocator_proc);
+
+gbAllocator heap_allocator(void) {
+	gbAllocator a;
+	a.proc = heap_allocator_proc;
+	a.data = NULL;
+	return a;
+}
+
+
+GB_ALLOCATOR_PROC(heap_allocator_proc) {
+	void *ptr = NULL;
+	gb_unused(allocator_data);
+	gb_unused(old_size);
+// TODO(bill): Throughly test!
+	switch (type) {
+#if defined(GB_COMPILER_MSVC)
+	case gbAllocation_Alloc:
+		ptr = _aligned_malloc(size, alignment);
+		if (flags & gbAllocatorFlag_ClearToZero)
+			gb_zero_size(ptr, size);
+		break;
+	case gbAllocation_Free:
+		_aligned_free(old_memory);
+		break;
+	case gbAllocation_Resize:
+		ptr = _aligned_realloc(old_memory, size, alignment);
+		break;
+
+#elif defined(GB_SYSTEM_LINUX)
+	// TODO(bill): *nix version that's decent
+	case gbAllocation_Alloc: {
+		ptr = aligned_alloc(alignment, size);
+		// ptr = malloc(size+alignment);
+
+		if (flags & gbAllocatorFlag_ClearToZero) {
+			gb_zero_size(ptr, size);
+		}
+		break;
+	}
+
+	case gbAllocation_Free: {
+		free(old_memory);
+		break;
+	}
+
+	case gbAllocation_Resize: {
+		// ptr = realloc(old_memory, size);
+		ptr = gb_default_resize_align(heap_allocator(), old_memory, old_size, size, alignment);
+		break;
+	}
+#else
+	// TODO(bill): *nix version that's decent
+	case gbAllocation_Alloc: {
+		posix_memalign(&ptr, alignment, size);
+
+		if (flags & gbAllocatorFlag_ClearToZero) {
+			gb_zero_size(ptr, size);
+		}
+		break;
+	}
+
+	case gbAllocation_Free: {
+		free(old_memory);
+		break;
+	}
+
+	case gbAllocation_Resize: {
+		ptr = gb_default_resize_align(heap_allocator(), old_memory, old_size, size, alignment);
+		break;
+	}
+#endif
+
+	case gbAllocation_FreeAll:
+		break;
+	}
+
+	return ptr;
+}
+
+#include "unicode.cpp"
+#include "string.cpp"
+#include "array.cpp"
+#include "integer128.cpp"
+#include "murmurhash3.cpp"
+
+#define for_array(index_, array_) for (isize index_ = 0; index_ < (array_).count; index_++)
+
+
+u128 fnv128a(void const *data, isize len) {
+	u128 o = u128_lo_hi(0x13bull, 0x1000000ull);
+	u128 h = u128_lo_hi(0x62b821756295c58dull, 0x6c62272e07bb0142ull);
+	u8 const *bytes = cast(u8 const *)data;
+	for (isize i = 0; i < len; i++) {
+		h.lo ^= bytes[i];
+		h = h * o;
+	}
+	return h;
+}
+
+#include "map.cpp"
+#include "ptr_set.cpp"
+#include "string_set.cpp"
+#include "priority_queue.cpp"
+
+
+
+gb_global String global_module_path = {0};
+gb_global bool global_module_path_set = false;
+
+gb_global gbScratchMemory scratch_memory = {0};
+
+void init_scratch_memory(isize size) {
+	void *memory = gb_alloc(heap_allocator(), size);
+	gb_scratch_memory_init(&scratch_memory, memory, size);
+}
+
+gbAllocator scratch_allocator(void) {
+	return gb_scratch_allocator(&scratch_memory);
+}
+
+struct Pool {
+	isize       memblock_size;
+	isize       out_of_band_size;
+	isize       alignment;
+
+	Array<u8 *> unused_memblock;
+	Array<u8 *> used_memblock;
+	Array<u8 *> out_of_band_allocations;
+
+	u8 *        current_memblock;
+	u8 *        current_pos;
+	isize       bytes_left;
+
+	gbAllocator block_allocator;
+};
+
+enum {
+	POOL_BUCKET_SIZE_DEFAULT      = 65536,
+	POOL_OUT_OF_BAND_SIZE_DEFAULT = 6554,
+};
+
+void pool_init(Pool *pool,
+               isize memblock_size = POOL_BUCKET_SIZE_DEFAULT,
+               isize out_of_band_size = POOL_OUT_OF_BAND_SIZE_DEFAULT,
+               isize alignment = 8,
+               gbAllocator block_allocator = heap_allocator(),
+               gbAllocator array_allocator = heap_allocator()) {
+	pool->memblock_size = memblock_size;
+	pool->out_of_band_size = out_of_band_size;
+	pool->alignment = alignment;
+	pool->block_allocator = block_allocator;
+
+	array_init(&pool->unused_memblock,         array_allocator);
+	array_init(&pool->used_memblock,           array_allocator);
+	array_init(&pool->out_of_band_allocations, array_allocator);
+}
+
+void pool_free_all(Pool *p) {
+	if (p->current_memblock != nullptr) {
+		array_add(&p->unused_memblock, p->current_memblock);
+		p->current_memblock = nullptr;
+	}
+
+	for_array(i, p->used_memblock) {
+		array_add(&p->unused_memblock, p->used_memblock[i]);
+	}
+	array_clear(&p->unused_memblock);
+
+	for_array(i, p->out_of_band_allocations) {
+		gb_free(p->block_allocator, p->out_of_band_allocations[i]);
+	}
+	array_clear(&p->out_of_band_allocations);
+}
+
+void pool_destroy(Pool *p) {
+	pool_free_all(p);
+
+	for_array(i, p->unused_memblock) {
+		gb_free(p->block_allocator, p->unused_memblock[i]);
+	}
+}
+
+void pool_cycle_new_block(Pool *p) {
+	GB_ASSERT_MSG(p->block_allocator.proc != nullptr,
+	              "You must call pool_init on a Pool before using it!");
+
+	if (p->current_memblock != nullptr) {
+		array_add(&p->used_memblock, p->current_memblock);
+	}
+
+	u8 *new_block = nullptr;
+
+	if (p->unused_memblock.count > 0) {
+		new_block = array_pop(&p->unused_memblock);
+	} else {
+		GB_ASSERT(p->block_allocator.proc != nullptr);
+		new_block = cast(u8 *)gb_alloc_align(p->block_allocator, p->memblock_size, p->alignment);
+	}
+
+	p->bytes_left       = p->memblock_size;
+	p->current_memblock = new_block;
+	p->current_memblock = new_block;
+}
+
+void *pool_get(Pool *p,
+               isize size, isize alignment = 0) {
+	if (alignment <= 0) alignment = p->alignment;
+
+	isize extra = alignment - (size & alignment);
+	size += extra;
+	if (size >= p->out_of_band_size) {
+		GB_ASSERT(p->block_allocator.proc != nullptr);
+		u8 *memory = cast(u8 *)gb_alloc_align(p->block_allocator, p->memblock_size, alignment);
+		if (memory != nullptr) {
+			array_add(&p->out_of_band_allocations, memory);
+		}
+		return memory;
+	}
+
+	if (p->bytes_left < size) {
+		pool_cycle_new_block(p);
+		if (p->current_memblock != nullptr) {
+			return nullptr;
+		}
+	}
+
+	u8 *res = p->current_pos;
+	p->current_pos += size;
+	p->bytes_left  -= size;
+	return res;
+}
+
+
+gbAllocator pool_allocator(Pool *pool);
+
+GB_ALLOCATOR_PROC(pool_allocator_procedure) {
+	Pool *p = cast(Pool *)allocator_data;
+	void *ptr = nullptr;
+
+	switch (type) {
+	case gbAllocation_Alloc:
+		return pool_get(p, size, alignment);
+	case gbAllocation_Free:
+		// Does nothing
+		break;
+	case gbAllocation_FreeAll:
+		pool_free_all(p);
+		break;
+	case gbAllocation_Resize:
+		return gb_default_resize_align(pool_allocator(p), old_memory, old_size, size, alignment);
+	}
+
+	return ptr;
+}
+
+gbAllocator pool_allocator(Pool *pool) {
+	gbAllocator allocator;
+	allocator.proc = pool_allocator_procedure;
+	allocator.data = pool;
+	return allocator;
+}
+
+
+
+i32 next_pow2(i32 n) {
+	if (n <= 0) {
+		return 0;
+	}
+	n--;
+	n |= n >> 1;
+	n |= n >> 2;
+	n |= n >> 4;
+	n |= n >> 8;
+	n |= n >> 16;
+	n++;
+	return n;
+}
+i64 next_pow2(i64 n) {
+	if (n <= 0) {
+		return 0;
+	}
+	n--;
+	n |= n >> 1;
+	n |= n >> 2;
+	n |= n >> 4;
+	n |= n >> 8;
+	n |= n >> 16;
+	n |= n >> 32;
+	n++;
+	return n;
+}
+
+i32 bit_set_count(u32 x) {
+	x -= ((x >> 1) & 0x55555555);
+	x = (((x >> 2) & 0x33333333) + (x & 0x33333333));
+	x = (((x >> 4) + x) & 0x0f0f0f0f);
+	x += (x >> 8);
+	x += (x >> 16);
+
+	return cast(i32)(x & 0x0000003f);
+}
+
+i64 bit_set_count(u64 x) {
+	u32 a = *(cast(u32 *)&x);
+	u32 b = *(cast(u32 *)&x + 1);
+	return bit_set_count(a) + bit_set_count(b);
+}
+
+u32 floor_log2(u32 x) {
+	x |= x >> 1;
+	x |= x >> 2;
+	x |= x >> 4;
+	x |= x >> 8;
+	x |= x >> 16;
+	return cast(u32)(bit_set_count(x) - 1);
+}
+
+u64 floor_log2(u64 x) {
+	x |= x >> 1;
+	x |= x >> 2;
+	x |= x >> 4;
+	x |= x >> 8;
+	x |= x >> 16;
+	x |= x >> 32;
+	return cast(u64)(bit_set_count(x) - 1);
+}
+
+
+u32 ceil_log2(u32 x) {
+	i32 y = cast(i32)(x & (x-1));
+	y |= -y;
+	y >>= 32-1;
+	x |= x >> 1;
+	x |= x >> 2;
+	x |= x >> 4;
+	x |= x >> 8;
+	x |= x >> 16;
+	return cast(u32)(bit_set_count(x) - 1 - y);
+}
+
+u64 ceil_log2(u64 x) {
+	i64 y = cast(i64)(x & (x-1));
+	y |= -y;
+	y >>= 64-1;
+	x |= x >> 1;
+	x |= x >> 2;
+	x |= x >> 4;
+	x |= x >> 8;
+	x |= x >> 16;
+	x |= x >> 32;
+	return cast(u64)(bit_set_count(x) - 1 - y);
+}
+
+
+i32 prev_pow2(i32 n) {
+	if (n <= 0) {
+		return 0;
+	}
+	n |= n >> 1;
+	n |= n >> 2;
+	n |= n >> 4;
+	n |= n >> 8;
+	n |= n >> 16;
+	return n - (n >> 1);
+}
+i64 prev_pow2(i64 n) {
+	if (n <= 0) {
+		return 0;
+	}
+	n |= n >> 1;
+	n |= n >> 2;
+	n |= n >> 4;
+	n |= n >> 8;
+	n |= n >> 16;
+	n |= n >> 32;
+	return n - (n >> 1);
+}
+
+i16 f32_to_f16(f32 value) {
+	union { u32 i; f32 f; } v;
+	i32 i, s, e, m;
+
+	v.f = value;
+	i = (i32)v.i;
+
+	s =  (i >> 16) & 0x00008000;
+	e = ((i >> 23) & 0x000000ff) - (127 - 15);
+	m =   i        & 0x007fffff;
+
+
+	if (e <= 0) {
+		if (e < -10) return cast(i16)s;
+		m = (m | 0x00800000) >> (1 - e);
+
+		if (m & 0x00001000)
+			m += 0x00002000;
+
+		return cast(i16)(s | (m >> 13));
+	} else if (e == 0xff - (127 - 15)) {
+		if (m == 0) {
+			return cast(i16)(s | 0x7c00); /* NOTE(bill): infinity */
+		} else {
+			/* NOTE(bill): NAN */
+			m >>= 13;
+			return cast(i16)(s | 0x7c00 | m | (m == 0));
+		}
+	} else {
+		if (m & 0x00001000) {
+			m += 0x00002000;
+			if (m & 0x00800000) {
+				m = 0;
+				e += 1;
+			}
+		}
+
+		if (e > 30) {
+			float volatile f = 1e12f;
+			int j;
+			for (j = 0; j < 10; j++) {
+				f *= f; /* NOTE(bill): Cause overflow */
+			}
+
+			return cast(i16)(s | 0x7c00);
+		}
+
+		return cast(i16)(s | (e << 10) | (m >> 13));
+	}
+}
+
+f64 gb_sqrt(f64 x) {
+	return sqrt(x);
+}
+
+
+
+
+
+// Doubly Linked Lists
+
+#define DLIST_SET(curr_element, next_element)  do { \
+	(curr_element)->next = (next_element);             \
+	(curr_element)->next->prev = (curr_element);       \
+	(curr_element) = (curr_element)->next;             \
+} while (0)
+
+#define DLIST_APPEND(root_element, curr_element, next_element) do { \
+	if ((root_element) == nullptr) { \
+		(root_element) = (curr_element) = (next_element); \
+	} else { \
+		DLIST_SET(curr_element, next_element); \
+	} \
+} while (0)
+
+
+
+#if defined(GB_SYSTEM_WINDOWS)
+
+wchar_t **command_line_to_wargv(wchar_t *cmd_line, int *_argc) {
+	u32 i, j;
+
+	u32 len = cast(u32)string16_len(cmd_line);
+	i = ((len+2)/2)*gb_size_of(void *) + gb_size_of(void *);
+
+	wchar_t **argv = cast(wchar_t **)GlobalAlloc(GMEM_FIXED, i + (len+2)*gb_size_of(wchar_t));
+	wchar_t *_argv = cast(wchar_t *)((cast(u8 *)argv)+i);
+
+	u32 argc = 0;
+	argv[argc] = _argv;
+	bool in_quote = false;
+	bool in_text = false;
+	bool in_space = true;
+	i = 0;
+	j = 0;
+
+	for (;;) {
+		wchar_t a = cmd_line[i];
+		if (a == 0) {
+			break;
+		}
+		if (in_quote) {
+			if (a == '\"') {
+				in_quote = false;
+			} else {
+				_argv[j++] = a;
+			}
+		} else {
+			switch (a) {
+			case '\"':
+				in_quote = true;
+				in_text = true;
+				if (in_space) argv[argc++] = _argv+j;
+				in_space = false;
+				break;
+			case ' ':
+			case '\t':
+			case '\n':
+			case '\r':
+				if (in_text) _argv[j++] = '\0';
+				in_text = false;
+				in_space = true;
+				break;
+			default:
+				in_text = true;
+				if (in_space) argv[argc++] = _argv+j;
+				_argv[j++] = a;
+				in_space = false;
+				break;
+			}
+		}
+		i++;
+	}
+	_argv[j] = '\0';
+	argv[argc] = nullptr;
+
+	if (_argc) *_argc = argc;
+	return argv;
+}
+
+#endif
+
+
+#if defined(GB_SYSTEM_WINDOWS)
+	bool path_is_directory(String path) {
+		gbAllocator a = heap_allocator();
+		String16 wstr = string_to_string16(a, path);
+		defer (gb_free(a, wstr.text));
+
+		i32 attribs = GetFileAttributesW(wstr.text);
+		if (attribs < 0) return false;
+
+		return (attribs & FILE_ATTRIBUTE_DIRECTORY) != 0;
+	}
+
+#else
+	bool path_is_directory(String path) {
+		gbAllocator a = heap_allocator();
+		char *copy = cast(char *)copy_string(a, path).text;
+		defer (gb_free(a, copy));
+
+		struct stat s;
+		if (stat(copy, &s) == 0) {
+			return (s.st_mode & S_IFDIR) != 0;
+		}
+		return false;
+	}
+#endif
+

src/docs.cpp

@@ -0,0 +1,107 @@
+// Generates Documentation
+
+gbString expr_to_string(AstNode *expression);
+
+String alloc_comment_group_string(gbAllocator a, CommentGroup g) {
+	isize len = 0;
+	for_array(i, g.list) {
+		String comment = g.list[i].string;
+		len += comment.len;
+		len += 1; // for \n
+	}
+	if (len == 0) {
+		return make_string(nullptr, 0);
+	}
+
+	u8 *text = gb_alloc_array(a, u8, len+1);
+	len = 0;
+	for_array(i, g.list) {
+		String comment = g.list[i].string;
+		if (comment[1] == '/') {
+			comment.text += 2;
+			comment.len  -= 2;
+		} else if (comment[1] == '*') {
+			comment.text += 2;
+			comment.len  -= 4;
+		}
+		comment = string_trim_whitespace(comment);
+		gb_memmove(text+len, comment.text, comment.len);
+		len += comment.len;
+		text[len++] = '\n';
+	}
+	return make_string(text, len);
+}
+
+#if 0
+void print_type_spec(AstNode *spec) {
+	ast_node(ts, TypeSpec, spec);
+	GB_ASSERT(ts->name->kind == AstNode_Ident);
+	String name = ts->name->Ident.string;
+	if (name.len == 0) {
+		return;
+	}
+	if (name[0] == '_') {
+		return;
+	}
+	gb_printf("type %.*s\n", LIT(name));
+}
+
+void print_proc_decl(AstNodeProcDecl *pd) {
+	GB_ASSERT(pd->name->kind == AstNode_Ident);
+	String name = pd->name->Ident.string;
+	if (name.len == 0) {
+		return;
+	}
+	if (name[0] == '_') {
+		return;
+	}
+
+	String docs = alloc_comment_group_string(heap_allocator(), pd->docs);
+	defer (gb_free(heap_allocator(), docs.text));
+
+	if (docs.len > 0) {
+		gb_file_write(&gb__std_files[gbFileStandard_Output], docs.text, docs.len);
+	} else {
+		return;
+	}
+
+	ast_node(proc_type, ProcType, pd->type);
+
+	gbString params = expr_to_string(proc_type->params);
+	defer (gb_string_free(params));
+	gb_printf("proc %.*s(%s)", LIT(name), params);
+	if (proc_type->results != nullptr)  {
+		ast_node(fl, FieldList, proc_type->results);
+		isize count = fl->list.count;
+		if (count > 0) {
+			gbString results = expr_to_string(proc_type->results);
+			defer (gb_string_free(results));
+			gb_printf(" -> ");
+			if (count != 1) {
+				gb_printf("(");
+			}
+			gb_printf("%s", results);
+			if (count != 1) {
+				gb_printf(")");
+			}
+		}
+	}
+	gb_printf("\n\n");
+}
+#endif
+void print_declaration(AstNode *decl) {
+}
+
+void generate_documentation(Parser *parser) {
+	for_array(file_index, parser->files) {
+		AstFile *file = parser->files[file_index];
+		Tokenizer *tokenizer = &file->tokenizer;
+		String fullpath = tokenizer->fullpath;
+		gb_printf("%.*s\n", LIT(fullpath));
+
+		for_array(decl_index, file->decls) {
+			AstNode *decl = file->decls[decl_index];
+			print_declaration(decl);
+		}
+	}
+}

src/entity.cpp

@@ -1,8 +1,7 @@
-typedef struct Scope    Scope;
+struct Scope;
-typedef struct Checker  Checker;
+struct Checker;
-typedef struct Type     Type;
+struct Type;
-typedef struct DeclInfo DeclInfo;
+struct DeclInfo;
-// typedef enum BuiltinProcId BuiltinProcId;
 
 
 #define ENTITY_KINDS \
@@ -12,19 +11,18 @@ typedef struct DeclInfo DeclInfo;
 	ENTITY_KIND(TypeName) \
 	ENTITY_KIND(Procedure) \
 	ENTITY_KIND(Builtin) \
+	ENTITY_KIND(Alias) \
 	ENTITY_KIND(ImportName) \
 	ENTITY_KIND(LibraryName) \
-	ENTITY_KIND(TypeAlias) \
-	ENTITY_KIND(ProcedureAlias) \
 	ENTITY_KIND(Nil) \
 	ENTITY_KIND(Label)
 
-typedef enum EntityKind {
+enum EntityKind {
 #define ENTITY_KIND(k) GB_JOIN2(Entity_, k),
 	ENTITY_KINDS
 #undef ENTITY_KIND
 	Entity_Count,
-} EntityKind;
+};
 
 String const entity_strings[] = {
 #define ENTITY_KIND(k) {cast(u8 *)#k, gb_size_of(#k)-1},
@@ -32,7 +30,7 @@ String const entity_strings[] = {
 #undef ENTITY_KIND
 };
 
-typedef enum EntityFlag {
+enum EntityFlag {
 	EntityFlag_Visited       = 1<<0,
 	EntityFlag_Used          = 1<<1,
 	EntityFlag_Using         = 1<<2,
@@ -45,24 +43,20 @@ typedef enum EntityFlag {
 	EntityFlag_Value         = 1<<9,
 	EntityFlag_Sret          = 1<<10,
 	EntityFlag_BitFieldValue = 1<<11,
-} EntityFlag;
+	EntityFlag_PolyConst     = 1<<12,
+
+	EntityFlag_CVarArg       = 1<<20,
+};
 
 // Zero value means the overloading process is not yet done
-typedef enum OverloadKind {
+enum OverloadKind {
-	Overload_Unknown,
+	Overload_Unknown = 0,
-	Overload_No,
+	Overload_No      = 1,
-	Overload_Yes,
+	Overload_Yes     = 2,
-} OverloadKind;
+};
-
-typedef	enum EntityAliasKind {
-	EntityAlias_Invalid,
-	EntityAlias_Type,
-	EntityAlias_Entity,
-} EntityAliasKind;
 
 
 // An Entity is a named "thing" in the language
-typedef struct Entity Entity;
 struct Entity {
 	EntityKind kind;
 	u64        id;
@@ -70,37 +64,55 @@ struct Entity {
 	Token      token;
 	Scope *    scope;
 	Type *     type;
-	AstNode *  identifier; // Can be NULL
+	AstNode *  identifier; // Can be nullptr
-	DeclInfo * parent_proc_decl; // NULL if in file/global scope
+	DeclInfo * parent_proc_decl; // nullptr if in file/global scope
 
 	// TODO(bill): Cleanup how `using` works for entities
 	Entity *   using_parent;
 	AstNode *  using_expr;
 
+	isize      order_in_src;
+
 	union {
 		struct {
 			ExactValue value;
 		} Constant;
 		struct {
-			i32  field_index;
+			i32        field_index;
-			i32  field_src_index;
+			i32        field_src_index;
-			bool is_immutable;
+			ExactValue default_value;
-			bool is_thread_local;
+			bool       default_is_nil;
+			bool       default_is_undef;
+			bool       default_is_location;
+			bool       is_immutable;
+			String     thread_local_model;
+			bool       is_foreign;
+			bool       is_export;
+			Entity *   foreign_library;
+			AstNode *  foreign_library_ident;
+			String     link_name;
+			String     link_prefix;
 		} Variable;
 		struct {
-			bool is_type_alias;
+			bool  is_type_alias;
+			Type *type_parameter_specialization;
 		} TypeName;
 		struct {
-			bool         is_foreign;
-			String       foreign_name;
-			Entity *     foreign_library;
-			String       link_name;
-			u64          tags;
 			OverloadKind overload_kind;
+			String       link_name;
+			String       link_prefix;
+			u64          tags;
+			bool         is_export;
+			bool         is_foreign;
+			Entity *     foreign_library;
+			AstNode *    foreign_library_ident;
 		} Procedure;
 		struct {
 			i32 id;
 		} Builtin;
+		struct {
+			Entity *base;
+		} Alias;
 		struct {
 			String path;
 			String name;
@@ -112,19 +124,15 @@ struct Entity {
 			String name;
 			bool   used;
 		} LibraryName;
-		i32 TypeAlias;
-		struct {
-			Entity *original;
-		} ProcedureAlias;
 		i32 Nil;
 		struct {
-			String name;
+			String   name;
 			AstNode *node;
 		} Label;
 	};
 };
 
-gb_global Entity *e_context = NULL;
+gb_global Entity *e_context = nullptr;
 
 bool is_entity_kind_exported(EntityKind kind) {
 	switch (kind) {
@@ -139,7 +147,7 @@ bool is_entity_kind_exported(EntityKind kind) {
 
 bool is_entity_exported(Entity *e) {
 	// TODO(bill): Determine the actual exportation rules for imports of entities
-	GB_ASSERT(e != NULL);
+	GB_ASSERT(e != nullptr);
 	if (!is_entity_kind_exported(e->kind)) {
 		return false;
 	}
@@ -148,9 +156,10 @@ bool is_entity_exported(Entity *e) {
 	if (name.len == 0) {
 		return false;
 	}
-	return name.text[0] != '_';
+	return name[0] != '_';
 }
 
+
 gb_global u64 global_entity_id = 0;
 
 Entity *alloc_entity(gbAllocator a, EntityKind kind, Scope *scope, Token token, Type *type) {
@@ -170,7 +179,7 @@ Entity *make_entity_variable(gbAllocator a, Scope *scope, Token token, Type *typ
 }
 
 Entity *make_entity_using_variable(gbAllocator a, Entity *parent, Token token, Type *type) {
-	GB_ASSERT(parent != NULL);
+	GB_ASSERT(parent != nullptr);
 	token.pos = parent->token.pos;
 	Entity *entity = alloc_entity(a, Entity_Variable, parent->scope, token, type);
 	entity->using_parent = parent;
@@ -199,6 +208,16 @@ Entity *make_entity_param(gbAllocator a, Scope *scope, Token token, Type *type,
 	return entity;
 }
 
+
+Entity *make_entity_const_param(gbAllocator a, Scope *scope, Token token, Type *type, ExactValue value, bool poly_const) {
+	Entity *entity = make_entity_constant(a, scope, token, type, value);
+	entity->flags |= EntityFlag_Used;
+	if (poly_const) entity->flags |= EntityFlag_PolyConst;
+	entity->flags |= EntityFlag_Param;
+	return entity;
+}
+
+
 Entity *make_entity_field(gbAllocator a, Scope *scope, Token token, Type *type, bool is_using, i32 field_src_index) {
 	Entity *entity = make_entity_variable(a, scope, token, type, false);
 	entity->Variable.field_src_index = field_src_index;
@@ -229,6 +248,12 @@ Entity *make_entity_builtin(gbAllocator a, Scope *scope, Token token, Type *type
 	return entity;
 }
 
+Entity *make_entity_alias(gbAllocator a, Scope *scope, Token token, Type *type, Entity *base) {
+	Entity *entity = alloc_entity(a, Entity_Alias, scope, token, type);
+	entity->Alias.base = base;
+	return entity;
+}
+
 Entity *make_entity_import_name(gbAllocator a, Scope *scope, Token token, Type *type,
                                 String path, String name, Scope *import_scope) {
 	Entity *entity = alloc_entity(a, Entity_ImportName, scope, token, type);
@@ -246,23 +271,12 @@ Entity *make_entity_library_name(gbAllocator a, Scope *scope, Token token, Type
 	return entity;
 }
 
-Entity *make_entity_type_alias(gbAllocator a, Scope *scope, Token token, Type *type) {
-	Entity *entity = alloc_entity(a, Entity_TypeAlias, scope, token, type);
-	return entity;
-}
-Entity *make_entity_procedure_alias(gbAllocator a, Scope *scope, Token token, Entity *original) {
-	GB_ASSERT(original != NULL);
-	Entity *entity = alloc_entity(a, Entity_ProcedureAlias, scope, token, original->type);
-	entity->ProcedureAlias.original = original;
-	return entity;
-}
 
 
 
 
 Entity *make_entity_nil(gbAllocator a, String name, Type *type) {
-	Token token = make_token_ident(name);
+	Entity *entity = alloc_entity(a, Entity_Nil, nullptr, make_token_ident(name), type);
-	Entity *entity = alloc_entity(a, Entity_Nil, NULL, token, type);
 	return entity;
 }
 
@@ -277,6 +291,6 @@ Entity *make_entity_label(gbAllocator a, Scope *scope, Token token, Type *type,
 
 Entity *make_entity_dummy_variable(gbAllocator a, Scope *scope, Token token) {
 	token.string = str_lit("_");
-	return make_entity_variable(a, scope, token, NULL, false);
+	return make_entity_variable(a, scope, token, nullptr, false);
 }
 

src/exact_value.cpp

@@ -3,13 +3,16 @@
 // TODO(bill): Big numbers
 // IMPORTANT TODO(bill): This needs to be completely fixed!!!!!!!!
 
-typedef struct AstNode AstNode;
+struct AstNode;
+struct HashKey;
+struct Type;
+bool are_types_identical(Type *x, Type *y);
 
-typedef struct Complex128 {
+struct Complex128 {
 	f64 real, imag;
-} Complex128;
+};
 
-typedef enum ExactValueKind {
+enum ExactValueKind {
 	ExactValue_Invalid,
 
 	ExactValue_Bool,
@@ -19,11 +22,13 @@ typedef enum ExactValueKind {
 	ExactValue_Complex,
 	ExactValue_Pointer,
 	ExactValue_Compound, // TODO(bill): Is this good enough?
+	ExactValue_Procedure, // TODO(bill): Is this good enough?
+	ExactValue_Type,
 
 	ExactValue_Count,
-} ExactValueKind;
+};
 
-typedef struct ExactValue {
+struct ExactValue {
 	ExactValueKind kind;
 	union {
 		bool          value_bool;
@@ -33,8 +38,12 @@ typedef struct ExactValue {
 		i64           value_pointer;
 		Complex128    value_complex;
 		AstNode *     value_compound;
+		AstNode *     value_procedure;
+		Type *        value_type;
 	};
-} ExactValue;
+};
+
+gb_global ExactValue const empty_exact_value = {};
 
 HashKey hash_exact_value(ExactValue v) {
 	return hashing_proc(&v, gb_size_of(ExactValue));
@@ -73,7 +82,7 @@ ExactValue exact_value_i128(i128 i) {
 }
 ExactValue exact_value_u128(u128 i) {
 	ExactValue result = {ExactValue_Integer};
-	result.value_integer = *cast(i128 *)&i;
+	result.value_integer = u128_to_i128(i);
 	return result;
 }
 
@@ -96,9 +105,21 @@ ExactValue exact_value_pointer(i64 ptr) {
 	return result;
 }
 
+ExactValue exact_value_type(Type *type) {
+	ExactValue result = {ExactValue_Type};
+	result.value_type = type;
+	return result;
+}
+
+ExactValue exact_value_procedure(AstNode *node) {
+	ExactValue result = {ExactValue_Procedure};
+	result.value_procedure = node;
+	return result;
+}
+
 
 ExactValue exact_value_integer_from_string(String string) {
-	return exact_value_i128(i128_from_string(string));
+	return exact_value_u128(u128_from_string(string));
 }
 
 f64 float_from_string(String string) {
@@ -114,6 +135,39 @@ f64 float_from_string(String string) {
 		i++;
 	}
 
+#if 0
+	if (len-i > 2 &&
+	    str[i] == '0' &&
+	    str[i+1] == 'h') {
+		i += 2;
+		u8 *text = string.text;
+		isize len = string.len;
+		if (has_prefix) {
+			text += 2;
+			len -= 2;
+		}
+
+		u64 base = 16;
+
+		u64 result = {0};
+		for (isize i = 0; i < len; i++) {
+			Rune r = cast(Rune)text[i];
+			if (r == '_') {
+				continue;
+			}
+			u64 v = bit128__digit_value(r);
+			if (v >= base) {
+				break;
+			}
+			result *= base;
+			result += v;
+		}
+
+
+		return *cast(f64 *)&result;
+	}
+#endif
+
 	f64 value = 0.0;
 	for (; i < len; i++) {
 		Rune r = cast(Rune)str[i];
@@ -191,8 +245,8 @@ ExactValue exact_value_from_basic_literal(Token token) {
 	case Token_Float:   return exact_value_float_from_string(token.string);
 	case Token_Imag: {
 		String str = token.string;
-		Rune last_rune = cast(Rune)str.text[str.len-1];
+		Rune last_rune = cast(Rune)str[str.len-1];
-		str.len--; // Ignore the `i|j|k`
+		str.len--; // Ignore the 'i|j|k'
 		f64 imag = float_from_string(str);
 
 		if (last_rune == 'i') {
@@ -224,7 +278,8 @@ ExactValue exact_value_to_integer(ExactValue v) {
 		if (f == v.value_float) {
 			return exact_value_i128(i);
 		}
-	} break;
+		break;
+	}
 
 	case ExactValue_Pointer:
 		return exact_value_i64(cast(i64)cast(intptr)v.value_pointer);
@@ -289,7 +344,7 @@ ExactValue exact_value_make_imag(ExactValue v) {
 	case ExactValue_Float:
 		return exact_value_complex(0, v.value_float);
 	default:
-		GB_PANIC("Expected an integer or float type for `exact_value_make_imag`");
+		GB_PANIC("Expected an integer or float type for 'exact_value_make_imag'");
 	}
 	ExactValue r = {ExactValue_Invalid};
 	return r;
@@ -306,7 +361,8 @@ ExactValue exact_unary_operator_value(TokenKind op, ExactValue v, i32 precision)
 		case ExactValue_Complex:
 			return v;
 		}
-	} break;
+		break;
+	}
 
 	case Token_Sub:	{
 		switch (v.kind) {
@@ -314,7 +370,7 @@ ExactValue exact_unary_operator_value(TokenKind op, ExactValue v, i32 precision)
 			return v;
 		case ExactValue_Integer: {
 			ExactValue i = v;
-			i.value_integer = i128_neg(i.value_integer);
+			i.value_integer = -i.value_integer;
 			return i;
 		}
 		case ExactValue_Float: {
@@ -328,7 +384,8 @@ ExactValue exact_unary_operator_value(TokenKind op, ExactValue v, i32 precision)
 			return exact_value_complex(-real, -imag);
 		}
 		}
-	} break;
+		break;
+	}
 
 	case Token_Xor: {
 		i128 i = I128_ZERO;
@@ -336,7 +393,7 @@ ExactValue exact_unary_operator_value(TokenKind op, ExactValue v, i32 precision)
 		case ExactValue_Invalid:
 			return v;
 		case ExactValue_Integer:
-			i = i128_not(v.value_integer);
+			i = ~v.value_integer;
 			break;
 		default:
 			goto failure;
@@ -346,11 +403,12 @@ ExactValue exact_unary_operator_value(TokenKind op, ExactValue v, i32 precision)
 		// limited to the types precision
 		// IMPORTANT NOTE(bill): Max precision is 64 bits as that's how integers are stored
 		if (0 < precision && precision < 128) {
-			i = i128_and(i, i128_not(i128_shl(I128_NEG_ONE, precision)));
+			i = i & ~(I128_NEG_ONE << precision);
 		}
 
 		return exact_value_i128(i);
-	} break;
+		break;
+	}
 
 	case Token_Not: {
 		switch (v.kind) {
@@ -358,13 +416,14 @@ ExactValue exact_unary_operator_value(TokenKind op, ExactValue v, i32 precision)
 		case ExactValue_Bool:
 			return exact_value_bool(!v.value_bool);
 		}
-	} break;
+		break;
+	}
 	}
 
 failure:
 	GB_PANIC("Invalid unary operation, %.*s", LIT(token_strings[op]));
 
-	ExactValue error_value = {0};
+	ExactValue error_value = {};
 	return error_value;
 }
 
@@ -458,24 +517,25 @@ ExactValue exact_binary_operator_value(TokenKind op, ExactValue x, ExactValue y)
 		i128 b = y.value_integer;
 		i128 c = I128_ZERO;
 		switch (op) {
-		case Token_Add:    c = i128_add(a, b);                           break;
+		case Token_Add:    c = a + b;                        break;
-		case Token_Sub:    c = i128_sub(a, b);                           break;
+		case Token_Sub:    c = a - b;                        break;
-		case Token_Mul:    c = i128_mul(a, b);                           break;
+		case Token_Mul:    c = a * b;                        break;
 		case Token_Quo:    return exact_value_float(fmod(i128_to_f64(a), i128_to_f64(b)));
-		case Token_QuoEq:  c = i128_quo(a, b);                           break; // NOTE(bill): Integer division
+		case Token_QuoEq:  c = a / b;                        break; // NOTE(bill): Integer division
-		case Token_Mod:    c = i128_mod(a, b);                           break;
+		case Token_Mod:    c = a % b;                        break;
-		case Token_ModMod: c = i128_mod(i128_add(i128_mod(a, b), b), b); break;
+		case Token_ModMod: c = ((a % b) + b) % b;            break;
-		case Token_And:    c = i128_and    (a, b);                       break;
+		case Token_And:    c = a & b;                        break;
-		case Token_Or:     c = i128_or     (a, b);                       break;
+		case Token_Or:     c = a | b;                        break;
-		case Token_Xor:    c = i128_xor    (a, b);                       break;
+		case Token_Xor:    c = a ^ b;                        break;
-		case Token_AndNot: c = i128_and_not(a, b);                       break;
+		case Token_AndNot: c = i128_and_not(a, b);           break;
-		case Token_Shl:    c = i128_shl    (a, i128_to_u64(b));          break;
+		case Token_Shl:    c = a << cast(u32)i128_to_u64(b); break;
-		case Token_Shr:    c = i128_shr    (a, i128_to_u64(b));          break;
+		case Token_Shr:    c = a >> cast(u32)i128_to_u64(b); break;
 		default: goto error;
 		}
 
 		return exact_value_i128(c);
-	} break;
+		break;
+	}
 
 	case ExactValue_Float: {
 		f64 a = x.value_float;
@@ -487,7 +547,8 @@ ExactValue exact_binary_operator_value(TokenKind op, ExactValue x, ExactValue y)
 		case Token_Quo: return exact_value_float(a / b);
 		default: goto error;
 		}
-	} break;
+		break;
+	}
 
 	case ExactValue_Complex: {
 		y = exact_value_to_complex(y);
@@ -514,18 +575,31 @@ ExactValue exact_binary_operator_value(TokenKind op, ExactValue x, ExactValue y)
 			f64 s = c*c + d*d;
 			real = (a*c + b*d)/s;
 			imag = (b*c - a*d)/s;
-		} break;
+			break;
+		}
 		default: goto error;
 		}
 		return exact_value_complex(real, imag);
-	} break;
+		break;
 	}
 
-error:
+	case ExactValue_String: {
-	;		// MSVC accepts this??? apparently you cannot declare variables immediately after labels...
+		if (op != Token_Add) goto error;
-	ExactValue error_value = {0};
+
-	// gb_printf_err("Invalid binary operation: %s\n", token_kind_to_string(op));
+		// NOTE(bill): How do you minimize this over allocation?
-	return error_value;
+		String sx = x.value_string;
+		String sy = y.value_string;
+		isize len = sx.len+sy.len;
+		u8 *data = gb_alloc_array(heap_allocator(), u8, len);
+		gb_memmove(data,        sx.text, sx.len);
+		gb_memmove(data+sx.len, sy.text, sy.len);
+		return exact_value_string(make_string(data, len));
+		break;
+	}
+	}
+
+error:; // NOTE(bill): MSVC accepts this??? apparently you cannot declare variables immediately after labels...
+	return empty_exact_value;
 }
 
 gb_inline ExactValue exact_value_add(ExactValue x, ExactValue y) { return exact_binary_operator_value(Token_Add, x, y); }
@@ -557,14 +631,15 @@ bool compare_exact_values(TokenKind op, ExactValue x, ExactValue y) {
 		i128 a = x.value_integer;
 		i128 b = y.value_integer;
 		switch (op) {
-		case Token_CmpEq: return i128_eq(a, b);
+		case Token_CmpEq: return a == b;
-		case Token_NotEq: return i128_ne(a, b);
+		case Token_NotEq: return a != b;
-		case Token_Lt:    return i128_lt(a, b);
+		case Token_Lt:    return a <  b;
-		case Token_LtEq:  return i128_le(a, b);
+		case Token_LtEq:  return a <= b;
-		case Token_Gt:    return i128_gt(a, b);
+		case Token_Gt:    return a >  b;
-		case Token_GtEq:  return i128_ge(a, b);
+		case Token_GtEq:  return a >= b;
 		}
-	} break;
+		break;
+	}
 
 	case ExactValue_Float: {
 		f64 a = x.value_float;
@@ -577,7 +652,8 @@ bool compare_exact_values(TokenKind op, ExactValue x, ExactValue y) {
 		case Token_Gt:    return cmp_f64(a, b) >  0;
 		case Token_GtEq:  return cmp_f64(a, b) >= 0;
 		}
-	} break;
+		break;
+	}
 
 	case ExactValue_Complex: {
 		f64 a = x.value_complex.real;
@@ -588,22 +664,30 @@ bool compare_exact_values(TokenKind op, ExactValue x, ExactValue y) {
 		case Token_CmpEq: return cmp_f64(a, c) == 0 && cmp_f64(b, d) == 0;
 		case Token_NotEq: return cmp_f64(a, c) != 0 || cmp_f64(b, d) != 0;
 		}
-	} break;
+		break;
+	}
 
 	case ExactValue_String: {
 		String a = x.value_string;
 		String b = y.value_string;
-		isize len = gb_min(a.len, b.len);
 		// TODO(bill): gb_memcompare is used because the strings are UTF-8
 		switch (op) {
-		case Token_CmpEq: return gb_memcompare(a.text, b.text, len) == 0;
+		case Token_CmpEq: return a == b;
-		case Token_NotEq: return gb_memcompare(a.text, b.text, len) != 0;
+		case Token_NotEq: return a != b;
-		case Token_Lt:    return gb_memcompare(a.text, b.text, len) <  0;
+		case Token_Lt:    return a <  b;
-		case Token_LtEq:  return gb_memcompare(a.text, b.text, len) <= 0;
+		case Token_LtEq:  return a <= b;
-		case Token_Gt:    return gb_memcompare(a.text, b.text, len) >  0;
+		case Token_Gt:    return a >  b;
-		case Token_GtEq:  return gb_memcompare(a.text, b.text, len) >= 0;
+		case Token_GtEq:  return a >= b;
 		}
-	} break;
+		break;
+	}
+
+	case ExactValue_Type:
+		switch (op) {
+		case Token_CmpEq: return are_types_identical(x.value_type, y.value_type);
+		case Token_NotEq: return !are_types_identical(x.value_type, y.value_type);
+		}
+		break;
 	}
 
 	GB_PANIC("Invalid comparison");

src/gb/gb.h

@@ -1,4 +1,4 @@
-/* gb.h - v0.28  - Ginger Bill's C Helper Library - public domain
+/* gb.h - v0.31  - Ginger Bill's C Helper Library - public domain
                  - no warranty implied; use at your own risk
 
 	This is a single header file with a bunch of useful stuff
@@ -58,6 +58,9 @@ TODOS
 	- More date & time functions
 
 VERSION HISTORY
+	0.31  - Add gb_file_remove
+	0.30  - Changes to gbThread (and gbMutex on Windows)
+	0.29  - Add extras for gbString
 	0.28  - Handle UCS2 correctly in Win32 part
 	0.27  - OSX fixes and Linux gbAffinity
 	0.26d - Minor changes to how gbFile works
@@ -164,11 +167,11 @@ extern "C" {
 #endif
 
 
-#ifndef GB_EDIAN_ORDER
+#ifndef GB_ENDIAN_ORDER
-#define GB_EDIAN_ORDER
+#define GB_ENDIAN_ORDER
 	// TODO(bill): Is the a good way or is it better to test for certain compilers and macros?
-	#define GB_IS_BIG_EDIAN    (!*(u8*)&(u16){1})
+	#define GB_IS_BIG_ENDIAN    (!*(u8*)&(u16){1})
-	#define GB_IS_LITTLE_EDIAN (!GB_IS_BIG_EDIAN)
+	#define GB_IS_LITTLE_ENDIAN (!GB_IS_BIG_ENDIAN)
 #endif
 
 #if defined(_WIN32) || defined(_WIN64)
@@ -927,12 +930,12 @@ GB_DEF void gb_semaphore_wait   (gbSemaphore *s);
 
 
 // Mutex
-// TODO(bill): Should this be replaced with a CRITICAL_SECTION on win32 or is the better?
 typedef struct gbMutex {
-	gbSemaphore semaphore;
+#if defined(GB_SYSTEM_WINDOWS)
-	gbAtomic32  counter;
+	CRITICAL_SECTION win32_critical_section;
-	gbAtomic32  owner;
+#else
-	i32         recursion;
+	pthread_mutex_t pthread_mutex;
+#endif
 } gbMutex;
 
 GB_DEF void gb_mutex_init    (gbMutex *m);
@@ -956,7 +959,7 @@ gb_mutex_init(&m);
 
 
 
-#define GB_THREAD_PROC(name) void name(void *data)
+#define GB_THREAD_PROC(name) isize name(struct gbThread *thread)
 typedef GB_THREAD_PROC(gbThreadProc);
 
 typedef struct gbThread {
@@ -967,7 +970,9 @@ typedef struct gbThread {
 #endif
 
 	gbThreadProc *proc;
-	void *        data;
+	void *        user_data;
+	isize         user_index;
+	isize         return_value;
 
 	gbSemaphore   semaphore;
 	isize         stack_size;
@@ -975,7 +980,7 @@ typedef struct gbThread {
 } gbThread;
 
 GB_DEF void gb_thread_init            (gbThread *t);
-GB_DEF void gb_thread_destory         (gbThread *t);
+GB_DEF void gb_thread_destroy         (gbThread *t);
 GB_DEF void gb_thread_start           (gbThread *t, gbThreadProc *proc, void *data);
 GB_DEF void gb_thread_start_with_stack(gbThread *t, gbThreadProc *proc, void *data, isize stack_size);
 GB_DEF void gb_thread_join            (gbThread *t);
@@ -1521,6 +1526,8 @@ GB_DEF void     gb_string_clear          (gbString str);
 GB_DEF gbString gb_string_append         (gbString str, gbString const other);
 GB_DEF gbString gb_string_append_length  (gbString str, void const *other, isize num_bytes);
 GB_DEF gbString gb_string_appendc        (gbString str, char const *other);
+GB_DEF gbString gb_string_append_rune    (gbString str, Rune r);
+GB_DEF gbString gb_string_append_fmt     (gbString str, char const *fmt, ...);
 GB_DEF gbString gb_string_set            (gbString str, char const *cstr);
 GB_DEF gbString gb_string_make_space_for (gbString str, isize add_len);
 GB_DEF isize    gb_string_allocation_size(gbString const str);
@@ -2044,6 +2051,7 @@ GB_DEF b32        gb_file_exists         (char const *filepath);
 GB_DEF gbFileTime gb_file_last_write_time(char const *filepath);
 GB_DEF b32        gb_file_copy           (char const *existing_filename, char const *new_filename, b32 fail_if_exists);
 GB_DEF b32        gb_file_move           (char const *existing_filename, char const *new_filename);
+GB_DEF b32        gb_file_remove         (char const *filename);
 
 
 #ifndef GB_PATH_SEPARATOR
@@ -3602,7 +3610,7 @@ extern "C" {
 #endif
 
 void gb_assert_handler(char const *condition, char const *file, i32 line, char const *msg, ...) {
-	gb_printf_err("%s:%d: Assert Failure: ", file, line);
+	gb_printf_err("%s(%d): Assert Failure: ", file, line);
 	if (condition)
 		gb_printf_err( "`%s` ", condition);
 	if (msg) {
@@ -4590,59 +4598,44 @@ gb_inline void gb_semaphore_release(gbSemaphore *s) { gb_semaphore_post(s, 1); }
 #error
 #endif
 
-// NOTE(bill): THIS IS FUCKING AWESOME THAT THIS "MUTEX" IS FAST AND RECURSIVE TOO!
-// NOTE(bill): WHO THE FUCK NEEDS A NORMAL MUTEX NOW?!?!?!?!
 gb_inline void gb_mutex_init(gbMutex *m) {
-	gb_atomic32_store(&m->counter, 0);
+#if defined(GB_SYSTEM_WINDOWS)
-	gb_atomic32_store(&m->owner, gb_thread_current_id());
+	InitializeCriticalSection(&m->win32_critical_section);
-	gb_semaphore_init(&m->semaphore);
+#else
-	m->recursion = 0;
+	pthread_mutex_init(&m->pthread_mutex, NULL);
+#endif
 }
 
-gb_inline void gb_mutex_destroy(gbMutex *m) { gb_semaphore_destroy(&m->semaphore); }
+gb_inline void gb_mutex_destroy(gbMutex *m) {
+#if defined(GB_SYSTEM_WINDOWS)
+	DeleteCriticalSection(&m->win32_critical_section);
+#else
+	pthread_mutex_destroy(&m->pthread_mutex);
+#endif
+}
 
 gb_inline void gb_mutex_lock(gbMutex *m) {
-	i32 thread_id = cast(i32)gb_thread_current_id();
+#if defined(GB_SYSTEM_WINDOWS)
-	if (gb_atomic32_fetch_add(&m->counter, 1) > 0) {
+	EnterCriticalSection(&m->win32_critical_section);
-		if (thread_id != gb_atomic32_load(&m->owner))
+#else
-			gb_semaphore_wait(&m->semaphore);
+	pthread_mutex_lock(&m->pthread_mutex);
-	}
+#endif
-
-	gb_atomic32_store(&m->owner, thread_id);
-	m->recursion++;
 }
 
 gb_inline b32 gb_mutex_try_lock(gbMutex *m) {
-	i32 thread_id = cast(i32)gb_thread_current_id();
+#if defined(GB_SYSTEM_WINDOWS)
-	if (gb_atomic32_load(&m->owner) == thread_id) {
+	return TryEnterCriticalSection(&m->win32_critical_section) != 0;
-		gb_atomic32_fetch_add(&m->counter, 1);
+#else
-	} else {
+	return pthread_mutex_trylock(&m->pthread_mutex) == 0;
-		i32 expected = 0;
+#endif
-		if (gb_atomic32_load(&m->counter) != 0)
-			return false;
-		if (!gb_atomic32_compare_exchange(&m->counter, expected, 1))
-			return false;
-		gb_atomic32_store(&m->owner, thread_id);
-	}
-
-	m->recursion++;
-	return true;
 }
 
 gb_inline void gb_mutex_unlock(gbMutex *m) {
-	i32 recursion;
+#if defined(GB_SYSTEM_WINDOWS)
-	i32 thread_id = cast(i32)gb_thread_current_id();
+	LeaveCriticalSection(&m->win32_critical_section);
-
+#else
-	GB_ASSERT(thread_id == gb_atomic32_load(&m->owner));
+	pthread_mutex_unlock(&m->pthread_mutex);
-
+#endif
-	recursion = --m->recursion;
-	if (recursion == 0)
-		gb_atomic32_store(&m->owner, thread_id);
-
-	if (gb_atomic32_fetch_add(&m->counter, -1) > 1) {
-		if (recursion == 0)
-			gb_semaphore_release(&m->semaphore);
-	}
 }
 
 
@@ -4661,7 +4654,7 @@ void gb_thread_init(gbThread *t) {
 	gb_semaphore_init(&t->semaphore);
 }
 
-void gb_thread_destory(gbThread *t) {
+void gb_thread_destroy(gbThread *t) {
 	if (t->is_running) gb_thread_join(t);
 	gb_semaphore_destroy(&t->semaphore);
 }
@@ -4669,22 +4662,32 @@ void gb_thread_destory(gbThread *t) {
 
 gb_inline void gb__thread_run(gbThread *t) {
 	gb_semaphore_release(&t->semaphore);
-	t->proc(t->data);
+	t->return_value = t->proc(t);
 }
 
 #if defined(GB_SYSTEM_WINDOWS)
-	gb_inline DWORD __stdcall gb__thread_proc(void *arg) { gb__thread_run(cast(gbThread *)arg); return 0; }
+	gb_inline DWORD __stdcall gb__thread_proc(void *arg) {
+		gbThread *t = cast(gbThread *)arg;
+		gb__thread_run(t);
+		t->is_running = false;
+		return 0;
+	}
 #else
-	gb_inline void *          gb__thread_proc(void *arg) { gb__thread_run(cast(gbThread *)arg); return NULL; }
+	gb_inline void *          gb__thread_proc(void *arg) {
+		gbThread *t = cast(gbThread *)arg;
+		gb__thread_run(t);
+		t->is_running = false;
+		return NULL;
+	}
 #endif
 
-gb_inline void gb_thread_start(gbThread *t, gbThreadProc *proc, void *data) { gb_thread_start_with_stack(t, proc, data, 0); }
+gb_inline void gb_thread_start(gbThread *t, gbThreadProc *proc, void *user_data) { gb_thread_start_with_stack(t, proc, user_data, 0); }
 
-gb_inline void gb_thread_start_with_stack(gbThread *t, gbThreadProc *proc, void *data, isize stack_size) {
+gb_inline void gb_thread_start_with_stack(gbThread *t, gbThreadProc *proc, void *user_data, isize stack_size) {
 	GB_ASSERT(!t->is_running);
 	GB_ASSERT(proc != NULL);
 	t->proc = proc;
-	t->data = data;
+	t->user_data = user_data;
 	t->stack_size = stack_size;
 
 #if defined(GB_SYSTEM_WINDOWS)
@@ -4695,8 +4698,9 @@ gb_inline void gb_thread_start_with_stack(gbThread *t, gbThreadProc *proc, void
 		pthread_attr_t attr;
 		pthread_attr_init(&attr);
 		pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
-		if (stack_size != 0)
+		if (stack_size != 0) {
 			pthread_attr_setstacksize(&attr, stack_size);
+		}
 		pthread_create(&t->posix_handle, &attr, gb__thread_proc, t);
 		pthread_attr_destroy(&attr);
 	}
@@ -5398,7 +5402,8 @@ gb_inline gbTempArenaMemory gb_temp_arena_memory_begin(gbArena *arena) {
 }
 
 gb_inline void gb_temp_arena_memory_end(gbTempArenaMemory tmp) {
-	GB_ASSERT(tmp.arena->total_allocated >= tmp.original_count);
+	GB_ASSERT_MSG(tmp.arena->total_allocated >= tmp.original_count,
+	              "%td >= %td", tmp.arena->total_allocated, tmp.original_count);
 	GB_ASSERT(tmp.arena->temp_count > 0);
 	tmp.arena->total_allocated = tmp.original_count;
 	tmp.arena->temp_count--;
@@ -6573,6 +6578,26 @@ gb_inline gbString gb_string_appendc(gbString str, char const *other) {
 	return gb_string_append_length(str, other, gb_strlen(other));
 }
 
+gbString gb_string_append_rune(gbString str, Rune r) {
+	if (r >= 0) {
+		u8 buf[8] = {0};
+		isize len = gb_utf8_encode_rune(buf, r);
+		return gb_string_append_length(str, buf, len);
+	}
+	return str;
+}
+
+gbString gb_string_append_fmt(gbString str, char const *fmt, ...) {
+	isize res;
+	char buf[4096] = {0};
+	va_list va;
+	va_start(va, fmt);
+	res = gb_snprintf_va(str, gb_count_of(buf)-1, fmt, va);
+	va_end(va);
+	return gb_string_append_length(str, buf, res);
+}
+
+
 
 gbString gb_string_set(gbString str, char const *cstr) {
 	isize len = gb_strlen(cstr);
@@ -7403,13 +7428,13 @@ u64 gb_murmur64_seed(void const *data_, isize len, u64 seed) {
 			if (w_len_) *w_len_ = w_len;
 			return NULL;
 		}
-		w_len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text, len, NULL, 0);
+		w_len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text, cast(int)len, NULL, 0);
 		if (w_len == 0) {
 			if (w_len_) *w_len_ = w_len;
 			return NULL;
 		}
 		w_text = gb_alloc_array(a, wchar_t, w_len+1);
-		w_len1 = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text, len, w_text, w_len);
+		w_len1 = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text, cast(int)len, w_text, cast(int)w_len);
 		if (w_len1 == 0) {
 			gb_free(a, w_text);
 			if (w_len_) *w_len_ = 0;
@@ -7908,6 +7933,19 @@ gb_inline b32 gb_file_move(char const *existing_filename, char const *new_filena
 	return result;
 }
 
+b32 gb_file_remove(char const *filename) {
+	wchar_t *w_filename = NULL;
+	gbAllocator a = gb_heap_allocator();
+	b32 result = false;
+	w_filename = gb__alloc_utf8_to_ucs2(a, filename, NULL);
+	if (w_filename == NULL) {
+		return false;
+	}
+	result = DeleteFileW(w_filename);
+	gb_free(a, w_filename);
+	return result;
+}
+
 
 
 #else
@@ -7916,7 +7954,7 @@ gbFileTime gb_file_last_write_time(char const *filepath) {
 	time_t result = 0;
 	struct stat file_stat;
 
-	if (stat(filepath, &file_stat)) {
+	if (stat(filepath, &file_stat) == 0) {
 		result = file_stat.st_mtime;
 	}
 
@@ -7946,13 +7984,20 @@ gb_inline b32 gb_file_copy(char const *existing_filename, char const *new_filena
 
 gb_inline b32 gb_file_move(char const *existing_filename, char const *new_filename) {
 	if (link(existing_filename, new_filename) == 0) {
-		if (unlink(existing_filename) != -1) {
+		return unlink(existing_filename) != -1;
-			return true;
-		}
 	}
 	return false;
 }
 
+b32 gb_file_remove(char const *filename) {
+#if defined(GB_SYSTEM_OSX)
+	return unlink(filename) != -1;
+#else
+	return remove(filename) == 0;
+#endif
+}
+
+
 #endif
 
 
@@ -8057,17 +8102,17 @@ char *gb_path_get_full_name(gbAllocator a, char const *path) {
 		return NULL;
 	}
 	w_fullpath = gb_alloc_array(gb_heap_allocator(), wchar_t, w_len+1);
-	GetFullPathNameW(w_path, w_len, w_fullpath, NULL);
+	GetFullPathNameW(w_path, cast(int)w_len, w_fullpath, NULL);
 	w_fullpath[w_len] = 0;
 	gb_free(gb_heap_allocator(), w_path);
 
-	new_len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, w_fullpath, w_len, NULL, 0, NULL, NULL);
+	new_len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, w_fullpath, cast(int)w_len, NULL, 0, NULL, NULL);
 	if (new_len == 0) {
 		gb_free(gb_heap_allocator(), w_fullpath);
 		return NULL;
 	}
 	new_path = gb_alloc_array(a, char, new_len+1);
-	new_len1 = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, w_fullpath, w_len, new_path, new_len, NULL, NULL);
+	new_len1 = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, w_fullpath, cast(int)w_len, new_path, cast(int)new_len, NULL, NULL);
 	if (new_len1 == 0) {
 		gb_free(gb_heap_allocator(), w_fullpath);
 		gb_free(a, new_path);

src/integer128.cpp

@@ -1,16 +1,25 @@
-typedef struct u128 {u64 lo; u64 hi;} u128;
-typedef struct i128 {u64 lo; i64 hi;} i128;
 
-#define BIT128_U64_HIGHBIT 0x8000000000000000ul
+#if defined(GB_COMPILER_MSVC) && defined(GB_ARCH_64_BIT) && defined(GB_CPU_X86)
-#define BIT128_U64_BITS62  0x7ffffffffffffffful
+	#define MSVC_AMD64_INTRINSICS
-#define BIT128_U64_ALLBITS 0xfffffffffffffffful
+	#include <intrin.h>
+	#pragma intrinsic(_mul128)
+#endif
+
+#define BIT128_U64_HIGHBIT 0x8000000000000000ull
+#define BIT128_U64_BITS62  0x7fffffffffffffffull
+#define BIT128_U64_ALLBITS 0xffffffffffffffffull
+
+
+typedef struct u128 { u64 lo; u64 hi; } u128;
+typedef struct i128 { u64 lo; i64 hi; } i128;
+
 
 static u128 const U128_ZERO = {0, 0};
 static u128 const U128_ONE  = {1, 0};
 static i128 const I128_ZERO = {0, 0};
 static i128 const I128_ONE  = {1, 0};
 static u128 const U128_NEG_ONE = {BIT128_U64_ALLBITS, BIT128_U64_ALLBITS};
-static i128 const I128_NEG_ONE = {BIT128_U64_ALLBITS, BIT128_U64_ALLBITS};
+static i128 const I128_NEG_ONE = {BIT128_U64_ALLBITS, cast(i64)BIT128_U64_ALLBITS};
 
 u128 u128_lo_hi      (u64 lo, u64 hi);
 u128 u128_from_u32   (u32 u);
@@ -31,10 +40,12 @@ i128 i128_from_string(String string);
 u64 u128_to_u64(u128 a);
 i64 u128_to_i64(u128 a);
 f64 u128_to_f64(u128 a);
+i128 u128_to_i128(u128 a);
 
 u64 i128_to_u64(i128 a);
 i64 i128_to_i64(i128 a);
 f64 i128_to_f64(i128 a);
+u128 i128_to_u128(i128 a);
 
 String u128_to_string(u128 a, char *buf, isize len);
 String i128_to_string(i128 a, char *buf, isize len);
@@ -84,6 +95,48 @@ void i128_divide (i128 num, i128 den, i128 *quo, i128 *rem);
 i128 i128_quo    (i128 a, i128 b);
 i128 i128_mod    (i128 a, i128 b);
 
+bool operator==(u128 const &a, u128 const &b) { return u128_eq(a, b); }
+bool operator!=(u128 const &a, u128 const &b) { return u128_ne(a, b); }
+bool operator< (u128 const &a, u128 const &b) { return u128_lt(a, b); }
+bool operator> (u128 const &a, u128 const &b) { return u128_gt(a, b); }
+bool operator<=(u128 const &a, u128 const &b) { return u128_le(a, b); }
+bool operator>=(u128 const &a, u128 const &b) { return u128_ge(a, b); }
+
+u128 operator+ (u128 const &a, u128 const &b) { return u128_add(a, b); }
+u128 operator- (u128 const &a, u128 const &b) { return u128_sub(a, b); }
+u128 operator* (u128 const &a, u128 const &b) { return u128_mul(a, b); }
+u128 operator/ (u128 const &a, u128 const &b) { return u128_quo(a, b); }
+u128 operator% (u128 const &a, u128 const &b) { return u128_mod(a, b); }
+u128 operator& (u128 const &a, u128 const &b) { return u128_and(a, b); }
+u128 operator| (u128 const &a, u128 const &b) { return u128_or (a, b); }
+u128 operator^ (u128 const &a, u128 const &b) { return u128_xor(a, b); }
+u128 operator~ (u128 const &a)                { return u128_not(a); }
+u128 operator+ (u128 const &a)                { return a; }
+u128 operator- (u128 const &a)                { return u128_neg(a); }
+u128 operator<<(u128 const &a, u32 const &b)  { return u128_shl(a, b); }
+u128 operator>>(u128 const &a, u32 const &b)  { return u128_shr(a, b); }
+
+
+bool operator==(i128 const &a, i128 const &b) { return i128_eq(a, b); }
+bool operator!=(i128 const &a, i128 const &b) { return i128_ne(a, b); }
+bool operator< (i128 const &a, i128 const &b) { return i128_lt(a, b); }
+bool operator> (i128 const &a, i128 const &b) { return i128_gt(a, b); }
+bool operator<=(i128 const &a, i128 const &b) { return i128_le(a, b); }
+bool operator>=(i128 const &a, i128 const &b) { return i128_ge(a, b); }
+
+i128 operator+ (i128 const &a, i128 const &b) { return i128_add(a, b); }
+i128 operator- (i128 const &a, i128 const &b) { return i128_sub(a, b); }
+i128 operator* (i128 const &a, i128 const &b) { return i128_mul(a, b); }
+i128 operator/ (i128 const &a, i128 const &b) { return i128_quo(a, b); }
+i128 operator% (i128 const &a, i128 const &b) { return i128_mod(a, b); }
+i128 operator& (i128 const &a, i128 const &b) { return i128_and(a, b); }
+i128 operator| (i128 const &a, i128 const &b) { return i128_or (a, b); }
+i128 operator^ (i128 const &a, i128 const &b) { return i128_xor(a, b); }
+i128 operator~ (i128 const &a)                { return i128_not(a); }
+i128 operator+ (i128 const &a)                { return a; }
+i128 operator- (i128 const &a)                { return i128_neg(a); }
+i128 operator<<(i128 const &a, u32 b)         { return i128_shl(a, b); }
+i128 operator>>(i128 const &a, u32 b)         { return i128_shr(a, b); }
 
 ////////////////////////////////////////////////////////////////
 
@@ -99,7 +152,12 @@ u64 bit128__digit_value(Rune r) {
 	return 16; // NOTE(bill): Larger than highest possible
 }
 
-u128 u128_lo_hi(u64 lo, u64 hi) { return (u128){lo, hi}; }
+u128 u128_lo_hi(u64 lo, u64 hi) {
+	u128 r = {};
+	r.lo = lo;
+	r.hi = hi;
+	return r;
+}
 u128 u128_from_u32(u32 u)       { return u128_lo_hi(cast(u64)u, 0); }
 u128 u128_from_u64(u64 u)       { return u128_lo_hi(cast(u64)u, 0); }
 u128 u128_from_i64(i64 u)       { return u128_lo_hi(cast(u64)u, u < 0 ? -1 : 0); }
@@ -109,8 +167,8 @@ u128 u128_from_string(String string) {
 	// TODO(bill): Allow for numbers with underscores in them
 	u64 base = 10;
 	bool has_prefix = false;
-	if (string.len > 2 && string.text[0] == '0') {
+	if (string.len > 2 && string[0] == '0') {
-		switch (string.text[1]) {
+		switch (string[1]) {
 		case 'b': base = 2;  has_prefix = true; break;
 		case 'o': base = 8;  has_prefix = true; break;
 		case 'd': base = 10; has_prefix = true; break;
@@ -160,8 +218,8 @@ i128 i128_from_string(String string) {
 	// TODO(bill): Allow for numbers with underscores in them
 	u64 base = 10;
 	bool has_prefix = false;
-	if (string.len > 2 && string.text[0] == '0') {
+	if (string.len > 2 && string[0] == '0') {
-		switch (string.text[1]) {
+		switch (string[1]) {
 		case 'b': base = 2;  has_prefix = true; break;
 		case 'o': base = 8;  has_prefix = true; break;
 		case 'd': base = 10; has_prefix = true; break;
@@ -219,6 +277,12 @@ f64 u128_to_f64(u128 a) {
 
 	return -((cast(f64)h * 18446744073709551616.0) + cast(f64)l);
 }
+i128 u128_to_i128(u128 a) {
+	return *cast(i128 *)&a;
+}
+
+
+
 
 u64 i128_to_u64(i128 a) {
 	return (a.lo&BIT128_U64_BITS62) | (a.hi&BIT128_U64_HIGHBIT);
@@ -241,6 +305,10 @@ f64 i128_to_f64(i128 a) {
 
 	return -((cast(f64)h * 18446744073709551616.0) + cast(f64)l);
 }
+u128 i128_to_u128(i128 a) {
+	return *cast(u128 *)&a;
+}
+
 
 
 String u128_to_string(u128 v, char *out_buf, isize out_buf_len) {
@@ -332,7 +400,11 @@ u128 u128_shl(u128 a, u32 n) {
 	if (n >= 128) {
 		return u128_lo_hi(0, 0);
 	}
-
+#if 0 && defined(MSVC_AMD64_INTRINSICS)
+	a.hi = __shiftleft128(a.lo, a.hi, n);
+	a.lo = a.lo << n;
+	return a;
+#else
 	if (n >= 64) {
 		n -= 64;
 		a.hi = a.lo;
@@ -347,13 +419,18 @@ u128 u128_shl(u128 a, u32 n) {
 		a.lo <<= n;
 	}
 	return a;
+#endif
 }
 
 u128 u128_shr(u128 a, u32 n) {
 	if (n >= 128) {
 		return u128_lo_hi(0, 0);
 	}
-
+#if 0 && defined(MSVC_AMD64_INTRINSICS)
+	a.lo = __shiftright128(a.lo, a.hi, n);
+	a.hi = a.hi >> n;
+	return a;
+#else
 	if (n >= 64) {
 		n -= 64;
 		a.lo = a.hi;
@@ -367,6 +444,7 @@ u128 u128_shr(u128 a, u32 n) {
 		a.hi >>= n;
 	}
 	return a;
+#endif
 }
 
 
@@ -383,6 +461,14 @@ u128 u128_mul(u128 a, u128 b) {
 		return a;
 	}
 
+
+#if defined(MSVC_AMD64_INTRINSICS)
+	if (a.hi == 0 && b.hi == 0) {
+		a.lo = _umul128(a.lo, b.lo, &a.hi);
+		return a;
+	}
+#endif
+
 	u128 res = {0};
 	u128 t = b;
 	for (u32 i = 0; i < 128; i++) {
@@ -396,44 +482,54 @@ u128 u128_mul(u128 a, u128 b) {
 	return res;
 }
 
-void u128_divide(u128 num, u128 den, u128 *quo, u128 *rem) {
+bool u128_hibit(u128 const &d) { return (d.hi & BIT128_U64_HIGHBIT) != 0; }
-	if (u128_eq(den, U128_ZERO)) {
+bool i128_hibit(i128 const &d) { return d.hi < 0; }
-		if (quo) *quo = u128_from_u64(num.lo/den.lo);
+
+void u128_divide(u128 a, u128 b, u128 *quo, u128 *rem) {
+	if (u128_eq(b, U128_ZERO)) {
+		if (quo) *quo = u128_from_u64(a.lo/b.lo);
 		if (rem) *rem = U128_ZERO;
-	} else {
+		return;
-		u128 n = num;
-		u128 d = den;
-		u128 x = U128_ONE;
-		u128 r = U128_ZERO;
-
-		while (u128_ge(n, d) && ((u128_shr(d, 128-1).lo&1) == 0)) {
-			x = u128_shl(x, 1);
-			d = u128_shl(d, 1);
-		}
-
-		while (u128_ne(x, U128_ZERO)) {
-			if (u128_ge(n, d)) {
-				n = u128_sub(n, d);
-				r = u128_or(r, x);
-			}
-
-			x = u128_shr(x, 1);
-			d = u128_shr(d, 1);
-		}
-
-		if (quo) *quo = r;
-		if (rem) *rem = n;
 	}
+	u128 r = a;
+	u128 d = b;
+	u128 x = U128_ONE;
+	u128 q = U128_ZERO;
+
+	while (u128_ge(r, d) && !u128_hibit(d)) {
+		x = u128_shl(x, 1);
+		d = u128_shl(d, 1);
+	}
+
+	while (u128_ne(x, U128_ZERO)) {
+		if (u128_ge(r, d)) {
+			r = u128_sub(r, d);
+			q = u128_or(q, x);
+		}
+
+		x = u128_shr(x, 1);
+		d = u128_shr(d, 1);
+	}
+
+	if (quo) *quo = q;
+	if (rem) *rem = r;
 }
 
 u128 u128_quo(u128 a, u128 b) {
+	if (a.hi == 0 && b.hi == 0) {
+		return u128_from_u64(a.lo/b.lo);
+	}
+
 	u128 res = {0};
-	u128_divide(a, b, &res, NULL);
+	u128_divide(a, b, &res, nullptr);
 	return res;
 }
 u128 u128_mod(u128 a, u128 b) {
+	if (a.hi == 0 && b.hi == 0) {
+		return u128_from_u64(a.lo%b.lo);
+	}
 	u128 res = {0};
-	u128_divide(a, b, NULL, &res);
+	u128_divide(a, b, nullptr, &res);
 	return res;
 }
 
@@ -491,6 +587,11 @@ i128 i128_shl(i128 a, u32 n) {
 		return i128_lo_hi(0, 0);
 	}
 
+#if 0 && defined(MSVC_AMD64_INTRINSICS)
+	a.hi = __shiftleft128(a.lo, a.hi, n);
+	a.lo = a.lo << n;
+	return a;
+#else
 	if (n >= 64) {
 		n -= 64;
 		a.hi = a.lo;
@@ -505,6 +606,7 @@ i128 i128_shl(i128 a, u32 n) {
 		a.lo <<= n;
 	}
 	return a;
+#endif
 }
 
 i128 i128_shr(i128 a, u32 n) {
@@ -512,6 +614,11 @@ i128 i128_shr(i128 a, u32 n) {
 		return i128_lo_hi(0, 0);
 	}
 
+#if 0 && defined(MSVC_AMD64_INTRINSICS)
+	a.lo = __shiftright128(a.lo, a.hi, n);
+	a.hi = a.hi >> n;
+	return a;
+#else
 	if (n >= 64) {
 		n -= 64;
 		a.lo = a.hi;
@@ -525,6 +632,7 @@ i128 i128_shr(i128 a, u32 n) {
 		a.hi >>= n;
 	}
 	return a;
+#endif
 }
 
 
@@ -541,6 +649,13 @@ i128 i128_mul(i128 a, i128 b) {
 		return a;
 	}
 
+#if defined(MSVC_AMD64_INTRINSICS)
+	if (a.hi == 0 && b.hi == 0) {
+		a.lo = _mul128(a.lo, b.lo, &a.hi);
+		return a;
+	}
+#endif
+
 	i128 res = {0};
 	i128 t = b;
 	for (u32 i = 0; i < 128; i++) {
@@ -554,59 +669,71 @@ i128 i128_mul(i128 a, i128 b) {
 	return res;
 }
 
-void i128_divide(i128 a, i128 b, i128 *quo, i128 *rem) {
+void i128_divide(i128 a, i128 b, i128 *quo_, i128 *rem_) {
-	// TODO(bill): Which one is correct?!
+	// TODO(bill): Optimize this i128 division calculation
-#if 1
+	i128 iquo = {0};
-	i128 s = i128_shr(b, 127);
+	i128 irem = {0};
-	b = i128_sub(i128_xor(b, s), s);
+	if (a.hi == 0 && b.hi == 0) {
-	s = i128_shr(a, 127);
+		u64 q = a.lo / b.lo;
-	b = i128_sub(i128_xor(a, s), s);
+		u64 r = a.lo % b.lo;
-
+		iquo = i128_from_u64(q);
-	u128 n, r = {0};
+		irem = i128_from_u64(r);
-	u128_divide(*cast(u128 *)&a, *cast(u128 *)&b, &n, &r);
+	} else if ((~a.hi) == 0 && (~b.hi) == 0) {
-	i128 ni = *cast(i128 *)&n;
+		i64 x = i128_to_i64(a);
-	i128 ri = *cast(i128 *)&r;
+		i64 y = i128_to_i64(b);
-
+		i64 q = x / y;
-	if (quo) *quo = i128_sub(i128_xor(ri, s), s);
+		i64 r = x % y;
-	if (rem) *rem = i128_sub(i128_xor(ni, s), s);
+		iquo = i128_from_i64(q);
-#else
+		irem = i128_from_i64(r);
-	if (i128_eq(b, I128_ZERO)) {
+	} else if (a.hi > 0 || b.hi > 0) {
-		if (quo) *quo = i128_from_u64(a.lo/b.lo);
+		u128 q, r = {0};
-		if (rem) *rem = I128_ZERO;
+		u128_divide(*cast(u128 *)&a, *cast(u128 *)&b, &q, &r);
+		iquo = *cast(i128 *)&q;
+		irem = *cast(i128 *)&r;
+	} else if (i128_eq(b, I128_ZERO)) {
+		iquo = i128_from_u64(a.lo/b.lo);
 	} else {
-		i128 n = a;
+		i32 rem_sign = 1;
-		i128 d = b;
+		i32 quo_sign = 1;
-		i128 x = I128_ONE;
+		if (i128_lt(a, I128_ZERO)) {
-		i128 r = I128_ZERO;
+			a = i128_neg(a);
-
+			rem_sign = -1;
-		while (i128_ge(n, d) && ((i128_shr(d, 128-1).lo&1) == 0)) {
-			x = i128_shl(x, 1);
-			d = i128_shl(d, 1);
 		}
+		if (i128_lt(b, I128_ZERO)) {
+			b = i128_neg(b);
+			quo_sign = -1;
+		}
+		quo_sign *= rem_sign;
 
-		while (i128_ne(x, I128_ZERO)) {
+		iquo = a;
-			if (i128_ge(n, d)) {
+
-				n = i128_sub(n, d);
+		for (isize i = 0; i < 128; i++) {
-				r = i128_or(r, x);
+			irem = i128_shl(irem, 1);
+			if (i128_lt(iquo, I128_ZERO)) {
+				irem.lo |= 1;
+			}
+			iquo = i128_shl(iquo, 1);
+			if (i128_ge(irem, b)) {
+				irem = i128_sub(irem, b);
+				iquo = i128_add(iquo, I128_ONE);
 			}
-
-			x = i128_shr(x, 1);
-			d = i128_shr(d, 1);
 		}
 
-		if (quo) *quo = r;
+		if (quo_sign < 0) iquo = i128_neg(iquo);
-		if (rem) *rem = n;
+		if (rem_sign < 0) irem = i128_neg(irem);
 	}
-#endif
+
+	if (quo_) *quo_ = iquo;
+	if (rem_) *rem_ = irem;
 }
 
 i128 i128_quo(i128 a, i128 b) {
 	i128 res = {0};
-	i128_divide(a, b, &res, NULL);
+	i128_divide(a, b, &res, nullptr);
 	return res;
 }
 i128 i128_mod(i128 a, i128 b) {
 	i128 res = {0};
-	i128_divide(a, b, NULL, &res);
+	i128_divide(a, b, nullptr, &res);
 	return res;
 }

src/ir_opt.cpp

@@ -1,6 +1,6 @@
 // Optimizations for the IR code
 
-void ir_opt_add_operands(irValueArray *ops, irInstr *i) {
+void ir_opt_add_operands(Array<irValue *> *ops, irInstr *i) {
 	switch (i->kind) {
 	case irInstr_Comment:
 		break;
@@ -39,7 +39,7 @@ void ir_opt_add_operands(irValueArray *ops, irInstr *i) {
 		array_add(ops, i->If.cond);
 		break;
 	case irInstr_Return:
-		if (i->Return.value != NULL) {
+		if (i->Return.value != nullptr) {
 			array_add(ops, i->Return.value);
 		}
 		break;
@@ -48,7 +48,7 @@ void ir_opt_add_operands(irValueArray *ops, irInstr *i) {
 		break;
 	case irInstr_Phi:
 		for_array(j, i->Phi.edges) {
-			array_add(ops, i->Phi.edges.e[j]);
+			array_add(ops, i->Phi.edges[j]);
 		}
 		break;
 	case irInstr_Unreachable:
@@ -80,6 +80,8 @@ void ir_opt_add_operands(irValueArray *ops, irInstr *i) {
 		// break;
 	case irInstr_StartupRuntime:
 		break;
+
+	#if 0
 	case irInstr_BoundsCheck:
 		array_add(ops, i->BoundsCheck.index);
 		array_add(ops, i->BoundsCheck.len);
@@ -88,6 +90,7 @@ void ir_opt_add_operands(irValueArray *ops, irInstr *i) {
 		array_add(ops, i->SliceBoundsCheck.low);
 		array_add(ops, i->SliceBoundsCheck.high);
 		break;
+	#endif
 	}
 }
 
@@ -97,24 +100,24 @@ void ir_opt_add_operands(irValueArray *ops, irInstr *i) {
 
 void ir_opt_block_replace_pred(irBlock *b, irBlock *from, irBlock *to) {
 	for_array(i, b->preds) {
-		irBlock *pred = b->preds.e[i];
+		irBlock *pred = b->preds[i];
 		if (pred == from) {
-			b->preds.e[i] = to;
+			b->preds[i] = to;
 		}
 	}
 }
 
 void ir_opt_block_replace_succ(irBlock *b, irBlock *from, irBlock *to) {
 	for_array(i, b->succs) {
-		irBlock *succ = b->succs.e[i];
+		irBlock *succ = b->succs[i];
 		if (succ == from) {
-			b->succs.e[i] = to;
+			b->succs[i] = to;
 		}
 	}
 }
 
 bool ir_opt_block_has_phi(irBlock *b) {
-	return b->instrs.e[0]->Instr.kind == irInstr_Phi;
+	return b->instrs[0]->Instr.kind == irInstr_Phi;
 }
 
 
@@ -126,10 +129,10 @@ bool ir_opt_block_has_phi(irBlock *b) {
 
 
 
-irValueArray ir_get_block_phi_nodes(irBlock *b) {
+Array<irValue *> ir_get_block_phi_nodes(irBlock *b) {
-	irValueArray phis = {0};
+	Array<irValue *> phis = {0};
 	for_array(i, b->instrs) {
-		irInstr *instr = &b->instrs.e[i]->Instr;
+		irInstr *instr = &b->instrs[i]->Instr;
 		if (instr->kind != irInstr_Phi) {
 			phis = b->instrs;
 			phis.count = i;
@@ -140,22 +143,22 @@ irValueArray ir_get_block_phi_nodes(irBlock *b) {
 }
 
 void ir_remove_pred(irBlock *b, irBlock *p) {
-	irValueArray phis = ir_get_block_phi_nodes(b);
+	Array<irValue *> phis = ir_get_block_phi_nodes(b);
 	isize i = 0;
 	for_array(j, b->preds) {
-		irBlock *pred = b->preds.e[j];
+		irBlock *pred = b->preds[j];
 		if (pred != p) {
-			b->preds.e[i] = b->preds.e[j];
+			b->preds[i] = b->preds[j];
 			for_array(k, phis) {
-				irInstrPhi *phi = &phis.e[k]->Instr.Phi;
+				irInstrPhi *phi = &phis[k]->Instr.Phi;
-				phi->edges.e[i] = phi->edges.e[j];
+				phi->edges[i] = phi->edges[j];
 			}
 			i++;
 		}
 	}
 	b->preds.count = i;
 	for_array(k, phis) {
-		irInstrPhi *phi = &phis.e[k]->Instr.Phi;
+		irInstrPhi *phi = &phis[k]->Instr.Phi;
 		phi->edges.count = i;
 	}
 
@@ -164,13 +167,13 @@ void ir_remove_pred(irBlock *b, irBlock *p) {
 void ir_remove_dead_blocks(irProcedure *proc) {
 	isize j = 0;
 	for_array(i, proc->blocks) {
-		irBlock *b = proc->blocks.e[i];
+		irBlock *b = proc->blocks[i];
-		if (b == NULL) {
+		if (b == nullptr) {
 			continue;
 		}
 		// NOTE(bill): Swap order
-		b->index = j;
+		b->index = cast(i32)j;
-		proc->blocks.e[j++] = b;
+		proc->blocks[j++] = b;
 	}
 	proc->blocks.count = j;
 }
@@ -180,7 +183,7 @@ void ir_mark_reachable(irBlock *b) {
 	isize const BLACK = -1;
 	b->index = BLACK;
 	for_array(i, b->succs) {
-		irBlock *succ = b->succs.e[i];
+		irBlock *succ = b->succs[i];
 		if (succ->index == WHITE) {
 			ir_mark_reachable(succ);
 		}
@@ -191,23 +194,23 @@ void ir_remove_unreachable_blocks(irProcedure *proc) {
 	isize const WHITE =  0;
 	isize const BLACK = -1;
 	for_array(i, proc->blocks) {
-		proc->blocks.e[i]->index = WHITE;
+		proc->blocks[i]->index = WHITE;
 	}
 
-	ir_mark_reachable(proc->blocks.e[0]);
+	ir_mark_reachable(proc->blocks[0]);
 
 	for_array(i, proc->blocks) {
-		irBlock *b = proc->blocks.e[i];
+		irBlock *b = proc->blocks[i];
 		if (b->index == WHITE) {
 			for_array(j, b->succs) {
-				irBlock *c = b->succs.e[j];
+				irBlock *c = b->succs[j];
 				if (c->index == BLACK) {
 					ir_remove_pred(c, b);
 				}
 			}
 			// NOTE(bill): Mark as empty but don't actually free it
 			// As it's been allocated with an arena
-			proc->blocks.e[i] = NULL;
+			proc->blocks[i] = nullptr;
 		}
 	}
 	ir_remove_dead_blocks(proc);
@@ -217,7 +220,7 @@ bool ir_opt_block_fusion(irProcedure *proc, irBlock *a) {
 	if (a->succs.count != 1) {
 		return false;
 	}
-	irBlock *b = a->succs.e[0];
+	irBlock *b = a->succs[0];
 	if (b->preds.count != 1) {
 		return false;
 	}
@@ -228,21 +231,21 @@ bool ir_opt_block_fusion(irProcedure *proc, irBlock *a) {
 
 	array_pop(&a->instrs); // Remove branch at end
 	for_array(i, b->instrs) {
-		array_add(&a->instrs, b->instrs.e[i]);
+		array_add(&a->instrs, b->instrs[i]);
-		ir_set_instr_parent(b->instrs.e[i], a);
+		ir_set_instr_parent(b->instrs[i], a);
 	}
 
 	array_clear(&a->succs);
 	for_array(i, b->succs) {
-		array_add(&a->succs, b->succs.e[i]);
+		array_add(&a->succs, b->succs[i]);
 	}
 
 	// Fix preds links
 	for_array(i, b->succs) {
-		ir_opt_block_replace_pred(b->succs.e[i], b, a);
+		ir_opt_block_replace_pred(b->succs[i], b, a);
 	}
 
-	proc->blocks.e[b->index] = NULL;
+	proc->blocks[b->index] = nullptr;
 	return true;
 }
 
@@ -254,8 +257,8 @@ void ir_opt_blocks(irProcedure *proc) {
 	while (changed) {
 		changed = false;
 		for_array(i, proc->blocks) {
-			irBlock *b = proc->blocks.e[i];
+			irBlock *b = proc->blocks[i];
-			if (b == NULL) {
+			if (b == nullptr) {
 				continue;
 			}
 			GB_ASSERT_MSG(b->index == i, "%d, %td", b->index, i);
@@ -273,21 +276,21 @@ void ir_opt_blocks(irProcedure *proc) {
 void ir_opt_build_referrers(irProcedure *proc) {
 	gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&proc->module->tmp_arena);
 
-	irValueArray ops = {0}; // NOTE(bill): Act as a buffer
+	Array<irValue *> ops = {0}; // NOTE(bill): Act as a buffer
-	array_init_reserve(&ops, proc->module->tmp_allocator, 64); // HACK(bill): This _could_ overflow the temp arena
+	array_init(&ops, proc->module->tmp_allocator, 64); // HACK(bill): This _could_ overflow the temp arena
 	for_array(i, proc->blocks) {
-		irBlock *b = proc->blocks.e[i];
+		irBlock *b = proc->blocks[i];
 		for_array(j, b->instrs) {
-			irValue *instr = b->instrs.e[j];
+			irValue *instr = b->instrs[j];
 			array_clear(&ops);
 			ir_opt_add_operands(&ops, &instr->Instr);
 			for_array(k, ops) {
-				irValue *op = ops.e[k];
+				irValue *op = ops[k];
-				if (op == NULL) {
+				if (op == nullptr) {
 					continue;
 				}
-				irValueArray *refs = ir_value_referrers(op);
+				Array<irValue *> *refs = ir_value_referrers(op);
-				if (refs != NULL) {
+				if (refs != nullptr) {
 					array_add(refs, instr);
 				}
 			}
@@ -322,10 +325,10 @@ i32 ir_lt_depth_first_search(irLTState *lt, irBlock *p, i32 i, irBlock **preorde
 	preorder[i] = p;
 	p->dom.pre = i++;
 	lt->sdom[p->index] = p;
-	ir_lt_link(lt, NULL, p);
+	ir_lt_link(lt, nullptr, p);
 	for_array(index, p->succs) {
-		irBlock *q = p->succs.e[index];
+		irBlock *q = p->succs[index];
-		if (lt->sdom[q->index] == NULL) {
+		if (lt->sdom[q->index] == nullptr) {
 			lt->parent[q->index] = p;
 			i = ir_lt_depth_first_search(lt, q, i, preorder);
 		}
@@ -336,7 +339,7 @@ i32 ir_lt_depth_first_search(irLTState *lt, irBlock *p, i32 i, irBlock **preorde
 irBlock *ir_lt_eval(irLTState *lt, irBlock *v) {
 	irBlock *u = v;
 	for (;
-	     lt->ancestor[v->index] != NULL;
+	     lt->ancestor[v->index] != nullptr;
 	     v = lt->ancestor[v->index]) {
 		if (lt->sdom[v->index]->dom.pre < lt->sdom[u->index]->dom.pre) {
 			u = v;
@@ -354,7 +357,7 @@ irDomPrePost ir_opt_number_dom_tree(irBlock *v, i32 pre, i32 post) {
 
 	v->dom.pre = pre++;
 	for_array(i, v->dom.children) {
-		result = ir_opt_number_dom_tree(v->dom.children.e[i], result.pre, result.post);
+		result = ir_opt_number_dom_tree(v->dom.children[i], result.pre, result.post);
 	}
 	v->dom.post = post++;
 
@@ -370,7 +373,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) {
 
 	gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&proc->module->tmp_arena);
 
-	isize n = proc->blocks.count;
+	i32 n = cast(i32)proc->blocks.count;
 	irBlock **buf = gb_alloc_array(proc->module->tmp_allocator, irBlock *, 5*n);
 
 	irLTState lt = {0};
@@ -381,7 +384,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) {
 
 	irBlock **preorder = &buf[3*n];
 	irBlock **buckets  = &buf[4*n];
-	irBlock *root = proc->blocks.e[0];
+	irBlock *root = proc->blocks[0];
 
 	// Step 1 - number vertices
 	i32 pre_num = ir_lt_depth_first_search(&lt, root, 0, preorder);
@@ -403,7 +406,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) {
 		// Step 2 - Compute all sdoms
 		lt.sdom[w->index] = lt.parent[w->index];
 		for_array(pred_index, w->preds) {
-			irBlock *v = w->preds.e[pred_index];
+			irBlock *v = w->preds[pred_index];
 			irBlock *u = ir_lt_eval(&lt, v);
 			if (lt.sdom[u->index]->dom.pre < lt.sdom[w->index]->dom.pre) {
 				lt.sdom[w->index] = lt.sdom[u->index];
@@ -429,7 +432,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) {
 	for (isize i = 1; i < n; i++) {
 		irBlock *w = preorder[i];
 		if (w == root) {
-			w->dom.idom = NULL;
+			w->dom.idom = nullptr;
 		} else {
 			// Weird tree relationships here!
 
@@ -438,7 +441,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) {
 			}
 
 			// Calculate children relation as inverse of idom
-			if (w->dom.idom->dom.children.e == NULL) {
+			if (w->dom.idom->dom.children.data == nullptr) {
 				// TODO(bill): Is this good enough for memory allocations?
 				array_init(&w->dom.idom->dom.children, heap_allocator());
 			}
@@ -461,7 +464,7 @@ void ir_opt_tree(irGen *s) {
 	s->opt_called = true;
 
 	for_array(member_index, s->module.procs) {
-		irProcedure *proc = s->module.procs.e[member_index];
+		irProcedure *proc = s->module.procs[member_index];
 		if (proc->blocks.count == 0) { // Prototype/external procedure
 			continue;
 		}

src/main.c

@@ -1,467 +0,0 @@
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-#define USE_CUSTOM_BACKEND false
-
-#include "common.c"
-#include "timings.c"
-#include "build_settings.c"
-#include "tokenizer.c"
-#include "parser.c"
-#include "checker.c"
-#include "ssa.c"
-#include "ir.c"
-#include "ir_opt.c"
-#include "ir_print.c"
-// #include "vm.c"
-
-#if defined(GB_SYSTEM_WINDOWS)
-// NOTE(bill): `name` is used in debugging and profiling modes
-i32 system_exec_command_line_app(char *name, bool is_silent, char *fmt, ...) {
-	STARTUPINFOW start_info = {gb_size_of(STARTUPINFOW)};
-	PROCESS_INFORMATION pi = {0};
-	char cmd_line[4096] = {0};
-	isize cmd_len;
-	va_list va;
-	gbTempArenaMemory tmp;
-	String16 cmd;
-	i32 exit_code = 0;
-
-	start_info.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
-	start_info.wShowWindow = SW_SHOW;
-	start_info.hStdInput   = GetStdHandle(STD_INPUT_HANDLE);
-	start_info.hStdOutput  = GetStdHandle(STD_OUTPUT_HANDLE);
-	start_info.hStdError   = GetStdHandle(STD_ERROR_HANDLE);
-
-	va_start(va, fmt);
-	cmd_len = gb_snprintf_va(cmd_line, gb_size_of(cmd_line), fmt, va);
-	va_end(va);
-	// gb_printf("%.*s\n", cast(int)cmd_len, cmd_line);
-
-	tmp = gb_temp_arena_memory_begin(&string_buffer_arena);
-
-	cmd = string_to_string16(string_buffer_allocator, make_string(cast(u8 *)cmd_line, cmd_len-1));
-
-	if (CreateProcessW(NULL, cmd.text,
-	                   NULL, NULL, true, 0, NULL, NULL,
-	                   &start_info, &pi)) {
-		WaitForSingleObject(pi.hProcess, INFINITE);
-		GetExitCodeProcess(pi.hProcess, cast(DWORD *)&exit_code);
-
-		CloseHandle(pi.hProcess);
-		CloseHandle(pi.hThread);
-	} else {
-		// NOTE(bill): failed to create process
-		gb_printf_err("Failed to execute command:\n\t%s\n", cmd_line);
-		exit_code = -1;
-	}
-
-	gb_temp_arena_memory_end(tmp);
-	return exit_code;
-}
-#elif defined(GB_SYSTEM_OSX) || defined(GB_SYSTEM_UNIX)
-i32 system_exec_command_line_app(char *name, bool is_silent, char *fmt, ...) {
-
-	char cmd_line[4096] = {0};
-	isize cmd_len;
-	va_list va;
-	String cmd;
-	i32 exit_code = 0;
-
-	va_start(va, fmt);
-	cmd_len = gb_snprintf_va(cmd_line, gb_size_of(cmd_line), fmt, va);
-	va_end(va);
-	cmd = make_string(cast(u8 *)&cmd_line, cmd_len-1);
-
-	exit_code = system(&cmd_line[0]);
-
-	// pid_t pid = fork();
-	// int status = 0;
-
-	// if(pid == 0) {
-	// 	// in child, pid == 0.
-	// 	int ret = execvp(cmd.text, (char* const*) cmd.text);
-
-	// 	if(ret == -1) {
-	// 		gb_printf_err("Failed to execute command:\n\t%s\n", cmd_line);
-
-	// 		// we're in the child, so returning won't do us any good -- just quit.
-	// 		exit(-1);
-	// 	}
-
-	// 	// unreachable
-	// 	abort();
-	// } else {
-	// 	// wait for child to finish, then we can continue cleanup
-
-	// 	int s = 0;
-	// 	waitpid(pid, &s, 0);
-
-	// 	status = WEXITSTATUS(s);
-	// }
-
-	// exit_code = status;
-
-	return exit_code;
-}
-#endif
-
-
-
-
-
-void print_usage_line(i32 indent, char *fmt, ...) {
-	while (indent --> 0) {
-		gb_printf_err("\t");
-	}
-	va_list va;
-	va_start(va, fmt);
-	gb_printf_err_va(fmt, va);
-	va_end(va);
-	gb_printf_err("\n");
-}
-
-void usage(char *argv0) {
-	print_usage_line(0, "%s is a tool for managing Odin source code", argv0);
-	print_usage_line(0, "Usage:");
-	print_usage_line(1, "%s command [arguments]", argv0);
-	print_usage_line(0, "Commands:");
-	print_usage_line(1, "build        compile .odin file as executable");
-	print_usage_line(1, "build_dll    compile .odin file as dll");
-	print_usage_line(1, "run          compile and run .odin file");
-	print_usage_line(1, "version      print version");
-}
-
-int main(int argc, char **argv) {
-	if (argc < 2) {
-		usage(argv[0]);
-		return 1;
-	}
-
-	Timings timings = {0};
-	timings_init(&timings, str_lit("Total Time"), 128);
-	// defer (timings_destroy(&timings));
-	init_string_buffer_memory();
-	init_scratch_memory(gb_megabytes(10));
-	init_global_error_collector();
-
-#if 1
-
-	init_build_context();
-
-	init_universal_scope();
-
-	char *init_filename = NULL;
-	bool run_output = false;
-	String arg1 = make_string_c(argv[1]);
-	if (str_eq(arg1, str_lit("run"))) {
-		if (argc != 3) {
-			usage(argv[0]);
-			return 1;
-		}
-		init_filename = argv[2];
-		run_output = true;
-	} else if (str_eq(arg1, str_lit("build_dll"))) {
-		if (argc != 3) {
-			usage(argv[0]);
-			return 1;
-		}
-		init_filename = argv[2];
-		build_context.is_dll = true;
-	} else if (str_eq(arg1, str_lit("build"))) {
-		if (argc != 3) {
-			usage(argv[0]);
-			return 1;
-		}
-		init_filename = argv[2];
-	} else if (str_eq(arg1, str_lit("version"))) {
-		gb_printf("%s version %.*s\n", argv[0], LIT(build_context.ODIN_VERSION));
-		return 0;
-	} else {
-		usage(argv[0]);
-		return 1;
-	}
-
-	// TODO(bill): prevent compiling without a linker
-
-	timings_start_section(&timings, str_lit("parse files"));
-
-	Parser parser = {0};
-	if (!init_parser(&parser)) {
-		return 1;
-	}
-	// defer (destroy_parser(&parser));
-
-	if (parse_files(&parser, init_filename) != ParseFile_None) {
-		return 1;
-	}
-
-
-#if 1
-	timings_start_section(&timings, str_lit("type check"));
-
-	Checker checker = {0};
-
-	init_checker(&checker, &parser, &build_context);
-	// defer (destroy_checker(&checker));
-
-	check_parsed_files(&checker);
-
-
-#endif
-#if USE_CUSTOM_BACKEND
-	if (global_error_collector.count != 0) {
-		return 1;
-	}
-
-	if (checker.parser->total_token_count < 2) {
-		return 1;
-	}
-
-	if (!ssa_generate(&parser, &checker.info)) {
-		return 1;
-	}
-#else
-	irGen ir_gen = {0};
-	if (!ir_gen_init(&ir_gen, &checker)) {
-		return 1;
-	}
-	// defer (ssa_gen_destroy(&ir_gen));
-
-	timings_start_section(&timings, str_lit("llvm ir gen"));
-	ir_gen_tree(&ir_gen);
-
-	timings_start_section(&timings, str_lit("llvm ir opt tree"));
-	ir_opt_tree(&ir_gen);
-
-	timings_start_section(&timings, str_lit("llvm ir print"));
-	print_llvm_ir(&ir_gen);
-
-	// prof_print_all();
-
-	#if 1
-	timings_start_section(&timings, str_lit("llvm-opt"));
-
-	String output_name = ir_gen.output_name;
-	String output_base = ir_gen.output_base;
-	int base_name_len = output_base.len;
-
-	i32 optimization_level = 0;
-	optimization_level = gb_clamp(optimization_level, 0, 3);
-
-	i32 exit_code = 0;
-
-	#if defined(GB_SYSTEM_WINDOWS)
-	// For more passes arguments: http://llvm.org/docs/Passes.html
-	exit_code = system_exec_command_line_app("llvm-opt", false,
-		"\"%.*sbin/opt\" \"%.*s\".ll -o \"%.*s\".bc "
-		"-mem2reg "
-		"-memcpyopt "
-		"-die "
-		// "-dse "
-		// "-dce "
-		// "-S "
-		"",
-		LIT(build_context.ODIN_ROOT),
-		LIT(output_base), LIT(output_base));
-	if (exit_code != 0) {
-		return exit_code;
-	}
-	#else
-	// NOTE(zangent): This is separate because it seems that LLVM tools are packaged
-	//   with the Windows version, while they will be system-provided on MacOS and GNU/Linux
-	exit_code = system_exec_command_line_app("llvm-opt", false,
-		"opt \"%.*s\".ll -o \"%.*s\".bc "
-		"-mem2reg "
-		"-memcpyopt "
-		"-die "
-		#if defined(GB_SYSTEM_OSX)
-			// This sets a requirement of Mountain Lion and up, but the compiler doesn't work without this limit.
-			// NOTE: If you change this (although this minimum is as low as you can go with Odin working)
-			//       make sure to also change the `macosx_version_min` param passed to `llc`
-			"-mtriple=x86_64-apple-macosx10.8 "
-		#endif
-		// "-dse "
-		// "-dce "
-		// "-S "
-		"",
-		LIT(output_base), LIT(output_base));
-	if (exit_code != 0) {
-		return exit_code;
-	}
-	#endif
-
-	#if defined(GB_SYSTEM_WINDOWS)
-	timings_start_section(&timings, str_lit("llvm-llc"));
-	// For more arguments: http://llvm.org/docs/CommandGuide/llc.html
-	exit_code = system_exec_command_line_app("llvm-llc", false,
-		"\"%.*sbin/llc\" \"%.*s.bc\" -filetype=obj -O%d "
-		"%.*s "
-		// "-debug-pass=Arguments "
-		"",
-		LIT(build_context.ODIN_ROOT),
-		LIT(output_base),
-		optimization_level,
-		LIT(build_context.llc_flags));
-	if (exit_code != 0) {
-		return exit_code;
-	}
-
-	timings_start_section(&timings, str_lit("msvc-link"));
-
-	gbString lib_str = gb_string_make(heap_allocator(), "");
-	// defer (gb_string_free(lib_str));
-	char lib_str_buf[1024] = {0};
-	for_array(i, ir_gen.module.foreign_library_paths) {
-		String lib = ir_gen.module.foreign_library_paths.e[i];
-		// gb_printf_err("Linking lib: %.*s\n", LIT(lib));
-		isize len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf),
-		                        " \"%.*s\"", LIT(lib));
-		lib_str = gb_string_appendc(lib_str, lib_str_buf);
-	}
-
-	char *output_ext = "exe";
-	char *link_settings = "";
-	if (build_context.is_dll) {
-		output_ext = "dll";
-		link_settings = "/DLL";
-	} else {
-		link_settings = "/ENTRY:mainCRTStartup";
-	}
-
-	exit_code = system_exec_command_line_app("msvc-link", true,
-		"link \"%.*s\".obj -OUT:\"%.*s.%s\" %s "
-		"/defaultlib:libcmt "
-		"/nologo /incremental:no /opt:ref /subsystem:CONSOLE "
-		" %.*s "
-		" %s "
-		"",
-		LIT(output_base), LIT(output_base), output_ext,
-		lib_str, LIT(build_context.link_flags),
-		link_settings
-		);
-	if (exit_code != 0) {
-		return exit_code;
-	}
-
-	// timings_print_all(&timings);
-
-	if (run_output) {
-		system_exec_command_line_app("odin run", false, "%.*s.exe", LIT(output_base));
-	}
-
-	#else
-
-	// NOTE(zangent): Linux / Unix is unfinished and not tested very well.
-
-
-	timings_start_section(&timings, str_lit("llvm-llc"));
-	// For more arguments: http://llvm.org/docs/CommandGuide/llc.html
-	exit_code = system_exec_command_line_app("llc", false,
-		"llc \"%.*s.bc\" -filetype=obj -relocation-model=pic -O%d "
-		"%.*s "
-		// "-debug-pass=Arguments "
-		"",
-		LIT(output_base),
-		optimization_level,
-		LIT(build_context.llc_flags));
-	if (exit_code != 0) {
-		return exit_code;
-	}
-
-	timings_start_section(&timings, str_lit("ld-link"));
-
-	gbString lib_str = gb_string_make(heap_allocator(), "");
-	// defer (gb_string_free(lib_str));
-	char lib_str_buf[1024] = {0};
-	for_array(i, ir_gen.module.foreign_library_paths) {
-		String lib = ir_gen.module.foreign_library_paths.e[i];
-
-		// NOTE(zangent): Sometimes, you have to use -framework on MacOS.
-		//   This allows you to specify '-f' in a #foreign_system_library,
-		//   without having to implement any new syntax specifically for MacOS.
-		#if defined(GB_SYSTEM_OSX)
-			isize len;
-			if(lib.len > 2 && lib.text[0] == '-' && lib.text[1] == 'f') {
-				len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf),
-				                        " -framework %.*s ", (int)(lib.len) - 2, lib.text + 2);
-			} else {
-				len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf),
-				                        " -l%.*s ", LIT(lib));
-			}
-		#else
-			isize len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf),
-			                        " -l%.*s ", LIT(lib));
-		#endif
-		lib_str = gb_string_appendc(lib_str, lib_str_buf);
-	}
-
-	// Unlike the Win32 linker code, the output_ext includes the dot, because
-	// typically executable files on *NIX systems don't have extensions.
-	char *output_ext = "";
-	char *link_settings = "";
-	char *linker;
-	if (build_context.is_dll) {
-		// Shared libraries are .dylib on MacOS and .so on Linux.
-		// TODO(zangent): Is that statement entirely truthful?
-		#if defined(GB_SYSTEM_OSX)
-			output_ext = ".dylib";
-		#else
-			output_ext = ".so";
-		#endif
-
-		link_settings = "-shared";
-	} else {
-		// TODO: Do I need anything here?
-		link_settings = "";
-	}
-
-	#if defined(GB_SYSTEM_OSX)
-		linker = "ld";
-	#else
-		// TODO(zangent): Figure out how to make ld work on Linux.
-		//   It probably has to do with including the entire CRT, but
-		//   that's quite a complicated issue to solve while remaining distro-agnostic.
-		//   Clang can figure out linker flags for us, and that's good enough _for now_.
-		linker = "clang -Wno-unused-command-line-argument";
-	#endif
-
-	exit_code = system_exec_command_line_app("ld-link", true,
-		"%s \"%.*s\".o -o \"%.*s%s\" %s "
-		"-lc -lm "
-		" %.*s "
-		" %s "
-		#if defined(GB_SYSTEM_OSX)
-			// This sets a requirement of Mountain Lion and up, but the compiler doesn't work without this limit.
-			// NOTE: If you change this (although this minimum is as low as you can go with Odin working)
-			//       make sure to also change the `mtriple` param passed to `opt`
-			" -macosx_version_min 10.8.0 "
-			// This points the linker to where the entry point is
-			" -e _main "
-		#endif
-		, linker, LIT(output_base), LIT(output_base), output_ext,
-		lib_str, LIT(build_context.link_flags),
-		link_settings
-		);
-	if (exit_code != 0) {
-		return exit_code;
-	}
-
-	// timings_print_all(&timings);
-
-	if (run_output) {
-		system_exec_command_line_app("odin run", false, "%.*s", LIT(output_base));
-	}
-
-	#endif
-#endif
-#endif
-#endif
-
-	return 0;
-}
-
-#if defined(__cplusplus)
-}
-#endif

src/main.cpp

@@ -0,0 +1,955 @@
+#define ALLOW_ARRAY_PROGRAMMING
+
+#define USE_CUSTOM_BACKEND 0
+// #define NO_ARRAY_BOUNDS_CHECK
+#if !defined(USE_THREADED_PARSER)
+#define USE_THREADED_PARSER 0
+#endif
+
+#include "common.cpp"
+#include "timings.cpp"
+#include "build_settings.cpp"
+#include "tokenizer.cpp"
+#include "parser.cpp"
+#include "docs.cpp"
+#include "checker.cpp"
+#include "ssa.cpp"
+#include "ir.cpp"
+#include "ir_opt.cpp"
+#include "ir_print.cpp"
+
+#if defined(GB_SYSTEM_WINDOWS)
+// NOTE(bill): 'name' is used in debugging and profiling modes
+i32 system_exec_command_line_app(char *name, bool is_silent, char *fmt, ...) {
+	STARTUPINFOW start_info = {gb_size_of(STARTUPINFOW)};
+	PROCESS_INFORMATION pi = {0};
+	char cmd_line[4096] = {0};
+	isize cmd_len;
+	va_list va;
+	gbTempArenaMemory tmp;
+	String16 cmd;
+	i32 exit_code = 0;
+
+	start_info.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
+	start_info.wShowWindow = SW_SHOW;
+	start_info.hStdInput   = GetStdHandle(STD_INPUT_HANDLE);
+	start_info.hStdOutput  = GetStdHandle(STD_OUTPUT_HANDLE);
+	start_info.hStdError   = GetStdHandle(STD_ERROR_HANDLE);
+
+	va_start(va, fmt);
+	cmd_len = gb_snprintf_va(cmd_line, gb_size_of(cmd_line), fmt, va);
+	va_end(va);
+
+	// gb_printf_err("%.*s\n", cast(int)cmd_len, cmd_line);
+
+	tmp = gb_temp_arena_memory_begin(&string_buffer_arena);
+
+	cmd = string_to_string16(string_buffer_allocator, make_string(cast(u8 *)cmd_line, cmd_len-1));
+
+	if (CreateProcessW(nullptr, cmd.text,
+	                   nullptr, nullptr, true, 0, nullptr, nullptr,
+	                   &start_info, &pi)) {
+		WaitForSingleObject(pi.hProcess, INFINITE);
+		GetExitCodeProcess(pi.hProcess, cast(DWORD *)&exit_code);
+
+		CloseHandle(pi.hProcess);
+		CloseHandle(pi.hThread);
+	} else {
+		// NOTE(bill): failed to create process
+		gb_printf_err("Failed to execute command:\n\t%s\n", cmd_line);
+		exit_code = -1;
+	}
+
+	gb_temp_arena_memory_end(tmp);
+	return exit_code;
+}
+#elif defined(GB_SYSTEM_OSX) || defined(GB_SYSTEM_UNIX)
+i32 system_exec_command_line_app(char *name, bool is_silent, char *fmt, ...) {
+
+	char cmd_line[4096] = {0};
+	isize cmd_len;
+	va_list va;
+	String cmd;
+	i32 exit_code = 0;
+
+	va_start(va, fmt);
+	cmd_len = gb_snprintf_va(cmd_line, gb_size_of(cmd_line), fmt, va);
+	va_end(va);
+	cmd = make_string(cast(u8 *)&cmd_line, cmd_len-1);
+
+	exit_code = system(&cmd_line[0]);
+
+	// pid_t pid = fork();
+	// int status = 0;
+
+	// if(pid == 0) {
+	// 	// in child, pid == 0.
+	// 	int ret = execvp(cmd.text, (char* const*) cmd.text);
+
+	// 	if(ret == -1) {
+	// 		gb_printf_err("Failed to execute command:\n\t%s\n", cmd_line);
+
+	// 		// we're in the child, so returning won't do us any good -- just quit.
+	// 		exit(-1);
+	// 	}
+
+	// 	// unreachable
+	// 	abort();
+	// } else {
+	// 	// wait for child to finish, then we can continue cleanup
+
+	// 	int s = 0;
+	// 	waitpid(pid, &s, 0);
+
+	// 	status = WEXITSTATUS(s);
+	// }
+
+	// exit_code = status;
+
+	return exit_code;
+}
+#endif
+
+
+
+Array<String> setup_args(int argc, char **argv) {
+	Array<String> args = {};
+	gbAllocator a = heap_allocator();
+	int i;
+
+#if defined(GB_SYSTEM_WINDOWS)
+	int wargc = 0;
+	wchar_t **wargv = command_line_to_wargv(GetCommandLineW(), &wargc);
+	array_init(&args, a, wargc);
+	for (i = 0; i < wargc; i++) {
+		wchar_t *warg = wargv[i];
+		isize wlen = string16_len(warg);
+		String16 wstr = make_string16(warg, wlen);
+		String arg = string16_to_string(a, wstr);
+		if (arg.len > 0) {
+			array_add(&args, arg);
+		}
+	}
+
+#else
+	array_init(&args, a, argc);
+	for (i = 0; i < argc; i++) {
+		String arg = make_string_c(argv[i]);
+		if (arg.len > 0) {
+			array_add(&args, arg);
+		}
+	}
+#endif
+	return args;
+}
+
+
+
+
+
+void print_usage_line(i32 indent, char *fmt, ...) {
+	while (indent --> 0) {
+		gb_printf_err("\t");
+	}
+	va_list va;
+	va_start(va, fmt);
+	gb_printf_err_va(fmt, va);
+	va_end(va);
+	gb_printf_err("\n");
+}
+
+void usage(String argv0) {
+	print_usage_line(0, "%.*s is a tool for managing Odin source code", LIT(argv0));
+	print_usage_line(0, "Usage:");
+	print_usage_line(1, "%.*s command [arguments]", LIT(argv0));
+	print_usage_line(0, "Commands:");
+	print_usage_line(1, "build     compile .odin file as executable");
+	print_usage_line(1, "run       compile and run .odin file");
+	print_usage_line(1, "docs      generate documentation for a .odin file");
+	print_usage_line(1, "version   print version");
+}
+
+
+bool string_is_valid_identifier(String str) {
+	if (str.len <= 0) return false;
+
+	isize rune_count = 0;
+
+	isize w = 0;
+	isize offset = 0;
+	while (offset < str.len) {
+		Rune r = 0;
+		w = gb_utf8_decode(str.text, str.len, &r);
+		if (r == GB_RUNE_INVALID) {
+			return false;
+		}
+
+		if (rune_count == 0) {
+			if (!rune_is_letter(r)) {
+				return false;
+			}
+		} else {
+			if (!rune_is_letter(r) && !rune_is_digit(r)) {
+				return false;
+			}
+		}
+		rune_count += 1;
+		offset += w;
+	}
+
+	return true;
+}
+
+enum BuildFlagKind {
+	BuildFlag_Invalid,
+
+	BuildFlag_OptimizationLevel,
+	BuildFlag_ShowTimings,
+	BuildFlag_ThreadCount,
+	BuildFlag_KeepTempFiles,
+	BuildFlag_Collection,
+	BuildFlag_BuildMode,
+
+	BuildFlag_COUNT,
+};
+
+enum BuildFlagParamKind {
+	BuildFlagParam_None,
+
+	BuildFlagParam_Boolean,
+	BuildFlagParam_Integer,
+	BuildFlagParam_Float,
+	BuildFlagParam_String,
+
+	BuildFlagParam_COUNT,
+};
+
+struct BuildFlag {
+	BuildFlagKind      kind;
+	String             name;
+	BuildFlagParamKind param_kind;
+};
+
+void add_flag(Array<BuildFlag> *build_flags, BuildFlagKind kind, String name, BuildFlagParamKind param_kind) {
+	BuildFlag flag = {kind, name, param_kind};
+	array_add(build_flags, flag);
+}
+
+bool parse_build_flags(Array<String> args) {
+	Array<BuildFlag> build_flags = {};
+	array_init(&build_flags, heap_allocator(), BuildFlag_COUNT);
+	add_flag(&build_flags, BuildFlag_OptimizationLevel, str_lit("opt"),             BuildFlagParam_Integer);
+	add_flag(&build_flags, BuildFlag_ShowTimings,       str_lit("show-timings"),    BuildFlagParam_None);
+	add_flag(&build_flags, BuildFlag_ThreadCount,       str_lit("thread-count"),    BuildFlagParam_Integer);
+	add_flag(&build_flags, BuildFlag_KeepTempFiles,     str_lit("keep-temp-files"), BuildFlagParam_None);
+	add_flag(&build_flags, BuildFlag_Collection,        str_lit("collection"),      BuildFlagParam_String);
+	add_flag(&build_flags, BuildFlag_BuildMode,         str_lit("build-mode"),      BuildFlagParam_String);
+
+
+	Array<String> flag_args = args;
+	flag_args.data  += 3;
+	flag_args.count -= 3;
+
+	bool set_flags[BuildFlag_COUNT] = {};
+
+	bool bad_flags = false;
+	for_array(i, flag_args) {
+		String flag = flag_args[i];
+		if (flag[0] != '-') {
+			gb_printf_err("Invalid flag: %.*s\n", LIT(flag));
+			continue;
+		}
+		String name = substring(flag, 1, flag.len);
+		isize end = 0;
+		for (; end < name.len; end++) {
+			if (name[end] == '=') break;
+		}
+		name = substring(name, 0, end);
+		String param = {};
+		if (end < flag.len-1) param = substring(flag, 2+end, flag.len);
+
+		bool found = false;
+		for_array(build_flag_index, build_flags) {
+			BuildFlag bf = build_flags[build_flag_index];
+			if (bf.name == name) {
+				found = true;
+				if (set_flags[bf.kind]) {
+					gb_printf_err("Previous flag set: '%.*s'\n", LIT(name));
+					bad_flags = true;
+				} else {
+					ExactValue value = {};
+					bool ok = false;
+					if (bf.param_kind == BuildFlagParam_None) {
+						if (param.len == 0) {
+							ok = true;
+						} else {
+							gb_printf_err("Flag '%.*s' was not expecting a parameter '%.*s'\n", LIT(name), LIT(param));
+							bad_flags = true;
+						}
+					} else if (param.len == 0) {
+						gb_printf_err("Flag missing for '%.*s'\n", LIT(name));
+						bad_flags = true;
+					} else {
+						ok = true;
+						switch (bf.param_kind) {
+						default: ok = false; break;
+						case BuildFlagParam_Boolean: {
+							if (param == "t") {
+								value = exact_value_bool(true);
+							} else if (param == "T") {
+								value = exact_value_bool(true);
+							} else if (param == "true") {
+								value = exact_value_bool(true);
+							} else if (param == "TRUE") {
+								value = exact_value_bool(true);
+							} else if (param == "True") {
+								value = exact_value_bool(true);
+							} else if (param == "1") {
+								value = exact_value_bool(true);
+							} else if (param == "f") {
+								value = exact_value_bool(false);
+							} else if (param == "F") {
+								value = exact_value_bool(false);
+							} else if (param == "false") {
+								value = exact_value_bool(false);
+							} else if (param == "FALSE") {
+								value = exact_value_bool(false);
+							} else if (param == "False") {
+								value = exact_value_bool(false);
+							} else if (param == "0") {
+								value = exact_value_bool(false);
+							} else {
+								gb_printf_err("Invalid flag parameter for '%.*s' = '%.*s'\n", LIT(name), LIT(param));
+							}
+						} break;
+						case BuildFlagParam_Integer:
+							value = exact_value_integer_from_string(param);
+							break;
+						case BuildFlagParam_Float:
+							value = exact_value_float_from_string(param);
+							break;
+						case BuildFlagParam_String:
+							value = exact_value_string(param);
+							break;
+						}
+					}
+					if (ok) {
+						switch (bf.param_kind) {
+						case BuildFlagParam_None:
+							if (value.kind != ExactValue_Invalid) {
+								gb_printf_err("%.*s expected no value, got %.*s", LIT(name), LIT(param));
+								bad_flags = true;
+								ok = false;
+							}
+							break;
+						case BuildFlagParam_Boolean:
+							if (value.kind != ExactValue_Bool) {
+								gb_printf_err("%.*s expected a boolean, got %.*s", LIT(name), LIT(param));
+								bad_flags = true;
+								ok = false;
+							}
+							break;
+						case BuildFlagParam_Integer:
+							if (value.kind != ExactValue_Integer) {
+								gb_printf_err("%.*s expected an integer, got %.*s", LIT(name), LIT(param));
+								bad_flags = true;
+								ok = false;
+							}
+							break;
+						case BuildFlagParam_Float:
+							if (value.kind != ExactValue_Float) {
+								gb_printf_err("%.*s expected a floating pointer number, got %.*s", LIT(name), LIT(param));
+								bad_flags = true;
+								ok = false;
+							}
+							break;
+						case BuildFlagParam_String:
+							if (value.kind != ExactValue_String) {
+								gb_printf_err("%.*s expected a string, got %.*s", LIT(name), LIT(param));
+								bad_flags = true;
+								ok = false;
+							}
+							break;
+						}
+
+						if (ok) switch (bf.kind) {
+						case BuildFlag_OptimizationLevel:
+							GB_ASSERT(value.kind == ExactValue_Integer);
+							build_context.optimization_level = cast(i32)i128_to_i64(value.value_integer);
+							break;
+						case BuildFlag_ShowTimings:
+							GB_ASSERT(value.kind == ExactValue_Invalid);
+							build_context.show_timings = true;
+							break;
+						case BuildFlag_ThreadCount: {
+							GB_ASSERT(value.kind == ExactValue_Integer);
+							isize count = cast(isize)i128_to_i64(value.value_integer);
+							if (count <= 0) {
+								gb_printf_err("%.*s expected a positive non-zero number, got %.*s", LIT(name), LIT(param));
+								build_context.thread_count = 0;
+							} else {
+								build_context.thread_count = count;
+							}
+							break;
+						}
+						case BuildFlag_KeepTempFiles:
+							GB_ASSERT(value.kind == ExactValue_Invalid);
+							build_context.keep_temp_files = true;
+							break;
+
+						case BuildFlag_Collection: {
+							GB_ASSERT(value.kind == ExactValue_String);
+							String str = value.value_string;
+							isize eq_pos = -1;
+							for (isize i = 0; i < str.len; i++) {
+								if (str[i] == '=') {
+									eq_pos = i;
+									break;
+								}
+							}
+							if (eq_pos < 0) {
+								gb_printf_err("Expected 'name=path', got '%.*s'\n", LIT(param));
+								bad_flags = true;
+								break;
+							}
+							String name = substring(str, 0, eq_pos);
+							String path = substring(str, eq_pos+1, str.len);
+							if (name.len == 0 || path.len == 0) {
+								gb_printf_err("Expected 'name=path', got '%.*s'\n", LIT(param));
+								bad_flags = true;
+								break;
+							}
+
+							if (!string_is_valid_identifier(name)) {
+								gb_printf_err("Library collection name '%.*s' must be a valid identifier\n", LIT(name));
+								bad_flags = true;
+								break;
+							}
+
+							if (name == "_") {
+								gb_printf_err("Library collection name cannot be an underscore\n");
+								bad_flags = true;
+								break;
+							}
+
+							if (name == "system") {
+								gb_printf_err("Library collection name 'system' is reserved\n");
+								bad_flags = true;
+								break;
+							}
+
+							String prev_path = {};
+							bool found = find_library_collection_path(name, &prev_path);
+							if (found) {
+								gb_printf_err("Library collection '%.*s' already exists with path '%.*s'\n", LIT(name), LIT(prev_path));
+								bad_flags = true;
+								break;
+							}
+
+							gbAllocator a = heap_allocator();
+							String fullpath = path_to_fullpath(a, path);
+							if (!path_is_directory(fullpath)) {
+								gb_printf_err("Library collection '%.*s' path must be a directory, got '%.*s'\n", LIT(name), LIT(fullpath));
+								gb_free(a, fullpath.text);
+								bad_flags = true;
+								break;
+							}
+
+							add_library_collection(name, path);
+
+							// NOTE(bill): Allow for multiple library collections
+							continue;
+						}
+
+						case BuildFlag_BuildMode: {
+							GB_ASSERT(value.kind == ExactValue_String);
+							String str = value.value_string;
+
+							if (build_context.command != "build") {
+								gb_printf_err("'build-mode' can only be used with the 'build' command\n");
+								bad_flags = true;
+								break;
+							}
+
+							if (str == "dll") {
+								build_context.is_dll = true;
+							} else if (str == "exe") {
+								build_context.is_dll = false;
+							} else {
+								gb_printf_err("Unknown build mode '%.*s'\n", LIT(str));
+								bad_flags = true;
+								break;
+							}
+
+							break;
+						}
+						}
+					}
+
+
+					set_flags[bf.kind] = ok;
+				}
+				break;
+			}
+		}
+		if (!found) {
+			gb_printf_err("Unknown flag: '%.*s'\n", LIT(name));
+			bad_flags = true;
+		}
+	}
+
+	return !bad_flags;
+}
+
+
+void show_timings(Checker *c, Timings *t) {
+	Parser *p    = c->parser;
+	isize lines  = p->total_line_count;
+	isize tokens = p->total_token_count;
+	isize files  = p->files.count;
+	{
+		timings_print_all(t);
+		gb_printf("\n");
+		gb_printf("Total Lines  - %td\n", lines);
+		gb_printf("Total Tokens - %td\n", tokens);
+		gb_printf("Total Files  - %td\n", files);
+		gb_printf("\n");
+	}
+	{
+		TimeStamp ts = t->sections[0];
+		GB_ASSERT(ts.label == "parse files");
+		f64 parse_time = time_stamp_as_second(ts, t->freq);
+		gb_printf("Parse pass\n");
+		gb_printf("LOC/s        - %.3f\n", cast(f64)lines/parse_time);
+		gb_printf("us/LOC       - %.3f\n", 1.0e6*parse_time/cast(f64)lines);
+		gb_printf("Tokens/s     - %.3f\n", cast(f64)tokens/parse_time);
+		gb_printf("us/Token     - %.3f\n", 1.0e6*parse_time/cast(f64)tokens);
+		gb_printf("\n");
+	}
+	{
+		f64 total_time = t->total_time_seconds;
+		gb_printf("Total pass\n");
+		gb_printf("LOC/s        - %.3f\n", cast(f64)lines/total_time);
+		gb_printf("us/LOC       - %.3f\n", 1.0e6*total_time/cast(f64)lines);
+		gb_printf("Tokens/s     - %.3f\n", cast(f64)tokens/total_time);
+		gb_printf("us/Token     - %.3f\n", 1.0e6*total_time/cast(f64)tokens);
+		gb_printf("\n");
+	}
+}
+
+void remove_temp_files(String output_base) {
+	if (build_context.keep_temp_files) return;
+
+	Array<u8> data = {};
+	array_init_count(&data, heap_allocator(), output_base.len + 10);
+	defer (array_free(&data));
+
+	isize n = output_base.len;
+	gb_memcopy(data.data, output_base.text, n);
+#define EXT_REMOVE(s) do {                         \
+		gb_memcopy(data.data+n, s, gb_size_of(s)); \
+		gb_file_remove(cast(char *)data.data);     \
+	} while (0)
+	EXT_REMOVE(".ll");
+	EXT_REMOVE(".bc");
+#if defined(GB_SYSTEM_WINDOWS)
+	EXT_REMOVE(".obj");
+#else
+	EXT_REMOVE(".o");
+#endif
+
+#undef EXT_REMOVE
+}
+
+int main(int arg_count, char **arg_ptr) {
+	if (arg_count < 2) {
+		usage(make_string_c(arg_ptr[0]));
+		return 1;
+	}
+
+	Timings timings = {0};
+	timings_init(&timings, str_lit("Total Time"), 128);
+	defer (timings_destroy(&timings));
+	init_string_buffer_memory();
+	init_scratch_memory(gb_megabytes(10));
+	init_global_error_collector();
+
+	array_init(&library_collections, heap_allocator());
+	// NOTE(bill): 'core' cannot be (re)defined by the user
+	add_library_collection(str_lit("core"), get_fullpath_relative(heap_allocator(), odin_root_dir(), str_lit("core")));
+
+	Array<String> args = setup_args(arg_count, arg_ptr);
+
+#if 1
+
+	String command = args[1];
+
+	String init_filename = {};
+	bool run_output = false;
+	if (command == "run") {
+		if (args.count < 3) {
+			usage(args[0]);
+			return 1;
+		}
+		init_filename = args[2];
+		run_output = true;
+	} else if (command == "build") {
+		if (args.count < 3) {
+			usage(args[0]);
+			return 1;
+		}
+		init_filename = args[2];
+	} else if (command == "docs") {
+		if (args.count < 3) {
+			usage(args[0]);
+			return 1;
+		}
+
+		init_filename = args[2];
+		build_context.generate_docs = true;
+		#if 1
+		print_usage_line(0, "Documentation generation is not yet supported");
+		return 1;
+		#endif
+	} else if (command == "version") {
+		gb_printf("%.*s version %.*s\n", LIT(args[0]), LIT(ODIN_VERSION));
+		return 0;
+	} else {
+		usage(args[0]);
+		return 1;
+	}
+
+	build_context.command = command;
+
+	if (!parse_build_flags(args)) {
+		return 1;
+	}
+
+
+
+	// NOTE(bill): add 'shared' directory if it is not already set
+	if (!find_library_collection_path(str_lit("shared"), nullptr)) {
+		add_library_collection(str_lit("shared"),
+		                       get_fullpath_relative(heap_allocator(), odin_root_dir(), str_lit("shared")));
+	}
+
+
+	init_build_context();
+	if (build_context.word_size == 4) {
+		print_usage_line(0, "%s 32-bit is not yet supported", args[0]);
+		return 1;
+	}
+	init_universal_scope();
+
+	// TODO(bill): prevent compiling without a linker
+
+	timings_start_section(&timings, str_lit("parse files"));
+
+	Parser parser = {0};
+	if (!init_parser(&parser)) {
+		return 1;
+	}
+	defer (destroy_parser(&parser));
+
+	if (parse_files(&parser, init_filename) != ParseFile_None) {
+		return 1;
+	}
+
+	if (build_context.generate_docs) {
+		generate_documentation(&parser);
+		return 0;
+	}
+
+#if 1
+	timings_start_section(&timings, str_lit("type check"));
+
+	Checker checker = {0};
+
+	init_checker(&checker, &parser);
+	defer (destroy_checker(&checker));
+
+	check_parsed_files(&checker);
+
+
+#endif
+#if defined(USE_CUSTOM_BACKEND) && USE_CUSTOM_BACKEND
+	if (global_error_collector.count != 0) {
+		return 1;
+	}
+
+	if (checker.parser->total_token_count < 2) {
+		return 1;
+	}
+
+	if (!ssa_generate(&parser, &checker.info)) {
+		return 1;
+	}
+#else
+	irGen ir_gen = {0};
+	if (!ir_gen_init(&ir_gen, &checker)) {
+		return 1;
+	}
+	defer (ir_gen_destroy(&ir_gen));
+
+	timings_start_section(&timings, str_lit("llvm ir gen"));
+	ir_gen_tree(&ir_gen);
+
+	timings_start_section(&timings, str_lit("llvm ir opt tree"));
+	ir_opt_tree(&ir_gen);
+
+	timings_start_section(&timings, str_lit("llvm ir print"));
+	print_llvm_ir(&ir_gen);
+
+	// prof_print_all();
+
+	#if 1
+	timings_start_section(&timings, str_lit("llvm-opt"));
+
+	String output_name = ir_gen.output_name;
+	String output_base = ir_gen.output_base;
+
+	build_context.optimization_level = gb_clamp(build_context.optimization_level, 0, 3);
+
+	i32 exit_code = 0;
+
+	#if defined(GB_SYSTEM_WINDOWS)
+		// For more passes arguments: http://llvm.org/docs/Passes.html
+		exit_code = system_exec_command_line_app("llvm-opt", false,
+			"\"%.*sbin/opt\" \"%.*s\".ll -o \"%.*s\".bc %.*s "
+			"-mem2reg "
+			"-memcpyopt "
+			"-die "
+			"",
+			LIT(build_context.ODIN_ROOT),
+			LIT(output_base), LIT(output_base),
+			LIT(build_context.opt_flags));
+		if (exit_code != 0) {
+			return exit_code;
+		}
+	#else
+		// NOTE(zangent): This is separate because it seems that LLVM tools are packaged
+		//   with the Windows version, while they will be system-provided on MacOS and GNU/Linux
+		exit_code = system_exec_command_line_app("llvm-opt", false,
+			"opt \"%.*s\".ll -o \"%.*s\".bc %.*s "
+			"-mem2reg "
+			"-memcpyopt "
+			"-die "
+			#if defined(GB_SYSTEM_OSX)
+				// This sets a requirement of Mountain Lion and up, but the compiler doesn't work without this limit.
+				// NOTE: If you change this (although this minimum is as low as you can go with Odin working)
+				//       make sure to also change the 'macosx_version_min' param passed to 'llc'
+				"-mtriple=x86_64-apple-macosx10.8 "
+			#endif
+			"",
+			LIT(output_base), LIT(output_base),
+			LIT(build_context.opt_flags));
+		if (exit_code != 0) {
+			return exit_code;
+		}
+	#endif
+
+	#if defined(GB_SYSTEM_WINDOWS)
+		timings_start_section(&timings, str_lit("llvm-llc"));
+		// For more arguments: http://llvm.org/docs/CommandGuide/llc.html
+		exit_code = system_exec_command_line_app("llvm-llc", false,
+			"\"%.*sbin/llc\" \"%.*s.bc\" -filetype=obj -O%d "
+			"%.*s "
+			// "-debug-pass=Arguments "
+			"",
+			LIT(build_context.ODIN_ROOT),
+			LIT(output_base),
+			build_context.optimization_level,
+			LIT(build_context.llc_flags));
+		if (exit_code != 0) {
+			return exit_code;
+		}
+
+		timings_start_section(&timings, str_lit("msvc-link"));
+
+		gbString lib_str = gb_string_make(heap_allocator(), "");
+		defer (gb_string_free(lib_str));
+		char lib_str_buf[1024] = {0};
+		for_array(i, ir_gen.module.foreign_library_paths) {
+			String lib = ir_gen.module.foreign_library_paths[i];
+			// gb_printf_err("Linking lib: %.*s\n", LIT(lib));
+			isize len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf),
+			                        " \"%.*s\"", LIT(lib));
+			lib_str = gb_string_appendc(lib_str, lib_str_buf);
+		}
+
+		char *output_ext = "exe";
+		char *link_settings = "";
+		if (build_context.is_dll) {
+			output_ext = "dll";
+			link_settings = "/DLL";
+		} else {
+			link_settings = "/ENTRY:mainCRTStartup";
+		}
+
+		exit_code = system_exec_command_line_app("msvc-link", true,
+			"link \"%.*s.obj\" -OUT:\"%.*s.%s\" %s "
+			"/defaultlib:libcmt "
+			// "/nodefaultlib "
+			// "/debug "
+			"/nologo /incremental:no /opt:ref /subsystem:CONSOLE "
+			" %.*s "
+			" %s "
+			"",
+			LIT(output_base), LIT(output_base), output_ext,
+			lib_str, LIT(build_context.link_flags),
+			link_settings
+			);
+		if (exit_code != 0) {
+			return exit_code;
+		}
+
+		if (build_context.show_timings) {
+			show_timings(&checker, &timings);
+		}
+
+		remove_temp_files(output_base);
+
+		if (run_output) {
+			system_exec_command_line_app("odin run", false, "%.*s.exe", LIT(output_base));
+		}
+
+	#else
+
+		// NOTE(zangent): Linux / Unix is unfinished and not tested very well.
+
+
+		timings_start_section(&timings, str_lit("llvm-llc"));
+		// For more arguments: http://llvm.org/docs/CommandGuide/llc.html
+		exit_code = system_exec_command_line_app("llc", false,
+			"llc \"%.*s.bc\" -filetype=obj -relocation-model=pic -O%d "
+			"%.*s "
+			// "-debug-pass=Arguments "
+			"",
+			LIT(output_base),
+			build_context.optimization_level,
+			LIT(build_context.llc_flags));
+		if (exit_code != 0) {
+			return exit_code;
+		}
+
+		// NOTE(vassvik): get cwd, for used for local shared libs linking, since those have to be relative to the exe
+		char cwd[256];
+		getcwd(&cwd[0], 256);
+		//printf("%s\n", cwd);
+
+		// NOTE(vassvik): needs to add the root to the library search paths, so that the full filenames of the library
+		//                files can be passed with -l:
+		gbString lib_str = gb_string_make(heap_allocator(), "-L/");
+
+		defer (gb_string_free(lib_str));
+		char lib_str_buf[1024] = {0};
+		for_array(i, ir_gen.module.foreign_library_paths) {
+			String lib = ir_gen.module.foreign_library_paths[i];
+
+			// NOTE(zangent): Sometimes, you have to use -framework on MacOS.
+			//   This allows you to specify '-f' in a #foreign_system_library,
+			//   without having to implement any new syntax specifically for MacOS.
+			#if defined(GB_SYSTEM_OSX)
+				isize len;
+				if(lib.len > 2 && lib[0] == '-' && lib[1] == 'f') {
+					// framework thingie
+					len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf), " -framework %.*s ", (int)(lib.len) - 2, lib.text + 2);
+				} else if (string_has_extension(lib, str_lit("a"))) {
+					// static libs, absolute full path relative to the file in which the lib was imported from
+					len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf), " %.*s ", LIT(lib));
+				} else if (string_has_extension(lib, str_lit("dylib"))) {
+					// dynamic lib, relative path to executable
+					len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf), " -l:%s/%.*s ", cwd, LIT(lib));
+				} else {
+					// dynamic or static system lib, just link regularly searching system library paths
+					len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf), " -l%.*s ", LIT(lib));
+				}
+			#else
+				// NOTE(vassvik): static libraries (.a files) in linux can be linked to directly using the full path,
+				//                since those are statically linked to at link time. shared libraries (.so) has to be
+				//                available at runtime wherever the executable is run, so we make require those to be
+				//                local to the executable (unless the system collection is used, in which case we search
+				//                the system library paths for the library file).
+				if (string_has_extension(lib, str_lit("a"))) {
+					// static libs, absolute full path relative to the file in which the lib was imported from
+					isize len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf), " -l:%.*s ", LIT(lib));
+				} else if (string_has_extension(lib, str_lit("so"))) {
+					// dynamic lib, relative path to executable
+					// NOTE(vassvik): it is the user's responsibility to make sure the shared library files are visible
+					//                at runtimeto the executable
+					isize len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf), " -l:%s/%.*s ", cwd, LIT(lib));
+				} else {
+					// dynamic or static system lib, just link regularly searching system library paths
+					isize len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf), " -l%.*s ", LIT(lib));
+				}
+			#endif
+			lib_str = gb_string_appendc(lib_str, lib_str_buf);
+		}
+
+		// Unlike the Win32 linker code, the output_ext includes the dot, because
+		// typically executable files on *NIX systems don't have extensions.
+		char *output_ext = "";
+		char *link_settings = "";
+		char *linker;
+		if (build_context.is_dll) {
+			// Shared libraries are .dylib on MacOS and .so on Linux.
+			#if defined(GB_SYSTEM_OSX)
+				output_ext = ".dylib";
+			#else
+				output_ext = ".so";
+			#endif
+
+			link_settings = "-shared";
+		} else {
+			// TODO: Do I need anything here?
+			link_settings = "";
+		}
+
+		#if defined(GB_SYSTEM_OSX)
+			linker = "ld";
+		#else
+			// TODO(zangent): Figure out how to make ld work on Linux.
+			//   It probably has to do with including the entire CRT, but
+			//   that's quite a complicated issue to solve while remaining distro-agnostic.
+			//   Clang can figure out linker flags for us, and that's good enough _for now_.
+			linker = "clang -Wno-unused-command-line-argument";
+		#endif
+
+		exit_code = system_exec_command_line_app("ld-link", true,
+			"%s \"%.*s.o\" -o \"%.*s%s\" %s "
+			"-lc -lm "
+			" %.*s "
+			" %s "
+			#if defined(GB_SYSTEM_OSX)
+				// This sets a requirement of Mountain Lion and up, but the compiler doesn't work without this limit.
+				// NOTE: If you change this (although this minimum is as low as you can go with Odin working)
+				//       make sure to also change the 'mtriple' param passed to 'opt'
+				" -macosx_version_min 10.8.0 "
+				// This points the linker to where the entry point is
+				" -e _main "
+			#endif
+			, linker, LIT(output_base), LIT(output_base), output_ext,
+			lib_str, LIT(build_context.link_flags),
+			link_settings
+			);
+		if (exit_code != 0) {
+			return exit_code;
+		}
+
+		if (build_context.show_timings) {
+			show_timings(&checker, &timings);
+		}
+
+		remove_temp_files(output_base);
+
+		if (run_output) {
+			system_exec_command_line_app("odin run", false, "%.*s", LIT(output_base));
+		}
+
+	#endif
+#endif
+#endif
+#endif
+
+	return 0;
+}

src/map.c

@@ -1,364 +0,0 @@
-/*
-	Example of usage:
-
-	#define MAP_TYPE String
-	#define MAP_PROC map_string_
-	#define MAP_NAME MapString
-	#include "map.c"
-*/
-// A `Map` is an unordered hash table which can allow for a key to point to multiple values
-// with the use of the `multi_*` procedures.
-// TODO(bill): I should probably allow the `multi_*` stuff to be #ifdefed out
-
-#ifndef MAP_UTIL_STUFF
-#define MAP_UTIL_STUFF
-// NOTE(bill): This util stuff is the same for every `Map`
-typedef struct MapFindResult {
-	isize hash_index;
-	isize entry_prev;
-	isize entry_index;
-} MapFindResult;
-
-typedef enum HashKeyKind {
-	HashKey_Default,
-	HashKey_String,
-	HashKey_Pointer,
-} HashKeyKind;
-
-typedef struct HashKey {
-	HashKeyKind kind;
-	u64         key;
-	union {
-		String string; // if String, s.len > 0
-		void * ptr;
-	};
-} HashKey;
-
-gb_inline HashKey hashing_proc(void const *data, isize len) {
-	HashKey h = {HashKey_Default};
-	h.kind = HashKey_Default;
-	// h.key = gb_murmur64(data, len);
-	h.key = gb_fnv64a(data, len);
-	// h.key = MurmurHash3_128(data, len, 0x3803cb8e);
-
-	return h;
-}
-
-gb_inline HashKey hash_string(String s) {
-	HashKey h = hashing_proc(s.text, s.len);
-	h.kind = HashKey_String;
-	h.string = s;
-	return h;
-}
-
-gb_inline HashKey hash_pointer(void *ptr) {
-	HashKey h = {HashKey_Default};
-	// h.key = u128_from_u64(cast(u64)cast(uintptr)ptr);
-	h.key = cast(u64)cast(uintptr)ptr;
-	h.ptr = ptr;
-	h.kind = HashKey_Default;
-	return h;
-}
-
-bool hash_key_equal(HashKey a, HashKey b) {
-	if (a.key == b.key) {
-		// NOTE(bill): If two string's hashes collide, compare the strings themselves
-		if (a.kind == HashKey_String) {
-			if (b.kind == HashKey_String) {
-				return str_eq(a.string, b.string);
-			}
-			return false;
-		}
-		return true;
-	}
-	return false;
-}
-#endif
-
-#define _J2_IND(a, b) a##b
-#define _J2(a, b) _J2_IND(a, b)
-
-/*
-MAP_TYPE - Entry type
-MAP_PROC - Function prefix (e.g. entity_map_)
-MAP_NAME - Name of Map (e.g. EntityMap)
-*/
-#define MAP_ENTRY _J2(MAP_NAME,Entry)
-
-typedef struct MAP_ENTRY {
-	HashKey  key;
-	isize    next;
-	MAP_TYPE value;
-} MAP_ENTRY;
-
-typedef struct MAP_NAME {
-	Array(isize)     hashes;
-	Array(MAP_ENTRY) entries;
-} MAP_NAME;
-
-void      _J2(MAP_PROC,init)             (MAP_NAME *h, gbAllocator a);
-void      _J2(MAP_PROC,init_with_reserve)(MAP_NAME *h, gbAllocator a, isize capacity);
-void      _J2(MAP_PROC,destroy)          (MAP_NAME *h);
-MAP_TYPE *_J2(MAP_PROC,get)              (MAP_NAME *h, HashKey key);
-void      _J2(MAP_PROC,set)              (MAP_NAME *h, HashKey key, MAP_TYPE value);
-void      _J2(MAP_PROC,remove)           (MAP_NAME *h, HashKey key);
-void      _J2(MAP_PROC,clear)            (MAP_NAME *h);
-void      _J2(MAP_PROC,grow)             (MAP_NAME *h);
-void      _J2(MAP_PROC,rehash)           (MAP_NAME *h, isize new_count);
-
-// Mutlivalued map procedure
-MAP_ENTRY *_J2(MAP_PROC,multi_find_first)(MAP_NAME *h, HashKey key);
-MAP_ENTRY *_J2(MAP_PROC,multi_find_next) (MAP_NAME *h, MAP_ENTRY *e);
-
-isize _J2(MAP_PROC,multi_count)     (MAP_NAME *h, HashKey key);
-void  _J2(MAP_PROC,multi_get_all)   (MAP_NAME *h, HashKey key, MAP_TYPE *items);
-void  _J2(MAP_PROC,multi_insert)    (MAP_NAME *h, HashKey key, MAP_TYPE value);
-void  _J2(MAP_PROC,multi_remove)    (MAP_NAME *h, HashKey key, MAP_ENTRY *e);
-void  _J2(MAP_PROC,multi_remove_all)(MAP_NAME *h, HashKey key);
-
-
-
-gb_inline void _J2(MAP_PROC,init)(MAP_NAME *h, gbAllocator a) {
-	array_init(&h->hashes,  a);
-	array_init(&h->entries, a);
-}
-
-gb_inline void _J2(MAP_PROC,init_with_reserve)(MAP_NAME *h, gbAllocator a, isize capacity) {
-	array_init_reserve(&h->hashes,  a, capacity);
-	array_init_reserve(&h->entries, a, capacity);
-}
-
-gb_inline void _J2(MAP_PROC,destroy)(MAP_NAME *h) {
-	array_free(&h->entries);
-	array_free(&h->hashes);
-}
-
-gb_internal isize _J2(MAP_PROC,_add_entry)(MAP_NAME *h, HashKey key) {
-	MAP_ENTRY e = {0};
-	e.key = key;
-	e.next = -1;
-	array_add(&h->entries, e);
-	return h->entries.count-1;
-}
-
-gb_internal MapFindResult _J2(MAP_PROC,_find)(MAP_NAME *h, HashKey key) {
-	MapFindResult fr = {-1, -1, -1};
-	if (h->hashes.count > 0) {
-		fr.hash_index  = key.key % h->hashes.count;
-		fr.entry_index = h->hashes.e[fr.hash_index];
-		while (fr.entry_index >= 0) {
-			if (hash_key_equal(h->entries.e[fr.entry_index].key, key)) {
-				return fr;
-			}
-			fr.entry_prev = fr.entry_index;
-			fr.entry_index = h->entries.e[fr.entry_index].next;
-		}
-	}
-	return fr;
-}
-
-gb_internal MapFindResult _J2(MAP_PROC,_find_from_entry)(MAP_NAME *h, MAP_ENTRY *e) {
-	MapFindResult fr = {-1, -1, -1};
-	if (h->hashes.count > 0) {
-		fr.hash_index  = e->key.key % h->hashes.count;
-		fr.entry_index = h->hashes.e[fr.hash_index];
-		while (fr.entry_index >= 0) {
-			if (&h->entries.e[fr.entry_index] == e) {
-				return fr;
-			}
-			fr.entry_prev = fr.entry_index;
-			fr.entry_index = h->entries.e[fr.entry_index].next;
-		}
-	}
-	return fr;
-}
-
-
-gb_internal b32 _J2(MAP_PROC,_full)(MAP_NAME *h) {
-	return 0.75f * h->hashes.count <= h->entries.count;
-}
-
-gb_inline void _J2(MAP_PROC,grow)(MAP_NAME *h) {
-	isize new_count = ARRAY_GROW_FORMULA(h->entries.count);
-	_J2(MAP_PROC,rehash)(h, new_count);
-}
-
-void _J2(MAP_PROC,rehash)(MAP_NAME *h, isize new_count) {
-	isize i, j;
-	MAP_NAME nh = {0};
-	_J2(MAP_PROC,init)(&nh, h->hashes.allocator);
-	array_resize(&nh.hashes, new_count);
-	array_reserve(&nh.entries, h->entries.count);
-	for (i = 0; i < new_count; i++) {
-		nh.hashes.e[i] = -1;
-	}
-	for (i = 0; i < h->entries.count; i++) {
-		MAP_ENTRY *e = &h->entries.e[i];
-		MapFindResult fr;
-		if (nh.hashes.count == 0) {
-			_J2(MAP_PROC,grow)(&nh);
-		}
-		fr = _J2(MAP_PROC,_find)(&nh, e->key);
-		j = _J2(MAP_PROC,_add_entry)(&nh, e->key);
-		if (fr.entry_prev < 0) {
-			nh.hashes.e[fr.hash_index] = j;
-		} else {
-			nh.entries.e[fr.entry_prev].next = j;
-		}
-		nh.entries.e[j].next = fr.entry_index;
-		nh.entries.e[j].value = e->value;
-		if (_J2(MAP_PROC,_full)(&nh)) {
-			_J2(MAP_PROC,grow)(&nh);
-		}
-	}
-	_J2(MAP_PROC,destroy)(h);
-	*h = nh;
-}
-
-gb_inline MAP_TYPE *_J2(MAP_PROC,get)(MAP_NAME *h, HashKey key) {
-	isize index = _J2(MAP_PROC,_find)(h, key).entry_index;
-	if (index >= 0) {
-		return &h->entries.e[index].value;
-	}
-	return NULL;
-}
-
-void _J2(MAP_PROC,set)(MAP_NAME *h, HashKey key, MAP_TYPE value) {
-	isize index;
-	MapFindResult fr;
-	if (h->hashes.count == 0)
-		_J2(MAP_PROC,grow)(h);
-	fr = _J2(MAP_PROC,_find)(h, key);
-	if (fr.entry_index >= 0) {
-		index = fr.entry_index;
-	} else {
-		index = _J2(MAP_PROC,_add_entry)(h, key);
-		if (fr.entry_prev >= 0) {
-			h->entries.e[fr.entry_prev].next = index;
-		} else {
-			h->hashes.e[fr.hash_index] = index;
-		}
-	}
-	h->entries.e[index].value = value;
-
-	if (_J2(MAP_PROC,_full)(h)) {
-		_J2(MAP_PROC,grow)(h);
-	}
-}
-
-
-
-void _J2(MAP_PROC,_erase)(MAP_NAME *h, MapFindResult fr) {
-	MapFindResult last;
-	if (fr.entry_prev < 0) {
-		h->hashes.e[fr.hash_index] = h->entries.e[fr.entry_index].next;
-	} else {
-		h->entries.e[fr.entry_prev].next = h->entries.e[fr.entry_index].next;
-	}
-	if (fr.entry_index == h->entries.count-1) {
-		array_pop(&h->entries);
-		return;
-	}
-	h->entries.e[fr.entry_index] = h->entries.e[h->entries.count-1];
-	last = _J2(MAP_PROC,_find)(h, h->entries.e[fr.entry_index].key);
-	if (last.entry_prev >= 0) {
-		h->entries.e[last.entry_prev].next = fr.entry_index;
-	} else {
-		h->hashes.e[last.hash_index] = fr.entry_index;
-	}
-}
-
-void _J2(MAP_PROC,remove)(MAP_NAME *h, HashKey key) {
-	MapFindResult fr = _J2(MAP_PROC,_find)(h, key);
-	if (fr.entry_index >= 0) {
-		_J2(MAP_PROC,_erase)(h, fr);
-	}
-}
-
-gb_inline void _J2(MAP_PROC,clear)(MAP_NAME *h) {
-	array_clear(&h->hashes);
-	array_clear(&h->entries);
-}
-
-
-#if 1
-MAP_ENTRY *_J2(MAP_PROC,multi_find_first)(MAP_NAME *h, HashKey key) {
-	isize i = _J2(MAP_PROC,_find)(h, key).entry_index;
-	if (i < 0) {
-		return NULL;
-	}
-	return &h->entries.e[i];
-}
-
-MAP_ENTRY *_J2(MAP_PROC,multi_find_next)(MAP_NAME *h, MAP_ENTRY *e) {
-	isize i = e->next;
-	while (i >= 0) {
-		if (hash_key_equal(h->entries.e[i].key, e->key)) {
-			return &h->entries.e[i];
-		}
-		i = h->entries.e[i].next;
-	}
-	return NULL;
-}
-
-isize _J2(MAP_PROC,multi_count)(MAP_NAME *h, HashKey key) {
-	isize count = 0;
-	MAP_ENTRY *e = _J2(MAP_PROC,multi_find_first)(h, key);
-	while (e != NULL) {
-		count++;
-		e = _J2(MAP_PROC,multi_find_next)(h, e);
-	}
-	return count;
-}
-
-void _J2(MAP_PROC,multi_get_all)(MAP_NAME *h, HashKey key, MAP_TYPE *items) {
-	isize i = 0;
-	MAP_ENTRY *e = _J2(MAP_PROC,multi_find_first)(h, key);
-	while (e != NULL) {
-		items[i++] = e->value;
-		e = _J2(MAP_PROC,multi_find_next)(h, e);
-	}
-}
-
-void _J2(MAP_PROC,multi_insert)(MAP_NAME *h, HashKey key, MAP_TYPE value) {
-	MapFindResult fr;
-	isize i;
-	if (h->hashes.count == 0) {
-		_J2(MAP_PROC,grow)(h);
-	}
-	// Make
-	fr = _J2(MAP_PROC,_find)(h, key);
-	i = _J2(MAP_PROC,_add_entry)(h, key);
-	if (fr.entry_prev < 0) {
-		h->hashes.e[fr.hash_index] = i;
-	} else {
-		h->entries.e[fr.entry_prev].next = i;
-	}
-	h->entries.e[i].next = fr.entry_index;
-	h->entries.e[i].value = value;
-	// Grow if needed
-	if (_J2(MAP_PROC,_full)(h)) {
-		_J2(MAP_PROC,grow)(h);
-	}
-}
-
-void _J2(MAP_PROC,multi_remove)(MAP_NAME *h, HashKey key, MAP_ENTRY *e) {
-	MapFindResult fr = _J2(MAP_PROC,_find_from_entry)(h, e);
-	if (fr.entry_index >= 0) {
-		_J2(MAP_PROC,_erase)(h, fr);
-	}
-}
-
-void _J2(MAP_PROC,multi_remove_all)(MAP_NAME *h, HashKey key) {
-	while (_J2(MAP_PROC,get)(h, key) != NULL) {
-		_J2(MAP_PROC,remove)(h, key);
-	}
-}
-#endif
-
-
-#undef _J2
-#undef MAP_TYPE
-#undef MAP_PROC
-#undef MAP_NAME
-#undef MAP_ENTRY

src/map.cpp

@@ -0,0 +1,374 @@
+// A `Map` is an unordered hash table which can allow for a key to point to multiple values
+// with the use of the `multi_*` procedures.
+// TODO(bill): I should probably allow the `multi_map_*` stuff to be #ifdefed out
+
+#ifndef MAP_UTIL_STUFF
+#define MAP_UTIL_STUFF
+// NOTE(bill): This util stuff is the same for every `Map`
+struct MapFindResult {
+	isize hash_index;
+	isize entry_prev;
+	isize entry_index;
+};
+
+enum HashKeyKind {
+	HashKey_Default,
+	HashKey_String,
+	HashKey_Ptr,
+	HashKey_PtrAndId,
+};
+
+struct PtrAndId {
+	void *ptr;
+	u32   id;
+};
+
+struct HashKey {
+	HashKeyKind kind;
+	// u128        key;
+	u64         key;
+	union {
+		String       string; // if String, s.len > 0
+		void *       ptr;
+		PtrAndId ptr_and_id;
+	};
+};
+
+gb_inline HashKey hashing_proc(void const *data, isize len) {
+	HashKey h = {HashKey_Default};
+	h.kind = HashKey_Default;
+	// h.key = u128_from_u64(gb_fnv64a(data, len));
+	h.key = gb_fnv64a(data, len);
+
+	return h;
+}
+
+gb_inline HashKey hash_string(String s) {
+	HashKey h = hashing_proc(s.text, s.len);
+	h.kind = HashKey_String;
+	h.string = s;
+	return h;
+}
+
+gb_inline HashKey hash_pointer(void *ptr) {
+	HashKey h = {HashKey_Ptr};
+	h.key = cast(u64)cast(uintptr)ptr;
+	h.ptr = ptr;
+	return h;
+}
+gb_inline HashKey hash_ptr_and_id(void *ptr, u32 id) {
+	HashKey h = {HashKey_PtrAndId};
+	h.key = cast(u64)cast(uintptr)ptr;
+	h.ptr_and_id.ptr = ptr;
+	h.ptr_and_id.id  = id;
+	return h;
+}
+
+bool hash_key_equal(HashKey a, HashKey b) {
+	if (a.key == b.key) {
+		// NOTE(bill): If two string's hashes collide, compare the strings themselves
+		if (a.kind == HashKey_String) {
+			if (b.kind == HashKey_String) {
+				return a.string == b.string;
+			}
+			return false;
+		} else if (a.kind == HashKey_PtrAndId) {
+			if (b.kind == HashKey_PtrAndId) {
+				return a.ptr_and_id.id == b.ptr_and_id.id;
+			}
+			return false;
+		}
+		return true;
+	}
+	return false;
+}
+bool operator==(HashKey a, HashKey b) { return hash_key_equal(a, b); }
+bool operator!=(HashKey a, HashKey b) { return !hash_key_equal(a, b); }
+
+#endif
+
+template <typename T>
+struct MapEntry {
+	HashKey  key;
+	isize    next;
+	T        value;
+};
+
+template <typename T>
+struct Map {
+	Array<isize>        hashes;
+	Array<MapEntry<T> > entries;
+};
+
+
+template <typename T> void map_init             (Map<T> *h, gbAllocator a, isize capacity = 16);
+template <typename T> void map_destroy          (Map<T> *h);
+template <typename T> T *  map_get              (Map<T> *h, HashKey key);
+template <typename T> void map_set              (Map<T> *h, HashKey key, T const &value);
+template <typename T> void map_remove           (Map<T> *h, HashKey key);
+template <typename T> void map_clear            (Map<T> *h);
+template <typename T> void map_grow             (Map<T> *h);
+template <typename T> void map_rehash           (Map<T> *h, isize new_count);
+
+// Mutlivalued map procedure
+template <typename T> MapEntry<T> * multi_map_find_first(Map<T> *h, HashKey key);
+template <typename T> MapEntry<T> * multi_map_find_next (Map<T> *h, MapEntry<T> *e);
+
+template <typename T> isize multi_map_count     (Map<T> *h, HashKey key);
+template <typename T> void  multi_map_get_all   (Map<T> *h, HashKey key, T *items);
+template <typename T> void  multi_map_insert    (Map<T> *h, HashKey key, T const &value);
+template <typename T> void  multi_map_remove    (Map<T> *h, HashKey key, MapEntry<T> *e);
+template <typename T> void  multi_map_remove_all(Map<T> *h, HashKey key);
+
+
+template <typename T>
+gb_inline void map_init(Map<T> *h, gbAllocator a, isize capacity) {
+	array_init(&h->hashes,  a, capacity);
+	array_init(&h->entries, a, capacity);
+}
+
+template <typename T>
+gb_inline void map_destroy(Map<T> *h) {
+	array_free(&h->entries);
+	array_free(&h->hashes);
+}
+
+template <typename T>
+gb_internal isize map__add_entry(Map<T> *h, HashKey key) {
+	MapEntry<T> e = {};
+	e.key = key;
+	e.next = -1;
+	array_add(&h->entries, e);
+	return h->entries.count-1;
+}
+
+template <typename T>
+gb_internal MapFindResult map__find(Map<T> *h, HashKey key) {
+	MapFindResult fr = {-1, -1, -1};
+	if (h->hashes.count > 0) {
+		// fr.hash_index  = u128_to_i64(key.key % u128_from_i64(h->hashes.count));
+		fr.hash_index = key.key % h->hashes.count;
+		fr.entry_index = h->hashes[fr.hash_index];
+		while (fr.entry_index >= 0) {
+			if (hash_key_equal(h->entries[fr.entry_index].key, key)) {
+				return fr;
+			}
+			fr.entry_prev = fr.entry_index;
+			fr.entry_index = h->entries[fr.entry_index].next;
+		}
+	}
+	return fr;
+}
+
+template <typename T>
+gb_internal MapFindResult map__find_from_entry(Map<T> *h, MapEntry<T> *e) {
+	MapFindResult fr = {-1, -1, -1};
+	if (h->hashes.count > 0) {
+		fr.hash_index  = e->key.key % h->hashes.count;
+		fr.entry_index = h->hashes[fr.hash_index];
+		while (fr.entry_index >= 0) {
+			if (&h->entries[fr.entry_index] == e) {
+				return fr;
+			}
+			fr.entry_prev = fr.entry_index;
+			fr.entry_index = h->entries[fr.entry_index].next;
+		}
+	}
+	return fr;
+}
+
+template <typename T>
+gb_internal b32 map__full(Map<T> *h) {
+	return 0.75f * h->hashes.count <= h->entries.count;
+}
+
+template <typename T>
+gb_inline void map_grow(Map<T> *h) {
+	isize new_count = ARRAY_GROW_FORMULA(h->entries.count);
+	map_rehash(h, new_count);
+}
+
+template <typename T>
+void map_rehash(Map<T> *h, isize new_count) {
+	isize i, j;
+	Map<T> nh = {};
+	map_init(&nh, h->hashes.allocator);
+	array_resize(&nh.hashes, new_count);
+	array_reserve(&nh.entries, h->entries.count);
+	for (i = 0; i < new_count; i++) {
+		nh.hashes[i] = -1;
+	}
+	for (i = 0; i < h->entries.count; i++) {
+		MapEntry<T> *e = &h->entries[i];
+		MapFindResult fr;
+		if (nh.hashes.count == 0) {
+			map_grow(&nh);
+		}
+		fr = map__find(&nh, e->key);
+		j = map__add_entry(&nh, e->key);
+		if (fr.entry_prev < 0) {
+			nh.hashes[fr.hash_index] = j;
+		} else {
+			nh.entries[fr.entry_prev].next = j;
+		}
+		nh.entries[j].next = fr.entry_index;
+		nh.entries[j].value = e->value;
+		if (map__full(&nh)) {
+			map_grow(&nh);
+		}
+	}
+	map_destroy(h);
+	*h = nh;
+}
+
+template <typename T>
+gb_inline T *map_get(Map<T> *h, HashKey key) {
+	isize index = map__find(h, key).entry_index;
+	if (index >= 0) {
+		return &h->entries[index].value;
+	}
+	return nullptr;
+}
+
+template <typename T>
+void map_set(Map<T> *h, HashKey key, T const &value) {
+	isize index;
+	MapFindResult fr;
+	if (h->hashes.count == 0)
+		map_grow(h);
+	fr = map__find(h, key);
+	if (fr.entry_index >= 0) {
+		index = fr.entry_index;
+	} else {
+		index = map__add_entry(h, key);
+		if (fr.entry_prev >= 0) {
+			h->entries[fr.entry_prev].next = index;
+		} else {
+			h->hashes[fr.hash_index] = index;
+		}
+	}
+	h->entries[index].value = value;
+
+	if (map__full(h)) {
+		map_grow(h);
+	}
+}
+
+
+template <typename T>
+void map__erase(Map<T> *h, MapFindResult fr) {
+	MapFindResult last;
+	if (fr.entry_prev < 0) {
+		h->hashes[fr.hash_index] = h->entries[fr.entry_index].next;
+	} else {
+		h->entries[fr.entry_prev].next = h->entries[fr.entry_index].next;
+	}
+	if (fr.entry_index == h->entries.count-1) {
+		array_pop(&h->entries);
+		return;
+	}
+	h->entries[fr.entry_index] = h->entries[h->entries.count-1];
+	last = map__find(h, h->entries[fr.entry_index].key);
+	if (last.entry_prev >= 0) {
+		h->entries[last.entry_prev].next = fr.entry_index;
+	} else {
+		h->hashes[last.hash_index] = fr.entry_index;
+	}
+}
+
+template <typename T>
+void map_remove(Map<T> *h, HashKey key) {
+	MapFindResult fr = map__find(h, key);
+	if (fr.entry_index >= 0) {
+		map__erase(h, fr);
+	}
+}
+
+template <typename T>
+gb_inline void map_clear(Map<T> *h) {
+	array_clear(&h->hashes);
+	array_clear(&h->entries);
+}
+
+
+#if 1
+template <typename T>
+MapEntry<T> *multi_map_find_first(Map<T> *h, HashKey key) {
+	isize i = map__find(h, key).entry_index;
+	if (i < 0) {
+		return nullptr;
+	}
+	return &h->entries[i];
+}
+
+template <typename T>
+MapEntry<T> *multi_map_find_next(Map<T> *h, MapEntry<T> *e) {
+	isize i = e->next;
+	while (i >= 0) {
+		if (hash_key_equal(h->entries[i].key, e->key)) {
+			return &h->entries[i];
+		}
+		i = h->entries[i].next;
+	}
+	return nullptr;
+}
+
+template <typename T>
+isize multi_map_count(Map<T> *h, HashKey key) {
+	isize count = 0;
+	MapEntry<T> *e = multi_map_find_first(h, key);
+	while (e != nullptr) {
+		count++;
+		e = multi_map_find_next(h, e);
+	}
+	return count;
+}
+
+template <typename T>
+void multi_map_get_all(Map<T> *h, HashKey key, T *items) {
+	isize i = 0;
+	MapEntry<T> *e = multi_map_find_first(h, key);
+	while (e != nullptr) {
+		items[i++] = e->value;
+		e = multi_map_find_next(h, e);
+	}
+}
+
+template <typename T>
+void multi_map_insert(Map<T> *h, HashKey key, T const &value) {
+	MapFindResult fr;
+	isize i;
+	if (h->hashes.count == 0) {
+		map_grow(h);
+	}
+	// Make
+	fr = map__find(h, key);
+	i = map__add_entry(h, key);
+	if (fr.entry_prev < 0) {
+		h->hashes[fr.hash_index] = i;
+	} else {
+		h->entries[fr.entry_prev].next = i;
+	}
+	h->entries[i].next = fr.entry_index;
+	h->entries[i].value = value;
+	// Grow if needed
+	if (map__full(h)) {
+		map_grow(h);
+	}
+}
+
+template <typename T>
+void multi_map_remove(Map<T> *h, HashKey key, MapEntry<T> *e) {
+	MapFindResult fr = map__find_from_entry(h, e);
+	if (fr.entry_index >= 0) {
+		map__erase(h, fr);
+	}
+}
+
+template <typename T>
+void multi_map_remove_all(Map<T> *h, HashKey key) {
+	while (map_get(h, key) != nullptr) {
+		map_remove(h, key);
+	}
+}
+#endif

src/murmurhash3.cpp

@@ -41,15 +41,15 @@ gb_inline u64 fmix64(u64 k) {
 	return k;
 }
 
-gb_inline u32 mm3_getblock32(u32 *const p, isize i) {
+gb_inline u32 mm3_getblock32(u32 const *p, isize i) {
 	return p[i];
 }
-gb_inline u64 mm3_getblock64(u64 *const p, isize i) {
+gb_inline u64 mm3_getblock64(u64 const *p, isize i) {
 	return p[i];
 }
 
-u128 MurmurHash3_x64_128(void *const key, isize len, u32 seed) {
+void MurmurHash3_x64_128(void const *key, isize len, u32 seed, void *out) {
-	u8 *const data = cast(u8 *const)key;
+	u8 const * data = cast(u8 const *)key;
 	isize nblocks = len / 16;
 
 	u64 h1 = seed;
@@ -58,7 +58,7 @@ u128 MurmurHash3_x64_128(void *const key, isize len, u32 seed) {
 	u64 const c1 = 0x87c37b91114253d5ULL;
 	u64 const c2 = 0x4cf5ad432745937fULL;
 
-	u64 *const blocks = cast(u64 *const)data;
+	u64 const * blocks = cast(u64 const *)data;
 
 	for (isize i = 0; i < nblocks; i++) {
 		u64 k1 = mm3_getblock64(blocks, i*2 + 0);
@@ -70,7 +70,7 @@ u128 MurmurHash3_x64_128(void *const key, isize len, u32 seed) {
 		h2 = ROTL64(h2,31); h2 += h1; h2 = h2*5+0x38495ab5;
 	}
 
-	u8 *const tail = cast(u8 *const)(data + nblocks*16);
+	u8 const * tail = cast(u8 const *)(data + nblocks*16);
 
 	u64 k1 = 0;
 	u64 k2 = 0;
@@ -108,11 +108,12 @@ u128 MurmurHash3_x64_128(void *const key, isize len, u32 seed) {
 	h1 += h2;
 	h2 += h1;
 
-	return u128_lo_hi(h1, h2);
+	((u64 *)out)[0] = h1;
+	((u64 *)out)[1] = h2;
 }
 
-u128 MurmurHash3_x86_128(void *const key, isize len, u32 seed) {
+void MurmurHash3_x86_128(void const *key, isize len, u32 seed, void *out) {
-	u8 *const data = cast(u8 * const)key;
+	u8 const * data = cast(u8 * const)key;
 	isize nblocks = len / 16;
 
 	u32 h1 = seed;
@@ -128,7 +129,7 @@ u128 MurmurHash3_x86_128(void *const key, isize len, u32 seed) {
 	//----------
 	// body
 
-	u32 *const blocks = cast(u32 *const)(data + nblocks*16);
+	u32 const * blocks = cast(u32 const *)(data + nblocks*16);
 
 	for (isize i = -nblocks; i != 0; i++) {
 		u32 k1 = mm3_getblock32(blocks, i*4 + 0);
@@ -156,7 +157,7 @@ u128 MurmurHash3_x86_128(void *const key, isize len, u32 seed) {
 	//----------
 	// tail
 
-	u8 *const tail = cast(u8 *const)(data + nblocks*16);
+	u8 const * tail = cast(u8 const *)(data + nblocks*16);
 
 	u32 k1 = 0;
 	u32 k2 = 0;
@@ -204,17 +205,21 @@ u128 MurmurHash3_x86_128(void *const key, isize len, u32 seed) {
 	h1 += h2; h1 += h3; h1 += h4;
 	h2 += h1; h3 += h1; h4 += h1;
 
-	u64 lo = (u64)h1 | ((u64)h2 << 32);
+
-	u64 hi = (u64)h3 | ((u64)h4 << 32);
+	((u32 *)out)[0] = h1;
-	return u128_lo_hi(lo, hi);
+	((u32 *)out)[1] = h2;
+	((u32 *)out)[2] = h3;
+	((u32 *)out)[3] = h4;
 }
 
-gb_inline u128 MurmurHash3_128(void *const key, isize len, u32 seed) {
+gb_inline u128 MurmurHash3_128(void const *key, isize len, u32 seed) {
+	u128 res;
 #if defined(GB_ARCH_64_BIT)
-	return MurmurHash3_x64_128(key, len, seed);
+	MurmurHash3_x64_128(key, len, seed, &res);
 #else
-	return MurmurHash3_x86_128(key, len, seed);
+	MurmurHash3_x86_128(key, len, seed, &res);
 #endif
+	return res;
 }
 
 

src/printer.c

@@ -1,221 +0,0 @@
-
-
-gb_inline void print_indent(isize indent) {
-	while (indent --> 0)
-		gb_printf("  ");
-}
-
-void print_ast(AstNode *node, isize indent) {
-	if (node == NULL)
-		return;
-
-	switch (node->kind) {
-	case AstNode_BasicLit:
-		print_indent(indent);
-		print_token(node->BasicLit);
-		break;
-	case AstNode_Ident:
-		print_indent(indent);
-		print_token(node->Ident);
-		break;
-	case AstNode_ProcLit:
-		print_indent(indent);
-		gb_printf("(proc lit)\n");
-		print_ast(node->ProcLit.type, indent+1);
-		print_ast(node->ProcLit.body, indent+1);
-		break;
-
-	case AstNode_CompoundLit:
-		print_indent(indent);
-		gb_printf("(compound lit)\n");
-		print_ast(node->CompoundLit.type, indent+1);
-		for_array(i, node->CompoundLit.elems) {
-			print_ast(node->CompoundLit.elems[i], indent+1);
-		}
-		break;
-
-
-	case AstNode_TagExpr:
-		print_indent(indent);
-		gb_printf("(tag)\n");
-		print_indent(indent+1);
-		print_token(node->TagExpr.name);
-		print_ast(node->TagExpr.expr, indent+1);
-		break;
-
-	case AstNode_UnaryExpr:
-		print_indent(indent);
-		print_token(node->UnaryExpr.op);
-		print_ast(node->UnaryExpr.expr, indent+1);
-		break;
-	case AstNode_BinaryExpr:
-		print_indent(indent);
-		print_token(node->BinaryExpr.op);
-		print_ast(node->BinaryExpr.left, indent+1);
-		print_ast(node->BinaryExpr.right, indent+1);
-		break;
-	case AstNode_CallExpr:
-		print_indent(indent);
-		gb_printf("(call)\n");
-		print_ast(node->CallExpr.proc, indent+1);
-		for_array(i, node->CallExpr.args) {
-			print_ast(node->CallExpr.args[i], indent+1);
-		}
-		break;
-	case AstNode_SelectorExpr:
-		print_indent(indent);
-		gb_printf(".\n");
-		print_ast(node->SelectorExpr.expr,  indent+1);
-		print_ast(node->SelectorExpr.selector, indent+1);
-		break;
-	case AstNode_IndexExpr:
-		print_indent(indent);
-		gb_printf("([])\n");
-		print_ast(node->IndexExpr.expr, indent+1);
-		print_ast(node->IndexExpr.index, indent+1);
-		break;
-	case AstNode_DerefExpr:
-		print_indent(indent);
-		gb_printf("(deref)\n");
-		print_ast(node->DerefExpr.expr, indent+1);
-		break;
-
-
-	case AstNode_ExprStmt:
-		print_ast(node->ExprStmt.expr, indent);
-		break;
-	case AstNode_IncDecStmt:
-		print_indent(indent);
-		print_token(node->IncDecStmt.op);
-		print_ast(node->IncDecStmt.expr, indent+1);
-		break;
-	case AstNode_AssignStmt:
-		print_indent(indent);
-		print_token(node->AssignStmt.op);
-		for_array(i, node->AssignStmt.lhs) {
-			print_ast(node->AssignStmt.lhs[i], indent+1);
-		}
-		for_array(i, node->AssignStmt.rhs) {
-			print_ast(node->AssignStmt.rhs[i], indent+1);
-		}
-		break;
-	case AstNode_BlockStmt:
-		print_indent(indent);
-		gb_printf("(block)\n");
-		for_array(i, node->BlockStmt.stmts) {
-			print_ast(node->BlockStmt.stmts[i], indent+1);
-		}
-		break;
-
-	case AstNode_IfStmt:
-		print_indent(indent);
-		gb_printf("(if)\n");
-		print_ast(node->IfStmt.cond, indent+1);
-		print_ast(node->IfStmt.body, indent+1);
-		if (node->IfStmt.else_stmt) {
-			print_indent(indent);
-			gb_printf("(else)\n");
-			print_ast(node->IfStmt.else_stmt, indent+1);
-		}
-		break;
-	case AstNode_ReturnStmt:
-		print_indent(indent);
-		gb_printf("(return)\n");
-		for_array(i, node->ReturnStmt.results) {
-			print_ast(node->ReturnStmt.results[i], indent+1);
-		}
-		break;
-	case AstNode_ForStmt:
-		print_indent(indent);
-		gb_printf("(for)\n");
-		print_ast(node->ForStmt.init, indent+1);
-		print_ast(node->ForStmt.cond, indent+1);
-		print_ast(node->ForStmt.post, indent+1);
-		print_ast(node->ForStmt.body, indent+1);
-		break;
-	case AstNode_DeferStmt:
-		print_indent(indent);
-		gb_printf("(defer)\n");
-		print_ast(node->DeferStmt.stmt, indent+1);
-		break;
-
-
-	case AstNode_VarDecl:
-		print_indent(indent);
-		gb_printf("(decl:var)\n");
-		for_array(i, node->VarDecl.names) {
-			print_ast(node->VarDecl.names[i], indent+1);
-		}
-		print_ast(node->VarDecl.type, indent+1);
-		for_array(i, node->VarDecl.values) {
-			print_ast(node->VarDecl.values[i], indent+1);
-		}
-		break;
-	case AstNode_ConstDecl:
-		print_indent(indent);
-		gb_printf("(decl:const)\n");
-		for_array(i, node->VarDecl.names) {
-			print_ast(node->VarDecl.names[i], indent+1);
-		}
-		print_ast(node->VarDecl.type, indent+1);
-		for_array(i, node->VarDecl.values) {
-			print_ast(node->VarDecl.values[i], indent+1);
-		}
-		break;
-	case AstNode_ProcDecl:
-		print_indent(indent);
-		gb_printf("(decl:proc)\n");
-		print_ast(node->ProcDecl.type, indent+1);
-		print_ast(node->ProcDecl.body, indent+1);
-		break;
-
-	case AstNode_TypeDecl:
-		print_indent(indent);
-		gb_printf("(type)\n");
-		print_ast(node->TypeDecl.name, indent+1);
-		print_ast(node->TypeDecl.type, indent+1);
-		break;
-
-	case AstNode_ProcType:
-		print_indent(indent);
-		gb_printf("(type:proc)(%td -> %td)\n", node->ProcType.params.count, node->ProcType.results.count);
-		for_array(i, node->ProcType.params) {
-			print_ast(node->ProcType.params[i], indent+1);
-		}
-		if (node->ProcType.results.count > 0) {
-			print_indent(indent+1);
-			gb_printf("->\n");
-			for_array(i, node->ProcType.results) {
-				print_ast(node->ProcType.results[i], indent+1);
-			}
-		}
-		break;
-	case AstNode_Parameter:
-		for_array(i, node->Parameter.names) {
-			print_ast(node->Parameter.names[i], indent+1);
-		}
-		print_ast(node->Parameter.type, indent);
-		break;
-	case AstNode_PointerType:
-		print_indent(indent);
-		print_token(node->PointerType.token);
-		print_ast(node->PointerType.type, indent+1);
-		break;
-	case AstNode_ArrayType:
-		print_indent(indent);
-		gb_printf("[]\n");
-		print_ast(node->ArrayType.count, indent+1);
-		print_ast(node->ArrayType.elem, indent+1);
-		break;
-	case AstNode_StructType:
-		print_indent(indent);
-		gb_printf("(struct)\n");
-		for_array(i, node->StructType.decls) {
-			print_ast(node->StructType.decls[i], indent+1);
-		}
-		break;
-	}
-
-	// if (node->next)
-		// print_ast(node->next, indent);
-}

src/priority_queue.cpp

@@ -0,0 +1,96 @@
+template <typename T>
+struct PriorityQueue {
+	Array<T> queue;
+
+	int  (* cmp) (T *q, isize i, isize j);
+	void (* swap)(T *q, isize i, isize j);
+};
+
+template <typename T>
+bool priority_queue_shift_down(PriorityQueue<T> *pq, isize i0, isize n) {
+	// O(n log n)
+	isize i = i0;
+	isize j, j1, j2;
+	if (0 > i || i > n) return false;
+	for (;;) {
+		j1 = 2*i + 1;
+		if (0 > j1 || j1 >= n) break;
+		j = j1;
+		j2 = j1 + 1;
+		if (j2 < n && pq->cmp(&pq->queue[0], j2, j1) < 0) {
+			j = j2;
+		}
+		if (pq->cmp(&pq->queue[0], i, j) < 0) break;
+
+		pq->swap(&pq->queue[0], i, j);
+		i = j;
+	}
+	return i > i0;
+}
+
+template <typename T>
+void priority_queue_shift_up(PriorityQueue<T> *pq, isize j) {
+	while (0 <= j && j < pq->queue.count) {
+		isize i = (j-1)/2;
+		if (i == j || pq->cmp(&pq->queue[0], i, j) < 0) {
+			break;
+		}
+		pq->swap(&pq->queue[0], i, j);
+		j = i;
+	}
+}
+
+// NOTE(bill): When an element at index `i0` has changed its value, this will fix the
+// the heap ordering. This using a basic "heapsort" with shift up and a shift down parts.
+template <typename T>
+void priority_queue_fix(PriorityQueue<T> *pq, isize i) {
+	if (!priority_queue_shift_down(pq, i, pq->queue.count)) {
+		priority_queue_shift_up(pq, i);
+	}
+}
+
+template <typename T>
+void priority_queue_push(PriorityQueue<T> *pq, T const &value) {
+	array_add(&pq->queue, value);
+	priority_queue_shift_up(pq, pq->queue.count-1);
+}
+
+template <typename T>
+T priority_queue_pop(PriorityQueue<T> *pq) {
+	GB_ASSERT(pq->queue.count > 0);
+
+	isize n = pq->queue.count - 1;
+	pq->swap(&pq->queue[0], 0, n);
+	priority_queue_shift_down(pq, 0, n);
+	return array_pop(&pq->queue);
+}
+
+
+template <typename T>
+T priority_queue_remove(PriorityQueue<T> *pq, isize i) {
+	GB_ASSERT(0 <= i && i < pq->queue.count);
+	isize n = pq->queue.count - 1;
+	if (n != i) {
+		pq->swap(&pq->queue[0], i, n);
+		priority_queue_shift_down(pq, i, n);
+		priority_queue_shift_up(pq, i);
+	}
+	return array_pop(&pq->queue);
+}
+
+
+template <typename T>
+PriorityQueue<T> priority_queue_create(Array<T> queue,
+                                       int  (* cmp) (T *q, isize i, isize j),
+                                       void (* swap)(T *q, isize i, isize j)) {
+	PriorityQueue<T> pq = {};
+	pq.queue = queue;
+	pq.cmp   = cmp;
+	pq.swap  = swap;
+
+	isize n = pq.queue.count;
+	for (isize i = n/2 - 1; i >= 0; i--) {
+		priority_queue_shift_down(&pq, i, n);
+	}
+	return pq;
+}

src/ptr_set.cpp

@@ -0,0 +1,195 @@
+struct PtrSetFindResult {
+	isize hash_index;
+	isize entry_prev;
+	isize entry_index;
+};
+
+
+template <typename T>
+struct PtrSetEntry {
+	T       ptr;
+	isize   next;
+};
+
+template <typename T>
+struct PtrSet {
+	Array<isize>          hashes;
+	Array<PtrSetEntry<T>> entries;
+};
+
+template <typename T> void ptr_set_init             (PtrSet<T> *s, gbAllocator a, isize capacity = 16);
+template <typename T> void ptr_set_destroy          (PtrSet<T> *s);
+template <typename T> void ptr_set_add              (PtrSet<T> *s, T ptr);
+template <typename T> bool ptr_set_exists           (PtrSet<T> *s, T ptr);
+template <typename T> void ptr_set_remove           (PtrSet<T> *s, T ptr);
+template <typename T> void ptr_set_clear            (PtrSet<T> *s);
+template <typename T> void ptr_set_grow             (PtrSet<T> *s);
+template <typename T> void ptr_set_rehash           (PtrSet<T> *s, isize new_count);
+
+
+template <typename T>
+void ptr_set_init(PtrSet<T> *s, gbAllocator a, isize capacity) {
+	array_init(&s->hashes,  a, capacity);
+	array_init(&s->entries, a, capacity);
+}
+
+template <typename T>
+void ptr_set_destroy(PtrSet<T> *s) {
+	array_free(&s->hashes);
+	array_free(&s->entries);
+}
+
+template <typename T>
+gb_internal isize ptr_set__add_entry(PtrSet<T> *s, T ptr) {
+	PtrSetEntry<T> e = {};
+	e.ptr = ptr;
+	e.next = -1;
+	array_add(&s->entries, e);
+	return s->entries.count-1;
+}
+
+
+template <typename T>
+gb_internal PtrSetFindResult ptr_set__find(PtrSet<T> *s, T ptr) {
+	PtrSetFindResult fr = {-1, -1, -1};
+	if (s->hashes.count > 0) {
+		uintptr p = cast(uintptr)ptr;
+		uintptr n = cast(uintptr)s->hashes.count;
+		fr.hash_index = cast(isize)(p % n);
+		fr.entry_index = s->hashes[fr.hash_index];
+		while (fr.entry_index >= 0) {
+			if (s->entries[fr.entry_index].ptr == ptr) {
+				return fr;
+			}
+			fr.entry_prev = fr.entry_index;
+			fr.entry_index = s->entries[fr.entry_index].next;
+		}
+	}
+	return fr;
+}
+
+template <typename T>
+gb_internal PtrSetFindResult ptr_set__find_from_entry(PtrSet<T> *s, PtrSetEntry<T> *e) {
+	PtrSetFindResult fr = {-1, -1, -1};
+	if (s->hashes.count > 0) {
+		fr.hash_index  = e->key.key % s->hashes.count;
+		fr.entry_index = s->hashes[fr.hash_index];
+		while (fr.entry_index >= 0) {
+			if (&s->entries[fr.entry_index] == e) {
+				return fr;
+			}
+			fr.entry_prev = fr.entry_index;
+			fr.entry_index = s->entries[fr.entry_index].next;
+		}
+	}
+	return fr;
+}
+
+template <typename T>
+gb_internal b32 ptr_set__full(PtrSet<T> *s) {
+	return 0.75f * s->hashes.count <= s->entries.count;
+}
+
+template <typename T>
+gb_inline void ptr_set_grow(PtrSet<T> *s) {
+	isize new_count = ARRAY_GROW_FORMULA(s->entries.count);
+	ptr_set_rehash(s, new_count);
+}
+
+template <typename T>
+void ptr_set_rehash(PtrSet<T> *s, isize new_count) {
+	isize i, j;
+	PtrSet<T> ns = {};
+	ptr_set_init(&ns, s->hashes.allocator);
+	array_resize(&ns.hashes, new_count);
+	array_reserve(&ns.entries, s->entries.count);
+	for (i = 0; i < new_count; i++) {
+		ns.hashes[i] = -1;
+	}
+	for (i = 0; i < s->entries.count; i++) {
+		PtrSetEntry<T> *e = &s->entries[i];
+		PtrSetFindResult fr;
+		if (ns.hashes.count == 0) {
+			ptr_set_grow(&ns);
+		}
+		fr = ptr_set__find(&ns, e->ptr);
+		j = ptr_set__add_entry(&ns, e->ptr);
+		if (fr.entry_prev < 0) {
+			ns.hashes[fr.hash_index] = j;
+		} else {
+			ns.entries[fr.entry_prev].next = j;
+		}
+		ns.entries[j].next = fr.entry_index;
+		if (ptr_set__full(&ns)) {
+			ptr_set_grow(&ns);
+		}
+	}
+	ptr_set_destroy(s);
+	*s = ns;
+}
+
+template <typename T>
+gb_inline bool ptr_set_exists(PtrSet<T> *s, T ptr) {
+	isize index = ptr_set__find(s, ptr).entry_index;
+	return index >= 0;
+}
+
+// Returns true if it already exists
+template <typename T>
+void ptr_set_add(PtrSet<T> *s, T ptr) {
+	isize index;
+	PtrSetFindResult fr;
+	if (s->hashes.count == 0) {
+		ptr_set_grow(s);
+	}
+	fr = ptr_set__find(s, ptr);
+	if (fr.entry_index >= 0) {
+		index = fr.entry_index;
+	} else {
+		index = ptr_set__add_entry(s, ptr);
+		if (fr.entry_prev >= 0) {
+			s->entries[fr.entry_prev].next = index;
+		} else {
+			s->hashes[fr.hash_index] = index;
+		}
+	}
+	if (ptr_set__full(s)) {
+		ptr_set_grow(s);
+	}
+}
+
+
+template <typename T>
+void ptr_set__erase(PtrSet<T> *s, PtrSetFindResult fr) {
+	PtrSetFindResult last;
+	if (fr.entry_prev < 0) {
+		s->hashes[fr.hash_index] = s->entries[fr.entry_index].next;
+	} else {
+		s->entries[fr.entry_prev].next = s->entries[fr.entry_index].next;
+	}
+	if (fr.entry_index == s->entries.count-1) {
+		array_pop(&s->entries);
+		return;
+	}
+	s->entries[fr.entry_index] = s->entries[s->entries.count-1];
+	last = ptr_set__find(s, s->entries[fr.entry_index].ptr);
+	if (last.entry_prev >= 0) {
+		s->entries[last.entry_prev].next = fr.entry_index;
+	} else {
+		s->hashes[last.hash_index] = fr.entry_index;
+	}
+}
+
+template <typename T>
+void ptr_set_remove(PtrSet<T> *s, T ptr) {
+	PtrSetFindResult fr = ptr_set__find(s, ptr);
+	if (fr.entry_index >= 0) {
+		ptr_set__erase(s, fr);
+	}
+}
+
+template <typename T>
+gb_inline void ptr_set_clear(PtrSet<T> *s) {
+	array_clear(&s->hashes);
+	array_clear(&s->entries);
+}

src/ssa_op.cpp

@@ -267,7 +267,6 @@ enum ssaOp {
 	SSA_OPS
 #undef SSA_OP
 };
-typedef enum ssaOp ssaOp;
 
 String const ssa_op_strings[] = {
 #define SSA_OP(k) {cast(u8 *)#k, gb_size_of(#k)-1},

src/string.cpp

@@ -1,29 +1,51 @@
-gb_global gbArena string_buffer_arena = {0};
+gb_global gbArena     string_buffer_arena = {};
-gb_global gbAllocator string_buffer_allocator = {0};
+gb_global gbAllocator string_buffer_allocator = {};
+gb_global gbMutex     string_buffer_mutex = {};
 
 void init_string_buffer_memory(void) {
 	// NOTE(bill): This should be enough memory for file systems
 	gb_arena_init_from_allocator(&string_buffer_arena, heap_allocator(), gb_megabytes(1));
 	string_buffer_allocator = gb_arena_allocator(&string_buffer_arena);
+	gb_mutex_init(&string_buffer_mutex);
 }
 
 
 // NOTE(bill): Used for UTF-8 strings
-typedef struct String {
+struct String {
 	u8 *  text;
 	isize len;
-} String;
+
+	u8 &operator[](isize i) {
+		GB_ASSERT_MSG(0 <= i && i < len, "[%td]", i);
+		return text[i];
+	}
+	u8 const &operator[](isize i) const {
+		GB_ASSERT_MSG(0 <= i && i < len, "[%td]", i);
+		return text[i];
+	}
+};
 // NOTE(bill): used for printf style arguments
 #define LIT(x) ((int)(x).len), (x).text
 #define STR_LIT(c_str) {cast(u8 *)c_str, gb_size_of(c_str)-1}
-#define str_lit(c_str) (String){cast(u8 *)c_str, gb_size_of(c_str)-1}
+#if defined(GB_COMPILER_MSVC) && _MSC_VER < 1700
-
+	#define str_lit(c_str) make_string(cast(u8 *)c_str, gb_size_of(c_str)-1)
+#else
+	#define str_lit(c_str) String{cast(u8 *)c_str, gb_size_of(c_str)-1}
+#endif
 
 // NOTE(bill): String16 is only used for Windows due to its file directories
-typedef struct String16 {
+struct String16 {
 	wchar_t *text;
 	isize    len;
-} String16;
+	wchar_t &operator[](isize i) {
+		GB_ASSERT_MSG(0 <= i && i < len, "[%td]", i);
+		return text[i];
+	}
+	wchar_t const &operator[](isize i) const {
+		GB_ASSERT_MSG(0 <= i && i < len, "[%td]", i);
+		return text[i];
+	}
+};
 
 
 gb_inline String make_string(u8 *text, isize len) {
@@ -44,11 +66,29 @@ gb_inline String16 make_string16(wchar_t *text, isize len) {
 	return s;
 }
 
+isize string16_len(wchar_t *s) {
+	if (s == nullptr) {
+		return 0;
+	}
+	wchar_t *p = s;
+	while (*p) {
+		p++;
+	}
+	return p - s;
+}
+
 
 gb_inline String make_string_c(char *text) {
 	return make_string(cast(u8 *)cast(void *)text, gb_strlen(text));
 }
 
+String substring(String s, isize lo, isize hi) {
+	isize max = s.len;
+	GB_ASSERT(lo <= hi && hi <= max);
+
+	return make_string(s.text+lo, hi-lo);
+}
+
 
 
 
@@ -56,8 +96,8 @@ gb_inline bool str_eq_ignore_case(String a, String b) {
 	if (a.len == b.len) {
 		isize i;
 		for (i = 0; i < a.len; i++) {
-			char x = cast(char)a.text[i];
+			char x = cast(char)a[i];
-			char y = cast(char)b.text[i];
+			char y = cast(char)b[i];
 			if (gb_char_to_lower(x) != gb_char_to_lower(y))
 				return false;
 		}
@@ -66,9 +106,8 @@ gb_inline bool str_eq_ignore_case(String a, String b) {
 	return false;
 }
 
-int string_compare(String x, String y) {
+int string_compare(String const &x, String const &y) {
-	if (!(x.len == y.len &&
+	if (x.len != y.len || x.text != y.text) {
-	      x.text == y.text)) {
 		isize n, fast, offset, curr_block;
 		isize *la, *lb;
 		isize pos;
@@ -88,16 +127,16 @@ int string_compare(String x, String y) {
 		for (; curr_block < fast; curr_block++) {
 			if (la[curr_block] ^ lb[curr_block]) {
 				for (pos = curr_block*gb_size_of(isize); pos < n; pos++) {
-					if (x.text[pos] ^ y.text[pos]) {
+					if (x[pos] ^ y[pos]) {
-						return cast(int)x.text[pos] - cast(int)y.text[pos];
+						return cast(int)x[pos] - cast(int)y[pos];
 					}
 				}
 			}
 		}
 
 		for (; offset < n; offset++) {
-			if (x.text[offset] ^ y.text[offset]) {
+			if (x[offset] ^ y[offset]) {
-				return cast(int)x.text[offset] - cast(int)y.text[offset];
+				return cast(int)x[offset] - cast(int)y[offset];
 			}
 		}
 	}
@@ -110,12 +149,36 @@ GB_COMPARE_PROC(string_cmp_proc) {
 	return string_compare(x, y);
 }
 
-gb_inline bool str_eq(String a, String b) { return a.len == b.len ? gb_memcompare(a.text, b.text, a.len) == 0 : false; }
+gb_inline bool str_eq(String const &a, String const &b) {
-gb_inline bool str_ne(String a, String b) { return !str_eq(a, b);                }
+	if (a.len != b.len) return false;
-gb_inline bool str_lt(String a, String b) { return string_compare(a, b) < 0;     }
+	for (isize i = 0; i < a.len; i++) {
-gb_inline bool str_gt(String a, String b) { return string_compare(a, b) > 0;     }
+		if (a.text[i] != b.text[i]) {
-gb_inline bool str_le(String a, String b) { return string_compare(a, b) <= 0;    }
+			return false;
-gb_inline bool str_ge(String a, String b) { return string_compare(a, b) >= 0;    }
+		}
+	}
+	return true;
+}
+gb_inline bool str_ne(String const &a, String const &b) { return !str_eq(a, b);                }
+gb_inline bool str_lt(String const &a, String const &b) { return string_compare(a, b) < 0;     }
+gb_inline bool str_gt(String const &a, String const &b) { return string_compare(a, b) > 0;     }
+gb_inline bool str_le(String const &a, String const &b) { return string_compare(a, b) <= 0;    }
+gb_inline bool str_ge(String const &a, String const &b) { return string_compare(a, b) >= 0;    }
+
+gb_inline bool operator == (String const &a, String const &b) { return str_eq(a, b); }
+gb_inline bool operator != (String const &a, String const &b) { return str_ne(a, b); }
+gb_inline bool operator <  (String const &a, String const &b) { return str_lt(a, b); }
+gb_inline bool operator >  (String const &a, String const &b) { return str_gt(a, b); }
+gb_inline bool operator <= (String const &a, String const &b) { return str_le(a, b); }
+gb_inline bool operator >= (String const &a, String const &b) { return str_ge(a, b); }
+
+template <isize N> bool operator == (String const &a, char const (&b)[N]) { return str_eq(a, make_string(cast(u8 *)b, N-1)); }
+template <isize N> bool operator != (String const &a, char const (&b)[N]) { return str_ne(a, make_string(cast(u8 *)b, N-1)); }
+template <isize N> bool operator <  (String const &a, char const (&b)[N]) { return str_lt(a, make_string(cast(u8 *)b, N-1)); }
+template <isize N> bool operator >  (String const &a, char const (&b)[N]) { return str_gt(a, make_string(cast(u8 *)b, N-1)); }
+template <isize N> bool operator <= (String const &a, char const (&b)[N]) { return str_le(a, make_string(cast(u8 *)b, N-1)); }
+template <isize N> bool operator >= (String const &a, char const (&b)[N]) { return str_ge(a, make_string(cast(u8 *)b, N-1)); }
+
+
 
 gb_inline bool str_has_prefix(String s, String prefix) {
 	isize i;
@@ -123,7 +186,7 @@ gb_inline bool str_has_prefix(String s, String prefix) {
 		return false;
 	}
 	for (i = 0; i < prefix.len; i++) {
-		if (s.text[i] != prefix.text[i]) {
+		if (s[i] != prefix[i]) {
 			return false;
 		}
 	}
@@ -133,11 +196,10 @@ gb_inline bool str_has_prefix(String s, String prefix) {
 gb_inline isize string_extension_position(String str) {
 	isize dot_pos = -1;
 	isize i = str.len;
-	bool seen_dot = false;
 	while (i --> 0) {
-		if (str.text[i] == GB_PATH_SEPARATOR)
+		if (str[i] == GB_PATH_SEPARATOR)
 			break;
-		if (str.text[i] == '.') {
+		if (str[i] == '.') {
 			dot_pos = i;
 			break;
 		}
@@ -147,11 +209,15 @@ gb_inline isize string_extension_position(String str) {
 }
 
 String string_trim_whitespace(String str) {
-	while (str.len > 0 && rune_is_whitespace(str.text[str.len-1])) {
+	while (str.len > 0 && rune_is_whitespace(str[str.len-1])) {
 		str.len--;
 	}
 
-	while (str.len > 0 && rune_is_whitespace(str.text[0])) {
+	while (str.len > 0 && str[str.len-1] == 0) {
+		str.len--;
+	}
+
+	while (str.len > 0 && rune_is_whitespace(str[0])) {
 		str.text++;
 		str.len--;
 	}
@@ -166,7 +232,7 @@ gb_inline bool string_has_extension(String str, String ext) {
 	}
 	isize len = str.len;
 	for (isize i = len-1; i >= 0; i--) {
-		if (str.text[i] == '.') {
+		if (str[i] == '.') {
 			break;
 		}
 		len--;
@@ -182,7 +248,7 @@ gb_inline bool string_has_extension(String str, String ext) {
 bool string_contains_char(String s, u8 c) {
 	isize i;
 	for (i = 0; i < s.len; i++) {
-		if (s.text[i] == c)
+		if (s[i] == c)
 			return true;
 	}
 	return false;
@@ -194,19 +260,45 @@ String filename_from_path(String s) {
 		isize j = 0;
 		s.len = i;
 		for (j = i-1; j >= 0; j--) {
-			if (s.text[j] == '/' ||
+			if (s[j] == '/' ||
-				s.text[j] == '\\') {
+				s[j] == '\\') {
 				break;
 			}
 		}
 		s.text += j+1;
 		s.len = i-j-1;
 	}
-	return make_string(NULL, 0);
+	return make_string(nullptr, 0);
+}
+
+String remove_directory_from_path(String s) {
+	isize len = 0;
+	for (isize i = s.len-1; i >= 0; i--) {
+		if (s[i] == '/' ||
+		    s[i] == '\\') {
+			break;
+		}
+		len += 1;
+	}
+	return substring(s, s.len-len, s.len);
 }
 
 
+String concatenate_strings(gbAllocator a, String x, String y) {
+	isize len = x.len+y.len;
+	u8 *data = gb_alloc_array(a, u8, len+1);
+	gb_memmove(data,       x.text, x.len);
+	gb_memmove(data+x.len, y.text, y.len);
+	data[len] = 0;
+	return make_string(data, len);
+}
 
+String copy_string(gbAllocator a, String s) {
+	u8 *data = gb_alloc_array(a, u8, s.len+1);
+	gb_memmove(data, s.text, s.len);
+	data[s.len] = 0;
+	return make_string(data, s.len);
+}
 
 
 
@@ -217,7 +309,7 @@ String filename_from_path(String s) {
 		return MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, multibyte_input, input_length, output, output_size);
 	}
 	int convert_widechar_to_multibyte(wchar_t *widechar_input, int input_length, char *output, int output_size) {
-		return WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, widechar_input, input_length, output, output_size, NULL, NULL);
+		return WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, widechar_input, input_length, output, output_size, nullptr, nullptr);
 	}
 #elif defined(GB_SYSTEM_UNIX) || defined(GB_SYSTEM_OSX)
 
@@ -251,45 +343,47 @@ String16 string_to_string16(gbAllocator a, String s) {
 	wchar_t *text;
 
 	if (s.len < 1) {
-		return make_string16(NULL, 0);
+		return make_string16(nullptr, 0);
 	}
 
-	len = convert_multibyte_to_widechar(cast(char *)s.text, s.len, NULL, 0);
+	len = convert_multibyte_to_widechar(cast(char *)s.text, cast(int)s.len, nullptr, 0);
 	if (len == 0) {
-		return make_string16(NULL, 0);
+		return make_string16(nullptr, 0);
 	}
 
 	text = gb_alloc_array(a, wchar_t, len+1);
 
-	len1 = convert_multibyte_to_widechar(cast(char *)s.text, s.len, text, len);
+	len1 = convert_multibyte_to_widechar(cast(char *)s.text, cast(int)s.len, text, cast(int)len);
 	if (len1 == 0) {
 		gb_free(a, text);
-		return make_string16(NULL, 0);
+		return make_string16(nullptr, 0);
 	}
 	text[len] = 0;
 
 	return make_string16(text, len-1);
 }
 
+
 String string16_to_string(gbAllocator a, String16 s) {
 	int len, len1;
 	u8 *text;
 
 	if (s.len < 1) {
-		return make_string(NULL, 0);
+		return make_string(nullptr, 0);
 	}
 
-	len = convert_widechar_to_multibyte(s.text, s.len, NULL, 0);
+	len = convert_widechar_to_multibyte(s.text, cast(int)s.len, nullptr, 0);
 	if (len == 0) {
-		return make_string(NULL, 0);
+		return make_string(nullptr, 0);
 	}
+	len += 1; // NOTE(bill): It needs an extra 1 for some reason
 
 	text = gb_alloc_array(a, u8, len+1);
 
-	len1 = convert_widechar_to_multibyte(s.text, s.len, cast(char *)text, len);
+	len1 = convert_widechar_to_multibyte(s.text, cast(int)s.len, cast(char *)text, cast(int)len);
 	if (len1 == 0) {
 		gb_free(a, text);
-		return make_string(NULL, 0);
+		return make_string(nullptr, 0);
 	}
 	text[len] = 0;
 
@@ -315,18 +409,18 @@ String string16_to_string(gbAllocator a, String16 s) {
 bool unquote_char(String s, u8 quote, Rune *rune, bool *multiple_bytes, String *tail_string) {
 	u8 c;
 
-	if (s.text[0] == quote &&
+	if (s[0] == quote &&
 	    (quote == '\'' || quote == '"')) {
 		return false;
-	} else if (s.text[0] >= 0x80) {
+	} else if (s[0] >= 0x80) {
 		Rune r = -1;
 		isize size = gb_utf8_decode(s.text, s.len, &r);
 		*rune = r;
 		*multiple_bytes = true;
 		*tail_string = make_string(s.text+size, s.len-size);
 		return true;
-	} else if (s.text[0] != '\\') {
+	} else if (s[0] != '\\') {
-		*rune = s.text[0];
+		*rune = s[0];
 		*tail_string = make_string(s.text+1, s.len-1);
 		return true;
 	}
@@ -334,7 +428,7 @@ bool unquote_char(String s, u8 quote, Rune *rune, bool *multiple_bytes, String *
 	if (s.len <= 1) {
 		return false;
 	}
-	c = s.text[1];
+	c = s[1];
 	s = make_string(s.text+2, s.len-2);
 
 	switch (c) {
@@ -372,7 +466,7 @@ bool unquote_char(String s, u8 quote, Rune *rune, bool *multiple_bytes, String *
 			return false;
 		}
 		for (i = 0; i < 2; i++) {
-			i32 d = gb_digit_to_int(s.text[i]);
+			i32 d = gb_digit_to_int(s[i]);
 			if (d < 0 || d > 7) {
 				return false;
 			}
@@ -400,7 +494,7 @@ bool unquote_char(String s, u8 quote, Rune *rune, bool *multiple_bytes, String *
 			return false;
 		}
 		for (i = 0; i < count; i++) {
-			i32 d = gb_hex_digit_to_int(s.text[i]);
+			i32 d = gb_hex_digit_to_int(s[i]);
 			if (d < 0) {
 				return false;
 			}
@@ -433,8 +527,8 @@ i32 unquote_string(gbAllocator a, String *s_) {
 	if (n < 2) {
 		return 0;
 	}
-	quote = s.text[0];
+	quote = s[0];
-	if (quote != s.text[n-1]) {
+	if (quote != s[n-1]) {
 		return 0;
 	}
 	s.text += 1;
@@ -471,12 +565,12 @@ i32 unquote_string(gbAllocator a, String *s_) {
 
 
 	{
-		u8 rune_temp[4] = {0};
+		u8 rune_temp[4] = {};
 		isize buf_len = 3*s.len / 2;
 		u8 *buf = gb_alloc_array(a, u8, buf_len);
 		isize offset = 0;
 		while (s.len > 0) {
-			String tail_string = {0};
+			String tail_string = {};
 			Rune r = 0;
 			bool multiple_bytes = false;
 			bool success = unquote_char(s, quote, &r, &multiple_bytes, &tail_string);

src/string_set.cpp

@@ -0,0 +1,184 @@
+struct StringSetFindResult {
+	isize hash_index;
+	isize entry_prev;
+	isize entry_index;
+};
+
+struct StringSetEntry {
+	HashKey  key;
+	isize    next;
+	String   value;
+};
+
+struct StringSet {
+	Array<isize>          hashes;
+	Array<StringSetEntry> entries;
+};
+
+
+void string_set_init   (StringSet *s, gbAllocator a, isize capacity = 16);
+void string_set_destroy(StringSet *s);
+void string_set_add    (StringSet *s, String str);
+bool string_set_exists (StringSet *s, String str);
+void string_set_remove (StringSet *s, String str);
+void string_set_clear  (StringSet *s);
+void string_set_grow   (StringSet *s);
+void string_set_rehash (StringSet *s, isize new_count);
+
+
+gb_inline void string_set_init(StringSet *s, gbAllocator a, isize capacity) {
+	array_init(&s->hashes,  a);
+	array_init(&s->entries, a);
+}
+
+gb_inline void string_set_destroy(StringSet *s) {
+	array_free(&s->entries);
+	array_free(&s->hashes);
+}
+
+gb_internal isize string_set__add_entry(StringSet *s, HashKey key) {
+	StringSetEntry e = {};
+	e.key = key;
+	e.next = -1;
+	array_add(&s->entries, e);
+	return s->entries.count-1;
+}
+
+gb_internal StringSetFindResult string_set__find(StringSet *s, HashKey key) {
+	StringSetFindResult fr = {-1, -1, -1};
+	if (s->hashes.count > 0) {
+		// fr.hash_index  = u128_to_i64(key.key % u128_from_i64(s->hashes.count));
+		fr.hash_index = key.key % s->hashes.count;
+		fr.entry_index = s->hashes[fr.hash_index];
+		while (fr.entry_index >= 0) {
+			if (hash_key_equal(s->entries[fr.entry_index].key, key)) {
+				return fr;
+			}
+			fr.entry_prev = fr.entry_index;
+			fr.entry_index = s->entries[fr.entry_index].next;
+		}
+	}
+	return fr;
+}
+
+gb_internal StringSetFindResult string_set__find_from_entry(StringSet *s, StringSetEntry *e) {
+	StringSetFindResult fr = {-1, -1, -1};
+	if (s->hashes.count > 0) {
+		fr.hash_index  = e->key.key % s->hashes.count;
+		fr.entry_index = s->hashes[fr.hash_index];
+		while (fr.entry_index >= 0) {
+			if (&s->entries[fr.entry_index] == e) {
+				return fr;
+			}
+			fr.entry_prev = fr.entry_index;
+			fr.entry_index = s->entries[fr.entry_index].next;
+		}
+	}
+	return fr;
+}
+
+gb_internal b32 string_set__full(StringSet *s) {
+	return 0.75f * s->hashes.count <= s->entries.count;
+}
+
+gb_inline void string_set_grow(StringSet *s) {
+	isize new_count = ARRAY_GROW_FORMULA(s->entries.count);
+	string_set_rehash(s, new_count);
+}
+
+void string_set_rehash(StringSet *s, isize new_count) {
+	isize i, j;
+	StringSet ns = {};
+	string_set_init(&ns, s->hashes.allocator);
+	array_resize(&ns.hashes, new_count);
+	array_reserve(&ns.entries, s->entries.count);
+	for (i = 0; i < new_count; i++) {
+		ns.hashes[i] = -1;
+	}
+	for (i = 0; i < s->entries.count; i++) {
+		StringSetEntry *e = &s->entries[i];
+		StringSetFindResult fr;
+		if (ns.hashes.count == 0) {
+			string_set_grow(&ns);
+		}
+		fr = string_set__find(&ns, e->key);
+		j = string_set__add_entry(&ns, e->key);
+		if (fr.entry_prev < 0) {
+			ns.hashes[fr.hash_index] = j;
+		} else {
+			ns.entries[fr.entry_prev].next = j;
+		}
+		ns.entries[j].next = fr.entry_index;
+		ns.entries[j].value = e->value;
+		if (string_set__full(&ns)) {
+			string_set_grow(&ns);
+		}
+	}
+	string_set_destroy(s);
+	*s = ns;
+}
+
+gb_inline bool string_set_exists(StringSet *s, String str) {
+	HashKey key = hash_string(str);
+	isize index = string_set__find(s, key).entry_index;
+	return index >= 0;
+}
+
+void string_set_add(StringSet *s, String str) {
+	isize index;
+	StringSetFindResult fr;
+	HashKey key = hash_string(str);
+	if (s->hashes.count == 0) {
+		string_set_grow(s);
+	}
+	fr = string_set__find(s, key);
+	if (fr.entry_index >= 0) {
+		index = fr.entry_index;
+	} else {
+		index = string_set__add_entry(s, key);
+		if (fr.entry_prev >= 0) {
+			s->entries[fr.entry_prev].next = index;
+		} else {
+			s->hashes[fr.hash_index] = index;
+		}
+	}
+	s->entries[index].value = str;
+
+	if (string_set__full(s)) {
+		string_set_grow(s);
+	}
+}
+
+
+void string_set__erase(StringSet *s, StringSetFindResult fr) {
+	StringSetFindResult last;
+	if (fr.entry_prev < 0) {
+		s->hashes[fr.hash_index] = s->entries[fr.entry_index].next;
+	} else {
+		s->entries[fr.entry_prev].next = s->entries[fr.entry_index].next;
+	}
+	if (fr.entry_index == s->entries.count-1) {
+		array_pop(&s->entries);
+		return;
+	}
+	s->entries[fr.entry_index] = s->entries[s->entries.count-1];
+	last = string_set__find(s, s->entries[fr.entry_index].key);
+	if (last.entry_prev >= 0) {
+		s->entries[last.entry_prev].next = fr.entry_index;
+	} else {
+		s->hashes[last.hash_index] = fr.entry_index;
+	}
+}
+
+void string_set_remove(StringSet *s, String str) {
+	HashKey key = hash_string(str);
+	StringSetFindResult fr = string_set__find(s, key);
+	if (fr.entry_index >= 0) {
+		string_set__erase(s, fr);
+	}
+}
+
+gb_inline void string_set_clear(StringSet *s) {
+	array_clear(&s->hashes);
+	array_clear(&s->entries);
+}

src/timings.cpp

@@ -1,14 +1,15 @@
-typedef struct TimeStamp {
+struct TimeStamp {
 	u64    start;
 	u64    finish;
 	String label;
-} TimeStamp;
+};
 
-typedef struct Timings {
+struct Timings {
 	TimeStamp        total;
-	Array(TimeStamp) sections;
+	Array<TimeStamp> sections;
 	u64              freq;
-} Timings;
+	f64              total_time_seconds;
+};
 
 
 #if defined(GB_SYSTEM_WINDOWS)
@@ -83,7 +84,7 @@ TimeStamp make_time_stamp(String label) {
 }
 
 void timings_init(Timings *t, String label, isize buffer_size) {
-	array_init_reserve(&t->sections, heap_allocator(), buffer_size);
+	array_init(&t->sections, heap_allocator(), buffer_size);
 	t->total = make_time_stamp(label);
 	t->freq  = time_stamp__freq();
 }
@@ -94,7 +95,7 @@ void timings_destroy(Timings *t) {
 
 void timings__stop_current_section(Timings *t) {
 	if (t->sections.count > 0) {
-		t->sections.e[t->sections.count-1].finish = time_stamp_time_now();
+		t->sections[t->sections.count-1].finish = time_stamp_time_now();
 	}
 }
 
@@ -103,36 +104,46 @@ void timings_start_section(Timings *t, String label) {
 	array_add(&t->sections, make_time_stamp(label));
 }
 
-f64 time_stamp_as_ms(TimeStamp ts, u64 freq) {
+f64 time_stamp_as_second(TimeStamp ts, u64 freq) {
 	GB_ASSERT_MSG(ts.finish >= ts.start, "time_stamp_as_ms - %.*s", LIT(ts.label));
-	return 1000.0 * cast(f64)(ts.finish - ts.start) / cast(f64)freq;
+	return cast(f64)(ts.finish - ts.start) / cast(f64)freq;
+}
+
+f64 time_stamp_as_ms(TimeStamp ts, u64 freq) {
+	return 1000.0*time_stamp_as_second(ts, freq);
 }
 
 void timings_print_all(Timings *t) {
 	char const SPACES[] = "                                                                ";
-	isize max_len, i;
+	isize max_len;
 
 	timings__stop_current_section(t);
 	t->total.finish = time_stamp_time_now();
 
 	max_len = t->total.label.len;
 	for_array(i, t->sections) {
-		TimeStamp ts = t->sections.e[i];
+		TimeStamp ts = t->sections[i];
 		max_len = gb_max(max_len, ts.label.len);
 	}
 
 	GB_ASSERT(max_len <= gb_size_of(SPACES)-1);
 
-	gb_printf("%.*s%.*s - %.3f ms\n",
+	t->total_time_seconds = time_stamp_as_second(t->total, t->freq);
+
+	f64 total_ms = time_stamp_as_ms(t->total, t->freq);
+
+	gb_printf("%.*s%.*s - % 9.3f ms - %6.2f%%\n",
 	          LIT(t->total.label),
 	          cast(int)(max_len-t->total.label.len), SPACES,
-	          time_stamp_as_ms(t->total, t->freq));
+	          total_ms,
+	          cast(f64)100.0);
 
 	for_array(i, t->sections) {
-		TimeStamp ts = t->sections.e[i];
+		TimeStamp ts = t->sections[i];
-		gb_printf("%.*s%.*s - %.3f ms\n",
+		f64 section_ms = time_stamp_as_ms(ts, t->freq);
+		gb_printf("%.*s%.*s - % 9.3f ms - %6.2f%%\n",
 		          LIT(ts.label),
 	              cast(int)(max_len-ts.label.len), SPACES,
-		          time_stamp_as_ms(ts, t->freq));
+		          section_ms, 100*section_ms/total_ms);
 	}
 }

src/tokenizer.cpp

@@ -37,25 +37,25 @@ TOKEN_KIND(Token__OperatorBegin, "_OperatorBegin"), \
 	TOKEN_KIND(Token_CmpOr,  "||"), \
 \
 TOKEN_KIND(Token__AssignOpBegin, "_AssignOpBegin"), \
-	TOKEN_KIND(Token_AddEq,      "+="), \
+	TOKEN_KIND(Token_AddEq,    "+="), \
-	TOKEN_KIND(Token_SubEq,      "-="), \
+	TOKEN_KIND(Token_SubEq,    "-="), \
-	TOKEN_KIND(Token_MulEq,      "*="), \
+	TOKEN_KIND(Token_MulEq,    "*="), \
-	TOKEN_KIND(Token_QuoEq,      "/="), \
+	TOKEN_KIND(Token_QuoEq,    "/="), \
-	TOKEN_KIND(Token_ModEq,      "%="), \
+	TOKEN_KIND(Token_ModEq,    "%="), \
-	TOKEN_KIND(Token_ModModEq,   "%%="), \
+	TOKEN_KIND(Token_ModModEq, "%%="), \
-	TOKEN_KIND(Token_AndEq,      "&="), \
+	TOKEN_KIND(Token_AndEq,    "&="), \
-	TOKEN_KIND(Token_OrEq,       "|="), \
+	TOKEN_KIND(Token_OrEq,     "|="), \
-	TOKEN_KIND(Token_XorEq,      "~="), \
+	TOKEN_KIND(Token_XorEq,    "~="), \
-	TOKEN_KIND(Token_AndNotEq,   "&~="), \
+	TOKEN_KIND(Token_AndNotEq, "&~="), \
-	TOKEN_KIND(Token_ShlEq,      "<<="), \
+	TOKEN_KIND(Token_ShlEq,    "<<="), \
-	TOKEN_KIND(Token_ShrEq,      ">>="), \
+	TOKEN_KIND(Token_ShrEq,    ">>="), \
-	TOKEN_KIND(Token_CmpAndEq,   "&&="), \
+	TOKEN_KIND(Token_CmpAndEq, "&&="), \
-	TOKEN_KIND(Token_CmpOrEq,    "||="), \
+	TOKEN_KIND(Token_CmpOrEq,  "||="), \
-TOKEN_KIND(Token__AssignOpEnd,   "_AssignOpEnd"), \
+TOKEN_KIND(Token__AssignOpEnd, "_AssignOpEnd"), \
-	TOKEN_KIND(Token_ArrowRight, "->"), \
+	TOKEN_KIND(Token_ArrowRight,       "->"), \
-	TOKEN_KIND(Token_ArrowLeft,  "<-"), \
+	TOKEN_KIND(Token_ArrowLeft,        "<-"), \
-	TOKEN_KIND(Token_Inc,        "++"), \
+	TOKEN_KIND(Token_DoubleArrowRight, "=>"), \
-	TOKEN_KIND(Token_Dec,        "--"), \
+	TOKEN_KIND(Token_Undef,            "---"), \
 \
 TOKEN_KIND(Token__ComparisonBegin, "_ComparisonBegin"), \
 	TOKEN_KIND(Token_CmpEq, "=="), \
@@ -76,52 +76,61 @@ TOKEN_KIND(Token__ComparisonEnd, "_ComparisonEnd"), \
 	TOKEN_KIND(Token_Semicolon,     ";"),   \
 	TOKEN_KIND(Token_Period,        "."),   \
 	TOKEN_KIND(Token_Comma,         ","),   \
-	TOKEN_KIND(Token_Ellipsis,      ".."),  \
+	TOKEN_KIND(Token_Ellipsis,      "..."), \
-	TOKEN_KIND(Token_HalfClosed,    "..<"), \
+	TOKEN_KIND(Token_HalfClosed,    ".."),  \
 	TOKEN_KIND(Token_BackSlash,     "\\"),  \
 TOKEN_KIND(Token__OperatorEnd, "_OperatorEnd"), \
 \
 TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \
-	TOKEN_KIND(Token_when,           "when"),                \
+	TOKEN_KIND(Token_import,                 "import"),                 \
-	TOKEN_KIND(Token_if,             "if"),                  \
+	TOKEN_KIND(Token_export,                 "export"),                 \
-	TOKEN_KIND(Token_else,           "else"),                \
+	TOKEN_KIND(Token_foreign,                "foreign"),                \
-	TOKEN_KIND(Token_for,            "for"),                 \
+	TOKEN_KIND(Token_type,                   "type"),                   \
-	TOKEN_KIND(Token_in,             "in"),                  \
+	TOKEN_KIND(Token_when,                   "when"),                   \
-	TOKEN_KIND(Token_match,          "match"),               \
+	TOKEN_KIND(Token_if,                     "if"),                     \
-	TOKEN_KIND(Token_case,           "case"),                \
+	TOKEN_KIND(Token_else,                   "else"),                   \
-	TOKEN_KIND(Token_break,          "break"),               \
+	TOKEN_KIND(Token_for,                    "for"),                    \
-	TOKEN_KIND(Token_continue,       "continue"),            \
+	TOKEN_KIND(Token_switch,                 "switch"),                 \
-	TOKEN_KIND(Token_fallthrough,    "fallthrough"),         \
+	TOKEN_KIND(Token_in,                     "in"),                     \
-	TOKEN_KIND(Token_defer,          "defer"),               \
+	TOKEN_KIND(Token_do,                     "do"),                     \
-	TOKEN_KIND(Token_return,         "return"),              \
+	TOKEN_KIND(Token_case,                   "case"),                   \
-	TOKEN_KIND(Token_proc,           "proc"),                \
+	TOKEN_KIND(Token_break,                  "break"),                  \
-	TOKEN_KIND(Token_macro,          "macro"),               \
+	TOKEN_KIND(Token_continue,               "continue"),               \
-	TOKEN_KIND(Token_struct,         "struct"),              \
+	TOKEN_KIND(Token_fallthrough,            "fallthrough"),            \
-	TOKEN_KIND(Token_union,          "union"),               \
+	TOKEN_KIND(Token_defer,                  "defer"),                  \
-	TOKEN_KIND(Token_raw_union,      "raw_union"),           \
+	TOKEN_KIND(Token_return,                 "return"),                 \
-	TOKEN_KIND(Token_enum,           "enum"),                \
+	TOKEN_KIND(Token_proc,                   "proc"),                   \
-	TOKEN_KIND(Token_bit_field,      "bit_field"),           \
+	TOKEN_KIND(Token_macro,                  "macro"),                  \
-	TOKEN_KIND(Token_vector,         "vector"),              \
+	TOKEN_KIND(Token_struct,                 "struct"),                 \
-	TOKEN_KIND(Token_static,         "static"),              \
+	TOKEN_KIND(Token_union,                  "union"),                  \
-	TOKEN_KIND(Token_dynamic,        "dynamic"),             \
+	TOKEN_KIND(Token_enum,                   "enum"),                   \
-	TOKEN_KIND(Token_map,            "map"),                 \
+	TOKEN_KIND(Token_bit_field,              "bit_field"),              \
-	TOKEN_KIND(Token_using,          "using"),               \
+	TOKEN_KIND(Token_vector,                 "vector"),                 \
-	TOKEN_KIND(Token_immutable,      "immutable"),           \
+	TOKEN_KIND(Token_map,                    "map"),                    \
-	TOKEN_KIND(Token_context,        "context"),             \
+	TOKEN_KIND(Token_static,                 "static"),                 \
-	TOKEN_KIND(Token_push_context,   "push_context"),        \
+	TOKEN_KIND(Token_dynamic,                "dynamic"),                \
-	TOKEN_KIND(Token_push_allocator, "push_allocator"),      \
+	TOKEN_KIND(Token_cast,                   "cast"),                   \
-	TOKEN_KIND(Token_asm,            "asm"),                 \
+	TOKEN_KIND(Token_transmute,              "transmute"),              \
-	TOKEN_KIND(Token_yield,          "yield"),               \
+	TOKEN_KIND(Token_using,                  "using"),                  \
-	TOKEN_KIND(Token_await,          "await"),               \
+	TOKEN_KIND(Token_inline,                 "inline"),                 \
-	TOKEN_KIND(Token_atomic,         "atomic"),              \
+	TOKEN_KIND(Token_no_inline,              "no_inline"),              \
+	TOKEN_KIND(Token_context,                "context"),                \
+	TOKEN_KIND(Token_size_of,                "size_of"),                \
+	TOKEN_KIND(Token_align_of,               "align_of"),               \
+	TOKEN_KIND(Token_offset_of,              "offset_of"),              \
+	TOKEN_KIND(Token_type_of,                "type_of"),                \
+	TOKEN_KIND(Token_type_info_of,           "type_info_of"),           \
+	TOKEN_KIND(Token_asm,                    "asm"),                    \
+	TOKEN_KIND(Token_yield,                  "yield"),                  \
+	TOKEN_KIND(Token_await,                  "await"),                  \
 TOKEN_KIND(Token__KeywordEnd, "_KeywordEnd"), \
 	TOKEN_KIND(Token_Count, "")
 
-typedef enum TokenKind {
+enum TokenKind {
 #define TOKEN_KIND(e, s) e
 	TOKEN_KINDS
 #undef TOKEN_KIND
-} TokenKind;
+};
 
 String const token_strings[] = {
 #define TOKEN_KIND(e, s) {cast(u8 *)s, gb_size_of(s)-1}
@@ -130,33 +139,39 @@ String const token_strings[] = {
 };
 
 
-typedef struct TokenPos {
+struct TokenPos {
 	String file;
 	isize  line;
 	isize  column;
-} TokenPos;
+};
 
-i32 token_pos_cmp(TokenPos a, TokenPos b) {
+TokenPos token_pos(String file, isize line, isize column) {
-	if (a.line == b.line) {
+	TokenPos pos = {file, line, column};
-		if (a.column == b.column) {
+	return pos;
-			isize min_len = gb_min(a.file.len, b.file.len);
+}
-			return gb_memcompare(a.file.text, b.file.text, min_len);
+
-		}
+i32 token_pos_cmp(TokenPos const &a, TokenPos const &b) {
+	if (a.line != b.line) {
+		return (a.line < b.line) ? -1 : +1;
+	}
+	if (a.column != b.column) {
 		return (a.column < b.column) ? -1 : +1;
 	}
-
+	return string_compare(a.file, b.file);
-	return (a.line < b.line) ? -1 : +1;
 }
 
-bool token_pos_eq(TokenPos a, TokenPos b) {
+bool operator==(TokenPos const &a, TokenPos const &b) { return token_pos_cmp(a, b) == 0; }
-	return token_pos_cmp(a, b) == 0;
+bool operator!=(TokenPos const &a, TokenPos const &b) { return token_pos_cmp(a, b) != 0; }
-}
+bool operator< (TokenPos const &a, TokenPos const &b) { return token_pos_cmp(a, b) <  0; }
+bool operator<=(TokenPos const &a, TokenPos const &b) { return token_pos_cmp(a, b) <= 0; }
+bool operator> (TokenPos const &a, TokenPos const &b) { return token_pos_cmp(a, b) >  0; }
+bool operator>=(TokenPos const &a, TokenPos const &b) { return token_pos_cmp(a, b) >= 0; }
 
-typedef struct Token {
+struct Token {
 	TokenKind kind;
 	String string;
 	TokenPos pos;
-} Token;
+};
 
 Token empty_token = {Token_Invalid};
 Token blank_token = {Token_Ident, {cast(u8 *)"_", 1}};
@@ -167,12 +182,12 @@ Token make_token_ident(String s) {
 }
 
 
-typedef struct ErrorCollector {
+struct ErrorCollector {
 	TokenPos prev;
 	i64     count;
 	i64     warning_count;
 	gbMutex mutex;
-} ErrorCollector;
+};
 
 gb_global ErrorCollector global_error_collector;
 
@@ -184,7 +199,7 @@ void warning_va(Token token, char *fmt, va_list va) {
 	gb_mutex_lock(&global_error_collector.mutex);
 	global_error_collector.warning_count++;
 	// NOTE(bill): Duplicate error, skip it
-	if (!token_pos_eq(global_error_collector.prev, token.pos)) {
+	if (global_error_collector.prev != token.pos) {
 		global_error_collector.prev = token.pos;
 		gb_printf_err("%.*s(%td:%td) Warning: %s\n",
 		              LIT(token.pos.file), token.pos.line, token.pos.column,
@@ -198,7 +213,7 @@ void error_va(Token token, char *fmt, va_list va) {
 	gb_mutex_lock(&global_error_collector.mutex);
 	global_error_collector.count++;
 	// NOTE(bill): Duplicate error, skip it
-	if (!token_pos_eq(global_error_collector.prev, token.pos)) {
+	if (global_error_collector.prev != token.pos) {
 		global_error_collector.prev = token.pos;
 		gb_printf_err("%.*s(%td:%td) %s\n",
 		              LIT(token.pos.file), token.pos.line, token.pos.column,
@@ -214,7 +229,7 @@ void syntax_error_va(Token token, char *fmt, va_list va) {
 	gb_mutex_lock(&global_error_collector.mutex);
 	global_error_collector.count++;
 	// NOTE(bill): Duplicate error, skip it
-	if (!token_pos_eq(global_error_collector.prev, token.pos)) {
+	if (global_error_collector.prev != token.pos) {
 		global_error_collector.prev = token.pos;
 		gb_printf_err("%.*s(%td:%td) Syntax Error: %s\n",
 		              LIT(token.pos.file), token.pos.line, token.pos.column,
@@ -230,7 +245,7 @@ void syntax_warning_va(Token token, char *fmt, va_list va) {
 	gb_mutex_lock(&global_error_collector.mutex);
 	global_error_collector.warning_count++;
 	// NOTE(bill): Duplicate error, skip it
-	if (!token_pos_eq(global_error_collector.prev, token.pos)) {
+	if (global_error_collector.prev != token.pos) {
 		global_error_collector.prev = token.pos;
 		gb_printf_err("%.*s(%td:%td) Syntax Warning: %s\n",
 		              LIT(token.pos.file), token.pos.line, token.pos.column,
@@ -306,7 +321,7 @@ gb_inline bool token_is_shift(TokenKind t) {
 gb_inline void print_token(Token t) { gb_printf("%.*s\n", LIT(t.string)); }
 
 
-typedef enum TokenizerInitError {
+enum TokenizerInitError {
 	TokenizerInit_None,
 
 	TokenizerInit_Invalid,
@@ -315,18 +330,18 @@ typedef enum TokenizerInitError {
 	TokenizerInit_Empty,
 
 	TokenizerInit_Count,
-} TokenizerInitError;
+};
 
 
-typedef struct TokenizerState {
+struct TokenizerState {
 	Rune  curr_rune;   // current character
 	u8 *  curr;        // character pos
 	u8 *  read_curr;   // pos from start
 	u8 *  line;        // current line pos
 	isize line_count;
-} TokenizerState;
+};
 
-typedef struct Tokenizer {
+struct Tokenizer {
 	String fullpath;
 	u8 *start;
 	u8 *end;
@@ -338,12 +353,12 @@ typedef struct Tokenizer {
 	isize line_count;
 
 	isize error_count;
-	Array(String) allocated_strings;
+	Array<String> allocated_strings;
-} Tokenizer;
+};
 
 
 TokenizerState save_tokenizer_state(Tokenizer *t) {
-	TokenizerState state = {0};
+	TokenizerState state = {};
 	state.curr_rune  = t->curr_rune;
 	state.curr       = t->curr;
 	state.read_curr  = t->read_curr;
@@ -415,18 +430,22 @@ TokenizerInitError init_tokenizer(Tokenizer *t, String fullpath) {
 	TokenizerInitError err = TokenizerInit_None;
 
 	char *c_str = gb_alloc_array(heap_allocator(), char, fullpath.len+1);
+	defer (gb_free(heap_allocator(), c_str));
+
 	gb_memcopy(c_str, fullpath.text, fullpath.len);
 	c_str[fullpath.len] = '\0';
 
 	// TODO(bill): Memory map rather than copy contents
 	gbFileContents fc = gb_file_read_contents(heap_allocator(), true, c_str);
 	gb_zero_item(t);
-	if (fc.data != NULL) {
+
+	t->fullpath = fullpath;
+	t->line_count = 1;
+
+	if (fc.data != nullptr) {
 		t->start = cast(u8 *)fc.data;
 		t->line = t->read_curr = t->curr = t->start;
 		t->end = t->start + fc.size;
-		t->fullpath = fullpath;
-		t->line_count = 1;
 
 		advance_to_next_rune(t);
 		if (t->curr_rune == GB_RUNE_BOM) {
@@ -435,8 +454,9 @@ TokenizerInitError init_tokenizer(Tokenizer *t, String fullpath) {
 
 		array_init(&t->allocated_strings, heap_allocator());
 	} else {
-		gbFile f = {0};
+		gbFile f = {};
 		gbFileError file_err = gb_file_open(&f, c_str);
+		defer (gb_file_close(&f));
 
 		switch (file_err) {
 		case gbFileError_Invalid:    err = TokenizerInit_Invalid;    break;
@@ -447,20 +467,17 @@ TokenizerInitError init_tokenizer(Tokenizer *t, String fullpath) {
 		if (err == TokenizerInit_None && gb_file_size(&f) == 0) {
 			err = TokenizerInit_Empty;
 		}
-
-		gb_file_close(&f);
 	}
 
-	gb_free(heap_allocator(), c_str);
 	return err;
 }
 
 gb_inline void destroy_tokenizer(Tokenizer *t) {
-	if (t->start != NULL) {
+	if (t->start != nullptr) {
 		gb_free(heap_allocator(), t->start);
 	}
 	for_array(i, t->allocated_strings) {
-		gb_free(heap_allocator(), t->allocated_strings.e[i].text);
+		gb_free(heap_allocator(), t->allocated_strings[i].text);
 	}
 	array_free(&t->allocated_strings);
 }
@@ -492,7 +509,7 @@ gb_inline void scan_mantissa(Tokenizer *t, i32 base) {
 }
 
 Token scan_number_to_token(Tokenizer *t, bool seen_decimal_point) {
-	Token token = {0};
+	Token token = {};
 	token.kind = Token_Integer;
 	token.string = make_string(t->curr, 1);
 	token.pos.file = t->fullpath;
@@ -538,7 +555,14 @@ Token scan_number_to_token(Tokenizer *t, bool seen_decimal_point) {
 			if (t->curr - prev <= 2) {
 				token.kind = Token_Invalid;
 			}
-		} else {
+		} /* else if (t->curr_rune == 'h') { // Hexadecimal Float
+			token.kind = Token_Float;
+			advance_to_next_rune(t);
+			scan_mantissa(t, 16);
+			if (t->curr - prev <= 2) {
+				token.kind = Token_Invalid;
+			}
+		} */ else {
 			seen_decimal_point = false;
 			scan_mantissa(t, 10);
 
@@ -742,7 +766,7 @@ bool tokenizer_find_line_end(Tokenizer *t) {
 Token tokenizer_get_token(Tokenizer *t) {
 	tokenizer_skip_whitespace(t);
 
-	Token token = {0};
+	Token token = {};
 	token.string = make_string(t->curr, 1);
 	token.pos.file = t->fullpath;
 	token.pos.line = t->line_count;
@@ -760,7 +784,7 @@ Token tokenizer_get_token(Tokenizer *t) {
 		// NOTE(bill): All keywords are > 1
 		if (token.string.len > 1) {
 			for (i32 k = Token__KeywordBegin+1; k < Token__KeywordEnd; k++) {
-				if (str_eq(token.string, token_strings[k])) {
+				if (token.string == token_strings[k]) {
 					token.kind = cast(TokenKind)k;
 					break;
 				}
@@ -866,10 +890,10 @@ Token tokenizer_get_token(Tokenizer *t) {
 			token.kind = Token_Period; // Default
 			if (t->curr_rune == '.') { // Could be an ellipsis
 				advance_to_next_rune(t);
-				token.kind = Token_Ellipsis;
+				token.kind = Token_HalfClosed;
-				if (t->curr_rune == '<') {
+				if (t->curr_rune == '.') {
 					advance_to_next_rune(t);
-					token.kind = Token_HalfClosed;
+					token.kind = Token_Ellipsis;
 				}
 			}
 			break;
@@ -897,11 +921,38 @@ Token tokenizer_get_token(Tokenizer *t) {
 		case '%': token.kind = token_kind_dub_eq(t, '%', Token_Mod, Token_ModEq, Token_ModMod, Token_ModModEq);      break;
 
 		case '*': token.kind = token_kind_variant2(t, Token_Mul, Token_MulEq);                                        break;
-		case '=': token.kind = token_kind_variant2(t, Token_Eq,  Token_CmpEq);                                        break;
+		case '=':
+			token.kind = Token_Eq;
+			if (t->curr_rune == '>') {
+				advance_to_next_rune(t);
+				token.kind = Token_DoubleArrowRight;
+			} else if (t->curr_rune == '=') {
+				advance_to_next_rune(t);
+				token.kind = Token_CmpEq;
+			}
+			break;
 		case '~': token.kind = token_kind_variant2(t, Token_Xor, Token_XorEq);                                        break;
 		case '!': token.kind = token_kind_variant2(t, Token_Not, Token_NotEq);                                        break;
-		case '+': token.kind = token_kind_variant3(t, Token_Add, Token_AddEq, '+', Token_Inc);                        break;
+		// case '+': token.kind = token_kind_variant3(t, Token_Add, Token_AddEq, '+', Token_Inc);                        break;
-		case '-': token.kind = token_kind_variant4(t, Token_Sub, Token_SubEq, '-', Token_Dec, '>', Token_ArrowRight); break;
+		case '+': token.kind = token_kind_variant2(t, Token_Add, Token_AddEq);                                        break;
+		case '-':
+			token.kind = Token_Sub;
+			if (t->curr_rune == '=') {
+				advance_to_next_rune(t);
+				token.kind = Token_SubEq;
+			} else if (t->curr_rune == '-') {
+				advance_to_next_rune(t);
+				token.kind = Token_Invalid;
+				if (t->curr_rune == '-') {
+					advance_to_next_rune(t);
+					token.kind = Token_Undef;
+				}
+			} else if (t->curr_rune == '>') {
+				advance_to_next_rune(t);
+				token.kind = Token_ArrowRight;
+			}
+			break;
+
 		case '/': {
 			if (t->curr_rune == '/') {
 				while (t->curr_rune != '\n' && t->curr_rune != GB_RUNE_EOF) {
@@ -938,6 +989,7 @@ Token tokenizer_get_token(Tokenizer *t) {
 
 		case '<':
 			if (t->curr_rune == '-') {
+				advance_to_next_rune(t);
 				token.kind = Token_ArrowLeft;
 			} else {
 				token.kind = token_kind_dub_eq(t, '<', Token_Lt, Token_LtEq, Token_Shl, Token_ShlEq);
@@ -962,8 +1014,8 @@ Token tokenizer_get_token(Tokenizer *t) {
 		case '|': token.kind = token_kind_dub_eq(t, '|', Token_Or, Token_OrEq, Token_CmpOr, Token_CmpOrEq); break;
 
 		default:
-			if (curr_rune != GB_RUNE_BOM) {
+		if (curr_rune != GB_RUNE_BOM) {
-				u8 str[4] = {0};
+				u8 str[4] = {};
 				int len = cast(int)gb_utf8_encode_rune(str, curr_rune);
 				tokenizer_err(t, "Illegal character: %.*s (%d) ", len, str, curr_rune);
 			}

src/unicode.cpp

@@ -1,9 +1,10 @@
 #pragma warning(push)
 #pragma warning(disable: 4245)
 
+extern "C" {
 // #include "utf8proc/utf8proc.h"
 #include "utf8proc/utf8proc.c"
-
+}
 #pragma warning(pop)
 
 

src/utf8proc/utf8proc.c

@@ -383,7 +383,7 @@ UTF8PROC_DLLEXPORT int utf8proc_charwidth(utf8proc_int32_t c) {
 }
 
 UTF8PROC_DLLEXPORT utf8proc_category_t utf8proc_category(utf8proc_int32_t c) {
-  return utf8proc_get_property(c)->category;
+  return cast(utf8proc_category_t)utf8proc_get_property(c)->category;
 }
 
 UTF8PROC_DLLEXPORT const char *utf8proc_category_string(utf8proc_int32_t c) {
@@ -393,15 +393,15 @@ UTF8PROC_DLLEXPORT const char *utf8proc_category_string(utf8proc_int32_t c) {
 
 #define utf8proc_decompose_lump(replacement_uc) \
   return utf8proc_decompose_char((replacement_uc), dst, bufsize, \
-  options & ~UTF8PROC_LUMP, last_boundclass)
+  (utf8proc_option_t)(options & ~UTF8PROC_LUMP), last_boundclass)
 
 UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_char(utf8proc_int32_t uc, utf8proc_int32_t *dst, utf8proc_ssize_t bufsize, utf8proc_option_t options, int *last_boundclass) {
   const utf8proc_property_t *property;
-  utf8proc_propval_t category;
+  utf8proc_category_t category;
   utf8proc_int32_t hangul_sindex;
   if (uc < 0 || uc >= 0x110000) return UTF8PROC_ERROR_NOTASSIGNED;
   property = unsafe_get_property(uc);
-  category = property->category;
+  category = cast(utf8proc_category_t)property->category;
   hangul_sindex = uc - UTF8PROC_HANGUL_SBASE;
   if (options & (UTF8PROC_COMPOSE|UTF8PROC_DECOMPOSE)) {
     if (hangul_sindex >= 0 && hangul_sindex < UTF8PROC_HANGUL_SCOUNT) {
@@ -728,28 +728,24 @@ UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_map_custom(
 
 UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFD(const utf8proc_uint8_t *str) {
   utf8proc_uint8_t *retval;
-  utf8proc_map(str, 0, &retval, UTF8PROC_NULLTERM | UTF8PROC_STABLE |
+  utf8proc_map(str, 0, &retval, cast(utf8proc_option_t)(UTF8PROC_NULLTERM|UTF8PROC_STABLE|UTF8PROC_DECOMPOSE));
-    UTF8PROC_DECOMPOSE);
   return retval;
 }
 
 UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFC(const utf8proc_uint8_t *str) {
   utf8proc_uint8_t *retval;
-  utf8proc_map(str, 0, &retval, UTF8PROC_NULLTERM | UTF8PROC_STABLE |
+  utf8proc_map(str, 0, &retval, cast(utf8proc_option_t)(UTF8PROC_NULLTERM|UTF8PROC_STABLE|UTF8PROC_COMPOSE));
-    UTF8PROC_COMPOSE);
   return retval;
 }
 
 UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKD(const utf8proc_uint8_t *str) {
   utf8proc_uint8_t *retval;
-  utf8proc_map(str, 0, &retval, UTF8PROC_NULLTERM | UTF8PROC_STABLE |
+  utf8proc_map(str, 0, &retval, cast(utf8proc_option_t)(UTF8PROC_NULLTERM|UTF8PROC_STABLE|UTF8PROC_DECOMPOSE|UTF8PROC_COMPAT));
-    UTF8PROC_DECOMPOSE | UTF8PROC_COMPAT);
   return retval;
 }
 
 UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC(const utf8proc_uint8_t *str) {
   utf8proc_uint8_t *retval;
-  utf8proc_map(str, 0, &retval, UTF8PROC_NULLTERM | UTF8PROC_STABLE |
+  utf8proc_map(str, 0, &retval, cast(utf8proc_option_t)(UTF8PROC_NULLTERM|UTF8PROC_STABLE|UTF8PROC_COMPOSE|UTF8PROC_COMPAT));
-    UTF8PROC_COMPOSE | UTF8PROC_COMPAT);
   return retval;
 }