cleaning up c library modules
authorBrendan Hansen <brendan.f.hansen@gmail.com>
Wed, 4 May 2022 16:20:44 +0000 (11:20 -0500)
committerBrendan Hansen <brendan.f.hansen@gmail.com>
Wed, 4 May 2022 16:20:44 +0000 (11:20 -0500)
16 files changed:
modules/glfw3/build.onyx [new file with mode: 0644]
modules/glfw3/build.sh
modules/glfw3/module.onyx
modules/glfw3/onyx_glfw3.c
modules/glfw3/onyx_glfw3.so
modules/http/http.onyx
modules/openal/ build.bat
modules/openal/build.onyx [new file with mode: 0644]
modules/openal/build.sh
modules/openal/module.onyx
modules/openal/onyx_openal.c
modules/openal/onyx_openal.so
modules/stb_image/build.onyx
modules/stb_image/stb_image.so
scripts/c_binding.onyx
scripts/c_library.onyx

diff --git a/modules/glfw3/build.onyx b/modules/glfw3/build.onyx
new file mode 100644 (file)
index 0000000..fd968af
--- /dev/null
@@ -0,0 +1,88 @@
+#load "core/std"
+#load "scripts/c_binding"
+#load "./module"
+
+use package core
+use package c_binding
+
+main :: () {
+    result := build_c_binding(.{
+        output_file = "modules/glfw3/onyx_glfw3.c",
+        foreign_block = (package glfw3).foreign_block,
+
+        cast_map = .[
+            .{ (package glfw3).GLFWmonitor_p, "GLFWmonitor *" },
+            .{ (package glfw3).GLFWwindow_p, "GLFWwindow *" },
+            .{ (package glfw3).GLFWcursor_p, "GLFWcursor *" },
+        ],
+
+        preamble = .[
+"""
+#include <GLFW/glfw3.h>
+
+#define __glfwGetLoadProcAddress() (unsigned long long) &glfwGetProcAddress
+
+#define _EXPAND(...) __VA_ARGS__
+#define GLFW_HOOK(callback_name, c_args, wasm_args) \
+    static wasm_func_t* __glfw_callback_##callback_name ; \
+    static void __glfw_##callback_name (GLFWwindow *window, _EXPAND c_args) { \
+        wasm_val_t args[] = { WASM_I64_VAL((unsigned long long) window), _EXPAND wasm_args }; \
+        wasm_val_vec_t args_array = WASM_ARRAY_VEC(args); \
+        wasm_val_vec_t results; \
+        runtime->wasm_func_call(__glfw_callback_##callback_name , &args_array, &results); \
+    } \
+    ONYX_DEF(callback_name, (LONG, PTR, INT), ()) { \
+        GLFWwindow *window = (GLFWwindow *) params->data[0].of.i64; \
+        char name[512]; \
+        strncpy(name, ONYX_PTR(params->data[1].of.i32), params->data[2].of.i32); \
+        name[params->data[2].of.i32] = '\0'; \
+        __glfw_callback_##callback_name = runtime->wasm_extern_as_func(runtime->wasm_extern_lookup_by_name(runtime->wasm_module, runtime->wasm_instance, name)); \
+        callback_name(window, __glfw_##callback_name); \
+        return NULL; \
+    }
+"""
+        ],
+
+        custom_implementations = .[
+            .{ "glfwSetKeyCallback", """
+                GLFW_HOOK(glfwSetKeyCallback, (int key, int scancode, int actions, int mods),
+                    (WASM_I32_VAL(key), WASM_I32_VAL(scancode), WASM_I32_VAL(actions), WASM_I32_VAL(mods)))"""
+            },
+            .{ "glfwSetCharCallback", """
+                GLFW_HOOK(glfwSetCharCallback, (unsigned int ch),
+                    (WASM_I32_VAL(ch)))"""
+            },
+            .{ "glfwSetCharModsCallback", """
+                GLFW_HOOK(glfwSetCharModsCallback, (unsigned int ch, int mods),
+                    (WASM_I32_VAL(ch), WASM_I32_VAL(mods)))"""
+            },
+            .{ "glfwSetMouseButtonCallback", """
+                GLFW_HOOK(glfwSetMouseButtonCallback, (int button, int action, int mods),
+                    (WASM_I32_VAL(button), WASM_I32_VAL(action), WASM_I32_VAL(mods)))"""
+            },
+            .{ "glfwSetCursorPosCallback", """
+                GLFW_HOOK(glfwSetCursorPosCallback, (double xpos, double ypos),
+                    (WASM_F64_VAL(xpos), WASM_F64_VAL(ypos)))"""
+            },
+            .{ "glfwSetCursorEnterCallback", """
+                GLFW_HOOK(glfwSetCursorEnterCallback, (int entered),
+                    (WASM_I32_VAL(entered)))"""
+            },
+            .{ "glfwSetScrollCallback", """
+                GLFW_HOOK(glfwSetScrollCallback, (double dx, double dy),
+                    (WASM_F64_VAL(dx), WASM_F64_VAL(dy)))"""
+            },
+            .{ "glfwSetWindowSizeCallback", """
+                GLFW_HOOK(glfwSetWindowSizeCallback, (int width, int height),
+                    (WASM_I32_VAL(width), WASM_I32_VAL(height)))"""
+            },
+        ],
+    });
+
+    if !result {
+        println("Failed to make c-file.");
+        os.exit(1);
+    } else {
+        println("Sucessfully made glfw3.c");
+    }
+}
index 63a924f35bdd1d3d8fde5f9a68a9b4357cb04ccc..b7b38863b0f126e39c8cea0b07cec05a7d8d8db0 100755 (executable)
@@ -1,4 +1,5 @@
 #!/bin/sh
 # To be run from the project root
 
+onyx run modules/glfw3/build --generate-foreign-info
 gcc -O2 -shared -fPIC ./modules/glfw3/onyx_glfw3.c -I include -I lib/common/include -lglfw -o modules/glfw3/onyx_glfw3.so
\ No newline at end of file
index 0e181a17ad64f2f7d037cbfd922cefe5a9b15d1b..76b8e777ca41f0b60c7693d466ba8cfb376c3de9 100644 (file)
@@ -2,8 +2,11 @@ package glfw3
 
 use package core { cptr }
 
-// Temporary path
-#library "onyx_glfw3"
+#if #defined((package runtime).Generated_Foreign_Info) {
+    foreign_block :: __foreign_block
+} else {
+    #library "onyx_glfw3"
+}
 
 // Opaque types that are only used by pointer
 GLFWmonitor_p :: #distinct u64
@@ -32,12 +35,12 @@ GLFWgammaramp :: struct {
      size: i32;
 }
 
-#foreign "onyx_glfw3" {
+#local __foreign_block :: #foreign "onyx_glfw3" {
     glfwInit         :: () -> bool ---
     glfwTerminate    :: () -> void ---
     glfwInitHint     :: (hint, value: i32) -> void ---
     glfwGetVersion   :: (major, minor, rev: ^i32) -> void ---
-    // glfwGetError     :: (description: ^^u8) -> void ---
+    glfwGetError     :: (description: ^cptr(u8)) -> void ---
     // glfwSetErrorCallback :: (f: (i32, cstr) -> void) -> void ---
 
     glfwMakeContextCurrent :: (window: GLFWwindow_p) -> void ---
@@ -67,37 +70,37 @@ GLFWgammaramp :: struct {
     glfwSetScrollCallback :: (window: GLFWwindow_p, export_name: str) -> void ---
     // glfwSetDropCallback
     glfwJoystickPresent :: (jid: i32) -> i32 ---
-    // glfwGetJoystickAxes :: (jid: i32, count: ^i32) -> ^f32 ---
-    // glfwGetJoystickButtons :: (jid: i32, count: ^i32) -> ^u8 ---
-    // glfwGetJoystickHats :: (jid: i32, count: ^i32) -> ^u8 ---
-    // glfwGetJoystickName :: (jid: i32) -> ^u8 ---
-    // glfwGetJoystickGUID :: (jid: i32) -> ^u8 ---
+    glfwGetJoystickAxes :: (jid: i32, count: ^i32) -> cptr(f32) ---
+    glfwGetJoystickButtons :: (jid: i32, count: ^i32) -> cptr(u8) ---
+    glfwGetJoystickHats :: (jid: i32, count: ^i32) -> cptr(u8) ---
+    glfwGetJoystickName :: (jid: i32) -> cptr(u8) ---
+    glfwGetJoystickGUID :: (jid: i32) -> cptr(u8) ---
     glfwSetJoystickUserPointer :: (jid: i32, pointer: rawptr) -> void ---
     glfwGetJoystickUserPointer :: (jid: i32) -> rawptr ---
     glfwJoystickIsGamepad :: (jid: i32) -> i32 ---
     // glfwSetJoystickCallback
     glfwUpdateGamepadMappings :: (string: cstr) -> i32 ---
-    // glfwGetGamepadName :: (jid: i32) -> cstr ---
+    glfwGetGamepadName :: (jid: i32) -> cptr(u8) ---
     glfwGetGamepadState :: (jid: i32, state: ^GLFWgamepadstate) -> i32 ---
     glfwSetClipboardString :: (window: GLFWwindow_p, string: cstr) -> void ---
-    // glfwGetClipboardString :: (window: GLFWwindow_p) -> cstr ---
+    glfwGetClipboardString :: (window: GLFWwindow_p) -> cptr(u8) ---
     glfwGetTime :: () -> f64 ---
     glfwSetTime :: (time: f64) -> void ---
     glfwGetTimerValue :: () -> u64 ---
     glfwGetTimerFrequency :: () -> u64 ---
 
-    glfwGetMonitors :: (max_monitors: i32, out_monitors: ^GLFWmonitor_p, out_count: ^i32) -> void ---
+    glfwGetMonitors :: (out_count: ^i32) -> cptr(GLFWmonitor_p) ---
     glfwGetPrimaryMonitor :: () -> GLFWmonitor_p ---
     glfwGetMonitorPos :: (monitor: GLFWmonitor_p, xpos, ypos: ^i32) -> void ---
     glfwGetMonitorWorkarea :: (monitor: GLFWmonitor_p, xpos, ypos, width, height: ^i32) -> void ---
     glfwGetMonitorPhysicalSize :: (monitor: GLFWmonitor_p, widthMM, heightMM: ^i32) -> void ---
     glfwGetMonitorContentScale :: (monitor: GLFWmonitor_p, xscale, yscale: ^f32) -> void ---
-    // glfwGetMonitorName :: (monitor: GLFWmonitor_p) -> cstr ---
+    glfwGetMonitorName :: (monitor: GLFWmonitor_p) -> cptr(u8) ---
     glfwSetMonitorUserPointer :: (monitor: GLFWmonitor_p, pointer: rawptr) -> void ---
     glfwGetMonitorUserPointer :: (monitor: GLFWmonitor_p) -> rawptr ---
     // glfwSetMonitorCallback
-    glfwGetVideoModes :: (monitor: GLFWmonitor_p, max_modes: i32, out_modes: ^GLFWvidmode, out_count: ^i32) -> void ---
-    glfwGetVideoMode :: (monitor: GLFWmonitor_p, out_mode: ^GLFWvidmode) -> void ---
+    glfwGetVideoModes :: (monitor: GLFWmonitor_p, out_count: ^i32) -> cptr(GLFWvidmode) ---
+    glfwGetVideoMode :: (monitor: GLFWmonitor_p) -> cptr(GLFWvidmode) ---
     glfwSetGamma :: (monitor: GLFWmonitor_p, gamma: f32) -> void ---
     // glfwGetGammaRamp :: (monitor: GLFWmonitor_p, out_ramp: ^GLFWgammramp) -> void ---
     // glfwSetGammaRamp :: (monitor: GLFWmonitor_p, ramp: ^GLFWgammramp) -> void ---
@@ -136,14 +139,19 @@ GLFWgammaramp :: struct {
     glfwPostEmptyEvent :: () -> void ---
     glfwSwapBuffers :: (window: GLFWwindow_p) -> void ---
     glfwSetWindowSizeCallback :: (window: GLFWwindow_p, name: str) -> void ---
+    #local __glfwGetLoadProcAddress :: () -> u64 ---
 }
 
 // This should always be defined right?
 #if #defined(package opengles) {
     use package opengles { GLGetProcAddress }
-    glfwGetLoadProcAddress :: () -> GLGetProcAddress #foreign "onyx_glfw3" "glfwGetLoadProcAddress" ---
+    glfwGetLoadProcAddress :: macro () -> GLGetProcAddress {
+        __glfwGetLoadProcAddress :: __glfwGetLoadProcAddress
+        return ~~ __glfwGetLoadProcAddress();
+    }
 }
 
+
 GLFW_FOCUSED   :: 0x00020001;
 GLFW_ICONIFIED :: 0x00020002;
 GLFW_RESIZABLE :: 0x00020003;
index dcbfb7b9a32f80974fd268d906f3dc9245a5da7a..21957b32327245b011b5cc4283f58c5209042f02 100644 (file)
Binary files a/modules/glfw3/onyx_glfw3.c and b/modules/glfw3/onyx_glfw3.c differ
index d73d1198dd71f05dc6cc67b0c699cd53cb304998..618f6307f7b136e3200015e23ae9bcd5e7339852 100755 (executable)
Binary files a/modules/glfw3/onyx_glfw3.so and b/modules/glfw3/onyx_glfw3.so differ
index 76f06112a3adf297c13a014160a4fa83c145d65f..4d05d9eea82ee919581fca8b60f05de8f19d4a07 100644 (file)
@@ -217,6 +217,7 @@ send_request :: (connection: ^Connection, req: ^Request) -> Response {
         line := io.read_line(^connection.r, consume_newline=true);
         if line == "\r\n" do break;
         res.headers->parse_header_line(line);
+        delete(^line);
     }
 
     data: [..] u8;
@@ -262,13 +263,13 @@ send_request :: (connection: ^Connection, req: ^Request) -> Response {
 }
 
 
+Key_Value_Pair :: struct { key, value: str; }
+
 
 #local {
     HTTP_VERSION_STRING :: "HTTP/1.1"
     USER_AGENT :: "onyx/0.1.0"
 
-    Key_Value_Pair :: struct { key, value: str; }
-
     Post_Data_Encoding :: enum {
         Json;
         Url_Encoded;
index afbba2c283e92f34fa00d8e89775a644ce9bde2a..e6e9f6d5c9e3d60b33420849d047fecd22ef1f76 100644 (file)
@@ -1,3 +1,4 @@
 @echo off
 
+onyx run modules/openal/build --generate-foreign-info
 cl /MT /std:c17 /TC /I include /I lib/common/include /I "C:\Program Files (x86)\OpenAL 1.1 SDK\include" /D_USRDLL /D_WINDLL modules\openal\onyx_openal.c /link "C:\Program Files (x86)\OpenAL 1.1 SDK\libs\Win64\OpenAL32.lib" /DLL /OUT:onyx_openal.dll
\ No newline at end of file
diff --git a/modules/openal/build.onyx b/modules/openal/build.onyx
new file mode 100644 (file)
index 0000000..390cfbe
--- /dev/null
@@ -0,0 +1,32 @@
+#load "core/std"
+#load "scripts/c_binding"
+#load "./module"
+
+use package core
+use package c_binding
+
+main :: () {
+    result := build_c_binding(.{
+        output_file = "modules/openal/onyx_openal.c",
+        foreign_block = (package openal).foreign_block,
+
+        cast_map = .[
+            .{ (package openal).ALCdevice, "ALCdevice *" },
+            .{ (package openal).ALCcontext, "ALCcontext *" },
+        ],
+
+        preamble = .[
+"""
+#include <AL/al.h>
+#include <AL/alc.h>
+"""
+        ],
+    });
+
+    if !result {
+        println("Failed to make c-file.");
+        os.exit(1);
+    } else {
+        println("Sucessfully made openal.c");
+    }
+}
\ No newline at end of file
index 32d64a11babde53ad78f2026403e71917752eb2e..18c9521036a385bec125d47989efad0059b80e6d 100755 (executable)
@@ -1,3 +1,4 @@
 #/bin/sh
 
+onyx run modules/openal/build --generate-foreign-info
 gcc -shared -fPIC modules/openal/onyx_openal.c -lopenal -I include -I lib/common/include -o ./modules/openal/onyx_openal.so
\ No newline at end of file
index ad5bfa50e9211064cf19fd855442f8775b197ab9..1718bcc4f33e0f8257cc0d8571e5914837dcbe2f 100644 (file)
@@ -2,13 +2,17 @@ package openal
 
 use package core { cptr }
 
-#library "onyx_openal"
+#if ((package runtime).Generated_Foreign_Info) {
+    foreign_block :: __foreign_block
+} else {
+    #library "onyx_openal"
+}
 
 ALCdevice :: #distinct u64
 ALCcontext :: #distinct u64
 ALCextfunc :: #distinct u64
 
-#foreign "onyx_openal" {
+#local __foreign_block :: #foreign "onyx_openal" {
     alGenBuffers :: (n: i32, buffers: ^u32) -> void ---
     alDeleteBuffers :: (n: i32, buffers: ^u32) -> void ---
     alIsBuffer :: (buffer: u32) -> bool ---
@@ -106,7 +110,7 @@ ALCextfunc :: #distinct u64
     alcCaptureSamples :: (device: ALCdevice, buf: rawptr, samples: i32) -> void ---
 
     // This returns a C-allocated string, which is not supported at the moment.
-    alGetString  :: (device: ALCdevice, param: i32) -> cptr(u8) ---
+    alGetString  :: (param: i32) -> cptr(u8) ---
     alcGetString :: (device: ALCdevice, param: i32) -> cptr(u8) ---
 }
 
index 79d4924943212a1ffad1dcb305ffbe283ea8c022..135f4b6e03f9b52daff13c9127fc949e00fe89cd 100644 (file)
-#define ONYX_LIBRARY_NAME onyx_openal
-#include "onyx_library.h"
+//
+// THIS FILE WAS AUTOMATICALLY GENERATED.
+//
+
 #include <AL/al.h>
 #include <AL/alc.h>
 
+
+#define ONYX_LIBRARY_NAME onyx_openal
+#include "onyx_library.h"
+
 #define P(i, k) (params->data[i].of.k)
 
-ONYX_DEF(alGenBuffers, (INT, PTR), ()) {
-    alGenBuffers(params->data[0].of.i32, ONYX_PTR(params->data[1].of.i32));
+ONYX_DEF(alGenBuffers, (WASM_I32, WASM_I32), ()) {
+    alGenBuffers(P(0, i32), ONYX_PTR(P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alDeleteBuffers, (WASM_I32, WASM_I32), ()) {
+    alDeleteBuffers(P(0, i32), ONYX_PTR(P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alIsBuffer, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(alIsBuffer(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alBufferData, (WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32), ()) {
+    alBufferData(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)), P(3, i32), P(4, i32));
+    return NULL;
+}
+
+ONYX_DEF(alBufferf, (WASM_I32, WASM_I32, WASM_F32), ()) {
+    alBufferf(P(0, i32), P(1, i32), P(2, f32));
+    return NULL;
+}
+
+ONYX_DEF(alBuffer3f, (WASM_I32, WASM_I32, WASM_F32, WASM_F32, WASM_F32), ()) {
+    alBuffer3f(P(0, i32), P(1, i32), P(2, f32), P(3, f32), P(4, f32));
+    return NULL;
+}
+
+ONYX_DEF(alBufferfv, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alBufferfv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alBufferi, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alBufferi(P(0, i32), P(1, i32), P(2, i32));
+    return NULL;
+}
+
+ONYX_DEF(alBuffer3i, (WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32), ()) {
+    alBuffer3i(P(0, i32), P(1, i32), P(2, i32), P(3, i32), P(4, i32));
+    return NULL;
+}
+
+ONYX_DEF(alBufferiv, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alBufferiv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetBufferf, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alGetBufferf(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetBuffer3f, (WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32), ()) {
+    alGetBuffer3f(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)), ONYX_PTR(P(3, i32)), ONYX_PTR(P(4, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetBufferfv, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alGetBufferfv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetBufferi, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alGetBufferi(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetBuffer3i, (WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32), ()) {
+    alGetBuffer3i(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)), ONYX_PTR(P(3, i32)), ONYX_PTR(P(4, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetBufferiv, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alGetBufferiv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGenSources, (WASM_I32, WASM_I32), ()) {
+    alGenSources(P(0, i32), ONYX_PTR(P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alDeleteSources, (WASM_I32, WASM_I32), ()) {
+    alDeleteSources(P(0, i32), ONYX_PTR(P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alIsSource, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(alIsSource(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alSourcef, (WASM_I32, WASM_I32, WASM_F32), ()) {
+    alSourcef(P(0, i32), P(1, i32), P(2, f32));
     return NULL;
 }
 
-ONYX_DEF(alDeleteBuffers, (INT, PTR), ()) {
-    alDeleteBuffers(params->data[0].of.i32, ONYX_PTR(params->data[1].of.i32));
+ONYX_DEF(alSource3f, (WASM_I32, WASM_I32, WASM_F32, WASM_F32, WASM_F32), ()) {
+    alSource3f(P(0, i32), P(1, i32), P(2, f32), P(3, f32), P(4, f32));
     return NULL;
 }
 
-ONYX_DEF(alIsBuffer, (INT), (BOOL)) {
-    results->data[0] = WASM_I32_VAL(alIsBuffer(params->data[0].of.i32));
+ONYX_DEF(alSourcefv, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alSourcefv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)));
     return NULL;
 }
 
-ONYX_DEF(alBufferData, (INT, INT, PTR, INT, INT), ()) {
-    alBufferData(
-        params->data[0].of.i32,
-        params->data[1].of.i32,
-        ONYX_PTR(params->data[2].of.i32),
-        params->data[3].of.i32,
-        params->data[4].of.i32);
+ONYX_DEF(alSourcei, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alSourcei(P(0, i32), P(1, i32), P(2, i32));
     return NULL;
 }
 
-ONYX_DEF(alBufferf,  (INT, INT, FLOAT), ()) { alBufferf(P(0, i32), P(1, i32), P(2, f32)); return NULL; }
-ONYX_DEF(alBuffer3f, (INT, INT, FLOAT, FLOAT, FLOAT), ()) { alBuffer3f(P(0, i32), P(1, i32), P(2, f32), P(3, f32), P(4, f32)); return NULL; }
-ONYX_DEF(alBufferfv, (INT, INT, PTR), ()) { alBufferfv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))); return NULL; }
-ONYX_DEF(alBufferi,  (INT, INT, INT), ()) { alBufferi(P(0, i32), P(1, i32), P(2, i32)); return NULL; }
-ONYX_DEF(alBuffer3i, (INT, INT, INT, INT, INT), ()) { alBuffer3i(P(0, i32), P(1, i32), P(2, i32), P(3, i32), P(4, i32)); return NULL; }
-ONYX_DEF(alBufferiv, (INT, INT, PTR), ()) { alBufferiv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))); return NULL; }
-ONYX_DEF(alGetBufferf,  (INT, INT, PTR), ()) { alGetBufferf(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))); return NULL; }
-ONYX_DEF(alGetBuffer3f, (INT, INT, PTR, PTR, PTR), ()) { alGetBuffer3f(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)), ONYX_PTR(P(3, i32)), ONYX_PTR(P(4, i32))); return NULL; }
-ONYX_DEF(alGetBufferfv, (INT, INT, PTR), ()) { alGetBufferfv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))); return NULL; }
-ONYX_DEF(alGetBufferi,  (INT, INT, PTR), ()) { alGetBufferi(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))); return NULL; }
-ONYX_DEF(alGetBuffer3i, (INT, INT, PTR, PTR, PTR), ()) { alGetBuffer3i(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)), ONYX_PTR(P(3, i32)), ONYX_PTR(P(4, i32))); return NULL; }
-ONYX_DEF(alGetBufferiv, (INT, INT, PTR), ()) { alGetBufferiv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))); return NULL; }
+ONYX_DEF(alSource3i, (WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32), ()) {
+    alSource3i(P(0, i32), P(1, i32), P(2, i32), P(3, i32), P(4, i32));
+    return NULL;
+}
+
+ONYX_DEF(alSourceiv, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alSourceiv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetSourcef, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alGetSourcef(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetSource3f, (WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32), ()) {
+    alGetSource3f(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)), ONYX_PTR(P(3, i32)), ONYX_PTR(P(4, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetSourcefv, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alGetSourcefv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetSourcei, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alGetSourcei(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetSource3i, (WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32), ()) {
+    alGetSource3i(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)), ONYX_PTR(P(3, i32)), ONYX_PTR(P(4, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetSourceiv, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alGetSourceiv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alSourcePlay, (WASM_I32), ()) {
+    alSourcePlay(P(0, i32));
+    return NULL;
+}
+
+ONYX_DEF(alSourcePlayv, (WASM_I32, WASM_I32), ()) {
+    alSourcePlayv(P(0, i32), ONYX_PTR(P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alSourcePause, (WASM_I32), ()) {
+    alSourcePause(P(0, i32));
+    return NULL;
+}
 
-ONYX_DEF(alGenSources, (INT, PTR), ()) {
-    alGenSources(params->data[0].of.i32, ONYX_PTR(params->data[1].of.i32));
+ONYX_DEF(alSourcePausev, (WASM_I32, WASM_I32), ()) {
+    alSourcePausev(P(0, i32), ONYX_PTR(P(1, i32)));
     return NULL;
 }
 
-ONYX_DEF(alDeleteSources, (INT, PTR), ()) {
-    alDeleteSources(params->data[0].of.i32, ONYX_PTR(params->data[1].of.i32));
+ONYX_DEF(alSourceStop, (WASM_I32), ()) {
+    alSourceStop(P(0, i32));
     return NULL;
 }
 
-ONYX_DEF(alIsSource, (INT), (BOOL)) {
-    results->data[0] = WASM_I32_VAL(alIsSource(params->data[0].of.i32));
+ONYX_DEF(alSourceStopv, (WASM_I32, WASM_I32), ()) {
+    alSourceStopv(P(0, i32), ONYX_PTR(P(1, i32)));
     return NULL;
 }
 
-ONYX_DEF(alSourcef,  (INT, INT, FLOAT), ()) { alSourcef(P(0, i32), P(1, i32), P(2, f32)); return NULL; }
-ONYX_DEF(alSource3f, (INT, INT, FLOAT, FLOAT, FLOAT), ()) { alSource3f(P(0, i32), P(1, i32), P(2, f32), P(3, f32), P(4, f32)); return NULL; }
-ONYX_DEF(alSourcefv, (INT, INT, PTR), ()) { alSourcefv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))); return NULL; }
-ONYX_DEF(alSourcei,  (INT, INT, INT), ()) { alSourcei(P(0, i32), P(1, i32), P(2, i32)); return NULL; }
-ONYX_DEF(alSource3i, (INT, INT, INT, INT, INT), ()) { alSource3i(P(0, i32), P(1, i32), P(2, i32), P(3, i32), P(4, i32)); return NULL; }
-ONYX_DEF(alSourceiv, (INT, INT, PTR), ()) { alSourceiv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))); return NULL; }
-ONYX_DEF(alGetSourcef,  (INT, INT, PTR), ()) { alGetSourcef(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))); return NULL; }
-ONYX_DEF(alGetSource3f, (INT, INT, PTR, PTR, PTR), ()) { alGetSource3f(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)), ONYX_PTR(P(3, i32)), ONYX_PTR(P(4, i32))); return NULL; }
-ONYX_DEF(alGetSourcefv, (INT, INT, PTR), ()) { alGetSourcefv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))); return NULL; }
-ONYX_DEF(alGetSourcei,  (INT, INT, PTR), ()) { alGetSourcei(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))); return NULL; }
-ONYX_DEF(alGetSource3i, (INT, INT, PTR, PTR, PTR), ()) { alGetSource3i(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)), ONYX_PTR(P(3, i32)), ONYX_PTR(P(4, i32))); return NULL; }
-ONYX_DEF(alGetSourceiv, (INT, INT, PTR), ()) { alGetSourceiv(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))); return NULL; }
+ONYX_DEF(alSourceRewind, (WASM_I32), ()) {
+    alSourceRewind(P(0, i32));
+    return NULL;
+}
+
+ONYX_DEF(alSourceRewindv, (WASM_I32, WASM_I32), ()) {
+    alSourceRewindv(P(0, i32), ONYX_PTR(P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alSourceQueueBuffers, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alSourceQueueBuffers(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alSourceUnqueueBuffers, (WASM_I32, WASM_I32, WASM_I32), ()) {
+    alSourceUnqueueBuffers(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alListenerf, (WASM_I32, WASM_F32), ()) {
+    alListenerf(P(0, i32), P(1, f32));
+    return NULL;
+}
+
+ONYX_DEF(alListener3f, (WASM_I32, WASM_F32, WASM_F32, WASM_F32), ()) {
+    alListener3f(P(0, i32), P(1, f32), P(2, f32), P(3, f32));
+    return NULL;
+}
+
+ONYX_DEF(alListenerfv, (WASM_I32, WASM_I32), ()) {
+    alListenerfv(P(0, i32), ONYX_PTR(P(1, i32)));
+    return NULL;
+}
 
-ONYX_DEF(alSourcePlay,  (INT),      ()) { alSourcePlay(P(0, i32)); return NULL; }
-ONYX_DEF(alSourcePlayv, (INT, PTR), ()) { alSourcePlayv(P(0, i32), ONYX_PTR(P(1, i32))); return NULL; }
-ONYX_DEF(alSourcePause,  (INT),      ()) { alSourcePause(P(0, i32)); return NULL; }
-ONYX_DEF(alSourcePausev, (INT, PTR), ()) { alSourcePausev(P(0, i32), ONYX_PTR(P(1, i32))); return NULL; }
-ONYX_DEF(alSourceStop,  (INT),      ()) { alSourceStop(P(0, i32)); return NULL; }
-ONYX_DEF(alSourceStopv, (INT, PTR), ()) { alSourceStopv(P(0, i32), ONYX_PTR(P(1, i32))); return NULL; }
-ONYX_DEF(alSourceRewind,  (INT),      ()) { alSourceRewind(P(0, i32)); return NULL; }
-ONYX_DEF(alSourceRewindv, (INT, PTR), ()) { alSourceRewindv(P(0, i32), ONYX_PTR(P(1, i32))); return NULL; }
-ONYX_DEF(alSourceQueueBuffers,   (INT, INT, PTR), ()) { alSourceQueueBuffers(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))); return NULL; }
-ONYX_DEF(alSourceUnqueueBuffers, (INT, INT, PTR), ()) { alSourceUnqueueBuffers(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))); return NULL; }
+ONYX_DEF(alListeneri, (WASM_I32, WASM_I32), ()) {
+    alListeneri(P(0, i32), P(1, i32));
+    return NULL;
+}
+
+ONYX_DEF(alListener3i, (WASM_I32, WASM_I32, WASM_I32, WASM_I32), ()) {
+    alListener3i(P(0, i32), P(1, i32), P(2, i32), P(3, i32));
+    return NULL;
+}
 
-ONYX_DEF(alListenerf,  (INT, FLOAT), ()) { alListenerf(P(0, i32), P(1, f32)); return NULL; }
-ONYX_DEF(alListener3f, (INT, FLOAT, FLOAT, FLOAT), ()) { alListener3f(P(0, i32), P(1, f32), P(2, f32), P(3, f32)); return NULL; }
-ONYX_DEF(alListenerfv, (INT, PTR), ()) { alListenerfv(P(0, i32), ONYX_PTR(P(1, i32))); return NULL; }
-ONYX_DEF(alListeneri,  (INT, INT), ()) { alListeneri(P(0, i32), P(1, i32)); return NULL; }
-ONYX_DEF(alListener3i, (INT, INT, INT, INT), ()) { alListener3i(P(0, i32), P(1, i32), P(2, i32), P(3, i32)); return NULL; }
-ONYX_DEF(alListeneriv, (INT, PTR), ()) { alListeneriv(P(0, i32), ONYX_PTR(P(1, i32))); return NULL; }
+ONYX_DEF(alListeneriv, (WASM_I32, WASM_I32), ()) {
+    alListeneriv(P(0, i32), ONYX_PTR(P(1, i32)));
+    return NULL;
+}
 
-ONYX_DEF(alGetListenerf,  (INT, PTR), ()) { alGetListenerf(P(0, i32), ONYX_PTR(P(1, i32))); return NULL; }
-ONYX_DEF(alGetListener3f, (INT, PTR, PTR, PTR), ()) { alGetListener3f(P(0, i32), ONYX_PTR(P(1, i32)), ONYX_PTR(P(2, i32)), ONYX_PTR(P(3, i32))); return NULL; }
-ONYX_DEF(alGetListenerfv, (INT, PTR), ()) { alGetListenerfv(P(0, i32), ONYX_PTR(P(1, i32))); return NULL; }
-ONYX_DEF(alGetListeneri,  (INT, PTR), ()) { alGetListeneri(P(0, i32), ONYX_PTR(P(1, i32))); return NULL; }
-ONYX_DEF(alGetListener3i, (INT, PTR, PTR, PTR), ()) { alGetListener3i(P(0, i32), ONYX_PTR(P(1, i32)), ONYX_PTR(P(2, i32)), ONYX_PTR(P(3, i32))); return NULL; }
-ONYX_DEF(alGetListeneriv, (INT, PTR), ()) { alGetListeneriv(P(0, i32), ONYX_PTR(P(1, i32))); return NULL; }
+ONYX_DEF(alGetListenerf, (WASM_I32, WASM_I32), ()) {
+    alGetListenerf(P(0, i32), ONYX_PTR(P(1, i32)));
+    return NULL;
+}
 
-ONYX_DEF(alEnable,  (INT), ()) { alEnable(P(0, i32)); return NULL; }
-ONYX_DEF(alDisable, (INT), ()) { alDisable(P(0, i32)); return NULL; }
-ONYX_DEF(alIsEnabled, (INT), (BOOL)) { results->data[0] = WASM_I32_VAL(alIsEnabled(P(0, i32))); return NULL; }
-ONYX_DEF(alGetBoolean, (INT), (BOOL)) { results->data[0] = WASM_I32_VAL(alGetBoolean(P(0, i32))); return NULL; }
-ONYX_DEF(alGetDouble, (INT), (DOUBLE)) { results->data[0] = WASM_F64_VAL(alGetDouble(P(0, i32))); return NULL; }
-ONYX_DEF(alGetFloat, (INT), (FLOAT)) { results->data[0] = WASM_F32_VAL(alGetFloat(P(0, i32))); return NULL; }
-ONYX_DEF(alGetInteger, (INT), (INT)) { results->data[0] = WASM_I32_VAL(alGetInteger(P(0, i32))); return NULL; }
-ONYX_DEF(alGetBooleanv, (INT, PTR), ()) { alGetBooleanv(P(0, i32), ONYX_PTR(P(1, i32))); return NULL; }
-ONYX_DEF(alGetDoublev, (INT, PTR), ()) { alGetDoublev(P(0, i32), ONYX_PTR(P(1, i32))); return NULL; }
-ONYX_DEF(alGetFloatv, (INT, PTR), ()) { alGetFloatv(P(0, i32), ONYX_PTR(P(1, i32))); return NULL; }
-ONYX_DEF(alGetIntegerv, (INT, PTR), ()) { alGetIntegerv(P(0, i32), ONYX_PTR(P(1, i32))); return NULL; }
-ONYX_DEF(alDistanceModel, (INT), ()) { alDistanceModel(P(0, i32)); return NULL; }
-ONYX_DEF(alDopplerFactor, (FLOAT), ()) { alDistanceModel(P(0, f32)); return NULL; }
-ONYX_DEF(alSpeedOfSound, (FLOAT), ()) { alDistanceModel(P(0, f32)); return NULL; }
+ONYX_DEF(alGetListener3f, (WASM_I32, WASM_I32, WASM_I32, WASM_I32), ()) {
+    alGetListener3f(P(0, i32), ONYX_PTR(P(1, i32)), ONYX_PTR(P(2, i32)), ONYX_PTR(P(3, i32)));
+    return NULL;
+}
 
-ONYX_DEF(alGetError, (), (INT)) { results->data[0] = WASM_I32_VAL(alGetError()); return NULL; }
-ONYX_DEF(alGetString, (INT), (LONG)) {
-    wasm_val_init_ptr(&results->data[0], (void *) alGetString(P(0, i32)));
-    return NULL;
-}
-
-ONYX_DEF(alcCreateContext, (LONG, PTR), (LONG)) { wasm_val_init_ptr(&results->data[0], alcCreateContext((ALCdevice *) P(0, i64), ONYX_PTR(P(1, i32)))); return NULL; }
-ONYX_DEF(alcMakeContextCurrent, (LONG), (BOOL)) { results->data[0] = WASM_I32_VAL(alcMakeContextCurrent((ALCcontext *) P(0, i64))); return NULL; }
-ONYX_DEF(alcProcessContext, (LONG), ()) { alcProcessContext((ALCcontext *) P(0, i64)); return NULL; }
-ONYX_DEF(alcSuspendContext, (LONG), ()) { alcSuspendContext((ALCcontext *) P(0, i64)); return NULL; }
-ONYX_DEF(alcDestroyContext, (LONG), ()) { alcDestroyContext((ALCcontext *) P(0, i64)); return NULL; }
-ONYX_DEF(alcGetCurrentContext, (), (LONG)) { wasm_val_init_ptr(&results->data[0], alcGetCurrentContext()); return NULL; }
-ONYX_DEF(alcGetContextsDevice, (LONG), (LONG)) { wasm_val_init_ptr(&results->data[0], alcGetContextsDevice((ALCcontext *) P(0, i64))); return NULL; }
-ONYX_DEF(alcGetError, (LONG), (INT)) { results->data[0] = WASM_I32_VAL(alcGetError((ALCdevice *) P(0, i64))); return NULL; }
-ONYX_DEF(alcOpenDevice, (PTR), (LONG)) { wasm_val_init_ptr(&results->data[0], alcOpenDevice(ONYX_PTR(P(0, i32)))); return NULL; }
-ONYX_DEF(alcCloseDevice, (LONG), (BOOL)) { results->data[0] = WASM_I32_VAL(alcCloseDevice((ALCdevice *) P(0, i64))); return NULL; }
-
-ONYX_DEF(alcIsExtensionPresent, (LONG, PTR), (BOOL)) { results->data[0] = WASM_I32_VAL(alcIsExtensionPresent((ALCdevice *) P(0, i64), ONYX_PTR(P(1, i32)))); return NULL; }
-ONYX_DEF(alcGetProcAddress, (LONG, PTR), (LONG)) { wasm_val_init_ptr(&results->data[0], alcGetProcAddress((ALCdevice *) P(0, i64), ONYX_PTR(P(1, i32)))); return NULL; }
-ONYX_DEF(alcGetEnumValue, (LONG, PTR), (INT)) { results->data[0] = WASM_I32_VAL(alcGetEnumValue((ALCdevice *) P(0, i64), ONYX_PTR(P(1, i32)))); return NULL; }
-ONYX_DEF(alcGetIntegerv, (LONG, INT, INT, PTR), ()) { alcGetIntegerv((ALCdevice *) P(0, i64), P(1, i32), P(2, i32), ONYX_PTR(P(3, i32))); return NULL; }
-
-ONYX_DEF(alcCaptureOpenDevice, (PTR, INT, INT, INT), (LONG)) {
-    wasm_val_init_ptr(&results->data[0], alcCaptureOpenDevice(ONYX_PTR(P(0, i32)), P(1, i32), P(2, i32), P(3, i32)));
-    return NULL;
-}
-ONYX_DEF(alcCaptureCloseDevice, (LONG), (BOOL)) { results->data[0] = WASM_I32_VAL(alcCaptureCloseDevice((ALCdevice *) P(0, i64))); return NULL; }
-ONYX_DEF(alcCaptureStart, (LONG), ()) { alcCaptureStart((ALCdevice *) P(0, i64)); return NULL; }
-ONYX_DEF(alcCaptureStop, (LONG), ()) { alcCaptureStop((ALCdevice *) P(0, i64)); return NULL; }
-ONYX_DEF(alcCaptureSamples, (LONG, PTR, INT), ()) { alcCaptureSamples((ALCdevice *) P(0, i64), ONYX_PTR(P(1, i32)), P(2, i32)); return NULL; }
-ONYX_DEF(alcGetString, (LONG, INT), (LONG)) {
-    wasm_val_init_ptr(&results->data[0], (void *) alcGetString((ALCdevice *) P(0, i64), P(1, i32)));
+ONYX_DEF(alGetListenerfv, (WASM_I32, WASM_I32), ()) {
+    alGetListenerfv(P(0, i32), ONYX_PTR(P(1, i32)));
     return NULL;
 }
 
+ONYX_DEF(alGetListeneri, (WASM_I32, WASM_I32), ()) {
+    alGetListeneri(P(0, i32), ONYX_PTR(P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetListener3i, (WASM_I32, WASM_I32, WASM_I32, WASM_I32), ()) {
+    alGetListener3i(P(0, i32), ONYX_PTR(P(1, i32)), ONYX_PTR(P(2, i32)), ONYX_PTR(P(3, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetListeneriv, (WASM_I32, WASM_I32), ()) {
+    alGetListeneriv(P(0, i32), ONYX_PTR(P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alEnable, (WASM_I32), ()) {
+    alEnable(P(0, i32));
+    return NULL;
+}
+
+ONYX_DEF(alDisable, (WASM_I32), ()) {
+    alDisable(P(0, i32));
+    return NULL;
+}
+
+ONYX_DEF(alIsEnabled, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(alIsEnabled(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetBoolean, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(alGetBoolean(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetDouble, (WASM_I32), (WASM_F64)) {
+    results->data[0] = WASM_F64_VAL(alGetDouble(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetFloat, (WASM_I32), (WASM_F32)) {
+    results->data[0] = WASM_F32_VAL(alGetFloat(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetInteger, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(alGetInteger(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetBooleanv, (WASM_I32, WASM_I32), ()) {
+    alGetBooleanv(P(0, i32), ONYX_PTR(P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetDoublev, (WASM_I32, WASM_I32), ()) {
+    alGetDoublev(P(0, i32), ONYX_PTR(P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetFloatv, (WASM_I32, WASM_I32), ()) {
+    alGetFloatv(P(0, i32), ONYX_PTR(P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alGetIntegerv, (WASM_I32, WASM_I32), ()) {
+    alGetIntegerv(P(0, i32), ONYX_PTR(P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alDistanceModel, (WASM_I32), ()) {
+    alDistanceModel(P(0, i32));
+    return NULL;
+}
+
+ONYX_DEF(alDopplerFactor, (WASM_F32), ()) {
+    alDopplerFactor(P(0, f32));
+    return NULL;
+}
+
+ONYX_DEF(alSpeedOfSound, (WASM_F32), ()) {
+    alSpeedOfSound(P(0, f32));
+    return NULL;
+}
+
+ONYX_DEF(alGetError, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(alGetError());
+    return NULL;
+}
+
+ONYX_DEF(alcCreateContext, (WASM_I64, WASM_I32), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(alcCreateContext((ALCdevice *) P(0, i64), ONYX_PTR(P(1, i32))));
+    return NULL;
+}
+
+ONYX_DEF(alcMakeContextCurrent, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(alcMakeContextCurrent((ALCcontext *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(alcProcessContext, (WASM_I64), ()) {
+    alcProcessContext((ALCcontext *) P(0, i64));
+    return NULL;
+}
+
+ONYX_DEF(alcSuspendContext, (WASM_I64), ()) {
+    alcSuspendContext((ALCcontext *) P(0, i64));
+    return NULL;
+}
+
+ONYX_DEF(alcDestroyContext, (WASM_I64), ()) {
+    alcDestroyContext((ALCcontext *) P(0, i64));
+    return NULL;
+}
+
+ONYX_DEF(alcGetCurrentContext, (), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(alcGetCurrentContext());
+    return NULL;
+}
+
+ONYX_DEF(alcGetContextsDevice, (WASM_I64), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(alcGetContextsDevice((ALCcontext *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(alcGetError, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(alcGetError((ALCdevice *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(alcOpenDevice, (WASM_I32), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(alcOpenDevice(ONYX_PTR(P(0, i32))));
+    return NULL;
+}
+
+ONYX_DEF(alcCloseDevice, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(alcCloseDevice((ALCdevice *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(alcIsExtensionPresent, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(alcIsExtensionPresent((ALCdevice *) P(0, i64), ONYX_PTR(P(1, i32))));
+    return NULL;
+}
+
+ONYX_DEF(alcGetProcAddress, (WASM_I64, WASM_I32), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(alcGetProcAddress((ALCdevice *) P(0, i64), ONYX_PTR(P(1, i32))));
+    return NULL;
+}
+
+ONYX_DEF(alcGetEnumValue, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(alcGetEnumValue((ALCdevice *) P(0, i64), ONYX_PTR(P(1, i32))));
+    return NULL;
+}
+
+ONYX_DEF(alcGetIntegerv, (WASM_I64, WASM_I32, WASM_I32, WASM_I32), ()) {
+    alcGetIntegerv((ALCdevice *) P(0, i64), P(1, i32), P(2, i32), ONYX_PTR(P(3, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alcCaptureOpenDevice, (WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(alcCaptureOpenDevice(ONYX_PTR(P(0, i32)), P(1, i32), P(2, i32), P(3, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alcCaptureCloseDevice, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(alcCaptureCloseDevice((ALCdevice *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(alcCaptureStart, (WASM_I64), ()) {
+    alcCaptureStart((ALCdevice *) P(0, i64));
+    return NULL;
+}
+
+ONYX_DEF(alcCaptureStop, (WASM_I64), ()) {
+    alcCaptureStop((ALCdevice *) P(0, i64));
+    return NULL;
+}
+
+ONYX_DEF(alcCaptureSamples, (WASM_I64, WASM_I32, WASM_I32), ()) {
+    alcCaptureSamples((ALCdevice *) P(0, i64), ONYX_PTR(P(1, i32)), P(2, i32));
+    return NULL;
+}
+
+ONYX_DEF(alGetString, (WASM_I32), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(alGetString(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(alcGetString, (WASM_I64, WASM_I32), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(alcGetString((ALCdevice *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+
+
 ONYX_LIBRARY {
     ONYX_FUNC(alGenBuffers)
     ONYX_FUNC(alDeleteBuffers)
@@ -163,7 +475,6 @@ ONYX_LIBRARY {
     ONYX_FUNC(alGetBufferi)
     ONYX_FUNC(alGetBuffer3i)
     ONYX_FUNC(alGetBufferiv)
-
     ONYX_FUNC(alGenSources)
     ONYX_FUNC(alDeleteSources)
     ONYX_FUNC(alIsSource)
@@ -189,7 +500,6 @@ ONYX_LIBRARY {
     ONYX_FUNC(alSourceRewindv)
     ONYX_FUNC(alSourceQueueBuffers)
     ONYX_FUNC(alSourceUnqueueBuffers)
-
     ONYX_FUNC(alListenerf)
     ONYX_FUNC(alListener3f)
     ONYX_FUNC(alListenerfv)
@@ -202,7 +512,6 @@ ONYX_LIBRARY {
     ONYX_FUNC(alGetListeneri)
     ONYX_FUNC(alGetListener3i)
     ONYX_FUNC(alGetListeneriv)
-
     ONYX_FUNC(alEnable)
     ONYX_FUNC(alDisable)
     ONYX_FUNC(alIsEnabled)
@@ -217,9 +526,7 @@ ONYX_LIBRARY {
     ONYX_FUNC(alDistanceModel)
     ONYX_FUNC(alDopplerFactor)
     ONYX_FUNC(alSpeedOfSound)
-
     ONYX_FUNC(alGetError)
-
     ONYX_FUNC(alcCreateContext)
     ONYX_FUNC(alcMakeContextCurrent)
     ONYX_FUNC(alcProcessContext)
@@ -228,20 +535,18 @@ ONYX_LIBRARY {
     ONYX_FUNC(alcGetCurrentContext)
     ONYX_FUNC(alcGetContextsDevice)
     ONYX_FUNC(alcGetError)
-
     ONYX_FUNC(alcOpenDevice)
     ONYX_FUNC(alcCloseDevice)
-
     ONYX_FUNC(alcIsExtensionPresent)
     ONYX_FUNC(alcGetProcAddress)
     ONYX_FUNC(alcGetEnumValue)
     ONYX_FUNC(alcGetIntegerv)
-
     ONYX_FUNC(alcCaptureOpenDevice)
     ONYX_FUNC(alcCaptureCloseDevice)
     ONYX_FUNC(alcCaptureStart)
     ONYX_FUNC(alcCaptureStop)
     ONYX_FUNC(alcCaptureSamples)
-
+    ONYX_FUNC(alGetString)
+    ONYX_FUNC(alcGetString)
     NULL
 };
\ No newline at end of file
index 7b8357933ac60f375b03645015e14b1993fca5ee..d853604de658d67dda22d0fce54c4c217c849cf3 100755 (executable)
Binary files a/modules/openal/onyx_openal.so and b/modules/openal/onyx_openal.so differ
index 9efc23a9661310b0de6e81f85c84420dd93e2cfa..feda8a67dd1de6ba10838a01463e8143c74505b2 100644 (file)
@@ -1,7 +1,7 @@
 #load "scripts/c_library"
 use package core
 
-main :: (args) => {
+main :: () {
     path := module_path(#file);
 
     compile_c_file(
index f3e460cde2a737a073c23ac9e6027644b532dacc..a33bd17e943d60af2729540f6503a2832c62e07b 100755 (executable)
Binary files a/modules/stb_image/stb_image.so and b/modules/stb_image/stb_image.so differ
index e506eeea71f3ceae15d0953143f652393efb9a5d..4d577febde5cc704f30e3e9e2c9685e32e7997fe 100644 (file)
@@ -12,11 +12,17 @@ Cast_Mapping :: struct {
     name: str;
 }
 
+Impl_Mapping :: struct {
+    name: str;
+    impl: str;
+}
+
 Binding_Config :: struct {
     foreign_block: type_info.foreign_block;
     preamble: [] str;
     output_file: str;
     cast_map: [] Cast_Mapping;
+    custom_implementations: [] Impl_Mapping;
 }
 
 build_c_binding :: (use binding_config: Binding_Config) -> bool {
@@ -27,6 +33,14 @@ build_c_binding :: (use binding_config: Binding_Config) -> bool {
         write_file_introduction(^writer, preamble, fb.module_name);
 
         for fb.funcs {
+            for impl: custom_implementations {
+                if impl.name == it.name {
+                    io.write(^writer, impl.impl);
+                    io.write(^writer, "\n");
+                    continue continue;
+                }
+            }
+
             write_function_body(^writer, it, cast_map);
         }
 
@@ -37,6 +51,10 @@ build_c_binding :: (use binding_config: Binding_Config) -> bool {
 }
 
 write_file_introduction :: (writer: ^io.Writer, preamble: [] str, name: str) {
+    io.write_format(writer, "//\n");
+    io.write_format(writer, "// THIS FILE WAS AUTOMATICALLY GENERATED.\n");
+    io.write_format(writer, "//\n");
+
     for text: preamble {
         io.write_format(writer, "{}\n", text);
     }
index f42d43110d7de236356ce279dfe9b09f766520ca..33c84a578ef7e01edc13136c172713de3dfe9851 100644 (file)
@@ -11,7 +11,8 @@ Linux_Compiler :: "/usr/bin/gcc"
 // Call as module_path(#file)
 module_path :: (file_path: str) -> str {
     out := file_path;
-    while out.count > 0 && (out[out.count - 1] != #char "/" && out[out.count - 1] != #char "\\") {
+    while out.count > 0 {
+        if out[out.count - 1] == #char "/" || out[out.count - 1] == #char "\\" do break;
         out.count -= 1;
     }