Merge branch 'master' into skytrias-vendor-additions

vendor/ENet/enet.odin

@@ -343,58 +343,58 @@ foreign ENet {
 	deinitialize                   :: proc() ---
 	linked_version                 :: proc() -> Version ---
 	time_get                       :: proc() -> u32 ---
-	time_set                       :: proc(u32) ---
+	time_set                       :: proc(newTimeBase: u32) ---
 
 	socket_create                  :: proc(SocketType) -> Socket ---
-	socket_bind                    :: proc(Socket, ^Address) -> i32 ---
-	socket_get_address             :: proc(Socket, ^Address) -> i32 ---
-	socket_listen                  :: proc(Socket, i32) -> i32 ---
-	socket_accept                  :: proc(Socket, ^Address) -> Socket ---
-	socket_connect                 :: proc(Socket, ^Address) -> i32 ---
-	socket_send                    :: proc(Socket, ^Address, ^Buffer, uint) -> i32 ---
-	socket_receive                 :: proc(Socket, ^Address, ^Buffer, uint) -> i32 ---
-	socket_wait                    :: proc(Socket, ^u32, u32) -> i32 ---
-	socket_set_option              :: proc(Socket, SocketOption, i32) -> i32 ---
-	socket_get_option              :: proc(Socket, SocketOption, ^i32) -> i32 ---
-	socket_shutdown                :: proc(Socket, SocketShutdown) -> i32 ---
-	socket_destroy                 :: proc(Socket) ---
-	socketset_select               :: proc(Socket, ^SocketSet, ^SocketSet, u32) -> i32 ---
+	socket_bind                    :: proc(socket: Socket, address: ^Address) -> i32 ---
+	socket_get_address             :: proc(socket: Socket, address: ^Address) -> i32 ---
+	socket_listen                  :: proc(socket: Socket, backlog: i32) -> i32 ---
+	socket_accept                  :: proc(socket: Socket, address: ^Address) -> Socket ---
+	socket_connect                 :: proc(socket: Socket, address: ^Address) -> i32 ---
+	socket_send                    :: proc(socket: Socket, address: ^Address, buffers: [^]Buffer, bufferCount: uint) -> i32 ---
+	socket_receive                 :: proc(socket: Socket, address: ^Address, buffers: [^]Buffer, bufferCount: uint) -> i32 ---
+	socket_wait                    :: proc(socket: Socket, condition: ^u32, timeout: u32) -> i32 ---
+	socket_set_option              :: proc(socket: Socket, option: SocketOption, value: i32) -> i32 ---
+	socket_get_option              :: proc(socket: Socket, option: SocketOption, value: ^i32) -> i32 ---
+	socket_shutdown                :: proc(socket: Socket, how: SocketShutdown) -> i32 ---
+	socket_destroy                 :: proc(socket: Socket) ---
+	socketset_select               :: proc(socket: Socket, readSet: ^SocketSet, writeSet: ^SocketSet, timeout: u32) -> i32 ---
 
 	address_set_host_ip            :: proc(address: ^Address, hostName: cstring) -> i32 ---
 	address_set_host               :: proc(address: ^Address, hostName: cstring) -> i32 ---
 	address_get_host_ip            :: proc(address: ^Address, hostName: [^]u8, nameLength: uint) -> i32 ---
 	address_get_host               :: proc(address: ^Address, hostName: [^]u8, nameLength: uint) -> i32 ---
 
-	packet_create                  :: proc(rawptr, uint, u32) -> ^Packet ---
-	packet_destroy                 :: proc(^Packet) ---
-	packet_resize                  :: proc(^Packet, uint) -> i32 ---
-	crc32                          :: proc(^Buffer, uint) -> u32 ---
+	packet_create                  :: proc(data: rawptr, dataLength: uint, flags: PacketFlag) -> ^Packet ---
+	packet_destroy                 :: proc(packet: ^Packet) ---
+	packet_resize                  :: proc(packet: ^Packet, dataLength: uint) -> i32 ---
+	crc32                          :: proc(buffers: [^]Buffer, bufferCount: uint) -> u32 ---
 
-	host_create                    :: proc(^Address, uint, uint, u32, u32) -> ^Host ---
-	host_destroy                   :: proc(^Host) ---
-	host_connect                   :: proc(^Host, ^Address, uint, u32) -> ^Peer ---
-	host_check_events              :: proc(^Host, ^Event) -> i32 ---
-	host_service                   :: proc(^Host, ^Event, u32) -> i32 ---
-	host_flush                     :: proc(^Host) ---
-	host_broadcast                 :: proc(^Host, u8, ^Packet) ---
-	host_compress                  :: proc(^Host, ^Compressor) ---
-	host_compress_with_range_coder :: proc(^Host) -> i32 ---
-	host_channel_limit             :: proc(^Host, uint) ---
-	host_bandwidth_limit           :: proc(^Host, u32, u32) ---
+	host_create                    :: proc(address: ^Address, peerCount: uint, channelLimit: uint, incomingBandwidth: u32, outgoingBandwidth: u32) -> ^Host ---
+	host_destroy                   :: proc(host: ^Host) ---
+	host_connect                   :: proc(host: ^Host, address: ^Address, channelCount: uint, data: u32) -> ^Peer ---
+	host_check_events              :: proc(host: ^Host, event: ^Event) -> i32 ---
+	host_service                   :: proc(host: ^Host, event: ^Event, timeout: u32) -> i32 ---
+	host_flush                     :: proc(host: ^Host) ---
+	host_broadcast                 :: proc(host: ^Host, channelID: u8, packet: ^Packet) ---
+	host_compress                  :: proc(host: ^Host, compressor: ^Compressor) ---
+	host_compress_with_range_coder :: proc(host: ^Host) -> i32 ---
+	host_channel_limit             :: proc(host: ^Host, channelLimit: uint) ---
+	host_bandwidth_limit           :: proc(host: ^Host, incomingBandwidth: u32, outgoingBandwidth: u32) ---
 
-	peer_send                      :: proc(^Peer, u8, ^Packet) -> i32 ---
-	peer_receive                   :: proc(^Peer, ^u8) -> ^Packet ---
-	peer_ping                      :: proc(^Peer) ---
-	peer_ping_interval             :: proc(^Peer, u32) ---
-	peer_timeout                   :: proc(^Peer, u32, u32, u32) ---
-	peer_reset                     :: proc(^Peer) ---
-	peer_disconnect                :: proc(^Peer, u32) ---
-	peer_disconnect_now            :: proc(^Peer, u32) ---
-	peer_disconnect_later          :: proc(^Peer, u32) ---
-	peer_throttle_configure        :: proc(^Peer, u32, u32, u32) ---
+	peer_send                      :: proc(peer: ^Peer, channelID: u8, packet: ^Packet) -> i32 ---
+	peer_receive                   :: proc(peer: ^Peer, channelID: ^u8) -> ^Packet ---
+	peer_ping                      :: proc(peer: ^Peer) ---
+	peer_ping_interval             :: proc(peer: ^Peer, pingInterval: u32) ---
+	peer_timeout                   :: proc(peer: ^Peer, timoutLimit: u32, timeoutMinimum: u32, timeoutMaximum: u32) ---
+	peer_reset                     :: proc(peer: ^Peer) ---
+	peer_disconnect                :: proc(peer: ^Peer, data: u32) ---
+	peer_disconnect_now            :: proc(peer: ^Peer, data: u32) ---
+	peer_disconnect_later          :: proc(peer: ^Peer, data: u32) ---
+	peer_throttle_configure        :: proc(peer: ^Peer, interval: u32, acceleration: u32, deceleration: u32) ---
 
 	range_coder_create             :: proc() -> rawptr ---
-	range_coder_destroy            :: proc(rawptr) ---
-	range_coder_compress           :: proc(rawptr, [^]Buffer, uint, uint, [^]u8, uint) -> uint ---
-	range_coder_decompress         :: proc(rawptr, [^]u8, uint, [^]u8, uint) -> uint ---
+	range_coder_destroy            :: proc(ctx: rawptr) ---
+	range_coder_compress           :: proc(ctx: rawptr, inBuffers: [^]Buffer, inBufferCount: uint, inLimit: uint, outData: [^]u8, outLimit: uint) -> uint ---
+	range_coder_decompress         :: proc(ctx: rawptr, inData: [^]u8, inLimit: uint, outData: [^]u8, outLimit: uint) -> uint ---
 }

vendor/README.md

@@ -143,7 +143,7 @@ Includes full bindings as well as wrappers to match the `core:crypto` API.
 See also LICENSE in the `commonmark` directory itself.
 Includes full bindings and Windows `.lib` and `.dll`.
 
-## CommonMark
+## zlib
 
 [zlib](https://github.com/madler/zlib) data compression library
 

vendor/botan/bindings/botan.odin

@@ -62,7 +62,7 @@ CRL_SIGN                  :: x509_cert_key_constraints(512)
 ENCIPHER_ONLY             :: x509_cert_key_constraints(256)
 DECIPHER_ONLY             :: x509_cert_key_constraints(128)
 
-HASH_SHA1           :: "SHA1"
+HASH_SHA1           :: "SHA-1"
 HASH_SHA_224        :: "SHA-224"
 HASH_SHA_256        :: "SHA-256"
 HASH_SHA_384        :: "SHA-384"
@@ -141,10 +141,12 @@ fpe_struct           :: struct{}
 fpe_t                :: ^fpe_struct
 
 when ODIN_OS == .Windows {
-    foreign import botan_lib "botan.lib"
+    foreign import botan_lib "botan-3.lib"
+} else when ODIN_OS == .Darwin {
+    foreign import botan_lib "system:botan-3"
 } else {
     foreign import botan_lib "system:botan-2"
-}
+} 
 
 @(default_calling_convention="c")
 @(link_prefix="botan_")

vendor/botan/blake2b/blake2b.odin

@@ -69,7 +69,7 @@ hash_stream :: proc(s: io.Stream) -> ([DIGEST_SIZE]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 

vendor/botan/gost/gost.odin

@@ -69,7 +69,7 @@ hash_stream :: proc(s: io.Stream) -> ([DIGEST_SIZE]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 

vendor/botan/keccak/keccak.odin

@@ -69,7 +69,7 @@ hash_stream_512 :: proc(s: io.Stream) -> ([DIGEST_SIZE_512]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 

vendor/botan/md4/md4.odin

@@ -69,7 +69,7 @@ hash_stream :: proc(s: io.Stream) -> ([DIGEST_SIZE]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 

vendor/botan/md5/md5.odin

@@ -69,7 +69,7 @@ hash_stream :: proc(s: io.Stream) -> ([DIGEST_SIZE]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 

vendor/botan/ripemd/ripemd.odin

@@ -69,7 +69,7 @@ hash_stream_160 :: proc(s: io.Stream) -> ([DIGEST_SIZE_160]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 

vendor/botan/sha1/sha1.odin

@@ -69,7 +69,7 @@ hash_stream :: proc(s: io.Stream) -> ([DIGEST_SIZE]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 

vendor/botan/sha2/sha2.odin

@@ -72,7 +72,7 @@ hash_stream_224 :: proc(s: io.Stream) -> ([DIGEST_SIZE_224]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 
@@ -151,7 +151,7 @@ hash_stream_256 :: proc(s: io.Stream) -> ([DIGEST_SIZE_256]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 
@@ -230,7 +230,7 @@ hash_stream_384 :: proc(s: io.Stream) -> ([DIGEST_SIZE_384]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 
@@ -309,7 +309,7 @@ hash_stream_512 :: proc(s: io.Stream) -> ([DIGEST_SIZE_512]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 

vendor/botan/sha3/sha3.odin

@@ -72,7 +72,7 @@ hash_stream_224 :: proc(s: io.Stream) -> ([DIGEST_SIZE_224]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 
@@ -151,7 +151,7 @@ hash_stream_256 :: proc(s: io.Stream) -> ([DIGEST_SIZE_256]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 
@@ -230,7 +230,7 @@ hash_stream_384 :: proc(s: io.Stream) -> ([DIGEST_SIZE_384]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 
@@ -309,7 +309,7 @@ hash_stream_512 :: proc(s: io.Stream) -> ([DIGEST_SIZE_512]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 

vendor/botan/shake/shake.odin

@@ -70,7 +70,7 @@ hash_stream_128 :: proc(s: io.Stream) -> ([DIGEST_SIZE_128]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 
@@ -149,7 +149,7 @@ hash_stream_256 :: proc(s: io.Stream) -> ([DIGEST_SIZE_256]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 

vendor/botan/skein512/skein512.odin

@@ -72,7 +72,7 @@ hash_stream_256 :: proc(s: io.Stream) -> ([DIGEST_SIZE_256]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 
@@ -151,7 +151,7 @@ hash_stream_512 :: proc(s: io.Stream) -> ([DIGEST_SIZE_512]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 
@@ -230,7 +230,7 @@ hash_stream_slice :: proc(s: io.Stream, bit_size: int, allocator := context.allo
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 

vendor/botan/sm3/sm3.odin

@@ -69,7 +69,7 @@ hash_stream :: proc(s: io.Stream) -> ([DIGEST_SIZE]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 

vendor/botan/streebog/streebog.odin

@@ -70,7 +70,7 @@ hash_stream_256 :: proc(s: io.Stream) -> ([DIGEST_SIZE_256]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 
@@ -149,7 +149,7 @@ hash_stream_512 :: proc(s: io.Stream) -> ([DIGEST_SIZE_512]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 

vendor/botan/tiger/tiger.odin

@@ -71,7 +71,7 @@ hash_stream_128 :: proc(s: io.Stream) -> ([DIGEST_SIZE_128]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 
@@ -150,7 +150,7 @@ hash_stream_160 :: proc(s: io.Stream) -> ([DIGEST_SIZE_160]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 
@@ -229,7 +229,7 @@ hash_stream_192 :: proc(s: io.Stream) -> ([DIGEST_SIZE_192]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 

vendor/botan/whirlpool/whirlpool.odin

@@ -69,7 +69,7 @@ hash_stream :: proc(s: io.Stream) -> ([DIGEST_SIZE]byte, bool) {
     defer delete(buf)
     i := 1
     for i > 0 {
-        i, _ = s->impl_read(buf)
+        i, _ = io.read(s, buf)
         if i > 0 {
             botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
         } 

vendor/darwin/Foundation/NSApplication.odin

@@ -1,6 +1,8 @@
 package objc_Foundation
 
 import "core:intrinsics"
+import "core:runtime"
+import "core:strings"
 
 ActivationPolicy :: enum UInteger {
 	Regular    = 0,
@@ -8,74 +10,86 @@ ActivationPolicy :: enum UInteger {
 	Prohibited = 2,
 }
 
-ApplicationDelegate :: struct {
-	willFinishLaunching:                  proc "c" (self: ^ApplicationDelegate, notification: ^Notification),
-	didFinishLaunching:                   proc "c" (self: ^ApplicationDelegate, notification: ^Notification),
-	shouldTerminateAfterLastWindowClosed: proc "c" (self: ^ApplicationDelegate, sender: ^Application) -> BOOL,
-
-	user_data: rawptr,
+ApplicationTerminateReply :: enum UInteger {
+	TerminateCancel = 0,
+	TerminateNow = 1,
+	TerminateLater = 2,
 }
 
+ApplicationPrintReply :: enum UInteger {
+	PrintingCancelled = 0,
+	PrintingSuccess = 1,
+	PrintingReplyLater = 2,
+	PrintingFailure = 3,
+}
+
+ApplicationPresentationOptionFlag :: enum UInteger {
+	AutoHideDock = 0,
+	HideDock = 1,
+	AutoHideMenuBar = 2,
+	HideMenuBar = 3,
+	DisableAppleMenu = 4,
+	DisableProcessSwitching = 5,
+	DisableForceQuit = 6,
+	DisableSessionTermination = 7,
+	DisableHideApplication = 8,
+	DisableMenuBarTransparency = 9,
+	FullScreen = 10,
+	AutoHideToolbar = 11,
+	DisableCursorLocationAssistance = 12,
+}
+ApplicationPresentationOptions :: distinct bit_set[ApplicationPresentationOptionFlag; UInteger]
+ApplicationPresentationOptionsDefault                         :: ApplicationPresentationOptions {}
+ApplicationPresentationOptionsAutoHideDock                    :: ApplicationPresentationOptions {.AutoHideDock}
+ApplicationPresentationOptionsHideDock                        :: ApplicationPresentationOptions {.HideDock}
+ApplicationPresentationOptionsAutoHideMenuBar                 :: ApplicationPresentationOptions {.AutoHideMenuBar}
+ApplicationPresentationOptionsHideMenuBar                     :: ApplicationPresentationOptions {.HideMenuBar}
+ApplicationPresentationOptionsDisableAppleMenu                :: ApplicationPresentationOptions {.DisableAppleMenu}
+ApplicationPresentationOptionsDisableProcessSwitching         :: ApplicationPresentationOptions {.DisableProcessSwitching}
+ApplicationPresentationOptionsDisableForceQuit                :: ApplicationPresentationOptions {.DisableForceQuit}
+ApplicationPresentationOptionsDisableSessionTermination       :: ApplicationPresentationOptions {.DisableSessionTermination}
+ApplicationPresentationOptionsDisableHideApplication          :: ApplicationPresentationOptions {.DisableHideApplication}
+ApplicationPresentationOptionsDisableMenuBarTransparency      :: ApplicationPresentationOptions {.DisableMenuBarTransparency}
+ApplicationPresentationOptionsFullScreen                      :: ApplicationPresentationOptions {.FullScreen}
+ApplicationPresentationOptionsAutoHideToolbar                 :: ApplicationPresentationOptions {.AutoHideToolbar}
+ApplicationPresentationOptionsDisableCursorLocationAssistance :: ApplicationPresentationOptions {.DisableCursorLocationAssistance}
+
 @(objc_class="NSApplication")
 Application :: struct {using _: Object}
 
 @(objc_type=Application, objc_name="sharedApplication", objc_is_class_method=true)
-Application_sharedApplication :: proc() -> ^Application {
+Application_sharedApplication :: proc "c" () -> ^Application {
 	return msgSend(^Application, Application, "sharedApplication")
 }
 
-@(objc_type=Application, objc_name="setDelegate")
-Application_setDelegate :: proc(self: ^Application, delegate: ^ApplicationDelegate) {
-	willFinishLaunching :: proc "c" (self: ^Value, _: SEL, notification: ^Notification) {
-		del := (^ApplicationDelegate)(self->pointerValue())
-		del->willFinishLaunching(notification)
-	}
-	didFinishLaunching :: proc "c" (self: ^Value, _: SEL, notification: ^Notification) {
-		del := (^ApplicationDelegate)(self->pointerValue())
-		del->didFinishLaunching(notification)
-	}
-	shouldTerminateAfterLastWindowClosed :: proc "c" (self: ^Value, _: SEL, application: ^Application) -> BOOL {
-		del := (^ApplicationDelegate)(self->pointerValue())
-		return del->shouldTerminateAfterLastWindowClosed(application)
-	}
-
-	wrapper := Value.valueWithPointer(delegate)
-
-	class_addMethod(intrinsics.objc_find_class("NSValue"), intrinsics.objc_find_selector("applicationWillFinishLaunching:"),                  auto_cast willFinishLaunching,                  "v@:@")
-	class_addMethod(intrinsics.objc_find_class("NSValue"), intrinsics.objc_find_selector("applicationDidFinishLaunching:"),                   auto_cast didFinishLaunching,                   "v@:@")
-	class_addMethod(intrinsics.objc_find_class("NSValue"), intrinsics.objc_find_selector("applicationShouldTerminateAfterLastWindowClosed:"), auto_cast shouldTerminateAfterLastWindowClosed, "B@:@")
-
-	msgSend(nil, self, "setDelegate:", wrapper)
-}
-
 @(objc_type=Application, objc_name="setActivationPolicy")
-Application_setActivationPolicy :: proc(self: ^Application, activationPolicy: ActivationPolicy) -> BOOL {
+Application_setActivationPolicy :: proc "c" (self: ^Application, activationPolicy: ActivationPolicy) -> BOOL {
 	return msgSend(BOOL, self, "setActivationPolicy:", activationPolicy)
 }
 
 @(objc_type=Application, objc_name="activateIgnoringOtherApps")
-Application_activateIgnoringOtherApps :: proc(self: ^Application, ignoreOtherApps: BOOL) {
+Application_activateIgnoringOtherApps :: proc "c" (self: ^Application, ignoreOtherApps: BOOL) {
 	msgSend(nil, self, "activateIgnoringOtherApps:", ignoreOtherApps)
 }
 
 @(objc_type=Application, objc_name="setMainMenu")
-Application_setMainMenu :: proc(self: ^Application, menu: ^Menu) {
+Application_setMainMenu :: proc "c" (self: ^Application, menu: ^Menu) {
 	msgSend(nil, self, "setMainMenu:", menu)
 }
 
 @(objc_type=Application, objc_name="windows")
-Application_windows :: proc(self: ^Application) -> ^Array {
+Application_windows :: proc "c" (self: ^Application) -> ^Array {
 	return msgSend(^Array, self, "windows")
 }
 
 @(objc_type=Application, objc_name="run")
-Application_run :: proc(self: ^Application) {
+Application_run :: proc "c" (self: ^Application) {
 	msgSend(nil, self, "run")
 }
 
 
 @(objc_type=Application, objc_name="terminate")
-Application_terminate :: proc(self: ^Application, sender: ^Object) {
+Application_terminate :: proc "c" (self: ^Application, sender: ^Object) {
 	msgSend(nil, self, "terminate:", sender)
 }
 
@@ -85,11 +99,466 @@ Application_terminate :: proc(self: ^Application, sender: ^Object) {
 RunningApplication :: struct {using _: Object}
 
 @(objc_type=RunningApplication, objc_name="currentApplication", objc_is_class_method=true)
-RunningApplication_currentApplication :: proc() -> ^RunningApplication {
+RunningApplication_currentApplication :: proc "c" () -> ^RunningApplication {
 	return msgSend(^RunningApplication, RunningApplication, "currentApplication")
 }
 
 @(objc_type=RunningApplication, objc_name="localizedName")
-RunningApplication_localizedName :: proc(self: ^RunningApplication) -> ^String {
+RunningApplication_localizedName :: proc "c" (self: ^RunningApplication) -> ^String {
 	return msgSend(^String, self, "localizedName")
-}
+}
+
+ApplicationDelegateTemplate :: struct {
+	// Launching Applications
+	applicationWillFinishLaunching:                              proc(notification: ^Notification),
+	applicationDidFinishLaunching:                               proc(notification: ^Notification),
+	// Managing Active Status
+	applicationWillBecomeActive:                                 proc(notification: ^Notification),
+	applicationDidBecomeActive:                                  proc(notification: ^Notification),
+	applicationWillResignActive:                                 proc(notification: ^Notification),
+	applicationDidResignActive:                                  proc(notification: ^Notification),
+	// Terminating Applications
+	applicationShouldTerminate:                                  proc(sender: ^Application) -> ApplicationTerminateReply,
+	applicationShouldTerminateAfterLastWindowClosed:             proc(sender: ^Application) -> BOOL,
+	applicationWillTerminate:                                    proc(notification: ^Notification),
+	// Hiding Applications
+	applicationWillHide:                                         proc(notification: ^Notification),
+	applicationDidHide:                                          proc(notification: ^Notification),
+	applicationWillUnhide:                                       proc(notification: ^Notification),
+	applicationDidUnhide:                                        proc(notification: ^Notification),
+	// Managing Windows
+	applicationWillUpdate:                                       proc(notification: ^Notification),
+	applicationDidUpdate:                                        proc(notification: ^Notification),
+	applicationShouldHandleReopenHasVisibleWindows:              proc(sender: ^Application, flag: BOOL) -> BOOL,
+	// Managing the Dock Menu
+	applicationDockMenu:                                         proc(sender: ^Application) -> ^Menu,
+	// Localizing Keyboard Shortcuts
+	applicationShouldAutomaticallyLocalizeKeyEquivalents:        proc(application: ^Application) -> BOOL,
+	// Displaying Errors
+	applicationWillPresentError:                                 proc(application: ^Application, error: ^Error) -> ^Error,
+	// Managing the Screen
+	applicationDidChangeScreenParameters:                        proc(notification: ^Notification),
+	// Continuing User Activities
+	applicationWillContinueUserActivityWithType:                 proc(application: ^Application, userActivityType: ^String) -> BOOL,
+	applicationContinueUserActivityRestorationHandler:           proc(application: ^Application, userActivity: ^UserActivity, restorationHandler: ^Block) -> BOOL,
+	applicationDidFailToContinueUserActivityWithTypeError:       proc(application: ^Application, userActivityType: ^String, error: ^Error),
+	applicationDidUpdateUserActivity:                            proc(application: ^Application, userActivity: ^UserActivity),
+	// Handling Push Notifications
+	applicationDidRegisterForRemoteNotificationsWithDeviceToken: proc(application: ^Application, deviceToken: ^Data),
+	applicationDidFailToRegisterForRemoteNotificationsWithError: proc(application: ^Application, error: ^Error),
+	applicationDidReceiveRemoteNotification:                     proc(application: ^Application, userInfo: ^Dictionary),
+	// Handling CloudKit Invitations
+	// TODO: if/when we have cloud kit bindings implement
+	// applicationUserDidAcceptCloudKitShareWithMetadata:        proc(application: ^Application, metadata: ^CKShareMetadata),
+	// Handling SiriKit Intents
+	// TODO: if/when we have siri kit bindings implement
+	// applicationHandlerForIntent:                              proc(application: ^Application, intent: ^INIntent) -> id,
+	// Opening Files
+	applicationOpenURLs:                                         proc(application: ^Application, urls: ^Array),
+	applicationOpenFile:                                         proc(sender: ^Application, filename: ^String) -> BOOL,
+	applicationOpenFileWithoutUI:                                proc(sender: id, filename: ^String) -> BOOL,
+	applicationOpenTempFile:                                     proc(sender: ^Application, filename: ^String) -> BOOL,
+	applicationOpenFiles:                                        proc(sender: ^Application, filenames: ^Array),
+	applicationShouldOpenUntitledFile:                           proc(sender: ^Application) -> BOOL,
+	applicationOpenUntitledFile:                                 proc(sender: ^Application) -> BOOL,
+	// Printing
+	applicationPrintFile:                                        proc(sender: ^Application, filename: ^String) -> BOOL,
+	applicationPrintFilesWithSettingsShowPrintPanels:            proc(application: ^Application, fileNames: ^Array, printSettings: ^Dictionary, showPrintPanels: BOOL) -> ApplicationPrintReply,
+	// Restoring Application State
+	applicationSupportsSecureRestorableState:                    proc(app: ^Application) -> BOOL,
+	applicationProtectedDataDidBecomeAvailable:                  proc(notification: ^Notification),
+	applicationProtectedDataWillBecomeUnavailable:               proc(notification: ^Notification),
+	applicationWillEncodeRestorableState:                        proc(app: ^Application, coder: ^Coder),
+	applicationDidDecodeRestorableState:                         proc(app: ^Application, coder: ^Coder),
+	// Handling Changes to the Occlusion State
+	applicationDidChangeOcclusionState:                          proc(notification: ^Notification),
+	// Scripting Your App
+	applicationDelegateHandlesKey:                               proc(sender: ^Application, key: ^String) -> BOOL,
+}
+
+ApplicationDelegate :: struct { using _: Object }
+_ApplicationDelegateInternal :: struct {
+	using _: ApplicationDelegateTemplate,
+	_context: runtime.Context,
+}
+
+application_delegate_register_and_alloc :: proc(template: ApplicationDelegateTemplate, class_name: string, delegate_context: Maybe(runtime.Context)) -> ^ApplicationDelegate {
+	class := objc_allocateClassPair(intrinsics.objc_find_class("NSObject"), strings.clone_to_cstring(class_name, context.temp_allocator), 0); if class == nil {
+		// Class already registered
+		return nil
+	}
+	if template.applicationWillFinishLaunching != nil {
+		applicationWillFinishLaunching :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationWillFinishLaunching(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationWillFinishLaunching:"), auto_cast applicationWillFinishLaunching, "v@:@")
+	}
+	if template.applicationDidFinishLaunching != nil {
+		applicationDidFinishLaunching :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationDidFinishLaunching(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationDidFinishLaunching:"), auto_cast applicationDidFinishLaunching, "v@:@")
+	}
+	if template.applicationWillBecomeActive != nil {
+		applicationWillBecomeActive :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationWillBecomeActive(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationWillBecomeActive:"), auto_cast applicationWillBecomeActive, "v@:@")
+	}
+	if template.applicationDidBecomeActive != nil {
+		applicationDidBecomeActive :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationDidBecomeActive(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationDidBecomeActive:"), auto_cast applicationDidBecomeActive, "v@:@")
+	}
+	if template.applicationWillResignActive != nil {
+		applicationWillResignActive :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationWillResignActive(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationWillResignActive:"), auto_cast applicationWillResignActive, "v@:@")
+	}
+	if template.applicationDidResignActive != nil {
+		applicationDidResignActive :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationDidResignActive(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationDidResignActive:"), auto_cast applicationDidResignActive, "v@:@")
+	}
+	if template.applicationShouldTerminate != nil {
+		applicationShouldTerminate :: proc "c" (self: id, sender: ^Application) -> ApplicationTerminateReply {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationShouldTerminate(sender)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationShouldTerminate:"), auto_cast applicationShouldTerminate, _UINTEGER_ENCODING+"@:@")
+	}
+	if template.applicationShouldTerminateAfterLastWindowClosed != nil {
+		applicationShouldTerminateAfterLastWindowClosed :: proc "c" (self: id, sender: ^Application) -> BOOL {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationShouldTerminateAfterLastWindowClosed(sender)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationShouldTerminateAfterLastWindowClosed:"), auto_cast applicationShouldTerminateAfterLastWindowClosed, "B@:@")
+	}
+	if template.applicationWillTerminate != nil {
+		applicationWillTerminate :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationWillTerminate(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationWillTerminate:"), auto_cast applicationWillTerminate, "v@:@")
+	}
+	if template.applicationWillHide != nil {
+		applicationWillHide :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationWillHide(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationWillHide:"), auto_cast applicationWillHide, "v@:@")
+	}
+	if template.applicationDidHide != nil {
+		applicationDidHide :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationDidHide(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationDidHide:"), auto_cast applicationDidHide, "v@:@")
+	}
+	if template.applicationWillUnhide != nil {
+		applicationWillUnhide :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationWillUnhide(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationWillUnhide:"), auto_cast applicationWillUnhide, "v@:@")
+	}
+	if template.applicationDidUnhide != nil {
+		applicationDidUnhide :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationDidUnhide(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationDidUnhide:"), auto_cast applicationDidUnhide, "v@:@")
+	}
+	if template.applicationWillUpdate != nil {
+		applicationWillUpdate :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationWillUpdate(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationWillUpdate:"), auto_cast applicationWillUpdate, "v@:@")
+	}
+	if template.applicationDidUpdate != nil {
+		applicationDidUpdate :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationDidUpdate(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationDidUpdate:"), auto_cast applicationDidUpdate, "v@:@")
+	}
+	if template.applicationShouldHandleReopenHasVisibleWindows != nil {
+		applicationShouldHandleReopenHasVisibleWindows :: proc "c" (self: id, sender: ^Application, flag: BOOL) -> BOOL {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationShouldHandleReopenHasVisibleWindows(sender, flag)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationShouldHandleReopen:hasVisibleWindows:"), auto_cast applicationShouldHandleReopenHasVisibleWindows, "B@:@B")
+	}
+	if template.applicationDockMenu != nil {
+		applicationDockMenu :: proc "c" (self: id, sender: ^Application) -> ^Menu {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationDockMenu(sender)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationDockMenu:"), auto_cast applicationDockMenu, "@@:@")
+	}
+	if template.applicationShouldAutomaticallyLocalizeKeyEquivalents != nil {
+		applicationShouldAutomaticallyLocalizeKeyEquivalents :: proc "c" (self: id, application: ^Application) -> BOOL {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationShouldAutomaticallyLocalizeKeyEquivalents(application)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationShouldAutomaticallyLocalizeKeyEquivalents:"), auto_cast applicationShouldAutomaticallyLocalizeKeyEquivalents, "B@:@")
+	}
+	if template.applicationWillPresentError != nil {
+		applicationWillPresentError :: proc "c" (self: id, application: ^Application, error: ^Error) -> ^Error {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationWillPresentError(application, error)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:willPresentError:"), auto_cast applicationWillPresentError, "@@:@@")
+	}
+	if template.applicationDidChangeScreenParameters != nil {
+		applicationDidChangeScreenParameters :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationDidChangeScreenParameters(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationDidChangeScreenParameters:"), auto_cast applicationDidChangeScreenParameters, "v@:@")
+	}
+	if template.applicationWillContinueUserActivityWithType != nil {
+		applicationWillContinueUserActivityWithType :: proc "c" (self: id, application: ^Application, userActivityType: ^String) -> BOOL {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationWillContinueUserActivityWithType(application, userActivityType)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:willContinueUserActivityWithType:"), auto_cast applicationWillContinueUserActivityWithType, "B@:@@")
+	}
+	if template.applicationContinueUserActivityRestorationHandler != nil {
+		applicationContinueUserActivityRestorationHandler :: proc "c" (self: id, application: ^Application, userActivity: ^UserActivity, restorationHandler: ^Block) -> BOOL {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationContinueUserActivityRestorationHandler(application, userActivity, restorationHandler)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:continueUserActivity:restorationHandler:"), auto_cast applicationContinueUserActivityRestorationHandler, "B@:@@?")
+	}
+	if template.applicationDidFailToContinueUserActivityWithTypeError != nil {
+		applicationDidFailToContinueUserActivityWithTypeError :: proc "c" (self: id, application: ^Application, userActivityType: ^String, error: ^Error) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationDidFailToContinueUserActivityWithTypeError(application, userActivityType, error)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:didFailToContinueUserActivityWithType:error:"), auto_cast applicationDidFailToContinueUserActivityWithTypeError, "v@:@@@")
+	}
+	if template.applicationDidUpdateUserActivity != nil {
+		applicationDidUpdateUserActivity :: proc "c" (self: id, application: ^Application, userActivity: ^UserActivity) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationDidUpdateUserActivity(application, userActivity)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:didUpdateUserActivity:"), auto_cast applicationDidUpdateUserActivity, "v@:@@")
+	}
+	if template.applicationDidRegisterForRemoteNotificationsWithDeviceToken != nil {
+		applicationDidRegisterForRemoteNotificationsWithDeviceToken :: proc "c" (self: id, application: ^Application, deviceToken: ^Data) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationDidRegisterForRemoteNotificationsWithDeviceToken(application, deviceToken)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:didRegisterForRemoteNotificationsWithDeviceToken:"), auto_cast applicationDidRegisterForRemoteNotificationsWithDeviceToken, "v@:@@")
+	}
+	if template.applicationDidFailToRegisterForRemoteNotificationsWithError != nil {
+		applicationDidFailToRegisterForRemoteNotificationsWithError :: proc "c" (self: id, application: ^Application, error: ^Error) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationDidFailToRegisterForRemoteNotificationsWithError(application, error)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:didFailToRegisterForRemoteNotificationsWithError:"), auto_cast applicationDidFailToRegisterForRemoteNotificationsWithError, "v@:@@")
+	}
+	if template.applicationDidReceiveRemoteNotification != nil {
+		applicationDidReceiveRemoteNotification :: proc "c" (self: id, application: ^Application, userInfo: ^Dictionary) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationDidReceiveRemoteNotification(application, userInfo)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:didReceiveRemoteNotification:"), auto_cast applicationDidReceiveRemoteNotification, "v@:@@")
+	}
+	// if template.applicationUserDidAcceptCloudKitShareWithMetadata != nil {
+	// 	applicationUserDidAcceptCloudKitShareWithMetadata :: proc "c" (self: id, application: ^Application, metadata: ^CKShareMetadata) {
+	// 		del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+	// 		context = del._context
+	// 		del.applicationUserDidAcceptCloudKitShareWithMetadata(application, metadata)
+	// 	}
+	// 	class_addMethod(class, intrinsics.objc_find_selector("application:userDidAcceptCloudKitShareWithMetadata:"), auto_cast applicationUserDidAcceptCloudKitShareWithMetadata, "v@:@@")
+	// }
+	// if template.applicationHandlerForIntent != nil {
+	// 	applicationHandlerForIntent :: proc "c" (self: id, application: ^Application, intent: ^INIntent) -> id {
+	// 		del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+	// 		context = del._context
+	// 		return del.applicationHandlerForIntent(application, intent)
+	// 	}
+	// 	class_addMethod(class, intrinsics.objc_find_selector("application:handlerForIntent:"), auto_cast applicationHandlerForIntent, "@@:@@")
+	// }
+	if template.applicationOpenURLs != nil {
+		applicationOpenURLs :: proc "c" (self: id, application: ^Application, urls: ^Array) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationOpenURLs(application, urls)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:openURLs:"), auto_cast applicationOpenURLs, "v@:@@")
+	}
+	if template.applicationOpenFile != nil {
+		applicationOpenFile :: proc "c" (self: id, sender: ^Application, filename: ^String) -> BOOL {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationOpenFile(sender, filename)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:openFile:"), auto_cast applicationOpenFile, "B@:@@")
+	}
+	if template.applicationOpenFileWithoutUI != nil {
+		applicationOpenFileWithoutUI :: proc "c" (self: id, sender: id, filename: ^String) -> BOOL {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationOpenFileWithoutUI(sender, filename)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:openFileWithoutUI:"), auto_cast applicationOpenFileWithoutUI, "B@:@@")
+	}
+	if template.applicationOpenTempFile != nil {
+		applicationOpenTempFile :: proc "c" (self: id, sender: ^Application, filename: ^String) -> BOOL {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationOpenTempFile(sender, filename)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:openTempFile:"), auto_cast applicationOpenTempFile, "B@:@@")
+	}
+	if template.applicationOpenFiles != nil {
+		applicationOpenFiles :: proc "c" (self: id, sender: ^Application, filenames: ^Array) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationOpenFiles(sender, filenames)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:openFiles:"), auto_cast applicationOpenFiles, "v@:@@")
+	}
+	if template.applicationShouldOpenUntitledFile != nil {
+		applicationShouldOpenUntitledFile :: proc "c" (self: id, sender: ^Application) -> BOOL {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationShouldOpenUntitledFile(sender)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationShouldOpenUntitledFile:"), auto_cast applicationShouldOpenUntitledFile, "B@:@")
+	}
+	if template.applicationOpenUntitledFile != nil {
+		applicationOpenUntitledFile :: proc "c" (self: id, sender: ^Application) -> BOOL {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationOpenUntitledFile(sender)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationOpenUntitledFile:"), auto_cast applicationOpenUntitledFile, "B@:@")
+	}
+	if template.applicationPrintFile != nil {
+		applicationPrintFile :: proc "c" (self: id, sender: ^Application, filename: ^String) -> BOOL {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationPrintFile(sender, filename)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:printFile:"), auto_cast applicationPrintFile, "B@:@@")
+	}
+	if template.applicationPrintFilesWithSettingsShowPrintPanels != nil {
+		applicationPrintFilesWithSettingsShowPrintPanels :: proc "c" (self: id, application: ^Application, fileNames: ^Array, printSettings: ^Dictionary, showPrintPanels: BOOL) -> ApplicationPrintReply {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationPrintFilesWithSettingsShowPrintPanels(application, fileNames, printSettings, showPrintPanels)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:printFiles:withSettings:showPrintPanels:"), auto_cast applicationPrintFilesWithSettingsShowPrintPanels, _UINTEGER_ENCODING+"@:@@@B")
+	}
+	if template.applicationSupportsSecureRestorableState != nil {
+		applicationSupportsSecureRestorableState :: proc "c" (self: id, app: ^Application) -> BOOL {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationSupportsSecureRestorableState(app)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationSupportsSecureRestorableState:"), auto_cast applicationSupportsSecureRestorableState, "B@:@")
+	}
+	if template.applicationProtectedDataDidBecomeAvailable != nil {
+		applicationProtectedDataDidBecomeAvailable :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationProtectedDataDidBecomeAvailable(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationProtectedDataDidBecomeAvailable:"), auto_cast applicationProtectedDataDidBecomeAvailable, "v@:@")
+	}
+	if template.applicationProtectedDataWillBecomeUnavailable != nil {
+		applicationProtectedDataWillBecomeUnavailable :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationProtectedDataWillBecomeUnavailable(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationProtectedDataWillBecomeUnavailable:"), auto_cast applicationProtectedDataWillBecomeUnavailable, "v@:@")
+	}
+	if template.applicationWillEncodeRestorableState != nil {
+		applicationWillEncodeRestorableState :: proc "c" (self: id, app: ^Application, coder: ^Coder) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationWillEncodeRestorableState(app, coder)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:willEncodeRestorableState:"), auto_cast applicationWillEncodeRestorableState, "v@:@@")
+	}
+	if template.applicationDidDecodeRestorableState != nil {
+		applicationDidDecodeRestorableState :: proc "c" (self: id, app: ^Application, coder: ^Coder) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationDidDecodeRestorableState(app, coder)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:didDecodeRestorableState:"), auto_cast applicationDidDecodeRestorableState, "v@:@@")
+	}
+	if template.applicationDidChangeOcclusionState != nil {
+		applicationDidChangeOcclusionState :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.applicationDidChangeOcclusionState(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("applicationDidChangeOcclusionState:"), auto_cast applicationDidChangeOcclusionState, "v@:@")
+	}
+	if template.applicationDelegateHandlesKey != nil {
+		applicationDelegateHandlesKey :: proc "c" (self: id, sender: ^Application, key: ^String) -> BOOL {
+			del := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.applicationDelegateHandlesKey(sender, key)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("application:delegateHandlesKey:"), auto_cast applicationDelegateHandlesKey, "B@:@@")
+	}
+
+	objc_registerClassPair(class)
+	del := class_createInstance(class, size_of(_ApplicationDelegateInternal))
+	del_internal := cast(^_ApplicationDelegateInternal)object_getIndexedIvars(del)
+	del_internal^ = {
+		template,
+		delegate_context.(runtime.Context) or_else runtime.default_context(),
+	}
+	return cast(^ApplicationDelegate)del
+}
+
+@(objc_type=Application, objc_name="setDelegate")
+Application_setDelegate :: proc "c" (self: ^Application, delegate: ^ApplicationDelegate) {
+	msgSend(nil, self, "setDelegate:", delegate)
+}

vendor/darwin/Foundation/NSArray.odin

@@ -8,35 +8,35 @@ Array :: struct {
 }
 
 @(objc_type=Array, objc_name="alloc", objc_is_class_method=true)
-Array_alloc :: proc() -> ^Array {
+Array_alloc :: proc "c" () -> ^Array {
 	return msgSend(^Array, Array, "alloc")
 }
 
 @(objc_type=Array, objc_name="init")
-Array_init :: proc(self: ^Array) -> ^Array {
+Array_init :: proc "c" (self: ^Array) -> ^Array {
 	return msgSend(^Array, self, "init")
 }
 
 @(objc_type=Array, objc_name="initWithObjects")
-Array_initWithObjects :: proc(self: ^Array, objects: [^]^Object, count: UInteger) -> ^Array {
+Array_initWithObjects :: proc "c" (self: ^Array, objects: [^]^Object, count: UInteger) -> ^Array {
 	return msgSend(^Array, self, "initWithObjects:count:", objects, count)
 }
 
 @(objc_type=Array, objc_name="initWithCoder")
-Array_initWithCoder :: proc(self: ^Array, coder: ^Coder) -> ^Array {
+Array_initWithCoder :: proc "c" (self: ^Array, coder: ^Coder) -> ^Array {
 	return msgSend(^Array, self, "initWithCoder:", coder)
 }
 
 @(objc_type=Array, objc_name="object")
-Array_object :: proc(self: ^Array, index: UInteger) -> ^Object {
+Array_object :: proc "c" (self: ^Array, index: UInteger) -> ^Object {
 	return msgSend(^Object, self, "objectAtIndex:", index)
 }
 @(objc_type=Array, objc_name="objectAs")
-Array_objectAs :: proc(self: ^Array, index: UInteger, $T: typeid) -> T where intrinsics.type_is_pointer(T), intrinsics.type_is_subtype_of(T, ^Object)  {
+Array_objectAs :: proc "c" (self: ^Array, index: UInteger, $T: typeid) -> T where intrinsics.type_is_pointer(T), intrinsics.type_is_subtype_of(T, ^Object)  {
 	return (T)(Array_object(self, index))
 }
 
 @(objc_type=Array, objc_name="count")
-Array_count :: proc(self: ^Array) -> UInteger {
+Array_count :: proc "c" (self: ^Array) -> UInteger {
 	return msgSend(UInteger, self, "count")
 }

vendor/darwin/Foundation/NSAutoreleasePool.odin

@@ -4,30 +4,30 @@ package objc_Foundation
 AutoreleasePool :: struct {using _: Object}
 
 @(objc_type=AutoreleasePool, objc_name="alloc", objc_is_class_method=true)
-AutoreleasePool_alloc :: proc() -> ^AutoreleasePool {
+AutoreleasePool_alloc :: proc "c" () -> ^AutoreleasePool {
 	return msgSend(^AutoreleasePool, AutoreleasePool, "alloc")
 }
 
 @(objc_type=AutoreleasePool, objc_name="init")
-AutoreleasePool_init :: proc(self: ^AutoreleasePool) -> ^AutoreleasePool {
+AutoreleasePool_init :: proc "c" (self: ^AutoreleasePool) -> ^AutoreleasePool {
 	return msgSend(^AutoreleasePool, self, "init")
 }
 
 @(objc_type=AutoreleasePool, objc_name="drain")
-AutoreleasePool_drain :: proc(self: ^AutoreleasePool) {
+AutoreleasePool_drain :: proc "c" (self: ^AutoreleasePool) {
 	msgSend(nil, self, "drain")
 }
 @(objc_type=AutoreleasePool, objc_name="addObject")
-AutoreleasePool_addObject :: proc(self: ^AutoreleasePool, obj: ^Object) {
+AutoreleasePool_addObject :: proc "c" (self: ^AutoreleasePool, obj: ^Object) {
 	msgSend(nil, self, "addObject:", obj)
 }
 @(objc_type=AutoreleasePool, objc_name="showPools")
-AutoreleasePool_showPools :: proc(self: ^AutoreleasePool, obj: ^Object) {
+AutoreleasePool_showPools :: proc "c" (self: ^AutoreleasePool, obj: ^Object) {
 	msgSend(nil, self, "showPools")
 }
 
 
 @(deferred_out=AutoreleasePool_drain)
-scoped_autoreleasepool :: proc() -> ^AutoreleasePool {
+scoped_autoreleasepool :: proc "c" () -> ^AutoreleasePool {
 	return AutoreleasePool.alloc()->init()
 }

vendor/darwin/Foundation/NSBundle.odin

@@ -4,188 +4,188 @@ package objc_Foundation
 Bundle :: struct { using _: Object }
 
 @(objc_type=Bundle, objc_name="mainBundle", objc_is_class_method=true)
-Bundle_mainBundle :: proc() -> ^Bundle {
+Bundle_mainBundle :: proc "c" () -> ^Bundle {
 	return msgSend(^Bundle, Bundle, "mainBundle")
 }
 
 @(objc_type=Bundle, objc_name="bundleWithPath", objc_is_class_method=true)
-Bundle_bundleWithPath :: proc(path: ^String) -> ^Bundle {
+Bundle_bundleWithPath :: proc "c" (path: ^String) -> ^Bundle {
 	return msgSend(^Bundle, Bundle, "bundleWithPath:", path)
 }
 
 @(objc_type=Bundle, objc_name="bundleWithURL", objc_is_class_method=true)
-Bundle_bundleWithURL :: proc(url: ^URL) -> ^Bundle {
+Bundle_bundleWithURL :: proc "c" (url: ^URL) -> ^Bundle {
 	return msgSend(^Bundle, Bundle, "bundleWithUrl:", url)
 }
 
 
 @(objc_type=Bundle, objc_name="alloc", objc_is_class_method=true)
-Bundle_alloc :: proc() -> ^Bundle {
+Bundle_alloc :: proc "c" () -> ^Bundle {
 	return msgSend(^Bundle, Bundle, "alloc")
 }
 
 @(objc_type=Bundle, objc_name="init")
-Bundle_init :: proc(self: ^Bundle) -> ^Bundle {
+Bundle_init :: proc "c" (self: ^Bundle) -> ^Bundle {
 	return msgSend(^Bundle, self, "init")
 }
 
 @(objc_type=Bundle, objc_name="initWithPath")
-Bundle_initWithPath :: proc(self: ^Bundle, path: ^String) -> ^Bundle {
+Bundle_initWithPath :: proc "c" (self: ^Bundle, path: ^String) -> ^Bundle {
 	return msgSend(^Bundle, self, "initWithPath:", path)
 }
 
 @(objc_type=Bundle, objc_name="initWithURL")
-Bundle_initWithURL :: proc(self: ^Bundle, url: ^URL) -> ^Bundle {
+Bundle_initWithURL :: proc "c" (self: ^Bundle, url: ^URL) -> ^Bundle {
 	return msgSend(^Bundle, self, "initWithUrl:", url)
 }
 
 @(objc_type=Bundle, objc_name="allBundles")
-Bundle_allBundles :: proc() -> (all: ^Array) {
+Bundle_allBundles :: proc "c" () -> (all: ^Array) {
 	return msgSend(type_of(all), Bundle, "allBundles")
 }
 
 @(objc_type=Bundle, objc_name="allFrameworks")
-Bundle_allFrameworks :: proc() -> (all: ^Array) {
+Bundle_allFrameworks :: proc "c" () -> (all: ^Array) {
 	return msgSend(type_of(all), Bundle, "allFrameworks")
 }
 
 @(objc_type=Bundle, objc_name="load")
-Bundle_load :: proc(self: ^Bundle) -> BOOL {
+Bundle_load :: proc "c" (self: ^Bundle) -> BOOL {
 	return msgSend(BOOL, self, "load")
 }
 @(objc_type=Bundle, objc_name="unload")
-Bundle_unload :: proc(self: ^Bundle) -> BOOL {
+Bundle_unload :: proc "c" (self: ^Bundle) -> BOOL {
 	return msgSend(BOOL, self, "unload")
 }
 
 @(objc_type=Bundle, objc_name="isLoaded")
-Bundle_isLoaded :: proc(self: ^Bundle) -> BOOL {
+Bundle_isLoaded :: proc "c" (self: ^Bundle) -> BOOL {
 	return msgSend(BOOL, self, "isLoaded")
 }
 
 @(objc_type=Bundle, objc_name="preflightAndReturnError")
-Bundle_preflightAndReturnError :: proc(self: ^Bundle) -> (ok: BOOL, error: ^Error) {
+Bundle_preflightAndReturnError :: proc "contextless" (self: ^Bundle) -> (ok: BOOL, error: ^Error) {
 	ok = msgSend(BOOL, self, "preflightAndReturnError:", &error)
 	return
 }
 
 @(objc_type=Bundle, objc_name="loadAndReturnError")
-Bundle_loadAndReturnError :: proc(self: ^Bundle) -> (ok: BOOL, error: ^Error) {
+Bundle_loadAndReturnError :: proc "contextless" (self: ^Bundle) -> (ok: BOOL, error: ^Error) {
 	ok = msgSend(BOOL, self, "loadAndReturnError:", &error)
 	return
 }
 
 @(objc_type=Bundle, objc_name="bundleURL")
-Bundle_bundleURL :: proc(self: ^Bundle) -> ^URL {
+Bundle_bundleURL :: proc "c" (self: ^Bundle) -> ^URL {
 	return msgSend(^URL, self, "bundleURL")
 }
 
 @(objc_type=Bundle, objc_name="resourceURL")
-Bundle_resourceURL :: proc(self: ^Bundle) -> ^URL {
+Bundle_resourceURL :: proc "c" (self: ^Bundle) -> ^URL {
 	return msgSend(^URL, self, "resourceURL")
 }
 
 @(objc_type=Bundle, objc_name="executableURL")
-Bundle_executableURL :: proc(self: ^Bundle) -> ^URL {
+Bundle_executableURL :: proc "c" (self: ^Bundle) -> ^URL {
 	return msgSend(^URL, self, "executableURL")
 }
 
 @(objc_type=Bundle, objc_name="URLForAuxiliaryExecutable")
-Bundle_URLForAuxiliaryExecutable :: proc(self: ^Bundle, executableName: ^String) -> ^URL {
+Bundle_URLForAuxiliaryExecutable :: proc "c" (self: ^Bundle, executableName: ^String) -> ^URL {
 	return msgSend(^URL, self, "URLForAuxiliaryExecutable:", executableName)
 }
 
 @(objc_type=Bundle, objc_name="privateFrameworksURL")
-Bundle_privateFrameworksURL :: proc(self: ^Bundle) -> ^URL {
+Bundle_privateFrameworksURL :: proc "c" (self: ^Bundle) -> ^URL {
 	return msgSend(^URL, self, "privateFrameworksURL")
 }
 
 @(objc_type=Bundle, objc_name="sharedFrameworksURL")
-Bundle_sharedFrameworksURL :: proc(self: ^Bundle) -> ^URL {
+Bundle_sharedFrameworksURL :: proc "c" (self: ^Bundle) -> ^URL {
 	return msgSend(^URL, self, "sharedFrameworksURL")
 }
 
 @(objc_type=Bundle, objc_name="sharedSupportURL")
-Bundle_sharedSupportURL :: proc(self: ^Bundle) -> ^URL {
+Bundle_sharedSupportURL :: proc "c" (self: ^Bundle) -> ^URL {
 	return msgSend(^URL, self, "sharedSupportURL")
 }
 
 @(objc_type=Bundle, objc_name="builtInPlugInsURL")
-Bundle_builtInPlugInsURL :: proc(self: ^Bundle) -> ^URL {
+Bundle_builtInPlugInsURL :: proc "c" (self: ^Bundle) -> ^URL {
 	return msgSend(^URL, self, "builtInPlugInsURL")
 }
 
 @(objc_type=Bundle, objc_name="appStoreReceiptURL")
-Bundle_appStoreReceiptURL :: proc(self: ^Bundle) -> ^URL {
+Bundle_appStoreReceiptURL :: proc "c" (self: ^Bundle) -> ^URL {
 	return msgSend(^URL, self, "appStoreReceiptURL")
 }
 
 @(objc_type=Bundle, objc_name="bundlePath")
-Bundle_bundlePath :: proc(self: ^Bundle) -> ^String {
+Bundle_bundlePath :: proc "c" (self: ^Bundle) -> ^String {
 	return msgSend(^String, self, "bundlePath")
 }
 
 @(objc_type=Bundle, objc_name="resourcePath")
-Bundle_resourcePath :: proc(self: ^Bundle) -> ^String {
+Bundle_resourcePath :: proc "c" (self: ^Bundle) -> ^String {
 	return msgSend(^String, self, "resourcePath")
 }
 
 @(objc_type=Bundle, objc_name="executablePath")
-Bundle_executablePath :: proc(self: ^Bundle) -> ^String {
+Bundle_executablePath :: proc "c" (self: ^Bundle) -> ^String {
 	return msgSend(^String, self, "executablePath")
 }
 
 @(objc_type=Bundle, objc_name="PathForAuxiliaryExecutable")
-Bundle_PathForAuxiliaryExecutable :: proc(self: ^Bundle, executableName: ^String) -> ^String {
+Bundle_PathForAuxiliaryExecutable :: proc "c" (self: ^Bundle, executableName: ^String) -> ^String {
 	return msgSend(^String, self, "PathForAuxiliaryExecutable:", executableName)
 }
 
 @(objc_type=Bundle, objc_name="privateFrameworksPath")
-Bundle_privateFrameworksPath :: proc(self: ^Bundle) -> ^String {
+Bundle_privateFrameworksPath :: proc "c" (self: ^Bundle) -> ^String {
 	return msgSend(^String, self, "privateFrameworksPath")
 }
 
 @(objc_type=Bundle, objc_name="sharedFrameworksPath")
-Bundle_sharedFrameworksPath :: proc(self: ^Bundle) -> ^String {
+Bundle_sharedFrameworksPath :: proc "c" (self: ^Bundle) -> ^String {
 	return msgSend(^String, self, "sharedFrameworksPath")
 }
 
 @(objc_type=Bundle, objc_name="sharedSupportPath")
-Bundle_sharedSupportPath :: proc(self: ^Bundle) -> ^String {
+Bundle_sharedSupportPath :: proc "c" (self: ^Bundle) -> ^String {
 	return msgSend(^String, self, "sharedSupportPath")
 }
 
 @(objc_type=Bundle, objc_name="builtInPlugInsPath")
-Bundle_builtInPlugInsPath :: proc(self: ^Bundle) -> ^String {
+Bundle_builtInPlugInsPath :: proc "c" (self: ^Bundle) -> ^String {
 	return msgSend(^String, self, "builtInPlugInsPath")
 }
 
 @(objc_type=Bundle, objc_name="appStoreReceiptPath")
-Bundle_appStoreReceiptPath :: proc(self: ^Bundle) -> ^String {
+Bundle_appStoreReceiptPath :: proc "c" (self: ^Bundle) -> ^String {
 	return msgSend(^String, self, "appStoreReceiptPath")
 }
 
 @(objc_type=Bundle, objc_name="bundleIdentifier")
-Bundle_bundleIdentifier :: proc(self: ^Bundle) -> ^String {
+Bundle_bundleIdentifier :: proc "c" (self: ^Bundle) -> ^String {
 	return msgSend(^String, self, "bundleIdentifier")
 }
 
 @(objc_type=Bundle, objc_name="infoDictionary")
-Bundle_infoDictionary :: proc(self: ^Bundle) -> ^Dictionary {
+Bundle_infoDictionary :: proc "c" (self: ^Bundle) -> ^Dictionary {
 	return msgSend(^Dictionary, self, "infoDictionary")
 }
 
 @(objc_type=Bundle, objc_name="localizedInfoDictionary")
-Bundle_localizedInfoDictionary :: proc(self: ^Bundle) -> ^Dictionary {
+Bundle_localizedInfoDictionary :: proc "c" (self: ^Bundle) -> ^Dictionary {
 	return msgSend(^Dictionary, self, "localizedInfoDictionary")
 }
 
 @(objc_type=Bundle, objc_name="objectForInfoDictionaryKey")
-Bundle_objectForInfoDictionaryKey :: proc(self: ^Bundle, key: ^String) -> ^Object {
+Bundle_objectForInfoDictionaryKey :: proc "c" (self: ^Bundle, key: ^String) -> ^Object {
 	return msgSend(^Object, self, "objectForInfoDictionaryKey:", key)
 }
 
 @(objc_type=Bundle, objc_name="localizedStringForKey")
-Bundle_localizedStringForKey :: proc(self: ^Bundle, key: ^String, value: ^String = nil, tableName: ^String = nil) -> ^String {
+Bundle_localizedStringForKey :: proc "c" (self: ^Bundle, key: ^String, value: ^String = nil, tableName: ^String = nil) -> ^String {
 	return msgSend(^String, self, "localizedStringForKey:value:table:", key, value, tableName)
 }

vendor/darwin/Foundation/NSData.odin

@@ -4,21 +4,21 @@ package objc_Foundation
 Data :: struct {using _: Copying(Data)}
 
 @(objc_type=Data, objc_name="alloc", objc_is_class_method=true)
-Data_alloc :: proc() -> ^Data {
+Data_alloc :: proc "c" () -> ^Data {
 	return msgSend(^Data, Data, "alloc")
 }
 
 @(objc_type=Data, objc_name="init")
-Data_init :: proc(self: ^Data) -> ^Data {
+Data_init :: proc "c" (self: ^Data) -> ^Data {
 	return msgSend(^Data, self, "init")
 }
 
 @(objc_type=Data, objc_name="mutableBytes")
-Data_mutableBytes :: proc(self: ^Data) -> rawptr {
+Data_mutableBytes :: proc "c" (self: ^Data) -> rawptr {
 	return msgSend(rawptr, self, "mutableBytes")
 }
 
 @(objc_type=Data, objc_name="length")
-Data_length :: proc(self: ^Data) -> UInteger {
+Data_length :: proc "c" (self: ^Data) -> UInteger {
 	return msgSend(UInteger, self, "length")
 }

vendor/darwin/Foundation/NSDate.odin

@@ -4,16 +4,16 @@ package objc_Foundation
 Date :: struct {using _: Copying(Date)}
 
 @(objc_type=Date, objc_name="alloc", objc_is_class_method=true)
-Date_alloc :: proc() -> ^Date {
+Date_alloc :: proc "c" () -> ^Date {
 	return msgSend(^Date, Date, "alloc")
 }
 
 @(objc_type=Date, objc_name="init")
-Date_init :: proc(self: ^Date) -> ^Date {
+Date_init :: proc "c" (self: ^Date) -> ^Date {
 	return msgSend(^Date, self, "init")
 }
 
 @(objc_type=Date, objc_name="dateWithTimeIntervalSinceNow")
-Date_dateWithTimeIntervalSinceNow :: proc(secs: TimeInterval) -> ^Date {
+Date_dateWithTimeIntervalSinceNow :: proc "c" (secs: TimeInterval) -> ^Date {
 	return msgSend(^Date, Date, "dateWithTimeIntervalSinceNow:", secs)
 }

vendor/darwin/Foundation/NSDictionary.odin

@@ -4,47 +4,47 @@ package objc_Foundation
 Dictionary :: struct {using _: Copying(Dictionary)}
 
 @(objc_type=Dictionary, objc_name="dictionary", objc_is_class_method=true)
-Dictionary_dictionary :: proc() -> ^Dictionary {
+Dictionary_dictionary :: proc "c" () -> ^Dictionary {
 	return msgSend(^Dictionary, Dictionary, "dictionary")
 }
 
 @(objc_type=Dictionary, objc_name="dictionaryWithObject", objc_is_class_method=true)
-Dictionary_dictionaryWithObject :: proc(object: ^Object, forKey: ^Object) -> ^Dictionary {
+Dictionary_dictionaryWithObject :: proc "c" (object: ^Object, forKey: ^Object) -> ^Dictionary {
 	return msgSend(^Dictionary, Dictionary, "dictionaryWithObject:forKey:", object, forKey)
 }
 
 @(objc_type=Dictionary, objc_name="dictionaryWithObjects", objc_is_class_method=true)
-Dictionary_dictionaryWithObjects :: proc(objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary {
+Dictionary_dictionaryWithObjects :: proc "c" (objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary {
 	return msgSend(^Dictionary, Dictionary, "dictionaryWithObjects:forKeys:count", objects, forKeys, count)
 }
 
 
 @(objc_type=Dictionary, objc_name="alloc", objc_is_class_method=true)
-Dictionary_alloc :: proc() -> ^Dictionary {
+Dictionary_alloc :: proc "c" () -> ^Dictionary {
 	return msgSend(^Dictionary, Dictionary, "alloc")
 }
 
 @(objc_type=Dictionary, objc_name="init")
-Dictionary_init :: proc(self: ^Dictionary) -> ^Dictionary {
+Dictionary_init :: proc "c" (self: ^Dictionary) -> ^Dictionary {
 	return msgSend(^Dictionary, self, "init")
 }
 
 @(objc_type=Dictionary, objc_name="initWithObjects")
-Dictionary_initWithObjects :: proc(self: ^Dictionary, objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary {
+Dictionary_initWithObjects :: proc "c" (self: ^Dictionary, objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary {
 	return msgSend(^Dictionary, self, "initWithObjects:forKeys:count", objects, forKeys, count)
 }
 
 @(objc_type=Dictionary, objc_name="objectForKey")
-Dictionary_objectForKey :: proc(self: ^Dictionary, key: ^Object) -> ^Object {
+Dictionary_objectForKey :: proc "c" (self: ^Dictionary, key: ^Object) -> ^Object {
 	return msgSend(^Dictionary, self, "objectForKey:", key)
 }
 
 @(objc_type=Dictionary, objc_name="count")
-Dictionary_count :: proc(self: ^Dictionary) -> UInteger {
+Dictionary_count :: proc "c" (self: ^Dictionary) -> UInteger {
 	return msgSend(UInteger, self, "count")
 }
 
 @(objc_type=Dictionary, objc_name="keyEnumerator")
-Dictionary_keyEnumerator :: proc(self: ^Dictionary, $KeyType: typeid) -> (enumerator: ^Enumerator(KeyType)) {
+Dictionary_keyEnumerator :: proc "c" (self: ^Dictionary, $KeyType: typeid) -> (enumerator: ^Enumerator(KeyType)) {
 	return msgSend(type_of(enumerator), self, "keyEnumerator")
 }

vendor/darwin/Foundation/NSEnumerator.odin

@@ -20,30 +20,30 @@ Enumerator :: struct($T: typeid) where intrinsics.type_is_pointer(T), intrinsics
 
 
 @(objc_type=FastEnumeration, objc_name="alloc", objc_is_class_method=true)
-FastEnumeration_alloc :: proc() -> ^FastEnumeration {
+FastEnumeration_alloc :: proc "c" () -> ^FastEnumeration {
 	return msgSend(^FastEnumeration, FastEnumeration, "alloc")
 }
 
 @(objc_type=FastEnumeration, objc_name="init")
-FastEnumeration_init :: proc(self: ^FastEnumeration) -> ^FastEnumeration {
+FastEnumeration_init :: proc "c" (self: ^FastEnumeration) -> ^FastEnumeration {
 	return msgSend(^FastEnumeration, self, "init")
 }
 
 
 @(objc_type=FastEnumeration, objc_name="countByEnumerating")
-FastEnumeration_countByEnumerating :: proc(self: ^FastEnumeration, state: ^FastEnumerationState, buffer: [^]^Object, len: UInteger) -> UInteger {
+FastEnumeration_countByEnumerating :: proc "c" (self: ^FastEnumeration, state: ^FastEnumerationState, buffer: [^]^Object, len: UInteger) -> UInteger {
 	return msgSend(UInteger, self, "countByEnumeratingWithState:objects:count:", state, buffer, len)
 }
 
-Enumerator_nextObject :: proc(self: ^$E/Enumerator($T)) -> T {
+Enumerator_nextObject :: proc "c" (self: ^$E/Enumerator($T)) -> T {
 	return msgSend(T, self, "nextObject")
 }
 
-Enumerator_allObjects :: proc(self: ^$E/Enumerator($T)) -> (all: ^Array) {
+Enumerator_allObjects :: proc "c" (self: ^$E/Enumerator($T)) -> (all: ^Array) {
 	return msgSend(type_of(all), self, "allObjects")
 }
 
-Enumerator_iterator :: proc(self: ^$E/Enumerator($T)) -> (obj: T, ok: bool) {
+Enumerator_iterator :: proc "contextless" (self: ^$E/Enumerator($T)) -> (obj: T, ok: bool) {
 	obj = msgSend(T, self, "nextObject")
 	ok = obj != nil
 	return

vendor/darwin/Foundation/NSError.odin

@@ -33,56 +33,56 @@ Error :: struct { using _: Copying(Error) }
 
 
 @(objc_type=Error, objc_name="alloc", objc_is_class_method=true)
-Error_alloc :: proc() -> ^Error {
+Error_alloc :: proc "c" () -> ^Error {
 	return msgSend(^Error, Error, "alloc")
 }
 
 @(objc_type=Error, objc_name="init")
-Error_init :: proc(self: ^Error) -> ^Error {
+Error_init :: proc "c" (self: ^Error) -> ^Error {
 	return msgSend(^Error, self, "init")
 }
 
 @(objc_type=Error, objc_name="errorWithDomain", objc_is_class_method=true)
-Error_errorWithDomain :: proc(domain: ErrorDomain, code: Integer, userInfo: ^Dictionary) -> ^Error {
+Error_errorWithDomain :: proc "c" (domain: ErrorDomain, code: Integer, userInfo: ^Dictionary) -> ^Error {
 	return msgSend(^Error, Error, "errorWithDomain:code:userInfo:", domain, code, userInfo)
 }
 
 @(objc_type=Error, objc_name="initWithDomain")
-Error_initWithDomain :: proc(self: ^Error, domain: ErrorDomain, code: Integer, userInfo: ^Dictionary) -> ^Error {
+Error_initWithDomain :: proc "c" (self: ^Error, domain: ErrorDomain, code: Integer, userInfo: ^Dictionary) -> ^Error {
 	return msgSend(^Error, self, "initWithDomain:code:userInfo:", domain, code, userInfo)
 }
 
 @(objc_type=Error, objc_name="code")
-Error_code :: proc(self: ^Error) -> Integer {
+Error_code :: proc "c" (self: ^Error) -> Integer {
 	return msgSend(Integer, self, "code")
 }
 
 @(objc_type=Error, objc_name="domain")
-Error_domain :: proc(self: ^Error) -> ErrorDomain {
+Error_domain :: proc "c" (self: ^Error) -> ErrorDomain {
 	return msgSend(ErrorDomain, self, "domain")
 }
 
 @(objc_type=Error, objc_name="userInfo")
-Error_userInfo :: proc(self: ^Error) -> ^Dictionary {
+Error_userInfo :: proc "c" (self: ^Error) -> ^Dictionary {
 	return msgSend(^Dictionary, self, "userInfo")
 }
 
 @(objc_type=Error, objc_name="localizedDescription")
-Error_localizedDescription :: proc(self: ^Error) -> ^String {
+Error_localizedDescription :: proc "c" (self: ^Error) -> ^String {
 	return msgSend(^String, self, "localizedDescription")
 }
 
 @(objc_type=Error, objc_name="localizedRecoveryOptions")
-Error_localizedRecoveryOptions :: proc(self: ^Error) -> (options: ^Array) {
+Error_localizedRecoveryOptions :: proc "c" (self: ^Error) -> (options: ^Array) {
 	return msgSend(type_of(options), self, "localizedRecoveryOptions")
 }
 
 @(objc_type=Error, objc_name="localizedRecoverySuggestion")
-Error_localizedRecoverySuggestion :: proc(self: ^Error) -> ^String {
+Error_localizedRecoverySuggestion :: proc "c" (self: ^Error) -> ^String {
 	return msgSend(^String, self, "localizedRecoverySuggestion")
 }
 
 @(objc_type=Error, objc_name="localizedFailureReason")
-Error_localizedFailureReason :: proc(self: ^Error) -> ^String {
+Error_localizedFailureReason :: proc "c" (self: ^Error) -> ^String {
 	return msgSend(^String, self, "localizedFailureReason")
 }

vendor/darwin/Foundation/NSEvent.odin

@@ -0,0 +1,5 @@
+package objc_Foundation
+
+@(objc_class="NSEvent")
+Event :: struct {using _: Object}
+// TODO: implement NSEvent

vendor/darwin/Foundation/NSLock.odin

@@ -2,10 +2,10 @@ package objc_Foundation
 
 Locking :: struct($T: typeid) {using _: Object}
 
-Locking_lock :: proc(self: ^Locking($T)) {
+Locking_lock :: proc "c" (self: ^Locking($T)) {
 	msgSend(nil, self, "lock")
 }
-Locking_unlock :: proc(self: ^Locking($T)) {
+Locking_unlock :: proc "c" (self: ^Locking($T)) {
 	msgSend(nil, self, "unlock")
 }
 
@@ -14,40 +14,40 @@ Condition :: struct {using _: Locking(Condition) }
 
 
 @(objc_type=Condition, objc_name="alloc", objc_is_class_method=true)
-Condition_alloc :: proc() -> ^Condition {
+Condition_alloc :: proc "c" () -> ^Condition {
 	return msgSend(^Condition, Condition, "alloc")
 }
 
 @(objc_type=Condition, objc_name="init")
-Condition_init :: proc(self: ^Condition) -> ^Condition {
+Condition_init :: proc "c" (self: ^Condition) -> ^Condition {
 	return msgSend(^Condition, self, "init")
 }
 
 @(objc_type=Condition, objc_name="wait")
-Condition_wait :: proc(self: ^Condition) {
+Condition_wait :: proc "c" (self: ^Condition) {
 	msgSend(nil, self, "wait")
 }
 
 @(objc_type=Condition, objc_name="waitUntilDate")
-Condition_waitUntilDate :: proc(self: ^Condition, limit: ^Date) -> BOOL {
+Condition_waitUntilDate :: proc "c" (self: ^Condition, limit: ^Date) -> BOOL {
 	return msgSend(BOOL, self, "waitUntilDate:", limit)
 }
 
 @(objc_type=Condition, objc_name="signal")
-Condition_signal :: proc(self: ^Condition) {
+Condition_signal :: proc "c" (self: ^Condition) {
 	msgSend(nil, self, "signal")
 }
 
 @(objc_type=Condition, objc_name="broadcast")
-Condition_broadcast :: proc(self: ^Condition) {
+Condition_broadcast :: proc "c" (self: ^Condition) {
 	msgSend(nil, self, "broadcast")
 }
 
 @(objc_type=Condition, objc_name="lock")
-Condition_lock :: proc(self: ^Condition) {
+Condition_lock :: proc "c" (self: ^Condition) {
 	msgSend(nil, self, "lock")
 }
 @(objc_type=Condition, objc_name="unlock")
-Condition_unlock :: proc(self: ^Condition) {
+Condition_unlock :: proc "c" (self: ^Condition) {
 	msgSend(nil, self, "unlock")
 }

vendor/darwin/Foundation/NSMenu.odin

@@ -27,11 +27,11 @@ MenuItemCallback :: proc "c" (unused: rawptr, name: SEL, sender: ^Object)
 MenuItem :: struct {using _: Object} 
 
 @(objc_type=MenuItem, objc_name="alloc", objc_is_class_method=true)
-MenuItem_alloc :: proc() -> ^MenuItem {
+MenuItem_alloc :: proc "c" () -> ^MenuItem {
 	return msgSend(^MenuItem, MenuItem, "alloc")
 }
 @(objc_type=MenuItem, objc_name="registerActionCallback", objc_is_class_method=true)
-MenuItem_registerActionCallback :: proc(name: cstring, callback: MenuItemCallback) -> SEL {
+MenuItem_registerActionCallback :: proc "c" (name: cstring, callback: MenuItemCallback) -> SEL {
 	s := string(name)
 	n := len(s)
 	sel: SEL
@@ -51,22 +51,22 @@ MenuItem_registerActionCallback :: proc(name: cstring, callback: MenuItemCallbac
 }
 
 @(objc_type=MenuItem, objc_name="init")
-MenuItem_init :: proc(self: ^MenuItem) -> ^MenuItem {
+MenuItem_init :: proc "c" (self: ^MenuItem) -> ^MenuItem {
 	return msgSend(^MenuItem, self, "init")
 }
 
 @(objc_type=MenuItem, objc_name="setKeyEquivalentModifierMask")
-MenuItem_setKeyEquivalentModifierMask :: proc(self: ^MenuItem, modifierMask: KeyEquivalentModifierMask) {
+MenuItem_setKeyEquivalentModifierMask :: proc "c" (self: ^MenuItem, modifierMask: KeyEquivalentModifierMask) {
 	msgSend(nil, self, "setKeyEquivalentModifierMask:", modifierMask)
 }
 
 @(objc_type=MenuItem, objc_name="keyEquivalentModifierMask")
-MenuItem_keyEquivalentModifierMask :: proc(self: ^MenuItem) -> KeyEquivalentModifierMask {
+MenuItem_keyEquivalentModifierMask :: proc "c" (self: ^MenuItem) -> KeyEquivalentModifierMask {
 	return msgSend(KeyEquivalentModifierMask, self, "keyEquivalentModifierMask")
 }
 
 @(objc_type=MenuItem, objc_name="setSubmenu")
-MenuItem_setSubmenu :: proc(self: ^MenuItem, submenu: ^Menu) {
+MenuItem_setSubmenu :: proc "c" (self: ^MenuItem, submenu: ^Menu) {
 	msgSend(nil, self, "setSubmenu:", submenu)
 }
 
@@ -77,27 +77,27 @@ MenuItem_setSubmenu :: proc(self: ^MenuItem, submenu: ^Menu) {
 Menu :: struct {using _: Object} 
 
 @(objc_type=Menu, objc_name="alloc", objc_is_class_method=true)
-Menu_alloc :: proc() -> ^Menu {
+Menu_alloc :: proc "c" () -> ^Menu {
 	return msgSend(^Menu, Menu, "alloc")
 }
 
 @(objc_type=Menu, objc_name="init")
-Menu_init :: proc(self: ^Menu) -> ^Menu {
+Menu_init :: proc "c" (self: ^Menu) -> ^Menu {
 	return msgSend(^Menu, self, "init")
 }
 
 @(objc_type=Menu, objc_name="initWithTitle")
-Menu_initWithTitle :: proc(self: ^Menu, title: ^String) -> ^Menu {
+Menu_initWithTitle :: proc "c" (self: ^Menu, title: ^String) -> ^Menu {
 	return msgSend(^Menu, self, "initWithTitle:", title)
 }
 
 
 @(objc_type=Menu, objc_name="addItem")
-Menu_addItem :: proc(self: ^Menu, item: ^MenuItem) {
+Menu_addItem :: proc "c" (self: ^Menu, item: ^MenuItem) {
 	msgSend(nil, self, "addItem:", item)
 }
 
 @(objc_type=Menu, objc_name="addItemWithTitle")
-Menu_addItemWithTitle :: proc(self: ^Menu, title: ^String, selector: SEL, keyEquivalent: ^String) -> ^MenuItem {
+Menu_addItemWithTitle :: proc "c" (self: ^Menu, title: ^String, selector: SEL, keyEquivalent: ^String) -> ^MenuItem {
 	return msgSend(^MenuItem, self, "addItemWithTitle:action:keyEquivalent:", title, selector, keyEquivalent)
 }

vendor/darwin/Foundation/NSNotification.odin

@@ -5,26 +5,56 @@ Notification :: struct{using _: Object}
 
 
 @(objc_type=Notification, objc_name="alloc", objc_is_class_method=true)
-Notification_alloc :: proc() -> ^Notification {
+Notification_alloc :: proc "c" () -> ^Notification {
 	return msgSend(^Notification, Notification, "alloc")
 }
 
 @(objc_type=Notification, objc_name="init")
-Notification_init :: proc(self: ^Notification) -> ^Notification {
+Notification_init :: proc "c" (self: ^Notification) -> ^Notification {
 	return msgSend(^Notification, self, "init")
 }
 
 @(objc_type=Notification, objc_name="name")
-Notification_name :: proc(self: ^Notification) -> ^String {
+Notification_name :: proc "c" (self: ^Notification) -> ^String {
 	return msgSend(^String, self, "name")
 }
 
 @(objc_type=Notification, objc_name="object")
-Notification_object :: proc(self: ^Notification) -> ^Object {
+Notification_object :: proc "c" (self: ^Notification) -> ^Object {
 	return msgSend(^Object, self, "object")
 }
 
 @(objc_type=Notification, objc_name="userInfo")
-Notification_userInfo :: proc(self: ^Notification) -> ^Dictionary {
+Notification_userInfo :: proc "c" (self: ^Notification) -> ^Dictionary {
 	return msgSend(^Dictionary, self, "userInfo")
+}
+
+NotificationName :: ^String
+
+@(objc_class="NSNotificationCenter")
+NotificationCenter :: struct{using _: Object}
+
+
+@(objc_type=NotificationCenter, objc_name="alloc", objc_is_class_method=true)
+NotificationCenter_alloc :: proc "c" () -> ^NotificationCenter {
+	return msgSend(^NotificationCenter, NotificationCenter, "alloc")
+}
+
+@(objc_type=NotificationCenter, objc_name="init")
+NotificationCenter_init :: proc "c" (self: ^NotificationCenter) -> ^NotificationCenter {
+	return msgSend(^NotificationCenter, self, "init")
+}
+
+@(objc_type=NotificationCenter, objc_name="defaultCenter", objc_is_class_method=true)
+NotificationCenter_defaultCenter :: proc "c" () -> ^NotificationCenter {
+	return msgSend(^NotificationCenter, NotificationCenter, "defaultCenter")
+}
+
+@(objc_type=NotificationCenter, objc_name="addObserver")
+NotificationCenter_addObserverName :: proc "c" (self: ^NotificationCenter, name: NotificationName, pObj: ^Object, pQueue: rawptr, block: ^Block) -> ^Object {
+	return msgSend(^Object, self, "addObserverName:object:queue:block:", name, pObj, pQueue, block)
+}
+@(objc_type=NotificationCenter, objc_name="removeObserver")
+NotificationCenter_removeObserver :: proc "c" (self: ^NotificationCenter, pObserver: ^Object) {
+	msgSend(nil, self, "removeObserver:", pObserver)
 }

vendor/darwin/Foundation/NSNumber.odin

@@ -12,37 +12,37 @@ when ODIN_OS == .Darwin {
 Value :: struct{using _: Copying(Value)}
 
 @(objc_type=Value, objc_name="alloc", objc_is_class_method=true)
-Value_alloc :: proc() -> ^Value {
+Value_alloc :: proc "c" () -> ^Value {
 	return msgSend(^Value, Value, "alloc")
 }
 
 @(objc_type=Value, objc_name="init")
-Value_init :: proc(self: ^Value) -> ^Value {
+Value_init :: proc "c" (self: ^Value) -> ^Value {
 	return msgSend(^Value, self, "init")
 }
 
 @(objc_type=Value, objc_name="valueWithBytes", objc_is_class_method=true)
-Value_valueWithBytes :: proc(value: rawptr, type: cstring) -> ^Value {
+Value_valueWithBytes :: proc "c" (value: rawptr, type: cstring) -> ^Value {
 	return msgSend(^Value, Value, "valueWithBytes:objCType:", value, type)
 }
 
 @(objc_type=Value, objc_name="valueWithPointer", objc_is_class_method=true)
-Value_valueWithPointer :: proc(pointer: rawptr) -> ^Value {
+Value_valueWithPointer :: proc "c" (pointer: rawptr) -> ^Value {
 	return msgSend(^Value, Value, "valueWithPointer:", pointer)
 }
 
 @(objc_type=Value, objc_name="initWithBytes")
-Value_initWithBytes :: proc(self: ^Value, value: rawptr, type: cstring) -> ^Value {
+Value_initWithBytes :: proc "c" (self: ^Value, value: rawptr, type: cstring) -> ^Value {
 	return msgSend(^Value, self, "initWithBytes:objCType:", value, type)
 }
 
 @(objc_type=Value, objc_name="initWithCoder")
-Value_initWithCoder :: proc(self: ^Value, coder: ^Coder) -> ^Value {
+Value_initWithCoder :: proc "c" (self: ^Value, coder: ^Coder) -> ^Value {
 	return msgSend(^Value, self, "initWithCoder:", coder)
 }
 
 @(objc_type=Value, objc_name="getValue")
-Value_getValue :: proc(self: ^Value, value: rawptr, size: UInteger) {
+Value_getValue :: proc "c" (self: ^Value, value: rawptr, size: UInteger) {
 	msgSend(nil, self, "getValue:size:", value, size)
 }
 
@@ -67,29 +67,30 @@ Value_pointerValue :: proc "c" (self: ^Value) -> rawptr {
 Number :: struct{using _: Copying(Number), using _: Value}
 
 @(objc_type=Number, objc_name="alloc", objc_is_class_method=true)
-Number_alloc :: proc() -> ^Number {
+Number_alloc :: proc "c" () -> ^Number {
 	return msgSend(^Number, Number, "alloc")
 }
 
 @(objc_type=Number, objc_name="init")
-Number_init :: proc(self: ^Number) -> ^Number {
+Number_init :: proc "c" (self: ^Number) -> ^Number {
 	return msgSend(^Number, self, "init")
 }
 
-@(objc_type=Number, objc_name="numberWithI8",   objc_is_class_method=true)   Number_numberWithI8   :: proc(value: i8)   -> ^Number { return msgSend(^Number, Number, "numberWithChar:",             value) }
-@(objc_type=Number, objc_name="numberWithU8",   objc_is_class_method=true)   Number_numberWithU8   :: proc(value: u8)   -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedChar:",     value) }
-@(objc_type=Number, objc_name="numberWithI16",  objc_is_class_method=true)  Number_numberWithI16  :: proc(value: i16)  -> ^Number { return msgSend(^Number, Number, "numberWithShort:",            value) }
-@(objc_type=Number, objc_name="numberWithU16",  objc_is_class_method=true)  Number_numberWithU16  :: proc(value: u16)  -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedShort:",    value) }
-@(objc_type=Number, objc_name="numberWithI32",  objc_is_class_method=true)  Number_numberWithI32  :: proc(value: i32)  -> ^Number { return msgSend(^Number, Number, "numberWithInt:",              value) }
-@(objc_type=Number, objc_name="numberWithU32",  objc_is_class_method=true)  Number_numberWithU32  :: proc(value: u32)  -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedInt:",      value) }
-@(objc_type=Number, objc_name="numberWithInt",  objc_is_class_method=true)  Number_numberWithInt  :: proc(value: int)  -> ^Number { return msgSend(^Number, Number, "numberWithLong:",             value) }
-@(objc_type=Number, objc_name="numberWithUint", objc_is_class_method=true) Number_numberWithUint :: proc(value: uint) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLong:",     value) }
-@(objc_type=Number, objc_name="numberWithU64",  objc_is_class_method=true)  Number_numberWithU64  :: proc(value: u64)  -> ^Number { return msgSend(^Number, Number, "numberWithLongLong:",         value) }
-@(objc_type=Number, objc_name="numberWithI64",  objc_is_class_method=true)  Number_numberWithI64  :: proc(value: i64)  -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLongLong:", value) }
-@(objc_type=Number, objc_name="numberWithF32",  objc_is_class_method=true)  Number_numberWithF32  :: proc(value: f32)  -> ^Number { return msgSend(^Number, Number, "numberWithFloat:",            value) }
-@(objc_type=Number, objc_name="numberWithF64",  objc_is_class_method=true)  Number_numberWithF64  :: proc(value: f64)  -> ^Number { return msgSend(^Number, Number, "numberWithDouble:",           value) }
-@(objc_type=Number, objc_name="numberWithBool", objc_is_class_method=true) Number_numberWithBool :: proc(value: BOOL) -> ^Number { return msgSend(^Number, Number, "numberWithBool:",             value) }
+@(objc_type=Number, objc_name="numberWithI8",   objc_is_class_method=true) Number_numberWithI8   :: proc "c" (value: i8)   -> ^Number { return msgSend(^Number, Number, "numberWithChar:",             value) }
+@(objc_type=Number, objc_name="numberWithU8",   objc_is_class_method=true) Number_numberWithU8   :: proc "c" (value: u8)   -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedChar:",     value) }
+@(objc_type=Number, objc_name="numberWithI16",  objc_is_class_method=true) Number_numberWithI16  :: proc "c" (value: i16)  -> ^Number { return msgSend(^Number, Number, "numberWithShort:",            value) }
+@(objc_type=Number, objc_name="numberWithU16",  objc_is_class_method=true) Number_numberWithU16  :: proc "c" (value: u16)  -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedShort:",    value) }
+@(objc_type=Number, objc_name="numberWithI32",  objc_is_class_method=true) Number_numberWithI32  :: proc "c" (value: i32)  -> ^Number { return msgSend(^Number, Number, "numberWithInt:",              value) }
+@(objc_type=Number, objc_name="numberWithU32",  objc_is_class_method=true) Number_numberWithU32  :: proc "c" (value: u32)  -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedInt:",      value) }
+@(objc_type=Number, objc_name="numberWithInt",  objc_is_class_method=true) Number_numberWithInt  :: proc "c" (value: int)  -> ^Number { return msgSend(^Number, Number, "numberWithLong:",             value) }
+@(objc_type=Number, objc_name="numberWithUint", objc_is_class_method=true) Number_numberWithUint :: proc "c" (value: uint) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLong:",     value) }
+@(objc_type=Number, objc_name="numberWithU64",  objc_is_class_method=true) Number_numberWithU64  :: proc "c" (value: u64)  -> ^Number { return msgSend(^Number, Number, "numberWithLongLong:",         value) }
+@(objc_type=Number, objc_name="numberWithI64",  objc_is_class_method=true) Number_numberWithI64  :: proc "c" (value: i64)  -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLongLong:", value) }
+@(objc_type=Number, objc_name="numberWithF32",  objc_is_class_method=true) Number_numberWithF32  :: proc "c" (value: f32)  -> ^Number { return msgSend(^Number, Number, "numberWithFloat:",            value) }
+@(objc_type=Number, objc_name="numberWithF64",  objc_is_class_method=true) Number_numberWithF64  :: proc "c" (value: f64)  -> ^Number { return msgSend(^Number, Number, "numberWithDouble:",           value) }
+@(objc_type=Number, objc_name="numberWithBool", objc_is_class_method=true) Number_numberWithBool :: proc "c" (value: BOOL) -> ^Number { return msgSend(^Number, Number, "numberWithBool:",             value) }
 
+@(objc_type=Number, objc_name="number", objc_is_class_method=true)
 Number_number :: proc{
 	Number_numberWithI8,
 	Number_numberWithU8,
@@ -106,49 +107,49 @@ Number_number :: proc{
 	Number_numberWithBool,
 }
 
-@(objc_type=Number, objc_name="initWithI8")    Number_initWithI8   :: proc(self: ^Number, value: i8)   -> ^Number { return msgSend(^Number, self, "initWithChar:",             value) }
-@(objc_type=Number, objc_name="initWithU8")    Number_initWithU8   :: proc(self: ^Number, value: u8)   -> ^Number { return msgSend(^Number, self, "initWithUnsignedChar:",     value) }
-@(objc_type=Number, objc_name="initWithI16")   Number_initWithI16  :: proc(self: ^Number, value: i16)  -> ^Number { return msgSend(^Number, self, "initWithShort:",            value) }
-@(objc_type=Number, objc_name="initWithU16")   Number_initWithU16  :: proc(self: ^Number, value: u16)  -> ^Number { return msgSend(^Number, self, "initWithUnsignedShort:",    value) }
-@(objc_type=Number, objc_name="initWithI32")   Number_initWithI32  :: proc(self: ^Number, value: i32)  -> ^Number { return msgSend(^Number, self, "initWithInt:",              value) }
-@(objc_type=Number, objc_name="initWithU32")   Number_initWithU32  :: proc(self: ^Number, value: u32)  -> ^Number { return msgSend(^Number, self, "initWithUnsignedInt:",      value) }
-@(objc_type=Number, objc_name="initWithInt")   Number_initWithInt  :: proc(self: ^Number, value: int)  -> ^Number { return msgSend(^Number, self, "initWithLong:",             value) }
-@(objc_type=Number, objc_name="initWithUint")  Number_initWithUint :: proc(self: ^Number, value: uint) -> ^Number { return msgSend(^Number, self, "initWithUnsignedLong:",     value) }
-@(objc_type=Number, objc_name="initWithU64")   Number_initWithU64  :: proc(self: ^Number, value: u64)  -> ^Number { return msgSend(^Number, self, "initWithLongLong:",         value) }
-@(objc_type=Number, objc_name="initWithI64")   Number_initWithI64  :: proc(self: ^Number, value: i64)  -> ^Number { return msgSend(^Number, self, "initWithUnsignedLongLong:", value) }
-@(objc_type=Number, objc_name="initWithF32")   Number_initWithF32  :: proc(self: ^Number, value: f32)  -> ^Number { return msgSend(^Number, self, "initWithFloat:",            value) }
-@(objc_type=Number, objc_name="initWithF64")   Number_initWithF64  :: proc(self: ^Number, value: f64)  -> ^Number { return msgSend(^Number, self, "initWithDouble:",           value) }
-@(objc_type=Number, objc_name="initWithBool")  Number_initWithBool :: proc(self: ^Number, value: BOOL) -> ^Number { return msgSend(^Number, self, "initWithBool:",             value) }
+@(objc_type=Number, objc_name="initWithI8")    Number_initWithI8   :: proc "c" (self: ^Number, value: i8)   -> ^Number { return msgSend(^Number, self, "initWithChar:",             value) }
+@(objc_type=Number, objc_name="initWithU8")    Number_initWithU8   :: proc "c" (self: ^Number, value: u8)   -> ^Number { return msgSend(^Number, self, "initWithUnsignedChar:",     value) }
+@(objc_type=Number, objc_name="initWithI16")   Number_initWithI16  :: proc "c" (self: ^Number, value: i16)  -> ^Number { return msgSend(^Number, self, "initWithShort:",            value) }
+@(objc_type=Number, objc_name="initWithU16")   Number_initWithU16  :: proc "c" (self: ^Number, value: u16)  -> ^Number { return msgSend(^Number, self, "initWithUnsignedShort:",    value) }
+@(objc_type=Number, objc_name="initWithI32")   Number_initWithI32  :: proc "c" (self: ^Number, value: i32)  -> ^Number { return msgSend(^Number, self, "initWithInt:",              value) }
+@(objc_type=Number, objc_name="initWithU32")   Number_initWithU32  :: proc "c" (self: ^Number, value: u32)  -> ^Number { return msgSend(^Number, self, "initWithUnsignedInt:",      value) }
+@(objc_type=Number, objc_name="initWithInt")   Number_initWithInt  :: proc "c" (self: ^Number, value: int)  -> ^Number { return msgSend(^Number, self, "initWithLong:",             value) }
+@(objc_type=Number, objc_name="initWithUint")  Number_initWithUint :: proc "c" (self: ^Number, value: uint) -> ^Number { return msgSend(^Number, self, "initWithUnsignedLong:",     value) }
+@(objc_type=Number, objc_name="initWithU64")   Number_initWithU64  :: proc "c" (self: ^Number, value: u64)  -> ^Number { return msgSend(^Number, self, "initWithLongLong:",         value) }
+@(objc_type=Number, objc_name="initWithI64")   Number_initWithI64  :: proc "c" (self: ^Number, value: i64)  -> ^Number { return msgSend(^Number, self, "initWithUnsignedLongLong:", value) }
+@(objc_type=Number, objc_name="initWithF32")   Number_initWithF32  :: proc "c" (self: ^Number, value: f32)  -> ^Number { return msgSend(^Number, self, "initWithFloat:",            value) }
+@(objc_type=Number, objc_name="initWithF64")   Number_initWithF64  :: proc "c" (self: ^Number, value: f64)  -> ^Number { return msgSend(^Number, self, "initWithDouble:",           value) }
+@(objc_type=Number, objc_name="initWithBool")  Number_initWithBool :: proc "c" (self: ^Number, value: BOOL) -> ^Number { return msgSend(^Number, self, "initWithBool:",             value) }
 
 
-@(objc_type=Number, objc_name="i8Value")       Number_i8Value       :: proc(self: ^Number) -> i8          { return msgSend(i8,          self, "charValue")             }
-@(objc_type=Number, objc_name="u8Value")       Number_u8Value       :: proc(self: ^Number) -> u8          { return msgSend(u8,          self, "unsignedCharValue")     }
-@(objc_type=Number, objc_name="i16Value")      Number_i16Value      :: proc(self: ^Number) -> i16         { return msgSend(i16,         self, "shortValue")            }
-@(objc_type=Number, objc_name="u16Value")      Number_u16Value      :: proc(self: ^Number) -> u16         { return msgSend(u16,         self, "unsignedShortValue")    }
-@(objc_type=Number, objc_name="i32Value")      Number_i32Value      :: proc(self: ^Number) -> i32         { return msgSend(i32,         self, "intValue")              }
-@(objc_type=Number, objc_name="u32Value")      Number_u32Value      :: proc(self: ^Number) -> u32         { return msgSend(u32,         self, "unsignedIntValue")      }
-@(objc_type=Number, objc_name="intValue")      Number_intValue      :: proc(self: ^Number) -> int         { return msgSend(int,         self, "longValue")             }
-@(objc_type=Number, objc_name="uintValue")     Number_uintValue     :: proc(self: ^Number) -> uint        { return msgSend(uint,        self, "unsignedLongValue")     }
-@(objc_type=Number, objc_name="u64Value")      Number_u64Value      :: proc(self: ^Number) -> u64         { return msgSend(u64,         self, "longLongValue")         }
-@(objc_type=Number, objc_name="i64Value")      Number_i64Value      :: proc(self: ^Number) -> i64         { return msgSend(i64,         self, "unsignedLongLongValue") }
-@(objc_type=Number, objc_name="f32Value")      Number_f32Value      :: proc(self: ^Number) -> f32         { return msgSend(f32,         self, "floatValue")            }
-@(objc_type=Number, objc_name="f64Value")      Number_f64Value      :: proc(self: ^Number) -> f64         { return msgSend(f64,         self, "doubleValue")           }
-@(objc_type=Number, objc_name="boolValue")     Number_boolValue     :: proc(self: ^Number) -> BOOL        { return msgSend(BOOL,        self, "boolValue")             }
-@(objc_type=Number, objc_name="integerValue")  Number_integerValue  :: proc(self: ^Number) -> Integer     { return msgSend(Integer,     self, "integerValue")          }
-@(objc_type=Number, objc_name="uintegerValue") Number_uintegerValue :: proc(self: ^Number) -> UInteger    { return msgSend(UInteger,    self, "unsignedIntegerValue")  }
-@(objc_type=Number, objc_name="stringValue")   Number_stringValue   :: proc(self: ^Number) -> ^String     { return msgSend(^String,     self, "stringValue")           }
+@(objc_type=Number, objc_name="i8Value")       Number_i8Value       :: proc "c" (self: ^Number) -> i8          { return msgSend(i8,          self, "charValue")             }
+@(objc_type=Number, objc_name="u8Value")       Number_u8Value       :: proc "c" (self: ^Number) -> u8          { return msgSend(u8,          self, "unsignedCharValue")     }
+@(objc_type=Number, objc_name="i16Value")      Number_i16Value      :: proc "c" (self: ^Number) -> i16         { return msgSend(i16,         self, "shortValue")            }
+@(objc_type=Number, objc_name="u16Value")      Number_u16Value      :: proc "c" (self: ^Number) -> u16         { return msgSend(u16,         self, "unsignedShortValue")    }
+@(objc_type=Number, objc_name="i32Value")      Number_i32Value      :: proc "c" (self: ^Number) -> i32         { return msgSend(i32,         self, "intValue")              }
+@(objc_type=Number, objc_name="u32Value")      Number_u32Value      :: proc "c" (self: ^Number) -> u32         { return msgSend(u32,         self, "unsignedIntValue")      }
+@(objc_type=Number, objc_name="intValue")      Number_intValue      :: proc "c" (self: ^Number) -> int         { return msgSend(int,         self, "longValue")             }
+@(objc_type=Number, objc_name="uintValue")     Number_uintValue     :: proc "c" (self: ^Number) -> uint        { return msgSend(uint,        self, "unsignedLongValue")     }
+@(objc_type=Number, objc_name="u64Value")      Number_u64Value      :: proc "c" (self: ^Number) -> u64         { return msgSend(u64,         self, "longLongValue")         }
+@(objc_type=Number, objc_name="i64Value")      Number_i64Value      :: proc "c" (self: ^Number) -> i64         { return msgSend(i64,         self, "unsignedLongLongValue") }
+@(objc_type=Number, objc_name="f32Value")      Number_f32Value      :: proc "c" (self: ^Number) -> f32         { return msgSend(f32,         self, "floatValue")            }
+@(objc_type=Number, objc_name="f64Value")      Number_f64Value      :: proc "c" (self: ^Number) -> f64         { return msgSend(f64,         self, "doubleValue")           }
+@(objc_type=Number, objc_name="boolValue")     Number_boolValue     :: proc "c" (self: ^Number) -> BOOL        { return msgSend(BOOL,        self, "boolValue")             }
+@(objc_type=Number, objc_name="integerValue")  Number_integerValue  :: proc "c" (self: ^Number) -> Integer     { return msgSend(Integer,     self, "integerValue")          }
+@(objc_type=Number, objc_name="uintegerValue") Number_uintegerValue :: proc "c" (self: ^Number) -> UInteger    { return msgSend(UInteger,    self, "unsignedIntegerValue")  }
+@(objc_type=Number, objc_name="stringValue")   Number_stringValue   :: proc "c" (self: ^Number) -> ^String     { return msgSend(^String,     self, "stringValue")           }
 
 @(objc_type=Number, objc_name="compare")
-Number_compare :: proc(self, other: ^Number) -> ComparisonResult {
+Number_compare :: proc "c" (self, other: ^Number) -> ComparisonResult {
 	return msgSend(ComparisonResult, self, "compare:", other)
 }
 
 @(objc_type=Number, objc_name="isEqualToNumber")
-Number_isEqualToNumber :: proc(self, other: ^Number) -> BOOL {
+Number_isEqualToNumber :: proc "c" (self, other: ^Number) -> BOOL {
 	return msgSend(BOOL, self, "isEqualToNumber:", other)
 }
 
 @(objc_type=Number, objc_name="descriptionWithLocale")
-Number_descriptionWithLocale :: proc(self: ^Number, locale: ^Object) -> ^String {
+Number_descriptionWithLocale :: proc "c" (self: ^Number, locale: ^Object) -> ^String {
 	return msgSend(^String, self, "descriptionWithLocale:", locale)
 }

vendor/darwin/Foundation/NSObject.odin

@@ -21,67 +21,67 @@ Object :: struct {using _: intrinsics.objc_object}
 @(objc_class="NSObject")
 Copying :: struct($T: typeid) {using _: Object}
 
-alloc :: proc($T: typeid) -> ^T where intrinsics.type_is_subtype_of(T, Object) {
+alloc :: proc "c" ($T: typeid) -> ^T where intrinsics.type_is_subtype_of(T, Object) {
 	return msgSend(^T, T, "alloc")
 }
 @(objc_type=Object, objc_name="init")
-init :: proc(self: ^$T) -> ^T where intrinsics.type_is_subtype_of(T, Object) {
+init :: proc "c" (self: ^$T) -> ^T where intrinsics.type_is_subtype_of(T, Object) {
 	return msgSend(^T, self, "init")
 }
 @(objc_type=Object, objc_name="copy")
-copy :: proc(self: ^Copying($T)) -> ^T where intrinsics.type_is_subtype_of(T, Object) {
+copy :: proc "c" (self: ^Copying($T)) -> ^T where intrinsics.type_is_subtype_of(T, Object) {
 	return msgSend(^T, self, "copy")
 }
 
-new :: proc($T: typeid) -> ^T where intrinsics.type_is_subtype_of(T, Object) {
+new :: proc "c" ($T: typeid) -> ^T where intrinsics.type_is_subtype_of(T, Object) {
 	return init(alloc(T))
 }
 
 @(objc_type=Object, objc_name="retain")
-retain :: proc(self: ^Object) {
+retain :: proc "c" (self: ^Object) {
 	_ = msgSend(^Object, self, "retain")
 }
 @(objc_type=Object, objc_name="release")
-release :: proc(self: ^Object) {
+release :: proc "c" (self: ^Object) {
 	msgSend(nil, self, "release")
 }
 @(objc_type=Object, objc_name="autorelease")
-autorelease :: proc(self: ^Object) {
+autorelease :: proc "c" (self: ^Object) {
 	msgSend(nil, self, "autorelease")
 }
 @(objc_type=Object, objc_name="retainCount")
-retainCount :: proc(self: ^Object) -> UInteger {
+retainCount :: proc "c" (self: ^Object) -> UInteger {
 	return msgSend(UInteger, self, "retainCount")
 }
 @(objc_type=Object, objc_name="class")
-class :: proc(self: ^Object) -> Class {
+class :: proc "c" (self: ^Object) -> Class {
 	return msgSend(Class, self, "class")
 }
 
 @(objc_type=Object, objc_name="hash")
-hash :: proc(self: ^Object) -> UInteger {
+hash :: proc "c" (self: ^Object) -> UInteger {
 	return msgSend(UInteger, self, "hash")
 }
 
 @(objc_type=Object, objc_name="isEqual")
-isEqual :: proc(self, pObject: ^Object) -> BOOL {
+isEqual :: proc "c" (self, pObject: ^Object) -> BOOL {
 	return msgSend(BOOL, self, "isEqual:", pObject)
 }
 
 @(objc_type=Object, objc_name="description")
-description :: proc(self: ^Object) -> ^String {
+description :: proc "c" (self: ^Object) -> ^String {
 	return msgSend(^String, self, "description")
 }
 
 @(objc_type=Object, objc_name="debugDescription")
-debugDescription :: proc(self: ^Object) -> ^String {
+debugDescription :: proc "c" (self: ^Object) -> ^String {
 	if msgSendSafeCheck(self, intrinsics.objc_find_selector("debugDescription")) {
 		return msgSend(^String, self, "debugDescription")
 	}
 	return nil
 }
 
-bridgingCast :: proc($T: typeid, obj: ^Object) where intrinsics.type_is_pointer(T), intrinsics.type_is_subtype_of(T, ^Object) {
+bridgingCast :: proc "c" ($T: typeid, obj: ^Object) where intrinsics.type_is_pointer(T), intrinsics.type_is_subtype_of(T, ^Object) {
 	return (T)(obj)
 }
 

vendor/darwin/Foundation/NSOpenPanel.odin

@@ -0,0 +1,31 @@
+package objc_Foundation
+
+@(objc_class="NSOpenPanel")
+OpenPanel :: struct{ using _: SavePanel }
+
+@(objc_type=OpenPanel, objc_name="openPanel", objc_is_class_method=true)
+OpenPanel_openPanel :: proc "c" () -> ^OpenPanel {
+	return msgSend(^OpenPanel, OpenPanel, "openPanel")
+}
+
+@(objc_type=OpenPanel, objc_name="URLs")
+OpenPanel_URLs :: proc "c" (self: ^OpenPanel) -> ^Array {
+	return msgSend(^Array, self, "URLs")
+}
+
+@(objc_type=OpenPanel, objc_name="setCanChooseFiles")
+OpenPanel_setCanChooseFiles :: proc "c" (self: ^OpenPanel, setting: BOOL) {
+	msgSend(nil, self, "setCanChooseFiles:", setting)
+}
+@(objc_type=OpenPanel, objc_name="setCanChooseDirectories")
+OpenPanel_setCanChooseDirectories :: proc "c" (self: ^OpenPanel, setting: BOOL) {
+	msgSend(nil, self, "setCanChooseDirectories:", setting)
+}
+@(objc_type=OpenPanel, objc_name="setResolvesAliases")
+OpenPanel_setResolvesAliases :: proc "c" (self: ^OpenPanel, setting: BOOL) {
+	msgSend(nil, self, "setResolvesAliases:", setting)
+}
+@(objc_type=OpenPanel, objc_name="setAllowsMultipleSelection")
+OpenPanel_setAllowsMultipleSelection :: proc "c" (self: ^OpenPanel, setting: BOOL) {
+	msgSend(nil, self, "setAllowsMultipleSelection:", setting)
+}

vendor/darwin/Foundation/NSPanel.odin

@@ -0,0 +1,9 @@
+package objc_Foundation
+
+ModalResponse :: enum UInteger {
+	Cancel = 0,
+	OK = 1,
+}
+
+@(objc_class="NSPanel")
+Panel :: struct{ using _: Window }

vendor/darwin/Foundation/NSPasteboard.odin

@@ -0,0 +1,5 @@
+package objc_Foundation
+
+@(objc_class="NSPasteboard")
+Pasteboard :: struct {using _: Object}
+// TODO: implement NSPasteboard

vendor/darwin/Foundation/NSRange.odin

@@ -5,18 +5,18 @@ Range :: struct {
 	length:  UInteger,
 }
 
-Range_Make :: proc(loc, len: UInteger) -> Range {
+Range_Make :: proc "c" (loc, len: UInteger) -> Range {
 	return Range{loc, len}
 }
 
-Range_Equal :: proc(a, b: Range) -> BOOL {
+Range_Equal :: proc "c" (a, b: Range) -> BOOL {
 	return a == b
 }
 
-Range_LocationInRange :: proc(self: Range, loc: UInteger) -> BOOL {
+Range_LocationInRange :: proc "c" (self: Range, loc: UInteger) -> BOOL {
 	return !((loc < self.location) && ((loc - self.location) < self.length))
 }
 
-Range_Max :: proc(self: Range) -> UInteger {
+Range_Max :: proc "c" (self: Range) -> UInteger {
 	return self.location + self.length
 }

vendor/darwin/Foundation/NSSavePanel.odin

@@ -0,0 +1,9 @@
+package objc_Foundation
+
+@(objc_class="NSSavePanel")
+SavePanel :: struct{ using _: Panel }
+
+@(objc_type=SavePanel, objc_name="runModal")
+SavePanel_runModal :: proc "c" (self: ^SavePanel) -> ModalResponse {
+	return msgSend(ModalResponse, self, "runModal")
+}

vendor/darwin/Foundation/NSScreen.odin

@@ -0,0 +1,5 @@
+package objc_Foundation
+
+@(objc_class="NSScreen")
+Screen :: struct {using _: Object}
+// TODO: implement NSScreen

vendor/darwin/Foundation/NSString.odin

@@ -64,77 +64,77 @@ MakeConstantString :: proc "c" (#const c: cstring) -> ^String {
 
 
 @(objc_type=String, objc_name="alloc", objc_is_class_method=true)
-String_alloc :: proc() -> ^String {
+String_alloc :: proc "c" () -> ^String {
 	return msgSend(^String, String, "alloc")
 }
 
 @(objc_type=String, objc_name="init")
-String_init :: proc(self: ^String) -> ^String {
+String_init :: proc "c" (self: ^String) -> ^String {
 	return msgSend(^String, self, "init")
 }
 
 
 @(objc_type=String, objc_name="initWithString")
-String_initWithString :: proc(self: ^String, other: ^String) -> ^String {
+String_initWithString :: proc "c" (self: ^String, other: ^String) -> ^String {
 	return msgSend(^String, self, "initWithString:", other)
 }
 
 @(objc_type=String, objc_name="initWithCString")
-String_initWithCString :: proc(self: ^String, pString: cstring, encoding: StringEncoding) -> ^String {
+String_initWithCString :: proc "c" (self: ^String, pString: cstring, encoding: StringEncoding) -> ^String {
 	return msgSend(^String, self, "initWithCstring:encoding:", pString, encoding)
 }
 
 @(objc_type=String, objc_name="initWithBytesNoCopy")
-String_initWithBytesNoCopy :: proc(self: ^String, pBytes: rawptr, length: UInteger, encoding: StringEncoding, freeWhenDone: bool) -> ^String {
+String_initWithBytesNoCopy :: proc "c" (self: ^String, pBytes: rawptr, length: UInteger, encoding: StringEncoding, freeWhenDone: bool) -> ^String {
 	return msgSend(^String, self, "initWithBytesNoCopy:length:encoding:freeWhenDone:", pBytes, length, encoding, freeWhenDone)
 }
 
 @(objc_type=String, objc_name="initWithOdinString")
-String_initWithOdinString :: proc(self: ^String, str: string) -> ^String {
+String_initWithOdinString :: proc "c" (self: ^String, str: string) -> ^String {
 	return String_initWithBytesNoCopy(self, raw_data(str), UInteger(len(str)), .UTF8, false)
 }
 
 @(objc_type=String, objc_name="characterAtIndex")
-String_characterAtIndex :: proc(self: ^String, index: UInteger) -> unichar {
+String_characterAtIndex :: proc "c" (self: ^String, index: UInteger) -> unichar {
 	return msgSend(unichar, self, "characterAtIndex:", index)
 }
 
 @(objc_type=String, objc_name="length")
-String_length :: proc(self: ^String) -> UInteger {
+String_length :: proc "c" (self: ^String) -> UInteger {
 	return msgSend(UInteger, self, "length")
 }
 
 @(objc_type=String, objc_name="cstringUsingEncoding")
-String_cstringUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> cstring {
+String_cstringUsingEncoding :: proc "c" (self: ^String, encoding: StringEncoding) -> cstring {
 	return msgSend(cstring, self, "cStringUsingEncoding:", encoding)
 }
 
 @(objc_type=String, objc_name="UTF8String")
-String_UTF8String :: proc(self: ^String) -> cstring {
+String_UTF8String :: proc "c" (self: ^String) -> cstring {
 	return msgSend(cstring, self, "UTF8String")
 }
 
 @(objc_type=String, objc_name="odinString")
-String_odinString :: proc(self: ^String) -> string {
+String_odinString :: proc "c" (self: ^String) -> string {
 	return string(String_UTF8String(self))
 }
 
 @(objc_type=String, objc_name="maximumLengthOfBytesUsingEncoding")
-String_maximumLengthOfBytesUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> UInteger {
+String_maximumLengthOfBytesUsingEncoding :: proc "c" (self: ^String, encoding: StringEncoding) -> UInteger {
 	return msgSend(UInteger, self, "maximumLengthOfBytesUsingEncoding:", encoding)
 }
 
 @(objc_type=String, objc_name="lengthOfBytesUsingEncoding")
-String_lengthOfBytesUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> UInteger {
+String_lengthOfBytesUsingEncoding :: proc "c" (self: ^String, encoding: StringEncoding) -> UInteger {
 	return msgSend(UInteger, self, "lengthOfBytesUsingEncoding:", encoding)
 }
 
 @(objc_type=String, objc_name="isEqualToString")
-String_isEqualToString :: proc(self, other: ^String) -> BOOL {
+String_isEqualToString :: proc "c" (self, other: ^String) -> BOOL {
 	return msgSend(BOOL, self, "isEqualToString:", other)
 }
 
 @(objc_type=String, objc_name="rangeOfString")
-String_rangeOfString :: proc(self, other: ^String, options: StringCompareOptions) -> Range {
+String_rangeOfString :: proc "c" (self, other: ^String, options: StringCompareOptions) -> Range {
 	return msgSend(Range, self, "rangeOfString:options:", other, options)
 }

vendor/darwin/Foundation/NSTypes.odin

@@ -45,3 +45,17 @@ Size :: struct {
 	width:  Float,
 	height: Float,
 }
+
+when size_of(UInteger) == 8 {
+	_UINTEGER_ENCODING :: "Q"
+} else {
+	_UINTEGER_ENCODING :: "I"
+}
+
+when size_of(Float) == 8 {
+	_POINT_ENCODING :: "{CGPoint=dd}"
+	_SIZE_ENCODING :: "{CGSize=dd}"
+} else {
+	_POINT_ENCODING :: "{NSPoint=ff}"
+	_SIZE_ENCODING :: "{NSSize=ff}"
+}

vendor/darwin/Foundation/NSURL.odin

@@ -5,26 +5,26 @@ URL :: struct{using _: Copying(URL)}
 
 
 @(objc_type=URL, objc_name="alloc", objc_is_class_method=true)
-URL_alloc :: proc() -> ^URL {
+URL_alloc :: proc "c" () -> ^URL {
 	return msgSend(^URL, URL, "alloc")
 }
 
 @(objc_type=URL, objc_name="init")
-URL_init :: proc(self: ^URL) -> ^URL {
+URL_init :: proc "c" (self: ^URL) -> ^URL {
 	return msgSend(^URL, self, "init")
 }
 
 @(objc_type=URL, objc_name="initWithString")
-URL_initWithString :: proc(self: ^URL, value: ^String) -> ^URL {
+URL_initWithString :: proc "c" (self: ^URL, value: ^String) -> ^URL {
 	return msgSend(^URL, self, "initWithString:", value)
 }
 
 @(objc_type=URL, objc_name="initFileURLWithPath")
-URL_initFileURLWithPath :: proc(self: ^URL, path: ^String) -> ^URL {
+URL_initFileURLWithPath :: proc "c" (self: ^URL, path: ^String) -> ^URL {
 	return msgSend(^URL, self, "initFileURLWithPath:", path)
 }
 
 @(objc_type=URL, objc_name="fileSystemRepresentation")
-URL_fileSystemRepresentation :: proc(self: ^URL) -> ^String {
-	return msgSend(^String, self, "fileSystemRepresentation")
-}
+URL_fileSystemRepresentation :: proc "c" (self: ^URL) -> cstring {
+	return msgSend(cstring, self, "fileSystemRepresentation")
+}

vendor/darwin/Foundation/NSUndoManager.odin

@@ -0,0 +1,5 @@
+package objc_Foundation
+
+@(objc_class="NSUndoManager")
+UndoManager :: struct {using _: Object}
+// TODO: implement NSUndoManager

vendor/darwin/Foundation/NSUserActivity.odin

@@ -0,0 +1,5 @@
+package objc_Foundation
+
+@(objc_class="NSUserActivity")
+UserActivity :: struct {using _: Object}
+// TODO: implement NSUserActivity

vendor/darwin/Foundation/NSUserDefaults.odin

@@ -0,0 +1,14 @@
+package objc_Foundation
+
+@(objc_class="NSUserDefaults")
+UserDefaults :: struct { using _: Object }
+
+@(objc_type=UserDefaults, objc_name="standardUserDefaults", objc_is_class_method=true)
+UserDefaults_standardUserDefaults :: proc "c" () -> ^UserDefaults {
+	return msgSend(^UserDefaults, UserDefaults, "standardUserDefaults")
+}
+
+@(objc_type=UserDefaults, objc_name="setBoolForKey")
+UserDefaults_setBoolForKey :: proc "c" (self: ^UserDefaults, value: BOOL, name: ^String) {
+	msgSend(nil, self, "setBool:forKey:", value, name)
+}

vendor/darwin/Foundation/NSWindow.odin

@@ -1,5 +1,8 @@
 package objc_Foundation
 
+import "core:strings"
+import "core:runtime"
+import "core:intrinsics"
 import NS "vendor:darwin/Foundation"
 
 Rect :: struct {
@@ -7,6 +10,12 @@ Rect :: struct {
 	using size: Size,
 }
 
+when size_of(Float) == 8 {
+	_RECT_ENCODING :: "{CGRect="+_POINT_ENCODING+_SIZE_ENCODING+"}"
+} else {
+	_RECT_ENCODING :: "{NSRect="+_POINT_ENCODING+_SIZE_ENCODING+"}"
+}
+
 WindowStyleFlag :: enum NS.UInteger {
 	Titled                 = 0,
 	Closable               = 1,
@@ -42,6 +51,510 @@ BackingStoreType :: enum NS.UInteger {
 	Buffered    = 2,
 }
 
+WindowDelegateTemplate :: struct {
+	// Managing Sheets
+	windowWillPositionSheetUsingRect:                                    proc(window: ^Window, sheet: ^Window, rect: Rect) -> Rect,
+	windowWillBeginSheet:                                                proc(notification: ^Notification),
+	windowDidEndSheet:                                                   proc(notification: ^Notification),
+	// Sizing Windows
+	windowWillResizeToSize:                                              proc(sender: ^Window, frameSize: Size) -> Size,
+	windowDidResize:                                                     proc(notification: ^Notification),
+	windowWillStartLiveResize:                                           proc(noitifcation: ^Notification),
+	windowDidEndLiveResize:                                              proc(notification: ^Notification),
+	// Minimizing Windows
+	windowWillMiniaturize:                                               proc(notification: ^Notification),
+	windowDidMiniaturize:                                                proc(notification: ^Notification),
+	windowDidDeminiaturize:                                              proc(notification: ^Notification),
+	// Zooming window
+	windowWillUseStandardFrameDefaultFrame:                              proc(window: ^Window, newFrame: Rect) -> Rect,
+	windowShouldZoomToFrame:                                             proc(window: ^Window, newFrame: Rect) -> BOOL,
+	// Managing Full-Screen Presentation
+	windowWillUseFullScreenContentSize:                                  proc(window: ^Window, proposedSize: Size) -> Size,
+	windowWillUseFullScreenPresentationOptions:                          proc(window: ^Window, proposedOptions: ApplicationPresentationOptions) -> ApplicationPresentationOptions,
+	windowWillEnterFullScreen:                                           proc(notification: ^Notification),
+	windowDidEnterFullScreen:                                            proc(notification: ^Notification),
+	windowWillExitFullScreen:                                            proc(notification: ^Notification),
+	windowDidExitFullScreen:                                             proc(notification: ^Notification),
+	// Custom Full-Screen Presentation Animations
+	customWindowsToEnterFullScreenForWindow:                             proc(window: ^Window) -> ^Array,
+	customWindowsToEnterFullScreenForWindowOnScreen:                     proc(window: ^Window, screen: ^Screen) -> ^Array,
+	windowStartCustomAnimationToEnterFullScreenWithDuration:             proc(window: ^Window, duration: TimeInterval),
+	windowStartCustomAnimationToEnterFullScreenOnScreenWithDuration:     proc(window: ^Window, screen: ^Screen, duration: TimeInterval),
+	windowDidFailToEnterFullScreen:                                      proc(window: ^Window),
+	customWindowsToExitFullScreenForWindow:                              proc(window: ^Window) -> ^Array,
+	windowStartCustomAnimationToExitFullScreenWithDuration:              proc(window: ^Window, duration: TimeInterval),
+	windowDidFailToExitFullScreen:                                       proc(window: ^Window),
+	// Moving Windows
+	windowWillMove:                                                      proc(notification: ^Notification),
+	windowDidMove:                                                       proc(notification: ^Notification),
+	windowDidChangeScreen:                                               proc(notification: ^Notification),
+	windowDidChangeScreenProfile:                                        proc(notification: ^Notification),
+	windowDidChangeBackingProperties:                                    proc(notification: ^Notification),
+	// Closing Windows
+	windowShouldClose:                                                   proc(sender: ^Window) -> BOOL,
+	windowWillClose:                                                     proc(notification: ^Notification),
+	// Managing Key Status
+	windowDidBecomeKey:                                                  proc(notification: ^Notification),
+	windowDidResignKey:                                                  proc(notification: ^Notification),
+	// Managing Main Status
+	windowDidBecomeMain:                                                 proc(notification: ^Notification),
+	windowDidResignMain:                                                 proc(notification: ^Notification),
+	// Managing Field Editors
+	windowWillReturnFieldEditorToObject:                                 proc(sender: ^Window, client: id) -> id,
+	// Updating Windows
+	windowDidUpdate:                                                     proc (notification: ^Notification),
+	// Exposing Windows
+	windowDidExpose:                                                     proc (notification: ^Notification),
+	// Managing Occlusion State
+	windowDidChangeOcclusionState:                                       proc(notification: ^Notification),
+	// Dragging Windows
+	windowShouldDragDocumentWithEventFromWithPasteboard:                 proc(window: ^Window, event: ^Event, dragImageLocation: Point, pasteboard: ^Pasteboard) -> BOOL,
+	// Getting the Undo Manager
+	windowWillReturnUndoManager:                                         proc(window: ^Window) -> ^UndoManager,
+	// Managing Titles
+	windowShouldPopUpDocumentPathMenu:                                   proc(window: ^Window, menu: ^Menu) -> BOOL,
+	// Managing Restorable State
+	windowWillEncodeRestorableState:                                     proc(window: ^Window, state: ^Coder),
+	windowDidEncodeRestorableState:                                      proc(window: ^Window, state: ^Coder),
+	// Managing Presentation in Version Browsers
+	windowWillResizeForVersionBrowserWithMaxPreferredSizeMaxAllowedSize: proc(window: ^Window, maxPreferredFrameSize: Size, maxAllowedFrameSize: Size) -> Size,
+	windowWillEnterVersionBrowser:                                       proc(notification: ^Notification),
+	windowDidEnterVersionBrowser:                                        proc(notification: ^Notification),
+	windowWillExitVersionBrowser:                                        proc(notification: ^Notification),
+	windowDidExitVersionBrowser:                                         proc(notification: ^Notification),
+}
+
+WindowDelegate :: struct { using _: Object }
+_WindowDelegateInternal :: struct {
+	using _: WindowDelegateTemplate,
+	_context: runtime.Context,
+}
+
+window_delegate_register_and_alloc :: proc(template: WindowDelegateTemplate, class_name: string, delegate_context: Maybe(runtime.Context)) -> ^WindowDelegate {
+	class := objc_allocateClassPair(intrinsics.objc_find_class("NSObject"), strings.clone_to_cstring(class_name, context.temp_allocator), 0); if class == nil {
+		// Class already registered
+		return nil
+	}
+	if template.windowWillPositionSheetUsingRect != nil {
+		windowWillPositionSheetUsingRect :: proc "c" (self: id, window: ^Window, sheet: ^Window, rect: Rect) -> Rect {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.windowWillPositionSheetUsingRect(window, sheet, rect)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("window:willPositionSheet:usingRect:"), auto_cast windowWillPositionSheetUsingRect, _RECT_ENCODING+"@:@@"+_RECT_ENCODING)
+	}
+	if template.windowWillBeginSheet != nil {
+		windowWillBeginSheet :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowWillBeginSheet(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowWillBeginSheet:"), auto_cast windowWillBeginSheet, "v@:@")
+	}
+	if template.windowDidEndSheet != nil {
+		windowDidEndSheet :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidEndSheet(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidEndSheet:"), auto_cast windowDidEndSheet, "v@:@")
+	}
+	if template.windowWillResizeToSize != nil {
+		windowWillResizeToSize :: proc "c" (self: id, sender: ^Window, frameSize: Size) -> Size {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.windowWillResizeToSize(sender, frameSize)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowWillResize:toSize:"), auto_cast windowWillResizeToSize, _SIZE_ENCODING+"@:@"+_SIZE_ENCODING)
+	}
+	if template.windowDidResize != nil {
+		windowDidResize :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidResize(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidResize:"), auto_cast windowDidResize, "v@:@")
+	}
+	if template.windowWillStartLiveResize != nil {
+		windowWillStartLiveResize :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowWillStartLiveResize(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowWillStartLiveResize:"), auto_cast windowWillStartLiveResize, "v@:@")
+	}
+	if template.windowDidEndLiveResize != nil {
+		windowDidEndLiveResize :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidEndLiveResize(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidEndLiveResize:"), auto_cast windowDidEndLiveResize, "v@:@")
+	}
+	if template.windowWillMiniaturize != nil {
+		windowWillMiniaturize :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowWillMiniaturize(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowWillMiniaturize:"), auto_cast windowWillMiniaturize, "v@:@")
+	}
+	if template.windowDidMiniaturize != nil {
+		windowDidMiniaturize :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidMiniaturize(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidMiniaturize:"), auto_cast windowDidMiniaturize, "v@:@")
+	}
+	if template.windowDidDeminiaturize != nil {
+		windowDidDeminiaturize :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidDeminiaturize(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidDeminiaturize:"), auto_cast windowDidDeminiaturize, "v@:@")
+	}
+	if template.windowWillUseStandardFrameDefaultFrame != nil {
+		windowWillUseStandardFrameDefaultFrame :: proc(self: id, window: ^Window, newFrame: Rect) -> Rect {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.windowWillUseStandardFrameDefaultFrame(window, newFrame)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowWillUseStandardFrame:defaultFrame:"), auto_cast windowWillUseStandardFrameDefaultFrame, _RECT_ENCODING+"@:@"+_RECT_ENCODING)
+	}
+	if template.windowShouldZoomToFrame != nil {
+		windowShouldZoomToFrame :: proc "c" (self: id, window: ^Window, newFrame: Rect) -> BOOL {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.windowShouldZoomToFrame(window, newFrame)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowShouldZoom:toFrame:"), auto_cast windowShouldZoomToFrame, "B@:@"+_RECT_ENCODING)
+	}
+	if template.windowWillUseFullScreenContentSize != nil {
+		windowWillUseFullScreenContentSize :: proc "c" (self: id, window: ^Window, proposedSize: Size) -> Size {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.windowWillUseFullScreenContentSize(window, proposedSize)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("window:willUseFullScreenContentSize:"), auto_cast windowWillUseFullScreenContentSize, _SIZE_ENCODING+"@:@"+_SIZE_ENCODING)
+	}
+	if template.windowWillUseFullScreenPresentationOptions != nil {
+		windowWillUseFullScreenPresentationOptions :: proc(self: id, window: ^Window, proposedOptions: ApplicationPresentationOptions) -> ApplicationPresentationOptions {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.windowWillUseFullScreenPresentationOptions(window, proposedOptions)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("window:willUseFullScreenPresentationOptions:"), auto_cast windowWillUseFullScreenPresentationOptions, _UINTEGER_ENCODING+"@:@"+_UINTEGER_ENCODING)
+	}
+	if template.windowWillEnterFullScreen != nil {
+		windowWillEnterFullScreen :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowWillEnterFullScreen(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowWillEnterFullScreen:"), auto_cast windowWillEnterFullScreen, "v@:@")
+	}
+	if template.windowDidEnterFullScreen != nil {
+		windowDidEnterFullScreen :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidEnterFullScreen(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidEnterFullScreen:"), auto_cast windowDidEnterFullScreen, "v@:@")
+	}
+	if template.windowWillExitFullScreen != nil {
+		windowWillExitFullScreen :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowWillExitFullScreen(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowWillExitFullScreen:"), auto_cast windowWillExitFullScreen, "v@:@")
+	}
+	if template.windowDidExitFullScreen != nil {
+		windowDidExitFullScreen :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidExitFullScreen(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidExitFullScreen:"), auto_cast windowDidExitFullScreen, "v@:@")
+	}
+	if template.customWindowsToEnterFullScreenForWindow != nil {
+		customWindowsToEnterFullScreenForWindow :: proc "c" (self: id, window: ^Window) -> ^Array {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.customWindowsToEnterFullScreenForWindow(window)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("customWindowsToEnterFullScreenForWindow:"), auto_cast customWindowsToEnterFullScreenForWindow, "@@:@")
+	}
+	if template.customWindowsToEnterFullScreenForWindowOnScreen != nil {
+		customWindowsToEnterFullScreenForWindowOnScreen :: proc(self: id, window: ^Window, screen: ^Screen) -> ^Array {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.customWindowsToEnterFullScreenForWindowOnScreen(window, screen)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("customWindowsToEnterFullScreenForWindow:onScreen:"), auto_cast customWindowsToEnterFullScreenForWindowOnScreen, "@@:@@")
+	}
+	if template.windowStartCustomAnimationToEnterFullScreenWithDuration != nil {
+		windowStartCustomAnimationToEnterFullScreenWithDuration :: proc "c" (self: id, window: ^Window, duration: TimeInterval) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowStartCustomAnimationToEnterFullScreenWithDuration(window, duration)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("window:startCustomAnimationToEnterFullScreenWithDuration:"), auto_cast windowStartCustomAnimationToEnterFullScreenWithDuration, "v@:@@")
+	}
+	if template.windowStartCustomAnimationToEnterFullScreenOnScreenWithDuration != nil {
+		windowStartCustomAnimationToEnterFullScreenOnScreenWithDuration :: proc(self: id, window: ^Window, screen: ^Screen, duration: TimeInterval) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowStartCustomAnimationToEnterFullScreenOnScreenWithDuration(window, screen, duration)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("window:startCustomAnimationToEnterFullScreenOnScreen:withDuration:"), auto_cast windowStartCustomAnimationToEnterFullScreenOnScreenWithDuration, "v@:@@d")
+	}
+	if template.windowDidFailToEnterFullScreen != nil {
+		windowDidFailToEnterFullScreen :: proc "c" (self: id, window: ^Window) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidFailToEnterFullScreen(window)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidFailToEnterFullScreen:"), auto_cast windowDidFailToEnterFullScreen, "v@:@")
+	}
+	if template.customWindowsToExitFullScreenForWindow != nil {
+		customWindowsToExitFullScreenForWindow :: proc "c" (self: id, window: ^Window) -> ^Array {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.customWindowsToExitFullScreenForWindow(window)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("customWindowsToExitFullScreenForWindow:"), auto_cast customWindowsToExitFullScreenForWindow, "@@:@")
+	}
+	if template.windowStartCustomAnimationToExitFullScreenWithDuration != nil {
+		windowStartCustomAnimationToExitFullScreenWithDuration :: proc "c" (self: id, window: ^Window, duration: TimeInterval) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowStartCustomAnimationToExitFullScreenWithDuration(window, duration)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("window:startCustomAnimationToExitFullScreenWithDuration:"), auto_cast windowStartCustomAnimationToExitFullScreenWithDuration, "v@:@d")
+	}
+	if template.windowDidFailToExitFullScreen != nil {
+		windowDidFailToExitFullScreen :: proc "c" (self: id, window: ^Window) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidFailToExitFullScreen(window)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidFailToExitFullScreen:"), auto_cast windowDidFailToExitFullScreen, "v@:@")
+	}
+	if template.windowWillMove != nil {
+		windowWillMove :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowWillMove(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowWillMove:"), auto_cast windowWillMove, "v@:@")
+	}
+	if template.windowDidMove != nil {
+		windowDidMove :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidMove(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidMove:"), auto_cast windowDidMove, "v@:@")
+	}
+	if template.windowDidChangeScreen != nil {
+		windowDidChangeScreen :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidChangeScreen(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidChangeScreen:"), auto_cast windowDidChangeScreen, "v@:@")
+	}
+	if template.windowDidChangeScreenProfile != nil {
+		windowDidChangeScreenProfile :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidChangeScreenProfile(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidChangeScreenProfile:"), auto_cast windowDidChangeScreenProfile, "v@:@")
+	}
+	if template.windowDidChangeBackingProperties != nil {
+		windowDidChangeBackingProperties :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidChangeBackingProperties(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidChangeBackingProperties:"), auto_cast windowDidChangeBackingProperties, "v@:@")
+	}
+	if template.windowShouldClose != nil {
+		windowShouldClose :: proc "c" (self:id, sender: ^Window) -> BOOL {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.windowShouldClose(sender)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowShouldClose:"), auto_cast windowShouldClose, "B@:@")
+	}
+	if template.windowWillClose != nil {
+		windowWillClose :: proc "c" (self:id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowWillClose(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowWillClose:"), auto_cast windowWillClose, "v@:@")
+	}
+	if template.windowDidBecomeKey != nil {
+		windowDidBecomeKey :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidBecomeKey(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidBecomeKey:"), auto_cast windowDidBecomeKey, "v@:@")
+	}
+	if template.windowDidResignKey != nil {
+		windowDidResignKey :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidResignKey(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidResignKey:"), auto_cast windowDidResignKey, "v@:@")
+	}
+	if template.windowDidBecomeMain != nil {
+		windowDidBecomeMain :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidBecomeMain(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidBecomeMain:"), auto_cast windowDidBecomeMain, "v@:@")
+	}
+	if template.windowDidResignMain != nil {
+		windowDidResignMain :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidResignMain(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidResignMain:"), auto_cast windowDidResignMain, "v@:@")
+	}
+	if template.windowWillReturnFieldEditorToObject != nil {
+		windowWillReturnFieldEditorToObject :: proc "c" (self:id, sender: ^Window, client: id) -> id {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.windowWillReturnFieldEditorToObject(sender, client)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowWillReturnFieldEditor:toObject:"), auto_cast windowWillReturnFieldEditorToObject, "@@:@@")
+	}
+	if template.windowDidUpdate != nil {
+		windowDidUpdate :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidUpdate(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidUpdate:"), auto_cast windowDidUpdate, "v@:@")
+	}
+	if template.windowDidExpose != nil {
+		windowDidExpose :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidExpose(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidExpose:"), auto_cast windowDidExpose, "v@:@")
+	}
+	if template.windowDidChangeOcclusionState != nil {
+		windowDidChangeOcclusionState :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidChangeOcclusionState(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidChangeOcclusionState:"), auto_cast windowDidChangeOcclusionState, "v@:@")
+	}
+	if template.windowShouldDragDocumentWithEventFromWithPasteboard != nil {
+		windowShouldDragDocumentWithEventFromWithPasteboard :: proc "c" (self: id, window: ^Window, event: ^Event, dragImageLocation: Point, pasteboard: ^Pasteboard) -> BOOL {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.windowShouldDragDocumentWithEventFromWithPasteboard(window, event, dragImageLocation, pasteboard)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("window:shouldDragDocumentWithEvent:from:withPasteboard:"), auto_cast windowShouldDragDocumentWithEventFromWithPasteboard, "B@:@@"+_POINT_ENCODING+"@")
+	}
+	if template.windowWillReturnUndoManager != nil {
+		windowWillReturnUndoManager :: proc "c" (self: id, window: ^Window) -> ^UndoManager {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.windowWillReturnUndoManager(window)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowWillReturnUndoManager:"), auto_cast windowWillReturnUndoManager, "@@:@")
+	}
+	if template.windowShouldPopUpDocumentPathMenu != nil {
+		windowShouldPopUpDocumentPathMenu :: proc "c" (self: id, window: ^Window, menu: ^Menu) -> BOOL {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.windowShouldPopUpDocumentPathMenu(window, menu)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("window:shouldPopUpDocumentPathMenu:"), auto_cast windowShouldPopUpDocumentPathMenu, "B@:@@")
+	}
+	if template.windowWillEncodeRestorableState != nil {
+		windowWillEncodeRestorableState :: proc "c" (self: id, window: ^Window, state: ^Coder) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowWillEncodeRestorableState(window, state)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("window:willEncodeRestorableState:"), auto_cast windowWillEncodeRestorableState, "v@:@@")
+	}
+	if template.windowDidEncodeRestorableState != nil {
+		windowDidEncodeRestorableState :: proc "c" (self: id, window: ^Window, state: ^Coder) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidEncodeRestorableState(window, state)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("window:didDecodeRestorableState:"), auto_cast windowDidEncodeRestorableState, "v@:@@")
+	}
+	if template.windowWillResizeForVersionBrowserWithMaxPreferredSizeMaxAllowedSize != nil {
+		windowWillResizeForVersionBrowserWithMaxPreferredSizeMaxAllowedSize :: proc "c" (self: id, window: ^Window, maxPreferredFrameSize: Size, maxAllowedFrameSize: Size) -> Size {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			return del.windowWillResizeForVersionBrowserWithMaxPreferredSizeMaxAllowedSize(window, maxPreferredFrameSize, maxPreferredFrameSize)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("window:willResizeForVersionBrowserWithMaxPreferredSize:maxAllowedSize:"), auto_cast windowWillResizeForVersionBrowserWithMaxPreferredSizeMaxAllowedSize, _SIZE_ENCODING+"@:@"+_SIZE_ENCODING+_SIZE_ENCODING)
+	}
+	if template.windowWillEnterVersionBrowser != nil {
+		windowWillEnterVersionBrowser :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowWillEnterVersionBrowser(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowWillEnterVersionBrowser:"), auto_cast windowWillEnterVersionBrowser, "v@:@")
+	}
+	if template.windowDidEnterVersionBrowser != nil {
+		windowDidEnterVersionBrowser :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidEnterVersionBrowser(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidEnterVersionBrowser:"), auto_cast windowDidEnterVersionBrowser, "v@:@")
+	}
+	if template.windowWillExitVersionBrowser != nil {
+		windowWillExitVersionBrowser :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowWillExitVersionBrowser(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowWillExitVersionBrowser:"), auto_cast windowWillExitVersionBrowser, "v@:@")
+	}
+	if template.windowDidExitVersionBrowser != nil {
+		windowDidExitVersionBrowser :: proc "c" (self: id, notification: ^Notification) {
+			del := cast(^_WindowDelegateInternal)object_getIndexedIvars(self)
+			context = del._context
+			del.windowDidExitVersionBrowser(notification)
+		}
+		class_addMethod(class, intrinsics.objc_find_selector("windowDidExitVersionBrowser:"), auto_cast windowDidExitVersionBrowser, "v@:@")
+	}
+
+	objc_registerClassPair(class)
+	del := class_createInstance(class, size_of(_WindowDelegateInternal))
+	del_internal := cast(^_WindowDelegateInternal)object_getIndexedIvars(del)
+	del_internal^ = {
+		template,
+		delegate_context.(runtime.Context) or_else runtime.default_context(),
+	}
+
+	return cast(^WindowDelegate)del
+}
+
 @(objc_class="NSColor")
 Color :: struct {using _: Object}
 
@@ -49,19 +562,19 @@ Color :: struct {using _: Object}
 Layer :: struct { using _: NS.Object }
 
 @(objc_type=Layer, objc_name="contentsScale")
-Layer_contentsScale :: proc(self: ^Layer) -> Float {
+Layer_contentsScale :: proc "c" (self: ^Layer) -> Float {
 	return msgSend(Float, self, "contentsScale")
 }
 @(objc_type=Layer, objc_name="setContentsScale")
-Layer_setContentsScale :: proc(self: ^Layer, scale: Float) {
+Layer_setContentsScale :: proc "c" (self: ^Layer, scale: Float) {
 	msgSend(nil, self, "setContentsScale:", scale)
 }
 @(objc_type=Layer, objc_name="frame")
-Layer_frame :: proc(self: ^Layer) -> Rect {
+Layer_frame :: proc "c" (self: ^Layer) -> Rect {
 	return msgSend(Rect, self, "frame")
 }
 @(objc_type=Layer, objc_name="addSublayer")
-Layer_addSublayer :: proc(self: ^Layer, layer: ^Layer) {
+Layer_addSublayer :: proc "c" (self: ^Layer, layer: ^Layer) {
 	msgSend(nil, self, "addSublayer:", layer)
 }
 
@@ -73,23 +586,23 @@ View :: struct {using _: Responder}
 
 
 @(objc_type=View, objc_name="initWithFrame")
-View_initWithFrame :: proc(self: ^View, frame: Rect) -> ^View {
+View_initWithFrame :: proc "c" (self: ^View, frame: Rect) -> ^View {
 	return msgSend(^View, self, "initWithFrame:", frame)
 }
 @(objc_type=View, objc_name="layer")
-View_layer :: proc(self: ^View) -> ^Layer {
+View_layer :: proc "c" (self: ^View) -> ^Layer {
 	return msgSend(^Layer, self, "layer")
 }
 @(objc_type=View, objc_name="setLayer")
-View_setLayer :: proc(self: ^View, layer: ^Layer) {
+View_setLayer :: proc "c" (self: ^View, layer: ^Layer) {
 	msgSend(nil, self, "setLayer:", layer)
 }
 @(objc_type=View, objc_name="wantsLayer")
-View_wantsLayer :: proc(self: ^View) -> BOOL {
+View_wantsLayer :: proc "c" (self: ^View) -> BOOL {
 	return msgSend(BOOL, self, "wantsLayer")
 }
 @(objc_type=View, objc_name="setWantsLayer")
-View_setWantsLayer :: proc(self: ^View, wantsLayer: BOOL) {
+View_setWantsLayer :: proc "c" (self: ^View, wantsLayer: BOOL) {
 	msgSend(nil, self, "setWantsLayer:", wantsLayer)
 }
 
@@ -97,7 +610,7 @@ View_setWantsLayer :: proc(self: ^View, wantsLayer: BOOL) {
 Window :: struct {using _: Responder}
 
 @(objc_type=Window, objc_name="alloc", objc_is_class_method=true)
-Window_alloc :: proc() -> ^Window {
+Window_alloc :: proc "c" () -> ^Window {
 	return msgSend(^Window, Window, "alloc")
 }
 
@@ -117,66 +630,70 @@ Window_initWithContentRect :: proc (self: ^Window, contentRect: Rect, styleMask:
 	return self
 }
 @(objc_type=Window, objc_name="contentView")
-Window_contentView :: proc(self: ^Window) -> ^View {
+Window_contentView :: proc "c" (self: ^Window) -> ^View {
 	return msgSend(^View, self, "contentView")
 }
 @(objc_type=Window, objc_name="setContentView")
-Window_setContentView :: proc(self: ^Window, content_view: ^View) {
+Window_setContentView :: proc "c" (self: ^Window, content_view: ^View) {
 	msgSend(nil, self, "setContentView:", content_view)
 }
 @(objc_type=Window, objc_name="contentLayoutRect")
-Window_contentLayoutRect :: proc(self: ^Window) -> Rect {
+Window_contentLayoutRect :: proc "c" (self: ^Window) -> Rect {
 	return msgSend(Rect, self, "contentLayoutRect")
 }
 @(objc_type=Window, objc_name="frame")
-Window_frame :: proc(self: ^Window) -> Rect {
+Window_frame :: proc "c" (self: ^Window) -> Rect {
 	return msgSend(Rect, self, "frame")
 }
 @(objc_type=Window, objc_name="setFrame")
-Window_setFrame :: proc(self: ^Window, frame: Rect) {
+Window_setFrame :: proc "c" (self: ^Window, frame: Rect) {
 	msgSend(nil, self, "setFrame:", frame)
 }
 @(objc_type=Window, objc_name="opaque")
-Window_opaque :: proc(self: ^Window) -> NS.BOOL {
+Window_opaque :: proc "c" (self: ^Window) -> NS.BOOL {
 	return msgSend(NS.BOOL, self, "opaque")
 }
 @(objc_type=Window, objc_name="setOpaque")
-Window_setOpaque :: proc(self: ^Window, ok: NS.BOOL) {
+Window_setOpaque :: proc "c" (self: ^Window, ok: NS.BOOL) {
 	msgSend(nil, self, "setOpaque:", ok)
 }
 @(objc_type=Window, objc_name="backgroundColor")
-Window_backgroundColor :: proc(self: ^Window) -> ^NS.Color {
+Window_backgroundColor :: proc "c" (self: ^Window) -> ^NS.Color {
 	return msgSend(^NS.Color, self, "backgroundColor")
 }
 @(objc_type=Window, objc_name="setBackgroundColor")
-Window_setBackgroundColor :: proc(self: ^Window, color: ^NS.Color) {
+Window_setBackgroundColor :: proc "c" (self: ^Window, color: ^NS.Color) {
 	msgSend(nil, self, "setBackgroundColor:", color)
 }
 @(objc_type=Window, objc_name="makeKeyAndOrderFront")
-Window_makeKeyAndOrderFront :: proc(self: ^Window, key: ^NS.Object) {
+Window_makeKeyAndOrderFront :: proc "c" (self: ^Window, key: ^NS.Object) {
 	msgSend(nil, self, "makeKeyAndOrderFront:", key)
 }
 @(objc_type=Window, objc_name="setTitle")
-Window_setTitle :: proc(self: ^Window, title: ^NS.String) {
+Window_setTitle :: proc "c" (self: ^Window, title: ^NS.String) {
 	msgSend(nil, self, "setTitle:", title)
 }
 @(objc_type=Window, objc_name="setTitlebarAppearsTransparent")
-Window_setTitlebarAppearsTransparent :: proc(self: ^Window, ok: NS.BOOL) {
+Window_setTitlebarAppearsTransparent :: proc "c" (self: ^Window, ok: NS.BOOL) {
 	msgSend(nil, self, "setTitlebarAppearsTransparent:", ok)
 }
 @(objc_type=Window, objc_name="setMovable")
-Window_setMovable :: proc(self: ^Window, ok: NS.BOOL) {
+Window_setMovable :: proc "c" (self: ^Window, ok: NS.BOOL) {
 	msgSend(nil, self, "setMovable:", ok)
 }
 @(objc_type=Window, objc_name="setMovableByWindowBackground")
-Window_setMovableByWindowBackground :: proc(self: ^Window, ok: NS.BOOL) {
+Window_setMovableByWindowBackground :: proc "c" (self: ^Window, ok: NS.BOOL) {
 	msgSend(nil, self, "setMovableByWindowBackground:", ok)
 }
 @(objc_type=Window, objc_name="setStyleMask")
-Window_setStyleMask :: proc(self: ^Window, style_mask: WindowStyleMask) {
+Window_setStyleMask :: proc "c" (self: ^Window, style_mask: WindowStyleMask) {
 	msgSend(nil, self, "setStyleMask:", style_mask)
 }
 @(objc_type=Window, objc_name="close")
-Window_close :: proc(self: ^Window) {
+Window_close :: proc "c" (self: ^Window) {
 	msgSend(nil, self, "close")
 }
+@(objc_type=Window, objc_name="setDelegate")
+Window_setDelegate :: proc "c" (self: ^Window, delegate: ^WindowDelegate) {
+	msgSend(nil, self, "setDelegate:", delegate)
+}

vendor/darwin/Foundation/objc.odin

@@ -13,10 +13,12 @@ foreign Foundation {
 	objc_allocateClassPair :: proc "c" (superclass : Class, name : cstring, extraBytes : c.size_t) -> Class ---
 	objc_registerClassPair :: proc "c" (cls : Class) ---
 
-	class_addMethod :: proc "c" (cls: Class, name: SEL, imp: IMP, types: cstring) -> BOOL ---
+	class_addMethod         :: proc "c" (cls: Class, name: SEL, imp: IMP, types: cstring) -> BOOL ---
 	class_getInstanceMethod :: proc "c" (cls: Class, name: SEL) -> Method ---
+	class_createInstance    :: proc "c" (cls: Class, extraBytes: c.size_t) -> id ---
 
 	method_setImplementation :: proc "c" (method: Method, imp: IMP) ---
+	object_getIndexedIvars   :: proc(obj: id) -> rawptr ---
 }
 
 

vendor/darwin/Metal/MetalEnums.odin

@@ -17,6 +17,14 @@ AccelerationStructureInstanceOption :: enum u32 {
 	NonOpaque                                  = 3,
 }
 
+
+AccelerationStructureRefitOptions :: distinct bit_set[AccelerationStructureRefitOption; NS.UInteger]
+AccelerationStructureRefitOption :: enum NS.UInteger {
+	VertexData       = 0,
+	PerPrimitiveData = 1,
+}
+
+
 MotionBorderMode :: enum u32 {
 	Clamp  = 0,
 	Vanish = 1,
@@ -148,6 +156,21 @@ BinaryArchiveError :: enum NS.UInteger {
 	InvalidFile        = 1,
 	UnexpectedElement  = 2,
 	CompilationFailure = 3,
+	InternalError      = 4,
+}
+
+BindingType :: enum NS.Integer {
+	Buffer                         = 0,
+	ThreadgroupMemory              = 1,
+	Texture                        = 2,
+	Sampler                        = 3,
+	ImageblockData                 = 16,
+	Imageblock                     = 17,
+	VisibleFunctionTable           = 24,
+	PrimitiveAccelerationStructure = 25,
+	InstanceAccelerationStructure  = 26,
+	IntersectionFunctionTable      = 27,
+	ObjectPayload                  = 34,
 }
 
 BlitOptionFlag :: enum NS.UInteger {
@@ -171,15 +194,16 @@ CaptureDestination :: enum NS.Integer {
 
 CommandBufferStatus :: enum NS.UInteger {
 	NotEnqueued = 0,
-	Enqueued = 1,
-	Committed = 2,
-	Scheduled = 3,
-	Completed = 4,
-	Error = 5,
+	Enqueued    = 1,
+	Committed   = 2,
+	Scheduled   = 3,
+	Completed   = 4,
+	Error       = 5,
 }
 
 CommandBufferError :: enum NS.UInteger {
 	None            = 0,
+	Internal        = 1,
 	Timeout         = 2,
 	PageFault       = 3,
 	AccessRevoked   = 4,
@@ -232,6 +256,7 @@ BarrierScope :: distinct bit_set[BarrierScopeFlag; NS.UInteger]
 CounterSampleBufferError :: enum NS.Integer {
 	OutOfMemory = 0,
 	Invalid     = 1,
+	Internal    = 2,
 }
 
 CompareFunction :: enum NS.UInteger {
@@ -312,6 +337,13 @@ GPUFamily :: enum NS.Integer {
 	Common3      = 3003,
 	MacCatalyst1 = 4001,
 	MacCatalyst2 = 4002,
+	Metal3       = 5001,
+}
+
+SparsePageSize :: enum NS.Integer {
+	Size16  = 101,
+	Size64  = 102,
+	Size256 = 103,
 }
 
 DeviceLocation :: enum NS.UInteger {
@@ -409,6 +441,9 @@ FunctionType :: enum NS.UInteger {
 	Kernel       = 3,
 	Visible      = 5,
 	Intersection = 6,
+	Mesh         = 7,
+	Object       = 8,
+
 }
 
 
@@ -421,15 +456,22 @@ LanguageVersion :: enum NS.UInteger {
 	Version2_2 = 131074,
 	Version2_3 = 131075,
 	Version2_4 = 131076,
+	Version3_0 = 196608,
 }
 
 LibraryType :: enum NS.Integer {
 	Executable = 0,
-	Dynamic = 1,
+	Dynamic    = 1,
+}
+
+LibraryOptimizationLevel :: enum NS.Integer {
+	Default = 0,
+	Size    = 1,
 }
 
 LibraryError :: enum NS.UInteger {
 	Unsupported      = 1,
+	Internal         = 2,
 	CompileFailure   = 3,
 	CompileWarning   = 4,
 	FunctionNotFound = 5,
@@ -624,6 +666,8 @@ RenderStage :: enum NS.UInteger {
 	Vertex   = 0,
 	Fragment = 1,
 	Tile     = 2,
+	Object   = 3,
+	Mesh     = 4,
 }
 RenderStages :: distinct bit_set[RenderStage; NS.UInteger]
 
@@ -861,6 +905,42 @@ IndexType :: enum NS.UInteger {
 	UInt32 = 1,
 }
 
+IOPriority :: enum NS.Integer {
+	High   = 0,
+	Normal = 1,
+	Low    = 2,
+}
+
+IOCommandQueueType :: enum NS.Integer {
+	Concurrent = 0,
+	Serial     = 1,
+}
+
+IOError :: enum NS.Integer {
+	URLInvalid = 1,
+	Internal   = 2,
+}
+
+IOStatus :: enum NS.Integer {
+	Pending   = 0,
+	Cancelled = 1,
+	Error     = 2,
+	Complete  = 3,
+}
+
+IOCompressionMethod :: enum NS.Integer {
+	Zlib     = 0,
+	LZFSE    = 1,
+	LZ4      = 2,
+	LZMA     = 3,
+	LZBitmap = 4,
+}
+
+IOCompressionStatus :: enum NS.Integer {
+	Complete = 0,
+	Error    = 1,
+}
+
 StepFunction :: enum NS.UInteger {
 	Constant                     = 0,
 	PerVertex                    = 1,

vendor/darwin/Metal/MetalErrors.odin

@@ -4,9 +4,11 @@ import NS "vendor:darwin/Foundation"
 
 foreign import "system:Metal.framework"
 
-CommonCounter :: ^NS.String
-CommonCounterSet :: ^NS.String
+CommonCounter          :: ^NS.String
+CommonCounterSet       :: ^NS.String
 DeviceNotificationName :: ^NS.String
+ErrorUserInfoKey       :: ^NS.ErrorUserInfoKey
+ErrorDomain            :: ^NS.ErrorDomain
 
 foreign Metal {
 	@(linkage="weak") CommonCounterTimestamp:                         CommonCounter
@@ -36,4 +38,12 @@ foreign Metal {
 	@(linkage="weak") DeviceWasAddedNotification:         DeviceNotificationName
 	@(linkage="weak") DeviceRemovalRequestedNotification: DeviceNotificationName
 	@(linkage="weak") DeviceWasRemovedNotification:       DeviceNotificationName
+}
+
+foreign Metal {
+	@(linkage="weak") CommandBufferEncoderInfoErrorKey: ErrorUserInfoKey
+}
+
+foreign Metal {
+	@(linkage="weak") IOErrorDomain: ErrorDomain
 }

vendor/darwin/Metal/MetalProcedures.odin

@@ -1,6 +1,7 @@
 package objc_Metal
 
 import NS "vendor:darwin/Foundation"
+import "core:c"
 
 @(require)
 foreign import "system:Metal.framework"
@@ -11,6 +12,12 @@ foreign Metal {
 	CopyAllDevicesWithObserver :: proc(observer: ^id, handler: DeviceNotificationHandler) -> ^NS.Array ---
 	CreateSystemDefaultDevice  :: proc() -> ^Device ---
 	RemoveDeviceObserver       :: proc(observer: id) ---
+
+
+	IOCompressionContextDefaultChunkSize :: proc() -> c.size_t ---
+	IOCreateCompressionContext           :: proc(path: cstring, type: IOCompressionMethod, chuckSize: c.size_t) -> rawptr ---
+	IOCompressionContextAppendData       :: proc(ctx: rawptr, data: rawptr, size: c.size_t) ---
+	IOFlushAndDestroyCompressionContext  :: proc(ctx: rawptr) -> IOCompressionStatus ---
 }
 
 

vendor/darwin/Metal/MetalTypes.odin

@@ -133,6 +133,8 @@ Region :: struct {
 
 SamplePosition :: distinct [2]f32
 
+ResourceID :: distinct u64
+
 ScissorRect :: struct {
 	x:      NS.Integer,
 	y:      NS.Integer,

vendor/darwin/MetalKit/MetalKit.odin

@@ -24,34 +24,34 @@ ViewDelegate :: struct {
 View :: struct {using _: NS.View}
 
 @(objc_type=View, objc_name="alloc", objc_is_class_method=true)
-View_alloc :: proc() -> ^View {
+View_alloc :: proc "c" () -> ^View {
 	return msgSend(^View, View, "alloc")
 }
 @(objc_type=View, objc_name="initWithFrame")
-View_initWithFrame :: proc(self: ^View, frame: NS.Rect, device: ^MTL.Device) -> ^View {
+View_initWithFrame :: proc "c" (self: ^View, frame: NS.Rect, device: ^MTL.Device) -> ^View {
 	return msgSend(^View, self, "initWithFrame:device:", frame, device)
 }
 @(objc_type=View, objc_name="initWithCoder")
-View_initWithCoder :: proc(self: ^View, coder: ^NS.Coder) -> ^View {
+View_initWithCoder :: proc "c" (self: ^View, coder: ^NS.Coder) -> ^View {
 	return msgSend(^View, self, "initWithCoder:", coder)
 }
 
 @(objc_type=View, objc_name="setDevice")
-View_setDevice :: proc(self: ^View, device: ^MTL.Device) {
+View_setDevice :: proc "c" (self: ^View, device: ^MTL.Device) {
 	msgSend(nil, self, "setDevice:", device)
 }
 @(objc_type=View, objc_name="device")
-View_device :: proc(self: ^View) -> ^MTL.Device {
+View_device :: proc "c" (self: ^View) -> ^MTL.Device {
 	return msgSend(^MTL.Device, self, "device")
 }
 
 @(objc_type=View, objc_name="draw")
-View_draw :: proc(self: ^View) {
+View_draw :: proc "c" (self: ^View) {
 	msgSend(nil, self, "draw")
 }
 
 @(objc_type=View, objc_name="setDelegate")
-View_setDelegate :: proc(self: ^View, delegate: ^ViewDelegate) {
+View_setDelegate :: proc "c" (self: ^View, delegate: ^ViewDelegate) {
 	drawDispatch :: proc "c" (self: ^NS.Value, cmd: NS.SEL, view: ^View) {
 		del := (^ViewDelegate)(self->pointerValue())
 		del->drawInMTKView(view)
@@ -72,7 +72,7 @@ View_setDelegate :: proc(self: ^View, delegate: ^ViewDelegate) {
 }
 
 @(objc_type=View, objc_name="delegate")
-View_delegate :: proc(self: ^View) -> ^ViewDelegate {
+View_delegate :: proc "c" (self: ^View) -> ^ViewDelegate {
 	wrapper := msgSend(^NS.Value, self, "delegate")
 	if wrapper != nil {
 		return (^ViewDelegate)(wrapper->pointerValue())
@@ -81,179 +81,179 @@ View_delegate :: proc(self: ^View) -> ^ViewDelegate {
 }
 
 @(objc_type=View, objc_name="currentDrawable")
-View_currentDrawable :: proc(self: ^View) -> ^CA.MetalDrawable {
+View_currentDrawable :: proc "c" (self: ^View) -> ^CA.MetalDrawable {
 	return msgSend(^CA.MetalDrawable, self, "currentDrawable")
 }
 
 @(objc_type=View, objc_name="setFramebufferOnly")
-View_setFramebufferOnly :: proc(self: ^View, framebufferOnly: bool) {
+View_setFramebufferOnly :: proc "c" (self: ^View, framebufferOnly: bool) {
 	msgSend(nil, self, "setFramebufferOnly:", framebufferOnly)
 }
 @(objc_type=View, objc_name="framebufferOnly")
-View_framebufferOnly :: proc(self: ^View) -> bool {
+View_framebufferOnly :: proc "c" (self: ^View) -> bool {
 	return msgSend(bool, self, "framebufferOnly")
 }
 
 @(objc_type=View, objc_name="setDepthStencilAttachmentTextureUsage")
-View_setDepthStencilAttachmentTextureUsage :: proc(self: ^View, textureUsage: MTL.TextureUsage) {
+View_setDepthStencilAttachmentTextureUsage :: proc "c" (self: ^View, textureUsage: MTL.TextureUsage) {
 	msgSend(nil, self, "setDepthStencilAttachmentTextureUsage:", textureUsage)
 }
 @(objc_type=View, objc_name="depthStencilAttachmentTextureUsage")
-View_depthStencilAttachmentTextureUsage :: proc(self: ^View) -> MTL.TextureUsage {
+View_depthStencilAttachmentTextureUsage :: proc "c" (self: ^View) -> MTL.TextureUsage {
 	return msgSend(MTL.TextureUsage, self, "depthStencilAttachmentTextureUsage")
 }
 
 @(objc_type=View, objc_name="setMultisampleColorAttachmentTextureUsage")
-View_setMultisampleColorAttachmentTextureUsage :: proc(self: ^View, textureUsage: MTL.TextureUsage) {
+View_setMultisampleColorAttachmentTextureUsage :: proc "c" (self: ^View, textureUsage: MTL.TextureUsage) {
 	msgSend(nil, self, "setMultisampleColorAttachmentTextureUsage:", textureUsage)
 }
 @(objc_type=View, objc_name="multisampleColorAttachmentTextureUsage")
-View_multisampleColorAttachmentTextureUsage :: proc(self: ^View) -> MTL.TextureUsage {
+View_multisampleColorAttachmentTextureUsage :: proc "c" (self: ^View) -> MTL.TextureUsage {
 	return msgSend(MTL.TextureUsage, self, "multisampleColorAttachmentTextureUsage")
 }
 
 @(objc_type=View, objc_name="setPresentsWithTransaction")
-View_setPresentsWithTransaction :: proc(self: ^View, presentsWithTransaction: bool) {
+View_setPresentsWithTransaction :: proc "c" (self: ^View, presentsWithTransaction: bool) {
 	msgSend(nil, self, "setPresentsWithTransaction:", presentsWithTransaction)
 }
 @(objc_type=View, objc_name="presentsWithTransaction")
-View_presentsWithTransaction :: proc(self: ^View) -> bool {
+View_presentsWithTransaction :: proc "c" (self: ^View) -> bool {
 	return msgSend(bool, self, "presentsWithTransaction")
 }
 
 @(objc_type=View, objc_name="setColorPixelFormat")
-View_setColorPixelFormat :: proc(self: ^View, colorPixelFormat: MTL.PixelFormat) {
+View_setColorPixelFormat :: proc "c" (self: ^View, colorPixelFormat: MTL.PixelFormat) {
 	msgSend(nil, self, "setColorPixelFormat:", colorPixelFormat)
 }
 @(objc_type=View, objc_name="colorPixelFormat")
-View_colorPixelFormat :: proc(self: ^View) -> MTL.PixelFormat {
+View_colorPixelFormat :: proc "c" (self: ^View) -> MTL.PixelFormat {
 	return msgSend(MTL.PixelFormat, self, "colorPixelFormat")
 }
 
 @(objc_type=View, objc_name="setDepthStencilPixelFormat")
-View_setDepthStencilPixelFormat :: proc(self: ^View, colorPixelFormat: MTL.PixelFormat) {
+View_setDepthStencilPixelFormat :: proc "c" (self: ^View, colorPixelFormat: MTL.PixelFormat) {
 	msgSend(nil, self, "setDepthStencilPixelFormat:", colorPixelFormat)
 }
 @(objc_type=View, objc_name="depthStencilPixelFormat")
-View_depthStencilPixelFormat :: proc(self: ^View) -> MTL.PixelFormat {
+View_depthStencilPixelFormat :: proc "c" (self: ^View) -> MTL.PixelFormat {
 	return msgSend(MTL.PixelFormat, self, "depthStencilPixelFormat")
 }
 
 @(objc_type=View, objc_name="setSampleCount")
-View_setSampleCount :: proc(self: ^View, sampleCount: NS.UInteger) {
+View_setSampleCount :: proc "c" (self: ^View, sampleCount: NS.UInteger) {
 	msgSend(nil, self, "setSampleCount:", sampleCount)
 }
 @(objc_type=View, objc_name="sampleCount")
-View_sampleCount :: proc(self: ^View) -> NS.UInteger {
+View_sampleCount :: proc "c" (self: ^View) -> NS.UInteger {
 	return msgSend(NS.UInteger, self, "sampleCount")
 }
 
 @(objc_type=View, objc_name="setClearColor")
-View_setClearColor :: proc(self: ^View, clearColor: MTL.ClearColor) {
+View_setClearColor :: proc "c" (self: ^View, clearColor: MTL.ClearColor) {
 	msgSend(nil, self, "setClearColor:", clearColor)
 }
 @(objc_type=View, objc_name="clearColor")
-View_clearColor :: proc(self: ^View) -> MTL.ClearColor {
+View_clearColor :: proc "c" (self: ^View) -> MTL.ClearColor {
 	return msgSend(MTL.ClearColor, self, "clearColor")
 }
 
 @(objc_type=View, objc_name="setClearDepth")
-View_setClearDepth :: proc(self: ^View, clearDepth: f64) {
+View_setClearDepth :: proc "c" (self: ^View, clearDepth: f64) {
 	msgSend(nil, self, "setClearDepth:", clearDepth)
 }
 @(objc_type=View, objc_name="clearDepth")
-View_clearDepth :: proc(self: ^View) -> f64 {
+View_clearDepth :: proc "c" (self: ^View) -> f64 {
 	return msgSend(f64, self, "clearDepth")
 }
 
 @(objc_type=View, objc_name="setClearStencil")
-View_setClearStencil :: proc(self: ^View, clearStencil: u32) {
+View_setClearStencil :: proc "c" (self: ^View, clearStencil: u32) {
 	msgSend(nil, self, "setClearStencil:", clearStencil)
 }
 @(objc_type=View, objc_name="clearStencil")
-View_clearStencil :: proc(self: ^View) -> u32 {
+View_clearStencil :: proc "c" (self: ^View) -> u32 {
 	return msgSend(u32, self, "clearStencil")
 }
 
 @(objc_type=View, objc_name="depthStencilTexture")
-View_depthStencilTexture :: proc(self: ^View) -> ^MTL.Texture {
+View_depthStencilTexture :: proc "c" (self: ^View) -> ^MTL.Texture {
 	return msgSend(^MTL.Texture, self, "depthStencilTexture")
 }
 @(objc_type=View, objc_name="multisampleColorTexture")
-View_multisampleColorTexture :: proc(self: ^View) -> ^MTL.Texture {
+View_multisampleColorTexture :: proc "c" (self: ^View) -> ^MTL.Texture {
 	return msgSend(^MTL.Texture, self, "multisampleColorTexture")
 }
 
 @(objc_type=View, objc_name="releaseDrawables")
-View_releaseDrawables :: proc(self: ^View) {
+View_releaseDrawables :: proc "c" (self: ^View) {
 	msgSend(nil, self, "releaseDrawables")
 }
 
 @(objc_type=View, objc_name="currentRenderPassDescriptor")
-View_currentRenderPassDescriptor :: proc(self: ^View) -> ^MTL.RenderPassDescriptor {
+View_currentRenderPassDescriptor :: proc "c" (self: ^View) -> ^MTL.RenderPassDescriptor {
 	return msgSend(^MTL.RenderPassDescriptor, self, "currentRenderPassDescriptor")
 }
 
 @(objc_type=View, objc_name="setPreferredFramesPerSecond")
-View_setPreferredFramesPerSecond :: proc(self: ^View, preferredFramesPerSecond: NS.Integer) {
+View_setPreferredFramesPerSecond :: proc "c" (self: ^View, preferredFramesPerSecond: NS.Integer) {
 	msgSend(nil, self, "setPreferredFramesPerSecond:", preferredFramesPerSecond)
 }
 @(objc_type=View, objc_name="preferredFramesPerSecond")
-View_preferredFramesPerSecond :: proc(self: ^View) -> NS.Integer {
+View_preferredFramesPerSecond :: proc "c" (self: ^View) -> NS.Integer {
 	return msgSend(NS.Integer, self, "preferredFramesPerSecond")
 }
 
 @(objc_type=View, objc_name="setEnableSetNeedsDisplay")
-View_setEnableSetNeedsDisplay :: proc(self: ^View, enableSetNeedsDisplay: bool) {
+View_setEnableSetNeedsDisplay :: proc "c" (self: ^View, enableSetNeedsDisplay: bool) {
 	msgSend(nil, self, "setEnableSetNeedsDisplay:", enableSetNeedsDisplay)
 }
 @(objc_type=View, objc_name="enableSetNeedsDisplay")
-View_enableSetNeedsDisplay :: proc(self: ^View) -> bool {
+View_enableSetNeedsDisplay :: proc "c" (self: ^View) -> bool {
 	return msgSend(bool, self, "enableSetNeedsDisplay")
 }
 
 @(objc_type=View, objc_name="setAutoresizeDrawable")
-View_setAutoresizeDrawable :: proc(self: ^View, autoresizeDrawable: bool) {
+View_setAutoresizeDrawable :: proc "c" (self: ^View, autoresizeDrawable: bool) {
 	msgSend(nil, self, "setAutoresizeDrawable:", autoresizeDrawable)
 }
 @(objc_type=View, objc_name="autoresizeDrawable")
-View_autoresizeDrawable :: proc(self: ^View) -> bool {
+View_autoresizeDrawable :: proc "c" (self: ^View) -> bool {
 	return msgSend(bool, self, "autoresizeDrawable")
 }
 
 @(objc_type=View, objc_name="setDrawableSize")
-View_setDrawableSize :: proc(self: ^View, drawableSize: NS.Size) {
+View_setDrawableSize :: proc "c" (self: ^View, drawableSize: NS.Size) {
 	msgSend(nil, self, "setDrawableSize:", drawableSize)
 }
 @(objc_type=View, objc_name="drawableSize")
-View_drawableSize :: proc(self: ^View) -> NS.Size {
+View_drawableSize :: proc "c" (self: ^View) -> NS.Size {
 	return msgSend(NS.Size, self, "drawableSize")
 }
 
 @(objc_type=View, objc_name="preferredDrawableSize")
-View_preferredDrawableSize :: proc(self: ^View) -> NS.Size {
+View_preferredDrawableSize :: proc "c" (self: ^View) -> NS.Size {
 	return msgSend(NS.Size, self, "preferredDrawableSize")
 }
 
 @(objc_type=View, objc_name="preferredDevice")
-View_preferredDevice :: proc(self: ^View) -> ^MTL.Device {
+View_preferredDevice :: proc "c" (self: ^View) -> ^MTL.Device {
 	return msgSend(^MTL.Device, self, "preferredDevice")
 }
 
 @(objc_type=View, objc_name="setPaused")
-View_setPaused :: proc(self: ^View, isPaused: bool) {
+View_setPaused :: proc "c" (self: ^View, isPaused: bool) {
 	msgSend(nil, self, "setPaused:", isPaused)
 }
 @(objc_type=View, objc_name="isPaused")
-View_isPaused :: proc(self: ^View) -> bool {
+View_isPaused :: proc "c" (self: ^View) -> bool {
 	return msgSend(bool, self, "isPaused")
 }
 
 @(objc_type=View, objc_name="setColorSpace")
-View_setColorSpace :: proc(self: ^View, colorSpace: ColorSpaceRef) {
+View_setColorSpace :: proc "c" (self: ^View, colorSpace: ColorSpaceRef) {
 	msgSend(nil, self, "setColorSpace:", colorSpace)
 }
 @(objc_type=View, objc_name="colorSpace")
-View_colorSpace :: proc(self: ^View) -> ColorSpaceRef {
+View_colorSpace :: proc "c" (self: ^View) -> ColorSpaceRef {
 	return msgSend(ColorSpaceRef, self, "colorSpace")
 }

vendor/darwin/QuartzCore/QuartzCore.odin

@@ -11,63 +11,74 @@ msgSend :: intrinsics.objc_send
 MetalLayer :: struct{ using _: NS.Layer}
 
 @(objc_type=MetalLayer, objc_name="layer", objc_is_class_method=true)
-MetalLayer_layer :: proc() -> ^MetalLayer {
+MetalLayer_layer :: proc "c" () -> ^MetalLayer {
 	return msgSend(^MetalLayer, MetalLayer, "layer")
 }
 
 @(objc_type=MetalLayer, objc_name="device")
-MetalLayer_device :: proc(self: ^MetalLayer) -> ^MTL.Device {
+MetalLayer_device :: proc "c" (self: ^MetalLayer) -> ^MTL.Device {
 	return msgSend(^MTL.Device, self, "device")
 }
 @(objc_type=MetalLayer, objc_name="setDevice")
-MetalLayer_setDevice :: proc(self: ^MetalLayer, device: ^MTL.Device) {
+MetalLayer_setDevice :: proc "c" (self: ^MetalLayer, device: ^MTL.Device) {
 	msgSend(nil, self, "setDevice:", device)
 }
 
 
 @(objc_type=MetalLayer, objc_name="opaque")
-MetalLayer_opaque :: proc(self: ^MetalLayer) -> NS.BOOL {
+MetalLayer_opaque :: proc "c" (self: ^MetalLayer) -> NS.BOOL {
 	return msgSend(NS.BOOL, self, "opaque")
 }
 @(objc_type=MetalLayer, objc_name="setOpaque")
-MetalLayer_setOpaque :: proc(self: ^MetalLayer, opaque: NS.BOOL) {
+MetalLayer_setOpaque :: proc "c" (self: ^MetalLayer, opaque: NS.BOOL) {
 	msgSend(nil, self, "setOpaque:", opaque)
 }
 
 @(objc_type=MetalLayer, objc_name="preferredDevice")
-MetalLayer_preferredDevice :: proc(self: ^MetalLayer) -> ^MTL.Device {
+MetalLayer_preferredDevice :: proc "c" (self: ^MetalLayer) -> ^MTL.Device {
 	return msgSend(^MTL.Device, self, "preferredDevice")
 }
 @(objc_type=MetalLayer, objc_name="pixelFormat")
-MetalLayer_pixelFormat :: proc(self: ^MetalLayer) -> MTL.PixelFormat {
+MetalLayer_pixelFormat :: proc "c" (self: ^MetalLayer) -> MTL.PixelFormat {
 	return msgSend(MTL.PixelFormat, self, "pixelFormat")
 }
 @(objc_type=MetalLayer, objc_name="setPixelFormat")
-MetalLayer_setPixelFormat :: proc(self: ^MetalLayer, pixelFormat: MTL.PixelFormat) {
+MetalLayer_setPixelFormat :: proc "c" (self: ^MetalLayer, pixelFormat: MTL.PixelFormat) {
 	msgSend(nil, self, "setPixelFormat:", pixelFormat)
 }
 
 @(objc_type=MetalLayer, objc_name="framebufferOnly")
-MetalLayer_framebufferOnly :: proc(self: ^MetalLayer) -> NS.BOOL {
+MetalLayer_framebufferOnly :: proc "c" (self: ^MetalLayer) -> NS.BOOL {
 	return msgSend(NS.BOOL, self, "framebufferOnly")
 }
 @(objc_type=MetalLayer, objc_name="setFramebufferOnly")
-MetalLayer_setFramebufferOnly :: proc(self: ^MetalLayer, ok: NS.BOOL) {
+MetalLayer_setFramebufferOnly :: proc "c" (self: ^MetalLayer, ok: NS.BOOL) {
 	msgSend(nil, self, "setFramebufferOnly:", ok)
 }
 
+
+@(objc_type=MetalLayer, objc_name="drawableSize")
+MetalLayer_drawableSize :: proc "c" (self: ^MetalLayer) -> NS.Size {
+	return msgSend(NS.Size, self, "drawableSize")
+}
+@(objc_type=MetalLayer, objc_name="setDrawableSize")
+MetalLayer_setDrawableSize :: proc "c" (self: ^MetalLayer, drawableSize: NS.Size) {
+	msgSend(nil, self, "setDrawableSize:", drawableSize)
+}
+
+
 @(objc_type=MetalLayer, objc_name="frame")
-MetalLayer_frame :: proc(self: ^MetalLayer) -> NS.Rect {
+MetalLayer_frame :: proc "c" (self: ^MetalLayer) -> NS.Rect {
 	return msgSend(NS.Rect, self, "frame")
 }
 @(objc_type=MetalLayer, objc_name="setFrame")
-MetalLayer_setFrame :: proc(self: ^MetalLayer, frame: NS.Rect) {
+MetalLayer_setFrame :: proc "c" (self: ^MetalLayer, frame: NS.Rect) {
 	msgSend(nil, self, "setFrame:", frame)
 }
 
 
 @(objc_type=MetalLayer, objc_name="nextDrawable")
-MetalLayer_nextDrawable :: proc(self: ^MetalLayer) -> ^MetalDrawable {
+MetalLayer_nextDrawable :: proc "c" (self: ^MetalLayer) -> ^MetalDrawable {
 	return msgSend(^MetalDrawable, self, "nextDrawable")
 }
 
@@ -77,11 +88,11 @@ MetalLayer_nextDrawable :: proc(self: ^MetalLayer) -> ^MetalDrawable {
 MetalDrawable :: struct { using _: MTL.Drawable }
 
 @(objc_type=MetalDrawable, objc_name="layer")
-MetalDrawable_layer :: proc(self: ^MetalDrawable) -> ^MetalLayer {
+MetalDrawable_layer :: proc "c" (self: ^MetalDrawable) -> ^MetalLayer {
 	return msgSend(^MetalLayer, self, "layer")
 }
 
 @(objc_type=MetalDrawable, objc_name="texture")
-MetalDrawable_texture :: proc(self: ^MetalDrawable) -> ^MTL.Texture {
+MetalDrawable_texture :: proc "c" (self: ^MetalDrawable) -> ^MTL.Texture {
 	return msgSend(^MTL.Texture, self, "texture")
 }

vendor/directx/ThirdPartyNotices.txt

@@ -0,0 +1,248 @@
+Microsoft/DirectXShaderCompiler
+
+THIRD-PARTY SOFTWARE NOTICES AND INFORMATION
+
+Do Not Translate or Localize
+
+This project incorporates components from the projects listed below. The
+original copyright notices and the licenses under which Microsoft received
+such components are set forth below. Microsoft reserves all rights not
+expressly granted herein, whether by implication, estoppel or otherwise.
+
+
+* LLVM
+
+==============================================================================
+LLVM Release License
+==============================================================================
+University of Illinois/NCSA
+Open Source License
+
+Copyright (c) 2003-2015 University of Illinois at Urbana-Champaign.
+All rights reserved.
+
+Developed by:
+
+    LLVM Team
+
+    University of Illinois at Urbana-Champaign
+
+    http://llvm.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal with
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimers.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimers in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the names of the LLVM Team, University of Illinois at
+      Urbana-Champaign, nor the names of its contributors may be used to
+      endorse or promote products derived from this Software without specific
+      prior written permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+SOFTWARE.
+
+==============================================================================
+Copyrights and Licenses for Third Party Software Distributed with LLVM:
+==============================================================================
+The LLVM software contains code written by third parties.  Such software will
+have its own individual LICENSE.TXT file in the directory in which it appears.
+This file will describe the copyrights, license, and restrictions which apply
+to that code.
+
+The disclaimer of warranty in the University of Illinois Open Source License
+applies to all code in the LLVM Distribution, and nothing in any of the
+other licenses gives permission to use the names of the LLVM Team or the
+University of Illinois to endorse or promote products derived from this
+Software.
+
+The following pieces of software have additional or alternate copyrights,
+licenses, and/or restrictions:
+
+Program             Directory
+-------             ---------
+OpenBSD regex       llvm/lib/Support/{reg*, COPYRIGHT.regex}
+pyyaml tests        llvm/test/YAMLParser/{*.data, LICENSE.TXT}
+md5 contributions   llvm/lib/Support/MD5.cpp llvm/include/llvm/Support/MD5.h
+
+
+* tools\clang
+
+==============================================================================
+LLVM Release License
+==============================================================================
+University of Illinois/NCSA
+Open Source License
+
+Copyright (c) 2007-2015 University of Illinois at Urbana-Champaign.
+All rights reserved.
+
+Developed by:
+
+    LLVM Team
+
+    University of Illinois at Urbana-Champaign
+
+    http://llvm.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal with
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimers.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimers in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the names of the LLVM Team, University of Illinois at
+      Urbana-Champaign, nor the names of its contributors may be used to
+      endorse or promote products derived from this Software without specific
+      prior written permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+SOFTWARE.
+
+==============================================================================
+The LLVM software contains code written by third parties.  Such software will
+have its own individual LICENSE.TXT file in the directory in which it appears.
+This file will describe the copyrights, license, and restrictions which apply
+to that code.
+
+The disclaimer of warranty in the University of Illinois Open Source License
+applies to all code in the LLVM Distribution, and nothing in any of the
+other licenses gives permission to use the names of the LLVM Team or the
+University of Illinois to endorse or promote products derived from this
+Software.
+
+
+* test\YAMLParser
+
+Copyright (c) 2006 Kirill Simonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+* include\llvm\Support
+
+LLVM System Interface Library
+-------------------------------------------------------------------------------
+The LLVM System Interface Library is licensed under the Illinois Open Source
+License and has the following additional copyright:
+
+Copyright (C) 2004 eXtensible Systems, Inc.
+
+* OpenBSD regex
+
+$OpenBSD: COPYRIGHT,v 1.3 2003/06/02 20:18:36 millert Exp $
+
+Copyright 1992, 1993, 1994 Henry Spencer.  All rights reserved.
+This software is not subject to any license of the American Telephone
+and Telegraph Company or of the Regents of the University of California.
+
+Permission is granted to anyone to use this software for any purpose on
+any computer system, and to alter it and redistribute it, subject
+to the following restrictions:
+
+1. The author is not responsible for the consequences of use of this
+   software, no matter how awful, even if they arise from flaws in it.
+
+2. The origin of this software must not be misrepresented, either by
+   explicit claim or by omission.  Since few users ever read sources,
+   credits must appear in the documentation.
+
+3. Altered versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.  Since few users
+   ever read sources, credits must appear in the documentation.
+
+4. This notice may not be removed or altered.
+
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+/*-
+ * Copyright (c) 1994
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)COPYRIGHT	8.1 (Berkeley) 3/16/94
+ */
+
+* lib\Headers Files
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/directx/d3d11/d3d11.odin

@@ -2384,7 +2384,7 @@ IDeviceContext_VTable :: struct {
 	GSSetSamplers:                             proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumSamplers: u32, ppSamplers: ^^ISamplerState),
 	OMSetRenderTargets:                        proc "stdcall" (this: ^IDeviceContext, NumViews: u32, ppRenderTargetViews: ^^IRenderTargetView, pDepthStencilView: ^IDepthStencilView),
 	OMSetRenderTargetsAndUnorderedAccessViews: proc "stdcall" (this: ^IDeviceContext, NumRTVs: u32, ppRenderTargetViews: ^^IRenderTargetView, pDepthStencilView: ^IDepthStencilView, UAVStartSlot: u32, NumUAVs: u32, ppUnorderedAccessViews: ^^IUnorderedAccessView, pUAVInitialCounts: ^u32),
-	OMSetBlendState:                           proc "stdcall" (this: ^IDeviceContext, pBlendState: ^IBlendState, BlendFactor: ^[4]f32, SampleMask: COLOR_WRITE_ENABLE_MASK),
+	OMSetBlendState:                           proc "stdcall" (this: ^IDeviceContext, pBlendState: ^IBlendState, BlendFactor: ^[4]f32, SampleMask: u32),
 	OMSetDepthStencilState:                    proc "stdcall" (this: ^IDeviceContext, pDepthStencilState: ^IDepthStencilState, StencilRef: u32),
 	SOSetTargets:                              proc "stdcall" (this: ^IDeviceContext, NumBuffers: u32, ppSOTargets: ^^IBuffer, pOffsets: ^u32),
 	DrawAuto:                                  proc "stdcall" (this: ^IDeviceContext),
@@ -5131,4 +5131,4 @@ MESSAGE_ID :: enum u32 {
 	END_TRACKED_WORKLOAD_INVALID_ARG,
 	TRACKED_WORKLOAD_DISJOINT_FAILURE,
 	D3D11_5_MESSAGES_END,
-}
+}

vendor/directx/d3d12/d3d12.odin

@@ -1226,7 +1226,7 @@ HEAP_FLAG :: enum u32 {
 }
 
 HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES :: HEAP_FLAGS{}
-HEAP_FLAG_ALLOW_ONLY_BUFFERS             :: HEAP_FLAGS{.DENY_BUFFERS, .ALLOW_DISPLAY}
+HEAP_FLAG_ALLOW_ONLY_BUFFERS             :: HEAP_FLAGS{.DENY_RT_DS_TEXTURES, .DENY_NON_RT_DS_TEXTURES}
 HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES  :: HEAP_FLAGS{.DENY_BUFFERS, .DENY_RT_DS_TEXTURES}
 HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES      :: HEAP_FLAGS{.DENY_BUFFERS, .DENY_NON_RT_DS_TEXTURES}
 
@@ -1992,6 +1992,8 @@ ROOT_SIGNATURE_FLAG :: enum u32 {
 	LOCAL_ROOT_SIGNATURE                  = 7,
 	DENY_AMPLIFICATION_SHADER_ROOT_ACCESS = 8,
 	DENY_MESH_SHADER_ROOT_ACCESS          = 9,
+	CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED     = 10,
+	SAMPLER_HEAP_DIRECTLY_INDEXED         = 11,
 }
 
 STATIC_BORDER_COLOR :: enum i32 {
@@ -2543,7 +2545,7 @@ IDevice_VTable :: struct {
 	CreateSampler:                    proc "stdcall" (this: ^IDevice, pDesc: ^SAMPLER_DESC, DestDescriptor: CPU_DESCRIPTOR_HANDLE),
 	CopyDescriptors:                  proc "stdcall" (this: ^IDevice, NumDestDescriptorRanges: u32, pDestDescriptorRangeStarts: ^CPU_DESCRIPTOR_HANDLE, pDestDescriptorRangeSizes: ^u32, NumSrcDescriptorRanges: u32, pSrcDescriptorRangeStarts: ^CPU_DESCRIPTOR_HANDLE, pSrcDescriptorRangeSizes: ^u32, DescriptorHeapsType: DESCRIPTOR_HEAP_TYPE),
 	CopyDescriptorsSimple:            proc "stdcall" (this: ^IDevice, NumDescriptors: u32, DestDescriptorRangeStart: CPU_DESCRIPTOR_HANDLE, SrcDescriptorRangeStart: CPU_DESCRIPTOR_HANDLE, DescriptorHeapsType: DESCRIPTOR_HEAP_TYPE),
-	GetResourceAllocationInfo:        proc "stdcall" (this: ^IDevice, visibleMask: u32, numResourceDescs: u32, pResourceDescs: ^RESOURCE_DESC) -> RESOURCE_ALLOCATION_INFO,
+	GetResourceAllocationInfo:        proc "stdcall" (this: ^IDevice, RetVal: ^RESOURCE_ALLOCATION_INFO, visibleMask: u32, numResourceDescs: u32, pResourceDescs: ^RESOURCE_DESC),
 	GetCustomHeapProperties:          proc "stdcall" (this: ^IDevice, nodeMask: u32, heapType: HEAP_TYPE) -> HEAP_PROPERTIES,
 	CreateCommittedResource:          proc "stdcall" (this: ^IDevice, pHeapProperties: ^HEAP_PROPERTIES, HeapFlags: HEAP_FLAGS, pDesc: ^RESOURCE_DESC, InitialResourceState: RESOURCE_STATES, pOptimizedClearValue: ^CLEAR_VALUE, riidResource: ^IID, ppvResource: ^rawptr) -> HRESULT,
 	CreateHeap:                       proc "stdcall" (this: ^IDevice, pDesc: ^HEAP_DESC, riid: ^IID, ppvHeap: ^rawptr) -> HRESULT,
@@ -2728,7 +2730,7 @@ IDevice4_VTable :: struct {
 	CreateCommittedResource1:       proc "stdcall" (this: ^IDevice4, pHeapProperties: ^HEAP_PROPERTIES, HeapFlags: HEAP_FLAGS, pDesc: ^RESOURCE_DESC, InitialResourceState: RESOURCE_STATES, pOptimizedClearValue: ^CLEAR_VALUE, pProtectedSession: ^IProtectedResourceSession, riidResource: ^IID, ppvResource: ^rawptr) -> HRESULT,
 	CreateHeap1:                    proc "stdcall" (this: ^IDevice4, pDesc: ^HEAP_DESC, pProtectedSession: ^IProtectedResourceSession, riid: ^IID, ppvHeap: ^rawptr) -> HRESULT,
 	CreateReservedResource1:        proc "stdcall" (this: ^IDevice4, pDesc: ^RESOURCE_DESC, InitialState: RESOURCE_STATES, pOptimizedClearValue: ^CLEAR_VALUE, pProtectedSession: ^IProtectedResourceSession, riid: ^IID, ppvResource: ^rawptr) -> HRESULT,
-	GetResourceAllocationInfo1:     proc "stdcall" (this: ^IDevice4, visibleMask: u32, numResourceDescs: u32, pResourceDescs: ^RESOURCE_DESC, pResourceAllocationInfo1: ^RESOURCE_ALLOCATION_INFO1) -> RESOURCE_ALLOCATION_INFO,
+	GetResourceAllocationInfo1:     proc "stdcall" (this: ^IDevice4, RetVal: ^RESOURCE_ALLOCATION_INFO, visibleMask: u32, numResourceDescs: u32, pResourceDescs: ^RESOURCE_DESC, pResourceAllocationInfo1: ^RESOURCE_ALLOCATION_INFO1),
 }
 
 LIFETIME_STATE :: enum i32 {
@@ -3516,7 +3518,7 @@ IDevice8 :: struct #raw_union {
 }
 IDevice8_VTable :: struct {
 	using id3d12device7_vtable: IDevice7_VTable,
-	GetResourceAllocationInfo2:               proc "stdcall" (this: ^IDevice8, visibleMask: u32, numResourceDescs: u32, pResourceDescs: ^RESOURCE_DESC1, pResourceAllocationInfo1: ^RESOURCE_ALLOCATION_INFO1) -> RESOURCE_ALLOCATION_INFO,
+	GetResourceAllocationInfo2:               proc "stdcall" (this: ^IDevice8, RetVal: ^RESOURCE_ALLOCATION_INFO, visibleMask: u32, numResourceDescs: u32, pResourceDescs: ^RESOURCE_DESC1, pResourceAllocationInfo1: ^RESOURCE_ALLOCATION_INFO1),
 	CreateCommittedResource2:                 proc "stdcall" (this: ^IDevice8, pHeapProperties: ^HEAP_PROPERTIES, HeapFlags: HEAP_FLAGS, pDesc: ^RESOURCE_DESC1, InitialResourceState: RESOURCE_STATES, pOptimizedClearValue: ^CLEAR_VALUE, pProtectedSession: ^IProtectedResourceSession, riidResource: ^IID, ppvResource: ^rawptr) -> HRESULT,
 	CreatePlacedResource1:                    proc "stdcall" (this: ^IDevice8, pHeap: ^IHeap, HeapOffset: u64, pDesc: ^RESOURCE_DESC1, InitialState: RESOURCE_STATES, pOptimizedClearValue: ^CLEAR_VALUE, riid: ^IID, ppvResource: ^rawptr) -> HRESULT,
 	CreateSamplerFeedbackUnorderedAccessView: proc "stdcall" (this: ^IDevice8, pTargetedResource: ^IResource, pFeedbackResource: ^IResource, DestDescriptor: CPU_DESCRIPTOR_HANDLE),
@@ -4870,6 +4872,25 @@ IInfoQueue_VTable :: struct {
 	GetMuteDebugOutput:                           proc "stdcall" (this: ^IInfoQueue) -> BOOL,
 }
 
+MESSAGE_CALLBACK_FLAGS :: distinct bit_set[MESSAGE_CALLBACK_FLAG; u32]
+MESSAGE_CALLBACK_FLAG :: enum {
+	IGNORE_FILTERS = 0,
+}
+
+PFN_MESSAGE_CALLBACK :: #type proc "c" (Category: MESSAGE_CATEGORY, Severity: MESSAGE_SEVERITY, ID: MESSAGE_ID, pDescription: cstring, pContext: rawptr)
+
+IInfoQueue1_UUID_STRING :: "2852dd88-b484-4c0c-b6b1-67168500e600"
+IInfoQueue1_UUID := &IID{0x2852dd88, 0xb484, 0x4c0c, {0xb6, 0xb1, 0x67, 0x16, 0x85, 0x00, 0xe6, 0x00}}
+IInfoQueue1 :: struct #raw_union {
+	#subtype iinfo_queue: IInfoQueue,
+	using idxgiinfoqueue1_vtable: ^IInfoQueue1_VTable,
+}
+IInfoQueue1_VTable :: struct {
+	using idxgiinfoqueue_vtable: IInfoQueue_VTable,
+	RegisterMessageCallback: proc "stdcall" (this: ^IInfoQueue1, CallbackFunc: PFN_MESSAGE_CALLBACK, CallbackFilterFlags: MESSAGE_CALLBACK_FLAGS, pContext: rawptr, pCallbackCookie: ^u32) -> HRESULT,
+	UnregisterMessageCallback: proc "stdcall" (this: ^IInfoQueue1, pCallbackCookie: u32) -> HRESULT,
+}
+
 PFN_CREATE_DEVICE :: #type proc "c" (a0: ^IUnknown, a1: FEATURE_LEVEL, a2: ^IID, a3: ^rawptr) -> HRESULT
 PFN_GET_DEBUG_INTERFACE :: #type proc "c" (a0: ^IID, a1: ^rawptr) -> HRESULT
 
@@ -4928,16 +4949,40 @@ IGraphicsCommandList6_VTable :: struct {
 	DispatchMesh: proc "stdcall" (this: ^IGraphicsCommandList6, ThreadGroupCountX: u32, ThreadGroupCountY: u32, ThreadGroupCountZ: u32),
 }
 
-SHADER_VERSION_TYPE :: enum i32 {
-	PIXEL_SHADER    = 0,
-	VERTEX_SHADER   = 1,
-	GEOMETRY_SHADER = 2,
+SHADER_VERSION_TYPE :: enum u32 {
+	PIXEL_SHADER          = 0,
+	VERTEX_SHADER         = 1,
+	GEOMETRY_SHADER       = 2,    
 
-	HULL_SHADER     = 3,
-	DOMAIN_SHADER   = 4,
-	COMPUTE_SHADER  = 5,
+	HULL_SHADER           = 3,
+	DOMAIN_SHADER         = 4,
+	COMPUTE_SHADER        = 5,
 
-	RESERVED0       = 65520,
+	LIBRARY               = 6,
+
+	RAY_GENERATION_SHADER = 7,
+	INTERSECTION_SHADER   = 8,
+	ANY_HIT_SHADER        = 9,
+	CLOSEST_HIT_SHADER    = 10,
+	MISS_SHADER           = 11,
+	CALLABLE_SHADER       = 12,
+
+	MESH_SHADER           = 13,
+	AMPLIFICATION_SHADER  = 14,
+
+	RESERVED0             = 0xFFF0,
+}
+
+shver_get_type :: proc "contextless" (version: u32) -> SHADER_VERSION_TYPE {
+	return SHADER_VERSION_TYPE((version >> 16) & 0xffff)
+}
+
+shver_get_major :: proc "contextless" (version: u32) -> u8 {
+	return u8((version >> 4) & 0xf)
+}
+
+shver_get_minor :: proc "contextless" (version: u32) -> u8 {
+	return u8((version >> 0) & 0xf)
 }
 
 SIGNATURE_PARAMETER_DESC :: struct {
@@ -4984,6 +5029,7 @@ SHADER_TYPE_DESC :: struct {
 	Offset:   u32,
 	Name:     cstring,
 }
+
 SHADER_DESC :: struct {
 	Version:                     u32,
 	Creator:                     cstring,
@@ -5042,6 +5088,39 @@ SHADER_INPUT_BIND_DESC :: struct {
 	uID:        u32,
 }
 
+SHADER_REQUIRES_FLAGS :: distinct bit_set[SHADER_REQUIRES; u64]
+SHADER_REQUIRES :: enum u64 {
+	DOUBLES                                                        = 0,
+	EARLY_DEPTH_STENCIL                                            = 1,
+	UAVS_AT_EVERY_STAGE                                            = 2,
+	_64_UAVS                                                       = 3,
+	MINIMUM_PRECISION                                              = 4,
+	_11_1_DOUBLE_EXTENSIONS                                        = 5,
+	_11_1_SHADER_EXTENSIONS                                        = 6,
+	LEVEL_9_COMPARISON_FILTERING                                   = 7,
+	TILED_RESOURCES                                                = 8,
+	STENCIL_REF                                                    = 9,
+	INNER_COVERAGE                                                 = 10,
+	TYPED_UAV_LOAD_ADDITIONAL_FORMATS                              = 11,
+	ROVS                                                           = 12,
+	VIEWPORT_AND_RT_ARRAY_INDEX_FROM_ANY_SHADER_FEEDING_RASTERIZER = 13,
+	WAVE_OPS                                                       = 14,
+	INT64_OPS                                                      = 15,
+	VIEW_ID                                                        = 16,
+	BARYCENTRICS                                                   = 17,
+	NATIVE_16BIT_OPS                                               = 18,
+	SHADING_RATE                                                   = 19,
+	RAYTRACING_TIER_1_1                                            = 20,
+	SAMPLER_FEEDBACK                                               = 21,
+	ATOMIC_INT64_ON_TYPED_RESOURCE                                 = 22,
+	ATOMIC_INT64_ON_GROUP_SHARED                                   = 23,
+	DERIVATIVES_IN_MESH_AND_AMPLIFICATION_SHADERS                  = 24,
+	RESOURCE_DESCRIPTOR_HEAP_INDEXING                              = 25,
+	SAMPLER_DESCRIPTOR_HEAP_INDEXING                               = 26,
+	WAVE_MMA                                                       = 27,
+	ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE                       = 28,
+}
+
 LIBRARY_DESC :: struct {
 	Creator:       cstring,
 	Flags:         u32,
@@ -5103,8 +5182,10 @@ PARAMETER_DESC :: struct {
 	FirstOutComponent: u32,
 }
 
+IShaderReflectionType_UUID_STRING :: "E913C351-783D-48CA-A1D1-4F306284AD56"
+IShaderReflectionType_UUID := &IID{0xE913C351, 0x783D, 0x48CA, {0xA1, 0xD1, 0x4F, 0x30, 0x62, 0x84, 0xAD, 0x56}}
 IShaderReflectionType :: struct {
-	vtable: ^IShaderReflectionType_VTable,
+	using id3d12shaderreflectiontype_vtable: ^IShaderReflectionType_VTable,
 }
 IShaderReflectionType_VTable :: struct {
 	GetDesc:              proc "stdcall" (this: ^IShaderReflectionType, pDesc: ^SHADER_TYPE_DESC) -> HRESULT,
@@ -5120,8 +5201,10 @@ IShaderReflectionType_VTable :: struct {
 	ImplementsInterface:  proc "stdcall" (this: ^IShaderReflectionType, pBase: ^IShaderReflectionType) -> HRESULT,
 }
 
+IShaderReflectionVariable_UUID_STRING :: "8337A8A6-A216-444A-B2F4-314733A73AEA"
+IShaderReflectionVariable_UUID := &IID{0x8337A8A6, 0xA216, 0x444A, {0xB2, 0xF4, 0x31, 0x47, 0x33, 0xA7, 0x3A, 0xEA}}
 IShaderReflectionVariable :: struct {
-	vtable: ^IShaderReflectionVariable_VTable,
+	using id3d12shaderreflectionvariable_vtable: ^IShaderReflectionVariable_VTable,
 }
 IShaderReflectionVariable_VTable :: struct {
 	GetDesc:          proc "stdcall" (this: ^IShaderReflectionVariable, pDesc: ^SHADER_VARIABLE_DESC) -> HRESULT,
@@ -5130,8 +5213,10 @@ IShaderReflectionVariable_VTable :: struct {
 	GetInterfaceSlot: proc "stdcall" (this: ^IShaderReflectionVariable, uArrayIndex: u32) -> u32,
 }
 
+IShaderReflectionConstantBuffer_UUID_STRING :: "C59598B4-48B3-4869-B9B1-B1618B14A8B7"
+IShaderReflectionConstantBuffer_UUID := &IID{0xC59598B4, 0x48B3, 0x4869, {0xB9, 0xB1, 0xB1, 0x61, 0x8B, 0x14, 0xA8, 0xB7}}
 IShaderReflectionConstantBuffer :: struct {
-	vtable: ^IShaderReflectionConstantBuffer_VTable,
+	using id3d12shaderreflectionconstantbuffer_vtable: ^IShaderReflectionConstantBuffer_VTable,
 }
 IShaderReflectionConstantBuffer_VTable :: struct {
 	GetDesc:            proc "stdcall" (this: ^IShaderReflectionConstantBuffer, pDesc: ^SHADER_BUFFER_DESC) -> HRESULT,
@@ -5139,6 +5224,8 @@ IShaderReflectionConstantBuffer_VTable :: struct {
 	GetVariableByName:  proc "stdcall" (this: ^IShaderReflectionConstantBuffer, Name: cstring) -> ^IShaderReflectionVariable,
 }
 
+IShaderReflection_UUID_STRING :: "5A58797D-A72C-478D-8BA2-EFC6B0EFE88E"
+IShaderReflection_UUID := &IID{0x5A58797D, 0xA72C, 0x478D, {0x8B, 0xA2, 0xEF, 0xC6, 0xB0, 0xEF, 0xE8, 0x8E}}
 IShaderReflection :: struct #raw_union {
 	#subtype iunknown: IUnknown,
 	using id3d12shaderreflection_vtable: ^IShaderReflection_VTable,
@@ -5163,9 +5250,11 @@ IShaderReflection_VTable :: struct {
 	GetNumInterfaceSlots:          proc "stdcall" (this: ^IShaderReflection) -> u32,
 	GetMinFeatureLevel:            proc "stdcall" (this: ^IShaderReflection, pLevel: ^FEATURE_LEVEL) -> HRESULT,
 	GetThreadGroupSize:            proc "stdcall" (this: ^IShaderReflection, pSizeX: ^u32, pSizeY: ^u32, pSizeZ: ^u32) -> u32,
-	GetRequiresFlags:              proc "stdcall" (this: ^IShaderReflection) -> u64,
+	GetRequiresFlags:              proc "stdcall" (this: ^IShaderReflection) -> SHADER_REQUIRES_FLAGS,
 }
 
+ILibraryReflection_UUID_STRING :: "8E349D19-54DB-4A56-9DC9-119D87BDB804"
+ILibraryReflection_UUID := &IID{0x8E349D19, 0x54DB, 0x4A56, {0x9D, 0xC9, 0x11, 0x9D, 0x87, 0xBD, 0xB8, 0x04}}
 ILibraryReflection :: struct #raw_union {
 	#subtype iunknown: IUnknown,
 	using id3d12libraryreflection_vtable: ^ILibraryReflection_VTable,
@@ -5176,8 +5265,10 @@ ILibraryReflection_VTable :: struct {
 	GetFunctionByIndex: proc "stdcall" (this: ^ILibraryReflection, FunctionIndex: i32) -> ^IFunctionReflection,
 }
 
+IFunctionReflection_UUID_STRING :: "1108795C-2772-4BA9-B2A8-D464DC7E2799"
+IFunctionReflection_UUID := &IID{0x1108795C, 0x2772, 0x4BA9, {0xB2, 0xA8, 0xD4, 0x64, 0xDC, 0x7E, 0x27, 0x99}}
 IFunctionReflection :: struct {
-	vtable: ^IFunctionReflection_VTable,
+	using id3d12functionreflection_vtable: ^IFunctionReflection_VTable,
 }
 IFunctionReflection_VTable :: struct {
 	GetDesc:                      proc "stdcall" (this: ^IFunctionReflection, pDesc: ^FUNCTION_DESC) -> HRESULT,
@@ -5189,8 +5280,10 @@ IFunctionReflection_VTable :: struct {
 	GetFunctionParameter:         proc "stdcall" (this: ^IFunctionReflection, ParameterIndex: i32) -> ^IFunctionParameterReflection,
 }
 
+IFunctionParameterReflection_UUID_STRING :: "EC25F42D-7006-4F2B-B33E-02CC3375733F"
+IFunctionParameterReflection_UUID := &IID{0xEC25F42D, 0x7006, 0x4F2B, {0xB3, 0x3E, 0x2, 0xCC, 0x33, 0x75, 0x73, 0x3F}}
 IFunctionParameterReflection :: struct {
-	vtable: ^IFunctionParameterReflection_VTable,
+	using id3d12functionparameterreflection_vtable: ^IFunctionParameterReflection_VTable,
 }
 IFunctionParameterReflection_VTable :: struct {
 	GetDesc: proc "stdcall" (this: ^IFunctionParameterReflection, pDesc: ^PARAMETER_DESC) -> HRESULT,

vendor/directx/dxc/dxcapi.odin

@@ -0,0 +1,603 @@
+package directx_dxc
+import win32 "core:sys/windows"
+import dxgi "vendor:directx/dxgi"
+foreign import "dxcompiler.lib"
+
+BOOL            :: dxgi.BOOL
+SIZE_T          :: dxgi.SIZE_T
+ULONG           :: dxgi.ULONG
+CLSID           :: dxgi.GUID
+IID             :: dxgi.IID
+HRESULT         :: dxgi.HRESULT
+IUnknown        :: dxgi.IUnknown
+IUnknown_VTable :: dxgi.IUnknown_VTable
+wstring         :: win32.wstring
+FILETIME        :: win32.FILETIME
+BSTR            :: wstring
+
+@(default_calling_convention="c", link_prefix="Dxc")
+foreign dxcompiler {
+	CreateInstance  :: proc (rclsid: ^CLSID, riid: ^IID, ppv: rawptr) -> HRESULT ---
+	CreateInstance2 :: proc (pMalloc: ^IMalloc, rclsid: ^CLSID, riid: ^IID, ppv: rawptr) -> HRESULT ---
+}
+
+pCreateInstanceProc  :: #type proc "c" (rclsid: ^CLSID, riid: ^IID, ppv: rawptr) -> HRESULT
+pCreateInstance2Proc :: #type proc "c" (pMalloc: ^IMalloc, rclsid: ^CLSID, riid: ^IID, ppv: rawptr) -> HRESULT
+
+CreateInstance_ProcName  :: "DxcCreateInstance"
+CreateInstance2_ProcName :: "DxcCreateInstance2"
+
+IMalloc :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using imalloc_vtable: ^IMalloc_VTable,
+}
+IMalloc_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	Alloc:          proc "stdcall" (this: ^IMalloc, cb: SIZE_T) -> rawptr,
+	Realloc:        proc "stdcall" (this: ^IMalloc, pv: rawptr, cb: SIZE_T) -> rawptr,
+	Free:           proc "stdcall" (this: ^IMalloc, pv: rawptr),
+	GetSize:        proc "stdcall" (this: ^IMalloc, pv: rawptr) -> SIZE_T,
+	DidAlloc:       proc "stdcall" (this: ^IMalloc, pv: rawptr) -> i32,
+	HeapMinimize:   proc "stdcall" (this: ^IMalloc),
+}
+
+ISequentialStream :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using isequentialstream_vtable: ^ISequentialStream_VTable,
+}
+ISequentialStream_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	Read:  proc "stdcall" (this: ^ISequentialStream, pv: rawptr, cb: ULONG, pcbRead: ^ULONG) -> HRESULT,
+	Write: proc "stdcall" (this: ^ISequentialStream, pv: rawptr, cb: ULONG, pcbWritten: ^ULONG) -> HRESULT,
+}
+
+STATSTG :: struct {
+	pwcsName:          wstring,
+	type:              u32,
+	cbSize:            u64,
+	mtime:             FILETIME,
+	ctime:             FILETIME,
+	atime:             FILETIME,
+	grfMode:           u32,
+	grfLocksSupported: u32,
+	clsid:             CLSID,
+	grfStateBits:      u32,
+	reserved:          u32,
+}
+
+IStream :: struct #raw_union {
+	#subtype isequentialstream: ISequentialStream,
+	using istream_vtable: ^IStream_VTable,
+}
+IStream_VTable :: struct {
+	using isequentialstream_vtable: ISequentialStream_VTable,
+	Seek:         proc "stdcall" (this: ^IStream, dlibMove: i64, dwOrigin: u32, plibNewPosition: ^u64) -> HRESULT,
+	SetSize:      proc "stdcall" (this: ^IStream, libNewSize: u64) -> HRESULT,
+	CopyTo:       proc "stdcall" (this: ^IStream, pstm: ^IStream, cb: u64, pcbRead: ^u64, pcbWritten: ^u64) -> HRESULT,
+	Commit:       proc "stdcall" (this: ^IStream, grfCommitFlags: u32) -> HRESULT,
+	Revert:       proc "stdcall" (this: ^IStream) -> HRESULT,
+	LockRegion:   proc "stdcall" (this: ^IStream, libOffset: u64, cb: u64, dwLockType: u32) -> HRESULT,
+	UnlockRegion: proc "stdcall" (this: ^IStream, libOffset: u64, cb: u64, dwLockType: u32) -> HRESULT,
+	Stat:         proc "stdcall" (this: ^IStream, pstatstg: ^STATSTG, grfStatFlag: u32) -> HRESULT,
+	Clone:        proc "stdcall" (this: ^IStream, ppstm: ^^IStream) -> HRESULT,
+}
+
+IBlob_UUID_STRING :: "8BA5FB08-5195-40E2-AC58-0D989C3A0102"
+IBlob_UUID := &IID{0x8BA5FB08, 0x5195, 0x40E2, {0xAC, 0x58, 0x0D, 0x98, 0x9C, 0x3A, 0x01, 0x02}}
+IBlob :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using id3d10blob_vtable: ^IBlob_VTable,
+}
+IBlob_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	GetBufferPointer: proc "stdcall" (this: ^IBlob) -> rawptr,
+	GetBufferSize:    proc "stdcall" (this: ^IBlob) -> SIZE_T,
+}
+
+IBlobEncoding_UUID_STRRING :: "7241D424-2646-4191-97C0-98E96E42FC68"
+IBlobEncoding_UUID := &IID{0x7241D424, 0x2646, 0x4191, {0x97, 0xC0, 0x98, 0xE9, 0x6E, 0x42, 0xFC, 0x68}}
+IBlobEncoding :: struct #raw_union {
+	#subtype idxcblob: IBlob,
+	using idxcblobencoding_vtable: ^IBlobEncoding_VTable,
+}
+IBlobEncoding_VTable :: struct {
+	using idxcblob_vtable: IBlob_VTable,
+	GetEncoding: proc "stdcall" (this: ^IBlobEncoding, pKnown: ^BOOL, pCodePage: ^u32) -> HRESULT,
+}
+
+IBlobUtf16_UUID_STRING :: "A3F84EAB-0FAA-497E-A39C-EE6ED60B2D84"
+IBlobUtf16_UUID := &IID{0xA3F84EAB, 0x0FAA, 0x497E, {0xA3, 0x9C, 0xEE, 0x6E, 0xD6, 0x0B, 0x2D, 0x84}}
+IBlobUtf16 :: struct #raw_union {
+	#subtype idxcblobencoding: IBlobEncoding,
+	using idxcblobutf16_vtable : ^IBlobUtf16_VTable,
+}
+IBlobUtf16_VTable :: struct {
+	using idxcblobencoding_vtable: IBlobEncoding_VTable,
+	GetStringPointer: proc "stdcall" (this: ^IBlobUtf16) -> wstring,
+	GetStringLength:  proc "stdcall" (this: ^IBlobUtf16) -> SIZE_T,
+}
+
+IBlobUtf8_UUID_STRING :: "3DA636C9-BA71-4024-A301-30CBF125305B"
+IBlobUtf8_UUID := &IID{0x3DA636C9, 0xBA71, 0x4024, {0xA3, 0x01, 0x30, 0xCB, 0xF1, 0x25, 0x30, 0x5B}}
+IBlobUtf8 :: struct #raw_union {
+	#subtype idxcblobencoding: IBlobEncoding,
+	using idxcblobutf8_vtable : ^IBlobUtf8_VTable,
+}
+IBlobUtf8_VTable :: struct {
+	using idxcblobencoding_vtable: IBlobEncoding_VTable,
+	GetStringPointer: proc "stdcall" (this: ^IBlobUtf8) -> cstring,
+	GetStringLength:  proc "stdcall" (this: ^IBlobUtf8) -> SIZE_T,
+}
+
+IIncludeHandler_UUID_STRING :: "7F61FC7D-950D-467F-B3E3-3C02FB49187C"
+IIncludeHandler_UUID := &IID{0x7F61FC7D, 0x950D, 0x467F, {0xB3, 0xE3, 0x3C, 0x02, 0xFB, 0x49, 0x18, 0x7C}}
+IIncludeHandler :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxcincludehandler_vtable: ^IIncludeHandler_VTable,
+}
+IIncludeHandler_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	LoadSource: proc "stdcall" (this: ^IIncludeHandler, pFilename: wstring, ppIncludeSource: ^^IBlob) -> HRESULT,
+}
+
+Define :: struct {
+	Name:  wstring,
+	Value: wstring,
+}
+
+ICompilerArgs_UUID_STRING :: "73EFFE2A-70DC-45F8-9690-EFF64C02429D"
+ICompilerArgs_UUID := &IID{0x73EFFE2A, 0x70DC, 0x45F8, {0x96, 0x90, 0xEF, 0xF6, 0x4C, 0x02, 0x42, 0x9D}}
+ICompilerArgs :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxccompilerargs_vtable: ^ICompilerArgs_VTable,
+}
+ICompilerArgs_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	GetArguments:       proc "stdcall" (this: ^ICompilerArgs) -> [^]wstring,
+	GetCount:           proc "stdcall" (this: ^ICompilerArgs) -> u32,
+	AddArguments:       proc "stdcall" (this: ^ICompilerArgs, pArguments: [^]wstring, argCount: u32) -> HRESULT,
+	AddArgumentsUTF8:   proc "stdcall" (this: ^ICompilerArgs, pArguments: [^]cstring, argCount: u32) -> HRESULT,
+	AddDefines:         proc "stdcall" (this: ^ICompilerArgs, pDefines: [^]Define, defineCount: u32) -> HRESULT,
+}
+
+ILibrary_UUID_STRING :: "E5204DC7-D18C-4C3C-BDFB-851673980FE7"
+ILibrary_UUID := &IID{0xE5204DC7, 0xD18C, 0x4C3C, {0xBD, 0xFB, 0x85, 0x16, 0x73, 0x98, 0x0F, 0xE7}}
+ILibrary :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxclibrary_vtable: ^ILibrary_VTable,
+}
+ILibrary_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	SetMalloc:                        proc "stdcall" (this: ^ILibrary, pMalloc: ^IMalloc) -> HRESULT,
+	CreateBlobFromBlob:               proc "stdcall" (this: ^ILibrary, pBlob: ^IBlob, offset: u32, length: u32, ppResult: ^^IBlob) -> HRESULT,
+	CreateBlobFromFile:               proc "stdcall" (this: ^ILibrary, pFileName: wstring, codePage: ^u32, pBlobEncoding: ^^IBlobEncoding) -> HRESULT,
+	CreateBlobWithEncodingFromPinned: proc "stdcall" (this: ^ILibrary, pText: rawptr, size: u32, codePage: u32, pBlobEncoding: ^^IBlobEncoding) -> HRESULT,
+	CreateBlobWithEncodingOnHeapCopy: proc "stdcall" (this: ^ILibrary, pText: rawptr, size: u32, codePage: u32, pBlobEncoding: ^^IBlobEncoding) -> HRESULT,
+	CreateBlobWithEncodingOnMalloc:   proc "stdcall" (this: ^ILibrary, pText: rawptr, pIMalloc: ^IMalloc, size: u32, codePage: u32, pBlobEncoding: ^^IBlobEncoding) -> HRESULT,
+	CreateIncludeHandler:             proc "stdcall" (this: ^ILibrary, ppResult: ^^IIncludeHandler) -> HRESULT,
+	CreateStreamFromBlobReadOnly:     proc "stdcall" (this: ^ILibrary, pBlob: ^IBlob, ppStream: ^^IStream) -> HRESULT,
+	GetBlobAsUtf8:                    proc "stdcall" (this: ^ILibrary, pBlob: ^IBlob, pBlobEncoding: ^^IBlobEncoding) -> HRESULT,
+	GetBlobAsUtf16:                   proc "stdcall" (this: ^ILibrary, pBlob: ^IBlob, pBlobEncoding: ^^IBlobEncoding) -> HRESULT,
+}
+
+IOperationResult_UUID_STRING :: "CEDB484A-D4E9-445A-B991-CA21CA157DC2"
+IOperationResult_UUID := &IID{0xCEDB484A, 0xD4E9, 0x445A, {0xB9, 0x91, 0xCA, 0x21, 0xCA, 0x15, 0x7D, 0xC2}}
+IOperationResult :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxcoperationresult_vtable: ^IOperationResult_VTable,
+}
+IOperationResult_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	GetStatus:      proc "stdcall" (this: ^IOperationResult, pStatus: ^HRESULT) -> HRESULT,
+	GetResult:      proc "stdcall" (this: ^IOperationResult, ppResult: ^^IBlob) -> HRESULT,
+	GetErrorBuffer: proc "stdcall" (this: ^IOperationResult, ppErrors: ^^IBlobEncoding) -> HRESULT,
+}
+
+ICompiler_UUID_STRING :: "8C210BF3-011F-4422-8D70-6F9ACB8DB617"
+ICompiler_UUID := &IID{0x8C210BF3, 0x011F, 0x4422, {0x8D, 0x70, 0x6F, 0x9A, 0xCB, 0x8D, 0xB6, 0x17}}
+ICompiler :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxccompiler_vtable: ^ICompiler_VTable,
+}
+ICompiler_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	Compile: proc "stdcall" (
+		this: ^ICompiler, 
+		pSource: ^Buffer, 
+		pSourceName: wstring,
+		pEntryPoint: wstring,
+		pTargetProfile: wstring,
+		pArguments: [^]wstring,
+		argCount: u32,
+		pDefines: [^]Define,
+		defineCount: u32,
+		pIncludeHandler: ^IIncludeHandler,
+		ppResult: ^^IOperationResult) -> HRESULT,
+	Preprocess: proc "stdcall" (
+		this: ^ICompiler, 
+		pSource: ^Buffer, 
+		pSourceName: wstring,
+		pArguments: [^]wstring,
+		argCount: u32,
+		pDefines: [^]Define,
+		defineCount: u32,
+		pIncludeHandler: ^IIncludeHandler,
+		ppResult: ^^IOperationResult) -> HRESULT,
+	Disassemble: proc "stdcall" (this: ^ICompiler, pSource: ^Buffer, ppDisassembly: ^IBlobEncoding) -> HRESULT,
+}
+
+ICompiler2_UUID_STRING :: "A005A9D9-B8BB-4594-B5C9-0E633BEC4D37"
+ICompiler2_UUID := &IID{0xA005A9D9, 0xB8BB, 0x4594, {0xB5, 0xC9, 0x0E, 0x63, 0x3B, 0xEC, 0x4D, 0x37}}
+ICompiler2 :: struct #raw_union {
+	#subtype icompiler: ICompiler,
+	using idxccompiler2_vtable: ^ICompiler2_VTable,
+}
+ICompiler2_VTable :: struct {
+	using idxccompiler_vtable: ^ICompiler_VTable,
+	CompileWithDebug: proc "stdcall" (
+		this: ^ICompiler2,
+		pSource: ^Buffer, 
+		pSourceName: wstring,
+		pEntryPoint: wstring,
+		pTargetProfile: wstring,
+		pArguments: [^]wstring,
+		argCount: u32,
+		pDefines: [^]Define,
+		defineCount: u32,
+		pIncludeHandler: ^IIncludeHandler,
+		ppResult: ^^IOperationResult,
+		ppDebugBlobName: ^wstring,
+		ppDebugBlob: ^^IBlob) -> HRESULT,
+}
+
+ILinker_UUID_STRING :: "F1B5BE2A-62DD-4327-A1C2-42AC1E1E78E6"
+ILinker_UUID := &IID{0xF1B5BE2A, 0x62DD, 0x4327, {0xA1, 0xC2, 0x42, 0xAC, 0x1E, 0x1E, 0x78, 0xE6}}
+ILinker :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxclinker_vtable: ^ILinker_VTable,
+}
+ILinker_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	RegisterLibrary: proc "stdcall" (this: ^ILinker, pLibName: ^IBlob) -> HRESULT,
+	Link: proc "stdcall" (
+		this: ^ILinker,
+		pEntryName: wstring,
+		pTargetProfile: wstring,
+		pLibNames: [^]wstring,
+		libCount: u32,
+		pArguments: [^]wstring,
+		argCount: u32,
+		ppResult: ^^IOperationResult) -> HRESULT,
+}
+
+Buffer :: struct {
+	Ptr:      rawptr,
+	Size:     SIZE_T,
+	Encoding: u32,
+}
+
+IUtils_UUID_STRING :: "4605C4CB-2019-492A-ADA4-65F20BB7D67F"
+IUtils_UUID := &IID{0x4605C4CB, 0x2019, 0x492A, {0xAD, 0xA4, 0x65, 0xF2, 0x0B, 0xB7, 0xD6, 0x7F}}
+IUtils :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxcutils_vtable: ^IUtils_VTable,
+}
+IUtils_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	CreateBlobFromBlob:           proc "stdcall" (this: ^IUtils, pBlob: ^IBlob, offset: u32, length: u32, ppResult: ^^IBlob) -> HRESULT,
+	CreateBlobFromPinned:         proc "stdcall" (this: ^IUtils, pData: rawptr, size: u32, codePage: u32, pBlobEncoding: ^^IBlobEncoding) -> HRESULT,
+	MoveToBlob:                   proc "stdcall" (this: ^IUtils, pData: rawptr, pIMalloc: ^IMalloc, size: u32, codePage: u32, pBlobEncoding: ^^IBlobEncoding) -> HRESULT,
+	CreateBlob:                   proc "stdcall" (this: ^IUtils, pData: rawptr, size: u32, codePage: u32, pBlobEncoding: ^^IBlobEncoding) -> HRESULT,
+	LoadFile:                     proc "stdcall" (this: ^IUtils, pFileName: wstring, pCodePage: ^u32, pBlobEncoding: ^^IBlobEncoding) -> HRESULT,
+	CreateReadOnlyStreamFromBlob: proc "stdcall" (this: ^IUtils, pBlob: ^IBlob, ppStream: ^^IStream) -> HRESULT,
+	CreateDefaultIncludeHandler:  proc "stdcall" (this: ^IUtils, ppResult: ^^IIncludeHandler) -> HRESULT,
+	GetBlobAsUtf8:                proc "stdcall" (this: ^IUtils, pBlob: ^IBlob, pBlobEncoding: ^^IBlobUtf8) -> HRESULT,
+	GetBlobAsUtf16:               proc "stdcall" (this: ^IUtils, pBlob: ^IBlob, pBlobEncoding: ^^IBlobUtf16) -> HRESULT,
+	GetDxilContainerPart:         proc "stdcall" (this: ^IUtils, pShader: ^Buffer, Part: u32, ppPartData: rawptr, pPartSizeInBytes: ^u32) -> HRESULT,
+	CreateReflection:             proc "stdcall" (this: ^IUtils, pData: ^Buffer, iid: ^IID, ppvReflection: rawptr) -> HRESULT,
+	BuildArguments:               proc "stdcall" (this: ^IUtils, pSourceName: wstring, pEntryPoint: wstring, pTargetProfile: wstring, pArguments: [^]wstring, argCount: u32, pDefines: [^]Define, defineCount: u32, ppArgs: ^[^]ICompilerArgs) -> HRESULT,
+	GetPDBContents:               proc "stdcall" (this: ^IUtils, pPDBBlob: ^IBlob, ppHash: ^^IBlob, ppContainer: ^^IBlob) -> HRESULT,
+}
+
+DXC_OUT_KIND :: enum u32 {
+	NONE            = 0,
+	OBJECT          = 1,
+	ERRORS          = 2,
+	PDB             = 3,
+	SHADER_HASH     = 4,
+	DISASSEMBLY     = 5,
+	HLSL            = 6,
+	TEXT            = 7,
+	REFLECTION      = 8,
+	ROOT_SIGNATURE  = 9,
+	EXTRA_OUTPUTS   = 10,
+	FORCE_DWORD     = 0xFFFFFFFF,
+}
+
+IResult_UUID_STRING :: "58346CDA-DDE7-4497-9461-6F87AF5E0659"
+IResult_UUID := &IID{0x58346CDA, 0xDDE7, 0x4497, {0x94, 0x61, 0x6F, 0x87, 0xAF, 0x5E, 0x06, 0x59}}
+IResult :: struct #raw_union {
+	#subtype idxcoperationresult: IOperationResult,
+	using idxcresult_vtable: ^IResult_VTable,
+}
+IResult_VTable :: struct {
+	using idxcoperationresult_vtable: IOperationResult_VTable,
+	HasOutput:        proc "stdcall" (this: ^IResult, dxcOutKind: DXC_OUT_KIND) -> BOOL,
+	GetOutput:        proc "stdcall" (this: ^IResult, dxcOutKind: DXC_OUT_KIND, iid: ^IID, ppvObject: rawptr, ppOutputName: ^^IBlobUtf16) -> HRESULT,
+	GetNumOutputs:    proc "stdcall" (this: ^IResult) -> u32,
+	GetOutputByIndex: proc "stdcall" (this: ^IResult, Index: u32) -> DXC_OUT_KIND,
+	PrimaryOutput:    proc "stdcall" (this: ^IResult) -> DXC_OUT_KIND,
+}
+
+IExtraOutputs_UUID_STRING :: "319B37A2-A5C2-494A-A5DE-4801B2FAF989"
+IExtraOutputs_UUID := &IID{0x319B37A2, 0xA5C2, 0x494A, {0xA5, 0xDE, 0x48, 0x01, 0xB2, 0xFA, 0xF9, 0x89}}
+IExtraOutputs :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxcextraoutputs_vtable: ^IExtraOutputs_VTable,
+}
+IExtraOutputs_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	GetOutputCount: proc "stdcall" (this: ^IExtraOutputs) -> u32,
+	GetOutput:      proc "stdcall" (this: ^IExtraOutputs, uIndex: u32, iid: ^IID, ppvObject: rawptr, ppOutputType: ^^IBlobUtf16, ppOutputName: ^^IBlobUtf16) -> HRESULT,
+}
+
+ICompiler3_UUID_STRING :: "228B4687-5A6A-4730-900C-9702B2203F54"
+ICompiler3_UUID := &IID{0x228B4687, 0x5A6A, 0x4730, {0x90, 0x0C, 0x97, 0x02, 0xB2, 0x20, 0x3F, 0x54}}
+ICompiler3 :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxccompiler3_vtable: ^ICompiler3_VTable,
+}
+ICompiler3_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	Compile:     proc "stdcall" (this: ^ICompiler3, pSource: ^Buffer, pArguments: [^]wstring, argCount: u32, pIncludeHandler: ^IIncludeHandler, riid: ^IID, ppResult: rawptr) -> HRESULT,
+	Disassemble: proc "stdcall" (this: ^ICompiler3, pObject: ^Buffer, riid: ^IID, ppResult: rawptr) -> HRESULT,
+}
+
+IValidator_UUID_STRING :: "A6E82BD2-1FD7-4826-9811-2857E797F49A"
+IValidator_UUID := &IID{0xA6E82BD2, 0x1FD7, 0x4826, {0x98, 0x11, 0x28, 0x57, 0xE7, 0x97, 0xF4, 0x9A}}
+IValidator :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxcvalidator_vtable: ^IValidator_VTable,
+}
+IValidator_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	Validate: proc "stdcall" (this: ^IValidator, pShader: ^IBlob, Flags: u32, ppResult: ^^IOperationResult) -> HRESULT,
+}
+
+IValidator2_UUID_STRING :: "458E1FD1-B1B2-4750-A6E1-9C10F03BED92"
+IValidator2_UUID := &IID{0x458E1FD1, 0xB1B2, 0x4750, {0xA6, 0xE1, 0x9C, 0x10, 0xF0, 0x3B, 0xED, 0x92}}
+IValidator2 :: struct #raw_union {
+	#subtype idxcvalidator: IValidator,
+	using idxcvalidator2_vtable: ^IValidator2_VTable,
+}
+IValidator2_VTable :: struct {
+	using idxcvalidator_vtable: IValidator_VTable,
+	ValidateWithDebug: proc "stdcall" (this: ^IValidator2, pShader: ^IBlob, Flags: u32, pOptDebugBitcode: ^Buffer, ppResult: ^^IOperationResult) -> HRESULT,
+}
+
+IContainerBuilder_UUID_STRING :: "334B1F50-2292-4B35-99A1-25588D8C17FE"
+IContainerBuilder_UUID := &IID{0x334B1F50, 0x2292, 0x4B35, {0x99, 0xA1, 0x25, 0x58, 0x8D, 0x8C, 0x17, 0xFE}}
+IContainerBuilder :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxccontainerbuilder_vtable: ^IContainerBuilder_VTable,
+}
+IContainerBuilder_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	Load:               proc "stdcall" (this: ^IContainerBuilder, pDxilContainerHeader: ^IBlob) -> HRESULT,
+	AddPart:            proc "stdcall" (this: ^IContainerBuilder, fourCC: u32, pSource: ^IBlob) -> HRESULT,
+	RemovePart:         proc "stdcall" (this: ^IContainerBuilder, fourCC: u32) -> HRESULT,
+	SerializeContainer: proc "stdcall" (this: ^IContainerBuilder, ppResult: ^^IOperationResult) -> HRESULT,
+}
+
+IAssembler_UUID_STRING :: "091F7A26-1C1F-4948-904B-E6E3A8A771D5"
+IAssembler_UUID := &IID{0x091F7A26, 0x1C1F, 0x4948, {0x90, 0x4B, 0xE6, 0xE3, 0xA8, 0xA7, 0x71, 0xD5}}
+IAssembler :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxcassembler_vtable: ^IAssembler_VTable,
+}
+IAssembler_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	AssembleToContainer: proc "stdcall" (this: ^IAssembler, pShader: ^IBlob, ppResult: ^^IOperationResult) -> HRESULT,
+}
+
+IContainerReflection_UUID_STRING :: "D2C21B26-8350-4BDC-976A-331CE6F4C54C"
+IContainerReflection_UUID := &IID{0xD2C21B26, 0x8350, 0x4BDC, {0x97, 0x6A, 0x33, 0x1C, 0xE6, 0xF4, 0xC5, 0x4C}}
+IContainerReflection :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxccontainerreflection_vtable: ^IContainerReflection_VTable,
+}
+IContainerReflection_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	Load:              proc "stdcall" (this: ^IContainerReflection, pContainer: ^IBlob) -> HRESULT,
+	GetPartCount:      proc "stdcall" (this: ^IContainerReflection, pResult: ^u32) -> HRESULT,
+	GetPartKind:       proc "stdcall" (this: ^IContainerReflection, idx: u32, pResult: ^u32) -> HRESULT,
+	GetPartContent:    proc "stdcall" (this: ^IContainerReflection, idx: u32, ppResult: ^^IBlob) -> HRESULT,
+	FindFirstPartKind: proc "stdcall" (this: ^IContainerReflection, kind: u32, pResult: ^u32) -> HRESULT,
+	GetPartReflection: proc "stdcall" (this: ^IContainerReflection, idx: u32, iid: ^IID, ppvObject: rawptr) -> HRESULT,
+}
+
+IOptimizerPass_UUID_STRING :: "AE2CD79F-CC22-453F-9B6B-B124E7A5204C"
+IOptimizerPass_UUID := &IID{0xAE2CD79F, 0xCC22, 0x453F, {0x9B, 0x6B, 0xB1, 0x24, 0xE7, 0xA5, 0x20, 0x4C}}
+IOptimizerPass :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxcoptimizerpass_vtable: ^IOptimizerPass_VTable,
+}
+IOptimizerPass_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	GetOptionName:           proc "stdcall" (this: ^IOptimizerPass, ppResult: ^wstring) -> HRESULT,
+	GetDescription:          proc "stdcall" (this: ^IOptimizerPass, ppResult: ^wstring) -> HRESULT,
+	GetOptionArgCount:       proc "stdcall" (this: ^IOptimizerPass, pCount: ^u32) -> HRESULT,
+	GetOptionArgName:        proc "stdcall" (this: ^IOptimizerPass, argIndex: u32, ppResult: ^wstring) -> HRESULT,
+	GetOptionArgDescription: proc "stdcall" (this: ^IOptimizerPass, argIndex: u32, ppResult: ^wstring) -> HRESULT,
+}
+
+IOptimizer_UUID_STRING :: "25740E2E-9CBA-401B-9119-4FB42F39F270"
+IOptimizer_UUID := &IID{0x25740E2E, 0x9CBA, 0x401B, {0x91, 0x19, 0x4F, 0xB4, 0x2F, 0x39, 0xF2, 0x70}}
+IOptimizer :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxcoptimizer_vtable: ^IOptimizer_VTable,
+}
+IOptimizer_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	GetAvailablePassCount: proc "stdcall" (this: ^IOptimizer, pCount: ^u32) -> HRESULT,
+	GetAvailablePass:      proc "stdcall" (this: ^IOptimizer, index: u32, ppResult: ^^IOptimizerPass) -> HRESULT,
+	RunOptimizer:          proc "stdcall" (this: ^IOptimizer, pBlob: ^IBlob, ppOptions: [^]wstring, optionCount: u32, pOutputModule: ^^IBlob, ppOutputText: ^^IBlobEncoding) -> HRESULT,
+}
+
+VersionInfoFlags :: enum u32 {
+	None     = 0,
+	Debug    = 1,
+	Internal = 2,
+}
+
+IVersionInfo_UUID_STRING :: "B04F5B50-2059-4F12-A8FF-A1E0CDE1CC7E"
+IVersionInfo_UUID := &IID{0xB04F5B50, 0x2059, 0x4F12, {0xA8, 0xFF, 0xA1, 0xE0, 0xCD, 0xE1, 0xCC, 0x7E}}
+IVersionInfo :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxcversioninfo_vtable: ^IVersionInfo_VTable,
+}
+IVersionInfo_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	GetVersion: proc "stdcall" (this: ^IVersionInfo, pMajor: ^u32, pMinor: ^u32) -> HRESULT,
+	GetFlags:   proc "stdcall" (this: ^IVersionInfo, pFlags: ^VersionInfoFlags) -> HRESULT,
+}
+
+IVersionInfo2_UUID_STRING :: "FB6904C4-42F0-4B62-9C46-983AF7DA7C83"
+IVersionInfo2_UUID := &IID{0xFB6904C4, 0x42F0, 0x4B62, {0x9C, 0x46, 0x98, 0x3A, 0xF7, 0xDA, 0x7C, 0x83}}
+IVersionInfo2 :: struct #raw_union {
+	#subtype idxcversioninfo: IVersionInfo,
+	using idxcversioninfo2_vtable: ^IVersionInfo2_VTable,
+}
+IVersionInfo2_VTable :: struct {
+	using idxcversioninfo_vtable: IVersionInfo_VTable,
+	GetCommitInfo: proc "stdcall" (this: ^IVersionInfo2, pCommitCount: ^u32, pCommitHash: ^[^]byte) -> HRESULT,
+}
+
+IVersionInfo3_UUID_STRING :: "5E13E843-9D25-473C-9AD2-03B2D0B44B1E"
+IVersionInfo3_UUID := &IID{0x5E13E843, 0x9D25, 0x473C, {0x9A, 0xD2, 0x03, 0xB2, 0xD0, 0xB4, 0x4B, 0x1E}}
+IVersionInfo3 :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxcversioninfo3_vtable: ^IVersionInfo3_VTable,
+}
+IVersionInfo3_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	GetCustomVersionString: proc "stdcall" (this: ^IVersionInfo3, pVersionString: ^cstring) -> HRESULT,
+}
+
+ArgPair :: struct {
+  pName:  wstring,
+  pValue: wstring,
+}
+
+IPdbUtils_UUID_STRING :: "E6C9647E-9D6A-4C3B-B94C-524B5A6C343D"
+IPdbUtils_UUID := &IID{0xE6C9647E, 0x9D6A, 0x4C3B, {0xB9, 0x4C, 0x52, 0x4B, 0x5A, 0x6C, 0x34, 0x3D}}
+IPdbUtils :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxcpdbutils_vtable: ^IPdbUtils_VTable,
+}
+IPdbUtils_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	Load:                  proc "stdcall" (this: ^IPdbUtils, pPdbOrDxil: ^IBlob) -> HRESULT,
+	GetSourceCount:        proc "stdcall" (this: ^IPdbUtils, pCount: ^u32) -> HRESULT,
+	GetSource:             proc "stdcall" (this: ^IPdbUtils, uIndex: u32, ppResult: ^^IBlobEncoding) -> HRESULT,
+	GetSourceName:         proc "stdcall" (this: ^IPdbUtils, uIndex: u32, pResult: ^BSTR) -> HRESULT,
+	GetFlagCount:          proc "stdcall" (this: ^IPdbUtils, pCount: ^u32) -> HRESULT,
+	GetFlag:               proc "stdcall" (this: ^IPdbUtils, uIndex: u32, pResult: ^BSTR) -> HRESULT,
+	GetArgCount:           proc "stdcall" (this: ^IPdbUtils, pCount: ^u32) -> HRESULT,
+	GetArg:                proc "stdcall" (this: ^IPdbUtils, uIndex: u32, pResult: ^BSTR) -> HRESULT,
+	GetArgPairCount:       proc "stdcall" (this: ^IPdbUtils, pCount: ^u32) -> HRESULT,
+	GetArgPair:            proc "stdcall" (this: ^IPdbUtils, uIndex: u32, pName: ^BSTR, pValue: ^BSTR) -> HRESULT,
+	GetDefineCount:        proc "stdcall" (this: ^IPdbUtils, pCount: ^u32) -> HRESULT,
+	GetDefine:             proc "stdcall" (this: ^IPdbUtils, uIndex: u32, pResult: ^BSTR) -> HRESULT,
+	GetTargetProfile:      proc "stdcall" (this: ^IPdbUtils, pResult: ^BSTR) -> HRESULT,
+	GetEntryPoint:         proc "stdcall" (this: ^IPdbUtils, pResult: ^BSTR) -> HRESULT,
+	GetMainFileName:       proc "stdcall" (this: ^IPdbUtils, pResult: ^BSTR) -> HRESULT,
+	GetHash:               proc "stdcall" (this: ^IPdbUtils, ppResult: ^^IBlob) -> HRESULT,
+	GetName:               proc "stdcall" (this: ^IPdbUtils, pResult: ^BSTR) -> HRESULT,
+	IsFullPDB:             proc "stdcall" (this: ^IPdbUtils) -> BOOL,
+	GetFullPDB:            proc "stdcall" (this: ^IPdbUtils, ppFullPDB: ^^IBlob) -> HRESULT,
+	GetVersionInfo:        proc "stdcall" (this: ^IPdbUtils, ppVersionInfo: ^^IVersionInfo) -> HRESULT,
+	SetCompiler:           proc "stdcall" (this: ^IPdbUtils, pCompiler: ^ICompiler3) -> HRESULT,
+	CompileForFullPDB:     proc "stdcall" (this: ^IPdbUtils, ppResult: ^^IResult) -> HRESULT,
+	OverrideArgs:          proc "stdcall" (this: ^IPdbUtils, pArgPairs: ^ArgPair, uNumArgPairs: u32) -> HRESULT,
+	OverrideRootSignature: proc "stdcall" (this: ^IPdbUtils, pRootSignature: wstring) -> HRESULT,
+}
+
+
+Compiler_CLSID_STRING :: "73E22D93-E6CE-47F3-B5BF-F0664F39C1B0"
+Compiler_CLSID := &CLSID{0x73E22D93, 0xE6CE, 0x47F3, {0xB5, 0xBF, 0xF0, 0x66, 0x4F, 0x39, 0xC1, 0xB0}}
+
+Linker_CLSID_STRING :: "EF6A8087-B0EA-4D56-9E45-D07E1A8B7806"
+Linker_CLSID := &CLSID{0xEF6A8087, 0xB0EA, 0x4D56, {0x9E, 0x45, 0xD0, 0x7E, 0x1A, 0x8B, 0x78, 0x6}}
+
+DiaDataSource_CLSID_STRING :: "CD1F6B73-2AB0-484D-8EDC-EBE7A43CA09F"
+DiaDataSource_CLSID := &CLSID{0xCD1F6B73, 0x2AB0, 0x484D, {0x8E, 0xDC, 0xEB, 0xE7, 0xA4, 0x3C, 0xA0, 0x9F}}
+
+CompilerArgs_CLSID_STRING :: "3E56AE82-224D-470F-A1A1-FE3016EE9F9D"
+CompilerArgs_CLSID := &CLSID{0x3E56AE82, 0x224D, 0x470F, {0xA1, 0xA1, 0xFE, 0x30, 0x16, 0xEE, 0x9F, 0x9D}}
+
+Library_CLSID_STRING :: "6245D6AF-66E0-48FD-80B4-4D271796748C"
+Library_CLSID := &CLSID{0x6245D6AF, 0x66E0, 0x48FD, {0x80, 0xB4, 0x4D, 0x27, 0x17, 0x96, 0x74, 0x8C}}
+
+Utils_CLSID_STRING :: Library_CLSID_STRING
+Utils_CLSID := Library_CLSID
+
+Validator_CLSID_STRING :: "8CA3E215-F728-4CF3-8CDD-88AF917587A1"
+Validator_CLSID := &CLSID{0x8CA3E215, 0xF728, 0x4CF3, {0x8C, 0xDD, 0x88, 0xAF, 0x91, 0x75, 0x87, 0xA1}}
+
+Assembler_CLSID_STRING :: "D728DB68-F903-4F80-94CD-DCCF76EC7151"
+Assembler_CLSID := &CLSID{0xD728DB68, 0xF903, 0x4F80, {0x94, 0xCD, 0xDC, 0xCF, 0x76, 0xEC, 0x71, 0x51}}
+
+ContainerReflection_CLSID_STRING :: "b9f54489-55b8-400c-ba3a-1675e4728b91"
+ContainerReflection_CLSID := &CLSID{0xB9F54489, 0x55B8, 0x400C, {0xBA, 0x3A, 0x16, 0x75, 0xE4, 0x72, 0x8B, 0x91}}
+
+Optimizer_CLSID_STRING :: "AE2CD79F-CC22-453F-9B6B-B124E7A5204C"
+Optimizer_CLSID := &CLSID{0xAE2CD79F, 0xCC22, 0x453F, {0x9B, 0x6B, 0xB1, 0x24, 0xE7, 0xA5, 0x20, 0x4C}}
+
+ContainerBuilder_CLSID_STRING :: "94134294-411f-4574-b4d0-8741e25240d2"
+ContainerBuilder_CLSID := &CLSID{0x94134294, 0x411F, 0x4574, {0xB4, 0xD0, 0x87, 0x41, 0xE2, 0x52, 0x40, 0xD2}}
+
+PdbUtils_CLSID_STRING :: "54621dfb-f2ce-457e-ae8c-ec355faeec7c"
+PdbUtils_CLSID := &CLSID{0x54621DFB, 0xF2CE, 0x457E, {0xAE, 0x8C, 0xEC, 0x35, 0x5F, 0xAE, 0xEC, 0x7C}}
+
+CP_UTF8  :: 65001
+CP_UTF16 :: 1200
+CP_ACP   :: 0
+
+make_fourcc :: proc "contextless" (ch0, ch1, ch2, ch3: u32) -> u32 {
+	return ch0 | (ch1 << 8) | (ch2 << 16) | (ch3 << 24)
+}
+
+PART_PDB                      :: u32('I') | (u32('L')<<8) | (u32('D')<<16) | (u32('B')<<24)
+PART_PDB_NAME                 :: u32('I') | (u32('L')<<8) | (u32('D')<<16) | (u32('N')<<24)
+PART_PRIVATE_DATA             :: u32('P') | (u32('R')<<8) | (u32('I')<<16) | (u32('V')<<24)
+PART_ROOT_SIGNATURE           :: u32('R') | (u32('T')<<8) | (u32('S')<<16) | (u32('0')<<24)
+PART_DXIL                     :: u32('D') | (u32('X')<<8) | (u32('I')<<16) | (u32('L')<<24)
+PART_REFLECTION_DATA          :: u32('S') | (u32('T')<<8) | (u32('A')<<16) | (u32('T')<<24)
+PART_SHADER_HASH              :: u32('H') | (u32('A')<<8) | (u32('S')<<16) | (u32('H')<<24)
+PART_INPUT_SIGNATURE          :: u32('I') | (u32('S')<<8) | (u32('G')<<16) | (u32('1')<<24)
+PART_OUTPUT_SIGNATURE         :: u32('O') | (u32('S')<<8) | (u32('G')<<16) | (u32('1')<<24)
+PART_PATCH_CONSTANT_SIGNATURE :: u32('P') | (u32('S')<<8) | (u32('G')<<16) | (u32('1')<<24)
+
+ARG_DEBUG                           :: "-Zi"
+ARG_SKIP_VALIDATION                 :: "-Vd"
+ARG_SKIP_OPTIMIZATIONS              :: "-Od"
+ARG_PACK_MATRIX_ROW_MAJOR           :: "-Zpr"
+ARG_PACK_MATRIX_COLUMN_MAJOR        :: "-Zpc"
+ARG_AVOID_FLOW_CONTROL              :: "-Gfa"
+ARG_PREFER_FLOW_CONTROL             :: "-Gfp"
+ARG_ENABLE_STRICTNESS               :: "-Ges"
+ARG_ENABLE_BACKWARDS_COMPATIBILITY  :: "-Gec"
+ARG_IEEE_STRICTNESS                 :: "-Gis"
+ARG_OPTIMIZATION_LEVEL0             :: "-O0"
+ARG_OPTIMIZATION_LEVEL1             :: "-O1"
+ARG_OPTIMIZATION_LEVEL2             :: "-O2"
+ARG_OPTIMIZATION_LEVEL3             :: "-O3"
+ARG_WARNINGS_ARE_ERRORS             :: "-WX"
+ARG_RESOURCES_MAY_ALIAS             :: "-res_may_alias"
+ARG_ALL_RESOURCES_BOUND             :: "-all_resources_bound"
+ARG_DEBUG_NAME_FOR_SOURCE           :: "-Zss"
+ARG_DEBUG_NAME_FOR_BINARY           :: "-Zsb"
+
+EXTRA_OUTPUT_NAME_STDOUT :: "*stdout*"
+EXTRA_OUTPUT_NAME_STDERR :: "*stderr*"

vendor/directx/dxgi/dxgi.odin

@@ -375,7 +375,7 @@ MAPPED_RECT :: struct {
 }
 
 ADAPTER_DESC :: struct {
-	Description:           [128]i16,
+	Description:           [128]u16 `fmt:"s,0"`,
 	VendorId:              u32,
 	DeviceId:              u32,
 	SubSysId:              u32,
@@ -387,7 +387,7 @@ ADAPTER_DESC :: struct {
 }
 
 OUTPUT_DESC :: struct {
-	DeviceName:         [32]i16,
+	DeviceName:         [32]u16 `fmt:"s,0"`,
 	DesktopCoordinates: RECT,
 	AttachedToDesktop:  BOOL,
 	Rotation:           MODE_ROTATION,
@@ -613,7 +613,7 @@ ADAPTER_FLAG :: enum u32 { // TODO: convert to bit_set
 }
 
 ADAPTER_DESC1 :: struct {
-	Description:           [128]i16,
+	Description:           [128]u16 `fmt:"s,0"`,
 	VendorId:              u32,
 	DeviceId:              u32,
 	SubSysId:              u32,
@@ -890,7 +890,7 @@ COMPUTE_PREEMPTION_GRANULARITY :: enum i32 {
 }
 
 ADAPTER_DESC2 :: struct {
-	Description:                   [128]i16,
+	Description:                   [128]u16 `fmt:"s,0"`,
 	VendorId:                      u32,
 	DeviceId:                      u32,
 	SubSysId:                      u32,

vendor/directx/dxgi/dxgidebug.odin

@@ -0,0 +1,141 @@
+package directx_dxgi
+
+import win32 "core:sys/windows"
+import "core:c"
+
+DEBUG_RLO_FLAGS :: enum u32 { // TODO: convert to bit_set
+	SUMMARY	        = 0x1,
+	DETAIL	        = 0x2,
+	IGNORE_INTERNAL	= 0x4,
+	ALL	            = 0x7,
+}
+
+UINT :: win32.UINT
+UINT64 :: win32.UINT64
+LPCSTR :: win32.LPCSTR
+DEBUG_ID :: win32.GUID
+INFO_QUEUE_MESSAGE_ID :: i32
+
+DEBUG_ALL  := DEBUG_ID{0xe48ae283, 0xda80, 0x490b, {0x87, 0xe6, 0x43, 0xe9, 0xa9, 0xcf, 0xda, 0x8}}
+DEBUG_DX   := DEBUG_ID{0x35cdd7fc, 0x13b2, 0x421d, {0xa5, 0xd7, 0x7e, 0x44, 0x51, 0x28, 0x7d, 0x64}}
+DEBUG_DXGI := DEBUG_ID{0x25cddaa4, 0xb1c6, 0x47e1, {0xac, 0x3e, 0x98, 0x87, 0x5b, 0x5a, 0x2e, 0x2a}}
+DEBUG_APP  := DEBUG_ID{0x6cd6e01, 0x4219, 0x4ebd, {0x87, 0x9, 0x27, 0xed, 0x23, 0x36, 0xc, 0x62}}
+
+INFO_QUEUE_MESSAGE_CATEGORY :: enum u32 {
+	UNKNOWN                 = 0,
+	MISCELLANEOUS	        = UNKNOWN + 1,
+	INITIALIZATION	        = MISCELLANEOUS + 1,
+	CLEANUP                 = INITIALIZATION + 1,
+	COMPILATION	            = CLEANUP + 1,
+	STATE_CREATION          = COMPILATION + 1,
+	STATE_SETTING           = STATE_CREATION + 1,
+	STATE_GETTING           = STATE_SETTING + 1,
+	RESOURCE_MANIPULATION	= STATE_GETTING + 1,
+	EXECUTION               = RESOURCE_MANIPULATION + 1,
+	SHADER                  = EXECUTION + 1,
+}
+
+INFO_QUEUE_MESSAGE_SEVERITY :: enum u32 {
+	CORRUPTION = 0,
+	ERROR      = CORRUPTION + 1,
+	WARNING    = ERROR + 1,
+	INFO       = WARNING + 1,
+	MESSAGE    = INFO + 1,
+}
+
+INFO_QUEUE_MESSAGE :: struct {
+	Producer:              DEBUG_ID,
+	Category:              INFO_QUEUE_MESSAGE_CATEGORY,
+	Severity:              INFO_QUEUE_MESSAGE_SEVERITY,
+	ID:                    INFO_QUEUE_MESSAGE_ID,
+	pDescription:          [^]c.char,
+	DescriptionByteLength: SIZE_T,
+}
+
+INFO_QUEUE_FILTER_DESC :: struct {
+	NumCategories: UINT,
+	pCategoryList: [^]INFO_QUEUE_MESSAGE_CATEGORY,
+	NumSeverities: UINT,
+	pSeverityList: [^]INFO_QUEUE_MESSAGE_SEVERITY,
+	NumIDs:        UINT,
+	pIDList:       [^]INFO_QUEUE_MESSAGE_ID,
+}
+
+INFO_QUEUE_FILTER :: struct {
+	AllowList: INFO_QUEUE_FILTER_DESC,
+	DenyList:  INFO_QUEUE_FILTER_DESC,
+}
+
+INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT :: 1024
+
+
+IInfoQueue_UUID_STRING :: "D67441C7-672A-476f-9E82-CD55B44949CE"
+IInfoQueue_UUID := &IID{0xD67441C7, 0x672A, 0x476f, {0x9E, 0x82, 0xCD, 0x55, 0xB4, 0x49, 0x49, 0xCE}}
+IInfoQueue :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxgiinfoqueue_vtable: ^IInfoQueue_VTable,
+}
+IInfoQueue_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	SetMessageCountLimit:                          proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, MessageCountLimit: UINT64) -> HRESULT,
+	ClearStoredMessages:                           proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID),
+	GetMessage:                                    proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, MessageIndex: UINT64, pMessage: ^INFO_QUEUE_MESSAGE, pMessageByteLength: ^SIZE_T) -> HRESULT,
+	GetNumStoredMessagesAllowedByRetrievalFilters: proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID) -> UINT64,
+	GetNumStoredMessages:                          proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID) -> UINT64,
+	GetNumMessagesDiscardedByMessageCountLimit:    proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID) -> UINT64,
+	GetMessageCountLimit:                          proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID) -> UINT64,
+	GetNumMessagesAllowedByStorageFilter:          proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID) -> UINT64,
+	GetNumMessagesDeniedByStorageFilter:           proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID) -> UINT64,
+	AddStorageFilterEntries:                       proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, pFilter: INFO_QUEUE_FILTER) -> HRESULT,
+	GetStorageFilter:                              proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, pFilter: ^INFO_QUEUE_FILTER, pFilterByteLength: ^SIZE_T) -> HRESULT,
+	ClearStorageFilter:                            proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID),
+	PushEmptyStorageFilter:                        proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID) -> HRESULT,
+	PushDenyAllStorageFilter:                      proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID) -> HRESULT,
+	PushCopyOfStorageFilter:                       proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID) -> HRESULT,
+	PushStorageFilter:                             proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, pFilter: ^INFO_QUEUE_FILTER) -> HRESULT,
+	PopStorageFilter:                              proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID),
+	GetStorageFilterStackSize:                     proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID) -> UINT,
+	AddRetrievalFilterEntries:                     proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, pFilter: ^INFO_QUEUE_FILTER) -> HRESULT,
+	GetRetrievalFilter:                            proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, pFilter: ^INFO_QUEUE_FILTER, pFilterByteLength: ^SIZE_T) -> HRESULT,
+	ClearRetrievalFilter:                          proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID),
+	PushEmptyRetrievalFilter:                      proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID) -> HRESULT,
+	PushDenyAllRetrievalFilter:                    proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID) -> HRESULT,
+	PushCopyOfRetrievalFilter:                     proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID) -> HRESULT,
+	PushRetrievalFilter:                           proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, pFilter: ^INFO_QUEUE_FILTER) -> HRESULT,
+	PopRetrievalFilter:                            proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID),
+	GetRetrievalFilterStackSize:                   proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID) -> UINT,
+	AddMessage:                                    proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, Category: INFO_QUEUE_MESSAGE_CATEGORY, Severity: INFO_QUEUE_MESSAGE_SEVERITY, ID: INFO_QUEUE_MESSAGE_ID, pDescription: LPCSTR) -> HRESULT,
+	AddApplicationMessage:                         proc "stdcall" (this: ^IInfoQueue, Severity: INFO_QUEUE_MESSAGE_SEVERITY, pDescription: LPCSTR) -> HRESULT,
+	SetBreakOnCategory:                            proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, Category: INFO_QUEUE_MESSAGE_CATEGORY, bEnable: BOOL) -> HRESULT,
+	SetBreakOnSeverity:                            proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, Severity: INFO_QUEUE_MESSAGE_SEVERITY, bEnable: BOOL) -> HRESULT,
+	SetBreakOnID:                                  proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, ID: INFO_QUEUE_MESSAGE_ID, bEnable: BOOL) -> HRESULT,
+	GetBreakOnCategory:                            proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, Category: INFO_QUEUE_MESSAGE_CATEGORY) -> BOOL,
+	GetBreakOnSeverity:                            proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, Severity: INFO_QUEUE_MESSAGE_SEVERITY) -> BOOL,
+	GetBreakOnID:                                  proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, ID: INFO_QUEUE_MESSAGE_ID) -> BOOL,
+	SetMuteDebugOutput:                            proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID, bMute: BOOL),
+	GetMuteDebugOutput:                            proc "stdcall" (this: ^IInfoQueue, Producer: DEBUG_ID) -> BOOL,
+}
+
+IDebug_UUID_STRING :: "119E7452-DE9E-40fe-8806-88F90C12B441"
+IDebug_UUID := &IID{0x119E7452, 0xDE9E, 0x40fe, {0x88, 0x06, 0x88, 0xF9, 0x0C, 0x12, 0xB4, 0x41}}
+IDebug :: struct #raw_union {
+	#subtype iunknown: IUnknown,
+	using idxgidebug_vtable: ^IDebug_VTable,
+}
+IDebug_VTable :: struct {
+	using iunknown_vtable: IUnknown_VTable,
+	ReportLiveObjects: proc "stdcall" (this: ^IDebug, apiid: GUID, flags: DEBUG_RLO_FLAGS),
+}
+
+IDebug1_UUID_STRING :: "c5a05f0c-16f2-4adf-9f4d-a8c4d58ac550"
+IDebug1_UUID := &IID{0xc5a05f0c, 0x16f2, 0x4adf, {0x9f, 0x4d, 0xa8, 0xc4, 0xd5, 0x8a, 0xc5, 0x50}}
+IDebug1 :: struct #raw_union {
+	#subtype idxgidebug: IDebug,
+	using idxgidebug1_vtable: ^IDebug1_VTable,
+}
+IDebug1_VTable :: struct {
+	using idxgidebug_vtable: IDebug_VTable,
+	EnableLeakTrackingForThread:    proc "stdcall" (this: ^IDebug1),
+	DisableLeakTrackingForThread:   proc "stdcall" (this: ^IDebug1),
+	IsLeakTrackingEnabledForThread: proc "stdcall" (this: ^IDebug1) -> BOOL,
+}

vendor/glfw/bindings/bindings.odin

@@ -3,13 +3,24 @@ package glfw_bindings
 import "core:c"
 import vk "vendor:vulkan"
 
+GLFW_DYNAMIC :: #config(GLFW_DYNAMIC, false)
+
 when ODIN_OS == .Windows {
-	foreign import glfw { 
-		"../lib/glfw3_mt.lib",
-		"system:user32.lib", 
-		"system:gdi32.lib", 
-		"system:shell32.lib",
-	} 
+	when GLFW_DYNAMIC {
+		foreign import glfw {
+			"../lib/glfw3dll.lib",
+			"system:user32.lib", 
+			"system:gdi32.lib", 
+			"system:shell32.lib",
+		}
+	} else {
+		foreign import glfw {
+			"../lib/glfw3_mt.lib",
+			"system:user32.lib",
+			"system:gdi32.lib",
+			"system:shell32.lib",
+		}
+	}
 } else when ODIN_OS == .Linux {
 	// TODO: Add the billion-or-so static libs to link to in linux
 	foreign import glfw "system:glfw"

vendor/glfw/constants.odin

@@ -1,5 +1,8 @@
 package glfw
 
+/* Config */
+GLFW_DYNAMIC :: #config(GLFW_DYNAMIC, false)
+
 /*** Constants ***/
 /* Versions */
 VERSION_MAJOR    :: 3

vendor/glfw/native_windows.odin

@@ -4,7 +4,11 @@ package glfw
 
 import win32 "core:sys/windows"
 
-foreign import glfw { "lib/glfw3_mt.lib", "system:user32.lib", "system:gdi32.lib", "system:shell32.lib" }
+when GLFW_DYNAMIC {
+    foreign import glfw { "lib/glfw3dll.lib", "system:user32.lib", "system:gdi32.lib", "system:shell32.lib" }
+} else {
+    foreign import glfw { "lib/glfw3_mt.lib", "system:user32.lib", "system:gdi32.lib", "system:shell32.lib" }
+}
 
 @(default_calling_convention="c", link_prefix="glfw")
 foreign glfw {

vendor/lua/5.1/include/lauxlib.h

@@ -0,0 +1,174 @@
+/*
+** $Id: lauxlib.h,v 1.88.1.1 2007/12/27 13:02:25 roberto Exp $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lauxlib_h
+#define lauxlib_h
+
+
+#include <stddef.h>
+#include <stdio.h>
+
+#include "lua.h"
+
+
+#if defined(LUA_COMPAT_GETN)
+LUALIB_API int (luaL_getn) (lua_State *L, int t);
+LUALIB_API void (luaL_setn) (lua_State *L, int t, int n);
+#else
+#define luaL_getn(L,i)          ((int)lua_objlen(L, i))
+#define luaL_setn(L,i,j)        ((void)0)  /* no op! */
+#endif
+
+#if defined(LUA_COMPAT_OPENLIB)
+#define luaI_openlib	luaL_openlib
+#endif
+
+
+/* extra error code for `luaL_load' */
+#define LUA_ERRFILE     (LUA_ERRERR+1)
+
+
+typedef struct luaL_Reg {
+  const char *name;
+  lua_CFunction func;
+} luaL_Reg;
+
+
+
+LUALIB_API void (luaI_openlib) (lua_State *L, const char *libname,
+                                const luaL_Reg *l, int nup);
+LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
+                                const luaL_Reg *l);
+LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_typerror) (lua_State *L, int narg, const char *tname);
+LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
+                                                          size_t *l);
+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
+                                          const char *def, size_t *l);
+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
+
+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
+                                          lua_Integer def);
+
+LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
+LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
+LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
+
+LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
+LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
+
+LUALIB_API void (luaL_where) (lua_State *L, int lvl);
+LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
+
+LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
+                                   const char *const lst[]);
+
+LUALIB_API int (luaL_ref) (lua_State *L, int t);
+LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
+
+LUALIB_API int (luaL_loadfile) (lua_State *L, const char *filename);
+LUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz,
+                                  const char *name);
+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
+
+LUALIB_API lua_State *(luaL_newstate) (void);
+
+
+LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
+                                                  const char *r);
+
+LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx,
+                                         const char *fname, int szhint);
+
+
+
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define luaL_argcheck(L, cond,numarg,extramsg)	\
+		((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
+#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
+#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
+#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
+#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
+
+#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
+
+#define luaL_dofile(L, fn) \
+	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_dostring(L, s) \
+	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))
+
+#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+
+
+typedef struct luaL_Buffer {
+  char *p;			/* current position in buffer */
+  int lvl;  /* number of strings in the stack (level) */
+  lua_State *L;
+  char buffer[LUAL_BUFFERSIZE];
+} luaL_Buffer;
+
+#define luaL_addchar(B,c) \
+  ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \
+   (*(B)->p++ = (char)(c)))
+
+/* compatibility only */
+#define luaL_putchar(B,c)	luaL_addchar(B,c)
+
+#define luaL_addsize(B,n)	((B)->p += (n))
+
+LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
+LUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B);
+LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
+LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
+LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
+
+
+/* }====================================================== */
+
+
+/* compatibility with ref system */
+
+/* pre-defined references */
+#define LUA_NOREF       (-2)
+#define LUA_REFNIL      (-1)
+
+#define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \
+      (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0))
+
+#define lua_unref(L,ref)        luaL_unref(L, LUA_REGISTRYINDEX, (ref))
+
+#define lua_getref(L,ref)       lua_rawgeti(L, LUA_REGISTRYINDEX, (ref))
+
+
+#define luaL_reg	luaL_Reg
+
+#endif
+
+

vendor/lua/5.1/include/lua.h

@@ -0,0 +1,388 @@
+/*
+** $Id: lua.h,v 1.218.1.7 2012/01/13 20:36:20 roberto Exp $
+** Lua - An Extensible Extension Language
+** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
+** See Copyright Notice at the end of this file
+*/
+
+
+#ifndef lua_h
+#define lua_h
+
+#include <stdarg.h>
+#include <stddef.h>
+
+
+#include "luaconf.h"
+
+
+#define LUA_VERSION	"Lua 5.1"
+#define LUA_RELEASE	"Lua 5.1.5"
+#define LUA_VERSION_NUM	501
+#define LUA_COPYRIGHT	"Copyright (C) 1994-2012 Lua.org, PUC-Rio"
+#define LUA_AUTHORS 	"R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
+
+
+/* mark for precompiled code (`<esc>Lua') */
+#define	LUA_SIGNATURE	"\033Lua"
+
+/* option for multiple returns in `lua_pcall' and `lua_call' */
+#define LUA_MULTRET	(-1)
+
+
+/*
+** pseudo-indices
+*/
+#define LUA_REGISTRYINDEX	(-10000)
+#define LUA_ENVIRONINDEX	(-10001)
+#define LUA_GLOBALSINDEX	(-10002)
+#define lua_upvalueindex(i)	(LUA_GLOBALSINDEX-(i))
+
+
+/* thread status; 0 is OK */
+#define LUA_YIELD	1
+#define LUA_ERRRUN	2
+#define LUA_ERRSYNTAX	3
+#define LUA_ERRMEM	4
+#define LUA_ERRERR	5
+
+
+typedef struct lua_State lua_State;
+
+typedef int (*lua_CFunction) (lua_State *L);
+
+
+/*
+** functions that read/write blocks when loading/dumping Lua chunks
+*/
+typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
+
+typedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud);
+
+
+/*
+** prototype for memory-allocation functions
+*/
+typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
+
+
+/*
+** basic types
+*/
+#define LUA_TNONE		(-1)
+
+#define LUA_TNIL		0
+#define LUA_TBOOLEAN		1
+#define LUA_TLIGHTUSERDATA	2
+#define LUA_TNUMBER		3
+#define LUA_TSTRING		4
+#define LUA_TTABLE		5
+#define LUA_TFUNCTION		6
+#define LUA_TUSERDATA		7
+#define LUA_TTHREAD		8
+
+
+
+/* minimum Lua stack available to a C function */
+#define LUA_MINSTACK	20
+
+
+/*
+** generic extra include file
+*/
+#if defined(LUA_USER_H)
+#include LUA_USER_H
+#endif
+
+
+/* type of numbers in Lua */
+typedef LUA_NUMBER lua_Number;
+
+
+/* type for integer functions */
+typedef LUA_INTEGER lua_Integer;
+
+
+
+/*
+** state manipulation
+*/
+LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
+LUA_API void       (lua_close) (lua_State *L);
+LUA_API lua_State *(lua_newthread) (lua_State *L);
+
+LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
+
+
+/*
+** basic stack manipulation
+*/
+LUA_API int   (lua_gettop) (lua_State *L);
+LUA_API void  (lua_settop) (lua_State *L, int idx);
+LUA_API void  (lua_pushvalue) (lua_State *L, int idx);
+LUA_API void  (lua_remove) (lua_State *L, int idx);
+LUA_API void  (lua_insert) (lua_State *L, int idx);
+LUA_API void  (lua_replace) (lua_State *L, int idx);
+LUA_API int   (lua_checkstack) (lua_State *L, int sz);
+
+LUA_API void  (lua_xmove) (lua_State *from, lua_State *to, int n);
+
+
+/*
+** access functions (stack -> C)
+*/
+
+LUA_API int             (lua_isnumber) (lua_State *L, int idx);
+LUA_API int             (lua_isstring) (lua_State *L, int idx);
+LUA_API int             (lua_iscfunction) (lua_State *L, int idx);
+LUA_API int             (lua_isuserdata) (lua_State *L, int idx);
+LUA_API int             (lua_type) (lua_State *L, int idx);
+LUA_API const char     *(lua_typename) (lua_State *L, int tp);
+
+LUA_API int            (lua_equal) (lua_State *L, int idx1, int idx2);
+LUA_API int            (lua_rawequal) (lua_State *L, int idx1, int idx2);
+LUA_API int            (lua_lessthan) (lua_State *L, int idx1, int idx2);
+
+LUA_API lua_Number      (lua_tonumber) (lua_State *L, int idx);
+LUA_API lua_Integer     (lua_tointeger) (lua_State *L, int idx);
+LUA_API int             (lua_toboolean) (lua_State *L, int idx);
+LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
+LUA_API size_t          (lua_objlen) (lua_State *L, int idx);
+LUA_API lua_CFunction   (lua_tocfunction) (lua_State *L, int idx);
+LUA_API void	       *(lua_touserdata) (lua_State *L, int idx);
+LUA_API lua_State      *(lua_tothread) (lua_State *L, int idx);
+LUA_API const void     *(lua_topointer) (lua_State *L, int idx);
+
+
+/*
+** push functions (C -> stack)
+*/
+LUA_API void  (lua_pushnil) (lua_State *L);
+LUA_API void  (lua_pushnumber) (lua_State *L, lua_Number n);
+LUA_API void  (lua_pushinteger) (lua_State *L, lua_Integer n);
+LUA_API void  (lua_pushlstring) (lua_State *L, const char *s, size_t l);
+LUA_API void  (lua_pushstring) (lua_State *L, const char *s);
+LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
+                                                      va_list argp);
+LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
+LUA_API void  (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
+LUA_API void  (lua_pushboolean) (lua_State *L, int b);
+LUA_API void  (lua_pushlightuserdata) (lua_State *L, void *p);
+LUA_API int   (lua_pushthread) (lua_State *L);
+
+
+/*
+** get functions (Lua -> stack)
+*/
+LUA_API void  (lua_gettable) (lua_State *L, int idx);
+LUA_API void  (lua_getfield) (lua_State *L, int idx, const char *k);
+LUA_API void  (lua_rawget) (lua_State *L, int idx);
+LUA_API void  (lua_rawgeti) (lua_State *L, int idx, int n);
+LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
+LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
+LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
+LUA_API void  (lua_getfenv) (lua_State *L, int idx);
+
+
+/*
+** set functions (stack -> Lua)
+*/
+LUA_API void  (lua_settable) (lua_State *L, int idx);
+LUA_API void  (lua_setfield) (lua_State *L, int idx, const char *k);
+LUA_API void  (lua_rawset) (lua_State *L, int idx);
+LUA_API void  (lua_rawseti) (lua_State *L, int idx, int n);
+LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
+LUA_API int   (lua_setfenv) (lua_State *L, int idx);
+
+
+/*
+** `load' and `call' functions (load and run Lua code)
+*/
+LUA_API void  (lua_call) (lua_State *L, int nargs, int nresults);
+LUA_API int   (lua_pcall) (lua_State *L, int nargs, int nresults, int errfunc);
+LUA_API int   (lua_cpcall) (lua_State *L, lua_CFunction func, void *ud);
+LUA_API int   (lua_load) (lua_State *L, lua_Reader reader, void *dt,
+                                        const char *chunkname);
+
+LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);
+
+
+/*
+** coroutine functions
+*/
+LUA_API int  (lua_yield) (lua_State *L, int nresults);
+LUA_API int  (lua_resume) (lua_State *L, int narg);
+LUA_API int  (lua_status) (lua_State *L);
+
+/*
+** garbage-collection function and options
+*/
+
+#define LUA_GCSTOP		0
+#define LUA_GCRESTART		1
+#define LUA_GCCOLLECT		2
+#define LUA_GCCOUNT		3
+#define LUA_GCCOUNTB		4
+#define LUA_GCSTEP		5
+#define LUA_GCSETPAUSE		6
+#define LUA_GCSETSTEPMUL	7
+
+LUA_API int (lua_gc) (lua_State *L, int what, int data);
+
+
+/*
+** miscellaneous functions
+*/
+
+LUA_API int   (lua_error) (lua_State *L);
+
+LUA_API int   (lua_next) (lua_State *L, int idx);
+
+LUA_API void  (lua_concat) (lua_State *L, int n);
+
+LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
+LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);
+
+
+
+/* 
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define lua_pop(L,n)		lua_settop(L, -(n)-1)
+
+#define lua_newtable(L)		lua_createtable(L, 0, 0)
+
+#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
+
+#define lua_pushcfunction(L,f)	lua_pushcclosure(L, (f), 0)
+
+#define lua_strlen(L,i)		lua_objlen(L, (i))
+
+#define lua_isfunction(L,n)	(lua_type(L, (n)) == LUA_TFUNCTION)
+#define lua_istable(L,n)	(lua_type(L, (n)) == LUA_TTABLE)
+#define lua_islightuserdata(L,n)	(lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
+#define lua_isnil(L,n)		(lua_type(L, (n)) == LUA_TNIL)
+#define lua_isboolean(L,n)	(lua_type(L, (n)) == LUA_TBOOLEAN)
+#define lua_isthread(L,n)	(lua_type(L, (n)) == LUA_TTHREAD)
+#define lua_isnone(L,n)		(lua_type(L, (n)) == LUA_TNONE)
+#define lua_isnoneornil(L, n)	(lua_type(L, (n)) <= 0)
+
+#define lua_pushliteral(L, s)	\
+	lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
+
+#define lua_setglobal(L,s)	lua_setfield(L, LUA_GLOBALSINDEX, (s))
+#define lua_getglobal(L,s)	lua_getfield(L, LUA_GLOBALSINDEX, (s))
+
+#define lua_tostring(L,i)	lua_tolstring(L, (i), NULL)
+
+
+
+/*
+** compatibility macros and functions
+*/
+
+#define lua_open()	luaL_newstate()
+
+#define lua_getregistry(L)	lua_pushvalue(L, LUA_REGISTRYINDEX)
+
+#define lua_getgccount(L)	lua_gc(L, LUA_GCCOUNT, 0)
+
+#define lua_Chunkreader		lua_Reader
+#define lua_Chunkwriter		lua_Writer
+
+
+/* hack */
+LUA_API void lua_setlevel	(lua_State *from, lua_State *to);
+
+
+/*
+** {======================================================================
+** Debug API
+** =======================================================================
+*/
+
+
+/*
+** Event codes
+*/
+#define LUA_HOOKCALL	0
+#define LUA_HOOKRET	1
+#define LUA_HOOKLINE	2
+#define LUA_HOOKCOUNT	3
+#define LUA_HOOKTAILRET 4
+
+
+/*
+** Event masks
+*/
+#define LUA_MASKCALL	(1 << LUA_HOOKCALL)
+#define LUA_MASKRET	(1 << LUA_HOOKRET)
+#define LUA_MASKLINE	(1 << LUA_HOOKLINE)
+#define LUA_MASKCOUNT	(1 << LUA_HOOKCOUNT)
+
+typedef struct lua_Debug lua_Debug;  /* activation record */
+
+
+/* Functions to be called by the debuger in specific events */
+typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
+
+
+LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar);
+LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
+LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n);
+LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n);
+
+LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count);
+LUA_API lua_Hook lua_gethook (lua_State *L);
+LUA_API int lua_gethookmask (lua_State *L);
+LUA_API int lua_gethookcount (lua_State *L);
+
+
+struct lua_Debug {
+  int event;
+  const char *name;	/* (n) */
+  const char *namewhat;	/* (n) `global', `local', `field', `method' */
+  const char *what;	/* (S) `Lua', `C', `main', `tail' */
+  const char *source;	/* (S) */
+  int currentline;	/* (l) */
+  int nups;		/* (u) number of upvalues */
+  int linedefined;	/* (S) */
+  int lastlinedefined;	/* (S) */
+  char short_src[LUA_IDSIZE]; /* (S) */
+  /* private part */
+  int i_ci;  /* active function */
+};
+
+/* }====================================================================== */
+
+
+/******************************************************************************
+* Copyright (C) 1994-2012 Lua.org, PUC-Rio.  All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+******************************************************************************/
+
+
+#endif

vendor/lua/5.1/include/lua.hpp

@@ -0,0 +1,9 @@
+// lua.hpp
+// Lua header files for C++
+// <<extern "C">> not supplied automatically because Lua also compiles as C++
+
+extern "C" {
+#include "lua.h"
+#include "lualib.h"
+#include "lauxlib.h"
+}

vendor/lua/5.1/include/luaconf.h

@@ -0,0 +1,766 @@
+/*
+** $Id: luaconf.h,v 1.82.1.7 2008/02/11 16:25:08 roberto Exp $
+** Configuration file for Lua
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lconfig_h
+#define lconfig_h
+
+#include <limits.h>
+#include <stddef.h>
+
+
+/*
+** ==================================================================
+** Search for "@@" to find all configurable definitions.
+** ===================================================================
+*/
+
+
+/*
+@@ LUA_ANSI controls the use of non-ansi features.
+** CHANGE it (define it) if you want Lua to avoid the use of any
+** non-ansi feature or library.
+*/
+#if defined(__STRICT_ANSI__)
+#define LUA_ANSI
+#endif
+
+
+#if !defined(LUA_ANSI) && defined(_WIN32)
+#define LUA_WIN
+#endif
+
+#if defined(LUA_USE_LINUX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
+#define LUA_USE_READLINE	/* needs some extra libraries */
+#endif
+
+#if defined(LUA_USE_MACOSX)
+#define LUA_USE_POSIX
+#define LUA_DL_DYLD		/* does not need extra library */
+#endif
+
+
+
+/*
+@@ LUA_USE_POSIX includes all functionallity listed as X/Open System
+@* Interfaces Extension (XSI).
+** CHANGE it (define it) if your system is XSI compatible.
+*/
+#if defined(LUA_USE_POSIX)
+#define LUA_USE_MKSTEMP
+#define LUA_USE_ISATTY
+#define LUA_USE_POPEN
+#define LUA_USE_ULONGJMP
+#endif
+
+
+/*
+@@ LUA_PATH and LUA_CPATH are the names of the environment variables that
+@* Lua check to set its paths.
+@@ LUA_INIT is the name of the environment variable that Lua
+@* checks for initialization code.
+** CHANGE them if you want different names.
+*/
+#define LUA_PATH        "LUA_PATH"
+#define LUA_CPATH       "LUA_CPATH"
+#define LUA_INIT	"LUA_INIT"
+
+
+/*
+@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
+@* Lua libraries.
+@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
+@* C libraries.
+** CHANGE them if your machine has a non-conventional directory
+** hierarchy or if you want to install your libraries in
+** non-conventional directories.
+*/
+#if defined(_WIN32)
+/*
+** In Windows, any exclamation mark ('!') in the path is replaced by the
+** path of the directory of the executable file of the current process.
+*/
+#define LUA_LDIR	"!\\lua\\"
+#define LUA_CDIR	"!\\"
+#define LUA_PATH_DEFAULT  \
+		".\\?.lua;"  LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \
+		             LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua"
+#define LUA_CPATH_DEFAULT \
+		".\\?.dll;"  LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" \
+		LUA_CDIR"clibs\\?.dll;" LUA_CDIR"clibs\\loadall.dll;" \
+		".\\?51.dll;"  LUA_CDIR"?51.dll;" LUA_CDIR"clibs\\?51.dll" 
+
+#else
+#define LUA_ROOT	"/usr/local/"
+#define LUA_LDIR	LUA_ROOT "share/lua/5.1/"
+#define LUA_CDIR	LUA_ROOT "lib/lua/5.1/"
+#define LUA_PATH_DEFAULT  \
+		"./?.lua;"  LUA_LDIR"?.lua;"  LUA_LDIR"?/init.lua;" \
+		            LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua"
+#define LUA_CPATH_DEFAULT \
+		"./?.so;"  LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" \
+		"./lib?51.so;" LUA_CDIR"lib?51.so"
+#endif
+
+
+/*
+@@ LUA_DIRSEP is the directory separator (for submodules).
+** CHANGE it if your machine does not use "/" as the directory separator
+** and is not Windows. (On Windows Lua automatically uses "\".)
+*/
+#if defined(_WIN32)
+#define LUA_DIRSEP	"\\"
+#else
+#define LUA_DIRSEP	"/"
+#endif
+
+
+/*
+@@ LUA_PATHSEP is the character that separates templates in a path.
+@@ LUA_PATH_MARK is the string that marks the substitution points in a
+@* template.
+@@ LUA_EXECDIR in a Windows path is replaced by the executable's
+@* directory.
+@@ LUA_IGMARK is a mark to ignore all before it when bulding the
+@* luaopen_ function name.
+** CHANGE them if for some reason your system cannot use those
+** characters. (E.g., if one of those characters is a common character
+** in file/directory names.) Probably you do not need to change them.
+*/
+#define LUA_PATHSEP	";"
+#define LUA_PATH_MARK	"?"
+#define LUA_EXECDIR	"!"
+#define LUA_IGMARK	"-"
+
+
+/*
+@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger.
+** CHANGE that if ptrdiff_t is not adequate on your machine. (On most
+** machines, ptrdiff_t gives a good choice between int or long.)
+*/
+#define LUA_INTEGER	ptrdiff_t
+
+
+/*
+@@ LUA_API is a mark for all core API functions.
+@@ LUALIB_API is a mark for all standard library functions.
+** CHANGE them if you need to define those functions in some special way.
+** For instance, if you want to create one Windows DLL with the core and
+** the libraries, you may want to use the following definition (define
+** LUA_BUILD_AS_DLL to get it).
+*/
+#if defined(LUA_BUILD_AS_DLL)
+
+#if defined(LUA_CORE) || defined(LUA_LIB)
+#define LUA_API __declspec(dllexport)
+#else
+#define LUA_API __declspec(dllimport)
+#endif
+
+#else
+
+#define LUA_API		extern
+
+#endif
+
+/* more often than not the libs go together with the core */
+#define LUALIB_API	LUA_API
+
+
+/*
+@@ LUAI_FUNC is a mark for all extern functions that are not to be
+@* exported to outside modules.
+@@ LUAI_DATA is a mark for all extern (const) variables that are not to
+@* be exported to outside modules.
+** CHANGE them if you need to mark them in some special way. Elf/gcc
+** (versions 3.2 and later) mark them as "hidden" to optimize access
+** when Lua is compiled as a shared library.
+*/
+#if defined(luaall_c)
+#define LUAI_FUNC	static
+#define LUAI_DATA	/* empty */
+
+#elif defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
+      defined(__ELF__)
+#define LUAI_FUNC	__attribute__((visibility("hidden"))) extern
+#define LUAI_DATA	LUAI_FUNC
+
+#else
+#define LUAI_FUNC	extern
+#define LUAI_DATA	extern
+#endif
+
+
+
+/*
+@@ LUA_QL describes how error messages quote program elements.
+** CHANGE it if you want a different appearance.
+*/
+#define LUA_QL(x)	"'" x "'"
+#define LUA_QS		LUA_QL("%s")
+
+
+/*
+@@ LUA_IDSIZE gives the maximum size for the description of the source
+@* of a function in debug information.
+** CHANGE it if you want a different size.
+*/
+#define LUA_IDSIZE	60
+
+
+/*
+** {==================================================================
+** Stand-alone configuration
+** ===================================================================
+*/
+
+#if defined(lua_c) || defined(luaall_c)
+
+/*
+@@ lua_stdin_is_tty detects whether the standard input is a 'tty' (that
+@* is, whether we're running lua interactively).
+** CHANGE it if you have a better definition for non-POSIX/non-Windows
+** systems.
+*/
+#if defined(LUA_USE_ISATTY)
+#include <unistd.h>
+#define lua_stdin_is_tty()	isatty(0)
+#elif defined(LUA_WIN)
+#include <io.h>
+#include <stdio.h>
+#define lua_stdin_is_tty()	_isatty(_fileno(stdin))
+#else
+#define lua_stdin_is_tty()	1  /* assume stdin is a tty */
+#endif
+
+
+/*
+@@ LUA_PROMPT is the default prompt used by stand-alone Lua.
+@@ LUA_PROMPT2 is the default continuation prompt used by stand-alone Lua.
+** CHANGE them if you want different prompts. (You can also change the
+** prompts dynamically, assigning to globals _PROMPT/_PROMPT2.)
+*/
+#define LUA_PROMPT		"> "
+#define LUA_PROMPT2		">> "
+
+
+/*
+@@ LUA_PROGNAME is the default name for the stand-alone Lua program.
+** CHANGE it if your stand-alone interpreter has a different name and
+** your system is not able to detect that name automatically.
+*/
+#define LUA_PROGNAME		"lua"
+
+
+/*
+@@ LUA_MAXINPUT is the maximum length for an input line in the
+@* stand-alone interpreter.
+** CHANGE it if you need longer lines.
+*/
+#define LUA_MAXINPUT	512
+
+
+/*
+@@ lua_readline defines how to show a prompt and then read a line from
+@* the standard input.
+@@ lua_saveline defines how to "save" a read line in a "history".
+@@ lua_freeline defines how to free a line read by lua_readline.
+** CHANGE them if you want to improve this functionality (e.g., by using
+** GNU readline and history facilities).
+*/
+#if defined(LUA_USE_READLINE)
+#include <stdio.h>
+#include <readline/readline.h>
+#include <readline/history.h>
+#define lua_readline(L,b,p)	((void)L, ((b)=readline(p)) != NULL)
+#define lua_saveline(L,idx) \
+	if (lua_strlen(L,idx) > 0)  /* non-empty line? */ \
+	  add_history(lua_tostring(L, idx));  /* add it to history */
+#define lua_freeline(L,b)	((void)L, free(b))
+#else
+#define lua_readline(L,b,p)	\
+	((void)L, fputs(p, stdout), fflush(stdout),  /* show prompt */ \
+	fgets(b, LUA_MAXINPUT, stdin) != NULL)  /* get line */
+#define lua_saveline(L,idx)	{ (void)L; (void)idx; }
+#define lua_freeline(L,b)	{ (void)L; (void)b; }
+#endif
+
+#endif
+
+/* }================================================================== */
+
+
+/*
+@@ LUAI_GCPAUSE defines the default pause between garbage-collector cycles
+@* as a percentage.
+** CHANGE it if you want the GC to run faster or slower (higher values
+** mean larger pauses which mean slower collection.) You can also change
+** this value dynamically.
+*/
+#define LUAI_GCPAUSE	200  /* 200% (wait memory to double before next GC) */
+
+
+/*
+@@ LUAI_GCMUL defines the default speed of garbage collection relative to
+@* memory allocation as a percentage.
+** CHANGE it if you want to change the granularity of the garbage
+** collection. (Higher values mean coarser collections. 0 represents
+** infinity, where each step performs a full collection.) You can also
+** change this value dynamically.
+*/
+#define LUAI_GCMUL	200 /* GC runs 'twice the speed' of memory allocation */
+
+
+
+/*
+@@ LUA_COMPAT_GETN controls compatibility with old getn behavior.
+** CHANGE it (define it) if you want exact compatibility with the
+** behavior of setn/getn in Lua 5.0.
+*/
+#undef LUA_COMPAT_GETN
+
+/*
+@@ LUA_COMPAT_LOADLIB controls compatibility about global loadlib.
+** CHANGE it to undefined as soon as you do not need a global 'loadlib'
+** function (the function is still available as 'package.loadlib').
+*/
+#undef LUA_COMPAT_LOADLIB
+
+/*
+@@ LUA_COMPAT_VARARG controls compatibility with old vararg feature.
+** CHANGE it to undefined as soon as your programs use only '...' to
+** access vararg parameters (instead of the old 'arg' table).
+*/
+#define LUA_COMPAT_VARARG
+
+/*
+@@ LUA_COMPAT_MOD controls compatibility with old math.mod function.
+** CHANGE it to undefined as soon as your programs use 'math.fmod' or
+** the new '%' operator instead of 'math.mod'.
+*/
+#define LUA_COMPAT_MOD
+
+/*
+@@ LUA_COMPAT_LSTR controls compatibility with old long string nesting
+@* facility.
+** CHANGE it to 2 if you want the old behaviour, or undefine it to turn
+** off the advisory error when nesting [[...]].
+*/
+#define LUA_COMPAT_LSTR		1
+
+/*
+@@ LUA_COMPAT_GFIND controls compatibility with old 'string.gfind' name.
+** CHANGE it to undefined as soon as you rename 'string.gfind' to
+** 'string.gmatch'.
+*/
+#define LUA_COMPAT_GFIND
+
+/*
+@@ LUA_COMPAT_OPENLIB controls compatibility with old 'luaL_openlib'
+@* behavior.
+** CHANGE it to undefined as soon as you replace to 'luaL_register'
+** your uses of 'luaL_openlib'
+*/
+#define LUA_COMPAT_OPENLIB
+
+
+
+/*
+@@ luai_apicheck is the assert macro used by the Lua-C API.
+** CHANGE luai_apicheck if you want Lua to perform some checks in the
+** parameters it gets from API calls. This may slow down the interpreter
+** a bit, but may be quite useful when debugging C code that interfaces
+** with Lua. A useful redefinition is to use assert.h.
+*/
+#if defined(LUA_USE_APICHECK)
+#include <assert.h>
+#define luai_apicheck(L,o)	{ (void)L; assert(o); }
+#else
+#define luai_apicheck(L,o)	{ (void)L; }
+#endif
+
+
+/*
+@@ LUAI_BITSINT defines the number of bits in an int.
+** CHANGE here if Lua cannot automatically detect the number of bits of
+** your machine. Probably you do not need to change this.
+*/
+/* avoid overflows in comparison */
+#if INT_MAX-20 < 32760
+#define LUAI_BITSINT	16
+#elif INT_MAX > 2147483640L
+/* int has at least 32 bits */
+#define LUAI_BITSINT	32
+#else
+#error "you must define LUA_BITSINT with number of bits in an integer"
+#endif
+
+
+/*
+@@ LUAI_UINT32 is an unsigned integer with at least 32 bits.
+@@ LUAI_INT32 is an signed integer with at least 32 bits.
+@@ LUAI_UMEM is an unsigned integer big enough to count the total
+@* memory used by Lua.
+@@ LUAI_MEM is a signed integer big enough to count the total memory
+@* used by Lua.
+** CHANGE here if for some weird reason the default definitions are not
+** good enough for your machine. (The definitions in the 'else'
+** part always works, but may waste space on machines with 64-bit
+** longs.) Probably you do not need to change this.
+*/
+#if LUAI_BITSINT >= 32
+#define LUAI_UINT32	unsigned int
+#define LUAI_INT32	int
+#define LUAI_MAXINT32	INT_MAX
+#define LUAI_UMEM	size_t
+#define LUAI_MEM	ptrdiff_t
+#else
+/* 16-bit ints */
+#define LUAI_UINT32	unsigned long
+#define LUAI_INT32	long
+#define LUAI_MAXINT32	LONG_MAX
+#define LUAI_UMEM	unsigned long
+#define LUAI_MEM	long
+#endif
+
+
+/*
+@@ LUAI_MAXCALLS limits the number of nested calls.
+** CHANGE it if you need really deep recursive calls. This limit is
+** arbitrary; its only purpose is to stop infinite recursion before
+** exhausting memory.
+*/
+#define LUAI_MAXCALLS	20000
+
+
+/*
+@@ LUAI_MAXCSTACK limits the number of Lua stack slots that a C function
+@* can use.
+** CHANGE it if you need lots of (Lua) stack space for your C
+** functions. This limit is arbitrary; its only purpose is to stop C
+** functions to consume unlimited stack space. (must be smaller than
+** -LUA_REGISTRYINDEX)
+*/
+#define LUAI_MAXCSTACK	8000
+
+
+
+/*
+** {==================================================================
+** CHANGE (to smaller values) the following definitions if your system
+** has a small C stack. (Or you may want to change them to larger
+** values if your system has a large C stack and these limits are
+** too rigid for you.) Some of these constants control the size of
+** stack-allocated arrays used by the compiler or the interpreter, while
+** others limit the maximum number of recursive calls that the compiler
+** or the interpreter can perform. Values too large may cause a C stack
+** overflow for some forms of deep constructs.
+** ===================================================================
+*/
+
+
+/*
+@@ LUAI_MAXCCALLS is the maximum depth for nested C calls (short) and
+@* syntactical nested non-terminals in a program.
+*/
+#define LUAI_MAXCCALLS		200
+
+
+/*
+@@ LUAI_MAXVARS is the maximum number of local variables per function
+@* (must be smaller than 250).
+*/
+#define LUAI_MAXVARS		200
+
+
+/*
+@@ LUAI_MAXUPVALUES is the maximum number of upvalues per function
+@* (must be smaller than 250).
+*/
+#define LUAI_MAXUPVALUES	60
+
+
+/*
+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+*/
+#define LUAL_BUFFERSIZE		BUFSIZ
+
+/* }================================================================== */
+
+
+
+
+/*
+** {==================================================================
+@@ LUA_NUMBER is the type of numbers in Lua.
+** CHANGE the following definitions only if you want to build Lua
+** with a number type different from double. You may also need to
+** change lua_number2int & lua_number2integer.
+** ===================================================================
+*/
+
+#define LUA_NUMBER_DOUBLE
+#define LUA_NUMBER	double
+
+/*
+@@ LUAI_UACNUMBER is the result of an 'usual argument conversion'
+@* over a number.
+*/
+#define LUAI_UACNUMBER	double
+
+
+/*
+@@ LUA_NUMBER_SCAN is the format for reading numbers.
+@@ LUA_NUMBER_FMT is the format for writing numbers.
+@@ lua_number2str converts a number to a string.
+@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.
+@@ lua_str2number converts a string to a number.
+*/
+#define LUA_NUMBER_SCAN		"%lf"
+#define LUA_NUMBER_FMT		"%.14g"
+#define lua_number2str(s,n)	sprintf((s), LUA_NUMBER_FMT, (n))
+#define LUAI_MAXNUMBER2STR	32 /* 16 digits, sign, point, and \0 */
+#define lua_str2number(s,p)	strtod((s), (p))
+
+
+/*
+@@ The luai_num* macros define the primitive operations over numbers.
+*/
+#if defined(LUA_CORE)
+#include <math.h>
+#define luai_numadd(a,b)	((a)+(b))
+#define luai_numsub(a,b)	((a)-(b))
+#define luai_nummul(a,b)	((a)*(b))
+#define luai_numdiv(a,b)	((a)/(b))
+#define luai_nummod(a,b)	((a) - floor((a)/(b))*(b))
+#define luai_numpow(a,b)	(pow(a,b))
+#define luai_numunm(a)		(-(a))
+#define luai_numeq(a,b)		((a)==(b))
+#define luai_numlt(a,b)		((a)<(b))
+#define luai_numle(a,b)		((a)<=(b))
+#define luai_numisnan(a)	(!luai_numeq((a), (a)))
+#endif
+
+
+/*
+@@ lua_number2int is a macro to convert lua_Number to int.
+@@ lua_number2integer is a macro to convert lua_Number to lua_Integer.
+** CHANGE them if you know a faster way to convert a lua_Number to
+** int (with any rounding method and without throwing errors) in your
+** system. In Pentium machines, a naive typecast from double to int
+** in C is extremely slow, so any alternative is worth trying.
+*/
+
+/* On a Pentium, resort to a trick */
+#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) && !defined(__SSE2__) && \
+    (defined(__i386) || defined (_M_IX86) || defined(__i386__))
+
+/* On a Microsoft compiler, use assembler */
+#if defined(_MSC_VER)
+
+#define lua_number2int(i,d)   __asm fld d   __asm fistp i
+#define lua_number2integer(i,n)		lua_number2int(i, n)
+
+/* the next trick should work on any Pentium, but sometimes clashes
+   with a DirectX idiosyncrasy */
+#else
+
+union luai_Cast { double l_d; long l_l; };
+#define lua_number2int(i,d) \
+  { volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; }
+#define lua_number2integer(i,n)		lua_number2int(i, n)
+
+#endif
+
+
+/* this option always works, but may be slow */
+#else
+#define lua_number2int(i,d)	((i)=(int)(d))
+#define lua_number2integer(i,d)	((i)=(lua_Integer)(d))
+
+#endif
+
+/* }================================================================== */
+
+
+/*
+@@ LUAI_USER_ALIGNMENT_T is a type that requires maximum alignment.
+** CHANGE it if your system requires alignments larger than double. (For
+** instance, if your system supports long doubles and they must be
+** aligned in 16-byte boundaries, then you should add long double in the
+** union.) Probably you do not need to change this.
+*/
+#define LUAI_USER_ALIGNMENT_T	union { double u; void *s; long l; }
+
+
+/*
+@@ LUAI_THROW/LUAI_TRY define how Lua does exception handling.
+** CHANGE them if you prefer to use longjmp/setjmp even with C++
+** or if want/don't to use _longjmp/_setjmp instead of regular
+** longjmp/setjmp. By default, Lua handles errors with exceptions when
+** compiling as C++ code, with _longjmp/_setjmp when asked to use them,
+** and with longjmp/setjmp otherwise.
+*/
+#if defined(__cplusplus)
+/* C++ exceptions */
+#define LUAI_THROW(L,c)	throw(c)
+#define LUAI_TRY(L,c,a)	try { a } catch(...) \
+	{ if ((c)->status == 0) (c)->status = -1; }
+#define luai_jmpbuf	int  /* dummy variable */
+
+#elif defined(LUA_USE_ULONGJMP)
+/* in Unix, try _longjmp/_setjmp (more efficient) */
+#define LUAI_THROW(L,c)	_longjmp((c)->b, 1)
+#define LUAI_TRY(L,c,a)	if (_setjmp((c)->b) == 0) { a }
+#define luai_jmpbuf	jmp_buf
+
+#else
+/* default handling with long jumps */
+#define LUAI_THROW(L,c)	longjmp((c)->b, 1)
+#define LUAI_TRY(L,c,a)	if (setjmp((c)->b) == 0) { a }
+#define luai_jmpbuf	jmp_buf
+
+#endif
+
+
+/*
+@@ LUA_MAXCAPTURES is the maximum number of captures that a pattern
+@* can do during pattern-matching.
+** CHANGE it if you need more captures. This limit is arbitrary.
+*/
+#define LUA_MAXCAPTURES		32
+
+
+/*
+@@ lua_tmpnam is the function that the OS library uses to create a
+@* temporary name.
+@@ LUA_TMPNAMBUFSIZE is the maximum size of a name created by lua_tmpnam.
+** CHANGE them if you have an alternative to tmpnam (which is considered
+** insecure) or if you want the original tmpnam anyway.  By default, Lua
+** uses tmpnam except when POSIX is available, where it uses mkstemp.
+*/
+#if defined(loslib_c) || defined(luaall_c)
+
+#if defined(LUA_USE_MKSTEMP)
+#include <unistd.h>
+#define LUA_TMPNAMBUFSIZE	32
+#define lua_tmpnam(b,e)	{ \
+	strcpy(b, "/tmp/lua_XXXXXX"); \
+	e = mkstemp(b); \
+	if (e != -1) close(e); \
+	e = (e == -1); }
+
+#else
+#define LUA_TMPNAMBUFSIZE	L_tmpnam
+#define lua_tmpnam(b,e)		{ e = (tmpnam(b) == NULL); }
+#endif
+
+#endif
+
+
+/*
+@@ lua_popen spawns a new process connected to the current one through
+@* the file streams.
+** CHANGE it if you have a way to implement it in your system.
+*/
+#if defined(LUA_USE_POPEN)
+
+#define lua_popen(L,c,m)	((void)L, fflush(NULL), popen(c,m))
+#define lua_pclose(L,file)	((void)L, (pclose(file) != -1))
+
+#elif defined(LUA_WIN)
+
+#define lua_popen(L,c,m)	((void)L, _popen(c,m))
+#define lua_pclose(L,file)	((void)L, (_pclose(file) != -1))
+
+#else
+
+#define lua_popen(L,c,m)	((void)((void)c, m),  \
+		luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)
+#define lua_pclose(L,file)		((void)((void)L, file), 0)
+
+#endif
+
+/*
+@@ LUA_DL_* define which dynamic-library system Lua should use.
+** CHANGE here if Lua has problems choosing the appropriate
+** dynamic-library system for your platform (either Windows' DLL, Mac's
+** dyld, or Unix's dlopen). If your system is some kind of Unix, there
+** is a good chance that it has dlopen, so LUA_DL_DLOPEN will work for
+** it.  To use dlopen you also need to adapt the src/Makefile (probably
+** adding -ldl to the linker options), so Lua does not select it
+** automatically.  (When you change the makefile to add -ldl, you must
+** also add -DLUA_USE_DLOPEN.)
+** If you do not want any kind of dynamic library, undefine all these
+** options.
+** By default, _WIN32 gets LUA_DL_DLL and MAC OS X gets LUA_DL_DYLD.
+*/
+#if defined(LUA_USE_DLOPEN)
+#define LUA_DL_DLOPEN
+#endif
+
+#if defined(LUA_WIN)
+#define LUA_DL_DLL
+#endif
+
+
+/*
+@@ LUAI_EXTRASPACE allows you to add user-specific data in a lua_State
+@* (the data goes just *before* the lua_State pointer).
+** CHANGE (define) this if you really need that. This value must be
+** a multiple of the maximum alignment required for your machine.
+*/
+#define LUAI_EXTRASPACE		0
+
+
+/*
+@@ luai_userstate* allow user-specific actions on threads.
+** CHANGE them if you defined LUAI_EXTRASPACE and need to do something
+** extra when a thread is created/deleted/resumed/yielded.
+*/
+#define luai_userstateopen(L)		((void)L)
+#define luai_userstateclose(L)		((void)L)
+#define luai_userstatethread(L,L1)	((void)L)
+#define luai_userstatefree(L)		((void)L)
+#define luai_userstateresume(L,n)	((void)L)
+#define luai_userstateyield(L,n)	((void)L)
+
+
+/*
+@@ LUA_INTFRMLEN is the length modifier for integer conversions
+@* in 'string.format'.
+@@ LUA_INTFRM_T is the integer type correspoding to the previous length
+@* modifier.
+** CHANGE them if your system supports long long or does not support long.
+*/
+
+#if defined(LUA_USELONGLONG)
+
+#define LUA_INTFRMLEN		"ll"
+#define LUA_INTFRM_T		long long
+
+#else
+
+#define LUA_INTFRMLEN		"l"
+#define LUA_INTFRM_T		long
+
+#endif
+
+
+
+/* =================================================================== */
+
+/*
+** Local configuration. You can use this space to add your redefinitions
+** without modifying the main part of the file.
+*/
+
+
+
+#endif
+

vendor/lua/5.1/include/lualib.h

@@ -0,0 +1,53 @@
+/*
+** $Id: lualib.h,v 1.36.1.1 2007/12/27 13:02:25 roberto Exp $
+** Lua standard libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lualib_h
+#define lualib_h
+
+#include "lua.h"
+
+
+/* Key to file-handle type */
+#define LUA_FILEHANDLE		"FILE*"
+
+
+#define LUA_COLIBNAME	"coroutine"
+LUALIB_API int (luaopen_base) (lua_State *L);
+
+#define LUA_TABLIBNAME	"table"
+LUALIB_API int (luaopen_table) (lua_State *L);
+
+#define LUA_IOLIBNAME	"io"
+LUALIB_API int (luaopen_io) (lua_State *L);
+
+#define LUA_OSLIBNAME	"os"
+LUALIB_API int (luaopen_os) (lua_State *L);
+
+#define LUA_STRLIBNAME	"string"
+LUALIB_API int (luaopen_string) (lua_State *L);
+
+#define LUA_MATHLIBNAME	"math"
+LUALIB_API int (luaopen_math) (lua_State *L);
+
+#define LUA_DBLIBNAME	"debug"
+LUALIB_API int (luaopen_debug) (lua_State *L);
+
+#define LUA_LOADLIBNAME	"package"
+LUALIB_API int (luaopen_package) (lua_State *L);
+
+
+/* open all previous libraries */
+LUALIB_API void (luaL_openlibs) (lua_State *L); 
+
+
+
+#ifndef lua_assert
+#define lua_assert(x)	((void)0)
+#endif
+
+
+#endif

vendor/lua/5.1/lua.odin

@@ -0,0 +1,659 @@
+package lua_5_1
+
+import "core:intrinsics"
+import "core:builtin"
+
+import c "core:c/libc"
+
+#assert(size_of(c.int) == size_of(b32))
+
+when ODIN_OS == .Windows {
+	foreign import lib "windows/lua5.1.dll.lib"
+} else when ODIN_OS == .Linux {
+	foreign import lib "linux/liblua5.1.a"
+} else {
+	foreign import lib "system:liblua5.1.a"
+}
+
+VERSION	        :: "Lua 5.1"
+RELEASE	        :: "Lua 5.1.5"
+VERSION_NUM	:: 501
+COPYRIGHT	:: "Copyright (C) 1994-2012 Lua.org, PUC-Rio"
+AUTHORS         :: "R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
+
+/* mark for precompiled code ('<esc>Lua') */
+SIGNATURE :: "\x1bLua"
+
+/* option for multiple returns in 'lua_pcall' and 'lua_call' */
+MULTRET :: -1
+
+REGISTRYINDEX :: -10000
+ENVIRONINDEX  :: -10001
+GLOBALSINDEX  :: -10002
+
+/*
+@@ LUAI_MAXSTACK limits the size of the Lua stack.
+** CHANGE it if you need a different limit. This limit is arbitrary;
+** its only purpose is to stop Lua from consuming unlimited stack
+** space (and to reserve some numbers for pseudo-indices).
+** (It must fit into max(size_t)/32.)
+*/
+MAXSTACK :: 1000000
+
+
+/*
+@@ LUA_EXTRASPACE defines the size of a raw memory area associated with
+** a Lua state with very fast access.
+** CHANGE it if you need a different size.
+*/
+EXTRASPACE :: size_of(rawptr)
+
+
+
+/*
+@@ LUA_IDSIZE gives the maximum size for the description of the source
+@@ of a function in debug information.
+** CHANGE it if you want a different size.
+*/
+IDSIZE :: 60
+
+
+/*
+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+*/
+L_BUFFERSIZE :: c.int(16 * size_of(rawptr) * size_of(Number))
+
+
+MAXALIGNVAL :: max(align_of(Number), align_of(f64), align_of(rawptr), align_of(Integer), align_of(c.long))
+
+
+Status :: enum c.int {
+	OK        = 0,
+	YIELD     = 1,
+	ERRRUN    = 2,
+	ERRSYNTAX = 3,
+	ERRMEM    = 4,
+	ERRERR    = 5,
+	ERRFILE   = 6,
+}
+
+/* thread status */
+OK        :: Status.OK
+YIELD     :: Status.YIELD
+ERRRUN    :: Status.ERRRUN
+ERRSYNTAX :: Status.ERRSYNTAX
+ERRMEM    :: Status.ERRMEM
+ERRERR    :: Status.ERRERR
+ERRFILE   :: Status.ERRFILE
+
+/*
+** basic types
+*/
+
+
+Type :: enum c.int {
+	NONE          = -1,
+
+	NIL           = 0,
+	BOOLEAN       = 1,
+	LIGHTUSERDATA = 2,
+	NUMBER        = 3,
+	STRING        = 4,
+	TABLE         = 5,
+	FUNCTION      = 6,
+	USERDATA      = 7,
+	THREAD        = 8,
+}
+
+TNONE          :: Type.NONE
+TNIL           :: Type.NIL
+TBOOLEAN       :: Type.BOOLEAN
+TLIGHTUSERDATA :: Type.LIGHTUSERDATA
+TNUMBER        :: Type.NUMBER
+TSTRING        :: Type.STRING
+TTABLE         :: Type.TABLE
+TFUNCTION      :: Type.FUNCTION
+TUSERDATA      :: Type.USERDATA
+TTHREAD        :: Type.THREAD
+NUMTYPES :: 9
+
+
+CompareOp :: enum c.int {
+	EQ = 0,
+	LT = 1,
+	LE = 2,
+}
+
+OPEQ :: CompareOp.EQ
+OPLT :: CompareOp.LT
+OPLE :: CompareOp.LE
+
+
+/* minimum Lua stack available to a C function */
+MINSTACK :: 20
+
+
+/* type of numbers in Lua */
+Number :: distinct (f32 when size_of(uintptr) == 4 else f64)
+
+
+/* type for integer functions */
+Integer :: distinct (i32 when size_of(uintptr) == 4 else i64)
+
+
+/*
+** Type for C functions registered with Lua
+*/
+CFunction :: #type proc "c" (L: ^State) -> c.int
+
+
+
+/*
+** Type for functions that read/write blocks when loading/dumping Lua chunks
+*/
+Reader :: #type proc "c" (L: ^State, ud: rawptr, sz: ^c.size_t) -> cstring
+Writer :: #type proc "c" (L: ^State, p: rawptr, sz: ^c.size_t, ud: rawptr) -> c.int
+
+
+/*
+** Type for memory-allocation functions
+*/
+Alloc :: #type proc "c" (ud: rawptr, ptr: rawptr, osize, nsize: c.size_t) -> rawptr
+
+
+GCWhat :: enum c.int {
+	STOP        = 0,
+	RESTART     = 1,
+	COLLECT     = 2,
+	COUNT       = 3,
+	COUNTB      = 4,
+	STEP        = 5,
+	SETPAUSE    = 6,
+	SETSTEPMUL  = 7,
+}
+GCSTOP        :: GCWhat.STOP
+GCRESTART     :: GCWhat.RESTART
+GCCOLLECT     :: GCWhat.COLLECT
+GCCOUNT       :: GCWhat.COUNT
+GCCOUNTB      :: GCWhat.COUNTB
+GCSTEP        :: GCWhat.STEP
+GCSETPAUSE    :: GCWhat.SETPAUSE
+GCSETSTEPMUL  :: GCWhat.SETSTEPMUL
+
+
+/*
+** Event codes
+*/
+
+HookEvent :: enum c.int {
+	CALL     = 0,
+	RET      = 1,
+	LINE     = 2,
+	COUNT    = 3,
+	TAILRET  = 4,
+}
+HOOKCALL    :: HookEvent.CALL
+HOOKRET     :: HookEvent.RET
+HOOKLINE    :: HookEvent.LINE
+HOOKCOUNT   :: HookEvent.COUNT
+HOOKTAILRET :: HookEvent.TAILRET
+
+
+/*
+** Event masks
+*/
+HookMask :: distinct bit_set[HookEvent; c.int]
+MASKCALL  :: HookMask{.CALL}
+MASKRET   :: HookMask{.RET}
+MASKLINE  :: HookMask{.LINE}
+MASKCOUNT :: HookMask{.COUNT}
+
+/* activation record */
+Debug :: struct {
+	event:           HookEvent,
+	name:            cstring,              /* (n) */
+	namewhat:        cstring,              /* (n) 'global', 'local', 'field', 'method' */
+	what:            cstring,              /* (S) 'Lua', 'C', 'main', 'tail' */
+	source:          cstring,              /* (S) */
+	currentline:     c.int,                /* (l) */
+	nups:            c.int,                /* (u) number of upvalues */
+	linedefined:     c.int,                /* (S) */
+	lastlinedefined: c.int,                /* (S) */
+	short_src:       [IDSIZE]u8 `fmt:"s"`, /* (S) */
+	/* private part */
+	i_ci:            c.int,                /* active function */
+}
+
+
+/* Functions to be called by the debugger in specific events */
+Hook :: #type proc "c" (L: ^State, ar: ^Debug)
+
+
+State :: struct {} // opaque data type
+
+
+@(link_prefix="lua_")
+@(default_calling_convention="c")
+foreign lib {
+	/*
+	** RCS ident string
+	*/
+
+	ident: [^]u8 // TODO(bill): is this correct?
+
+
+	/*
+	** state manipulation
+	*/
+
+	newstate  :: proc(f: Alloc, ud: rawptr) -> ^State ---
+	close     :: proc(L: ^State) ---
+	newthread :: proc(L: ^State) -> ^State ---
+
+	atpanic :: proc(L: ^State, panicf: CFunction) -> CFunction ---
+
+
+	/*
+	** basic stack manipulation
+	*/
+
+	gettop     :: proc (L: ^State) -> c.int ---
+	settop     :: proc (L: ^State, idx: c.int) ---
+	pushvalue  :: proc (L: ^State, idx: c.int) ---
+	remove     :: proc (L: ^State, idx: c.int) ---
+	insert     :: proc (L: ^State, idx: c.int) ---
+	replace    :: proc (L: ^State, idx: c.int) ---
+	checkstack :: proc (L: ^State, sz: c.int) -> c.int ---
+
+	xmove :: proc(from, to: ^State, n: c.int) ---
+
+
+	/*
+	** access functions (stack -> C)
+	*/
+
+	isnumber    :: proc(L: ^State, idx: c.int) -> b32 ---
+	isstring    :: proc(L: ^State, idx: c.int) -> b32 ---
+	iscfunction :: proc(L: ^State, idx: c.int) -> b32 ---
+	isinteger   :: proc(L: ^State, idx: c.int) -> b32 ---
+	isuserdata  :: proc(L: ^State, idx: c.int) -> b32 ---
+	type        :: proc(L: ^State, idx: c.int) -> Type ---
+	typename    :: proc(L: ^State, tp: Type) -> cstring ---
+
+	equal    :: proc(L: ^State, idx1, idx2: c.int) -> b32 ---
+	rawequal :: proc(L: ^State, idx1, idx2: c.int) -> b32 ---
+	lessthan :: proc(L: ^State, idx1, idx2: c.int) -> b32 ---
+
+	toboolean   :: proc(L: ^State, idx: c.int) -> b32 ---
+	tolstring   :: proc(L: ^State, idx: c.int, len: ^c.size_t) -> cstring ---
+	objlen      :: proc(L: ^State, idx: c.int) -> c.size_t ---
+	tocfunction :: proc(L: ^State, idx: c.int) -> CFunction ---
+	touserdata  :: proc(L: ^State, idx: c.int) -> rawptr ---
+	tothread    :: proc(L: ^State, idx: c.int) -> ^State ---
+	topointer   :: proc(L: ^State, idx: c.int) -> rawptr ---
+
+	/*
+	** push functions (C -> stack)
+	*/
+
+	pushnil      :: proc(L: ^State) ---
+	pushnumber   :: proc(L: ^State, n: Number) ---
+	pushinteger  :: proc(L: ^State, n: Integer) ---
+	pushlstring  :: proc(L: ^State, s: cstring, l: c.size_t) ---
+	pushstring   :: proc(L: ^State, s: cstring) ---
+	pushvfstring :: proc(L: ^State, fmt: cstring, argp: c.va_list) -> cstring ---
+	pushfstring       :: proc(L: ^State, fmt: cstring, #c_vararg args: ..any) -> cstring ---
+	pushcclosure      :: proc(L: ^State, fn: CFunction, n: c.int) ---
+	pushboolean       :: proc(L: ^State, b: b32) ---
+	pushlightuserdata :: proc(L: ^State, p: rawptr) ---
+	pushthread        :: proc(L: ^State) -> Status ---
+
+	/*
+	** get functions (Lua -> stack)
+	*/
+
+	gettable  :: proc(L: ^State, idx: c.int) ---
+	getfield  :: proc(L: ^State, idx: c.int, k: cstring) ---
+	geti      :: proc(L: ^State, idx: c.int, n: Integer) ---
+	rawget    :: proc(L: ^State, idx: c.int) ---
+	rawgeti   :: proc(L: ^State, idx: c.int, n: Integer) ---
+	rawgetp   :: proc(L: ^State, idx: c.int, p: rawptr) ---
+
+	createtable  :: proc(L: ^State, narr, nrec: c.int) ---
+	newuserdata  :: proc(L: ^State, sz: c.size_t) -> rawptr ---
+	getmetatable :: proc(L: ^State, objindex: c.int) -> c.int ---
+	getfenv      :: proc(L: ^State, idx: c.int) ---
+
+
+	/*
+	** set functions (stack -> Lua)
+	*/
+
+	settable     :: proc(L: ^State, idx: c.int) ---
+	setfield     :: proc(L: ^State, idx: c.int, k: cstring) ---
+	rawset       :: proc(L: ^State, idx: c.int) ---
+	rawseti      :: proc(L: ^State, idx: c.int, n: c.int) ---
+	rawsetp      :: proc(L: ^State, idx: c.int, p: rawptr) ---
+	setmetatable :: proc(L: ^State, objindex: c.int) -> c.int ---
+	setfenv      :: proc(L: ^State, idx: c.int) -> c.int ---
+
+
+	/*
+	** 'load' and 'call' functions (load and run Lua code)
+	*/
+
+	call :: proc(L: ^State, nargs, nresults: c.int) ---
+
+	getctx :: proc(L: ^State, ctx: ^c.int) -> c.int ---
+
+	pcall :: proc(L: ^State, nargs, nresults: c.int, errfunc: c.int) -> c.int ---
+	cpcall :: proc(L: ^State, func: CFunction, ud: rawptr) -> c.int ---
+
+	load :: proc(L: ^State, reader: Reader, dt: rawptr,
+	             chunkname: cstring) -> Status ---
+
+	dump :: proc(L: ^State, writer: Writer, data: rawptr) -> Status ---
+
+
+	/*
+	** coroutine functions
+	*/
+
+	yield       :: proc(L: ^State, nresults: c.int) -> Status ---
+	resume      :: proc(L: ^State, narg: c.int) -> Status ---
+	status      :: proc(L: ^State) -> Status ---
+
+
+	/*
+	** garbage-collection function and options
+	*/
+
+
+
+	gc :: proc(L: ^State, what: GCWhat, data: c.int) -> c.int ---
+
+
+	/*
+	** miscellaneous functions
+	*/
+
+	error :: proc(L: ^State) -> Status ---
+
+	next :: proc(L: ^State, idx: c.int) -> c.int ---
+
+	concat :: proc(L: ^State, n: c.int) ---
+	len    :: proc(L: ^State, idx: c.int) ---
+
+	getallocf :: proc(L: State, ud: ^rawptr) -> Alloc ---
+	setallocf :: proc(L: ^State, f: Alloc, ud: rawptr) ---
+
+	/*
+	** {======================================================================
+	** Debug API
+	** =======================================================================
+	*/
+
+	getstack   :: proc(L: ^State, level: c.int, ar: ^Debug) -> c.int ---
+	getinfo    :: proc(L: ^State, what: cstring, ar: ^Debug) -> c.int ---
+	getlocal   :: proc(L: ^State, ar: ^Debug, n: c.int) -> cstring ---
+	setlocal   :: proc(L: ^State, ar: ^Debug, n: c.int) -> cstring ---
+	getupvalue :: proc(L: ^State, funcindex: c.int, n: c.int) -> cstring ---
+	setupvalue :: proc(L: ^State, funcindex: c.int, n: c.int) -> cstring ---
+
+	sethook :: proc(L: ^State, func: Hook, mask: HookMask, count: c.int) -> c.int ---
+	gethook :: proc(L: ^State) -> Hook ---
+	gethookmask  :: proc(L: ^State) -> HookMask ---
+	gethookcount :: proc(L: ^State) -> c.int ---
+
+	/* }============================================================== */
+}
+
+
+
+COLIBNAME   :: "coroutine"
+TABLIBNAME  :: "table"
+IOLIBNAME   :: "io"
+OSLIBNAME   :: "os"
+STRLIBNAME  :: "string"
+UTF8LIBNAME :: "utf8"
+MATHLIBNAME :: "math"
+DBLIBNAME   :: "debug"
+LOADLIBNAME :: "package"
+
+@(link_prefix="lua")
+@(default_calling_convention="c")
+foreign lib {
+	open_base      :: proc(L: ^State) -> c.int ---
+	open_table     :: proc(L: ^State) -> c.int ---
+	open_io        :: proc(L: ^State) -> c.int ---
+	open_os        :: proc(L: ^State) -> c.int ---
+	open_string    :: proc(L: ^State) -> c.int ---
+	open_utf8      :: proc(L: ^State) -> c.int ---
+	open_math      :: proc(L: ^State) -> c.int ---
+	open_debug     :: proc(L: ^State) -> c.int ---
+	open_package   :: proc(L: ^State) -> c.int ---
+
+	/* open all previous libraries */
+
+	L_openlibs :: proc(L: ^State) ---
+}
+
+
+
+GNAME :: "_G"
+
+L_Reg :: struct {
+	name: cstring,
+  	func: CFunction,
+}
+
+/* predefined references */
+NOREF  :: -2
+REFNIL :: -1
+
+@(link_prefix="lua")
+@(default_calling_convention="c")
+foreign lib {
+	L_openlib      :: proc(L: ^State, libname: cstring, l: [^]L_Reg, nup: c.int) ---
+	L_register     :: proc(L: ^State, libname: cstring, l: ^L_Reg) ---
+	L_getmetafield :: proc(L: ^State, obj: c.int, e: cstring) -> c.int ---
+	L_callmeta     :: proc(L: ^State, obj: c.int, e: cstring) -> c.int ---
+	L_typeerror    :: proc(L: ^State, narg: c.int, tname: cstring) -> c.int ---
+	L_argerror     :: proc(L: ^State, numarg: c.int, extramsg: cstring) -> c.int ---
+	@(link_name="luaL_checklstring")
+	L_checkstring  :: proc(L: ^State, numArg: c.int, l: ^c.size_t = nil) -> cstring ---
+	@(link_name="luaL_optlstring")
+	L_optstring    :: proc(L: ^State, numArg: c.int, def: cstring, l: ^c.size_t = nil) -> cstring ---
+	L_checknumber  :: proc(L: ^State, numArg: c.int) -> Number ---
+	L_optnumber    :: proc(L: ^State, nArg: c.int, def: Number) -> Number ---
+
+	L_checkinteger  :: proc(L: ^State, numArg: c.int) -> Integer ---
+	L_optinteger    :: proc(L: ^State, nArg: c.int, def: Integer) -> Integer ---
+
+
+	L_checkstack :: proc(L: ^State, sz: c.int, msg: cstring) ---
+	L_checktype  :: proc(L: ^State, narg: c.int, t: c.int) ---
+	L_checkany   :: proc(L: ^State, narg: c.int) ---
+
+	L_newmetatable :: proc(L: ^State, tname: cstring) -> c.int ---
+	L_checkudata   :: proc(L: ^State, ud: c.int, tname: cstring) -> rawptr ---
+
+	L_where :: proc(L: ^State, lvl: c.int) ---
+	L_error :: proc(L: ^State, fmt: cstring, #c_vararg args: ..any) -> Status ---
+
+	L_checkoption :: proc(L: ^State, narg: c.int, def: cstring, lst: [^]cstring) -> c.int ---
+
+
+	L_ref   :: proc(L: ^State, t: c.int) -> c.int ---
+	L_unref :: proc(L: ^State, t: c.int, ref: c.int) ---
+
+	L_loadfile :: proc (L: ^State, filename: cstring) -> Status ---
+
+	L_loadbuffer :: proc(L: ^State, buff: [^]byte, sz: c.size_t, name: cstring) -> Status ---
+	L_loadstring  :: proc(L: ^State, s: cstring) -> Status ---
+
+	L_newstate :: proc() -> ^State ---
+
+	L_gsub :: proc(L: ^State, s, p, r: cstring) -> cstring ---
+
+	L_findtable :: proc(L: ^State, idx: c.int, fname: cstring, szhint: c.int) -> cstring ---
+}
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+
+L_Buffer :: struct {
+	p:    [^]byte,  /* buffer address */
+	lvl:  c.int,    /* number of strings in the stack (level) */
+	L:    ^State,
+	buffer: [L_BUFFERSIZE]byte,  /* initial buffer */
+}
+
+L_addchar :: #force_inline proc "c" (B: ^L_Buffer, c: byte) {
+	end := ([^]byte)(&B.buffer)[L_BUFFERSIZE:]
+	if B.p < end {
+		L_prepbuffer(B)
+	}
+	B.p[0] = c
+	B.p = B.p[1:]
+}
+L_putchar :: L_addchar
+
+L_addsize :: #force_inline proc "c" (B: ^L_Buffer, s: c.size_t) -> [^]byte {
+	B.p = B.p[s:]
+	return B.p
+}
+
+
+@(link_prefix="lua")
+@(default_calling_convention="c")
+foreign lib {
+	L_buffinit       :: proc(L: ^State, B: ^L_Buffer) ---
+	L_prepbuffer     :: proc(B: ^L_Buffer) -> [^]byte ---
+	L_addlstring     :: proc(B: ^L_Buffer, s: cstring, l: c.size_t) ---
+	L_addstring      :: proc(B: ^L_Buffer, s: cstring) ---
+	L_addvalue       :: proc(B: ^L_Buffer) ---
+	L_pushresult     :: proc(B: ^L_Buffer) ---
+	L_pushresultsize :: proc(B: ^L_Buffer, sz: c.size_t) ---
+	L_buffinitsize   :: proc(L: ^State, B: ^L_Buffer, sz: c.size_t) -> [^]byte ---
+}
+
+@(link_prefix="lua_")
+@(default_calling_convention="c")
+foreign lib {
+	/* hack */
+	setlevel :: proc(from, to: ^State) ---
+}
+
+
+/* }====================================================== */
+
+
+
+
+/*
+** {==============================================================
+** some useful macros
+** ===============================================================
+*/
+
+pop :: #force_inline proc "c" (L: ^State, n: c.int) {
+	settop(L, -n-1)
+}
+newtable :: #force_inline proc "c" (L: ^State) {
+	createtable(L, 0, 0)
+}
+register :: #force_inline proc "c" (L: ^State, n: cstring, f: CFunction) {
+	pushcfunction(L, f)
+	setglobal(L, n)
+}
+
+pushcfunction :: #force_inline proc "c" (L: ^State, f: CFunction) {
+	pushcclosure(L, f, 0)
+}
+
+strlen :: #force_inline proc "c" (L: ^State, i: c.int) -> c.size_t {
+	return objlen(L, i)
+}
+
+
+isfunction      :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .FUNCTION      }
+istable         :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .TABLE         }
+islightuserdata :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .LIGHTUSERDATA }
+isnil           :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .NIL           }
+isboolean       :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .BOOLEAN       }
+isthread        :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .THREAD        }
+isnone          :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .NONE          }
+isnoneornil     :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) <= .NIL           }
+
+
+pushliteral :: pushstring
+setglobal :: #force_inline proc "c" (L: ^State, s: cstring) {
+	setfield(L, GLOBALSINDEX, s)
+}
+getglobal :: #force_inline proc "c" (L: ^State, s: cstring) {
+	getfield(L, GLOBALSINDEX, s)
+}
+tostring :: #force_inline proc "c" (L: ^State, i: c.int) -> cstring {
+	return tolstring(L, i, nil)
+}
+
+open :: newstate
+getregistry :: #force_inline proc "c" (L: ^State) {
+	pushvalue(L, REGISTRYINDEX)
+}
+
+getgccount :: #force_inline proc "c" (L: ^State) -> c.int {
+	return gc(L, .COUNT, 0)
+}
+
+Chunkreader :: Reader
+Chunkwriter :: Writer
+
+
+L_argcheck :: #force_inline proc "c" (L: ^State, cond: bool, numarg: c.int, extramsg: cstring) {
+	if cond {
+		L_argerror(L, numarg, extramsg)
+	}
+}
+
+L_typename :: #force_inline proc "c" (L: ^State, i: c.int) -> cstring {
+	return typename(L, type(L, i))
+}
+L_dofile :: #force_inline proc "c" (L: ^State, s: cstring) -> c.int {
+	err := L_loadfile(L, s)
+	return pcall(L, 0, MULTRET, 0) if err == nil else c.int(err)
+}
+L_dostring :: #force_inline proc "c" (L: ^State, s: cstring) -> c.int {
+	err := L_loadstring(L, s)
+	return pcall(L, 0, MULTRET, 0) if err == nil else c.int(err)
+}
+L_getmetatable :: #force_inline proc "c" (L: ^State, n: cstring) {
+	getfield(L, REGISTRYINDEX, n)
+}
+L_opt :: #force_inline proc "c" (L: ^State, f: $F, n: c.int, d: $T) -> T where intrinsics.type_is_proc(F) {
+	return d if isnoneornil(L, n) else f(L, n)
+}
+
+
+
+ref :: #force_inline proc "c" (L: ^State, lock: bool) -> c.int {
+	if lock {
+		return L_ref(L, REGISTRYINDEX)
+	}
+	pushstring(L, "unlocked references are obsolete")
+	error(L)
+	return 0
+}
+unref :: #force_inline proc "c" (L: ^State, ref: c.int) {
+	L_unref(L,REGISTRYINDEX, ref)
+}
+getref :: #force_inline proc "c" (L: ^State, ref: Integer) {
+	rawgeti(L, REGISTRYINDEX, ref)
+}
+
+
+/* }============================================================== */

vendor/lua/5.2/include/lauxlib.h

@@ -0,0 +1,212 @@
+/*
+** $Id: lauxlib.h,v 1.120.1.1 2013/04/12 18:48:47 roberto Exp $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lauxlib_h
+#define lauxlib_h
+
+
+#include <stddef.h>
+#include <stdio.h>
+
+#include "lua.h"
+
+
+
+/* extra error code for `luaL_load' */
+#define LUA_ERRFILE     (LUA_ERRERR+1)
+
+
+typedef struct luaL_Reg {
+  const char *name;
+  lua_CFunction func;
+} luaL_Reg;
+
+
+LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver);
+#define luaL_checkversion(L)	luaL_checkversion_(L, LUA_VERSION_NUM)
+
+LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
+LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
+LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
+                                                          size_t *l);
+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
+                                          const char *def, size_t *l);
+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
+
+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
+                                          lua_Integer def);
+LUALIB_API lua_Unsigned (luaL_checkunsigned) (lua_State *L, int numArg);
+LUALIB_API lua_Unsigned (luaL_optunsigned) (lua_State *L, int numArg,
+                                            lua_Unsigned def);
+
+LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
+LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
+LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
+
+LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
+LUALIB_API void  (luaL_setmetatable) (lua_State *L, const char *tname);
+LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
+LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
+
+LUALIB_API void (luaL_where) (lua_State *L, int lvl);
+LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
+
+LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
+                                   const char *const lst[]);
+
+LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
+LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
+
+/* pre-defined references */
+#define LUA_NOREF       (-2)
+#define LUA_REFNIL      (-1)
+
+LUALIB_API int (luaL_ref) (lua_State *L, int t);
+LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
+
+LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
+                                               const char *mode);
+
+#define luaL_loadfile(L,f)	luaL_loadfilex(L,f,NULL)
+
+LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
+                                   const char *name, const char *mode);
+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
+
+LUALIB_API lua_State *(luaL_newstate) (void);
+
+LUALIB_API int (luaL_len) (lua_State *L, int idx);
+
+LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
+                                                  const char *r);
+
+LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
+
+LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
+
+LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
+                                  const char *msg, int level);
+
+LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
+                                 lua_CFunction openf, int glb);
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+
+#define luaL_newlibtable(L,l)	\
+  lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
+
+#define luaL_newlib(L,l)	(luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
+
+#define luaL_argcheck(L, cond,numarg,extramsg)	\
+		((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
+#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
+#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
+#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
+#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
+
+#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
+
+#define luaL_dofile(L, fn) \
+	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_dostring(L, s) \
+	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))
+
+#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
+
+#define luaL_loadbuffer(L,s,sz,n)	luaL_loadbufferx(L,s,sz,n,NULL)
+
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+typedef struct luaL_Buffer {
+  char *b;  /* buffer address */
+  size_t size;  /* buffer size */
+  size_t n;  /* number of characters in buffer */
+  lua_State *L;
+  char initb[LUAL_BUFFERSIZE];  /* initial buffer */
+} luaL_Buffer;
+
+
+#define luaL_addchar(B,c) \
+  ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
+   ((B)->b[(B)->n++] = (c)))
+
+#define luaL_addsize(B,s)	((B)->n += (s))
+
+LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
+LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
+LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
+LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
+
+#define luaL_prepbuffer(B)	luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
+
+/* }====================================================== */
+
+
+
+/*
+** {======================================================
+** File handles for IO library
+** =======================================================
+*/
+
+/*
+** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
+** initial structure 'luaL_Stream' (it may contain other fields
+** after that initial structure).
+*/
+
+#define LUA_FILEHANDLE          "FILE*"
+
+
+typedef struct luaL_Stream {
+  FILE *f;  /* stream (NULL for incompletely created streams) */
+  lua_CFunction closef;  /* to close stream (NULL for closed streams) */
+} luaL_Stream;
+
+/* }====================================================== */
+
+
+
+/* compatibility with old module system */
+#if defined(LUA_COMPAT_MODULE)
+
+LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,
+                                   int sizehint);
+LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
+                                const luaL_Reg *l, int nup);
+
+#define luaL_register(L,n,l)	(luaL_openlib(L,(n),(l),0))
+
+#endif
+
+
+#endif
+
+

vendor/lua/5.2/include/lua.h

@@ -0,0 +1,444 @@
+/*
+** $Id: lua.h,v 1.285.1.4 2015/02/21 14:04:50 roberto Exp $
+** Lua - A Scripting Language
+** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
+** See Copyright Notice at the end of this file
+*/
+
+
+#ifndef lua_h
+#define lua_h
+
+#include <stdarg.h>
+#include <stddef.h>
+
+
+#include "luaconf.h"
+
+
+#define LUA_VERSION_MAJOR	"5"
+#define LUA_VERSION_MINOR	"2"
+#define LUA_VERSION_NUM		502
+#define LUA_VERSION_RELEASE	"4"
+
+#define LUA_VERSION	"Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
+#define LUA_RELEASE	LUA_VERSION "." LUA_VERSION_RELEASE
+#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2015 Lua.org, PUC-Rio"
+#define LUA_AUTHORS	"R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
+
+
+/* mark for precompiled code ('<esc>Lua') */
+#define LUA_SIGNATURE	"\033Lua"
+
+/* option for multiple returns in 'lua_pcall' and 'lua_call' */
+#define LUA_MULTRET	(-1)
+
+
+/*
+** pseudo-indices
+*/
+#define LUA_REGISTRYINDEX	LUAI_FIRSTPSEUDOIDX
+#define lua_upvalueindex(i)	(LUA_REGISTRYINDEX - (i))
+
+
+/* thread status */
+#define LUA_OK		0
+#define LUA_YIELD	1
+#define LUA_ERRRUN	2
+#define LUA_ERRSYNTAX	3
+#define LUA_ERRMEM	4
+#define LUA_ERRGCMM	5
+#define LUA_ERRERR	6
+
+
+typedef struct lua_State lua_State;
+
+typedef int (*lua_CFunction) (lua_State *L);
+
+
+/*
+** functions that read/write blocks when loading/dumping Lua chunks
+*/
+typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
+
+typedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud);
+
+
+/*
+** prototype for memory-allocation functions
+*/
+typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
+
+
+/*
+** basic types
+*/
+#define LUA_TNONE		(-1)
+
+#define LUA_TNIL		0
+#define LUA_TBOOLEAN		1
+#define LUA_TLIGHTUSERDATA	2
+#define LUA_TNUMBER		3
+#define LUA_TSTRING		4
+#define LUA_TTABLE		5
+#define LUA_TFUNCTION		6
+#define LUA_TUSERDATA		7
+#define LUA_TTHREAD		8
+
+#define LUA_NUMTAGS		9
+
+
+
+/* minimum Lua stack available to a C function */
+#define LUA_MINSTACK	20
+
+
+/* predefined values in the registry */
+#define LUA_RIDX_MAINTHREAD	1
+#define LUA_RIDX_GLOBALS	2
+#define LUA_RIDX_LAST		LUA_RIDX_GLOBALS
+
+
+/* type of numbers in Lua */
+typedef LUA_NUMBER lua_Number;
+
+
+/* type for integer functions */
+typedef LUA_INTEGER lua_Integer;
+
+/* unsigned integer type */
+typedef LUA_UNSIGNED lua_Unsigned;
+
+
+
+/*
+** generic extra include file
+*/
+#if defined(LUA_USER_H)
+#include LUA_USER_H
+#endif
+
+
+/*
+** RCS ident string
+*/
+extern const char lua_ident[];
+
+
+/*
+** state manipulation
+*/
+LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
+LUA_API void       (lua_close) (lua_State *L);
+LUA_API lua_State *(lua_newthread) (lua_State *L);
+
+LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
+
+
+LUA_API const lua_Number *(lua_version) (lua_State *L);
+
+
+/*
+** basic stack manipulation
+*/
+LUA_API int   (lua_absindex) (lua_State *L, int idx);
+LUA_API int   (lua_gettop) (lua_State *L);
+LUA_API void  (lua_settop) (lua_State *L, int idx);
+LUA_API void  (lua_pushvalue) (lua_State *L, int idx);
+LUA_API void  (lua_remove) (lua_State *L, int idx);
+LUA_API void  (lua_insert) (lua_State *L, int idx);
+LUA_API void  (lua_replace) (lua_State *L, int idx);
+LUA_API void  (lua_copy) (lua_State *L, int fromidx, int toidx);
+LUA_API int   (lua_checkstack) (lua_State *L, int sz);
+
+LUA_API void  (lua_xmove) (lua_State *from, lua_State *to, int n);
+
+
+/*
+** access functions (stack -> C)
+*/
+
+LUA_API int             (lua_isnumber) (lua_State *L, int idx);
+LUA_API int             (lua_isstring) (lua_State *L, int idx);
+LUA_API int             (lua_iscfunction) (lua_State *L, int idx);
+LUA_API int             (lua_isuserdata) (lua_State *L, int idx);
+LUA_API int             (lua_type) (lua_State *L, int idx);
+LUA_API const char     *(lua_typename) (lua_State *L, int tp);
+
+LUA_API lua_Number      (lua_tonumberx) (lua_State *L, int idx, int *isnum);
+LUA_API lua_Integer     (lua_tointegerx) (lua_State *L, int idx, int *isnum);
+LUA_API lua_Unsigned    (lua_tounsignedx) (lua_State *L, int idx, int *isnum);
+LUA_API int             (lua_toboolean) (lua_State *L, int idx);
+LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
+LUA_API size_t          (lua_rawlen) (lua_State *L, int idx);
+LUA_API lua_CFunction   (lua_tocfunction) (lua_State *L, int idx);
+LUA_API void	       *(lua_touserdata) (lua_State *L, int idx);
+LUA_API lua_State      *(lua_tothread) (lua_State *L, int idx);
+LUA_API const void     *(lua_topointer) (lua_State *L, int idx);
+
+
+/*
+** Comparison and arithmetic functions
+*/
+
+#define LUA_OPADD	0	/* ORDER TM */
+#define LUA_OPSUB	1
+#define LUA_OPMUL	2
+#define LUA_OPDIV	3
+#define LUA_OPMOD	4
+#define LUA_OPPOW	5
+#define LUA_OPUNM	6
+
+LUA_API void  (lua_arith) (lua_State *L, int op);
+
+#define LUA_OPEQ	0
+#define LUA_OPLT	1
+#define LUA_OPLE	2
+
+LUA_API int   (lua_rawequal) (lua_State *L, int idx1, int idx2);
+LUA_API int   (lua_compare) (lua_State *L, int idx1, int idx2, int op);
+
+
+/*
+** push functions (C -> stack)
+*/
+LUA_API void        (lua_pushnil) (lua_State *L);
+LUA_API void        (lua_pushnumber) (lua_State *L, lua_Number n);
+LUA_API void        (lua_pushinteger) (lua_State *L, lua_Integer n);
+LUA_API void        (lua_pushunsigned) (lua_State *L, lua_Unsigned n);
+LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t l);
+LUA_API const char *(lua_pushstring) (lua_State *L, const char *s);
+LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
+                                                      va_list argp);
+LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
+LUA_API void  (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
+LUA_API void  (lua_pushboolean) (lua_State *L, int b);
+LUA_API void  (lua_pushlightuserdata) (lua_State *L, void *p);
+LUA_API int   (lua_pushthread) (lua_State *L);
+
+
+/*
+** get functions (Lua -> stack)
+*/
+LUA_API void  (lua_getglobal) (lua_State *L, const char *var);
+LUA_API void  (lua_gettable) (lua_State *L, int idx);
+LUA_API void  (lua_getfield) (lua_State *L, int idx, const char *k);
+LUA_API void  (lua_rawget) (lua_State *L, int idx);
+LUA_API void  (lua_rawgeti) (lua_State *L, int idx, int n);
+LUA_API void  (lua_rawgetp) (lua_State *L, int idx, const void *p);
+LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
+LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
+LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
+LUA_API void  (lua_getuservalue) (lua_State *L, int idx);
+
+
+/*
+** set functions (stack -> Lua)
+*/
+LUA_API void  (lua_setglobal) (lua_State *L, const char *var);
+LUA_API void  (lua_settable) (lua_State *L, int idx);
+LUA_API void  (lua_setfield) (lua_State *L, int idx, const char *k);
+LUA_API void  (lua_rawset) (lua_State *L, int idx);
+LUA_API void  (lua_rawseti) (lua_State *L, int idx, int n);
+LUA_API void  (lua_rawsetp) (lua_State *L, int idx, const void *p);
+LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
+LUA_API void  (lua_setuservalue) (lua_State *L, int idx);
+
+
+/*
+** 'load' and 'call' functions (load and run Lua code)
+*/
+LUA_API void  (lua_callk) (lua_State *L, int nargs, int nresults, int ctx,
+                           lua_CFunction k);
+#define lua_call(L,n,r)		lua_callk(L, (n), (r), 0, NULL)
+
+LUA_API int   (lua_getctx) (lua_State *L, int *ctx);
+
+LUA_API int   (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
+                            int ctx, lua_CFunction k);
+#define lua_pcall(L,n,r,f)	lua_pcallk(L, (n), (r), (f), 0, NULL)
+
+LUA_API int   (lua_load) (lua_State *L, lua_Reader reader, void *dt,
+                                        const char *chunkname,
+                                        const char *mode);
+
+LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);
+
+
+/*
+** coroutine functions
+*/
+LUA_API int  (lua_yieldk) (lua_State *L, int nresults, int ctx,
+                           lua_CFunction k);
+#define lua_yield(L,n)		lua_yieldk(L, (n), 0, NULL)
+LUA_API int  (lua_resume) (lua_State *L, lua_State *from, int narg);
+LUA_API int  (lua_status) (lua_State *L);
+
+/*
+** garbage-collection function and options
+*/
+
+#define LUA_GCSTOP		0
+#define LUA_GCRESTART		1
+#define LUA_GCCOLLECT		2
+#define LUA_GCCOUNT		3
+#define LUA_GCCOUNTB		4
+#define LUA_GCSTEP		5
+#define LUA_GCSETPAUSE		6
+#define LUA_GCSETSTEPMUL	7
+#define LUA_GCSETMAJORINC	8
+#define LUA_GCISRUNNING		9
+#define LUA_GCGEN		10
+#define LUA_GCINC		11
+
+LUA_API int (lua_gc) (lua_State *L, int what, int data);
+
+
+/*
+** miscellaneous functions
+*/
+
+LUA_API int   (lua_error) (lua_State *L);
+
+LUA_API int   (lua_next) (lua_State *L, int idx);
+
+LUA_API void  (lua_concat) (lua_State *L, int n);
+LUA_API void  (lua_len)    (lua_State *L, int idx);
+
+LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
+LUA_API void      (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
+
+
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define lua_tonumber(L,i)	lua_tonumberx(L,i,NULL)
+#define lua_tointeger(L,i)	lua_tointegerx(L,i,NULL)
+#define lua_tounsigned(L,i)	lua_tounsignedx(L,i,NULL)
+
+#define lua_pop(L,n)		lua_settop(L, -(n)-1)
+
+#define lua_newtable(L)		lua_createtable(L, 0, 0)
+
+#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
+
+#define lua_pushcfunction(L,f)	lua_pushcclosure(L, (f), 0)
+
+#define lua_isfunction(L,n)	(lua_type(L, (n)) == LUA_TFUNCTION)
+#define lua_istable(L,n)	(lua_type(L, (n)) == LUA_TTABLE)
+#define lua_islightuserdata(L,n)	(lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
+#define lua_isnil(L,n)		(lua_type(L, (n)) == LUA_TNIL)
+#define lua_isboolean(L,n)	(lua_type(L, (n)) == LUA_TBOOLEAN)
+#define lua_isthread(L,n)	(lua_type(L, (n)) == LUA_TTHREAD)
+#define lua_isnone(L,n)		(lua_type(L, (n)) == LUA_TNONE)
+#define lua_isnoneornil(L, n)	(lua_type(L, (n)) <= 0)
+
+#define lua_pushliteral(L, s)	\
+	lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
+
+#define lua_pushglobaltable(L)  \
+	lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)
+
+#define lua_tostring(L,i)	lua_tolstring(L, (i), NULL)
+
+
+
+/*
+** {======================================================================
+** Debug API
+** =======================================================================
+*/
+
+
+/*
+** Event codes
+*/
+#define LUA_HOOKCALL	0
+#define LUA_HOOKRET	1
+#define LUA_HOOKLINE	2
+#define LUA_HOOKCOUNT	3
+#define LUA_HOOKTAILCALL 4
+
+
+/*
+** Event masks
+*/
+#define LUA_MASKCALL	(1 << LUA_HOOKCALL)
+#define LUA_MASKRET	(1 << LUA_HOOKRET)
+#define LUA_MASKLINE	(1 << LUA_HOOKLINE)
+#define LUA_MASKCOUNT	(1 << LUA_HOOKCOUNT)
+
+typedef struct lua_Debug lua_Debug;  /* activation record */
+
+
+/* Functions to be called by the debugger in specific events */
+typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
+
+
+LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar);
+LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar);
+LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n);
+LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n);
+
+LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n);
+LUA_API void  (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,
+                                               int fidx2, int n2);
+
+LUA_API int (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
+LUA_API lua_Hook (lua_gethook) (lua_State *L);
+LUA_API int (lua_gethookmask) (lua_State *L);
+LUA_API int (lua_gethookcount) (lua_State *L);
+
+
+struct lua_Debug {
+  int event;
+  const char *name;	/* (n) */
+  const char *namewhat;	/* (n) 'global', 'local', 'field', 'method' */
+  const char *what;	/* (S) 'Lua', 'C', 'main', 'tail' */
+  const char *source;	/* (S) */
+  int currentline;	/* (l) */
+  int linedefined;	/* (S) */
+  int lastlinedefined;	/* (S) */
+  unsigned char nups;	/* (u) number of upvalues */
+  unsigned char nparams;/* (u) number of parameters */
+  char isvararg;        /* (u) */
+  char istailcall;	/* (t) */
+  char short_src[LUA_IDSIZE]; /* (S) */
+  /* private part */
+  struct CallInfo *i_ci;  /* active function */
+};
+
+/* }====================================================================== */
+
+
+/******************************************************************************
+* Copyright (C) 1994-2015 Lua.org, PUC-Rio.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+******************************************************************************/
+
+
+#endif

vendor/lua/5.2/include/lua.hpp

@@ -0,0 +1,9 @@
+// lua.hpp
+// Lua header files for C++
+// <<extern "C">> not supplied automatically because Lua also compiles as C++
+
+extern "C" {
+#include "lua.h"
+#include "lualib.h"
+#include "lauxlib.h"
+}

vendor/lua/5.2/include/luaconf.h

@@ -0,0 +1,553 @@
+/*
+** $Id: luaconf.h,v 1.176.1.2 2013/11/21 17:26:16 roberto Exp $
+** Configuration file for Lua
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lconfig_h
+#define lconfig_h
+
+#include <limits.h>
+#include <stddef.h>
+
+
+/*
+** ==================================================================
+** Search for "@@" to find all configurable definitions.
+** ===================================================================
+*/
+
+
+/*
+@@ LUA_ANSI controls the use of non-ansi features.
+** CHANGE it (define it) if you want Lua to avoid the use of any
+** non-ansi feature or library.
+*/
+#if !defined(LUA_ANSI) && defined(__STRICT_ANSI__)
+#define LUA_ANSI
+#endif
+
+
+#if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE)
+#define LUA_WIN		/* enable goodies for regular Windows platforms */
+#endif
+
+#if defined(LUA_WIN)
+#define LUA_DL_DLL
+#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
+#endif
+
+
+
+#if defined(LUA_USE_LINUX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
+#define LUA_USE_READLINE	/* needs some extra libraries */
+#define LUA_USE_STRTODHEX	/* assume 'strtod' handles hex formats */
+#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
+#define LUA_USE_LONGLONG	/* assume support for long long */
+#endif
+
+#if defined(LUA_USE_MACOSX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN		/* does not need -ldl */
+#define LUA_USE_READLINE	/* needs an extra library: -lreadline */
+#define LUA_USE_STRTODHEX	/* assume 'strtod' handles hex formats */
+#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
+#define LUA_USE_LONGLONG	/* assume support for long long */
+#endif
+
+
+
+/*
+@@ LUA_USE_POSIX includes all functionality listed as X/Open System
+@* Interfaces Extension (XSI).
+** CHANGE it (define it) if your system is XSI compatible.
+*/
+#if defined(LUA_USE_POSIX)
+#define LUA_USE_MKSTEMP
+#define LUA_USE_ISATTY
+#define LUA_USE_POPEN
+#define LUA_USE_ULONGJMP
+#define LUA_USE_GMTIME_R
+#endif
+
+
+
+/*
+@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
+@* Lua libraries.
+@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
+@* C libraries.
+** CHANGE them if your machine has a non-conventional directory
+** hierarchy or if you want to install your libraries in
+** non-conventional directories.
+*/
+#if defined(_WIN32)	/* { */
+/*
+** In Windows, any exclamation mark ('!') in the path is replaced by the
+** path of the directory of the executable file of the current process.
+*/
+#define LUA_LDIR	"!\\lua\\"
+#define LUA_CDIR	"!\\"
+#define LUA_PATH_DEFAULT  \
+		LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \
+		LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua;" ".\\?.lua"
+#define LUA_CPATH_DEFAULT \
+		LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" ".\\?.dll;" \
+    LUA_CDIR"?52.dll;" ".\\?52.dll"
+
+#else			/* }{ */
+
+#define LUA_VDIR	LUA_VERSION_MAJOR "." LUA_VERSION_MINOR "/"
+#define LUA_ROOT	"/usr/local/"
+#define LUA_LDIR	LUA_ROOT "share/lua/" LUA_VDIR
+#define LUA_CDIR	LUA_ROOT "lib/lua/" LUA_VDIR
+#define LUA_PATH_DEFAULT  \
+		LUA_LDIR"?.lua;"  LUA_LDIR"?/init.lua;" \
+		LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua;" "./?.lua"
+#define LUA_CPATH_DEFAULT \
+		LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so;" \
+    LUA_CDIR"lib?52.so;" "./lib?52.so"
+#endif			/* } */
+
+
+/*
+@@ LUA_DIRSEP is the directory separator (for submodules).
+** CHANGE it if your machine does not use "/" as the directory separator
+** and is not Windows. (On Windows Lua automatically uses "\".)
+*/
+#if defined(_WIN32)
+#define LUA_DIRSEP	"\\"
+#else
+#define LUA_DIRSEP	"/"
+#endif
+
+
+/*
+@@ LUA_ENV is the name of the variable that holds the current
+@@ environment, used to access global names.
+** CHANGE it if you do not like this name.
+*/
+#define LUA_ENV		"_ENV"
+
+
+/*
+@@ LUA_API is a mark for all core API functions.
+@@ LUALIB_API is a mark for all auxiliary library functions.
+@@ LUAMOD_API is a mark for all standard library opening functions.
+** CHANGE them if you need to define those functions in some special way.
+** For instance, if you want to create one Windows DLL with the core and
+** the libraries, you may want to use the following definition (define
+** LUA_BUILD_AS_DLL to get it).
+*/
+#if defined(LUA_BUILD_AS_DLL)	/* { */
+
+#if defined(LUA_CORE) || defined(LUA_LIB)	/* { */
+#define LUA_API __declspec(dllexport)
+#else						/* }{ */
+#define LUA_API __declspec(dllimport)
+#endif						/* } */
+
+#else				/* }{ */
+
+#define LUA_API		extern
+
+#endif				/* } */
+
+
+/* more often than not the libs go together with the core */
+#define LUALIB_API	LUA_API
+#define LUAMOD_API	LUALIB_API
+
+
+/*
+@@ LUAI_FUNC is a mark for all extern functions that are not to be
+@* exported to outside modules.
+@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables
+@* that are not to be exported to outside modules (LUAI_DDEF for
+@* definitions and LUAI_DDEC for declarations).
+** CHANGE them if you need to mark them in some special way. Elf/gcc
+** (versions 3.2 and later) mark them as "hidden" to optimize access
+** when Lua is compiled as a shared library. Not all elf targets support
+** this attribute. Unfortunately, gcc does not offer a way to check
+** whether the target offers that support, and those without support
+** give a warning about it. To avoid these warnings, change to the
+** default definition.
+*/
+#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
+    defined(__ELF__)		/* { */
+#define LUAI_FUNC	__attribute__((visibility("hidden"))) extern
+#define LUAI_DDEC	LUAI_FUNC
+#define LUAI_DDEF	/* empty */
+
+#else				/* }{ */
+#define LUAI_FUNC	extern
+#define LUAI_DDEC	extern
+#define LUAI_DDEF	/* empty */
+#endif				/* } */
+
+
+
+/*
+@@ LUA_QL describes how error messages quote program elements.
+** CHANGE it if you want a different appearance.
+*/
+#define LUA_QL(x)	"'" x "'"
+#define LUA_QS		LUA_QL("%s")
+
+
+/*
+@@ LUA_IDSIZE gives the maximum size for the description of the source
+@* of a function in debug information.
+** CHANGE it if you want a different size.
+*/
+#define LUA_IDSIZE	60
+
+
+/*
+@@ luai_writestring/luai_writeline define how 'print' prints its results.
+** They are only used in libraries and the stand-alone program. (The #if
+** avoids including 'stdio.h' everywhere.)
+*/
+#if defined(LUA_LIB) || defined(lua_c)
+#include <stdio.h>
+#define luai_writestring(s,l)	fwrite((s), sizeof(char), (l), stdout)
+#define luai_writeline()	(luai_writestring("\n", 1), fflush(stdout))
+#endif
+
+/*
+@@ luai_writestringerror defines how to print error messages.
+** (A format string with one argument is enough for Lua...)
+*/
+#define luai_writestringerror(s,p) \
+	(fprintf(stderr, (s), (p)), fflush(stderr))
+
+
+/*
+@@ LUAI_MAXSHORTLEN is the maximum length for short strings, that is,
+** strings that are internalized. (Cannot be smaller than reserved words
+** or tags for metamethods, as these strings must be internalized;
+** #("function") = 8, #("__newindex") = 10.)
+*/
+#define LUAI_MAXSHORTLEN        40
+
+
+
+/*
+** {==================================================================
+** Compatibility with previous versions
+** ===================================================================
+*/
+
+/*
+@@ LUA_COMPAT_ALL controls all compatibility options.
+** You can define it to get all options, or change specific options
+** to fit your specific needs.
+*/
+#if defined(LUA_COMPAT_ALL)	/* { */
+
+/*
+@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.
+** You can replace it with 'table.unpack'.
+*/
+#define LUA_COMPAT_UNPACK
+
+/*
+@@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'.
+** You can replace it with 'package.searchers'.
+*/
+#define LUA_COMPAT_LOADERS
+
+/*
+@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall.
+** You can call your C function directly (with light C functions).
+*/
+#define lua_cpcall(L,f,u)  \
+	(lua_pushcfunction(L, (f)), \
+	 lua_pushlightuserdata(L,(u)), \
+	 lua_pcall(L,1,0,0))
+
+
+/*
+@@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library.
+** You can rewrite 'log10(x)' as 'log(x, 10)'.
+*/
+#define LUA_COMPAT_LOG10
+
+/*
+@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base
+** library. You can rewrite 'loadstring(s)' as 'load(s)'.
+*/
+#define LUA_COMPAT_LOADSTRING
+
+/*
+@@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library.
+*/
+#define LUA_COMPAT_MAXN
+
+/*
+@@ The following macros supply trivial compatibility for some
+** changes in the API. The macros themselves document how to
+** change your code to avoid using them.
+*/
+#define lua_strlen(L,i)		lua_rawlen(L, (i))
+
+#define lua_objlen(L,i)		lua_rawlen(L, (i))
+
+#define lua_equal(L,idx1,idx2)		lua_compare(L,(idx1),(idx2),LUA_OPEQ)
+#define lua_lessthan(L,idx1,idx2)	lua_compare(L,(idx1),(idx2),LUA_OPLT)
+
+/*
+@@ LUA_COMPAT_MODULE controls compatibility with previous
+** module functions 'module' (Lua) and 'luaL_register' (C).
+*/
+#define LUA_COMPAT_MODULE
+
+#endif				/* } */
+
+/* }================================================================== */
+
+
+
+/*
+@@ LUAI_BITSINT defines the number of bits in an int.
+** CHANGE here if Lua cannot automatically detect the number of bits of
+** your machine. Probably you do not need to change this.
+*/
+/* avoid overflows in comparison */
+#if INT_MAX-20 < 32760		/* { */
+#define LUAI_BITSINT	16
+#elif INT_MAX > 2147483640L	/* }{ */
+/* int has at least 32 bits */
+#define LUAI_BITSINT	32
+#else				/* }{ */
+#error "you must define LUA_BITSINT with number of bits in an integer"
+#endif				/* } */
+
+
+/*
+@@ LUA_INT32 is a signed integer with exactly 32 bits.
+@@ LUAI_UMEM is an unsigned integer big enough to count the total
+@* memory used by Lua.
+@@ LUAI_MEM is a signed integer big enough to count the total memory
+@* used by Lua.
+** CHANGE here if for some weird reason the default definitions are not
+** good enough for your machine. Probably you do not need to change
+** this.
+*/
+#if LUAI_BITSINT >= 32		/* { */
+#define LUA_INT32	int
+#define LUAI_UMEM	size_t
+#define LUAI_MEM	ptrdiff_t
+#else				/* }{ */
+/* 16-bit ints */
+#define LUA_INT32	long
+#define LUAI_UMEM	unsigned long
+#define LUAI_MEM	long
+#endif				/* } */
+
+
+/*
+@@ LUAI_MAXSTACK limits the size of the Lua stack.
+** CHANGE it if you need a different limit. This limit is arbitrary;
+** its only purpose is to stop Lua from consuming unlimited stack
+** space (and to reserve some numbers for pseudo-indices).
+*/
+#if LUAI_BITSINT >= 32
+#define LUAI_MAXSTACK		1000000
+#else
+#define LUAI_MAXSTACK		15000
+#endif
+
+/* reserve some space for error handling */
+#define LUAI_FIRSTPSEUDOIDX	(-LUAI_MAXSTACK - 1000)
+
+
+
+
+/*
+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+** CHANGE it if it uses too much C-stack space.
+*/
+#define LUAL_BUFFERSIZE		BUFSIZ
+
+
+
+
+/*
+** {==================================================================
+@@ LUA_NUMBER is the type of numbers in Lua.
+** CHANGE the following definitions only if you want to build Lua
+** with a number type different from double. You may also need to
+** change lua_number2int & lua_number2integer.
+** ===================================================================
+*/
+
+#define LUA_NUMBER_DOUBLE
+#define LUA_NUMBER	double
+
+/*
+@@ LUAI_UACNUMBER is the result of an 'usual argument conversion'
+@* over a number.
+*/
+#define LUAI_UACNUMBER	double
+
+
+/*
+@@ LUA_NUMBER_SCAN is the format for reading numbers.
+@@ LUA_NUMBER_FMT is the format for writing numbers.
+@@ lua_number2str converts a number to a string.
+@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.
+*/
+#define LUA_NUMBER_SCAN		"%lf"
+#define LUA_NUMBER_FMT		"%.14g"
+#define lua_number2str(s,n)	sprintf((s), LUA_NUMBER_FMT, (n))
+#define LUAI_MAXNUMBER2STR	32 /* 16 digits, sign, point, and \0 */
+
+
+/*
+@@ l_mathop allows the addition of an 'l' or 'f' to all math operations
+*/
+#define l_mathop(x)		(x)
+
+
+/*
+@@ lua_str2number converts a decimal numeric string to a number.
+@@ lua_strx2number converts an hexadecimal numeric string to a number.
+** In C99, 'strtod' does both conversions. C89, however, has no function
+** to convert floating hexadecimal strings to numbers. For these
+** systems, you can leave 'lua_strx2number' undefined and Lua will
+** provide its own implementation.
+*/
+#define lua_str2number(s,p)	strtod((s), (p))
+
+#if defined(LUA_USE_STRTODHEX)
+#define lua_strx2number(s,p)	strtod((s), (p))
+#endif
+
+
+/*
+@@ The luai_num* macros define the primitive operations over numbers.
+*/
+
+/* the following operations need the math library */
+#if defined(lobject_c) || defined(lvm_c)
+#include <math.h>
+#define luai_nummod(L,a,b)	((a) - l_mathop(floor)((a)/(b))*(b))
+#define luai_numpow(L,a,b)	(l_mathop(pow)(a,b))
+#endif
+
+/* these are quite standard operations */
+#if defined(LUA_CORE)
+#define luai_numadd(L,a,b)	((a)+(b))
+#define luai_numsub(L,a,b)	((a)-(b))
+#define luai_nummul(L,a,b)	((a)*(b))
+#define luai_numdiv(L,a,b)	((a)/(b))
+#define luai_numunm(L,a)	(-(a))
+#define luai_numeq(a,b)		((a)==(b))
+#define luai_numlt(L,a,b)	((a)<(b))
+#define luai_numle(L,a,b)	((a)<=(b))
+#define luai_numisnan(L,a)	(!luai_numeq((a), (a)))
+#endif
+
+
+
+/*
+@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger.
+** CHANGE that if ptrdiff_t is not adequate on your machine. (On most
+** machines, ptrdiff_t gives a good choice between int or long.)
+*/
+#define LUA_INTEGER	ptrdiff_t
+
+/*
+@@ LUA_UNSIGNED is the integral type used by lua_pushunsigned/lua_tounsigned.
+** It must have at least 32 bits.
+*/
+#define LUA_UNSIGNED	unsigned LUA_INT32
+
+
+
+/*
+** Some tricks with doubles
+*/
+
+#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI)	/* { */
+/*
+** The next definitions activate some tricks to speed up the
+** conversion from doubles to integer types, mainly to LUA_UNSIGNED.
+**
+@@ LUA_MSASMTRICK uses Microsoft assembler to avoid clashes with a
+** DirectX idiosyncrasy.
+**
+@@ LUA_IEEE754TRICK uses a trick that should work on any machine
+** using IEEE754 with a 32-bit integer type.
+**
+@@ LUA_IEEELL extends the trick to LUA_INTEGER; should only be
+** defined when LUA_INTEGER is a 32-bit integer.
+**
+@@ LUA_IEEEENDIAN is the endianness of doubles in your machine
+** (0 for little endian, 1 for big endian); if not defined, Lua will
+** check it dynamically for LUA_IEEE754TRICK (but not for LUA_NANTRICK).
+**
+@@ LUA_NANTRICK controls the use of a trick to pack all types into
+** a single double value, using NaN values to represent non-number
+** values. The trick only works on 32-bit machines (ints and pointers
+** are 32-bit values) with numbers represented as IEEE 754-2008 doubles
+** with conventional endianess (12345678 or 87654321), in CPUs that do
+** not produce signaling NaN values (all NaNs are quiet).
+*/
+
+/* Microsoft compiler on a Pentium (32 bit) ? */
+#if defined(LUA_WIN) && defined(_MSC_VER) && defined(_M_IX86)	/* { */
+
+#define LUA_MSASMTRICK
+#define LUA_IEEEENDIAN		0
+#define LUA_NANTRICK
+
+
+/* pentium 32 bits? */
+#elif defined(__i386__) || defined(__i386) || defined(__X86__) /* }{ */
+
+#define LUA_IEEE754TRICK
+#define LUA_IEEELL
+#define LUA_IEEEENDIAN		0
+#define LUA_NANTRICK
+
+/* pentium 64 bits? */
+#elif defined(__x86_64)						/* }{ */
+
+#define LUA_IEEE754TRICK
+#define LUA_IEEEENDIAN		0
+
+#elif defined(__POWERPC__) || defined(__ppc__)			/* }{ */
+
+#define LUA_IEEE754TRICK
+#define LUA_IEEEENDIAN		1
+
+#else								/* }{ */
+
+/* assume IEEE754 and a 32-bit integer type */
+#define LUA_IEEE754TRICK
+
+#endif								/* } */
+
+#endif							/* } */
+
+/* }================================================================== */
+
+
+
+
+/* =================================================================== */
+
+/*
+** Local configuration. You can use this space to add your redefinitions
+** without modifying the main part of the file.
+*/
+
+
+
+#endif
+

vendor/lua/5.2/include/lualib.h

@@ -0,0 +1,55 @@
+/*
+** $Id: lualib.h,v 1.43.1.1 2013/04/12 18:48:47 roberto Exp $
+** Lua standard libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lualib_h
+#define lualib_h
+
+#include "lua.h"
+
+
+
+LUAMOD_API int (luaopen_base) (lua_State *L);
+
+#define LUA_COLIBNAME	"coroutine"
+LUAMOD_API int (luaopen_coroutine) (lua_State *L);
+
+#define LUA_TABLIBNAME	"table"
+LUAMOD_API int (luaopen_table) (lua_State *L);
+
+#define LUA_IOLIBNAME	"io"
+LUAMOD_API int (luaopen_io) (lua_State *L);
+
+#define LUA_OSLIBNAME	"os"
+LUAMOD_API int (luaopen_os) (lua_State *L);
+
+#define LUA_STRLIBNAME	"string"
+LUAMOD_API int (luaopen_string) (lua_State *L);
+
+#define LUA_BITLIBNAME	"bit32"
+LUAMOD_API int (luaopen_bit32) (lua_State *L);
+
+#define LUA_MATHLIBNAME	"math"
+LUAMOD_API int (luaopen_math) (lua_State *L);
+
+#define LUA_DBLIBNAME	"debug"
+LUAMOD_API int (luaopen_debug) (lua_State *L);
+
+#define LUA_LOADLIBNAME	"package"
+LUAMOD_API int (luaopen_package) (lua_State *L);
+
+
+/* open all previous libraries */
+LUALIB_API void (luaL_openlibs) (lua_State *L);
+
+
+
+#if !defined(lua_assert)
+#define lua_assert(x)	((void)0)
+#endif
+
+
+#endif

vendor/lua/5.2/lua.odin

@@ -0,0 +1,728 @@
+package lua_5_2
+
+import "core:intrinsics"
+import "core:builtin"
+
+import c "core:c/libc"
+
+#assert(size_of(c.int) == size_of(b32))
+
+when ODIN_OS == .Windows {
+	foreign import lib "windows/lua52dll.lib"
+} else when ODIN_OS == .Linux {
+	foreign import lib "linux/liblua52.a"
+} else {
+	foreign import lib "system:liblua52.a"
+}
+
+VERSION_MAJOR       :: "5"
+VERSION_MINOR       :: "2"
+VERSION_NUM         :: 502
+VERSION_RELEASE     :: "4"
+
+VERSION             :: "Lua " + VERSION_MAJOR + "." + VERSION_MINOR
+RELEASE             :: VERSION + "." + VERSION_RELEASE
+COPYRIGHT           :: RELEASE + "  Copyright (C) 1994-2015 Lua.org, PUC-Rio"
+AUTHORS             :: "R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
+
+
+/* mark for precompiled code ('<esc>Lua') */
+SIGNATURE :: "\x1bLua"
+
+/* option for multiple returns in 'lua_pcall' and 'lua_call' */
+MULTRET :: -1
+
+FIRSTPSEUDOIDX :: -MAXSTACK - 1000
+
+REGISTRYINDEX :: -FIRSTPSEUDOIDX
+
+
+/*
+@@ LUAI_MAXSTACK limits the size of the Lua stack.
+** CHANGE it if you need a different limit. This limit is arbitrary;
+** its only purpose is to stop Lua from consuming unlimited stack
+** space (and to reserve some numbers for pseudo-indices).
+** (It must fit into max(size_t)/32.)
+*/
+MAXSTACK :: 1000000
+
+
+/*
+@@ LUA_EXTRASPACE defines the size of a raw memory area associated with
+** a Lua state with very fast access.
+** CHANGE it if you need a different size.
+*/
+EXTRASPACE :: size_of(rawptr)
+
+
+
+/*
+@@ LUA_IDSIZE gives the maximum size for the description of the source
+@@ of a function in debug information.
+** CHANGE it if you want a different size.
+*/
+IDSIZE :: 60
+
+
+/*
+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+*/
+L_BUFFERSIZE :: c.int(16 * size_of(rawptr) * size_of(Number))
+
+
+MAXALIGNVAL :: max(align_of(Number), align_of(f64), align_of(rawptr), align_of(Integer), align_of(c.long))
+
+
+Status :: enum c.int {
+	OK        = 0,
+	YIELD     = 1,
+	ERRRUN    = 2,
+	ERRSYNTAX = 3,
+	ERRMEM    = 4,
+	ERRERR    = 5,
+	ERRGCMM   = 6,
+	ERRFILE   = 7,
+}
+
+/* thread status */
+OK        :: Status.OK
+YIELD     :: Status.YIELD
+ERRRUN    :: Status.ERRRUN
+ERRSYNTAX :: Status.ERRSYNTAX
+ERRMEM    :: Status.ERRMEM
+ERRERR    :: Status.ERRERR
+ERRFILE   :: Status.ERRFILE
+
+/*
+** basic types
+*/
+
+
+Type :: enum c.int {
+	NONE          = -1,
+
+	NIL           = 0,
+	BOOLEAN       = 1,
+	LIGHTUSERDATA = 2,
+	NUMBER        = 3,
+	STRING        = 4,
+	TABLE         = 5,
+	FUNCTION      = 6,
+	USERDATA      = 7,
+	THREAD        = 8,
+}
+
+TNONE          :: Type.NONE
+TNIL           :: Type.NIL
+TBOOLEAN       :: Type.BOOLEAN
+TLIGHTUSERDATA :: Type.LIGHTUSERDATA
+TNUMBER        :: Type.NUMBER
+TSTRING        :: Type.STRING
+TTABLE         :: Type.TABLE
+TFUNCTION      :: Type.FUNCTION
+TUSERDATA      :: Type.USERDATA
+TTHREAD        :: Type.THREAD
+NUMTYPES :: 9
+
+
+
+ArithOp :: enum c.int {
+	ADD  = 0,	/* ORDER TM, ORDER OP */
+	SUB  = 1,
+	MUL  = 2,
+	DIV  = 3,
+	MOD  = 4,
+	POW  = 5,
+	UNM  = 6,
+}
+
+CompareOp :: enum c.int {
+	EQ = 0,
+	LT = 1,
+	LE = 2,
+}
+
+OPADD :: ArithOp.ADD
+OPSUB :: ArithOp.SUB
+OPMUL :: ArithOp.MUL
+OPDIV :: ArithOp.DIV
+OPMOD :: ArithOp.MOD
+OPPOW :: ArithOp.POW
+OPUNM :: ArithOp.UNM
+
+OPEQ :: CompareOp.EQ
+OPLT :: CompareOp.LT
+OPLE :: CompareOp.LE
+
+
+/* minimum Lua stack available to a C function */
+MINSTACK :: 20
+
+
+/* predefined values in the registry */
+RIDX_MAINTHREAD :: 1
+RIDX_GLOBALS    :: 2
+RIDX_LAST       :: RIDX_GLOBALS
+
+
+/* type of numbers in Lua */
+Number :: distinct (f32 when size_of(uintptr) == 4 else f64)
+
+
+/* type for integer functions */
+Integer :: distinct (i32 when size_of(uintptr) == 4 else i64)
+
+/* unsigned integer type */
+Unsigned :: distinct (u32 when size_of(uintptr) == 4 else u64)
+
+
+/*
+** Type for C functions registered with Lua
+*/
+CFunction :: #type proc "c" (L: ^State) -> c.int
+
+
+
+/*
+** Type for functions that read/write blocks when loading/dumping Lua chunks
+*/
+Reader :: #type proc "c" (L: ^State, ud: rawptr, sz: ^c.size_t) -> cstring
+Writer :: #type proc "c" (L: ^State, p: rawptr, sz: ^c.size_t, ud: rawptr) -> c.int
+
+
+/*
+** Type for memory-allocation functions
+*/
+Alloc :: #type proc "c" (ud: rawptr, ptr: rawptr, osize, nsize: c.size_t) -> rawptr
+
+
+GCWhat :: enum c.int {
+	STOP        = 0,
+	RESTART     = 1,
+	COLLECT     = 2,
+	COUNT       = 3,
+	COUNTB      = 4,
+	STEP        = 5,
+	SETPAUSE    = 6,
+	SETSTEPMUL  = 7,
+	SETMAJORINC = 8,
+	ISRUNNING   = 9,
+	GEN         = 10,
+	INC         = 11,
+}
+GCSTOP        :: GCWhat.STOP
+GCRESTART     :: GCWhat.RESTART
+GCCOLLECT     :: GCWhat.COLLECT
+GCCOUNT       :: GCWhat.COUNT
+GCCOUNTB      :: GCWhat.COUNTB
+GCSTEP        :: GCWhat.STEP
+GCSETPAUSE    :: GCWhat.SETPAUSE
+GCSETSTEPMUL  :: GCWhat.SETSTEPMUL
+GCSETMAJORINC :: GCWhat.SETMAJORINC
+GCISRUNNING   :: GCWhat.ISRUNNING
+GCGEN         :: GCWhat.GEN
+GCINC         :: GCWhat.INC
+
+
+
+/*
+** Event codes
+*/
+
+HookEvent :: enum c.int {
+	CALL     = 0,
+	RET      = 1,
+	LINE     = 2,
+	COUNT    = 3,
+	TAILCALL = 4,
+}
+HOOKCALL     :: HookEvent.CALL
+HOOKRET      :: HookEvent.RET
+HOOKLINE     :: HookEvent.LINE
+HOOKCOUNT    :: HookEvent.COUNT
+HOOKTAILCALL :: HookEvent.TAILCALL
+
+
+/*
+** Event masks
+*/
+HookMask :: distinct bit_set[HookEvent; c.int]
+MASKCALL  :: HookMask{.CALL}
+MASKRET   :: HookMask{.RET}
+MASKLINE  :: HookMask{.LINE}
+MASKCOUNT :: HookMask{.COUNT}
+
+/* activation record */
+Debug :: struct {
+	event:           HookEvent,
+	name:            cstring,                  /* (n) */
+	namewhat:        cstring,                  /* (n) 'global', 'local', 'field', 'method' */
+	what:            cstring,                  /* (S) 'Lua', 'C', 'main', 'tail' */
+	source:          cstring,                  /* (S) */
+	currentline:     c.int,                    /* (l) */
+	linedefined:     c.int,                    /* (S) */
+	lastlinedefined: c.int,                    /* (S) */
+	nups:            u8,                       /* (u) number of upvalues */
+	nparams:         u8,                       /* (u) number of parameters */
+	isvararg:        bool,                     /* (u) */
+	istailcall:      bool,                     /* (t) */
+	short_src:       [IDSIZE]u8 `fmt:"s"`, /* (S) */
+	/* private part */
+	i_ci:            rawptr,                   /* active function */
+}
+
+
+/* Functions to be called by the debugger in specific events */
+Hook :: #type proc "c" (L: ^State, ar: ^Debug)
+
+
+State :: struct {} // opaque data type
+
+
+@(link_prefix="lua_")
+@(default_calling_convention="c")
+foreign lib {
+	/*
+	** RCS ident string
+	*/
+
+	ident: [^]u8 // TODO(bill): is this correct?
+
+
+	/*
+	** state manipulation
+	*/
+
+	newstate  :: proc(f: Alloc, ud: rawptr) -> ^State ---
+	close     :: proc(L: ^State) ---
+	newthread :: proc(L: ^State) -> ^State ---
+
+	atpanic :: proc(L: ^State, panicf: CFunction) -> CFunction ---
+
+	version :: proc(L: ^State) -> ^Number ---
+
+
+	/*
+	** basic stack manipulation
+	*/
+
+	absindex   :: proc (L: ^State, idx: c.int) -> c.int ---
+	gettop     :: proc (L: ^State) -> c.int ---
+	settop     :: proc (L: ^State, idx: c.int) ---
+	pushvalue  :: proc (L: ^State, idx: c.int) ---
+	remove     :: proc (L: ^State, idx: c.int) ---
+	insert     :: proc (L: ^State, idx: c.int) ---
+	replace    :: proc (L: ^State, idx: c.int) ---
+	copy       :: proc (L: ^State, fromidx, toidx: c.int) ---
+	checkstack :: proc (L: ^State, sz: c.int) -> c.int ---
+
+	xmove :: proc(from, to: ^State, n: c.int) ---
+
+
+	/*
+	** access functions (stack -> C)
+	*/
+
+	isnumber    :: proc(L: ^State, idx: c.int) -> b32 ---
+	isstring    :: proc(L: ^State, idx: c.int) -> b32 ---
+	iscfunction :: proc(L: ^State, idx: c.int) -> b32 ---
+	isinteger   :: proc(L: ^State, idx: c.int) -> b32 ---
+	isuserdata  :: proc(L: ^State, idx: c.int) -> b32 ---
+	type        :: proc(L: ^State, idx: c.int) -> Type ---
+	typename    :: proc(L: ^State, tp: Type) -> cstring ---
+
+	@(link_name="lua_tonumberx")
+	tonumber    :: proc(L: ^State, idx: c.int, isnum: ^b32 = nil) -> Number ---
+	@(link_name="lua_tointegerx")
+	tointeger   :: proc(L: ^State, idx: c.int, isnum: ^b32 = nil) -> Integer ---
+	@(link_name="lua_tounsignedx")
+	tounsigned  :: proc(L: ^State, idx: c.int, isnum: ^b32 = nil) -> Unsigned ---
+	toboolean   :: proc(L: ^State, idx: c.int) -> b32 ---
+	tolstring   :: proc(L: ^State, idx: c.int, len: ^c.size_t) -> cstring ---
+	rawlen      :: proc(L: ^State, idx: c.int) -> c.size_t ---
+	tocfunction :: proc(L: ^State, idx: c.int) -> CFunction ---
+	touserdata  :: proc(L: ^State, idx: c.int) -> rawptr ---
+	tothread    :: proc(L: ^State, idx: c.int) -> ^State ---
+	topointer   :: proc(L: ^State, idx: c.int) -> rawptr ---
+
+	/*
+	** Comparison and arithmetic functions
+	*/
+
+	arith    :: proc(L: ^State, op: ArithOp) ---
+	rawequal :: proc(L: ^State, idx1, idx2: c.int) -> b32 ---
+	compare  :: proc(L: ^State, idx1, idx2: c.int, op: CompareOp) -> b32 ---
+
+	/*
+	** push functions (C -> stack)
+	*/
+
+	pushnil      :: proc(L: ^State) ---
+	pushnumber   :: proc(L: ^State, n: Number) ---
+	pushinteger  :: proc(L: ^State, n: Integer) ---
+	pushunsigned :: proc(L: ^State, n: Unsigned) ---
+	pushlstring  :: proc(L: ^State, s: cstring, l: c.size_t) -> cstring ---
+	pushstring   :: proc(L: ^State, s: cstring) -> cstring ---
+	pushvfstring :: proc(L: ^State, fmt: cstring, argp: c.va_list) -> cstring ---
+	pushfstring       :: proc(L: ^State, fmt: cstring, #c_vararg args: ..any) -> cstring ---
+	pushcclosure      :: proc(L: ^State, fn: CFunction, n: c.int) ---
+	pushboolean       :: proc(L: ^State, b: b32) ---
+	pushlightuserdata :: proc(L: ^State, p: rawptr) ---
+	pushthread        :: proc(L: ^State) -> Status ---
+
+	/*
+	** get functions (Lua -> stack)
+	*/
+
+	getglobal :: proc(L: ^State, name: cstring) ---
+	gettable  :: proc(L: ^State, idx: c.int) ---
+	getfield  :: proc(L: ^State, idx: c.int, k: cstring) ---
+	geti      :: proc(L: ^State, idx: c.int, n: Integer) ---
+	rawget    :: proc(L: ^State, idx: c.int) ---
+	rawgeti   :: proc(L: ^State, idx: c.int, n: Integer) ---
+	rawgetp   :: proc(L: ^State, idx: c.int, p: rawptr) ---
+
+	createtable  :: proc(L: ^State, narr, nrec: c.int) ---
+	newuserdata  :: proc(L: ^State, sz: c.size_t) -> rawptr ---
+	getmetatable :: proc(L: ^State, objindex: c.int) -> c.int ---
+	getuservalue :: proc(L: ^State, idx: c.int) ---
+
+
+	/*
+	** set functions (stack -> Lua)
+	*/
+
+	setglobal    :: proc(L: ^State, var: cstring) ---
+	settable     :: proc(L: ^State, idx: c.int) ---
+	setfield     :: proc(L: ^State, idx: c.int, k: cstring) ---
+	rawset       :: proc(L: ^State, idx: c.int) ---
+	rawseti      :: proc(L: ^State, idx: c.int, n: c.int) ---
+	rawsetp      :: proc(L: ^State, idx: c.int, p: rawptr) ---
+	setmetatable :: proc(L: ^State, objindex: c.int) -> c.int ---
+	setuservalue :: proc(L: ^State, idx: c.int) -> c.int ---
+
+
+	/*
+	** 'load' and 'call' functions (load and run Lua code)
+	*/
+
+	@(link_name="lua_callk")
+	call :: proc(L: ^State, nargs, nresults: c.int, ctx: c.int = 0,
+	             k: CFunction = nil) ---
+
+	getctx :: proc(L: ^State, ctx: ^c.int) -> c.int ---
+
+	@(link_name="lua_pcallk")
+	pcall :: proc(L: ^State, nargs, nresults: c.int, errfunc: c.int,
+	              ctx: c.int = 0, k: CFunction = nil) -> c.int ---
+
+	load :: proc(L: ^State, reader: Reader, dt: rawptr,
+	             chunkname, mode: cstring) -> Status ---
+
+	dump :: proc(L: ^State, writer: Writer, data: rawptr) -> Status ---
+
+
+	/*
+	** coroutine functions
+	*/
+
+	@(link_name="lua_yieldk")
+	yield       :: proc(L: ^State, nresults: c.int, ctx: c.int = 0, k: CFunction = nil) -> Status ---
+	resume      :: proc(L: ^State, from: ^State, narg: c.int) -> Status ---
+	status      :: proc(L: ^State) -> Status ---
+
+
+	/*
+	** garbage-collection function and options
+	*/
+
+
+
+	gc :: proc(L: ^State, what: GCWhat, data: c.int) -> c.int ---
+
+
+	/*
+	** miscellaneous functions
+	*/
+
+	error :: proc(L: ^State) -> Status ---
+
+	next :: proc(L: ^State, idx: c.int) -> c.int ---
+
+	concat :: proc(L: ^State, n: c.int) ---
+	len    :: proc(L: ^State, idx: c.int) ---
+
+	getallocf :: proc(L: State, ud: ^rawptr) -> Alloc ---
+	setallocf :: proc(L: ^State, f: Alloc, ud: rawptr) ---
+
+	/*
+	** {======================================================================
+	** Debug API
+	** =======================================================================
+	*/
+
+	getstack   :: proc(L: ^State, level: c.int, ar: ^Debug) -> c.int ---
+	getinfo    :: proc(L: ^State, what: cstring, ar: ^Debug) -> c.int ---
+	getlocal   :: proc(L: ^State, ar: ^Debug, n: c.int) -> cstring ---
+	setlocal   :: proc(L: ^State, ar: ^Debug, n: c.int) -> cstring ---
+	getupvalue :: proc(L: ^State, funcindex: c.int, n: c.int) -> cstring ---
+	setupvalue :: proc(L: ^State, funcindex: c.int, n: c.int) -> cstring ---
+
+	upvalueid   :: proc(L: ^State, fidx, n: c.int) -> rawptr ---
+	upvaluejoin :: proc(L: ^State, fidx1, n1, fidx2, n2: c.int) ---
+
+	sethook :: proc(L: ^State, func: Hook, mask: HookMask, count: c.int) -> c.int ---
+	gethook :: proc(L: ^State) -> Hook ---
+	gethookmask  :: proc(L: ^State) -> HookMask ---
+	gethookcount :: proc(L: ^State) -> c.int ---
+
+	/* }============================================================== */
+}
+
+
+
+/* version suffix for environment variable names */
+VERSUFFIX :: "_" + VERSION_MAJOR + "_" + VERSION_MINOR
+
+COLIBNAME   :: "coroutine"
+TABLIBNAME  :: "table"
+IOLIBNAME   :: "io"
+OSLIBNAME   :: "os"
+STRLIBNAME  :: "string"
+UTF8LIBNAME :: "utf8"
+BITLIBNAME  :: "bit32"
+MATHLIBNAME :: "math"
+DBLIBNAME   :: "debug"
+LOADLIBNAME :: "package"
+
+@(link_prefix="lua")
+@(default_calling_convention="c")
+foreign lib {
+	open_base      :: proc(L: ^State) -> c.int ---
+	open_coroutine :: proc(L: ^State) -> c.int ---
+	open_table     :: proc(L: ^State) -> c.int ---
+	open_io        :: proc(L: ^State) -> c.int ---
+	open_os        :: proc(L: ^State) -> c.int ---
+	open_string    :: proc(L: ^State) -> c.int ---
+	open_utf8      :: proc(L: ^State) -> c.int ---
+	open_bit32     :: proc(L: ^State) -> c.int ---
+	open_math      :: proc(L: ^State) -> c.int ---
+	open_debug     :: proc(L: ^State) -> c.int ---
+	open_package   :: proc(L: ^State) -> c.int ---
+
+	/* open all previous libraries */
+
+	L_openlibs :: proc(L: ^State) ---
+}
+
+
+
+GNAME :: "_G"
+
+L_Reg :: struct {
+	name: cstring,
+  	func: CFunction,
+}
+
+
+/* predefined references */
+NOREF  :: -2
+REFNIL :: -1
+
+
+@(link_prefix="lua")
+@(default_calling_convention="c")
+foreign lib {
+	@(link_name="luaL_checkversion_")
+	L_checkversion :: proc(L: ^State, ver: Number = VERSION_NUM) ---
+
+
+	L_getmetafield :: proc(L: ^State, obj: c.int, e: cstring) -> c.int ---
+	L_callmeta     :: proc(L: ^State, obj: c.int, e: cstring) -> c.int ---
+	@(link_name="luaL_tolstring")
+	L_tostring     :: proc(L: ^State, idx: c.int, len: ^c.size_t = nil) -> cstring ---
+	L_argerror     :: proc(L: ^State, numarg: c.int, extramsg: cstring) -> c.int ---
+	@(link_name="luaL_checklstring")
+	L_checkstring  :: proc(L: ^State, numArg: c.int, l: ^c.size_t = nil) -> cstring ---
+	@(link_name="luaL_optlstring")
+	L_optstring    :: proc(L: ^State, numArg: c.int, def: cstring, l: ^c.size_t = nil) -> cstring ---
+	L_checknumber  :: proc(L: ^State, numArg: c.int) -> Number ---
+	L_optnumber    :: proc(L: ^State, nArg: c.int, def: Number) -> Number ---
+
+	L_checkinteger  :: proc(L: ^State, numArg: c.int) -> Integer ---
+	L_optinteger    :: proc(L: ^State, nArg: c.int, def: Integer) -> Integer ---
+	L_checkunsigned :: proc(L: ^State, numArg: c.int) -> Unsigned ---
+	L_optunsigned   :: proc(L: ^State, nArg: c.int, def: Unsigned) -> Unsigned ---
+
+
+	L_checkstack :: proc(L: ^State, sz: c.int, msg: cstring) ---
+	L_checktype  :: proc(L: ^State, narg: c.int, t: c.int) ---
+	L_checkany   :: proc(L: ^State, narg: c.int) ---
+
+	L_newmetatable :: proc(L: ^State, tname: cstring) -> c.int ---
+	L_setmetatable :: proc(L: ^State, tname: cstring) ---
+	L_testudata    :: proc(L: ^State, ud: c.int, tname: cstring) -> rawptr ---
+	L_checkudata   :: proc(L: ^State, ud: c.int, tname: cstring) -> rawptr ---
+
+	L_where :: proc(L: ^State, lvl: c.int) ---
+	L_error :: proc(L: ^State, fmt: cstring, #c_vararg args: ..any) -> Status ---
+
+	L_checkoption :: proc(L: ^State, narg: c.int, def: cstring, lst: [^]cstring) -> c.int ---
+
+	L_fileresult :: proc(L: ^State, stat: c.int, fname: cstring) -> c.int ---
+	L_execresult :: proc(L: ^State, stat: c.int) -> c.int ---
+
+
+	L_ref   :: proc(L: ^State, t: c.int) -> c.int ---
+	L_unref :: proc(L: ^State, t: c.int, ref: c.int) ---
+
+	@(link_name="luaL_loadfilex")
+	L_loadfile :: proc (L: ^State, filename: cstring, mode: cstring = nil) -> Status ---
+
+	@(link_name="luaL_loadbufferx")
+	L_loadbuffer :: proc(L: ^State, buff: [^]byte, sz: c.size_t, name: cstring, mode: cstring = nil) -> Status ---
+	L_loadstring  :: proc(L: ^State, s: cstring) -> Status ---
+
+	L_newstate :: proc() -> ^State ---
+
+	L_len :: proc(L: ^State, idx: c.int) -> c.int ---
+
+	L_gsub :: proc(L: ^State, s, p, r: cstring) -> cstring ---
+
+	L_setfuncs :: proc(L: ^State, l: [^]L_Reg, nup: c.int) ---
+
+	L_getsubtable :: proc(L: ^State, idx: c.int, fname: cstring) -> c.int ---
+
+	L_traceback   :: proc(L: ^State, L1: ^State, msg: cstring, level: c.int) ---
+
+	L_requiref    :: proc(L: ^State, modname: cstring, openf: CFunction, glb: c.int) ---
+
+}
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+
+L_Buffer :: struct {
+	b:    [^]byte,  /* buffer address */
+	size: c.size_t, /* buffer size */
+	n:    c.size_t, /* number of characters in buffer */
+	L:    ^State,
+	initb: [L_BUFFERSIZE]byte,  /* initial buffer */
+}
+
+L_addchar :: #force_inline proc "c" (B: ^L_Buffer, c: byte) {
+	if B.n < B.size {
+		L_prepbuffsize(B, 1)
+	}
+	B.b[B.n] = c
+	B.n += 1
+}
+
+L_addsize :: #force_inline proc "c" (B: ^L_Buffer, s: c.size_t) -> c.size_t {
+	B.n += s
+	return B.n
+}
+
+L_prepbuffer :: #force_inline proc "c" (B: ^L_Buffer) -> [^]byte {
+	return L_prepbuffsize(B, c.size_t(L_BUFFERSIZE))
+}
+
+
+@(link_prefix="lua")
+@(default_calling_convention="c")
+foreign lib {
+	L_buffinit       :: proc(L: ^State, B: ^L_Buffer) ---
+	L_prepbuffsize   :: proc(B: ^L_Buffer, sz: c.size_t) -> [^]byte ---
+	L_addlstring     :: proc(B: ^L_Buffer, s: cstring, l: c.size_t) ---
+	L_addstring      :: proc(B: ^L_Buffer, s: cstring) ---
+	L_addvalue       :: proc(B: ^L_Buffer) ---
+	L_pushresult     :: proc(B: ^L_Buffer) ---
+	L_pushresultsize :: proc(B: ^L_Buffer, sz: c.size_t) ---
+	L_buffinitsize   :: proc(L: ^State, B: ^L_Buffer, sz: c.size_t) -> [^]byte ---
+}
+
+
+/* }====================================================== */
+
+
+
+
+/*
+** {==============================================================
+** some useful macros
+** ===============================================================
+*/
+
+pop :: #force_inline proc "c" (L: ^State, n: c.int) {
+	settop(L, -n-1)
+}
+newtable :: #force_inline proc "c" (L: ^State) {
+	createtable(L, 0, 0)
+}
+register :: #force_inline proc "c" (L: ^State, n: cstring, f: CFunction) {
+	pushcfunction(L, f)
+	setglobal(L, n)
+}
+
+pushcfunction :: #force_inline proc "c" (L: ^State, f: CFunction) {
+	pushcclosure(L, f, 0)
+}
+
+
+isfunction      :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .FUNCTION      }
+istable         :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .TABLE         }
+islightuserdata :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .LIGHTUSERDATA }
+isnil           :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .NIL           }
+isboolean       :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .BOOLEAN       }
+isthread        :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .THREAD        }
+isnone          :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .NONE          }
+isnoneornil     :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) <= .NIL           }
+
+
+pushliteral :: pushstring
+pushglobaltable :: #force_inline proc "c" (L: ^State) {
+	rawgeti(L, REGISTRYINDEX, RIDX_GLOBALS)
+}
+tostring :: #force_inline proc "c" (L: ^State, i: c.int) -> cstring {
+	return tolstring(L, i, nil)
+}
+
+L_newlibtable :: #force_inline proc "c" (L: ^State, l: []L_Reg) {
+	createtable(L, 0, c.int(builtin.len(l) - 1))
+}
+
+L_newlib :: proc(L: ^State, l: []L_Reg) {
+	L_newlibtable(L, l)
+	L_setfuncs(L, raw_data(l), 0)
+}
+
+L_argcheck :: #force_inline proc "c" (L: ^State, cond: bool, numarg: c.int, extramsg: cstring) {
+	if cond {
+		L_argerror(L, numarg, extramsg)
+	}
+}
+
+L_typename :: #force_inline proc "c" (L: ^State, i: c.int) -> cstring {
+	return typename(L, type(L, i))
+}
+L_dofile :: #force_inline proc "c" (L: ^State, s: cstring) -> c.int {
+	err := L_loadfile(L, s)
+	return pcall(L, 0, MULTRET, 0) if err == nil else c.int(err)
+}
+L_dostring :: #force_inline proc "c" (L: ^State, s: cstring) -> c.int {
+	err := L_loadstring(L, s)
+	return pcall(L, 0, MULTRET, 0) if err == nil else c.int(err)
+}
+L_getmetatable :: #force_inline proc "c" (L: ^State, n: cstring) {
+	getfield(L, REGISTRYINDEX, n)
+}
+L_opt :: #force_inline proc "c" (L: ^State, f: $F, n: c.int, d: $T) -> T where intrinsics.type_is_proc(F) {
+	return d if isnoneornil(L, n) else f(L, n)
+}
+
+
+
+/* }============================================================== */

vendor/lua/5.3/include/lauxlib.h

@@ -0,0 +1,264 @@
+/*
+** $Id: lauxlib.h,v 1.131.1.1 2017/04/19 17:20:42 roberto Exp $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lauxlib_h
+#define lauxlib_h
+
+
+#include <stddef.h>
+#include <stdio.h>
+
+#include "lua.h"
+
+
+
+/* extra error code for 'luaL_loadfilex' */
+#define LUA_ERRFILE     (LUA_ERRERR+1)
+
+
+/* key, in the registry, for table of loaded modules */
+#define LUA_LOADED_TABLE	"_LOADED"
+
+
+/* key, in the registry, for table of preloaded loaders */
+#define LUA_PRELOAD_TABLE	"_PRELOAD"
+
+
+typedef struct luaL_Reg {
+  const char *name;
+  lua_CFunction func;
+} luaL_Reg;
+
+
+#define LUAL_NUMSIZES	(sizeof(lua_Integer)*16 + sizeof(lua_Number))
+
+LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz);
+#define luaL_checkversion(L)  \
+	  luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)
+
+LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
+LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
+LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg);
+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg,
+                                                          size_t *l);
+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg,
+                                          const char *def, size_t *l);
+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);
+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);
+
+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);
+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,
+                                          lua_Integer def);
+
+LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
+LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);
+LUALIB_API void (luaL_checkany) (lua_State *L, int arg);
+
+LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
+LUALIB_API void  (luaL_setmetatable) (lua_State *L, const char *tname);
+LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
+LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
+
+LUALIB_API void (luaL_where) (lua_State *L, int lvl);
+LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
+
+LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def,
+                                   const char *const lst[]);
+
+LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
+LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
+
+/* predefined references */
+#define LUA_NOREF       (-2)
+#define LUA_REFNIL      (-1)
+
+LUALIB_API int (luaL_ref) (lua_State *L, int t);
+LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
+
+LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
+                                               const char *mode);
+
+#define luaL_loadfile(L,f)	luaL_loadfilex(L,f,NULL)
+
+LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
+                                   const char *name, const char *mode);
+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
+
+LUALIB_API lua_State *(luaL_newstate) (void);
+
+LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx);
+
+LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
+                                                  const char *r);
+
+LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
+
+LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
+
+LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
+                                  const char *msg, int level);
+
+LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
+                                 lua_CFunction openf, int glb);
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+
+#define luaL_newlibtable(L,l)	\
+  lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
+
+#define luaL_newlib(L,l)  \
+  (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
+
+#define luaL_argcheck(L, cond,arg,extramsg)	\
+		((void)((cond) || luaL_argerror(L, (arg), (extramsg))))
+#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
+#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
+
+#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
+
+#define luaL_dofile(L, fn) \
+	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_dostring(L, s) \
+	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))
+
+#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
+
+#define luaL_loadbuffer(L,s,sz,n)	luaL_loadbufferx(L,s,sz,n,NULL)
+
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+typedef struct luaL_Buffer {
+  char *b;  /* buffer address */
+  size_t size;  /* buffer size */
+  size_t n;  /* number of characters in buffer */
+  lua_State *L;
+  char initb[LUAL_BUFFERSIZE];  /* initial buffer */
+} luaL_Buffer;
+
+
+#define luaL_addchar(B,c) \
+  ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
+   ((B)->b[(B)->n++] = (c)))
+
+#define luaL_addsize(B,s)	((B)->n += (s))
+
+LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
+LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
+LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
+LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
+
+#define luaL_prepbuffer(B)	luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
+
+/* }====================================================== */
+
+
+
+/*
+** {======================================================
+** File handles for IO library
+** =======================================================
+*/
+
+/*
+** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
+** initial structure 'luaL_Stream' (it may contain other fields
+** after that initial structure).
+*/
+
+#define LUA_FILEHANDLE          "FILE*"
+
+
+typedef struct luaL_Stream {
+  FILE *f;  /* stream (NULL for incompletely created streams) */
+  lua_CFunction closef;  /* to close stream (NULL for closed streams) */
+} luaL_Stream;
+
+/* }====================================================== */
+
+
+
+/* compatibility with old module system */
+#if defined(LUA_COMPAT_MODULE)
+
+LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,
+                                   int sizehint);
+LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
+                                const luaL_Reg *l, int nup);
+
+#define luaL_register(L,n,l)	(luaL_openlib(L,(n),(l),0))
+
+#endif
+
+
+/*
+** {==================================================================
+** "Abstraction Layer" for basic report of messages and errors
+** ===================================================================
+*/
+
+/* print a string */
+#if !defined(lua_writestring)
+#define lua_writestring(s,l)   fwrite((s), sizeof(char), (l), stdout)
+#endif
+
+/* print a newline and flush the output */
+#if !defined(lua_writeline)
+#define lua_writeline()        (lua_writestring("\n", 1), fflush(stdout))
+#endif
+
+/* print an error message */
+#if !defined(lua_writestringerror)
+#define lua_writestringerror(s,p) \
+        (fprintf(stderr, (s), (p)), fflush(stderr))
+#endif
+
+/* }================================================================== */
+
+
+/*
+** {============================================================
+** Compatibility with deprecated conversions
+** =============================================================
+*/
+#if defined(LUA_COMPAT_APIINTCASTS)
+
+#define luaL_checkunsigned(L,a)	((lua_Unsigned)luaL_checkinteger(L,a))
+#define luaL_optunsigned(L,a,d)	\
+	((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d)))
+
+#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
+
+#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
+
+#endif
+/* }============================================================ */
+
+
+
+#endif
+
+

vendor/lua/5.3/include/lua.h

@@ -0,0 +1,485 @@
+/*
+** Lua - A Scripting Language
+** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
+** See Copyright Notice at the end of this file
+*/
+
+
+#ifndef lua_h
+#define lua_h
+
+#include <stdarg.h>
+#include <stddef.h>
+
+
+#include "luaconf.h"
+
+
+#define LUA_VERSION_MAJOR	"5"
+#define LUA_VERSION_MINOR	"3"
+#define LUA_VERSION_NUM		503
+#define LUA_VERSION_RELEASE	"6"
+
+#define LUA_VERSION	"Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
+#define LUA_RELEASE	LUA_VERSION "." LUA_VERSION_RELEASE
+#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2020 Lua.org, PUC-Rio"
+#define LUA_AUTHORS	"R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
+
+
+/* mark for precompiled code ('<esc>Lua') */
+#define LUA_SIGNATURE	"\x1bLua"
+
+/* option for multiple returns in 'lua_pcall' and 'lua_call' */
+#define LUA_MULTRET	(-1)
+
+
+/*
+** Pseudo-indices
+** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty
+** space after that to help overflow detection)
+*/
+#define LUA_REGISTRYINDEX	(-LUAI_MAXSTACK - 1000)
+#define lua_upvalueindex(i)	(LUA_REGISTRYINDEX - (i))
+
+
+/* thread status */
+#define LUA_OK		0
+#define LUA_YIELD	1
+#define LUA_ERRRUN	2
+#define LUA_ERRSYNTAX	3
+#define LUA_ERRMEM	4
+#define LUA_ERRGCMM	5
+#define LUA_ERRERR	6
+
+
+typedef struct lua_State lua_State;
+
+
+/*
+** basic types
+*/
+#define LUA_TNONE		(-1)
+
+#define LUA_TNIL		0
+#define LUA_TBOOLEAN		1
+#define LUA_TLIGHTUSERDATA	2
+#define LUA_TNUMBER		3
+#define LUA_TSTRING		4
+#define LUA_TTABLE		5
+#define LUA_TFUNCTION		6
+#define LUA_TUSERDATA		7
+#define LUA_TTHREAD		8
+
+#define LUA_NUMTAGS		9
+
+
+
+/* minimum Lua stack available to a C function */
+#define LUA_MINSTACK	20
+
+
+/* predefined values in the registry */
+#define LUA_RIDX_MAINTHREAD	1
+#define LUA_RIDX_GLOBALS	2
+#define LUA_RIDX_LAST		LUA_RIDX_GLOBALS
+
+
+/* type of numbers in Lua */
+typedef LUA_NUMBER lua_Number;
+
+
+/* type for integer functions */
+typedef LUA_INTEGER lua_Integer;
+
+/* unsigned integer type */
+typedef LUA_UNSIGNED lua_Unsigned;
+
+/* type for continuation-function contexts */
+typedef LUA_KCONTEXT lua_KContext;
+
+
+/*
+** Type for C functions registered with Lua
+*/
+typedef int (*lua_CFunction) (lua_State *L);
+
+/*
+** Type for continuation functions
+*/
+typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);
+
+
+/*
+** Type for functions that read/write blocks when loading/dumping Lua chunks
+*/
+typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
+
+typedef int (*lua_Writer) (lua_State *L, const void *p, size_t sz, void *ud);
+
+
+/*
+** Type for memory-allocation functions
+*/
+typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
+
+
+
+/*
+** generic extra include file
+*/
+#if defined(LUA_USER_H)
+#include LUA_USER_H
+#endif
+
+
+/*
+** RCS ident string
+*/
+extern const char lua_ident[];
+
+
+/*
+** state manipulation
+*/
+LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
+LUA_API void       (lua_close) (lua_State *L);
+LUA_API lua_State *(lua_newthread) (lua_State *L);
+
+LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
+
+
+LUA_API const lua_Number *(lua_version) (lua_State *L);
+
+
+/*
+** basic stack manipulation
+*/
+LUA_API int   (lua_absindex) (lua_State *L, int idx);
+LUA_API int   (lua_gettop) (lua_State *L);
+LUA_API void  (lua_settop) (lua_State *L, int idx);
+LUA_API void  (lua_pushvalue) (lua_State *L, int idx);
+LUA_API void  (lua_rotate) (lua_State *L, int idx, int n);
+LUA_API void  (lua_copy) (lua_State *L, int fromidx, int toidx);
+LUA_API int   (lua_checkstack) (lua_State *L, int n);
+
+LUA_API void  (lua_xmove) (lua_State *from, lua_State *to, int n);
+
+
+/*
+** access functions (stack -> C)
+*/
+
+LUA_API int             (lua_isnumber) (lua_State *L, int idx);
+LUA_API int             (lua_isstring) (lua_State *L, int idx);
+LUA_API int             (lua_iscfunction) (lua_State *L, int idx);
+LUA_API int             (lua_isinteger) (lua_State *L, int idx);
+LUA_API int             (lua_isuserdata) (lua_State *L, int idx);
+LUA_API int             (lua_type) (lua_State *L, int idx);
+LUA_API const char     *(lua_typename) (lua_State *L, int tp);
+
+LUA_API lua_Number      (lua_tonumberx) (lua_State *L, int idx, int *isnum);
+LUA_API lua_Integer     (lua_tointegerx) (lua_State *L, int idx, int *isnum);
+LUA_API int             (lua_toboolean) (lua_State *L, int idx);
+LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
+LUA_API size_t          (lua_rawlen) (lua_State *L, int idx);
+LUA_API lua_CFunction   (lua_tocfunction) (lua_State *L, int idx);
+LUA_API void	       *(lua_touserdata) (lua_State *L, int idx);
+LUA_API lua_State      *(lua_tothread) (lua_State *L, int idx);
+LUA_API const void     *(lua_topointer) (lua_State *L, int idx);
+
+
+/*
+** Comparison and arithmetic functions
+*/
+
+#define LUA_OPADD	0	/* ORDER TM, ORDER OP */
+#define LUA_OPSUB	1
+#define LUA_OPMUL	2
+#define LUA_OPMOD	3
+#define LUA_OPPOW	4
+#define LUA_OPDIV	5
+#define LUA_OPIDIV	6
+#define LUA_OPBAND	7
+#define LUA_OPBOR	8
+#define LUA_OPBXOR	9
+#define LUA_OPSHL	10
+#define LUA_OPSHR	11
+#define LUA_OPUNM	12
+#define LUA_OPBNOT	13
+
+LUA_API void  (lua_arith) (lua_State *L, int op);
+
+#define LUA_OPEQ	0
+#define LUA_OPLT	1
+#define LUA_OPLE	2
+
+LUA_API int   (lua_rawequal) (lua_State *L, int idx1, int idx2);
+LUA_API int   (lua_compare) (lua_State *L, int idx1, int idx2, int op);
+
+
+/*
+** push functions (C -> stack)
+*/
+LUA_API void        (lua_pushnil) (lua_State *L);
+LUA_API void        (lua_pushnumber) (lua_State *L, lua_Number n);
+LUA_API void        (lua_pushinteger) (lua_State *L, lua_Integer n);
+LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len);
+LUA_API const char *(lua_pushstring) (lua_State *L, const char *s);
+LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
+                                                      va_list argp);
+LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
+LUA_API void  (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
+LUA_API void  (lua_pushboolean) (lua_State *L, int b);
+LUA_API void  (lua_pushlightuserdata) (lua_State *L, void *p);
+LUA_API int   (lua_pushthread) (lua_State *L);
+
+
+/*
+** get functions (Lua -> stack)
+*/
+LUA_API int (lua_getglobal) (lua_State *L, const char *name);
+LUA_API int (lua_gettable) (lua_State *L, int idx);
+LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k);
+LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n);
+LUA_API int (lua_rawget) (lua_State *L, int idx);
+LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n);
+LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p);
+
+LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
+LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
+LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
+LUA_API int  (lua_getuservalue) (lua_State *L, int idx);
+
+
+/*
+** set functions (stack -> Lua)
+*/
+LUA_API void  (lua_setglobal) (lua_State *L, const char *name);
+LUA_API void  (lua_settable) (lua_State *L, int idx);
+LUA_API void  (lua_setfield) (lua_State *L, int idx, const char *k);
+LUA_API void  (lua_seti) (lua_State *L, int idx, lua_Integer n);
+LUA_API void  (lua_rawset) (lua_State *L, int idx);
+LUA_API void  (lua_rawseti) (lua_State *L, int idx, lua_Integer n);
+LUA_API void  (lua_rawsetp) (lua_State *L, int idx, const void *p);
+LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
+LUA_API void  (lua_setuservalue) (lua_State *L, int idx);
+
+
+/*
+** 'load' and 'call' functions (load and run Lua code)
+*/
+LUA_API void  (lua_callk) (lua_State *L, int nargs, int nresults,
+                           lua_KContext ctx, lua_KFunction k);
+#define lua_call(L,n,r)		lua_callk(L, (n), (r), 0, NULL)
+
+LUA_API int   (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
+                            lua_KContext ctx, lua_KFunction k);
+#define lua_pcall(L,n,r,f)	lua_pcallk(L, (n), (r), (f), 0, NULL)
+
+LUA_API int   (lua_load) (lua_State *L, lua_Reader reader, void *dt,
+                          const char *chunkname, const char *mode);
+
+LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip);
+
+
+/*
+** coroutine functions
+*/
+LUA_API int  (lua_yieldk)     (lua_State *L, int nresults, lua_KContext ctx,
+                               lua_KFunction k);
+LUA_API int  (lua_resume)     (lua_State *L, lua_State *from, int narg);
+LUA_API int  (lua_status)     (lua_State *L);
+LUA_API int (lua_isyieldable) (lua_State *L);
+
+#define lua_yield(L,n)		lua_yieldk(L, (n), 0, NULL)
+
+
+/*
+** garbage-collection function and options
+*/
+
+#define LUA_GCSTOP		0
+#define LUA_GCRESTART		1
+#define LUA_GCCOLLECT		2
+#define LUA_GCCOUNT		3
+#define LUA_GCCOUNTB		4
+#define LUA_GCSTEP		5
+#define LUA_GCSETPAUSE		6
+#define LUA_GCSETSTEPMUL	7
+#define LUA_GCISRUNNING		9
+
+LUA_API int (lua_gc) (lua_State *L, int what, int data);
+
+
+/*
+** miscellaneous functions
+*/
+
+LUA_API int   (lua_error) (lua_State *L);
+
+LUA_API int   (lua_next) (lua_State *L, int idx);
+
+LUA_API void  (lua_concat) (lua_State *L, int n);
+LUA_API void  (lua_len)    (lua_State *L, int idx);
+
+LUA_API size_t   (lua_stringtonumber) (lua_State *L, const char *s);
+
+LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
+LUA_API void      (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
+
+
+
+/*
+** {==============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define lua_getextraspace(L)	((void *)((char *)(L) - LUA_EXTRASPACE))
+
+#define lua_tonumber(L,i)	lua_tonumberx(L,(i),NULL)
+#define lua_tointeger(L,i)	lua_tointegerx(L,(i),NULL)
+
+#define lua_pop(L,n)		lua_settop(L, -(n)-1)
+
+#define lua_newtable(L)		lua_createtable(L, 0, 0)
+
+#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
+
+#define lua_pushcfunction(L,f)	lua_pushcclosure(L, (f), 0)
+
+#define lua_isfunction(L,n)	(lua_type(L, (n)) == LUA_TFUNCTION)
+#define lua_istable(L,n)	(lua_type(L, (n)) == LUA_TTABLE)
+#define lua_islightuserdata(L,n)	(lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
+#define lua_isnil(L,n)		(lua_type(L, (n)) == LUA_TNIL)
+#define lua_isboolean(L,n)	(lua_type(L, (n)) == LUA_TBOOLEAN)
+#define lua_isthread(L,n)	(lua_type(L, (n)) == LUA_TTHREAD)
+#define lua_isnone(L,n)		(lua_type(L, (n)) == LUA_TNONE)
+#define lua_isnoneornil(L, n)	(lua_type(L, (n)) <= 0)
+
+#define lua_pushliteral(L, s)	lua_pushstring(L, "" s)
+
+#define lua_pushglobaltable(L)  \
+	((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS))
+
+#define lua_tostring(L,i)	lua_tolstring(L, (i), NULL)
+
+
+#define lua_insert(L,idx)	lua_rotate(L, (idx), 1)
+
+#define lua_remove(L,idx)	(lua_rotate(L, (idx), -1), lua_pop(L, 1))
+
+#define lua_replace(L,idx)	(lua_copy(L, -1, (idx)), lua_pop(L, 1))
+
+/* }============================================================== */
+
+
+/*
+** {==============================================================
+** compatibility macros for unsigned conversions
+** ===============================================================
+*/
+#if defined(LUA_COMPAT_APIINTCASTS)
+
+#define lua_pushunsigned(L,n)	lua_pushinteger(L, (lua_Integer)(n))
+#define lua_tounsignedx(L,i,is)	((lua_Unsigned)lua_tointegerx(L,i,is))
+#define lua_tounsigned(L,i)	lua_tounsignedx(L,(i),NULL)
+
+#endif
+/* }============================================================== */
+
+/*
+** {======================================================================
+** Debug API
+** =======================================================================
+*/
+
+
+/*
+** Event codes
+*/
+#define LUA_HOOKCALL	0
+#define LUA_HOOKRET	1
+#define LUA_HOOKLINE	2
+#define LUA_HOOKCOUNT	3
+#define LUA_HOOKTAILCALL 4
+
+
+/*
+** Event masks
+*/
+#define LUA_MASKCALL	(1 << LUA_HOOKCALL)
+#define LUA_MASKRET	(1 << LUA_HOOKRET)
+#define LUA_MASKLINE	(1 << LUA_HOOKLINE)
+#define LUA_MASKCOUNT	(1 << LUA_HOOKCOUNT)
+
+typedef struct lua_Debug lua_Debug;  /* activation record */
+
+
+/* Functions to be called by the debugger in specific events */
+typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
+
+
+LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar);
+LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar);
+LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n);
+LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n);
+
+LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n);
+LUA_API void  (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,
+                                               int fidx2, int n2);
+
+LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
+LUA_API lua_Hook (lua_gethook) (lua_State *L);
+LUA_API int (lua_gethookmask) (lua_State *L);
+LUA_API int (lua_gethookcount) (lua_State *L);
+
+
+struct lua_Debug {
+  int event;
+  const char *name;	/* (n) */
+  const char *namewhat;	/* (n) 'global', 'local', 'field', 'method' */
+  const char *what;	/* (S) 'Lua', 'C', 'main', 'tail' */
+  const char *source;	/* (S) */
+  int currentline;	/* (l) */
+  int linedefined;	/* (S) */
+  int lastlinedefined;	/* (S) */
+  unsigned char nups;	/* (u) number of upvalues */
+  unsigned char nparams;/* (u) number of parameters */
+  char isvararg;        /* (u) */
+  char istailcall;	/* (t) */
+  char short_src[LUA_IDSIZE]; /* (S) */
+  /* private part */
+  struct CallInfo *i_ci;  /* active function */
+};
+
+/* }====================================================================== */
+
+
+/******************************************************************************
+* Copyright (C) 1994-2020 Lua.org, PUC-Rio.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+******************************************************************************/
+
+
+#endif

vendor/lua/5.3/include/lua.hpp

@@ -0,0 +1,9 @@
+// lua.hpp
+// Lua header files for C++
+// <<extern "C">> not supplied automatically because Lua also compiles as C++
+
+extern "C" {
+#include "lua.h"
+#include "lualib.h"
+#include "lauxlib.h"
+}

vendor/lua/5.3/include/luaconf.h

@@ -0,0 +1,792 @@
+/*
+** $Id: luaconf.h,v 1.259.1.1 2017/04/19 17:29:57 roberto Exp $
+** Configuration file for Lua
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef luaconf_h
+#define luaconf_h
+
+#include <limits.h>
+#include <stddef.h>
+
+
+/*
+** ===================================================================
+** Search for "@@" to find all configurable definitions.
+** ===================================================================
+*/
+
+
+/*
+** {====================================================================
+** System Configuration: macros to adapt (if needed) Lua to some
+** particular platform, for instance compiling it with 32-bit numbers or
+** restricting it to C89.
+** =====================================================================
+*/
+
+/*
+@@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats. You
+** can also define LUA_32BITS in the make file, but changing here you
+** ensure that all software connected to Lua will be compiled with the
+** same configuration.
+*/
+/* #define LUA_32BITS */
+
+
+/*
+@@ LUA_USE_C89 controls the use of non-ISO-C89 features.
+** Define it if you want Lua to avoid the use of a few C99 features
+** or Windows-specific features on Windows.
+*/
+/* #define LUA_USE_C89 */
+
+
+/*
+** By default, Lua on Windows use (some) specific Windows features
+*/
+#if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE)
+#define LUA_USE_WINDOWS  /* enable goodies for regular Windows */
+#endif
+
+
+#if defined(LUA_USE_WINDOWS)
+#define LUA_DL_DLL	/* enable support for DLL */
+#define LUA_USE_C89	/* broadly, Windows is C89 */
+#endif
+
+
+#if defined(LUA_USE_LINUX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
+#define LUA_USE_READLINE	/* needs some extra libraries */
+#endif
+
+
+#if defined(LUA_USE_MACOSX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN		/* MacOS does not need -ldl */
+#define LUA_USE_READLINE	/* needs an extra library: -lreadline */
+#endif
+
+
+/*
+@@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for
+** C89 ('long' and 'double'); Windows always has '__int64', so it does
+** not need to use this case.
+*/
+#if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS)
+#define LUA_C89_NUMBERS
+#endif
+
+
+
+/*
+@@ LUAI_BITSINT defines the (minimum) number of bits in an 'int'.
+*/
+/* avoid undefined shifts */
+#if ((INT_MAX >> 15) >> 15) >= 1
+#define LUAI_BITSINT	32
+#else
+/* 'int' always must have at least 16 bits */
+#define LUAI_BITSINT	16
+#endif
+
+
+/*
+@@ LUA_INT_TYPE defines the type for Lua integers.
+@@ LUA_FLOAT_TYPE defines the type for Lua floats.
+** Lua should work fine with any mix of these options (if supported
+** by your C compiler). The usual configurations are 64-bit integers
+** and 'double' (the default), 32-bit integers and 'float' (for
+** restricted platforms), and 'long'/'double' (for C compilers not
+** compliant with C99, which may not have support for 'long long').
+*/
+
+/* predefined options for LUA_INT_TYPE */
+#define LUA_INT_INT		1
+#define LUA_INT_LONG		2
+#define LUA_INT_LONGLONG	3
+
+/* predefined options for LUA_FLOAT_TYPE */
+#define LUA_FLOAT_FLOAT		1
+#define LUA_FLOAT_DOUBLE	2
+#define LUA_FLOAT_LONGDOUBLE	3
+
+#if defined(LUA_32BITS)		/* { */
+/*
+** 32-bit integers and 'float'
+*/
+#if LUAI_BITSINT >= 32  /* use 'int' if big enough */
+#define LUA_INT_TYPE	LUA_INT_INT
+#else  /* otherwise use 'long' */
+#define LUA_INT_TYPE	LUA_INT_LONG
+#endif
+#define LUA_FLOAT_TYPE	LUA_FLOAT_FLOAT
+
+#elif defined(LUA_C89_NUMBERS)	/* }{ */
+/*
+** largest types available for C89 ('long' and 'double')
+*/
+#define LUA_INT_TYPE	LUA_INT_LONG
+#define LUA_FLOAT_TYPE	LUA_FLOAT_DOUBLE
+
+#endif				/* } */
+
+
+/*
+** default configuration for 64-bit Lua ('long long' and 'double')
+*/
+#if !defined(LUA_INT_TYPE)
+#define LUA_INT_TYPE	LUA_INT_LONGLONG
+#endif
+
+#if !defined(LUA_FLOAT_TYPE)
+#define LUA_FLOAT_TYPE	LUA_FLOAT_DOUBLE
+#endif
+
+/* }================================================================== */
+
+
+
+
+/*
+** {==================================================================
+** Configuration for Paths.
+** ===================================================================
+*/
+
+/*
+** LUA_PATH_SEP is the character that separates templates in a path.
+** LUA_PATH_MARK is the string that marks the substitution points in a
+** template.
+** LUA_EXEC_DIR in a Windows path is replaced by the executable's
+** directory.
+*/
+#define LUA_PATH_SEP            ";"
+#define LUA_PATH_MARK           "?"
+#define LUA_EXEC_DIR            "!"
+
+
+/*
+@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
+** Lua libraries.
+@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
+** C libraries.
+** CHANGE them if your machine has a non-conventional directory
+** hierarchy or if you want to install your libraries in
+** non-conventional directories.
+*/
+#define LUA_VDIR	LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
+#if defined(_WIN32)	/* { */
+/*
+** In Windows, any exclamation mark ('!') in the path is replaced by the
+** path of the directory of the executable file of the current process.
+*/
+#define LUA_LDIR	"!\\lua\\"
+#define LUA_CDIR	"!\\"
+#define LUA_SHRDIR	"!\\..\\share\\lua\\" LUA_VDIR "\\"
+#define LUA_PATH_DEFAULT  \
+		LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \
+		LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua;" \
+		LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \
+		".\\?.lua;" ".\\?\\init.lua"
+#define LUA_CPATH_DEFAULT \
+		LUA_CDIR"?.dll;" \
+		LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \
+		LUA_CDIR"loadall.dll;" ".\\?.dll;" \
+		LUA_CDIR"?53.dll;" ".\\?53.dll"
+
+#else			/* }{ */
+
+#define LUA_ROOT	"/usr/local/"
+#define LUA_LDIR	LUA_ROOT "share/lua/" LUA_VDIR "/"
+#define LUA_CDIR	LUA_ROOT "lib/lua/" LUA_VDIR "/"
+#define LUA_PATH_DEFAULT  \
+		LUA_LDIR"?.lua;"  LUA_LDIR"?/init.lua;" \
+		LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua;" \
+		"./?.lua;" "./?/init.lua"
+#define LUA_CPATH_DEFAULT \
+		LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so;" \
+		LUA_CDIR"lib?53.so;" "./lib?53.so"
+#endif			/* } */
+
+
+/*
+@@ LUA_DIRSEP is the directory separator (for submodules).
+** CHANGE it if your machine does not use "/" as the directory separator
+** and is not Windows. (On Windows Lua automatically uses "\".)
+*/
+#if defined(_WIN32)
+#define LUA_DIRSEP	"\\"
+#else
+#define LUA_DIRSEP	"/"
+#endif
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Marks for exported symbols in the C code
+** ===================================================================
+*/
+
+/*
+@@ LUA_API is a mark for all core API functions.
+@@ LUALIB_API is a mark for all auxiliary library functions.
+@@ LUAMOD_API is a mark for all standard library opening functions.
+** CHANGE them if you need to define those functions in some special way.
+** For instance, if you want to create one Windows DLL with the core and
+** the libraries, you may want to use the following definition (define
+** LUA_BUILD_AS_DLL to get it).
+*/
+#if defined(LUA_BUILD_AS_DLL)	/* { */
+
+#if defined(LUA_CORE) || defined(LUA_LIB)	/* { */
+#define LUA_API __declspec(dllexport)
+#else						/* }{ */
+#define LUA_API __declspec(dllimport)
+#endif						/* } */
+
+#else				/* }{ */
+
+#define LUA_API		extern
+
+#endif				/* } */
+
+
+/* more often than not the libs go together with the core */
+#define LUALIB_API	LUA_API
+#define LUAMOD_API	LUALIB_API
+
+
+/*
+@@ LUAI_FUNC is a mark for all extern functions that are not to be
+** exported to outside modules.
+@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables
+** that are not to be exported to outside modules (LUAI_DDEF for
+** definitions and LUAI_DDEC for declarations).
+** CHANGE them if you need to mark them in some special way. Elf/gcc
+** (versions 3.2 and later) mark them as "hidden" to optimize access
+** when Lua is compiled as a shared library. Not all elf targets support
+** this attribute. Unfortunately, gcc does not offer a way to check
+** whether the target offers that support, and those without support
+** give a warning about it. To avoid these warnings, change to the
+** default definition.
+*/
+#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
+    defined(__ELF__)		/* { */
+#define LUAI_FUNC	__attribute__((visibility("hidden"))) extern
+#else				/* }{ */
+#define LUAI_FUNC	extern
+#endif				/* } */
+
+#define LUAI_DDEC	LUAI_FUNC
+#define LUAI_DDEF	/* empty */
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Compatibility with previous versions
+** ===================================================================
+*/
+
+/*
+@@ LUA_COMPAT_5_2 controls other macros for compatibility with Lua 5.2.
+@@ LUA_COMPAT_5_1 controls other macros for compatibility with Lua 5.1.
+** You can define it to get all options, or change specific options
+** to fit your specific needs.
+*/
+#if defined(LUA_COMPAT_5_2)	/* { */
+
+/*
+@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated
+** functions in the mathematical library.
+*/
+#define LUA_COMPAT_MATHLIB
+
+/*
+@@ LUA_COMPAT_BITLIB controls the presence of library 'bit32'.
+*/
+#define LUA_COMPAT_BITLIB
+
+/*
+@@ LUA_COMPAT_IPAIRS controls the effectiveness of the __ipairs metamethod.
+*/
+#define LUA_COMPAT_IPAIRS
+
+/*
+@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for
+** manipulating other integer types (lua_pushunsigned, lua_tounsigned,
+** luaL_checkint, luaL_checklong, etc.)
+*/
+#define LUA_COMPAT_APIINTCASTS
+
+#endif				/* } */
+
+
+#if defined(LUA_COMPAT_5_1)	/* { */
+
+/* Incompatibilities from 5.2 -> 5.3 */
+#define LUA_COMPAT_MATHLIB
+#define LUA_COMPAT_APIINTCASTS
+
+/*
+@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.
+** You can replace it with 'table.unpack'.
+*/
+#define LUA_COMPAT_UNPACK
+
+/*
+@@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'.
+** You can replace it with 'package.searchers'.
+*/
+#define LUA_COMPAT_LOADERS
+
+/*
+@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall.
+** You can call your C function directly (with light C functions).
+*/
+#define lua_cpcall(L,f,u)  \
+	(lua_pushcfunction(L, (f)), \
+	 lua_pushlightuserdata(L,(u)), \
+	 lua_pcall(L,1,0,0))
+
+
+/*
+@@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library.
+** You can rewrite 'log10(x)' as 'log(x, 10)'.
+*/
+#define LUA_COMPAT_LOG10
+
+/*
+@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base
+** library. You can rewrite 'loadstring(s)' as 'load(s)'.
+*/
+#define LUA_COMPAT_LOADSTRING
+
+/*
+@@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library.
+*/
+#define LUA_COMPAT_MAXN
+
+/*
+@@ The following macros supply trivial compatibility for some
+** changes in the API. The macros themselves document how to
+** change your code to avoid using them.
+*/
+#define lua_strlen(L,i)		lua_rawlen(L, (i))
+
+#define lua_objlen(L,i)		lua_rawlen(L, (i))
+
+#define lua_equal(L,idx1,idx2)		lua_compare(L,(idx1),(idx2),LUA_OPEQ)
+#define lua_lessthan(L,idx1,idx2)	lua_compare(L,(idx1),(idx2),LUA_OPLT)
+
+/*
+@@ LUA_COMPAT_MODULE controls compatibility with previous
+** module functions 'module' (Lua) and 'luaL_register' (C).
+*/
+#define LUA_COMPAT_MODULE
+
+#endif				/* } */
+
+
+/*
+@@ LUA_COMPAT_FLOATSTRING makes Lua format integral floats without a
+@@ a float mark ('.0').
+** This macro is not on by default even in compatibility mode,
+** because this is not really an incompatibility.
+*/
+/* #define LUA_COMPAT_FLOATSTRING */
+
+/* }================================================================== */
+
+
+
+/*
+** {==================================================================
+** Configuration for Numbers.
+** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_*
+** satisfy your needs.
+** ===================================================================
+*/
+
+/*
+@@ LUA_NUMBER is the floating-point type used by Lua.
+@@ LUAI_UACNUMBER is the result of a 'default argument promotion'
+@@ over a floating number.
+@@ l_mathlim(x) corrects limit name 'x' to the proper float type
+** by prefixing it with one of FLT/DBL/LDBL.
+@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats.
+@@ LUA_NUMBER_FMT is the format for writing floats.
+@@ lua_number2str converts a float to a string.
+@@ l_mathop allows the addition of an 'l' or 'f' to all math operations.
+@@ l_floor takes the floor of a float.
+@@ lua_str2number converts a decimal numeric string to a number.
+*/
+
+
+/* The following definitions are good for most cases here */
+
+#define l_floor(x)		(l_mathop(floor)(x))
+
+#define lua_number2str(s,sz,n)  \
+	l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n))
+
+/*
+@@ lua_numbertointeger converts a float number to an integer, or
+** returns 0 if float is not within the range of a lua_Integer.
+** (The range comparisons are tricky because of rounding. The tests
+** here assume a two-complement representation, where MININTEGER always
+** has an exact representation as a float; MAXINTEGER may not have one,
+** and therefore its conversion to float may have an ill-defined value.)
+*/
+#define lua_numbertointeger(n,p) \
+  ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \
+   (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \
+      (*(p) = (LUA_INTEGER)(n), 1))
+
+
+/* now the variable definitions */
+
+#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT		/* { single float */
+
+#define LUA_NUMBER	float
+
+#define l_mathlim(n)		(FLT_##n)
+
+#define LUAI_UACNUMBER	double
+
+#define LUA_NUMBER_FRMLEN	""
+#define LUA_NUMBER_FMT		"%.7g"
+
+#define l_mathop(op)		op##f
+
+#define lua_str2number(s,p)	strtof((s), (p))
+
+
+#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE	/* }{ long double */
+
+#define LUA_NUMBER	long double
+
+#define l_mathlim(n)		(LDBL_##n)
+
+#define LUAI_UACNUMBER	long double
+
+#define LUA_NUMBER_FRMLEN	"L"
+#define LUA_NUMBER_FMT		"%.19Lg"
+
+#define l_mathop(op)		op##l
+
+#define lua_str2number(s,p)	strtold((s), (p))
+
+#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE	/* }{ double */
+
+#define LUA_NUMBER	double
+
+#define l_mathlim(n)		(DBL_##n)
+
+#define LUAI_UACNUMBER	double
+
+#define LUA_NUMBER_FRMLEN	""
+#define LUA_NUMBER_FMT		"%.14g"
+
+#define l_mathop(op)		op
+
+#define lua_str2number(s,p)	strtod((s), (p))
+
+#else						/* }{ */
+
+#error "numeric float type not defined"
+
+#endif					/* } */
+
+
+
+/*
+@@ LUA_INTEGER is the integer type used by Lua.
+**
+@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER.
+**
+@@ LUAI_UACINT is the result of a 'default argument promotion'
+@@ over a lUA_INTEGER.
+@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers.
+@@ LUA_INTEGER_FMT is the format for writing integers.
+@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER.
+@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER.
+@@ lua_integer2str converts an integer to a string.
+*/
+
+
+/* The following definitions are good for most cases here */
+
+#define LUA_INTEGER_FMT		"%" LUA_INTEGER_FRMLEN "d"
+
+#define LUAI_UACINT		LUA_INTEGER
+
+#define lua_integer2str(s,sz,n)  \
+	l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n))
+
+/*
+** use LUAI_UACINT here to avoid problems with promotions (which
+** can turn a comparison between unsigneds into a signed comparison)
+*/
+#define LUA_UNSIGNED		unsigned LUAI_UACINT
+
+
+/* now the variable definitions */
+
+#if LUA_INT_TYPE == LUA_INT_INT		/* { int */
+
+#define LUA_INTEGER		int
+#define LUA_INTEGER_FRMLEN	""
+
+#define LUA_MAXINTEGER		INT_MAX
+#define LUA_MININTEGER		INT_MIN
+
+#elif LUA_INT_TYPE == LUA_INT_LONG	/* }{ long */
+
+#define LUA_INTEGER		long
+#define LUA_INTEGER_FRMLEN	"l"
+
+#define LUA_MAXINTEGER		LONG_MAX
+#define LUA_MININTEGER		LONG_MIN
+
+#elif LUA_INT_TYPE == LUA_INT_LONGLONG	/* }{ long long */
+
+/* use presence of macro LLONG_MAX as proxy for C99 compliance */
+#if defined(LLONG_MAX)		/* { */
+/* use ISO C99 stuff */
+
+#define LUA_INTEGER		long long
+#define LUA_INTEGER_FRMLEN	"ll"
+
+#define LUA_MAXINTEGER		LLONG_MAX
+#define LUA_MININTEGER		LLONG_MIN
+
+#elif defined(LUA_USE_WINDOWS) /* }{ */
+/* in Windows, can use specific Windows types */
+
+#define LUA_INTEGER		__int64
+#define LUA_INTEGER_FRMLEN	"I64"
+
+#define LUA_MAXINTEGER		_I64_MAX
+#define LUA_MININTEGER		_I64_MIN
+
+#else				/* }{ */
+
+#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \
+  or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)"
+
+#endif				/* } */
+
+#else				/* }{ */
+
+#error "numeric integer type not defined"
+
+#endif				/* } */
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Dependencies with C99 and other C details
+** ===================================================================
+*/
+
+/*
+@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89.
+** (All uses in Lua have only one format item.)
+*/
+#if !defined(LUA_USE_C89)
+#define l_sprintf(s,sz,f,i)	snprintf(s,sz,f,i)
+#else
+#define l_sprintf(s,sz,f,i)	((void)(sz), sprintf(s,f,i))
+#endif
+
+
+/*
+@@ lua_strx2number converts an hexadecimal numeric string to a number.
+** In C99, 'strtod' does that conversion. Otherwise, you can
+** leave 'lua_strx2number' undefined and Lua will provide its own
+** implementation.
+*/
+#if !defined(LUA_USE_C89)
+#define lua_strx2number(s,p)		lua_str2number(s,p)
+#endif
+
+
+/*
+@@ lua_pointer2str converts a pointer to a readable string in a
+** non-specified way.
+*/
+#define lua_pointer2str(buff,sz,p)	l_sprintf(buff,sz,"%p",p)
+
+
+/*
+@@ lua_number2strx converts a float to an hexadecimal numeric string.
+** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that.
+** Otherwise, you can leave 'lua_number2strx' undefined and Lua will
+** provide its own implementation.
+*/
+#if !defined(LUA_USE_C89)
+#define lua_number2strx(L,b,sz,f,n)  \
+	((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n)))
+#endif
+
+
+/*
+** 'strtof' and 'opf' variants for math functions are not valid in
+** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the
+** availability of these variants. ('math.h' is already included in
+** all files that use these macros.)
+*/
+#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF))
+#undef l_mathop  /* variants not available */
+#undef lua_str2number
+#define l_mathop(op)		(lua_Number)op  /* no variant */
+#define lua_str2number(s,p)	((lua_Number)strtod((s), (p)))
+#endif
+
+
+/*
+@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation
+** functions.  It must be a numerical type; Lua will use 'intptr_t' if
+** available, otherwise it will use 'ptrdiff_t' (the nearest thing to
+** 'intptr_t' in C89)
+*/
+#define LUA_KCONTEXT	ptrdiff_t
+
+#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
+    __STDC_VERSION__ >= 199901L
+#include <stdint.h>
+#if defined(INTPTR_MAX)  /* even in C99 this type is optional */
+#undef LUA_KCONTEXT
+#define LUA_KCONTEXT	intptr_t
+#endif
+#endif
+
+
+/*
+@@ lua_getlocaledecpoint gets the locale "radix character" (decimal point).
+** Change that if you do not want to use C locales. (Code using this
+** macro must include header 'locale.h'.)
+*/
+#if !defined(lua_getlocaledecpoint)
+#define lua_getlocaledecpoint()		(localeconv()->decimal_point[0])
+#endif
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Language Variations
+** =====================================================================
+*/
+
+/*
+@@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some
+** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from
+** numbers to strings. Define LUA_NOCVTS2N to turn off automatic
+** coercion from strings to numbers.
+*/
+/* #define LUA_NOCVTN2S */
+/* #define LUA_NOCVTS2N */
+
+
+/*
+@@ LUA_USE_APICHECK turns on several consistency checks on the C API.
+** Define it as a help when debugging C code.
+*/
+#if defined(LUA_USE_APICHECK)
+#include <assert.h>
+#define luai_apicheck(l,e)	assert(e)
+#endif
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Macros that affect the API and must be stable (that is, must be the
+** same when you compile Lua and when you compile code that links to
+** Lua). You probably do not want/need to change them.
+** =====================================================================
+*/
+
+/*
+@@ LUAI_MAXSTACK limits the size of the Lua stack.
+** CHANGE it if you need a different limit. This limit is arbitrary;
+** its only purpose is to stop Lua from consuming unlimited stack
+** space (and to reserve some numbers for pseudo-indices).
+*/
+#if LUAI_BITSINT >= 32
+#define LUAI_MAXSTACK		1000000
+#else
+#define LUAI_MAXSTACK		15000
+#endif
+
+
+/*
+@@ LUA_EXTRASPACE defines the size of a raw memory area associated with
+** a Lua state with very fast access.
+** CHANGE it if you need a different size.
+*/
+#define LUA_EXTRASPACE		(sizeof(void *))
+
+
+/*
+@@ LUA_IDSIZE gives the maximum size for the description of the source
+@@ of a function in debug information.
+** CHANGE it if you want a different size.
+*/
+#define LUA_IDSIZE	60
+
+
+/*
+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+** CHANGE it if it uses too much C-stack space. (For long double,
+** 'string.format("%.99f", -1e4932)' needs 5034 bytes, so a
+** smaller buffer would force a memory allocation for each call to
+** 'string.format'.)
+*/
+#if LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE
+#define LUAL_BUFFERSIZE		8192
+#else
+#define LUAL_BUFFERSIZE   ((int)(0x80 * sizeof(void*) * sizeof(lua_Integer)))
+#endif
+
+/* }================================================================== */
+
+
+/*
+@@ LUA_QL describes how error messages quote program elements.
+** Lua does not use these macros anymore; they are here for
+** compatibility only.
+*/
+#define LUA_QL(x)	"'" x "'"
+#define LUA_QS		LUA_QL("%s")
+
+
+
+
+/* =================================================================== */
+
+/*
+** Local configuration. You can use this space to add your redefinitions
+** without modifying the main part of the file.
+*/
+
+
+
+
+
+#endif
+

vendor/lua/5.3/include/lualib.h

@@ -0,0 +1,61 @@
+/*
+** $Id: lualib.h,v 1.45.1.1 2017/04/19 17:20:42 roberto Exp $
+** Lua standard libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lualib_h
+#define lualib_h
+
+#include "lua.h"
+
+
+/* version suffix for environment variable names */
+#define LUA_VERSUFFIX          "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR
+
+
+LUAMOD_API int (luaopen_base) (lua_State *L);
+
+#define LUA_COLIBNAME	"coroutine"
+LUAMOD_API int (luaopen_coroutine) (lua_State *L);
+
+#define LUA_TABLIBNAME	"table"
+LUAMOD_API int (luaopen_table) (lua_State *L);
+
+#define LUA_IOLIBNAME	"io"
+LUAMOD_API int (luaopen_io) (lua_State *L);
+
+#define LUA_OSLIBNAME	"os"
+LUAMOD_API int (luaopen_os) (lua_State *L);
+
+#define LUA_STRLIBNAME	"string"
+LUAMOD_API int (luaopen_string) (lua_State *L);
+
+#define LUA_UTF8LIBNAME	"utf8"
+LUAMOD_API int (luaopen_utf8) (lua_State *L);
+
+#define LUA_BITLIBNAME	"bit32"
+LUAMOD_API int (luaopen_bit32) (lua_State *L);
+
+#define LUA_MATHLIBNAME	"math"
+LUAMOD_API int (luaopen_math) (lua_State *L);
+
+#define LUA_DBLIBNAME	"debug"
+LUAMOD_API int (luaopen_debug) (lua_State *L);
+
+#define LUA_LOADLIBNAME	"package"
+LUAMOD_API int (luaopen_package) (lua_State *L);
+
+
+/* open all previous libraries */
+LUALIB_API void (luaL_openlibs) (lua_State *L);
+
+
+
+#if !defined(lua_assert)
+#define lua_assert(x)	((void)0)
+#endif
+
+
+#endif

vendor/lua/5.3/lua.odin

@@ -0,0 +1,759 @@
+package lua_5_3
+
+import "core:intrinsics"
+import "core:builtin"
+
+import c "core:c/libc"
+
+#assert(size_of(c.int) == size_of(b32))
+
+when ODIN_OS == .Windows {
+	foreign import lib "windows/lua53dll.lib"
+} else when ODIN_OS == .Linux {
+	foreign import lib "linux/liblua53.a"
+} else {
+	foreign import lib "system:liblua53.a"
+}
+
+VERSION_MAJOR       :: "5"
+VERSION_MINOR       :: "3"
+VERSION_NUM         :: 503
+VERSION_RELEASE     :: "6"
+
+VERSION             :: "Lua " + VERSION_MAJOR + "." + VERSION_MINOR
+RELEASE             :: VERSION + "." + VERSION_RELEASE
+COPYRIGHT           :: RELEASE + "  Copyright (C) 1994-2020 Lua.org, PUC-Rio"
+AUTHORS             :: "R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
+
+
+/* mark for precompiled code ('<esc>Lua') */
+SIGNATURE :: "\x1bLua"
+
+/* option for multiple returns in 'lua_pcall' and 'lua_call' */
+MULTRET :: -1
+
+REGISTRYINDEX :: -MAXSTACK - 1000
+
+
+/*
+@@ LUAI_MAXSTACK limits the size of the Lua stack.
+** CHANGE it if you need a different limit. This limit is arbitrary;
+** its only purpose is to stop Lua from consuming unlimited stack
+** space (and to reserve some numbers for pseudo-indices).
+** (It must fit into max(size_t)/32.)
+*/
+MAXSTACK :: 1000000
+
+
+/*
+@@ LUA_EXTRASPACE defines the size of a raw memory area associated with
+** a Lua state with very fast access.
+** CHANGE it if you need a different size.
+*/
+EXTRASPACE :: size_of(rawptr)
+
+
+
+/*
+@@ LUA_IDSIZE gives the maximum size for the description of the source
+@@ of a function in debug information.
+** CHANGE it if you want a different size.
+*/
+IDSIZE :: 60
+
+
+/*
+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+*/
+L_BUFFERSIZE :: c.int(16 * size_of(rawptr) * size_of(Number))
+
+
+MAXALIGNVAL :: max(align_of(Number), align_of(f64), align_of(rawptr), align_of(Integer), align_of(c.long))
+
+
+Status :: enum c.int {
+	OK        = 0,
+	YIELD     = 1,
+	ERRRUN    = 2,
+	ERRSYNTAX = 3,
+	ERRMEM    = 4,
+	ERRERR    = 5,
+	ERRGCMM   = 6,
+	ERRFILE   = 7,
+}
+
+/* thread status */
+OK        :: Status.OK
+YIELD     :: Status.YIELD
+ERRRUN    :: Status.ERRRUN
+ERRSYNTAX :: Status.ERRSYNTAX
+ERRMEM    :: Status.ERRMEM
+ERRERR    :: Status.ERRERR
+ERRFILE   :: Status.ERRFILE
+
+/*
+** basic types
+*/
+
+
+Type :: enum c.int {
+	NONE          = -1,
+
+	NIL           = 0,
+	BOOLEAN       = 1,
+	LIGHTUSERDATA = 2,
+	NUMBER        = 3,
+	STRING        = 4,
+	TABLE         = 5,
+	FUNCTION      = 6,
+	USERDATA      = 7,
+	THREAD        = 8,
+}
+
+TNONE          :: Type.NONE
+TNIL           :: Type.NIL
+TBOOLEAN       :: Type.BOOLEAN
+TLIGHTUSERDATA :: Type.LIGHTUSERDATA
+TNUMBER        :: Type.NUMBER
+TSTRING        :: Type.STRING
+TTABLE         :: Type.TABLE
+TFUNCTION      :: Type.FUNCTION
+TUSERDATA      :: Type.USERDATA
+TTHREAD        :: Type.THREAD
+NUMTYPES :: 9
+
+
+
+ArithOp :: enum c.int {
+	ADD  = 0,	/* ORDER TM, ORDER OP */
+	SUB  = 1,
+	MUL  = 2,
+	MOD  = 3,
+	POW  = 4,
+	DIV  = 5,
+	IDIV = 6,
+	BAND = 7,
+	BOR  = 8,
+	BXOR = 9,
+	SHL  = 10,
+	SHR  = 11,
+	UNM  = 12,
+	BNOT = 13,
+}
+
+CompareOp :: enum c.int {
+	EQ = 0,
+	LT = 1,
+	LE = 2,
+}
+
+OPADD  :: ArithOp.ADD
+OPSUB  :: ArithOp.SUB
+OPMUL  :: ArithOp.MUL
+OPMOD  :: ArithOp.MOD
+OPPOW  :: ArithOp.POW
+OPDIV  :: ArithOp.DIV
+OPIDIV :: ArithOp.IDIV
+OPBAND :: ArithOp.BAND
+OPBOR  :: ArithOp.BOR
+OPBXOR :: ArithOp.BXOR
+OPSHL  :: ArithOp.SHL
+OPSHR  :: ArithOp.SHR
+OPUNM  :: ArithOp.UNM
+OPBNOT :: ArithOp.BNOT
+
+OPEQ :: CompareOp.EQ
+OPLT :: CompareOp.LT
+OPLE :: CompareOp.LE
+
+
+/* minimum Lua stack available to a C function */
+MINSTACK :: 20
+
+
+/* predefined values in the registry */
+RIDX_MAINTHREAD :: 1
+RIDX_GLOBALS    :: 2
+RIDX_LAST       :: RIDX_GLOBALS
+
+
+/* type of numbers in Lua */
+Number :: distinct (f32 when size_of(uintptr) == 4 else f64)
+
+
+/* type for integer functions */
+Integer :: distinct (i32 when size_of(uintptr) == 4 else i64)
+
+/* unsigned integer type */
+Unsigned :: distinct (u32 when size_of(uintptr) == 4 else u64)
+
+/* type for continuation-function contexts */
+KContext :: distinct int
+
+
+/*
+** Type for C functions registered with Lua
+*/
+CFunction :: #type proc "c" (L: ^State) -> c.int
+
+/*
+** Type for continuation functions
+*/
+KFunction :: #type proc "c" (L: ^State, status: c.int, ctx: KContext) -> c.int
+
+
+/*
+** Type for functions that read/write blocks when loading/dumping Lua chunks
+*/
+Reader :: #type proc "c" (L: ^State, ud: rawptr, sz: ^c.size_t) -> cstring
+Writer :: #type proc "c" (L: ^State, p: rawptr, sz: ^c.size_t, ud: rawptr) -> c.int
+
+
+/*
+** Type for memory-allocation functions
+*/
+Alloc :: #type proc "c" (ud: rawptr, ptr: rawptr, osize, nsize: c.size_t) -> rawptr
+
+
+GCWhat :: enum c.int {
+	STOP       = 0,
+	RESTART    = 1,
+	COLLECT    = 2,
+	COUNT      = 3,
+	COUNTB     = 4,
+	STEP       = 5,
+	SETPAUSE   = 6,
+	SETSTEPMUL = 7,
+	ISRUNNING  = 9,
+}
+GCSTOP       :: GCWhat.STOP
+GCRESTART    :: GCWhat.RESTART
+GCCOLLECT    :: GCWhat.COLLECT
+GCCOUNT      :: GCWhat.COUNT
+GCCOUNTB     :: GCWhat.COUNTB
+GCSTEP       :: GCWhat.STEP
+GCSETPAUSE   :: GCWhat.SETPAUSE
+GCSETSTEPMUL :: GCWhat.SETSTEPMUL
+GCISRUNNING  :: GCWhat.ISRUNNING
+
+
+
+/*
+** Event codes
+*/
+
+HookEvent :: enum c.int {
+	CALL     = 0,
+	RET      = 1,
+	LINE     = 2,
+	COUNT    = 3,
+	TAILCALL = 4,
+}
+HOOKCALL     :: HookEvent.CALL
+HOOKRET      :: HookEvent.RET
+HOOKLINE     :: HookEvent.LINE
+HOOKCOUNT    :: HookEvent.COUNT
+HOOKTAILCALL :: HookEvent.TAILCALL
+
+
+/*
+** Event masks
+*/
+HookMask :: distinct bit_set[HookEvent; c.int]
+MASKCALL  :: HookMask{.CALL}
+MASKRET   :: HookMask{.RET}
+MASKLINE  :: HookMask{.LINE}
+MASKCOUNT :: HookMask{.COUNT}
+
+/* activation record */
+Debug :: struct {
+	event:           HookEvent,
+	name:            cstring,                  /* (n) */
+	namewhat:        cstring,                  /* (n) 'global', 'local', 'field', 'method' */
+	what:            cstring,                  /* (S) 'Lua', 'C', 'main', 'tail' */
+	source:          cstring,                  /* (S) */
+	currentline:     c.int,                    /* (l) */
+	linedefined:     c.int,                    /* (S) */
+	lastlinedefined: c.int,                    /* (S) */
+	nups:            u8,                       /* (u) number of upvalues */
+	nparams:         u8,                       /* (u) number of parameters */
+	isvararg:        bool,                     /* (u) */
+	istailcall:      bool,                     /* (t) */
+	short_src:       [IDSIZE]u8 `fmt:"s"`, /* (S) */
+	/* private part */
+	i_ci:            rawptr,                   /* active function */
+}
+
+
+/* Functions to be called by the debugger in specific events */
+Hook :: #type proc "c" (L: ^State, ar: ^Debug)
+
+
+State :: struct {} // opaque data type
+
+
+@(link_prefix="lua_")
+@(default_calling_convention="c")
+foreign lib {
+	/*
+	** RCS ident string
+	*/
+
+	ident: [^]u8 // TODO(bill): is this correct?
+
+
+	/*
+	** state manipulation
+	*/
+
+	newstate  :: proc(f: Alloc, ud: rawptr) -> ^State ---
+	close     :: proc(L: ^State) ---
+	newthread :: proc(L: ^State) -> ^State ---
+
+	atpanic :: proc(L: ^State, panicf: CFunction) -> CFunction ---
+
+	version :: proc(L: ^State) -> ^Number ---
+
+
+	/*
+	** basic stack manipulation
+	*/
+
+	absindex   :: proc (L: ^State, idx: c.int) -> c.int ---
+	gettop     :: proc (L: ^State) -> c.int ---
+	settop     :: proc (L: ^State, idx: c.int) ---
+	pushvalue  :: proc (L: ^State, idx: c.int) ---
+	rotate     :: proc (L: ^State, idx: c.int, n: c.int) ---
+	copy       :: proc (L: ^State, fromidx, toidx: c.int) ---
+	checkstack :: proc (L: ^State, n: c.int) -> c.int ---
+
+	xmove :: proc(from, to: ^State, n: c.int) ---
+
+
+	/*
+	** access functions (stack -> C)
+	*/
+
+	isnumber    :: proc(L: ^State, idx: c.int) -> b32 ---
+	isstring    :: proc(L: ^State, idx: c.int) -> b32 ---
+	iscfunction :: proc(L: ^State, idx: c.int) -> b32 ---
+	isinteger   :: proc(L: ^State, idx: c.int) -> b32 ---
+	isuserdata  :: proc(L: ^State, idx: c.int) -> b32 ---
+	type        :: proc(L: ^State, idx: c.int) -> Type ---
+	typename    :: proc(L: ^State, tp: Type) -> cstring ---
+
+	@(link_name="lua_tonumberx")
+	tonumber    :: proc(L: ^State, idx: c.int, isnum: ^b32 = nil) -> Number ---
+	@(link_name="lua_tointegerx")
+	tointeger   :: proc(L: ^State, idx: c.int, isnum: ^b32 = nil) -> Integer ---
+	toboolean   :: proc(L: ^State, idx: c.int) -> b32 ---
+	tolstring   :: proc(L: ^State, idx: c.int, len: ^c.size_t) -> cstring ---
+	rawlen      :: proc(L: ^State, idx: c.int) -> c.size_t ---
+	tocfunction :: proc(L: ^State, idx: c.int) -> CFunction ---
+	touserdata  :: proc(L: ^State, idx: c.int) -> rawptr ---
+	tothread    :: proc(L: ^State, idx: c.int) -> ^State ---
+	topointer   :: proc(L: ^State, idx: c.int) -> rawptr ---
+
+	/*
+	** Comparison and arithmetic functions
+	*/
+
+	arith    :: proc(L: ^State, op: ArithOp) ---
+	rawequal :: proc(L: ^State, idx1, idx2: c.int) -> b32 ---
+	compare  :: proc(L: ^State, idx1, idx2: c.int, op: CompareOp) -> b32 ---
+
+	/*
+	** push functions (C -> stack)
+	*/
+
+	pushnil      :: proc(L: ^State) ---
+	pushnumber   :: proc(L: ^State, n: Number) ---
+	pushinteger  :: proc(L: ^State, n: Integer) ---
+	pushlstring  :: proc(L: ^State, s: cstring, len: c.size_t) -> cstring ---
+	pushstring   :: proc(L: ^State, s: cstring) -> cstring ---
+	pushvfstring :: proc(L: ^State, fmt: cstring, argp: c.va_list) -> cstring ---
+	pushfstring       :: proc(L: ^State, fmt: cstring, #c_vararg args: ..any) -> cstring ---
+	pushcclosure      :: proc(L: ^State, fn: CFunction, n: c.int) ---
+	pushboolean       :: proc(L: ^State, b: b32) ---
+	pushlightuserdata :: proc(L: ^State, p: rawptr) ---
+	pushthread        :: proc(L: ^State) -> Status ---
+
+	/*
+	** get functions (Lua -> stack)
+	*/
+
+	getglobal :: proc(L: ^State, name: cstring) -> c.int ---
+	gettable  :: proc(L: ^State, idx: c.int) -> c.int ---
+	getfield  :: proc(L: ^State, idx: c.int, k: cstring) -> c.int ---
+	geti      :: proc(L: ^State, idx: c.int, n: Integer) -> c.int ---
+	rawget    :: proc(L: ^State, idx: c.int) -> c.int ---
+	rawgeti   :: proc(L: ^State, idx: c.int, n: Integer) -> c.int ---
+	rawgetp   :: proc(L: ^State, idx: c.int, p: rawptr) -> c.int ---
+
+	createtable  :: proc(L: ^State, narr, nrec: c.int) ---
+	newuserdata  :: proc(L: ^State, sz: c.size_t) -> rawptr ---
+	getmetatable :: proc(L: ^State, objindex: c.int) -> c.int ---
+	getuservalue :: proc(L: ^State, idx: c.int) -> c.int ---
+
+
+	/*
+	** set functions (stack -> Lua)
+	*/
+
+	setglobal    :: proc(L: ^State, name: cstring) ---
+	settable     :: proc(L: ^State, idx: c.int) ---
+	setfield     :: proc(L: ^State, idx: c.int, k: cstring) ---
+	seti         :: proc(L: ^State, idx: c.int, n: Integer) ---
+	rawset       :: proc(L: ^State, idx: c.int) ---
+	rawseti      :: proc(L: ^State, idx: c.int, n: Integer) ---
+	rawsetp      :: proc(L: ^State, idx: c.int, p: rawptr) ---
+	setmetatable :: proc(L: ^State, objindex: c.int) -> c.int ---
+	setuservalue :: proc(L: ^State, idx: c.int) -> c.int ---
+
+
+	/*
+	** 'load' and 'call' functions (load and run Lua code)
+	*/
+
+	@(link_name="lua_callk")
+	call :: proc(L: ^State, nargs, nresults: c.int,
+	             ctx: KContext = 0, k: KFunction = nil) ---
+
+	@(link_name="lua_pcallk")
+	pcall :: proc(L: ^State, nargs, nresults: c.int, errfunc: c.int,
+	              ctx: KContext = 0, k: KFunction = nil) -> c.int ---
+
+	load :: proc(L: ^State, reader: Reader, dt: rawptr,
+	             chunkname, mode: cstring) -> Status ---
+
+	dump :: proc(L: ^State, writer: Writer, data: rawptr, strip: b32) -> Status ---
+
+
+	/*
+	** coroutine functions
+	*/
+
+	@(link_name="lua_yieldk")
+	yield       :: proc(L: ^State, nresults: c.int, ctx: KContext = 0, k: KFunction = nil) -> Status ---
+	resume      :: proc(L: ^State, from: ^State, narg: c.int) -> Status ---
+	status      :: proc(L: ^State) -> Status ---
+	isyieldable :: proc(L: ^State) -> b32 ---
+
+
+	/*
+	** garbage-collection function and options
+	*/
+
+
+
+	gc :: proc(L: ^State, what: GCWhat, data: c.int) -> c.int ---
+
+
+	/*
+	** miscellaneous functions
+	*/
+
+	error :: proc(L: ^State) -> Status ---
+
+	next :: proc(L: ^State, idx: c.int) -> c.int ---
+
+	concat :: proc(L: ^State, n: c.int) ---
+	len    :: proc(L: ^State, idx: c.int) ---
+
+	stringtonumber :: proc(L: ^State, s: cstring) -> c.size_t ---
+
+	getallocf :: proc(L: State, ud: ^rawptr) -> Alloc ---
+	setallocf :: proc(L: ^State, f: Alloc, ud: rawptr) ---
+
+	/*
+	** {======================================================================
+	** Debug API
+	** =======================================================================
+	*/
+
+	getstack   :: proc(L: ^State, level: c.int, ar: ^Debug) -> c.int ---
+	getinfo    :: proc(L: ^State, what: cstring, ar: ^Debug) -> c.int ---
+	getlocal   :: proc(L: ^State, ar: ^Debug, n: c.int) -> cstring ---
+	setlocal   :: proc(L: ^State, ar: ^Debug, n: c.int) -> cstring ---
+	getupvalue :: proc(L: ^State, funcindex: c.int, n: c.int) -> cstring ---
+	setupvalue :: proc(L: ^State, funcindex: c.int, n: c.int) -> cstring ---
+
+	upvalueid   :: proc(L: ^State, fidx, n: c.int) -> rawptr ---
+	upvaluejoin :: proc(L: ^State, fidx1, n1, fidx2, n2: c.int) ---
+
+	sethook :: proc(L: ^State, func: Hook, mask: HookMask, count: c.int) ---
+	gethook :: proc(L: ^State) -> Hook ---
+	gethookmask  :: proc(L: ^State) -> HookMask ---
+	gethookcount :: proc(L: ^State) -> c.int ---
+
+	/* }============================================================== */
+}
+
+
+
+/* version suffix for environment variable names */
+VERSUFFIX :: "_" + VERSION_MAJOR + "_" + VERSION_MINOR
+
+COLIBNAME   :: "coroutine"
+TABLIBNAME  :: "table"
+IOLIBNAME   :: "io"
+OSLIBNAME   :: "os"
+STRLIBNAME  :: "string"
+UTF8LIBNAME :: "utf8"
+BITLIBNAME  :: "bit32"
+MATHLIBNAME :: "math"
+DBLIBNAME   :: "debug"
+LOADLIBNAME :: "package"
+
+@(link_prefix="lua")
+@(default_calling_convention="c")
+foreign lib {
+	open_base      :: proc(L: ^State) -> c.int ---
+	open_coroutine :: proc(L: ^State) -> c.int ---
+	open_table     :: proc(L: ^State) -> c.int ---
+	open_io        :: proc(L: ^State) -> c.int ---
+	open_os        :: proc(L: ^State) -> c.int ---
+	open_string    :: proc(L: ^State) -> c.int ---
+	open_utf8      :: proc(L: ^State) -> c.int ---
+	open_bit32     :: proc(L: ^State) -> c.int ---
+	open_math      :: proc(L: ^State) -> c.int ---
+	open_debug     :: proc(L: ^State) -> c.int ---
+	open_package   :: proc(L: ^State) -> c.int ---
+
+	/* open all previous libraries */
+
+	L_openlibs :: proc(L: ^State) ---
+}
+
+
+
+GNAME :: "_G"
+
+/* key, in the registry, for table of loaded modules */
+LOADED_TABLE :: "_LOADED"
+
+
+/* key, in the registry, for table of preloaded loaders */
+PRELOAD_TABLE :: "_PRELOAD"
+
+L_Reg :: struct {
+	name: cstring,
+  	func: CFunction,
+}
+
+L_NUMSIZES :: size_of(Integer)*16 + size_of(Number)
+
+
+/* predefined references */
+NOREF  :: -2
+REFNIL :: -1
+
+
+@(link_prefix="lua")
+@(default_calling_convention="c")
+foreign lib {
+	@(link_name="luaL_checkversion_")
+	L_checkversion :: proc(L: ^State, ver: Number = VERSION_NUM, sz: c.size_t = L_NUMSIZES) ---
+
+
+	L_getmetafield :: proc(L: ^State, obj: c.int, e: cstring) -> c.int ---
+	L_callmeta     :: proc(L: ^State, obj: c.int, e: cstring) -> c.int ---
+	@(link_name="luaL_tolstring")
+	L_tostring     :: proc(L: ^State, idx: c.int, len: ^c.size_t = nil) -> cstring ---
+	L_argerror     :: proc(L: ^State, arg: c.int, extramsg: cstring) -> c.int ---
+	@(link_name="luaL_checklstring")
+	L_checkstring  :: proc(L: ^State, arg: c.int, l: ^c.size_t = nil) -> cstring ---
+	@(link_name="luaL_optlstring")
+	L_optstring    :: proc(L: ^State, arg: c.int, def: cstring, l: ^c.size_t = nil) -> cstring ---
+	L_checknumber  :: proc(L: ^State, arg: c.int) -> Number ---
+	L_optnumber    :: proc(L: ^State, arg: c.int, def: Number) -> Number ---
+
+	L_checkinteger :: proc(L: ^State, arg: c.int) -> Integer ---
+	L_optinteger   :: proc(L: ^State, arg: c.int, def: Integer) -> Integer ---
+
+	L_checkstack :: proc(L: ^State, sz: c.int, msg: cstring) ---
+	L_checktype  :: proc(L: ^State, arg: c.int, t: c.int) ---
+	L_checkany   :: proc(L: ^State, arg: c.int) ---
+
+	L_newmetatable :: proc(L: ^State, tname: cstring) -> c.int ---
+	L_setmetatable :: proc(L: ^State, tname: cstring) ---
+	L_testudata    :: proc(L: ^State, ud: c.int, tname: cstring) -> rawptr ---
+	L_checkudata   :: proc(L: ^State, ud: c.int, tname: cstring) -> rawptr ---
+
+	L_where :: proc(L: ^State, lvl: c.int) ---
+	L_error :: proc(L: ^State, fmt: cstring, #c_vararg args: ..any) -> Status ---
+
+	L_checkoption :: proc(L: ^State, arg: c.int, def: cstring, lst: [^]cstring) -> c.int ---
+
+	L_fileresult :: proc(L: ^State, stat: c.int, fname: cstring) -> c.int ---
+	L_execresult :: proc(L: ^State, stat: c.int) -> c.int ---
+
+
+	L_ref   :: proc(L: ^State, t: c.int) -> c.int ---
+	L_unref :: proc(L: ^State, t: c.int, ref: c.int) ---
+
+	@(link_name="luaL_loadfilex")
+	L_loadfile :: proc (L: ^State, filename: cstring, mode: cstring = nil) -> Status ---
+
+	@(link_name="luaL_loadbufferx")
+	L_loadbuffer :: proc(L: ^State, buff: [^]byte, sz: c.size_t, name: cstring, mode: cstring = nil) -> Status ---
+	L_loadstring  :: proc(L: ^State, s: cstring) -> Status ---
+
+	L_newstate :: proc() -> ^State ---
+
+	L_len :: proc(L: ^State, idx: c.int) -> Integer ---
+
+	L_gsub :: proc(L: ^State, s, p, r: cstring) -> cstring ---
+
+	L_setfuncs :: proc(L: ^State, l: [^]L_Reg, nup: c.int) ---
+
+	L_getsubtable :: proc(L: ^State, idx: c.int, fname: cstring) -> c.int ---
+
+	L_traceback   :: proc(L: ^State, L1: ^State, msg: cstring, level: c.int) ---
+
+	L_requiref    :: proc(L: ^State, modname: cstring, openf: CFunction, glb: c.int) ---
+
+}
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+
+L_Buffer :: struct {
+	b:    [^]byte,  /* buffer address */
+	size: c.size_t, /* buffer size */
+	n:    c.size_t, /* number of characters in buffer */
+	L:    ^State,
+	initb: [L_BUFFERSIZE]byte,  /* initial buffer */
+}
+
+L_addchar :: #force_inline proc "c" (B: ^L_Buffer, c: byte) {
+	if B.n < B.size {
+		L_prepbuffsize(B, 1)
+	}
+	B.b[B.n] = c
+	B.n += 1
+}
+
+L_addsize :: #force_inline proc "c" (B: ^L_Buffer, s: c.size_t) -> c.size_t {
+	B.n += s
+	return B.n
+}
+
+L_prepbuffer :: #force_inline proc "c" (B: ^L_Buffer) -> [^]byte {
+	return L_prepbuffsize(B, c.size_t(L_BUFFERSIZE))
+}
+
+
+@(link_prefix="lua")
+@(default_calling_convention="c")
+foreign lib {
+	L_buffinit       :: proc(L: ^State, B: ^L_Buffer) ---
+	L_prepbuffsize   :: proc(B: ^L_Buffer, sz: c.size_t) -> [^]byte ---
+	L_addlstring     :: proc(B: ^L_Buffer, s: cstring, l: c.size_t) ---
+	L_addstring      :: proc(B: ^L_Buffer, s: cstring) ---
+	L_addvalue       :: proc(B: ^L_Buffer) ---
+	L_pushresult     :: proc(B: ^L_Buffer) ---
+	L_pushresultsize :: proc(B: ^L_Buffer, sz: c.size_t) ---
+	L_buffinitsize   :: proc(L: ^State, B: ^L_Buffer, sz: c.size_t) -> [^]byte ---
+}
+
+
+/* }====================================================== */
+
+
+
+
+/*
+** {==============================================================
+** some useful macros
+** ===============================================================
+*/
+
+getextraspace :: #force_inline proc "c" (L: ^State) -> rawptr {
+	return rawptr(([^]byte)(L)[-EXTRASPACE:])
+}
+pop :: #force_inline proc "c" (L: ^State, n: c.int) {
+	settop(L, -n-1)
+}
+newtable :: #force_inline proc "c" (L: ^State) {
+	createtable(L, 0, 0)
+}
+register :: #force_inline proc "c" (L: ^State, n: cstring, f: CFunction) {
+	pushcfunction(L, f)
+	setglobal(L, n)
+}
+
+pushcfunction :: #force_inline proc "c" (L: ^State, f: CFunction) {
+	pushcclosure(L, f, 0)
+}
+
+
+isfunction      :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .FUNCTION      }
+istable         :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .TABLE         }
+islightuserdata :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .LIGHTUSERDATA }
+isnil           :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .NIL           }
+isboolean       :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .BOOLEAN       }
+isthread        :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .THREAD        }
+isnone          :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .NONE          }
+isnoneornil     :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) <= .NIL           }
+
+
+pushliteral :: pushstring
+pushglobaltable :: #force_inline proc "c" (L: ^State) {
+	rawgeti(L, REGISTRYINDEX, RIDX_GLOBALS)
+}
+tostring :: #force_inline proc "c" (L: ^State, i: c.int) -> cstring {
+	return tolstring(L, i, nil)
+}
+insert :: #force_inline proc "c" (L: ^State, idx: c.int) {
+	rotate(L, idx, 1)
+}
+remove :: #force_inline proc "c" (L: ^State, idx: c.int) {
+	rotate(L, idx, -1)
+	pop(L, 1)
+}
+replace :: #force_inline proc "c" (L: ^State, idx: c.int) {
+	copy(L, -1, idx)
+	pop(L, 1)
+}
+
+L_newlibtable :: #force_inline proc "c" (L: ^State, l: []L_Reg) {
+	createtable(L, 0, c.int(builtin.len(l) - 1))
+}
+
+L_newlib :: proc(L: ^State, l: []L_Reg) {
+	L_checkversion(L)
+	L_newlibtable(L, l)
+	L_setfuncs(L, raw_data(l), 0)
+}
+
+L_argcheck :: #force_inline proc "c" (L: ^State, cond: bool, arg: c.int, extramsg: cstring) {
+	if cond {
+		L_argerror(L, arg, extramsg)
+	}
+}
+
+L_typename :: #force_inline proc "c" (L: ^State, i: c.int) -> cstring {
+	return typename(L, type(L, i))
+}
+L_dofile :: #force_inline proc "c" (L: ^State, s: cstring) -> c.int {
+	err := L_loadfile(L, s)
+	return pcall(L, 0, MULTRET, 0) if err == nil else c.int(err)
+}
+L_dostring :: #force_inline proc "c" (L: ^State, s: cstring) -> c.int {
+	err := L_loadstring(L, s)
+	return pcall(L, 0, MULTRET, 0) if err == nil else c.int(err)
+}
+L_getmetatable :: #force_inline proc "c" (L: ^State, n: cstring) -> c.int {
+	return getfield(L, REGISTRYINDEX, n)
+}
+L_opt :: #force_inline proc "c" (L: ^State, f: $F, n: c.int, d: $T) -> T where intrinsics.type_is_proc(F) {
+	return d if isnoneornil(L, n) else f(L, n)
+}
+
+
+
+/* }============================================================== */

vendor/lua/5.4/include/lauxlib.h

@@ -0,0 +1,276 @@
+/*
+** $Id: lauxlib.h $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lauxlib_h
+#define lauxlib_h
+
+
+#include <stddef.h>
+#include <stdio.h>
+
+#include "lua.h"
+
+
+/* global table */
+#define LUA_GNAME	"_G"
+
+
+typedef struct luaL_Buffer luaL_Buffer;
+
+
+/* extra error code for 'luaL_loadfilex' */
+#define LUA_ERRFILE     (LUA_ERRERR+1)
+
+
+/* key, in the registry, for table of loaded modules */
+#define LUA_LOADED_TABLE	"_LOADED"
+
+
+/* key, in the registry, for table of preloaded loaders */
+#define LUA_PRELOAD_TABLE	"_PRELOAD"
+
+
+typedef struct luaL_Reg {
+  const char *name;
+  lua_CFunction func;
+} luaL_Reg;
+
+
+#define LUAL_NUMSIZES	(sizeof(lua_Integer)*16 + sizeof(lua_Number))
+
+LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz);
+#define luaL_checkversion(L)  \
+	  luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)
+
+LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
+LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
+LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg);
+LUALIB_API int (luaL_typeerror) (lua_State *L, int arg, const char *tname);
+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg,
+                                                          size_t *l);
+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg,
+                                          const char *def, size_t *l);
+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);
+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);
+
+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);
+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,
+                                          lua_Integer def);
+
+LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
+LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);
+LUALIB_API void (luaL_checkany) (lua_State *L, int arg);
+
+LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
+LUALIB_API void  (luaL_setmetatable) (lua_State *L, const char *tname);
+LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
+LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
+
+LUALIB_API void (luaL_where) (lua_State *L, int lvl);
+LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
+
+LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def,
+                                   const char *const lst[]);
+
+LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
+LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
+
+
+/* predefined references */
+#define LUA_NOREF       (-2)
+#define LUA_REFNIL      (-1)
+
+LUALIB_API int (luaL_ref) (lua_State *L, int t);
+LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
+
+LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
+                                               const char *mode);
+
+#define luaL_loadfile(L,f)	luaL_loadfilex(L,f,NULL)
+
+LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
+                                   const char *name, const char *mode);
+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
+
+LUALIB_API lua_State *(luaL_newstate) (void);
+
+LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx);
+
+LUALIB_API void luaL_addgsub (luaL_Buffer *b, const char *s,
+                                     const char *p, const char *r);
+LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s,
+                                    const char *p, const char *r);
+
+LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
+
+LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
+
+LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
+                                  const char *msg, int level);
+
+LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
+                                 lua_CFunction openf, int glb);
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+
+#define luaL_newlibtable(L,l)	\
+  lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
+
+#define luaL_newlib(L,l)  \
+  (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
+
+#define luaL_argcheck(L, cond,arg,extramsg)	\
+		((void)((cond) || luaL_argerror(L, (arg), (extramsg))))
+
+#define luaL_argexpected(L,cond,arg,tname)	\
+		((void)((cond) || luaL_typeerror(L, (arg), (tname))))
+
+#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
+#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
+
+#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
+
+#define luaL_dofile(L, fn) \
+	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_dostring(L, s) \
+	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))
+
+#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
+
+#define luaL_loadbuffer(L,s,sz,n)	luaL_loadbufferx(L,s,sz,n,NULL)
+
+
+/* push the value used to represent failure/error */
+#define luaL_pushfail(L)	lua_pushnil(L)
+
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+struct luaL_Buffer {
+  char *b;  /* buffer address */
+  size_t size;  /* buffer size */
+  size_t n;  /* number of characters in buffer */
+  lua_State *L;
+  union {
+    LUAI_MAXALIGN;  /* ensure maximum alignment for buffer */
+    char b[LUAL_BUFFERSIZE];  /* initial buffer */
+  } init;
+};
+
+
+#define luaL_bufflen(bf)	((bf)->n)
+#define luaL_buffaddr(bf)	((bf)->b)
+
+
+#define luaL_addchar(B,c) \
+  ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
+   ((B)->b[(B)->n++] = (c)))
+
+#define luaL_addsize(B,s)	((B)->n += (s))
+
+#define luaL_buffsub(B,s)	((B)->n -= (s))
+
+LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
+LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
+LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
+LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
+
+#define luaL_prepbuffer(B)	luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
+
+/* }====================================================== */
+
+
+
+/*
+** {======================================================
+** File handles for IO library
+** =======================================================
+*/
+
+/*
+** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
+** initial structure 'luaL_Stream' (it may contain other fields
+** after that initial structure).
+*/
+
+#define LUA_FILEHANDLE          "FILE*"
+
+
+typedef struct luaL_Stream {
+  FILE *f;  /* stream (NULL for incompletely created streams) */
+  lua_CFunction closef;  /* to close stream (NULL for closed streams) */
+} luaL_Stream;
+
+/* }====================================================== */
+
+/*
+** {==================================================================
+** "Abstraction Layer" for basic report of messages and errors
+** ===================================================================
+*/
+
+/* print a string */
+#if !defined(lua_writestring)
+#define lua_writestring(s,l)   fwrite((s), sizeof(char), (l), stdout)
+#endif
+
+/* print a newline and flush the output */
+#if !defined(lua_writeline)
+#define lua_writeline()        (lua_writestring("\n", 1), fflush(stdout))
+#endif
+
+/* print an error message */
+#if !defined(lua_writestringerror)
+#define lua_writestringerror(s,p) \
+        (fprintf(stderr, (s), (p)), fflush(stderr))
+#endif
+
+/* }================================================================== */
+
+
+/*
+** {============================================================
+** Compatibility with deprecated conversions
+** =============================================================
+*/
+#if defined(LUA_COMPAT_APIINTCASTS)
+
+#define luaL_checkunsigned(L,a)	((lua_Unsigned)luaL_checkinteger(L,a))
+#define luaL_optunsigned(L,a,d)	\
+	((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d)))
+
+#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
+
+#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
+
+#endif
+/* }============================================================ */
+
+
+
+#endif
+
+