From 432ba6341971ffaaae9b040d85da088307b55fd6 Mon Sep 17 00:00:00 2001
From: Brendan Hansen <brendan.f.hansen@gmail.com>
Date: Tue, 26 Apr 2022 13:41:29 -0500
Subject: [PATCH] added most of the ncurses library

---
 core/type_info/helper.onyx      |    8 +-
 modules/ncurses/build.sh        |    4 +
 modules/ncurses/module.onyx     |  352 +++++++++
 modules/ncurses/ncurses.c       | 1190 +++++++++++++++++++++++++++++++
 modules/ncurses/onyx_ncurses.so |  Bin 0 -> 158240 bytes
 scripts/c_binding.onyx          |  193 +++++
 6 files changed, 1746 insertions(+), 1 deletion(-)
 create mode 100755 modules/ncurses/build.sh
 create mode 100644 modules/ncurses/module.onyx
 create mode 100644 modules/ncurses/ncurses.c
 create mode 100755 modules/ncurses/onyx_ncurses.so
 create mode 100644 scripts/c_binding.onyx

diff --git a/core/type_info/helper.onyx b/core/type_info/helper.onyx
index 8c9c9ac8..47a3ac89 100644
--- a/core/type_info/helper.onyx
+++ b/core/type_info/helper.onyx
@@ -125,6 +125,12 @@ write_type_name :: (writer: ^io.Writer, t: type_expr) {
     }
 }
 
+is_pointer :: (t: type_expr) -> bool {
+    if t == rawptr do return true;
+    info := get_type_info(t);
+    return info.kind == .Pointer;
+}
+
 size_of :: (t: type_expr) -> u32 {
     info := get_type_info(t);
     if info == null do return 0;
@@ -318,4 +324,4 @@ for_all_types :: macro (body: Code) {
 
         #unquote body;
     }
-}
\ No newline at end of file
+}
diff --git a/modules/ncurses/build.sh b/modules/ncurses/build.sh
new file mode 100755
index 00000000..caff9ee2
--- /dev/null
+++ b/modules/ncurses/build.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+onyx run scripts/c_binding.onyx modules/ncurses/module.onyx > modules/ncurses/ncurses.c
+gcc -shared -fPIC -I include -I lib/common/include -O2 modules/ncurses/ncurses.c -o modules/ncurses/onyx_ncurses.so -lncurses
diff --git a/modules/ncurses/module.onyx b/modules/ncurses/module.onyx
new file mode 100644
index 00000000..d77c728e
--- /dev/null
+++ b/modules/ncurses/module.onyx
@@ -0,0 +1,352 @@
+package ncurses
+
+use package core {cptr, conv, string}
+
+
+WINDOW :: #distinct u64
+SCREEN :: #distinct u64
+
+chtype :: u32
+
+attr_t :: u32
+A_NORMAL :: 0
+A_ATTRIBUTES :: 0xffffff00
+A_CHARTEXT   :: 0xff
+A_COLOR      :: 0xff00
+A_STANDOUT   :: 0x00010000
+A_UNDERLINE  :: 0x00020000
+A_REVERSE    :: 0x00040000
+A_BLINK      :: 0x00080000
+A_DIM        :: 0x00100000
+A_BOLD       :: 0x00200000
+A_ALTCHARSET :: 0x00400000
+A_INVIS      :: 0x00800000
+A_PROTECT    :: 0x01000000
+A_HORIZONTAL :: 0x02000000
+A_LEFT       :: 0x04000000
+A_LOW        :: 0x08000000
+A_RIGHT      :: 0x10000000
+A_TOP        :: 0x20000000
+A_VERTICAL   :: 0x40000000
+A_ITALIC     :: 0x80000000
+
+#library "onyx_ncurses"
+#foreign "onyx_ncurses" {
+
+/*
+use CBindings
+CBindings :: struct {
+    name :: "onyx_ncurses"
+    file_prefix :: """
+#include "ncurses.h"
+
+WINDOW *__get_stdscr() {
+    return stdscr;
+}
+
+void __get_yx    (WINDOW *w, int *y, int *x) { getyx(w, *y, *x); }
+void __get_par_yx(WINDOW *w, int *y, int *x) { getparyx(w, *y, *x); }
+void __get_beg_yx(WINDOW *w, int *y, int *x) { getbegyx(w, *y, *x); }
+void __get_max_yx(WINDOW *w, int *y, int *x) { getmaxyx(w, *y, *x); }
+
+chtype __ACS_LOOKUP(int a) { return NCURSES_ACS(a); }
+
+"""
+    cast_map :: (#type struct {type: type_expr; name: str;}).[
+        .{ WINDOW, "WINDOW *" },
+    ]
+*/
+
+    // initscr
+    initscr   :: () -> WINDOW ---
+    endwin    :: () -> i32    ---
+    isendwin  :: () -> bool   ---
+    newterm   :: (type: cstr, out_fd, in_fd: ^u32) -> SCREEN ---
+    set_term  :: (new: SCREEN) -> SCREEN ---
+    delscreen :: (sp: SCREEN) -> void ---
+
+    // color
+    start_color :: () -> i32 ---
+    has_colors  :: () -> bool ---
+    can_change_color :: () -> bool ---
+    init_pair  :: (pair: i32, foreground: i32, background: i32) -> i32 ---
+    init_color :: (color: i32, r, g, b: i32) -> i32 ---
+    color_content :: (color: i32, r, g, b: ^i32) -> i32 ---
+    pair_content  :: (pair: i32, f, b: ^i32) -> i32 ---
+    reset_color_pairs :: () -> void ---
+    COLOR_PAIR :: (color: i32) -> i32 ---
+    PAIR_NUMBER :: (pair: i32) -> i32 ---
+
+    // inopts
+    cbreak :: () -> i32 ---
+    nocbreak :: () -> i32 ---
+    echo :: () -> i32 ---
+    noecho :: () -> i32 ---
+    intrflush :: (w: WINDOW, bf: bool) -> i32 ---
+    keypad :: (w: WINDOW, bf: bool) -> i32 ---
+    meta :: (w: WINDOW, bf: bool) -> i32 ---
+    nodelay :: (w: WINDOW, bf: bool) -> i32 ---
+    notimeout :: (w: WINDOW, bf: bool) -> i32 ---
+    nl :: () -> i32 ---
+    nonl :: () -> i32 ---
+    raw :: () -> i32 ---
+    noraw :: () -> i32 ---
+    qiflush :: () -> void ---
+    noqiflush :: () -> void ---
+    halfdelay :: (tenths: i32) -> i32 ---
+    timeout :: (delay: i32) -> void ---
+    wtimeout :: (w: WINDOW, delay: i32) -> void ---
+    typeahead :: (fd: i32) -> i32 ---
+
+    // outopts
+    clearkok :: (w: WINDOW, bf: bool) -> i32 ---
+    idlok :: (w: WINDOW, bf: bool) -> i32 ---
+    idcok :: (w: WINDOW, bf: bool) -> void ---
+    immedok :: (w: WINDOW, bf: bool) -> void ---
+    leaveok :: (w: WINDOW, bf: bool) -> i32 ---
+    scrollok :: (w: WINDOW, bf: bool) -> i32 ---
+    setscrreg :: (top, bot: i32) -> i32 ---
+    wsetscrreg :: (w: WINDOW, top, bot: i32) -> i32 ---
+
+    // attr
+    attr_get  :: (attr: ^attr_t, pair: ^u16, opts: ^void) -> i32 ---
+    wattr_get :: (w: WINDOW, attr: ^attr_t, pair: ^u16, opts: ^void) -> i32 ---
+    attr_set  :: (attr: ^attr_t, pair: u16, opts: ^void) -> i32 ---
+    wattr_set :: (w: WINDOW, attr: attr_t, pair: u16, opts: ^void) -> i32 ---
+    attr_off  :: (attr: attr_t, opts: ^void) -> i32 ---
+    wattr_off :: (w: WINDOW, attr: attr_t, opts: ^void) -> i32 ---
+    attr_on   :: (attr: attr_t, opts: ^void) -> i32 ---
+    wattr_on  :: (w: WINDOW, attr: attr_t, opts: ^void) -> i32 ---
+    attroff   :: (attr: attr_t) -> i32 ---
+    wattroff  :: (w: WINDOW, attr: attr_t) -> i32 ---
+    attron    :: (attr: attr_t) -> i32 ---
+    wattron   :: (w: WINDOW, attr: attr_t) -> i32 ---
+    attrset   :: (attr: attr_t) -> i32 ---
+    wattrset  :: (w: WINDOW, attr: attr_t) -> i32 ---
+    chgat     :: (n: i32, attr: attr_t, pair: u16, opts: ^void) -> i32 ---
+    wchgat    :: (w: WINDOW, n: i32, attr: attr_t, pair: u16, opts: ^void) -> i32 ---
+    mvchgat   :: (y, x: i32, n: i32, attr: attr_t, pair: u16, opts: ^void) -> i32 ---
+    mvmchgat  :: (w: WINDOW, y, x: i32, n: i32, attr: attr_t, pair: u16, opts: ^void) -> i32 ---
+    color_set  :: (pair: u16, opts: ^void) -> i32 ---
+    wcolor_set :: (w: WINDOW, pair: u16, opts: ^void) -> i32 ---
+    standend  :: () -> i32 ---
+    wstandend :: (w: WINDOW) -> i32 ---
+    standout  :: () -> i32 ---
+    wstandout :: (w: WINDOW) -> i32 ---
+
+    // util
+    unctrl     :: (c: chtype) -> cptr(u8) ---
+    // wunctrl   :: (c: ^u8) -> cptr(u8) ---
+    keyname    :: (c: i32) -> cptr(u8) ---
+    key_name   :: (w: i32) -> cptr(u8) ---
+    filter     :: () -> void ---
+    nofilter   :: () -> void ---
+    use_env    :: (f: bool) -> void ---
+    use_tioctl :: (f: bool) -> void ---
+    // putwin     :: (w: WINDOW, filep: u32) -> i32 ---
+    getwin     :: (filep: u32) -> WINDOW ---
+    delay_output :: (ms: i32) -> i32 ---
+    flushinp   :: () -> i32 ---
+
+    // kernel
+    def_prog_mode :: () -> i32 ---
+    def_shell_mode :: () -> i32 ---
+    reset_prog_mode :: () -> i32 ---
+    reset_shell_mode :: () -> i32 ---
+    resetty :: () -> i32 ---
+    savetty :: () -> i32 ---
+    getsyx  :: (y, x: i32) -> void ---
+    setsyx  :: (y, x: i32) -> void ---
+    // ripoffline :: (line: i32, init: (WINDOW, i32) -> i32) -> i32 ---
+    curs_set :: (visibility: i32) -> i32 ---
+    napms :: (ms: i32) -> i32 ---
+
+    // refresh
+    refresh :: () -> i32 ---
+    wrefresh :: (w: WINDOW) -> i32 ---
+    wnoutrefresh :: (w: WINDOW) -> i32 ---
+    doupdate :: () -> i32 ---
+    redrawwin :: (w: WINDOW) -> i32 ---
+    wredrawln :: (w: WINDOW, beg_line, num_lines: i32) -> i32 ---
+
+    // addch
+    addch :: (ch: chtype) -> i32 ---
+    waddch :: (w: WINDOW, ch: chtype) -> i32 ---
+    mvaddch :: (y, x: i32, ch: chtype) -> i32 ---
+    mvwaddch :: (w: WINDOW, y, x: i32, ch: chtype) -> i32 ---
+    echochar :: (ch: chtype) -> i32 ---
+    wechochar :: (w: WINDOW, ch: chtype) -> i32 ---
+
+    // addchstr
+    addchstr :: (chstr: ^chtype) -> i32 ---
+    addchnstr :: (chstr: [] chtype) -> i32 ---
+    waddchstr :: (w: WINDOW, chstr: ^chtype) -> i32 ---
+    waddchnstr :: (w: WINDOW, chstr: [] chtype) -> i32 ---
+    mvaddchstr :: (y, x: i32, chstr: ^chtype) -> i32 ---
+    mvaddchnstr :: (y, x: i32, chstr: [] chtype) -> i32 ---
+    mvwaddchstr :: (w: WINDOW, y, x: i32, chstr: ^chtype) -> i32 ---
+    mvwaddchnstr :: (w: WINDOW, y, x: i32, chstr: [] chtype) -> i32 ---
+
+    // addstr
+    addstr :: (chstr: cstr) -> i32 ---
+    addnstr :: (chstr: str) -> i32 ---
+    waddstr :: (w: WINDOW, chstr: cstr) -> i32 ---
+    waddnstr :: (w: WINDOW, chstr: str) -> i32 ---
+    mvaddstr :: (y, x: i32, chstr: cstr) -> i32 ---
+    mvaddnstr :: (y, x: i32, chstr: str) -> i32 ---
+    mvwaddstr :: (w: WINDOW, y, x: i32, chstr: cstr) -> i32 ---
+    mvwaddnstr :: (w: WINDOW, y, x: i32, chstr: str) -> i32 ---
+
+    // clear
+    erase :: () -> i32 ---
+    werase :: (w: WINDOW) -> i32 ---
+    clear :: () -> i32 ---
+    wclear :: (w: WINDOW) -> i32 ---
+    clrtobot :: () -> i32 ---
+    wclrtobot :: (w: WINDOW) -> i32 ---
+    clrtoeol :: () -> i32 ---
+    wclrtoeol :: (w: WINDOW) -> i32 ---
+
+    // opaque
+    is_cleared :: (w: WINDOW) -> bool ---
+    is_idcok :: (w: WINDOW) -> bool ---
+    is_idlok :: (w: WINDOW) -> bool ---
+    is_immedok :: (w: WINDOW) -> bool ---
+    is_keypad :: (w: WINDOW) -> bool ---
+    is_leaveok :: (w: WINDOW) -> bool ---
+    is_nodelay :: (w: WINDOW) -> bool ---
+    is_notimeout :: (w: WINDOW) -> bool ---
+    is_pad :: (w: WINDOW) -> bool ---
+    is_scrollok :: (w: WINDOW) -> bool ---
+    is_subwin :: (w: WINDOW) -> bool ---
+    is_syncok :: (w: WINDOW) -> bool ---
+    wgetparent :: (w: WINDOW) -> WINDOW ---
+    wgetdelay  :: (w: WINDOW) -> i32 ---
+    @TODO // Why doesn't this one work?
+    // wgetscrreg :: (w: WINDOW, top, bottom: ^i32) -> void ---
+
+    // window
+    newwin :: (nlines, ncols, y, x: i32) -> WINDOW ---
+    delwin :: (w: WINDOW) -> i32 ---
+    mvwin  :: (w: WINDOW, y, x: i32) -> i32 ---
+    subwin :: (w: WINDOW, nlines, ncols, y, x: i32) -> WINDOW ---
+    derwin :: (w: WINDOW, nlines, ncols, y, x: i32) -> WINDOW ---
+    mvderwin :: (w: WINDOW, parent_y, parent_x: i32) -> i32 ---
+    dupwin :: (w: WINDOW) -> WINDOW ---
+    wsyncup :: (w: WINDOW) -> void ---
+    syncok :: (w: WINDOW, bf: bool) -> i32 ---
+    wcursyncup :: (w: WINDOW) -> void ---
+    wsyncdown :: (w: WINDOW) -> void ---
+
+    // touch
+    touchline :: (w: WINDOW, start, count: i32) -> i32 ---
+    touchwin  :: (w: WINDOW) -> i32 ---
+    wtouchln  :: (w: WINDOW, y, b, changed: i32) -> i32 ---
+    untouchwin :: (w: WINDOW) -> i32 ---
+    is_linetouched :: (w: WINDOW, line: i32) -> bool ---
+    is_wintouched :: (w: WINDOW) -> bool ---
+
+    // bkgd
+    bkgdset :: (ch: chtype) -> void ---
+    wbkgdset :: (w: WINDOW, ch: chtype) -> void ---
+    bkgd :: (bh: chtype) -> i32 ---
+    wbkgd :: (w: WINDOW, ch: chtype) -> i32 ---
+    getbkgd :: (w: WINDOW) -> chtype ---
+
+    // inch
+    inch :: () -> chtype ---
+    winch :: (w: WINDOW) -> chtype ---
+    mvinch :: (y, x: i32) -> chtype ---
+    mvwinch :: (w: WINDOW, y, x: i32) -> chtype ---
+
+    // getch
+    getch :: () -> i32 ---
+    wgetch :: (w: WINDOW) -> i32 ---
+    mvgetch :: (y, x: i32) -> i32 ---
+    mvwgetch :: (y, x: i32, w: WINDOW) -> i32 ---
+    ungetch :: (ch: i32) -> i32 ---
+    has_key :: (ch: i32) -> i32 ---
+
+    // getyx
+    __get_yx     :: (w: WINDOW, y, x: ^i32) -> void ---
+    __get_par_yx :: (w: WINDOW, y, x: ^i32) -> void --- 
+    __get_beg_yx :: (w: WINDOW, y, x: ^i32) -> void --- 
+    __get_max_yx :: (w: WINDOW, y, x: ^i32) -> void --- 
+
+    // getstr
+    // The API for these is horrible for use in Onyx.
+    // Use ogetstr and family for a better API.
+    getstr   :: (s: cstr) -> i32 ---  // Wildly unsafe!
+    getnstr  :: (s: str) -> i32 ---
+    wgetstr  :: (w: WINDOW, s: cstr) -> i32 ---
+    wgetnstr :: (w: WINDOW, s: str) -> i32 ---
+    mvgetstr   :: (y, x: i32, s: cstr) -> i32 ---  // Wildly unsafe!
+    mvgetnstr  :: (y, x: i32, s: str) -> i32 ---
+    mvwgetstr  :: (w: WINDOW, y, x: i32, s: cstr) -> i32 ---
+    mvwgetnstr :: (w: WINDOW, y, x: i32, s: str) -> i32 ---
+
+    // border
+    border :: (ls, rs, ts, bs, tl, tr, bl, br: chtype) -> i32 ---
+    wborder :: (w: WINDOW, ls, rs, ts, bs, tl, tr, bl, br: chtype) -> i32 ---
+    box :: (w: WINDOW, verch, horch: chtype) -> i32 ---
+    hline  :: (ch: chtype, n: i32) -> i32 ---
+    whline :: (w: WINDOW, ch: chtype, n: i32) -> i32 ---
+    vline  :: (ch: chtype, n: i32) -> i32 ---
+    wvline :: (w: WINDOW, ch: chtype, n: i32) -> i32 ---
+    mvhline  :: (y, x: i32, ch: chtype, n: i32) -> i32 ---
+    mvwhline :: (w: WINDOW, y, x: i32, ch: chtype, n: i32) -> i32 ---
+    mvvline  :: (y, x: i32, ch: chtype, n: i32) -> i32 ---
+    mvwvline :: (w: WINDOW, y, x: i32, ch: chtype, n: i32) -> i32 ---
+
+
+    // variables
+    __get_stdscr :: () -> WINDOW ---
+    NCURSES_ACS  :: (a: i32) -> chtype ---
+}
+
+stdscr    :: __get_stdscr
+getyx     :: __get_yx
+getparyx  :: __get_par_yx
+getbegyx  :: __get_beg_yx
+getmaxyx  :: __get_max_yx
+
+ogetstr :: ($max_length: i32) -> str {
+    buf: [max_length] u8;
+    err := getnstr(buf);
+    return string.alloc_copy(string.from_cstr(~~ buf));
+}
+
+printw :: (fmt: str, args: ..any) {
+    buf: [1024] u8;
+    to_output := conv.format_va(buf, fmt, args);
+    addnstr(to_output);
+}
+
+wprintw :: (w: WINDOW, fmt: str, args: ..any) {
+    buf: [1024] u8;
+    to_output := conv.format_va(buf, fmt, args);
+    waddnstr(w, to_output);
+}
+
+mvprintw :: (y, x: i32, fmt: str, args: ..any) {
+    buf: [1024] u8;
+    to_output := conv.format_va(buf, fmt, args);
+    mvaddnstr(y, x, to_output);
+}
+
+mvwprintw :: (w: WINDOW, y, x: i32, fmt: str, args: ..any) {
+    buf: [1024] u8;
+    to_output := conv.format_va(buf, fmt, args);
+    mvwaddnstr(w, y, x, to_output);
+}
+
+
+COLOR_BLACK	:: 0
+COLOR_RED	:: 1
+COLOR_GREEN	:: 2
+COLOR_YELLOW :: 3
+COLOR_BLUE :: 4
+COLOR_MAGENTA :: 5
+COLOR_CYAN :: 6
+COLOR_WHITE :: 7
+
diff --git a/modules/ncurses/ncurses.c b/modules/ncurses/ncurses.c
new file mode 100644
index 00000000..cb880b1c
--- /dev/null
+++ b/modules/ncurses/ncurses.c
@@ -0,0 +1,1190 @@
+
+#include "ncurses.h"
+
+WINDOW *__get_stdscr() {
+    return stdscr;
+}
+
+void __get_yx    (WINDOW *w, int *y, int *x) { getyx(w, *y, *x); }
+void __get_par_yx(WINDOW *w, int *y, int *x) { getparyx(w, *y, *x); }
+void __get_beg_yx(WINDOW *w, int *y, int *x) { getbegyx(w, *y, *x); }
+void __get_max_yx(WINDOW *w, int *y, int *x) { getmaxyx(w, *y, *x); }
+
+chtype __ACS_LOOKUP(int a) { return NCURSES_ACS(a); }
+
+
+
+#define ONYX_LIBRARY_NAME onyx_ncurses
+#include "onyx_library.h"
+
+#define P(i, k) (params->data[i].of.k)
+
+ONYX_DEF(initscr, (), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(initscr());
+    return NULL;
+}
+
+ONYX_DEF(endwin, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(endwin());
+    return NULL;
+}
+
+ONYX_DEF(isendwin, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(isendwin());
+    return NULL;
+}
+
+ONYX_DEF(newterm, (WASM_I32, WASM_I32, WASM_I32), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(newterm(ONYX_PTR(P(0, i32)), ONYX_PTR(P(1, i32)), ONYX_PTR(P(2, i32))));
+    return NULL;
+}
+
+ONYX_DEF(set_term, (WASM_I64), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(set_term(P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(delscreen, (WASM_I64), ()) {
+    delscreen(P(0, i64));
+    return NULL;
+}
+
+ONYX_DEF(start_color, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(start_color());
+    return NULL;
+}
+
+ONYX_DEF(has_colors, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(has_colors());
+    return NULL;
+}
+
+ONYX_DEF(can_change_color, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(can_change_color());
+    return NULL;
+}
+
+ONYX_DEF(init_pair, (WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(init_pair(P(0, i32), P(1, i32), P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(init_color, (WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(init_color(P(0, i32), P(1, i32), P(2, i32), P(3, i32)));
+    return NULL;
+}
+
+ONYX_DEF(color_content, (WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(color_content(P(0, i32), ONYX_PTR(P(1, i32)), ONYX_PTR(P(2, i32)), ONYX_PTR(P(3, i32))));
+    return NULL;
+}
+
+ONYX_DEF(pair_content, (WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(pair_content(P(0, i32), ONYX_PTR(P(1, i32)), ONYX_PTR(P(2, i32))));
+    return NULL;
+}
+
+ONYX_DEF(reset_color_pairs, (), ()) {
+    reset_color_pairs();
+    return NULL;
+}
+
+ONYX_DEF(COLOR_PAIR, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(COLOR_PAIR(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(PAIR_NUMBER, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(PAIR_NUMBER(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(cbreak, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(cbreak());
+    return NULL;
+}
+
+ONYX_DEF(nocbreak, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(nocbreak());
+    return NULL;
+}
+
+ONYX_DEF(echo, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(echo());
+    return NULL;
+}
+
+ONYX_DEF(noecho, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(noecho());
+    return NULL;
+}
+
+ONYX_DEF(intrflush, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(intrflush((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(keypad, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(keypad((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(meta, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(meta((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(nodelay, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(nodelay((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(notimeout, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(notimeout((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(nl, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(nl());
+    return NULL;
+}
+
+ONYX_DEF(nonl, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(nonl());
+    return NULL;
+}
+
+ONYX_DEF(raw, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(raw());
+    return NULL;
+}
+
+ONYX_DEF(noraw, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(noraw());
+    return NULL;
+}
+
+ONYX_DEF(qiflush, (), ()) {
+    qiflush();
+    return NULL;
+}
+
+ONYX_DEF(noqiflush, (), ()) {
+    noqiflush();
+    return NULL;
+}
+
+ONYX_DEF(halfdelay, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(halfdelay(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(timeout, (WASM_I32), ()) {
+    timeout(P(0, i32));
+    return NULL;
+}
+
+ONYX_DEF(wtimeout, (WASM_I64, WASM_I32), ()) {
+    wtimeout((WINDOW *) P(0, i64), P(1, i32));
+    return NULL;
+}
+
+ONYX_DEF(typeahead, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(typeahead(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(clearkok, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(clearkok((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(idlok, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(idlok((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(idcok, (WASM_I64, WASM_I32), ()) {
+    idcok((WINDOW *) P(0, i64), P(1, i32));
+    return NULL;
+}
+
+ONYX_DEF(immedok, (WASM_I64, WASM_I32), ()) {
+    immedok((WINDOW *) P(0, i64), P(1, i32));
+    return NULL;
+}
+
+ONYX_DEF(leaveok, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(leaveok((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(scrollok, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(scrollok((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(setscrreg, (WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(setscrreg(P(0, i32), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(wsetscrreg, (WASM_I64, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wsetscrreg((WINDOW *) P(0, i64), P(1, i32), P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(attr_get, (WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(attr_get(ONYX_PTR(P(0, i32)), ONYX_PTR(P(1, i32)), ONYX_PTR(P(2, i32))));
+    return NULL;
+}
+
+ONYX_DEF(wattr_get, (WASM_I64, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wattr_get((WINDOW *) P(0, i64), ONYX_PTR(P(1, i32)), ONYX_PTR(P(2, i32)), ONYX_PTR(P(3, i32))));
+    return NULL;
+}
+
+ONYX_DEF(attr_set, (WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(attr_set(ONYX_PTR(P(0, i32)), P(1, i32), ONYX_PTR(P(2, i32))));
+    return NULL;
+}
+
+ONYX_DEF(wattr_set, (WASM_I64, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wattr_set((WINDOW *) P(0, i64), P(1, i32), P(2, i32), ONYX_PTR(P(3, i32))));
+    return NULL;
+}
+
+ONYX_DEF(attr_off, (WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(attr_off(P(0, i32), ONYX_PTR(P(1, i32))));
+    return NULL;
+}
+
+ONYX_DEF(wattr_off, (WASM_I64, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wattr_off((WINDOW *) P(0, i64), P(1, i32), ONYX_PTR(P(2, i32))));
+    return NULL;
+}
+
+ONYX_DEF(attr_on, (WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(attr_on(P(0, i32), ONYX_PTR(P(1, i32))));
+    return NULL;
+}
+
+ONYX_DEF(wattr_on, (WASM_I64, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wattr_on((WINDOW *) P(0, i64), P(1, i32), ONYX_PTR(P(2, i32))));
+    return NULL;
+}
+
+ONYX_DEF(attroff, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(attroff(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(wattroff, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wattroff((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(attron, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(attron(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(wattron, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wattron((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(attrset, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(attrset(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(wattrset, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wattrset((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(chgat, (WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(chgat(P(0, i32), P(1, i32), P(2, i32), ONYX_PTR(P(3, i32))));
+    return NULL;
+}
+
+ONYX_DEF(wchgat, (WASM_I64, WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wchgat((WINDOW *) P(0, i64), P(1, i32), P(2, i32), P(3, i32), ONYX_PTR(P(4, i32))));
+    return NULL;
+}
+
+ONYX_DEF(mvchgat, (WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvchgat(P(0, i32), P(1, i32), P(2, i32), P(3, i32), P(4, i32), ONYX_PTR(P(5, i32))));
+    return NULL;
+}
+
+ONYX_DEF(mvmchgat, (WASM_I64, WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvmchgat((WINDOW *) P(0, i64), P(1, i32), P(2, i32), P(3, i32), P(4, i32), P(5, i32), ONYX_PTR(P(6, i32))));
+    return NULL;
+}
+
+ONYX_DEF(color_set, (WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(color_set(P(0, i32), ONYX_PTR(P(1, i32))));
+    return NULL;
+}
+
+ONYX_DEF(wcolor_set, (WASM_I64, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wcolor_set((WINDOW *) P(0, i64), P(1, i32), ONYX_PTR(P(2, i32))));
+    return NULL;
+}
+
+ONYX_DEF(standend, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(standend());
+    return NULL;
+}
+
+ONYX_DEF(wstandend, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wstandend((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(standout, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(standout());
+    return NULL;
+}
+
+ONYX_DEF(wstandout, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wstandout((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(unctrl, (WASM_I32), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(unctrl(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(keyname, (WASM_I32), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(keyname(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(key_name, (WASM_I32), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(key_name(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(filter, (), ()) {
+    filter();
+    return NULL;
+}
+
+ONYX_DEF(nofilter, (), ()) {
+    nofilter();
+    return NULL;
+}
+
+ONYX_DEF(use_env, (WASM_I32), ()) {
+    use_env(P(0, i32));
+    return NULL;
+}
+
+ONYX_DEF(use_tioctl, (WASM_I32), ()) {
+    use_tioctl(P(0, i32));
+    return NULL;
+}
+
+ONYX_DEF(getwin, (WASM_I32), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(getwin(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(delay_output, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(delay_output(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(flushinp, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(flushinp());
+    return NULL;
+}
+
+ONYX_DEF(def_prog_mode, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(def_prog_mode());
+    return NULL;
+}
+
+ONYX_DEF(def_shell_mode, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(def_shell_mode());
+    return NULL;
+}
+
+ONYX_DEF(reset_prog_mode, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(reset_prog_mode());
+    return NULL;
+}
+
+ONYX_DEF(reset_shell_mode, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(reset_shell_mode());
+    return NULL;
+}
+
+ONYX_DEF(resetty, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(resetty());
+    return NULL;
+}
+
+ONYX_DEF(savetty, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(savetty());
+    return NULL;
+}
+
+ONYX_DEF(getsyx, (WASM_I32, WASM_I32), ()) {
+    getsyx(P(0, i32), P(1, i32));
+    return NULL;
+}
+
+ONYX_DEF(setsyx, (WASM_I32, WASM_I32), ()) {
+    setsyx(P(0, i32), P(1, i32));
+    return NULL;
+}
+
+ONYX_DEF(curs_set, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(curs_set(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(napms, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(napms(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(refresh, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(refresh());
+    return NULL;
+}
+
+ONYX_DEF(wrefresh, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wrefresh((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(wnoutrefresh, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wnoutrefresh((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(doupdate, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(doupdate());
+    return NULL;
+}
+
+ONYX_DEF(redrawwin, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(redrawwin((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(wredrawln, (WASM_I64, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wredrawln((WINDOW *) P(0, i64), P(1, i32), P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(addch, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(addch(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(waddch, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(waddch((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(mvaddch, (WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvaddch(P(0, i32), P(1, i32), P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(mvwaddch, (WASM_I64, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvwaddch((WINDOW *) P(0, i64), P(1, i32), P(2, i32), P(3, i32)));
+    return NULL;
+}
+
+ONYX_DEF(echochar, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(echochar(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(wechochar, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wechochar((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(addchstr, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(addchstr(ONYX_PTR(P(0, i32))));
+    return NULL;
+}
+
+ONYX_DEF(addchnstr, (WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(addchnstr(ONYX_PTR(P(0, i32)), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(waddchstr, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(waddchstr((WINDOW *) P(0, i64), ONYX_PTR(P(1, i32))));
+    return NULL;
+}
+
+ONYX_DEF(waddchnstr, (WASM_I64, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(waddchnstr((WINDOW *) P(0, i64), ONYX_PTR(P(1, i32)), P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(mvaddchstr, (WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvaddchstr(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))));
+    return NULL;
+}
+
+ONYX_DEF(mvaddchnstr, (WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvaddchnstr(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)), P(3, i32)));
+    return NULL;
+}
+
+ONYX_DEF(mvwaddchstr, (WASM_I64, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvwaddchstr((WINDOW *) P(0, i64), P(1, i32), P(2, i32), ONYX_PTR(P(3, i32))));
+    return NULL;
+}
+
+ONYX_DEF(mvwaddchnstr, (WASM_I64, WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvwaddchnstr((WINDOW *) P(0, i64), P(1, i32), P(2, i32), ONYX_PTR(P(3, i32)), P(4, i32)));
+    return NULL;
+}
+
+ONYX_DEF(addstr, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(addstr(ONYX_PTR(P(0, i32))));
+    return NULL;
+}
+
+ONYX_DEF(addnstr, (WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(addnstr(ONYX_PTR(P(0, i32)), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(waddstr, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(waddstr((WINDOW *) P(0, i64), ONYX_PTR(P(1, i32))));
+    return NULL;
+}
+
+ONYX_DEF(waddnstr, (WASM_I64, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(waddnstr((WINDOW *) P(0, i64), ONYX_PTR(P(1, i32)), P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(mvaddstr, (WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvaddstr(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))));
+    return NULL;
+}
+
+ONYX_DEF(mvaddnstr, (WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvaddnstr(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)), P(3, i32)));
+    return NULL;
+}
+
+ONYX_DEF(mvwaddstr, (WASM_I64, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvwaddstr((WINDOW *) P(0, i64), P(1, i32), P(2, i32), ONYX_PTR(P(3, i32))));
+    return NULL;
+}
+
+ONYX_DEF(mvwaddnstr, (WASM_I64, WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvwaddnstr((WINDOW *) P(0, i64), P(1, i32), P(2, i32), ONYX_PTR(P(3, i32)), P(4, i32)));
+    return NULL;
+}
+
+ONYX_DEF(erase, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(erase());
+    return NULL;
+}
+
+ONYX_DEF(werase, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(werase((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(clear, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(clear());
+    return NULL;
+}
+
+ONYX_DEF(wclear, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wclear((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(clrtobot, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(clrtobot());
+    return NULL;
+}
+
+ONYX_DEF(wclrtobot, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wclrtobot((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(clrtoeol, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(clrtoeol());
+    return NULL;
+}
+
+ONYX_DEF(wclrtoeol, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wclrtoeol((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(is_cleared, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(is_cleared((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(is_idcok, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(is_idcok((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(is_idlok, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(is_idlok((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(is_immedok, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(is_immedok((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(is_keypad, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(is_keypad((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(is_leaveok, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(is_leaveok((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(is_nodelay, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(is_nodelay((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(is_notimeout, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(is_notimeout((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(is_pad, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(is_pad((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(is_scrollok, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(is_scrollok((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(is_subwin, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(is_subwin((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(is_syncok, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(is_syncok((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(wgetparent, (WASM_I64), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(wgetparent((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(wgetdelay, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wgetdelay((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(newwin, (WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(newwin(P(0, i32), P(1, i32), P(2, i32), P(3, i32)));
+    return NULL;
+}
+
+ONYX_DEF(delwin, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(delwin((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(mvwin, (WASM_I64, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvwin((WINDOW *) P(0, i64), P(1, i32), P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(subwin, (WASM_I64, WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(subwin((WINDOW *) P(0, i64), P(1, i32), P(2, i32), P(3, i32), P(4, i32)));
+    return NULL;
+}
+
+ONYX_DEF(derwin, (WASM_I64, WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(derwin((WINDOW *) P(0, i64), P(1, i32), P(2, i32), P(3, i32), P(4, i32)));
+    return NULL;
+}
+
+ONYX_DEF(mvderwin, (WASM_I64, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvderwin((WINDOW *) P(0, i64), P(1, i32), P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(dupwin, (WASM_I64), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(dupwin((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(wsyncup, (WASM_I64), ()) {
+    wsyncup((WINDOW *) P(0, i64));
+    return NULL;
+}
+
+ONYX_DEF(syncok, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(syncok((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(wcursyncup, (WASM_I64), ()) {
+    wcursyncup((WINDOW *) P(0, i64));
+    return NULL;
+}
+
+ONYX_DEF(wsyncdown, (WASM_I64), ()) {
+    wsyncdown((WINDOW *) P(0, i64));
+    return NULL;
+}
+
+ONYX_DEF(touchline, (WASM_I64, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(touchline((WINDOW *) P(0, i64), P(1, i32), P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(touchwin, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(touchwin((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(wtouchln, (WASM_I64, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wtouchln((WINDOW *) P(0, i64), P(1, i32), P(2, i32), P(3, i32)));
+    return NULL;
+}
+
+ONYX_DEF(untouchwin, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(untouchwin((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(is_linetouched, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(is_linetouched((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(is_wintouched, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(is_wintouched((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(bkgdset, (WASM_I32), ()) {
+    bkgdset(P(0, i32));
+    return NULL;
+}
+
+ONYX_DEF(wbkgdset, (WASM_I64, WASM_I32), ()) {
+    wbkgdset((WINDOW *) P(0, i64), P(1, i32));
+    return NULL;
+}
+
+ONYX_DEF(bkgd, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(bkgd(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(wbkgd, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wbkgd((WINDOW *) P(0, i64), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(getbkgd, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(getbkgd((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(inch, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(inch());
+    return NULL;
+}
+
+ONYX_DEF(winch, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(winch((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(mvinch, (WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvinch(P(0, i32), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(mvwinch, (WASM_I64, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvwinch((WINDOW *) P(0, i64), P(1, i32), P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(getch, (), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(getch());
+    return NULL;
+}
+
+ONYX_DEF(wgetch, (WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wgetch((WINDOW *) P(0, i64)));
+    return NULL;
+}
+
+ONYX_DEF(mvgetch, (WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvgetch(P(0, i32), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(mvwgetch, (WASM_I32, WASM_I32, WASM_I64), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvwgetch(P(0, i32), P(1, i32), (WINDOW *) P(2, i64)));
+    return NULL;
+}
+
+ONYX_DEF(ungetch, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(ungetch(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(has_key, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(has_key(P(0, i32)));
+    return NULL;
+}
+
+ONYX_DEF(__get_yx, (WASM_I64, WASM_I32, WASM_I32), ()) {
+    __get_yx((WINDOW *) P(0, i64), ONYX_PTR(P(1, i32)), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(__get_par_yx, (WASM_I64, WASM_I32, WASM_I32), ()) {
+    __get_par_yx((WINDOW *) P(0, i64), ONYX_PTR(P(1, i32)), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(__get_beg_yx, (WASM_I64, WASM_I32, WASM_I32), ()) {
+    __get_beg_yx((WINDOW *) P(0, i64), ONYX_PTR(P(1, i32)), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(__get_max_yx, (WASM_I64, WASM_I32, WASM_I32), ()) {
+    __get_max_yx((WINDOW *) P(0, i64), ONYX_PTR(P(1, i32)), ONYX_PTR(P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(getstr, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(getstr(ONYX_PTR(P(0, i32))));
+    return NULL;
+}
+
+ONYX_DEF(getnstr, (WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(getnstr(ONYX_PTR(P(0, i32)), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(wgetstr, (WASM_I64, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wgetstr((WINDOW *) P(0, i64), ONYX_PTR(P(1, i32))));
+    return NULL;
+}
+
+ONYX_DEF(wgetnstr, (WASM_I64, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wgetnstr((WINDOW *) P(0, i64), ONYX_PTR(P(1, i32)), P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(mvgetstr, (WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvgetstr(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32))));
+    return NULL;
+}
+
+ONYX_DEF(mvgetnstr, (WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvgetnstr(P(0, i32), P(1, i32), ONYX_PTR(P(2, i32)), P(3, i32)));
+    return NULL;
+}
+
+ONYX_DEF(mvwgetstr, (WASM_I64, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvwgetstr((WINDOW *) P(0, i64), P(1, i32), P(2, i32), ONYX_PTR(P(3, i32))));
+    return NULL;
+}
+
+ONYX_DEF(mvwgetnstr, (WASM_I64, WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvwgetnstr((WINDOW *) P(0, i64), P(1, i32), P(2, i32), ONYX_PTR(P(3, i32)), P(4, i32)));
+    return NULL;
+}
+
+ONYX_DEF(border, (WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(border(P(0, i32), P(1, i32), P(2, i32), P(3, i32), P(4, i32), P(5, i32), P(6, i32), P(7, i32)));
+    return NULL;
+}
+
+ONYX_DEF(wborder, (WASM_I64, WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wborder((WINDOW *) P(0, i64), P(1, i32), P(2, i32), P(3, i32), P(4, i32), P(5, i32), P(6, i32), P(7, i32), P(8, i32)));
+    return NULL;
+}
+
+ONYX_DEF(box, (WASM_I64, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(box((WINDOW *) P(0, i64), P(1, i32), P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(hline, (WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(hline(P(0, i32), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(whline, (WASM_I64, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(whline((WINDOW *) P(0, i64), P(1, i32), P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(vline, (WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(vline(P(0, i32), P(1, i32)));
+    return NULL;
+}
+
+ONYX_DEF(wvline, (WASM_I64, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(wvline((WINDOW *) P(0, i64), P(1, i32), P(2, i32)));
+    return NULL;
+}
+
+ONYX_DEF(mvhline, (WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvhline(P(0, i32), P(1, i32), P(2, i32), P(3, i32)));
+    return NULL;
+}
+
+ONYX_DEF(mvwhline, (WASM_I64, WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvwhline((WINDOW *) P(0, i64), P(1, i32), P(2, i32), P(3, i32), P(4, i32)));
+    return NULL;
+}
+
+ONYX_DEF(mvvline, (WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvvline(P(0, i32), P(1, i32), P(2, i32), P(3, i32)));
+    return NULL;
+}
+
+ONYX_DEF(mvwvline, (WASM_I64, WASM_I32, WASM_I32, WASM_I32, WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(mvwvline((WINDOW *) P(0, i64), P(1, i32), P(2, i32), P(3, i32), P(4, i32)));
+    return NULL;
+}
+
+ONYX_DEF(__get_stdscr, (), (WASM_I64)) {
+    results->data[0] = WASM_I64_VAL(__get_stdscr());
+    return NULL;
+}
+
+ONYX_DEF(NCURSES_ACS, (WASM_I32), (WASM_I32)) {
+    results->data[0] = WASM_I32_VAL(NCURSES_ACS(P(0, i32)));
+    return NULL;
+}
+
+
+
+ONYX_LIBRARY {
+    ONYX_FUNC(initscr)
+    ONYX_FUNC(endwin)
+    ONYX_FUNC(isendwin)
+    ONYX_FUNC(newterm)
+    ONYX_FUNC(set_term)
+    ONYX_FUNC(delscreen)
+    ONYX_FUNC(start_color)
+    ONYX_FUNC(has_colors)
+    ONYX_FUNC(can_change_color)
+    ONYX_FUNC(init_pair)
+    ONYX_FUNC(init_color)
+    ONYX_FUNC(color_content)
+    ONYX_FUNC(pair_content)
+    ONYX_FUNC(reset_color_pairs)
+    ONYX_FUNC(COLOR_PAIR)
+    ONYX_FUNC(PAIR_NUMBER)
+    ONYX_FUNC(cbreak)
+    ONYX_FUNC(nocbreak)
+    ONYX_FUNC(echo)
+    ONYX_FUNC(noecho)
+    ONYX_FUNC(intrflush)
+    ONYX_FUNC(keypad)
+    ONYX_FUNC(meta)
+    ONYX_FUNC(nodelay)
+    ONYX_FUNC(notimeout)
+    ONYX_FUNC(nl)
+    ONYX_FUNC(nonl)
+    ONYX_FUNC(raw)
+    ONYX_FUNC(noraw)
+    ONYX_FUNC(qiflush)
+    ONYX_FUNC(noqiflush)
+    ONYX_FUNC(halfdelay)
+    ONYX_FUNC(timeout)
+    ONYX_FUNC(wtimeout)
+    ONYX_FUNC(typeahead)
+    ONYX_FUNC(clearkok)
+    ONYX_FUNC(idlok)
+    ONYX_FUNC(idcok)
+    ONYX_FUNC(immedok)
+    ONYX_FUNC(leaveok)
+    ONYX_FUNC(scrollok)
+    ONYX_FUNC(setscrreg)
+    ONYX_FUNC(wsetscrreg)
+    ONYX_FUNC(attr_get)
+    ONYX_FUNC(wattr_get)
+    ONYX_FUNC(attr_set)
+    ONYX_FUNC(wattr_set)
+    ONYX_FUNC(attr_off)
+    ONYX_FUNC(wattr_off)
+    ONYX_FUNC(attr_on)
+    ONYX_FUNC(wattr_on)
+    ONYX_FUNC(attroff)
+    ONYX_FUNC(wattroff)
+    ONYX_FUNC(attron)
+    ONYX_FUNC(wattron)
+    ONYX_FUNC(attrset)
+    ONYX_FUNC(wattrset)
+    ONYX_FUNC(chgat)
+    ONYX_FUNC(wchgat)
+    ONYX_FUNC(mvchgat)
+    ONYX_FUNC(mvmchgat)
+    ONYX_FUNC(color_set)
+    ONYX_FUNC(wcolor_set)
+    ONYX_FUNC(standend)
+    ONYX_FUNC(wstandend)
+    ONYX_FUNC(standout)
+    ONYX_FUNC(wstandout)
+    ONYX_FUNC(unctrl)
+    ONYX_FUNC(keyname)
+    ONYX_FUNC(key_name)
+    ONYX_FUNC(filter)
+    ONYX_FUNC(nofilter)
+    ONYX_FUNC(use_env)
+    ONYX_FUNC(use_tioctl)
+    ONYX_FUNC(getwin)
+    ONYX_FUNC(delay_output)
+    ONYX_FUNC(flushinp)
+    ONYX_FUNC(def_prog_mode)
+    ONYX_FUNC(def_shell_mode)
+    ONYX_FUNC(reset_prog_mode)
+    ONYX_FUNC(reset_shell_mode)
+    ONYX_FUNC(resetty)
+    ONYX_FUNC(savetty)
+    ONYX_FUNC(getsyx)
+    ONYX_FUNC(setsyx)
+    ONYX_FUNC(curs_set)
+    ONYX_FUNC(napms)
+    ONYX_FUNC(refresh)
+    ONYX_FUNC(wrefresh)
+    ONYX_FUNC(wnoutrefresh)
+    ONYX_FUNC(doupdate)
+    ONYX_FUNC(redrawwin)
+    ONYX_FUNC(wredrawln)
+    ONYX_FUNC(addch)
+    ONYX_FUNC(waddch)
+    ONYX_FUNC(mvaddch)
+    ONYX_FUNC(mvwaddch)
+    ONYX_FUNC(echochar)
+    ONYX_FUNC(wechochar)
+    ONYX_FUNC(addchstr)
+    ONYX_FUNC(addchnstr)
+    ONYX_FUNC(waddchstr)
+    ONYX_FUNC(waddchnstr)
+    ONYX_FUNC(mvaddchstr)
+    ONYX_FUNC(mvaddchnstr)
+    ONYX_FUNC(mvwaddchstr)
+    ONYX_FUNC(mvwaddchnstr)
+    ONYX_FUNC(addstr)
+    ONYX_FUNC(addnstr)
+    ONYX_FUNC(waddstr)
+    ONYX_FUNC(waddnstr)
+    ONYX_FUNC(mvaddstr)
+    ONYX_FUNC(mvaddnstr)
+    ONYX_FUNC(mvwaddstr)
+    ONYX_FUNC(mvwaddnstr)
+    ONYX_FUNC(erase)
+    ONYX_FUNC(werase)
+    ONYX_FUNC(clear)
+    ONYX_FUNC(wclear)
+    ONYX_FUNC(clrtobot)
+    ONYX_FUNC(wclrtobot)
+    ONYX_FUNC(clrtoeol)
+    ONYX_FUNC(wclrtoeol)
+    ONYX_FUNC(is_cleared)
+    ONYX_FUNC(is_idcok)
+    ONYX_FUNC(is_idlok)
+    ONYX_FUNC(is_immedok)
+    ONYX_FUNC(is_keypad)
+    ONYX_FUNC(is_leaveok)
+    ONYX_FUNC(is_nodelay)
+    ONYX_FUNC(is_notimeout)
+    ONYX_FUNC(is_pad)
+    ONYX_FUNC(is_scrollok)
+    ONYX_FUNC(is_subwin)
+    ONYX_FUNC(is_syncok)
+    ONYX_FUNC(wgetparent)
+    ONYX_FUNC(wgetdelay)
+    ONYX_FUNC(newwin)
+    ONYX_FUNC(delwin)
+    ONYX_FUNC(mvwin)
+    ONYX_FUNC(subwin)
+    ONYX_FUNC(derwin)
+    ONYX_FUNC(mvderwin)
+    ONYX_FUNC(dupwin)
+    ONYX_FUNC(wsyncup)
+    ONYX_FUNC(syncok)
+    ONYX_FUNC(wcursyncup)
+    ONYX_FUNC(wsyncdown)
+    ONYX_FUNC(touchline)
+    ONYX_FUNC(touchwin)
+    ONYX_FUNC(wtouchln)
+    ONYX_FUNC(untouchwin)
+    ONYX_FUNC(is_linetouched)
+    ONYX_FUNC(is_wintouched)
+    ONYX_FUNC(bkgdset)
+    ONYX_FUNC(wbkgdset)
+    ONYX_FUNC(bkgd)
+    ONYX_FUNC(wbkgd)
+    ONYX_FUNC(getbkgd)
+    ONYX_FUNC(inch)
+    ONYX_FUNC(winch)
+    ONYX_FUNC(mvinch)
+    ONYX_FUNC(mvwinch)
+    ONYX_FUNC(getch)
+    ONYX_FUNC(wgetch)
+    ONYX_FUNC(mvgetch)
+    ONYX_FUNC(mvwgetch)
+    ONYX_FUNC(ungetch)
+    ONYX_FUNC(has_key)
+    ONYX_FUNC(__get_yx)
+    ONYX_FUNC(__get_par_yx)
+    ONYX_FUNC(__get_beg_yx)
+    ONYX_FUNC(__get_max_yx)
+    ONYX_FUNC(getstr)
+    ONYX_FUNC(getnstr)
+    ONYX_FUNC(wgetstr)
+    ONYX_FUNC(wgetnstr)
+    ONYX_FUNC(mvgetstr)
+    ONYX_FUNC(mvgetnstr)
+    ONYX_FUNC(mvwgetstr)
+    ONYX_FUNC(mvwgetnstr)
+    ONYX_FUNC(border)
+    ONYX_FUNC(wborder)
+    ONYX_FUNC(box)
+    ONYX_FUNC(hline)
+    ONYX_FUNC(whline)
+    ONYX_FUNC(vline)
+    ONYX_FUNC(wvline)
+    ONYX_FUNC(mvhline)
+    ONYX_FUNC(mvwhline)
+    ONYX_FUNC(mvvline)
+    ONYX_FUNC(mvwvline)
+    ONYX_FUNC(__get_stdscr)
+    ONYX_FUNC(NCURSES_ACS)
+    NULL
+};
\ No newline at end of file
diff --git a/modules/ncurses/onyx_ncurses.so b/modules/ncurses/onyx_ncurses.so
new file mode 100755
index 0000000000000000000000000000000000000000..857b36b66b7b39c57f65a1a71d76667f6f88088e
GIT binary patch
literal 158240
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

literal 0
HcmV?d00001

diff --git a/scripts/c_binding.onyx b/scripts/c_binding.onyx
new file mode 100644
index 00000000..b4249abe
--- /dev/null
+++ b/scripts/c_binding.onyx
@@ -0,0 +1,193 @@
+#load "core/std"
+
+use package core
+use package simd
+
+CBindings :: (package ncurses).CBindings
+
+#if !#defined(CBindings) {
+    #error "Expected to find CBindings structure";
+}
+
+
+
+main :: (args: [] cstr) {
+    println(CBindings.file_prefix);
+
+    printf("""
+#define ONYX_LIBRARY_NAME {}
+#include "onyx_library.h"
+
+#define P(i, k) (params->data[i].of.k)
+
+""", CBindings.name);
+
+    use type_info;
+    bind_info := cast(^Type_Info_Struct) get_type_info(CBindings);
+    for bind_info.methods {
+        method_type := it.func.type;
+        method_info := cast (^Type_Info_Function) get_type_info(method_type);
+        assert(method_info.kind == .Function, "Expected function type.");
+
+        printf("ONYX_DEF({}, (", it.name);
+        i := 0;
+        for method_info.parameter_types {
+            print_type_encoding(it);
+
+            if i != method_info.parameter_types.count - 1 {
+                print(", ");
+            }
+            i += 1;
+        }
+
+        print("), (");
+        print_type_encoding(method_info.return_type);
+        print(")) {\n");
+        print_body(it.name, method_info);
+        print("}\n\n");
+    }
+
+    print("\n\n");
+    print("ONYX_LIBRARY {\n");
+    for bind_info.methods {
+        printf("    ONYX_FUNC({})\n", it.name);
+    }
+    print("    NULL\n");
+    print("};");
+}
+
+print_body :: (method_name, method_info) => {
+    use type_info;
+    call := io.dynamic_string_stream_make();
+    defer io.dynamic_string_stream_free(^call);
+    callw := io.writer_make(^call);
+
+    param_num := 0;
+    for method_info.parameter_types {
+        if get_type_info(it).kind == .Slice {
+            io.write_format(^callw, "ONYX_PTR(P({}, i32)), P({}, i32)", param_num, param_num + 1);
+            param_num += 1;
+
+        } elseif is_pointer(it) {
+            io.write_format(^callw, "ONYX_PTR(P({}, i32))", param_num);
+
+        } else {
+            matched := false;
+            for^ m: CBindings.cast_map {
+                if m.type == it {
+                    io.write_format(^callw, "({}) P({}, {})", m.name, param_num, type_to_wasm_type(it));
+                    matched = true;
+                    break;
+                }
+            }
+            
+            if !matched do io.write_format(^callw, "P({}, {})", param_num, type_to_wasm_type(it));
+        }
+
+        io.write_format(^callw, ", ");
+        param_num += 1;
+    }
+
+    call_str := call->to_str();
+    wasm_return_type := type_to_wasm_type(method_info.return_type);
+    switch wasm_return_type {
+        case ""    do printf("    {}({});\n", method_name, call_str[0..call_str.count-2]);
+        case "i32" do printf("    results->data[0] = WASM_I32_VAL({}({}));\n", method_name, call_str[0..call_str.count-2]);
+        case "i64" do printf("    results->data[0] = WASM_I64_VAL({}({}));\n", method_name, call_str[0..call_str.count-2]);
+        case "f32" do printf("    results->data[0] = WASM_F32_VAL({}({}));\n", method_name, call_str[0..call_str.count-2]);
+        case "f64" do printf("    results->data[0] = WASM_F64_VAL({}({}));\n", method_name, call_str[0..call_str.count-2]);
+    }
+
+    printf("    return NULL;\n");
+}
+
+type_to_wasm_type :: (t: type_expr) -> str {
+    use type_info;
+
+    param_info := get_type_info(t);
+    switch param_info.kind {
+        case .Basic do switch t {
+            case bool do return "i32";
+            case i8   do return "i32";
+            case u8   do return "i32";
+            case i16  do return "i32";
+            case u16  do return "i32";
+            case i32  do return "i32";
+            case u32  do return "i32";
+            case i64  do return "i64";
+            case u64  do return "i64";
+
+            case f32  do return "f32";
+            case f64  do return "f64";
+
+            case rawptr do return "i32"; // This will have to depend on the pointer size...
+            
+            case i8x16, i16x8, i32x4, i64x2, f32x4, f64x2, v128 do return "v128";
+
+            case type_expr do return "i32";
+        }
+
+        case .Pointer do return "i32"; // This will also have to depend on the pointer size...
+        case .Function do assert(false, "Passing functions between wasm and c is not yet supported.");
+        case .Array do return "i32";
+        case .Slice do assert(false, "ASDFASDF");
+        case .Enum do return type_to_wasm_type((cast(^Type_Info_Enum) param_info).backing_type);
+        case .Distinct do return type_to_wasm_type((cast(^Type_Info_Distinct) param_info).base_type);
+
+        case .Struct {
+            s_info := cast(^Type_Info_Struct) param_info;
+            if s_info.members.count == 1 {
+                return type_to_wasm_type(s_info.members[0].type);
+            }
+
+            assert(false, "Passing structures between wasm and c is not yet supported.");
+        }
+    }
+
+    return "";
+}
+
+print_type_encoding :: (t: type_expr) {
+    use type_info;
+
+    param_info := get_type_info(t);
+    switch param_info.kind {
+        case .Basic do switch t {
+            case bool do print("WASM_I32");
+            case i8   do print("WASM_I32");
+            case u8   do print("WASM_I32");
+            case i16  do print("WASM_I32");
+            case u16  do print("WASM_I32");
+            case i32  do print("WASM_I32");
+            case u32  do print("WASM_I32");
+            case i64  do print("WASM_I64");
+            case u64  do print("WASM_I64");
+
+            case f32  do print("WASM_F32");
+            case f64  do print("WASM_F64");
+
+            case rawptr do print("WASM_I32"); // This will have to depend on the pointer size...
+            
+            case i8x16, i16x8, i32x4, i64x2, f32x4, f64x2, v128 do print("WASM_V128");
+
+            case type_expr do print("WASM_I32");
+        }
+
+        case .Pointer do print("WASM_I32"); // This will also have to depend on the pointer size...
+        case .Function do assert(false, "Passing functions between wasm and c is not yet supported.");
+        case .Array do print("WASM_I32");
+        case .Slice do print("WASM_I32, WASM_I32");
+        case .Enum do print_type_encoding((cast(^Type_Info_Enum) param_info).backing_type);
+        case .Distinct do print_type_encoding((cast(^Type_Info_Distinct) param_info).base_type);
+
+        case .Struct {
+            s_info := cast(^Type_Info_Struct) param_info;
+            if s_info.members.count == 1 {
+                print_type_encoding(s_info.members[0].type);
+                return;
+            }
+
+            assert(false, "Passing structures between wasm and c is not yet supported.");
+        }
+    }
+}
-- 
2.25.1