From 36c76090638e80d1cb9ad2dd060aae65976f24c8 Mon Sep 17 00:00:00 2001 From: Steven Barth Date: Sun, 31 Aug 2008 11:14:47 +0000 Subject: [PATCH] Add luacurses to contrib --- contrib/luacurses/Makefile | 8 + contrib/luacurses/src/Makefile | 15 + contrib/luacurses/src/doc/curses.pdf | Bin 0 -> 39485 bytes contrib/luacurses/src/doc/curses.ps.gz | Bin 0 -> 36118 bytes contrib/luacurses/src/src/curses.c | 3630 ++++++++++++++++++++++++++++++++ contrib/luacurses/src/src/luacurses.c | 137 ++ contrib/luacurses/src/src/luacurses.h | 38 + contrib/luacurses/src/test/filter.lua | 49 + contrib/luacurses/src/test/getnstr.lua | 12 + contrib/luacurses/src/test/getyx.lua | 13 + contrib/luacurses/src/test/hello.lua | 20 + contrib/luacurses/src/test/mouse.lua | 54 + contrib/luacurses/src/test/pair.lua | 18 + contrib/luacurses/src/test/rain.lua | 89 + 14 files changed, 4083 insertions(+) create mode 100644 contrib/luacurses/Makefile create mode 100644 contrib/luacurses/src/Makefile create mode 100644 contrib/luacurses/src/doc/curses.pdf create mode 100644 contrib/luacurses/src/doc/curses.ps.gz create mode 100644 contrib/luacurses/src/src/curses.c create mode 100644 contrib/luacurses/src/src/luacurses.c create mode 100644 contrib/luacurses/src/src/luacurses.h create mode 100644 contrib/luacurses/src/test/filter.lua create mode 100644 contrib/luacurses/src/test/getnstr.lua create mode 100644 contrib/luacurses/src/test/getyx.lua create mode 100644 contrib/luacurses/src/test/hello.lua create mode 100644 contrib/luacurses/src/test/mouse.lua create mode 100644 contrib/luacurses/src/test/pair.lua create mode 100644 contrib/luacurses/src/test/rain.lua diff --git a/contrib/luacurses/Makefile b/contrib/luacurses/Makefile new file mode 100644 index 000000000..d044c38fa --- /dev/null +++ b/contrib/luacurses/Makefile @@ -0,0 +1,8 @@ +include ../../build/module.mk +include ../../build/config.mk +include ../../build/gccconfig.mk + +compile: + mkdir -p dist$(LUA_LIBRARYDIR) + $(CC) $(CPPFLAGS) $(CFLAGS) $(EXTRA_CFLAGS) $(SHLIB_FLAGS) -pedantic \ + -Wall $(FPIC) $(LUA_CFLAGS) -o dist$(LUA_LIBRARYDIR)/curses.so src/src/curses.c src/src/luacurses.c diff --git a/contrib/luacurses/src/Makefile b/contrib/luacurses/src/Makefile new file mode 100644 index 000000000..1dd108f49 --- /dev/null +++ b/contrib/luacurses/src/Makefile @@ -0,0 +1,15 @@ + +SRC=src/curses.c src/luacurses.c +INCLUDE=/usr/include/lua5.1 +CFLAGS=-shared -ansi -Wall -O2 -I$(INCLUDE) -fpic + +all: lib/curses.so + +lib/curses.so: $(SRC) + if ! [ -d lib ]; then mkdir lib; fi + gcc $(CFLAGS) -o lib/curses.so $(SRC) + +clean: + rm -Rf lib + + diff --git a/contrib/luacurses/src/doc/curses.pdf b/contrib/luacurses/src/doc/curses.pdf new file mode 100644 index 0000000000000000000000000000000000000000..b4dd7529d3de7cb2e8d60383b45063adb5f67e91 GIT binary patch literal 39485 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 literal 0 HcmV?d00001 diff --git a/contrib/luacurses/src/src/curses.c b/contrib/luacurses/src/src/curses.c new file mode 100644 index 000000000..9e6760a9f --- /dev/null +++ b/contrib/luacurses/src/src/curses.c @@ -0,0 +1,3630 @@ +#include +#include + +#include +#include +#include + +typedef struct mklualib_regnum +{ + const char* name; + lua_Number num; +} mklualib_regnum; + +void mklualib_regstring(lua_State* L, const char* name, const char* s) +{ + lua_pushstring(L, name); + lua_pushstring(L, s); + lua_settable(L, -3); +} + +void mklualib_regchar(lua_State* L, const char* name, char c) +{ + lua_pushstring(L, name); + lua_pushlstring(L, &c, 1); + lua_settable(L, -3); +} + +void mklualib_regnumbers(lua_State* L, const mklualib_regnum* l) +{ + for (; l->name; l++) + { + lua_pushstring(L, l->name); + lua_pushnumber(L, l->num); + lua_settable(L, -3); + } +} + + +#include +#include "luacurses.h" +#define MKLUALIB_MODULE_CURSES "curses" +/* curses.COLORS*/ +int mklualib_curses_COLORS(lua_State* mklualib_lua_state) +{ + int mklualib_curses_COLORS_ret = (int) COLORS; + lua_pushnumber(mklualib_lua_state, mklualib_curses_COLORS_ret); + return 1; +} + +/* curses.COLOR_PAIRS*/ +int mklualib_curses_COLOR_PAIRS(lua_State* mklualib_lua_state) +{ + int mklualib_curses_COLOR_PAIRS_ret = (int) COLOR_PAIRS; + lua_pushnumber(mklualib_lua_state, mklualib_curses_COLOR_PAIRS_ret); + return 1; +} + +/* curses.NCURSES_ACS*/ +int mklualib_curses_NCURSES_ACS(lua_State* mklualib_lua_state) +{ + char c = (char) lua_tostring(mklualib_lua_state, 1)[0]; + int mklualib_curses_NCURSES_ACS_ret = (int) NCURSES_ACS(c); + lua_pushnumber(mklualib_lua_state, mklualib_curses_NCURSES_ACS_ret); + return 1; +} + +/* curses.ACS_ULCORNER*/ +int mklualib_curses_ACS_ULCORNER(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_ULCORNER_ret = (int) ACS_ULCORNER; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_ULCORNER_ret); + return 1; +} + +/* curses.ACS_LLCORNER*/ +int mklualib_curses_ACS_LLCORNER(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_LLCORNER_ret = (int) ACS_LLCORNER; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_LLCORNER_ret); + return 1; +} + +/* curses.ACS_URCORNER*/ +int mklualib_curses_ACS_URCORNER(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_URCORNER_ret = (int) ACS_URCORNER; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_URCORNER_ret); + return 1; +} + +/* curses.ACS_LRCORNER*/ +int mklualib_curses_ACS_LRCORNER(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_LRCORNER_ret = (int) ACS_LRCORNER; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_LRCORNER_ret); + return 1; +} + +/* curses.ACS_LTEE*/ +int mklualib_curses_ACS_LTEE(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_LTEE_ret = (int) ACS_LTEE; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_LTEE_ret); + return 1; +} + +/* curses.ACS_RTEE*/ +int mklualib_curses_ACS_RTEE(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_RTEE_ret = (int) ACS_RTEE; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_RTEE_ret); + return 1; +} + +/* curses.ACS_BTEE*/ +int mklualib_curses_ACS_BTEE(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_BTEE_ret = (int) ACS_BTEE; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_BTEE_ret); + return 1; +} + +/* curses.ACS_TTEE*/ +int mklualib_curses_ACS_TTEE(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_TTEE_ret = (int) ACS_TTEE; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_TTEE_ret); + return 1; +} + +/* curses.ACS_HLINE*/ +int mklualib_curses_ACS_HLINE(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_HLINE_ret = (int) ACS_HLINE; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_HLINE_ret); + return 1; +} + +/* curses.ACS_VLINE*/ +int mklualib_curses_ACS_VLINE(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_VLINE_ret = (int) ACS_VLINE; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_VLINE_ret); + return 1; +} + +/* curses.ACS_PLUS*/ +int mklualib_curses_ACS_PLUS(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_PLUS_ret = (int) ACS_PLUS; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_PLUS_ret); + return 1; +} + +/* curses.ACS_S1*/ +int mklualib_curses_ACS_S1(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_S1_ret = (int) ACS_S1; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_S1_ret); + return 1; +} + +/* curses.ACS_S9*/ +int mklualib_curses_ACS_S9(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_S9_ret = (int) ACS_S9; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_S9_ret); + return 1; +} + +/* curses.ACS_DIAMOND*/ +int mklualib_curses_ACS_DIAMOND(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_DIAMOND_ret = (int) ACS_DIAMOND; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_DIAMOND_ret); + return 1; +} + +/* curses.ACS_CKBOARD*/ +int mklualib_curses_ACS_CKBOARD(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_CKBOARD_ret = (int) ACS_CKBOARD; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_CKBOARD_ret); + return 1; +} + +/* curses.ACS_DEGREE*/ +int mklualib_curses_ACS_DEGREE(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_DEGREE_ret = (int) ACS_DEGREE; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_DEGREE_ret); + return 1; +} + +/* curses.ACS_PLMINUS*/ +int mklualib_curses_ACS_PLMINUS(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_PLMINUS_ret = (int) ACS_PLMINUS; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_PLMINUS_ret); + return 1; +} + +/* curses.ACS_BULLET*/ +int mklualib_curses_ACS_BULLET(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_BULLET_ret = (int) ACS_BULLET; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_BULLET_ret); + return 1; +} + +/* curses.ACS_LARROW*/ +int mklualib_curses_ACS_LARROW(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_LARROW_ret = (int) ACS_LARROW; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_LARROW_ret); + return 1; +} + +/* curses.ACS_RARROW*/ +int mklualib_curses_ACS_RARROW(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_RARROW_ret = (int) ACS_RARROW; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_RARROW_ret); + return 1; +} + +/* curses.ACS_DARROW*/ +int mklualib_curses_ACS_DARROW(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_DARROW_ret = (int) ACS_DARROW; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_DARROW_ret); + return 1; +} + +/* curses.ACS_UARROW*/ +int mklualib_curses_ACS_UARROW(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_UARROW_ret = (int) ACS_UARROW; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_UARROW_ret); + return 1; +} + +/* curses.ACS_BOARD*/ +int mklualib_curses_ACS_BOARD(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_BOARD_ret = (int) ACS_BOARD; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_BOARD_ret); + return 1; +} + +/* curses.ACS_LANTERN*/ +int mklualib_curses_ACS_LANTERN(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_LANTERN_ret = (int) ACS_LANTERN; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_LANTERN_ret); + return 1; +} + +/* curses.ACS_BLOCK*/ +int mklualib_curses_ACS_BLOCK(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_BLOCK_ret = (int) ACS_BLOCK; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_BLOCK_ret); + return 1; +} + +/* curses.ACS_S3*/ +int mklualib_curses_ACS_S3(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_S3_ret = (int) ACS_S3; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_S3_ret); + return 1; +} + +/* curses.ACS_S7*/ +int mklualib_curses_ACS_S7(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_S7_ret = (int) ACS_S7; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_S7_ret); + return 1; +} + +/* curses.ACS_LEQUAL*/ +int mklualib_curses_ACS_LEQUAL(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_LEQUAL_ret = (int) ACS_LEQUAL; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_LEQUAL_ret); + return 1; +} + +/* curses.ACS_GEQUAL*/ +int mklualib_curses_ACS_GEQUAL(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_GEQUAL_ret = (int) ACS_GEQUAL; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_GEQUAL_ret); + return 1; +} + +/* curses.ACS_PI*/ +int mklualib_curses_ACS_PI(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_PI_ret = (int) ACS_PI; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_PI_ret); + return 1; +} + +/* curses.ACS_NEQUAL*/ +int mklualib_curses_ACS_NEQUAL(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_NEQUAL_ret = (int) ACS_NEQUAL; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_NEQUAL_ret); + return 1; +} + +/* curses.ACS_STERLING*/ +int mklualib_curses_ACS_STERLING(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_STERLING_ret = (int) ACS_STERLING; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_STERLING_ret); + return 1; +} + +/* curses.ACS_BSSB*/ +int mklualib_curses_ACS_BSSB(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_BSSB_ret = (int) ACS_BSSB; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_BSSB_ret); + return 1; +} + +/* curses.ACS_SSBB*/ +int mklualib_curses_ACS_SSBB(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_SSBB_ret = (int) ACS_SSBB; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_SSBB_ret); + return 1; +} + +/* curses.ACS_BBSS*/ +int mklualib_curses_ACS_BBSS(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_BBSS_ret = (int) ACS_BBSS; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_BBSS_ret); + return 1; +} + +/* curses.ACS_SBBS*/ +int mklualib_curses_ACS_SBBS(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_SBBS_ret = (int) ACS_SBBS; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_SBBS_ret); + return 1; +} + +/* curses.ACS_SBSS*/ +int mklualib_curses_ACS_SBSS(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_SBSS_ret = (int) ACS_SBSS; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_SBSS_ret); + return 1; +} + +/* curses.ACS_SSSB*/ +int mklualib_curses_ACS_SSSB(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_SSSB_ret = (int) ACS_SSSB; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_SSSB_ret); + return 1; +} + +/* curses.ACS_SSBS*/ +int mklualib_curses_ACS_SSBS(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_SSBS_ret = (int) ACS_SSBS; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_SSBS_ret); + return 1; +} + +/* curses.ACS_BSSS*/ +int mklualib_curses_ACS_BSSS(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_BSSS_ret = (int) ACS_BSSS; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_BSSS_ret); + return 1; +} + +/* curses.ACS_BSBS*/ +int mklualib_curses_ACS_BSBS(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_BSBS_ret = (int) ACS_BSBS; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_BSBS_ret); + return 1; +} + +/* curses.ACS_SBSB*/ +int mklualib_curses_ACS_SBSB(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_SBSB_ret = (int) ACS_SBSB; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_SBSB_ret); + return 1; +} + +/* curses.ACS_SSSS*/ +int mklualib_curses_ACS_SSSS(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ACS_SSSS_ret = (int) ACS_SSSS; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ACS_SSSS_ret); + return 1; +} + +/* curses.delscreen */ +/* SCREEN*:delscreen */ +int mklualib_curses_delscreen(lua_State* mklualib_lua_state) +{ + SCREEN* _arg0 = luacurses_toscreen(mklualib_lua_state, 1); + delscreen(_arg0); + return 0; +} + +/* curses.set_term */ +/* SCREEN*:set_term */ +int mklualib_curses_set_term(lua_State* mklualib_lua_state) +{ + SCREEN* _arg0 = luacurses_toscreen(mklualib_lua_state, 1); + SCREEN* mklualib_curses_set_term_ret = (SCREEN*) set_term(_arg0); + SCREEN** mklualib_curses_set_term_ret_retptr = luacurses_newscreen(mklualib_lua_state); + *mklualib_curses_set_term_ret_retptr = mklualib_curses_set_term_ret; + return 1; +} + +/* SCREEN*:__tostring */ +int mklualib_curses_screen___tostring(lua_State* mklualib_lua_state) +{ + SCREEN* s = luacurses_toscreen(mklualib_lua_state, 1); + char* mklualib_curses_screen___tostring_ret = (char*) luacurses_screen_tostring(s); + lua_pushstring(mklualib_lua_state, mklualib_curses_screen___tostring_ret); + free(mklualib_curses_screen___tostring_ret); + return 1; +} + +/* SCREEN*:__gc */ +int mklualib_curses_screen___gc(lua_State* mklualib_lua_state) +{ + SCREEN* s = luacurses_toscreen(mklualib_lua_state, 1); + luacurses_screen_free(s); + return 0; +} + +/* WINDOW*:__tostring */ +int mklualib_curses_window___tostring(lua_State* mklualib_lua_state) +{ + WINDOW* w = luacurses_towindow(mklualib_lua_state, 1); + char* mklualib_curses_window___tostring_ret = (char*) luacurses_window_tostring(w); + lua_pushstring(mklualib_lua_state, mklualib_curses_window___tostring_ret); + free(mklualib_curses_window___tostring_ret); + return 1; +} + +/* WINDOW*:__gc */ +int mklualib_curses_window___gc(lua_State* mklualib_lua_state) +{ + WINDOW* w = luacurses_towindow(mklualib_lua_state, 1); + luacurses_window_free(w); + return 0; +} + +/* curses.box */ +/* WINDOW*:box */ +int mklualib_curses_box(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + chtype _arg1 = (chtype) lua_tonumber(mklualib_lua_state, 2); + chtype _arg2 = (chtype) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_box_ret = (int) box(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_box_ret); + return 1; +} + +/* curses.clearok */ +/* WINDOW*:clearok */ +int mklualib_curses_clearok(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + bool _arg1 = (bool) lua_toboolean(mklualib_lua_state, 2); + int mklualib_curses_clearok_ret = (int) clearok(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_clearok_ret); + return 1; +} + +/* curses.delwin */ +/* WINDOW*:delwin */ +int mklualib_curses_delwin(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_delwin_ret = (int) delwin(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_delwin_ret); + return 1; +} + +/* curses.derwin */ +/* WINDOW*:derwin */ +int mklualib_curses_derwin(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + int _arg4 = (int) lua_tonumber(mklualib_lua_state, 5); + WINDOW* mklualib_curses_derwin_ret = (WINDOW*) derwin(_arg0, _arg1, _arg2, _arg3, _arg4); + WINDOW** mklualib_curses_derwin_ret_retptr = luacurses_newwindow(mklualib_lua_state); + *mklualib_curses_derwin_ret_retptr = mklualib_curses_derwin_ret; + return 1; +} + +/* curses.dupwin */ +/* WINDOW*:dupwin */ +int mklualib_curses_dupwin(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + WINDOW* mklualib_curses_dupwin_ret = (WINDOW*) dupwin(_arg0); + WINDOW** mklualib_curses_dupwin_ret_retptr = luacurses_newwindow(mklualib_lua_state); + *mklualib_curses_dupwin_ret_retptr = mklualib_curses_dupwin_ret; + return 1; +} + +/* curses.getbkgd */ +/* WINDOW*:getbkgd */ +int mklualib_curses_getbkgd(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + chtype mklualib_curses_getbkgd_ret = (chtype) getbkgd(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_getbkgd_ret); + return 1; +} + +/* curses.idcok */ +/* WINDOW*:idcok */ +int mklualib_curses_idcok(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + bool _arg1 = (bool) lua_toboolean(mklualib_lua_state, 2); + idcok(_arg0, _arg1); + return 0; +} + +/* curses.idlok */ +/* WINDOW*:idlok */ +int mklualib_curses_idlok(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + bool _arg1 = (bool) lua_toboolean(mklualib_lua_state, 2); + int mklualib_curses_idlok_ret = (int) idlok(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_idlok_ret); + return 1; +} + +/* curses.immedok */ +/* WINDOW*:immedok */ +int mklualib_curses_immedok(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + bool _arg1 = (bool) lua_toboolean(mklualib_lua_state, 2); + immedok(_arg0, _arg1); + return 0; +} + +/* curses.intrflush */ +/* WINDOW*:intrflush */ +int mklualib_curses_intrflush(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + bool _arg1 = (bool) lua_toboolean(mklualib_lua_state, 2); + int mklualib_curses_intrflush_ret = (int) intrflush(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_intrflush_ret); + return 1; +} + +/* curses.is_linetouched */ +/* WINDOW*:is_linetouched */ +int mklualib_curses_is_linetouched(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + bool mklualib_curses_is_linetouched_ret = (bool) is_linetouched(_arg0, _arg1); + lua_pushboolean(mklualib_lua_state, mklualib_curses_is_linetouched_ret); + return 1; +} + +/* curses.is_wintouched */ +/* WINDOW*:is_wintouched */ +int mklualib_curses_is_wintouched(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + bool mklualib_curses_is_wintouched_ret = (bool) is_wintouched(_arg0); + lua_pushboolean(mklualib_lua_state, mklualib_curses_is_wintouched_ret); + return 1; +} + +/* curses.keypad */ +/* WINDOW*:keypad */ +int mklualib_curses_keypad(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + bool _arg1 = (bool) lua_toboolean(mklualib_lua_state, 2); + int mklualib_curses_keypad_ret = (int) keypad(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_keypad_ret); + return 1; +} + +/* curses.leaveok */ +/* WINDOW*:leaveok */ +int mklualib_curses_leaveok(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + bool _arg1 = (bool) lua_toboolean(mklualib_lua_state, 2); + int mklualib_curses_leaveok_ret = (int) leaveok(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_leaveok_ret); + return 1; +} + +/* curses.meta */ +/* WINDOW*:meta */ +int mklualib_curses_meta(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + bool _arg1 = (bool) lua_toboolean(mklualib_lua_state, 2); + int mklualib_curses_meta_ret = (int) meta(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_meta_ret); + return 1; +} + +/* curses.mvderwin */ +/* WINDOW*:mvderwin */ +int mklualib_curses_mvderwin(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_mvderwin_ret = (int) mvderwin(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvderwin_ret); + return 1; +} + +/* curses.mvwaddch */ +/* WINDOW*:mvaddch */ +int mklualib_curses_mvwaddch(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + chtype _arg3 = (chtype) lua_tonumber(mklualib_lua_state, 4); + int mklualib_curses_mvwaddch_ret = (int) mvwaddch(_arg0, _arg1, _arg2, _arg3); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvwaddch_ret); + return 1; +} + +/* curses.mvwaddstr */ +/* WINDOW*:mvaddstr */ +int mklualib_curses_mvwaddstr(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + char* _arg3 = (char*) lua_tostring(mklualib_lua_state, 4); + int mklualib_curses_mvwaddstr_ret = (int) mvwaddstr(_arg0, _arg1, _arg2, _arg3); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvwaddstr_ret); + return 1; +} + +/* curses.mvwchgat */ +/* WINDOW*:mvchgat */ +int mklualib_curses_mvwchgat(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + attr_t _arg4 = (attr_t) lua_tonumber(mklualib_lua_state, 5); + short _arg5 = (short) lua_tonumber(mklualib_lua_state, 6); + int mklualib_curses_mvwchgat_ret = (int) mvwchgat(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, 0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvwchgat_ret); + return 1; +} + +/* curses.mvwdelch */ +/* WINDOW*:mvdelch */ +int mklualib_curses_mvwdelch(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_mvwdelch_ret = (int) mvwdelch(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvwdelch_ret); + return 1; +} + +/* curses.mvwgetch */ +/* WINDOW*:mvgetch */ +int mklualib_curses_mvwgetch(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_mvwgetch_ret = (int) mvwgetch(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvwgetch_ret); + return 1; +} + +/* curses.mvwgetnstr */ +/* WINDOW*:mvgetnstr */ +int mklualib_curses_mvwgetnstr(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + char* mklualib_curses_mvwgetnstr_ret = (char*) luacurses_mvwgetnstr(_arg0, _arg1, _arg2, _arg3); + lua_pushstring(mklualib_lua_state, mklualib_curses_mvwgetnstr_ret); + return 1; +} + +/* curses.mvwhline */ +/* WINDOW*:mvhline */ +int mklualib_curses_mvwhline(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + chtype _arg3 = (chtype) lua_tonumber(mklualib_lua_state, 4); + int _arg4 = (int) lua_tonumber(mklualib_lua_state, 5); + int mklualib_curses_mvwhline_ret = (int) mvwhline(_arg0, _arg1, _arg2, _arg3, _arg4); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvwhline_ret); + return 1; +} + +/* curses.mvwin */ +/* WINDOW*:mvin */ +int mklualib_curses_mvwin(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_mvwin_ret = (int) mvwin(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvwin_ret); + return 1; +} + +/* curses.mvwinch */ +/* WINDOW*:mvinch */ +int mklualib_curses_mvwinch(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + chtype mklualib_curses_mvwinch_ret = (chtype) mvwinch(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvwinch_ret); + return 1; +} + +/* curses.mvwinnstr */ +/* WINDOW*:mvinnstr */ +int mklualib_curses_mvwinnstr(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + char* _arg3 = (char*) lua_tostring(mklualib_lua_state, 4); + int _arg4 = (int) lua_tonumber(mklualib_lua_state, 5); + int mklualib_curses_mvwinnstr_ret = (int) mvwinnstr(_arg0, _arg1, _arg2, _arg3, _arg4); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvwinnstr_ret); + return 1; +} + +/* curses.mvwinsch */ +/* WINDOW*:mvinsch */ +int mklualib_curses_mvwinsch(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + chtype _arg3 = (chtype) lua_tonumber(mklualib_lua_state, 4); + int mklualib_curses_mvwinsch_ret = (int) mvwinsch(_arg0, _arg1, _arg2, _arg3); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvwinsch_ret); + return 1; +} + +/* curses.mvwinsnstr */ +/* WINDOW*:mvinsnstr */ +int mklualib_curses_mvwinsnstr(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + char* _arg3 = (char*) lua_tostring(mklualib_lua_state, 4); + int _arg4 = (int) lua_tonumber(mklualib_lua_state, 5); + int mklualib_curses_mvwinsnstr_ret = (int) mvwinsnstr(_arg0, _arg1, _arg2, _arg3, _arg4); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvwinsnstr_ret); + return 1; +} + +/* curses.mvwinsstr */ +/* WINDOW*:mvinsstr */ +int mklualib_curses_mvwinsstr(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + char* _arg3 = (char*) lua_tostring(mklualib_lua_state, 4); + int mklualib_curses_mvwinsstr_ret = (int) mvwinsstr(_arg0, _arg1, _arg2, _arg3); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvwinsstr_ret); + return 1; +} + +/* curses.mvwinstr */ +/* WINDOW*:mvinstr */ +int mklualib_curses_mvwinstr(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + char* _arg3 = (char*) lua_tostring(mklualib_lua_state, 4); + int mklualib_curses_mvwinstr_ret = (int) mvwinstr(_arg0, _arg1, _arg2, _arg3); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvwinstr_ret); + return 1; +} + +/* curses.mvwvline */ +/* WINDOW*:mvvline */ +int mklualib_curses_mvwvline(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + chtype _arg3 = (chtype) lua_tonumber(mklualib_lua_state, 4); + int _arg4 = (int) lua_tonumber(mklualib_lua_state, 5); + int mklualib_curses_mvwvline_ret = (int) mvwvline(_arg0, _arg1, _arg2, _arg3, _arg4); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvwvline_ret); + return 1; +} + +/* curses.nodelay */ +/* WINDOW*:nodelay */ +int mklualib_curses_nodelay(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + bool _arg1 = (bool) lua_toboolean(mklualib_lua_state, 2); + int mklualib_curses_nodelay_ret = (int) nodelay(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_nodelay_ret); + return 1; +} + +/* curses.notimeout */ +/* WINDOW*:notimeout */ +int mklualib_curses_notimeout(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + bool _arg1 = (bool) lua_toboolean(mklualib_lua_state, 2); + int mklualib_curses_notimeout_ret = (int) notimeout(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_notimeout_ret); + return 1; +} + +/* curses.pechochar */ +/* WINDOW*:pechochar */ +int mklualib_curses_pechochar(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + chtype _arg1 = (chtype) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_pechochar_ret = (int) pechochar(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_pechochar_ret); + return 1; +} + +/* curses.pnoutrefresh */ +/* WINDOW*:pnoutrefresh */ +int mklualib_curses_pnoutrefresh(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + int _arg4 = (int) lua_tonumber(mklualib_lua_state, 5); + int _arg5 = (int) lua_tonumber(mklualib_lua_state, 6); + int _arg6 = (int) lua_tonumber(mklualib_lua_state, 7); + int mklualib_curses_pnoutrefresh_ret = (int) pnoutrefresh(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6); + lua_pushnumber(mklualib_lua_state, mklualib_curses_pnoutrefresh_ret); + return 1; +} + +/* curses.prefresh */ +/* WINDOW*:prefresh */ +int mklualib_curses_prefresh(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + int _arg4 = (int) lua_tonumber(mklualib_lua_state, 5); + int _arg5 = (int) lua_tonumber(mklualib_lua_state, 6); + int _arg6 = (int) lua_tonumber(mklualib_lua_state, 7); + int mklualib_curses_prefresh_ret = (int) prefresh(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6); + lua_pushnumber(mklualib_lua_state, mklualib_curses_prefresh_ret); + return 1; +} + +/* curses.putwin */ +/* WINDOW*:putwin */ +int mklualib_curses_putwin(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + FILE* _arg1 = tofile(mklualib_lua_state, 2); + int mklualib_curses_putwin_ret = (int) putwin(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_putwin_ret); + return 1; +} + +/* curses.redrawwin */ +/* WINDOW*:redrawwin */ +int mklualib_curses_redrawwin(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_redrawwin_ret = (int) redrawwin(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_redrawwin_ret); + return 1; +} + +/* curses.scroll */ +/* WINDOW*:scroll */ +int mklualib_curses_scroll(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_scroll_ret = (int) scroll(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_scroll_ret); + return 1; +} + +/* curses.scrollok */ +/* WINDOW*:scrollok */ +int mklualib_curses_scrollok(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + bool _arg1 = (bool) lua_toboolean(mklualib_lua_state, 2); + int mklualib_curses_scrollok_ret = (int) scrollok(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_scrollok_ret); + return 1; +} + +/* curses.touchline */ +/* WINDOW*:touchline */ +int mklualib_curses_touchline(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_touchline_ret = (int) touchline(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_touchline_ret); + return 1; +} + +/* curses.touchwin */ +/* WINDOW*:touchwin */ +int mklualib_curses_touchwin(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_touchwin_ret = (int) touchwin(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_touchwin_ret); + return 1; +} + +/* curses.untouchwin */ +/* WINDOW*:untouchwin */ +int mklualib_curses_untouchwin(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_untouchwin_ret = (int) untouchwin(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_untouchwin_ret); + return 1; +} + +/* curses.waddch */ +/* WINDOW*:addch */ +int mklualib_curses_waddch(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + chtype _arg1 = (chtype) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_waddch_ret = (int) waddch(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_waddch_ret); + return 1; +} + +/* curses.waddnstr */ +/* WINDOW*:addnstr */ +int mklualib_curses_waddnstr(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + char* _arg1 = (char*) lua_tostring(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_waddnstr_ret = (int) waddnstr(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_waddnstr_ret); + return 1; +} + +/* curses.waddstr */ +/* WINDOW*:addstr */ +int mklualib_curses_waddstr(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + char* _arg1 = (char*) lua_tostring(mklualib_lua_state, 2); + int mklualib_curses_waddstr_ret = (int) waddstr(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_waddstr_ret); + return 1; +} + +/* curses.wattron */ +/* WINDOW*:attron */ +int mklualib_curses_wattron(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_wattron_ret = (int) wattron(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wattron_ret); + return 1; +} + +/* curses.wattroff */ +/* WINDOW*:attroff */ +int mklualib_curses_wattroff(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_wattroff_ret = (int) wattroff(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wattroff_ret); + return 1; +} + +/* curses.wattrset */ +/* WINDOW*:attrset */ +int mklualib_curses_wattrset(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_wattrset_ret = (int) wattrset(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wattrset_ret); + return 1; +} + +/* curses.wattr_get */ +/* WINDOW*:attr_get */ +int mklualib_curses_wattr_get(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + attr_t _arg1; + short _arg2; + int mklualib_curses_wattr_get_ret = (int) wattr_get(_arg0, &_arg1, &_arg2, 0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wattr_get_ret); + lua_pushnumber(mklualib_lua_state, _arg1); + lua_pushnumber(mklualib_lua_state, _arg2); + return 3; +} + +/* curses.wattr_on */ +/* WINDOW*:attr_on */ +int mklualib_curses_wattr_on(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + attr_t _arg1 = (attr_t) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_wattr_on_ret = (int) wattr_on(_arg0, _arg1, 0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wattr_on_ret); + return 1; +} + +/* curses.wattr_off */ +/* WINDOW*:attr_off */ +int mklualib_curses_wattr_off(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + attr_t _arg1 = (attr_t) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_wattr_off_ret = (int) wattr_off(_arg0, _arg1, 0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wattr_off_ret); + return 1; +} + +/* curses.wattr_set */ +/* WINDOW*:attr_set */ +int mklualib_curses_wattr_set(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + attr_t _arg1 = (attr_t) lua_tonumber(mklualib_lua_state, 2); + short _arg2 = (short) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_wattr_set_ret = (int) wattr_set(_arg0, _arg1, _arg2, 0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wattr_set_ret); + return 1; +} + +/* curses.wbkgd */ +/* WINDOW*:bkgd */ +int mklualib_curses_wbkgd(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + chtype _arg1 = (chtype) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_wbkgd_ret = (int) wbkgd(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wbkgd_ret); + return 1; +} + +/* curses.wbkgdset */ +/* WINDOW*:bkgdset */ +int mklualib_curses_wbkgdset(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + chtype _arg1 = (chtype) lua_tonumber(mklualib_lua_state, 2); + wbkgdset(_arg0, _arg1); + return 0; +} + +/* curses.wborder */ +/* WINDOW*:border */ +int mklualib_curses_wborder(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + chtype _arg1 = (chtype) lua_tonumber(mklualib_lua_state, 2); + chtype _arg2 = (chtype) lua_tonumber(mklualib_lua_state, 3); + chtype _arg3 = (chtype) lua_tonumber(mklualib_lua_state, 4); + chtype _arg4 = (chtype) lua_tonumber(mklualib_lua_state, 5); + chtype _arg5 = (chtype) lua_tonumber(mklualib_lua_state, 6); + chtype _arg6 = (chtype) lua_tonumber(mklualib_lua_state, 7); + chtype _arg7 = (chtype) lua_tonumber(mklualib_lua_state, 8); + chtype _arg8 = (chtype) lua_tonumber(mklualib_lua_state, 9); + int mklualib_curses_wborder_ret = (int) wborder(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7, _arg8); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wborder_ret); + return 1; +} + +/* curses.wchgat */ +/* WINDOW*:chgat */ +int mklualib_curses_wchgat(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + attr_t _arg2 = (attr_t) lua_tonumber(mklualib_lua_state, 3); + short _arg3 = (short) lua_tonumber(mklualib_lua_state, 4); + int mklualib_curses_wchgat_ret = (int) wchgat(_arg0, _arg1, _arg2, _arg3, 0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wchgat_ret); + return 1; +} + +/* curses.wclear */ +/* WINDOW*:clear */ +int mklualib_curses_wclear(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_wclear_ret = (int) wclear(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wclear_ret); + return 1; +} + +/* curses.wclrtobot */ +/* WINDOW*:clrtobot */ +int mklualib_curses_wclrtobot(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_wclrtobot_ret = (int) wclrtobot(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wclrtobot_ret); + return 1; +} + +/* curses.wclrtoeol */ +/* WINDOW*:clrtoeol */ +int mklualib_curses_wclrtoeol(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_wclrtoeol_ret = (int) wclrtoeol(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wclrtoeol_ret); + return 1; +} + +/* curses.wcolor_set */ +/* WINDOW*:color_set */ +int mklualib_curses_wcolor_set(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + short _arg1 = (short) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_wcolor_set_ret = (int) wcolor_set(_arg0, _arg1, 0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wcolor_set_ret); + return 1; +} + +/* curses.wcursyncup */ +/* WINDOW*:cursyncup */ +int mklualib_curses_wcursyncup(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + wcursyncup(_arg0); + return 0; +} + +/* curses.wdelch */ +/* WINDOW*:delch */ +int mklualib_curses_wdelch(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_wdelch_ret = (int) wdelch(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wdelch_ret); + return 1; +} + +/* curses.wdeleteln */ +/* WINDOW*:deleteln */ +int mklualib_curses_wdeleteln(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_wdeleteln_ret = (int) wdeleteln(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wdeleteln_ret); + return 1; +} + +/* curses.wechochar */ +/* WINDOW*:echochar */ +int mklualib_curses_wechochar(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + chtype _arg1 = (chtype) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_wechochar_ret = (int) wechochar(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wechochar_ret); + return 1; +} + +/* curses.werase */ +/* WINDOW*:erase */ +int mklualib_curses_werase(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_werase_ret = (int) werase(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_werase_ret); + return 1; +} + +/* curses.wgetch */ +/* WINDOW*:getch */ +int mklualib_curses_wgetch(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_wgetch_ret = (int) wgetch(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wgetch_ret); + return 1; +} + +/* curses.wgetnstr */ +/* WINDOW*:getnstr */ +int mklualib_curses_wgetnstr(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + char* mklualib_curses_wgetnstr_ret = (char*) luacurses_wgetnstr(_arg0, _arg1); + lua_pushstring(mklualib_lua_state, mklualib_curses_wgetnstr_ret); + return 1; +} + +/* curses.whline */ +/* WINDOW*:hline */ +int mklualib_curses_whline(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + chtype _arg1 = (chtype) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_whline_ret = (int) whline(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_whline_ret); + return 1; +} + +/* curses.winch */ +/* WINDOW*:inch */ +int mklualib_curses_winch(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + chtype mklualib_curses_winch_ret = (chtype) winch(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_winch_ret); + return 1; +} + +/* curses.winnstr */ +/* WINDOW*:innstr */ +int mklualib_curses_winnstr(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + char* _arg1 = (char*) lua_tostring(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_winnstr_ret = (int) winnstr(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_winnstr_ret); + return 1; +} + +/* curses.winsch */ +/* WINDOW*:insch */ +int mklualib_curses_winsch(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + chtype _arg1 = (chtype) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_winsch_ret = (int) winsch(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_winsch_ret); + return 1; +} + +/* curses.winsdelln */ +/* WINDOW*:insdelln */ +int mklualib_curses_winsdelln(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_winsdelln_ret = (int) winsdelln(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_winsdelln_ret); + return 1; +} + +/* curses.winsertln */ +/* WINDOW*:insertln */ +int mklualib_curses_winsertln(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_winsertln_ret = (int) winsertln(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_winsertln_ret); + return 1; +} + +/* curses.winsnstr */ +/* WINDOW*:insnstr */ +int mklualib_curses_winsnstr(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + char* _arg1 = (char*) lua_tostring(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_winsnstr_ret = (int) winsnstr(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_winsnstr_ret); + return 1; +} + +/* curses.winsstr */ +/* WINDOW*:insstr */ +int mklualib_curses_winsstr(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + char* _arg1 = (char*) lua_tostring(mklualib_lua_state, 2); + int mklualib_curses_winsstr_ret = (int) winsstr(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_winsstr_ret); + return 1; +} + +/* curses.winstr */ +/* WINDOW*:instr */ +int mklualib_curses_winstr(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + char* _arg1 = (char*) lua_tostring(mklualib_lua_state, 2); + int mklualib_curses_winstr_ret = (int) winstr(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_winstr_ret); + return 1; +} + +/* curses.wmove */ +/* WINDOW*:move */ +int mklualib_curses_wmove(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_wmove_ret = (int) wmove(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wmove_ret); + return 1; +} + +/* curses.wnoutrefresh */ +/* WINDOW*:noutrefresh */ +int mklualib_curses_wnoutrefresh(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_wnoutrefresh_ret = (int) wnoutrefresh(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wnoutrefresh_ret); + return 1; +} + +/* curses.wredrawln */ +/* WINDOW*:redrawln */ +int mklualib_curses_wredrawln(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_wredrawln_ret = (int) wredrawln(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wredrawln_ret); + return 1; +} + +/* curses.wrefresh */ +/* WINDOW*:refresh */ +int mklualib_curses_wrefresh(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_wrefresh_ret = (int) wrefresh(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wrefresh_ret); + return 1; +} + +/* curses.wscrl */ +/* WINDOW*:scrl */ +int mklualib_curses_wscrl(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_wscrl_ret = (int) wscrl(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wscrl_ret); + return 1; +} + +/* curses.wsetscrreg */ +/* WINDOW*:setscrreg */ +int mklualib_curses_wsetscrreg(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_wsetscrreg_ret = (int) wsetscrreg(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wsetscrreg_ret); + return 1; +} + +/* curses.wstandout */ +/* WINDOW*:standout */ +int mklualib_curses_wstandout(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_wstandout_ret = (int) wstandout(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wstandout_ret); + return 1; +} + +/* curses.wstandend */ +/* WINDOW*:standend */ +int mklualib_curses_wstandend(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int mklualib_curses_wstandend_ret = (int) wstandend(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wstandend_ret); + return 1; +} + +/* curses.wsyncdown */ +/* WINDOW*:syncdown */ +int mklualib_curses_wsyncdown(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + wsyncdown(_arg0); + return 0; +} + +/* curses.wsyncup */ +/* WINDOW*:syncup */ +int mklualib_curses_wsyncup(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + wsyncup(_arg0); + return 0; +} + +/* curses.wtimeout */ +/* WINDOW*:timeout */ +int mklualib_curses_wtimeout(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + wtimeout(_arg0, _arg1); + return 0; +} + +/* curses.wtouchln */ +/* WINDOW*:touchln */ +int mklualib_curses_wtouchln(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + int mklualib_curses_wtouchln_ret = (int) wtouchln(_arg0, _arg1, _arg2, _arg3); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wtouchln_ret); + return 1; +} + +/* curses.wvline */ +/* WINDOW*:vline */ +int mklualib_curses_wvline(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + chtype _arg1 = (chtype) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_wvline_ret = (int) wvline(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wvline_ret); + return 1; +} + +/* curses.wenclose */ +/* WINDOW*:enclose */ +int mklualib_curses_wenclose(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + bool mklualib_curses_wenclose_ret = (bool) wenclose(_arg0, _arg1, _arg2); + lua_pushboolean(mklualib_lua_state, mklualib_curses_wenclose_ret); + return 1; +} + +/* curses.wmouse_trafo */ +/* WINDOW*:mouse_trafo */ +int mklualib_curses_wmouse_trafo(lua_State* mklualib_lua_state) +{ + WINDOW* win = luacurses_towindow(mklualib_lua_state, 1); + int y = (int) lua_tonumber(mklualib_lua_state, 2); + int x = (int) lua_tonumber(mklualib_lua_state, 3); + bool to_screen = (bool) lua_toboolean(mklualib_lua_state, 4); + bool mklualib_curses_wmouse_trafo_ret = (bool) wmouse_trafo(win, &y, &x, to_screen); + lua_pushboolean(mklualib_lua_state, mklualib_curses_wmouse_trafo_ret); + lua_pushnumber(mklualib_lua_state, y); + lua_pushnumber(mklualib_lua_state, x); + return 3; +} + +/* curses.stdscr*/ +int mklualib_curses_stdscr(lua_State* mklualib_lua_state) +{ + WINDOW* mklualib_curses_stdscr_ret = (WINDOW*) stdscr; + WINDOW** mklualib_curses_stdscr_ret_retptr = luacurses_newwindow(mklualib_lua_state); + *mklualib_curses_stdscr_ret_retptr = mklualib_curses_stdscr_ret; + return 1; +} + +/* curses.curscr*/ +int mklualib_curses_curscr(lua_State* mklualib_lua_state) +{ + WINDOW* mklualib_curses_curscr_ret = (WINDOW*) curscr; + WINDOW** mklualib_curses_curscr_ret_retptr = luacurses_newwindow(mklualib_lua_state); + *mklualib_curses_curscr_ret_retptr = mklualib_curses_curscr_ret; + return 1; +} + +/* curses.newscr*/ +int mklualib_curses_newscr(lua_State* mklualib_lua_state) +{ + WINDOW* mklualib_curses_newscr_ret = (WINDOW*) newscr; + WINDOW** mklualib_curses_newscr_ret_retptr = luacurses_newwindow(mklualib_lua_state); + *mklualib_curses_newscr_ret_retptr = mklualib_curses_newscr_ret; + return 1; +} + +/* curses.LINES*/ +int mklualib_curses_LINES(lua_State* mklualib_lua_state) +{ + int mklualib_curses_LINES_ret = (int) LINES; + lua_pushnumber(mklualib_lua_state, mklualib_curses_LINES_ret); + return 1; +} + +/* curses.COLS*/ +int mklualib_curses_COLS(lua_State* mklualib_lua_state) +{ + int mklualib_curses_COLS_ret = (int) COLS; + lua_pushnumber(mklualib_lua_state, mklualib_curses_COLS_ret); + return 1; +} + +/* curses.TABSIZE*/ +int mklualib_curses_TABSIZE(lua_State* mklualib_lua_state) +{ + int mklualib_curses_TABSIZE_ret = (int) TABSIZE; + lua_pushnumber(mklualib_lua_state, mklualib_curses_TABSIZE_ret); + return 1; +} + +/* curses.ESCDELAY*/ +int mklualib_curses_ESCDELAY(lua_State* mklualib_lua_state) +{ + int mklualib_curses_ESCDELAY_ret = (int) ESCDELAY; + lua_pushnumber(mklualib_lua_state, mklualib_curses_ESCDELAY_ret); + return 1; +} + +/* curses.is_term_resized*/ +int mklualib_curses_is_term_resized(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + bool mklualib_curses_is_term_resized_ret = (bool) is_term_resized(_arg0, _arg1); + lua_pushboolean(mklualib_lua_state, mklualib_curses_is_term_resized_ret); + return 1; +} + +/* curses.keybound*/ +int mklualib_curses_keybound(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + char* mklualib_curses_keybound_ret = (char*) keybound(_arg0, _arg1); + lua_pushstring(mklualib_lua_state, mklualib_curses_keybound_ret); + free(mklualib_curses_keybound_ret); + return 1; +} + +/* curses.curses_version*/ +int mklualib_curses_curses_version(lua_State* mklualib_lua_state) +{ + char* mklualib_curses_curses_version_ret = (char*) curses_version(); + lua_pushstring(mklualib_lua_state, mklualib_curses_curses_version_ret); + return 1; +} + +/* curses.assume_default_colors*/ +int mklualib_curses_assume_default_colors(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_assume_default_colors_ret = (int) assume_default_colors(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_assume_default_colors_ret); + return 1; +} + +/* curses.define_key*/ +int mklualib_curses_define_key(lua_State* mklualib_lua_state) +{ + char* _arg0 = (char*) lua_tostring(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_define_key_ret = (int) define_key(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_define_key_ret); + return 1; +} + +/* curses.key_defined*/ +int mklualib_curses_key_defined(lua_State* mklualib_lua_state) +{ + char* _arg0 = (char*) lua_tostring(mklualib_lua_state, 1); + int mklualib_curses_key_defined_ret = (int) key_defined(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_key_defined_ret); + return 1; +} + +/* curses.keyok*/ +int mklualib_curses_keyok(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + bool _arg1 = (bool) lua_toboolean(mklualib_lua_state, 2); + int mklualib_curses_keyok_ret = (int) keyok(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_keyok_ret); + return 1; +} + +/* curses.resize_term*/ +int mklualib_curses_resize_term(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_resize_term_ret = (int) resize_term(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_resize_term_ret); + return 1; +} + +/* curses.resizeterm*/ +int mklualib_curses_resizeterm(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_resizeterm_ret = (int) resizeterm(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_resizeterm_ret); + return 1; +} + +/* curses.use_default_colors*/ +int mklualib_curses_use_default_colors(lua_State* mklualib_lua_state) +{ + int mklualib_curses_use_default_colors_ret = (int) use_default_colors(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_use_default_colors_ret); + return 1; +} + +/* curses.use_extended_names*/ +int mklualib_curses_use_extended_names(lua_State* mklualib_lua_state) +{ + bool _arg0 = (bool) lua_toboolean(mklualib_lua_state, 1); + int mklualib_curses_use_extended_names_ret = (int) use_extended_names(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_use_extended_names_ret); + return 1; +} + +/* curses.wresize*/ +int mklualib_curses_wresize(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_wresize_ret = (int) wresize(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_wresize_ret); + return 1; +} + +/* curses.addch*/ +int mklualib_curses_addch(lua_State* mklualib_lua_state) +{ + chtype _arg0 = (chtype) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_addch_ret = (int) addch(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_addch_ret); + return 1; +} + +/* curses.addnstr*/ +int mklualib_curses_addnstr(lua_State* mklualib_lua_state) +{ + char* _arg0 = (char*) lua_tostring(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_addnstr_ret = (int) addnstr(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_addnstr_ret); + return 1; +} + +/* curses.addstr*/ +int mklualib_curses_addstr(lua_State* mklualib_lua_state) +{ + char* _arg0 = (char*) lua_tostring(mklualib_lua_state, 1); + int mklualib_curses_addstr_ret = (int) addstr(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_addstr_ret); + return 1; +} + +/* curses.attroff*/ +int mklualib_curses_attroff(lua_State* mklualib_lua_state) +{ + attr_t _arg0 = (attr_t) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_attroff_ret = (int) attroff(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_attroff_ret); + return 1; +} + +/* curses.attron*/ +int mklualib_curses_attron(lua_State* mklualib_lua_state) +{ + attr_t _arg0 = (attr_t) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_attron_ret = (int) attron(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_attron_ret); + return 1; +} + +/* curses.attrset*/ +int mklualib_curses_attrset(lua_State* mklualib_lua_state) +{ + attr_t _arg0 = (attr_t) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_attrset_ret = (int) attrset(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_attrset_ret); + return 1; +} + +/* curses.attr_get*/ +int mklualib_curses_attr_get(lua_State* mklualib_lua_state) +{ + attr_t _arg0; + short _arg1; + int mklualib_curses_attr_get_ret = (int) attr_get(&_arg0, &_arg1, 0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_attr_get_ret); + lua_pushnumber(mklualib_lua_state, _arg0); + lua_pushnumber(mklualib_lua_state, _arg1); + return 3; +} + +/* curses.attr_off*/ +int mklualib_curses_attr_off(lua_State* mklualib_lua_state) +{ + attr_t _arg0 = (attr_t) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_attr_off_ret = (int) attr_off(_arg0, 0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_attr_off_ret); + return 1; +} + +/* curses.attr_on*/ +int mklualib_curses_attr_on(lua_State* mklualib_lua_state) +{ + attr_t _arg0 = (attr_t) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_attr_on_ret = (int) attr_on(_arg0, 0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_attr_on_ret); + return 1; +} + +/* curses.attr_set*/ +int mklualib_curses_attr_set(lua_State* mklualib_lua_state) +{ + attr_t _arg0 = (attr_t) lua_tonumber(mklualib_lua_state, 1); + short _arg1 = (short) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_attr_set_ret = (int) attr_set(_arg0, _arg1, 0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_attr_set_ret); + return 1; +} + +/* curses.baudrate*/ +int mklualib_curses_baudrate(lua_State* mklualib_lua_state) +{ + int mklualib_curses_baudrate_ret = (int) baudrate(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_baudrate_ret); + return 1; +} + +/* curses.beep*/ +int mklualib_curses_beep(lua_State* mklualib_lua_state) +{ + int mklualib_curses_beep_ret = (int) beep(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_beep_ret); + return 1; +} + +/* curses.bkgd*/ +int mklualib_curses_bkgd(lua_State* mklualib_lua_state) +{ + chtype _arg0 = (chtype) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_bkgd_ret = (int) bkgd(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_bkgd_ret); + return 1; +} + +/* curses.bkgdset*/ +int mklualib_curses_bkgdset(lua_State* mklualib_lua_state) +{ + chtype _arg0 = (chtype) lua_tonumber(mklualib_lua_state, 1); + bkgdset(_arg0); + return 0; +} + +/* curses.border*/ +int mklualib_curses_border(lua_State* mklualib_lua_state) +{ + chtype _arg0 = (chtype) lua_tonumber(mklualib_lua_state, 1); + chtype _arg1 = (chtype) lua_tonumber(mklualib_lua_state, 2); + chtype _arg2 = (chtype) lua_tonumber(mklualib_lua_state, 3); + chtype _arg3 = (chtype) lua_tonumber(mklualib_lua_state, 4); + chtype _arg4 = (chtype) lua_tonumber(mklualib_lua_state, 5); + chtype _arg5 = (chtype) lua_tonumber(mklualib_lua_state, 6); + chtype _arg6 = (chtype) lua_tonumber(mklualib_lua_state, 7); + chtype _arg7 = (chtype) lua_tonumber(mklualib_lua_state, 8); + int mklualib_curses_border_ret = (int) border(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7); + lua_pushnumber(mklualib_lua_state, mklualib_curses_border_ret); + return 1; +} + +/* curses.can_change_color*/ +int mklualib_curses_can_change_color(lua_State* mklualib_lua_state) +{ + bool mklualib_curses_can_change_color_ret = (bool) can_change_color(); + lua_pushboolean(mklualib_lua_state, mklualib_curses_can_change_color_ret); + return 1; +} + +/* curses.cbreak*/ +int mklualib_curses_cbreak(lua_State* mklualib_lua_state) +{ + int mklualib_curses_cbreak_ret = (int) cbreak(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_cbreak_ret); + return 1; +} + +/* curses.chgat*/ +int mklualib_curses_chgat(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + attr_t _arg1 = (attr_t) lua_tonumber(mklualib_lua_state, 2); + short _arg2 = (short) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_chgat_ret = (int) chgat(_arg0, _arg1, _arg2, 0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_chgat_ret); + return 1; +} + +/* curses.clear*/ +int mklualib_curses_clear(lua_State* mklualib_lua_state) +{ + int mklualib_curses_clear_ret = (int) clear(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_clear_ret); + return 1; +} + +/* curses.clrtobot*/ +int mklualib_curses_clrtobot(lua_State* mklualib_lua_state) +{ + int mklualib_curses_clrtobot_ret = (int) clrtobot(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_clrtobot_ret); + return 1; +} + +/* curses.clrtoeol*/ +int mklualib_curses_clrtoeol(lua_State* mklualib_lua_state) +{ + int mklualib_curses_clrtoeol_ret = (int) clrtoeol(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_clrtoeol_ret); + return 1; +} + +/* curses.color_content*/ +int mklualib_curses_color_content(lua_State* mklualib_lua_state) +{ + short _arg0 = (short) lua_tonumber(mklualib_lua_state, 1); + short _arg1; + short _arg2; + short _arg3; + int mklualib_curses_color_content_ret = (int) color_content(_arg0, &_arg1, &_arg2, &_arg3); + lua_pushnumber(mklualib_lua_state, mklualib_curses_color_content_ret); + lua_pushnumber(mklualib_lua_state, _arg1); + lua_pushnumber(mklualib_lua_state, _arg2); + lua_pushnumber(mklualib_lua_state, _arg3); + return 4; +} + +/* curses.color_set*/ +int mklualib_curses_color_set(lua_State* mklualib_lua_state) +{ + short _arg0 = (short) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_color_set_ret = (int) color_set(_arg0, 0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_color_set_ret); + return 1; +} + +/* curses.COLOR_PAIR*/ +int mklualib_curses_COLOR_PAIR(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_COLOR_PAIR_ret = (int) COLOR_PAIR(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_COLOR_PAIR_ret); + return 1; +} + +/* curses.copywin*/ +int mklualib_curses_copywin(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + WINDOW* _arg1 = luacurses_towindow(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + int _arg4 = (int) lua_tonumber(mklualib_lua_state, 5); + int _arg5 = (int) lua_tonumber(mklualib_lua_state, 6); + int _arg6 = (int) lua_tonumber(mklualib_lua_state, 7); + int _arg7 = (int) lua_tonumber(mklualib_lua_state, 8); + int _arg8 = (int) lua_tonumber(mklualib_lua_state, 9); + int mklualib_curses_copywin_ret = (int) copywin(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7, _arg8); + lua_pushnumber(mklualib_lua_state, mklualib_curses_copywin_ret); + return 1; +} + +/* curses.curs_set*/ +int mklualib_curses_curs_set(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_curs_set_ret = (int) curs_set(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_curs_set_ret); + return 1; +} + +/* curses.def_prog_mode*/ +int mklualib_curses_def_prog_mode(lua_State* mklualib_lua_state) +{ + int mklualib_curses_def_prog_mode_ret = (int) def_prog_mode(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_def_prog_mode_ret); + return 1; +} + +/* curses.def_shell_mode*/ +int mklualib_curses_def_shell_mode(lua_State* mklualib_lua_state) +{ + int mklualib_curses_def_shell_mode_ret = (int) def_shell_mode(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_def_shell_mode_ret); + return 1; +} + +/* curses.delay_output*/ +int mklualib_curses_delay_output(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_delay_output_ret = (int) delay_output(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_delay_output_ret); + return 1; +} + +/* curses.delch*/ +int mklualib_curses_delch(lua_State* mklualib_lua_state) +{ + int mklualib_curses_delch_ret = (int) delch(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_delch_ret); + return 1; +} + +/* curses.deleteln*/ +int mklualib_curses_deleteln(lua_State* mklualib_lua_state) +{ + int mklualib_curses_deleteln_ret = (int) deleteln(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_deleteln_ret); + return 1; +} + +/* curses.doupdate*/ +int mklualib_curses_doupdate(lua_State* mklualib_lua_state) +{ + int mklualib_curses_doupdate_ret = (int) doupdate(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_doupdate_ret); + return 1; +} + +/* curses.echo*/ +int mklualib_curses_echo(lua_State* mklualib_lua_state) +{ + int mklualib_curses_echo_ret = (int) echo(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_echo_ret); + return 1; +} + +/* curses.echochar*/ +int mklualib_curses_echochar(lua_State* mklualib_lua_state) +{ + chtype _arg0 = (chtype) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_echochar_ret = (int) echochar(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_echochar_ret); + return 1; +} + +/* curses.erase*/ +int mklualib_curses_erase(lua_State* mklualib_lua_state) +{ + int mklualib_curses_erase_ret = (int) erase(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_erase_ret); + return 1; +} + +/* curses.endwin*/ +int mklualib_curses_endwin(lua_State* mklualib_lua_state) +{ + int mklualib_curses_endwin_ret = (int) endwin(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_endwin_ret); + return 1; +} + +/* curses.erasechar*/ +int mklualib_curses_erasechar(lua_State* mklualib_lua_state) +{ + char mklualib_curses_erasechar_ret = (char) erasechar(); + lua_pushlstring(mklualib_lua_state, &mklualib_curses_erasechar_ret, 1); + return 1; +} + +/* curses.filter*/ +int mklualib_curses_filter(lua_State* mklualib_lua_state) +{ + filter(); + return 0; +} + +/* curses.flash*/ +int mklualib_curses_flash(lua_State* mklualib_lua_state) +{ + int mklualib_curses_flash_ret = (int) flash(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_flash_ret); + return 1; +} + +/* curses.flushinp*/ +int mklualib_curses_flushinp(lua_State* mklualib_lua_state) +{ + int mklualib_curses_flushinp_ret = (int) flushinp(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_flushinp_ret); + return 1; +} + +/* curses.getch*/ +int mklualib_curses_getch(lua_State* mklualib_lua_state) +{ + int mklualib_curses_getch_ret = (int) getch(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_getch_ret); + return 1; +} + +/* curses.getnstr*/ +int mklualib_curses_getnstr(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + char* mklualib_curses_getnstr_ret = (char*) luacurses_getnstr(_arg0); + lua_pushstring(mklualib_lua_state, mklualib_curses_getnstr_ret); + return 1; +} + +/* curses.getwin*/ +int mklualib_curses_getwin(lua_State* mklualib_lua_state) +{ + FILE* _arg0 = tofile(mklualib_lua_state, 1); + WINDOW* mklualib_curses_getwin_ret = (WINDOW*) getwin(_arg0); + WINDOW** mklualib_curses_getwin_ret_retptr = luacurses_newwindow(mklualib_lua_state); + *mklualib_curses_getwin_ret_retptr = mklualib_curses_getwin_ret; + return 1; +} + +/* curses.halfdelay*/ +int mklualib_curses_halfdelay(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_halfdelay_ret = (int) halfdelay(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_halfdelay_ret); + return 1; +} + +/* curses.has_colors*/ +int mklualib_curses_has_colors(lua_State* mklualib_lua_state) +{ + bool mklualib_curses_has_colors_ret = (bool) has_colors(); + lua_pushboolean(mklualib_lua_state, mklualib_curses_has_colors_ret); + return 1; +} + +/* curses.has_ic*/ +int mklualib_curses_has_ic(lua_State* mklualib_lua_state) +{ + bool mklualib_curses_has_ic_ret = (bool) has_ic(); + lua_pushboolean(mklualib_lua_state, mklualib_curses_has_ic_ret); + return 1; +} + +/* curses.has_il*/ +int mklualib_curses_has_il(lua_State* mklualib_lua_state) +{ + bool mklualib_curses_has_il_ret = (bool) has_il(); + lua_pushboolean(mklualib_lua_state, mklualib_curses_has_il_ret); + return 1; +} + +/* curses.hline*/ +int mklualib_curses_hline(lua_State* mklualib_lua_state) +{ + chtype _arg0 = (chtype) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_hline_ret = (int) hline(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_hline_ret); + return 1; +} + +/* curses.inch*/ +int mklualib_curses_inch(lua_State* mklualib_lua_state) +{ + chtype mklualib_curses_inch_ret = (chtype) inch(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_inch_ret); + return 1; +} + +/* curses.initscr*/ +int mklualib_curses_initscr(lua_State* mklualib_lua_state) +{ + WINDOW* mklualib_curses_initscr_ret = (WINDOW*) initscr(); + WINDOW** mklualib_curses_initscr_ret_retptr = luacurses_newwindow(mklualib_lua_state); + *mklualib_curses_initscr_ret_retptr = mklualib_curses_initscr_ret; + return 1; +} + +/* curses.init_color*/ +int mklualib_curses_init_color(lua_State* mklualib_lua_state) +{ + short _arg0 = (short) lua_tonumber(mklualib_lua_state, 1); + short _arg1 = (short) lua_tonumber(mklualib_lua_state, 2); + short _arg2 = (short) lua_tonumber(mklualib_lua_state, 3); + short _arg3 = (short) lua_tonumber(mklualib_lua_state, 4); + int mklualib_curses_init_color_ret = (int) init_color(_arg0, _arg1, _arg2, _arg3); + lua_pushnumber(mklualib_lua_state, mklualib_curses_init_color_ret); + return 1; +} + +/* curses.init_pair*/ +int mklualib_curses_init_pair(lua_State* mklualib_lua_state) +{ + short _arg0 = (short) lua_tonumber(mklualib_lua_state, 1); + short _arg1 = (short) lua_tonumber(mklualib_lua_state, 2); + short _arg2 = (short) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_init_pair_ret = (int) init_pair(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_init_pair_ret); + return 1; +} + +/* curses.innstr*/ +int mklualib_curses_innstr(lua_State* mklualib_lua_state) +{ + char* _arg0 = (char*) lua_tostring(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_innstr_ret = (int) innstr(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_innstr_ret); + return 1; +} + +/* curses.insch*/ +int mklualib_curses_insch(lua_State* mklualib_lua_state) +{ + chtype _arg0 = (chtype) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_insch_ret = (int) insch(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_insch_ret); + return 1; +} + +/* curses.insdelln*/ +int mklualib_curses_insdelln(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_insdelln_ret = (int) insdelln(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_insdelln_ret); + return 1; +} + +/* curses.insertln*/ +int mklualib_curses_insertln(lua_State* mklualib_lua_state) +{ + int mklualib_curses_insertln_ret = (int) insertln(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_insertln_ret); + return 1; +} + +/* curses.insnstr*/ +int mklualib_curses_insnstr(lua_State* mklualib_lua_state) +{ + char* _arg0 = (char*) lua_tostring(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_insnstr_ret = (int) insnstr(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_insnstr_ret); + return 1; +} + +/* curses.insstr*/ +int mklualib_curses_insstr(lua_State* mklualib_lua_state) +{ + char* _arg0 = (char*) lua_tostring(mklualib_lua_state, 1); + int mklualib_curses_insstr_ret = (int) insstr(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_insstr_ret); + return 1; +} + +/* curses.instr*/ +int mklualib_curses_instr(lua_State* mklualib_lua_state) +{ + char* _arg0 = (char*) lua_tostring(mklualib_lua_state, 1); + int mklualib_curses_instr_ret = (int) instr(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_instr_ret); + return 1; +} + +/* curses.isendwin*/ +int mklualib_curses_isendwin(lua_State* mklualib_lua_state) +{ + bool mklualib_curses_isendwin_ret = (bool) isendwin(); + lua_pushboolean(mklualib_lua_state, mklualib_curses_isendwin_ret); + return 1; +} + +/* curses.keyname*/ +int mklualib_curses_keyname(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + char* mklualib_curses_keyname_ret = (char*) keyname(_arg0); + lua_pushstring(mklualib_lua_state, mklualib_curses_keyname_ret); + return 1; +} + +/* curses.killchar*/ +int mklualib_curses_killchar(lua_State* mklualib_lua_state) +{ + char mklualib_curses_killchar_ret = (char) killchar(); + lua_pushlstring(mklualib_lua_state, &mklualib_curses_killchar_ret, 1); + return 1; +} + +/* curses.longname*/ +int mklualib_curses_longname(lua_State* mklualib_lua_state) +{ + char* mklualib_curses_longname_ret = (char*) longname(); + lua_pushstring(mklualib_lua_state, mklualib_curses_longname_ret); + return 1; +} + +/* curses.move*/ +int mklualib_curses_move(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_move_ret = (int) move(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_move_ret); + return 1; +} + +/* curses.mvaddch*/ +int mklualib_curses_mvaddch(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + chtype _arg2 = (chtype) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_mvaddch_ret = (int) mvaddch(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvaddch_ret); + return 1; +} + +/* curses.mvaddnstr*/ +int mklualib_curses_mvaddnstr(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + char* _arg2 = (char*) lua_tostring(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + int mklualib_curses_mvaddnstr_ret = (int) mvaddnstr(_arg0, _arg1, _arg2, _arg3); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvaddnstr_ret); + return 1; +} + +/* curses.mvaddstr*/ +int mklualib_curses_mvaddstr(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + char* _arg2 = (char*) lua_tostring(mklualib_lua_state, 3); + int mklualib_curses_mvaddstr_ret = (int) mvaddstr(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvaddstr_ret); + return 1; +} + +/* curses.mvchgat*/ +int mklualib_curses_mvchgat(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + attr_t _arg3 = (attr_t) lua_tonumber(mklualib_lua_state, 4); + short _arg4 = (short) lua_tonumber(mklualib_lua_state, 5); + int mklualib_curses_mvchgat_ret = (int) mvchgat(_arg0, _arg1, _arg2, _arg3, _arg4, 0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvchgat_ret); + return 1; +} + +/* curses.mvcur*/ +int mklualib_curses_mvcur(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + int mklualib_curses_mvcur_ret = (int) mvcur(_arg0, _arg1, _arg2, _arg3); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvcur_ret); + return 1; +} + +/* curses.mvdelch*/ +int mklualib_curses_mvdelch(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_mvdelch_ret = (int) mvdelch(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvdelch_ret); + return 1; +} + +/* curses.mvgetch*/ +int mklualib_curses_mvgetch(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_mvgetch_ret = (int) mvgetch(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvgetch_ret); + return 1; +} + +/* curses.mvgetnstr*/ +int mklualib_curses_mvgetnstr(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + char* mklualib_curses_mvgetnstr_ret = (char*) luacurses_mvgetnstr(_arg0, _arg1, _arg2); + lua_pushstring(mklualib_lua_state, mklualib_curses_mvgetnstr_ret); + return 1; +} + +/* curses.mvhline*/ +int mklualib_curses_mvhline(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + chtype _arg2 = (chtype) lua_tonumber(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + int mklualib_curses_mvhline_ret = (int) mvhline(_arg0, _arg1, _arg2, _arg3); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvhline_ret); + return 1; +} + +/* curses.mvinch*/ +int mklualib_curses_mvinch(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + chtype mklualib_curses_mvinch_ret = (chtype) mvinch(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvinch_ret); + return 1; +} + +/* curses.mvinnstr*/ +int mklualib_curses_mvinnstr(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + char* _arg2 = (char*) lua_tostring(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + int mklualib_curses_mvinnstr_ret = (int) mvinnstr(_arg0, _arg1, _arg2, _arg3); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvinnstr_ret); + return 1; +} + +/* curses.mvinsch*/ +int mklualib_curses_mvinsch(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + chtype _arg2 = (chtype) lua_tonumber(mklualib_lua_state, 3); + int mklualib_curses_mvinsch_ret = (int) mvinsch(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvinsch_ret); + return 1; +} + +/* curses.mvinsnstr*/ +int mklualib_curses_mvinsnstr(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + char* _arg2 = (char*) lua_tostring(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + int mklualib_curses_mvinsnstr_ret = (int) mvinsnstr(_arg0, _arg1, _arg2, _arg3); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvinsnstr_ret); + return 1; +} + +/* curses.mvinsstr*/ +int mklualib_curses_mvinsstr(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + char* _arg2 = (char*) lua_tostring(mklualib_lua_state, 3); + int mklualib_curses_mvinsstr_ret = (int) mvinsstr(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvinsstr_ret); + return 1; +} + +/* curses.mvinstr*/ +int mklualib_curses_mvinstr(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + char* _arg2 = (char*) lua_tostring(mklualib_lua_state, 3); + int mklualib_curses_mvinstr_ret = (int) mvinstr(_arg0, _arg1, _arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvinstr_ret); + return 1; +} + +/* curses.mvvline*/ +int mklualib_curses_mvvline(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + chtype _arg2 = (chtype) lua_tonumber(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + int mklualib_curses_mvvline_ret = (int) mvvline(_arg0, _arg1, _arg2, _arg3); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mvvline_ret); + return 1; +} + +/* curses.napms*/ +int mklualib_curses_napms(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_napms_ret = (int) napms(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_napms_ret); + return 1; +} + +/* curses.newpad*/ +int mklualib_curses_newpad(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + WINDOW* mklualib_curses_newpad_ret = (WINDOW*) newpad(_arg0, _arg1); + WINDOW** mklualib_curses_newpad_ret_retptr = luacurses_newwindow(mklualib_lua_state); + *mklualib_curses_newpad_ret_retptr = mklualib_curses_newpad_ret; + return 1; +} + +/* curses.newterm*/ +int mklualib_curses_newterm(lua_State* mklualib_lua_state) +{ + char* _arg0 = (char*) lua_tostring(mklualib_lua_state, 1); + FILE* _arg1 = tofile(mklualib_lua_state, 2); + FILE* _arg2 = tofile(mklualib_lua_state, 3); + SCREEN* mklualib_curses_newterm_ret = (SCREEN*) newterm(_arg0, _arg1, _arg2); + SCREEN** mklualib_curses_newterm_ret_retptr = luacurses_newscreen(mklualib_lua_state); + *mklualib_curses_newterm_ret_retptr = mklualib_curses_newterm_ret; + return 1; +} + +/* curses.newwin*/ +int mklualib_curses_newwin(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + WINDOW* mklualib_curses_newwin_ret = (WINDOW*) newwin(_arg0, _arg1, _arg2, _arg3); + WINDOW** mklualib_curses_newwin_ret_retptr = luacurses_newwindow(mklualib_lua_state); + *mklualib_curses_newwin_ret_retptr = mklualib_curses_newwin_ret; + return 1; +} + +/* curses.nl*/ +int mklualib_curses_nl(lua_State* mklualib_lua_state) +{ + int mklualib_curses_nl_ret = (int) nl(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_nl_ret); + return 1; +} + +/* curses.nocbreak*/ +int mklualib_curses_nocbreak(lua_State* mklualib_lua_state) +{ + int mklualib_curses_nocbreak_ret = (int) nocbreak(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_nocbreak_ret); + return 1; +} + +/* curses.noecho*/ +int mklualib_curses_noecho(lua_State* mklualib_lua_state) +{ + int mklualib_curses_noecho_ret = (int) noecho(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_noecho_ret); + return 1; +} + +/* curses.nonl*/ +int mklualib_curses_nonl(lua_State* mklualib_lua_state) +{ + int mklualib_curses_nonl_ret = (int) nonl(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_nonl_ret); + return 1; +} + +/* curses.noqiflush*/ +int mklualib_curses_noqiflush(lua_State* mklualib_lua_state) +{ + noqiflush(); + return 0; +} + +/* curses.noraw*/ +int mklualib_curses_noraw(lua_State* mklualib_lua_state) +{ + int mklualib_curses_noraw_ret = (int) noraw(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_noraw_ret); + return 1; +} + +/* curses.overlay*/ +int mklualib_curses_overlay(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + WINDOW* _arg1 = luacurses_towindow(mklualib_lua_state, 2); + int mklualib_curses_overlay_ret = (int) overlay(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_overlay_ret); + return 1; +} + +/* curses.overwrite*/ +int mklualib_curses_overwrite(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + WINDOW* _arg1 = luacurses_towindow(mklualib_lua_state, 2); + int mklualib_curses_overwrite_ret = (int) overwrite(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_overwrite_ret); + return 1; +} + +/* curses.pair_content*/ +int mklualib_curses_pair_content(lua_State* mklualib_lua_state) +{ + short _arg0 = (short) lua_tonumber(mklualib_lua_state, 1); + short _arg1; + short _arg2; + int mklualib_curses_pair_content_ret = (int) pair_content(_arg0, &_arg1, &_arg2); + lua_pushnumber(mklualib_lua_state, mklualib_curses_pair_content_ret); + lua_pushnumber(mklualib_lua_state, _arg1); + lua_pushnumber(mklualib_lua_state, _arg2); + return 3; +} + +/* curses.PAIR_NUMBER*/ +int mklualib_curses_PAIR_NUMBER(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_PAIR_NUMBER_ret = (int) PAIR_NUMBER(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_PAIR_NUMBER_ret); + return 1; +} + +/* curses.putp*/ +int mklualib_curses_putp(lua_State* mklualib_lua_state) +{ + char* _arg0 = (char*) lua_tostring(mklualib_lua_state, 1); + int mklualib_curses_putp_ret = (int) putp(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_putp_ret); + return 1; +} + +/* curses.qiflush*/ +int mklualib_curses_qiflush(lua_State* mklualib_lua_state) +{ + qiflush(); + return 0; +} + +/* curses.raw*/ +int mklualib_curses_raw(lua_State* mklualib_lua_state) +{ + int mklualib_curses_raw_ret = (int) raw(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_raw_ret); + return 1; +} + +/* curses.refresh*/ +int mklualib_curses_refresh(lua_State* mklualib_lua_state) +{ + int mklualib_curses_refresh_ret = (int) refresh(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_refresh_ret); + return 1; +} + +/* curses.resetty*/ +int mklualib_curses_resetty(lua_State* mklualib_lua_state) +{ + int mklualib_curses_resetty_ret = (int) resetty(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_resetty_ret); + return 1; +} + +/* curses.reset_prog_mode*/ +int mklualib_curses_reset_prog_mode(lua_State* mklualib_lua_state) +{ + int mklualib_curses_reset_prog_mode_ret = (int) reset_prog_mode(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_reset_prog_mode_ret); + return 1; +} + +/* curses.reset_shell_mode*/ +int mklualib_curses_reset_shell_mode(lua_State* mklualib_lua_state) +{ + int mklualib_curses_reset_shell_mode_ret = (int) reset_shell_mode(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_reset_shell_mode_ret); + return 1; +} + +/* curses.savetty*/ +int mklualib_curses_savetty(lua_State* mklualib_lua_state) +{ + int mklualib_curses_savetty_ret = (int) savetty(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_savetty_ret); + return 1; +} + +/* curses.scr_dump*/ +int mklualib_curses_scr_dump(lua_State* mklualib_lua_state) +{ + char* _arg0 = (char*) lua_tostring(mklualib_lua_state, 1); + int mklualib_curses_scr_dump_ret = (int) scr_dump(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_scr_dump_ret); + return 1; +} + +/* curses.scr_init*/ +int mklualib_curses_scr_init(lua_State* mklualib_lua_state) +{ + char* _arg0 = (char*) lua_tostring(mklualib_lua_state, 1); + int mklualib_curses_scr_init_ret = (int) scr_init(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_scr_init_ret); + return 1; +} + +/* curses.scrl*/ +int mklualib_curses_scrl(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_scrl_ret = (int) scrl(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_scrl_ret); + return 1; +} + +/* curses.scr_restore*/ +int mklualib_curses_scr_restore(lua_State* mklualib_lua_state) +{ + char* _arg0 = (char*) lua_tostring(mklualib_lua_state, 1); + int mklualib_curses_scr_restore_ret = (int) scr_restore(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_scr_restore_ret); + return 1; +} + +/* curses.scr_set*/ +int mklualib_curses_scr_set(lua_State* mklualib_lua_state) +{ + char* _arg0 = (char*) lua_tostring(mklualib_lua_state, 1); + int mklualib_curses_scr_set_ret = (int) scr_set(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_scr_set_ret); + return 1; +} + +/* curses.setscrreg*/ +int mklualib_curses_setscrreg(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_setscrreg_ret = (int) setscrreg(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_setscrreg_ret); + return 1; +} + +/* curses.standout*/ +int mklualib_curses_standout(lua_State* mklualib_lua_state) +{ + int mklualib_curses_standout_ret = (int) standout(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_standout_ret); + return 1; +} + +/* curses.standend*/ +int mklualib_curses_standend(lua_State* mklualib_lua_state) +{ + int mklualib_curses_standend_ret = (int) standend(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_standend_ret); + return 1; +} + +/* curses.start_color*/ +int mklualib_curses_start_color(lua_State* mklualib_lua_state) +{ + int mklualib_curses_start_color_ret = (int) start_color(); + lua_pushnumber(mklualib_lua_state, mklualib_curses_start_color_ret); + return 1; +} + +/* curses.subpad*/ +int mklualib_curses_subpad(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + int _arg4 = (int) lua_tonumber(mklualib_lua_state, 5); + WINDOW* mklualib_curses_subpad_ret = (WINDOW*) subpad(_arg0, _arg1, _arg2, _arg3, _arg4); + WINDOW** mklualib_curses_subpad_ret_retptr = luacurses_newwindow(mklualib_lua_state); + *mklualib_curses_subpad_ret_retptr = mklualib_curses_subpad_ret; + return 1; +} + +/* curses.subwin*/ +int mklualib_curses_subwin(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int _arg2 = (int) lua_tonumber(mklualib_lua_state, 3); + int _arg3 = (int) lua_tonumber(mklualib_lua_state, 4); + int _arg4 = (int) lua_tonumber(mklualib_lua_state, 5); + WINDOW* mklualib_curses_subwin_ret = (WINDOW*) subwin(_arg0, _arg1, _arg2, _arg3, _arg4); + WINDOW** mklualib_curses_subwin_ret_retptr = luacurses_newwindow(mklualib_lua_state); + *mklualib_curses_subwin_ret_retptr = mklualib_curses_subwin_ret; + return 1; +} + +/* curses.syncok*/ +int mklualib_curses_syncok(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + bool _arg1 = (bool) lua_toboolean(mklualib_lua_state, 2); + int mklualib_curses_syncok_ret = (int) syncok(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_syncok_ret); + return 1; +} + +/* curses.timeout*/ +int mklualib_curses_timeout(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + timeout(_arg0); + return 0; +} + +/* curses.typeahead*/ +int mklualib_curses_typeahead(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_typeahead_ret = (int) typeahead(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_typeahead_ret); + return 1; +} + +/* curses.ungetch*/ +int mklualib_curses_ungetch(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_ungetch_ret = (int) ungetch(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_ungetch_ret); + return 1; +} + +/* curses.use_env*/ +int mklualib_curses_use_env(lua_State* mklualib_lua_state) +{ + bool _arg0 = (bool) lua_toboolean(mklualib_lua_state, 1); + use_env(_arg0); + return 0; +} + +/* curses.vidattr*/ +int mklualib_curses_vidattr(lua_State* mklualib_lua_state) +{ + chtype _arg0 = (chtype) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_vidattr_ret = (int) vidattr(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_vidattr_ret); + return 1; +} + +/* curses.vline*/ +int mklualib_curses_vline(lua_State* mklualib_lua_state) +{ + chtype _arg0 = (chtype) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + int mklualib_curses_vline_ret = (int) vline(_arg0, _arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_vline_ret); + return 1; +} + +/* curses.getyx*/ +int mklualib_curses_getyx(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int y; + int x; + getyx(_arg0, y, x); + lua_pushnumber(mklualib_lua_state, y); + lua_pushnumber(mklualib_lua_state, x); + return 2; +} + +/* curses.getbegyx*/ +int mklualib_curses_getbegyx(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int y; + int x; + getbegyx(_arg0, y, x); + lua_pushnumber(mklualib_lua_state, y); + lua_pushnumber(mklualib_lua_state, x); + return 2; +} + +/* curses.getmaxyx*/ +int mklualib_curses_getmaxyx(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int y; + int x; + getmaxyx(_arg0, y, x); + lua_pushnumber(mklualib_lua_state, y); + lua_pushnumber(mklualib_lua_state, x); + return 2; +} + +/* curses.getparyx*/ +int mklualib_curses_getparyx(lua_State* mklualib_lua_state) +{ + WINDOW* _arg0 = luacurses_towindow(mklualib_lua_state, 1); + int y; + int x; + getparyx(_arg0, y, x); + lua_pushnumber(mklualib_lua_state, y); + lua_pushnumber(mklualib_lua_state, x); + return 2; +} + +/* curses.KEY_F*/ +int mklualib_curses_KEY_F(lua_State* mklualib_lua_state) +{ + int n = (int) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_KEY_F_ret = (int) KEY_F(n); + lua_pushnumber(mklualib_lua_state, mklualib_curses_KEY_F_ret); + return 1; +} + +/* curses.BUTTON_RELEASE*/ +int mklualib_curses_BUTTON_RELEASE(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + bool mklualib_curses_BUTTON_RELEASE_ret = (bool) BUTTON_RELEASE(_arg0, _arg1); + lua_pushboolean(mklualib_lua_state, mklualib_curses_BUTTON_RELEASE_ret); + return 1; +} + +/* curses.BUTTON_PRESS*/ +int mklualib_curses_BUTTON_PRESS(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + bool mklualib_curses_BUTTON_PRESS_ret = (bool) BUTTON_PRESS(_arg0, _arg1); + lua_pushboolean(mklualib_lua_state, mklualib_curses_BUTTON_PRESS_ret); + return 1; +} + +/* curses.BUTTON_CLICK*/ +int mklualib_curses_BUTTON_CLICK(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + bool mklualib_curses_BUTTON_CLICK_ret = (bool) BUTTON_CLICK(_arg0, _arg1); + lua_pushboolean(mklualib_lua_state, mklualib_curses_BUTTON_CLICK_ret); + return 1; +} + +/* curses.BUTTON_DOUBLE_CLICK*/ +int mklualib_curses_BUTTON_DOUBLE_CLICK(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + bool mklualib_curses_BUTTON_DOUBLE_CLICK_ret = (bool) BUTTON_DOUBLE_CLICK(_arg0, _arg1); + lua_pushboolean(mklualib_lua_state, mklualib_curses_BUTTON_DOUBLE_CLICK_ret); + return 1; +} + +/* curses.BUTTON_TRIPLE_CLICK*/ +int mklualib_curses_BUTTON_TRIPLE_CLICK(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + bool mklualib_curses_BUTTON_TRIPLE_CLICK_ret = (bool) BUTTON_TRIPLE_CLICK(_arg0, _arg1); + lua_pushboolean(mklualib_lua_state, mklualib_curses_BUTTON_TRIPLE_CLICK_ret); + return 1; +} + +/* curses.BUTTON_RESERVED_EVENT*/ +int mklualib_curses_BUTTON_RESERVED_EVENT(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + bool mklualib_curses_BUTTON_RESERVED_EVENT_ret = (bool) BUTTON_RESERVED_EVENT(_arg0, _arg1); + lua_pushboolean(mklualib_lua_state, mklualib_curses_BUTTON_RESERVED_EVENT_ret); + return 1; +} + +/* curses.getmouse*/ +int mklualib_curses_getmouse(lua_State* mklualib_lua_state) +{ + short id; + int x; + int y; + int z; + mmask_t bstate; + bool mklualib_curses_getmouse_ret = (bool) luacurses_getmouse(&id, &x, &y, &z, &bstate); + lua_pushboolean(mklualib_lua_state, mklualib_curses_getmouse_ret); + lua_pushnumber(mklualib_lua_state, id); + lua_pushnumber(mklualib_lua_state, x); + lua_pushnumber(mklualib_lua_state, y); + lua_pushnumber(mklualib_lua_state, z); + lua_pushnumber(mklualib_lua_state, bstate); + return 6; +} + +/* curses.ungetmouse*/ +int mklualib_curses_ungetmouse(lua_State* mklualib_lua_state) +{ + short id = (short) lua_tonumber(mklualib_lua_state, 1); + int x = (int) lua_tonumber(mklualib_lua_state, 2); + int y = (int) lua_tonumber(mklualib_lua_state, 3); + int z = (int) lua_tonumber(mklualib_lua_state, 4); + mmask_t bstate = (mmask_t) lua_tonumber(mklualib_lua_state, 5); + bool mklualib_curses_ungetmouse_ret = (bool) luacurses_ungetmouse(id, x, y, z, bstate); + lua_pushboolean(mklualib_lua_state, mklualib_curses_ungetmouse_ret); + return 1; +} + +/* curses.mousemask*/ +int mklualib_curses_mousemask(lua_State* mklualib_lua_state) +{ + mmask_t _arg0 = (mmask_t) lua_tonumber(mklualib_lua_state, 1); + mmask_t _arg1; + mmask_t mklualib_curses_mousemask_ret = (mmask_t) mousemask(_arg0, &_arg1); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mousemask_ret); + lua_pushnumber(mklualib_lua_state, _arg1); + return 2; +} + +/* curses.addmousemask*/ +int mklualib_curses_addmousemask(lua_State* mklualib_lua_state) +{ + mmask_t _arg0 = (mmask_t) lua_tonumber(mklualib_lua_state, 1); + mmask_t mklualib_curses_addmousemask_ret = (mmask_t) luacurses_addmousemask(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_addmousemask_ret); + return 1; +} + +/* curses.mouseinterval*/ +int mklualib_curses_mouseinterval(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int mklualib_curses_mouseinterval_ret = (int) mouseinterval(_arg0); + lua_pushnumber(mklualib_lua_state, mklualib_curses_mouseinterval_ret); + return 1; +} + +/* curses.mouse_trafo*/ +int mklualib_curses_mouse_trafo(lua_State* mklualib_lua_state) +{ + int _arg0 = (int) lua_tonumber(mklualib_lua_state, 1); + int _arg1 = (int) lua_tonumber(mklualib_lua_state, 2); + bool _arg2 = (bool) lua_toboolean(mklualib_lua_state, 3); + bool mklualib_curses_mouse_trafo_ret = (bool) mouse_trafo(&_arg0, &_arg1, _arg2); + lua_pushboolean(mklualib_lua_state, mklualib_curses_mouse_trafo_ret); + lua_pushnumber(mklualib_lua_state, _arg0); + lua_pushnumber(mklualib_lua_state, _arg1); + return 3; +} + +const luaL_reg mklualib_curses_lib[] = { + {"COLORS", mklualib_curses_COLORS}, + {"COLOR_PAIRS", mklualib_curses_COLOR_PAIRS}, + {"NCURSES_ACS", mklualib_curses_NCURSES_ACS}, + {"ACS_ULCORNER", mklualib_curses_ACS_ULCORNER}, + {"ACS_LLCORNER", mklualib_curses_ACS_LLCORNER}, + {"ACS_URCORNER", mklualib_curses_ACS_URCORNER}, + {"ACS_LRCORNER", mklualib_curses_ACS_LRCORNER}, + {"ACS_LTEE", mklualib_curses_ACS_LTEE}, + {"ACS_RTEE", mklualib_curses_ACS_RTEE}, + {"ACS_BTEE", mklualib_curses_ACS_BTEE}, + {"ACS_TTEE", mklualib_curses_ACS_TTEE}, + {"ACS_HLINE", mklualib_curses_ACS_HLINE}, + {"ACS_VLINE", mklualib_curses_ACS_VLINE}, + {"ACS_PLUS", mklualib_curses_ACS_PLUS}, + {"ACS_S1", mklualib_curses_ACS_S1}, + {"ACS_S9", mklualib_curses_ACS_S9}, + {"ACS_DIAMOND", mklualib_curses_ACS_DIAMOND}, + {"ACS_CKBOARD", mklualib_curses_ACS_CKBOARD}, + {"ACS_DEGREE", mklualib_curses_ACS_DEGREE}, + {"ACS_PLMINUS", mklualib_curses_ACS_PLMINUS}, + {"ACS_BULLET", mklualib_curses_ACS_BULLET}, + {"ACS_LARROW", mklualib_curses_ACS_LARROW}, + {"ACS_RARROW", mklualib_curses_ACS_RARROW}, + {"ACS_DARROW", mklualib_curses_ACS_DARROW}, + {"ACS_UARROW", mklualib_curses_ACS_UARROW}, + {"ACS_BOARD", mklualib_curses_ACS_BOARD}, + {"ACS_LANTERN", mklualib_curses_ACS_LANTERN}, + {"ACS_BLOCK", mklualib_curses_ACS_BLOCK}, + {"ACS_S3", mklualib_curses_ACS_S3}, + {"ACS_S7", mklualib_curses_ACS_S7}, + {"ACS_LEQUAL", mklualib_curses_ACS_LEQUAL}, + {"ACS_GEQUAL", mklualib_curses_ACS_GEQUAL}, + {"ACS_PI", mklualib_curses_ACS_PI}, + {"ACS_NEQUAL", mklualib_curses_ACS_NEQUAL}, + {"ACS_STERLING", mklualib_curses_ACS_STERLING}, + {"ACS_BSSB", mklualib_curses_ACS_BSSB}, + {"ACS_SSBB", mklualib_curses_ACS_SSBB}, + {"ACS_BBSS", mklualib_curses_ACS_BBSS}, + {"ACS_SBBS", mklualib_curses_ACS_SBBS}, + {"ACS_SBSS", mklualib_curses_ACS_SBSS}, + {"ACS_SSSB", mklualib_curses_ACS_SSSB}, + {"ACS_SSBS", mklualib_curses_ACS_SSBS}, + {"ACS_BSSS", mklualib_curses_ACS_BSSS}, + {"ACS_BSBS", mklualib_curses_ACS_BSBS}, + {"ACS_SBSB", mklualib_curses_ACS_SBSB}, + {"ACS_SSSS", mklualib_curses_ACS_SSSS}, + {"delscreen", mklualib_curses_delscreen}, + {"set_term", mklualib_curses_set_term}, + {"box", mklualib_curses_box}, + {"clearok", mklualib_curses_clearok}, + {"delwin", mklualib_curses_delwin}, + {"derwin", mklualib_curses_derwin}, + {"dupwin", mklualib_curses_dupwin}, + {"getbkgd", mklualib_curses_getbkgd}, + {"idcok", mklualib_curses_idcok}, + {"idlok", mklualib_curses_idlok}, + {"immedok", mklualib_curses_immedok}, + {"intrflush", mklualib_curses_intrflush}, + {"is_linetouched", mklualib_curses_is_linetouched}, + {"is_wintouched", mklualib_curses_is_wintouched}, + {"keypad", mklualib_curses_keypad}, + {"leaveok", mklualib_curses_leaveok}, + {"meta", mklualib_curses_meta}, + {"mvderwin", mklualib_curses_mvderwin}, + {"mvwaddch", mklualib_curses_mvwaddch}, + {"mvwaddstr", mklualib_curses_mvwaddstr}, + {"mvwchgat", mklualib_curses_mvwchgat}, + {"mvwdelch", mklualib_curses_mvwdelch}, + {"mvwgetch", mklualib_curses_mvwgetch}, + {"mvwgetnstr", mklualib_curses_mvwgetnstr}, + {"mvwhline", mklualib_curses_mvwhline}, + {"mvwin", mklualib_curses_mvwin}, + {"mvwinch", mklualib_curses_mvwinch}, + {"mvwinnstr", mklualib_curses_mvwinnstr}, + {"mvwinsch", mklualib_curses_mvwinsch}, + {"mvwinsnstr", mklualib_curses_mvwinsnstr}, + {"mvwinsstr", mklualib_curses_mvwinsstr}, + {"mvwinstr", mklualib_curses_mvwinstr}, + {"mvwvline", mklualib_curses_mvwvline}, + {"nodelay", mklualib_curses_nodelay}, + {"notimeout", mklualib_curses_notimeout}, + {"pechochar", mklualib_curses_pechochar}, + {"pnoutrefresh", mklualib_curses_pnoutrefresh}, + {"prefresh", mklualib_curses_prefresh}, + {"putwin", mklualib_curses_putwin}, + {"redrawwin", mklualib_curses_redrawwin}, + {"scroll", mklualib_curses_scroll}, + {"scrollok", mklualib_curses_scrollok}, + {"touchline", mklualib_curses_touchline}, + {"touchwin", mklualib_curses_touchwin}, + {"untouchwin", mklualib_curses_untouchwin}, + {"waddch", mklualib_curses_waddch}, + {"waddnstr", mklualib_curses_waddnstr}, + {"waddstr", mklualib_curses_waddstr}, + {"wattron", mklualib_curses_wattron}, + {"wattroff", mklualib_curses_wattroff}, + {"wattrset", mklualib_curses_wattrset}, + {"wattr_get", mklualib_curses_wattr_get}, + {"wattr_on", mklualib_curses_wattr_on}, + {"wattr_off", mklualib_curses_wattr_off}, + {"wattr_set", mklualib_curses_wattr_set}, + {"wbkgd", mklualib_curses_wbkgd}, + {"wbkgdset", mklualib_curses_wbkgdset}, + {"wborder", mklualib_curses_wborder}, + {"wchgat", mklualib_curses_wchgat}, + {"wclear", mklualib_curses_wclear}, + {"wclrtobot", mklualib_curses_wclrtobot}, + {"wclrtoeol", mklualib_curses_wclrtoeol}, + {"wcolor_set", mklualib_curses_wcolor_set}, + {"wcursyncup", mklualib_curses_wcursyncup}, + {"wdelch", mklualib_curses_wdelch}, + {"wdeleteln", mklualib_curses_wdeleteln}, + {"wechochar", mklualib_curses_wechochar}, + {"werase", mklualib_curses_werase}, + {"wgetch", mklualib_curses_wgetch}, + {"wgetnstr", mklualib_curses_wgetnstr}, + {"whline", mklualib_curses_whline}, + {"winch", mklualib_curses_winch}, + {"winnstr", mklualib_curses_winnstr}, + {"winsch", mklualib_curses_winsch}, + {"winsdelln", mklualib_curses_winsdelln}, + {"winsertln", mklualib_curses_winsertln}, + {"winsnstr", mklualib_curses_winsnstr}, + {"winsstr", mklualib_curses_winsstr}, + {"winstr", mklualib_curses_winstr}, + {"wmove", mklualib_curses_wmove}, + {"wnoutrefresh", mklualib_curses_wnoutrefresh}, + {"wredrawln", mklualib_curses_wredrawln}, + {"wrefresh", mklualib_curses_wrefresh}, + {"wscrl", mklualib_curses_wscrl}, + {"wsetscrreg", mklualib_curses_wsetscrreg}, + {"wstandout", mklualib_curses_wstandout}, + {"wstandend", mklualib_curses_wstandend}, + {"wsyncdown", mklualib_curses_wsyncdown}, + {"wsyncup", mklualib_curses_wsyncup}, + {"wtimeout", mklualib_curses_wtimeout}, + {"wtouchln", mklualib_curses_wtouchln}, + {"wvline", mklualib_curses_wvline}, + {"wenclose", mklualib_curses_wenclose}, + {"wmouse_trafo", mklualib_curses_wmouse_trafo}, + {"stdscr", mklualib_curses_stdscr}, + {"curscr", mklualib_curses_curscr}, + {"newscr", mklualib_curses_newscr}, + {"LINES", mklualib_curses_LINES}, + {"COLS", mklualib_curses_COLS}, + {"TABSIZE", mklualib_curses_TABSIZE}, + {"ESCDELAY", mklualib_curses_ESCDELAY}, + {"is_term_resized", mklualib_curses_is_term_resized}, + {"keybound", mklualib_curses_keybound}, + {"curses_version", mklualib_curses_curses_version}, + {"assume_default_colors", mklualib_curses_assume_default_colors}, + {"define_key", mklualib_curses_define_key}, + {"key_defined", mklualib_curses_key_defined}, + {"keyok", mklualib_curses_keyok}, + {"resize_term", mklualib_curses_resize_term}, + {"resizeterm", mklualib_curses_resizeterm}, + {"use_default_colors", mklualib_curses_use_default_colors}, + {"use_extended_names", mklualib_curses_use_extended_names}, + {"wresize", mklualib_curses_wresize}, + {"addch", mklualib_curses_addch}, + {"addnstr", mklualib_curses_addnstr}, + {"addstr", mklualib_curses_addstr}, + {"attroff", mklualib_curses_attroff}, + {"attron", mklualib_curses_attron}, + {"attrset", mklualib_curses_attrset}, + {"attr_get", mklualib_curses_attr_get}, + {"attr_off", mklualib_curses_attr_off}, + {"attr_on", mklualib_curses_attr_on}, + {"attr_set", mklualib_curses_attr_set}, + {"baudrate", mklualib_curses_baudrate}, + {"beep", mklualib_curses_beep}, + {"bkgd", mklualib_curses_bkgd}, + {"bkgdset", mklualib_curses_bkgdset}, + {"border", mklualib_curses_border}, + {"can_change_color", mklualib_curses_can_change_color}, + {"cbreak", mklualib_curses_cbreak}, + {"chgat", mklualib_curses_chgat}, + {"clear", mklualib_curses_clear}, + {"clrtobot", mklualib_curses_clrtobot}, + {"clrtoeol", mklualib_curses_clrtoeol}, + {"color_content", mklualib_curses_color_content}, + {"color_set", mklualib_curses_color_set}, + {"COLOR_PAIR", mklualib_curses_COLOR_PAIR}, + {"copywin", mklualib_curses_copywin}, + {"curs_set", mklualib_curses_curs_set}, + {"def_prog_mode", mklualib_curses_def_prog_mode}, + {"def_shell_mode", mklualib_curses_def_shell_mode}, + {"delay_output", mklualib_curses_delay_output}, + {"delch", mklualib_curses_delch}, + {"deleteln", mklualib_curses_deleteln}, + {"doupdate", mklualib_curses_doupdate}, + {"echo", mklualib_curses_echo}, + {"echochar", mklualib_curses_echochar}, + {"erase", mklualib_curses_erase}, + {"endwin", mklualib_curses_endwin}, + {"erasechar", mklualib_curses_erasechar}, + {"filter", mklualib_curses_filter}, + {"flash", mklualib_curses_flash}, + {"flushinp", mklualib_curses_flushinp}, + {"getch", mklualib_curses_getch}, + {"getnstr", mklualib_curses_getnstr}, + {"getwin", mklualib_curses_getwin}, + {"halfdelay", mklualib_curses_halfdelay}, + {"has_colors", mklualib_curses_has_colors}, + {"has_ic", mklualib_curses_has_ic}, + {"has_il", mklualib_curses_has_il}, + {"hline", mklualib_curses_hline}, + {"inch", mklualib_curses_inch}, + {"initscr", mklualib_curses_initscr}, + {"init_color", mklualib_curses_init_color}, + {"init_pair", mklualib_curses_init_pair}, + {"innstr", mklualib_curses_innstr}, + {"insch", mklualib_curses_insch}, + {"insdelln", mklualib_curses_insdelln}, + {"insertln", mklualib_curses_insertln}, + {"insnstr", mklualib_curses_insnstr}, + {"insstr", mklualib_curses_insstr}, + {"instr", mklualib_curses_instr}, + {"isendwin", mklualib_curses_isendwin}, + {"keyname", mklualib_curses_keyname}, + {"killchar", mklualib_curses_killchar}, + {"longname", mklualib_curses_longname}, + {"move", mklualib_curses_move}, + {"mvaddch", mklualib_curses_mvaddch}, + {"mvaddnstr", mklualib_curses_mvaddnstr}, + {"mvaddstr", mklualib_curses_mvaddstr}, + {"mvchgat", mklualib_curses_mvchgat}, + {"mvcur", mklualib_curses_mvcur}, + {"mvdelch", mklualib_curses_mvdelch}, + {"mvgetch", mklualib_curses_mvgetch}, + {"mvgetnstr", mklualib_curses_mvgetnstr}, + {"mvhline", mklualib_curses_mvhline}, + {"mvinch", mklualib_curses_mvinch}, + {"mvinnstr", mklualib_curses_mvinnstr}, + {"mvinsch", mklualib_curses_mvinsch}, + {"mvinsnstr", mklualib_curses_mvinsnstr}, + {"mvinsstr", mklualib_curses_mvinsstr}, + {"mvinstr", mklualib_curses_mvinstr}, + {"mvvline", mklualib_curses_mvvline}, + {"napms", mklualib_curses_napms}, + {"newpad", mklualib_curses_newpad}, + {"newterm", mklualib_curses_newterm}, + {"newwin", mklualib_curses_newwin}, + {"nl", mklualib_curses_nl}, + {"nocbreak", mklualib_curses_nocbreak}, + {"noecho", mklualib_curses_noecho}, + {"nonl", mklualib_curses_nonl}, + {"noqiflush", mklualib_curses_noqiflush}, + {"noraw", mklualib_curses_noraw}, + {"overlay", mklualib_curses_overlay}, + {"overwrite", mklualib_curses_overwrite}, + {"pair_content", mklualib_curses_pair_content}, + {"PAIR_NUMBER", mklualib_curses_PAIR_NUMBER}, + {"putp", mklualib_curses_putp}, + {"qiflush", mklualib_curses_qiflush}, + {"raw", mklualib_curses_raw}, + {"refresh", mklualib_curses_refresh}, + {"resetty", mklualib_curses_resetty}, + {"reset_prog_mode", mklualib_curses_reset_prog_mode}, + {"reset_shell_mode", mklualib_curses_reset_shell_mode}, + {"savetty", mklualib_curses_savetty}, + {"scr_dump", mklualib_curses_scr_dump}, + {"scr_init", mklualib_curses_scr_init}, + {"scrl", mklualib_curses_scrl}, + {"scr_restore", mklualib_curses_scr_restore}, + {"scr_set", mklualib_curses_scr_set}, + {"setscrreg", mklualib_curses_setscrreg}, + {"standout", mklualib_curses_standout}, + {"standend", mklualib_curses_standend}, + {"start_color", mklualib_curses_start_color}, + {"subpad", mklualib_curses_subpad}, + {"subwin", mklualib_curses_subwin}, + {"syncok", mklualib_curses_syncok}, + {"timeout", mklualib_curses_timeout}, + {"typeahead", mklualib_curses_typeahead}, + {"ungetch", mklualib_curses_ungetch}, + {"use_env", mklualib_curses_use_env}, + {"vidattr", mklualib_curses_vidattr}, + {"vline", mklualib_curses_vline}, + {"getyx", mklualib_curses_getyx}, + {"getbegyx", mklualib_curses_getbegyx}, + {"getmaxyx", mklualib_curses_getmaxyx}, + {"getparyx", mklualib_curses_getparyx}, + {"KEY_F", mklualib_curses_KEY_F}, + {"BUTTON_RELEASE", mklualib_curses_BUTTON_RELEASE}, + {"BUTTON_PRESS", mklualib_curses_BUTTON_PRESS}, + {"BUTTON_CLICK", mklualib_curses_BUTTON_CLICK}, + {"BUTTON_DOUBLE_CLICK", mklualib_curses_BUTTON_DOUBLE_CLICK}, + {"BUTTON_TRIPLE_CLICK", mklualib_curses_BUTTON_TRIPLE_CLICK}, + {"BUTTON_RESERVED_EVENT", mklualib_curses_BUTTON_RESERVED_EVENT}, + {"getmouse", mklualib_curses_getmouse}, + {"ungetmouse", mklualib_curses_ungetmouse}, + {"mousemask", mklualib_curses_mousemask}, + {"addmousemask", mklualib_curses_addmousemask}, + {"mouseinterval", mklualib_curses_mouseinterval}, + {"mouse_trafo", mklualib_curses_mouse_trafo}, + {0, 0} +}; + +const mklualib_regnum mklualib_curses_lib_nums[] = { + {"OK", OK}, + {"ERR", ERR}, + {"WA_ATTRIBUTES", WA_ATTRIBUTES}, + {"WA_NORMAL", WA_NORMAL}, + {"WA_STANDOUT", WA_STANDOUT}, + {"WA_UNDERLINE", WA_UNDERLINE}, + {"WA_REVERSE", WA_REVERSE}, + {"WA_BLINK", WA_BLINK}, + {"WA_DIM", WA_DIM}, + {"WA_BOLD", WA_BOLD}, + {"WA_ALTCHARSET", WA_ALTCHARSET}, + {"WA_INVIS", WA_INVIS}, + {"WA_PROTECT", WA_PROTECT}, + {"WA_HORIZONTAL", WA_HORIZONTAL}, + {"WA_LEFT", WA_LEFT}, + {"WA_LOW", WA_LOW}, + {"WA_RIGHT", WA_RIGHT}, + {"WA_TOP", WA_TOP}, + {"WA_VERTICAL", WA_VERTICAL}, + {"COLOR_BLACK", COLOR_BLACK}, + {"COLOR_RED", COLOR_RED}, + {"COLOR_GREEN", COLOR_GREEN}, + {"COLOR_YELLOW", COLOR_YELLOW}, + {"COLOR_BLUE", COLOR_BLUE}, + {"COLOR_MAGENTA", COLOR_MAGENTA}, + {"COLOR_CYAN", COLOR_CYAN}, + {"COLOR_WHITE", COLOR_WHITE}, + {"A_NORMAL", A_NORMAL}, + {"A_ATTRIBUTES", A_ATTRIBUTES}, + {"A_CHARTEXT", A_CHARTEXT}, + {"A_COLOR", A_COLOR}, + {"A_STANDOUT", A_STANDOUT}, + {"A_UNDERLINE", A_UNDERLINE}, + {"A_REVERSE", A_REVERSE}, + {"A_BLINK", A_BLINK}, + {"A_DIM", A_DIM}, + {"A_BOLD", A_BOLD}, + {"A_ALTCHARSET", A_ALTCHARSET}, + {"A_INVIS", A_INVIS}, + {"A_PROTECT", A_PROTECT}, + {"A_HORIZONTAL", A_HORIZONTAL}, + {"A_LEFT", A_LEFT}, + {"A_LOW", A_LOW}, + {"A_RIGHT", A_RIGHT}, + {"A_TOP", A_TOP}, + {"A_VERTICAL", A_VERTICAL}, + {"KEY_CODE_YES", KEY_CODE_YES}, + {"KEY_MIN", KEY_MIN}, + {"KEY_BREAK", KEY_BREAK}, + {"KEY_SRESET", KEY_SRESET}, + {"KEY_RESET", KEY_RESET}, + {"KEY_DOWN", KEY_DOWN}, + {"KEY_UP", KEY_UP}, + {"KEY_LEFT", KEY_LEFT}, + {"KEY_RIGHT", KEY_RIGHT}, + {"KEY_HOME", KEY_HOME}, + {"KEY_BACKSPACE", KEY_BACKSPACE}, + {"KEY_F0", KEY_F0}, + {"KEY_DL", KEY_DL}, + {"KEY_IL", KEY_IL}, + {"KEY_DC", KEY_DC}, + {"KEY_IC", KEY_IC}, + {"KEY_EIC", KEY_EIC}, + {"KEY_CLEAR", KEY_CLEAR}, + {"KEY_EOS", KEY_EOS}, + {"KEY_EOL", KEY_EOL}, + {"KEY_SF", KEY_SF}, + {"KEY_SR", KEY_SR}, + {"KEY_NPAGE", KEY_NPAGE}, + {"KEY_PPAGE", KEY_PPAGE}, + {"KEY_STAB", KEY_STAB}, + {"KEY_CTAB", KEY_CTAB}, + {"KEY_CATAB", KEY_CATAB}, + {"KEY_ENTER", KEY_ENTER}, + {"KEY_PRINT", KEY_PRINT}, + {"KEY_LL", KEY_LL}, + {"KEY_A1", KEY_A1}, + {"KEY_A3", KEY_A3}, + {"KEY_B2", KEY_B2}, + {"KEY_C1", KEY_C1}, + {"KEY_C3", KEY_C3}, + {"KEY_BTAB", KEY_BTAB}, + {"KEY_BEG", KEY_BEG}, + {"KEY_CANCEL", KEY_CANCEL}, + {"KEY_CLOSE", KEY_CLOSE}, + {"KEY_COMMAND", KEY_COMMAND}, + {"KEY_COPY", KEY_COPY}, + {"KEY_CREATE", KEY_CREATE}, + {"KEY_END", KEY_END}, + {"KEY_EXIT", KEY_EXIT}, + {"KEY_FIND", KEY_FIND}, + {"KEY_HELP", KEY_HELP}, + {"KEY_MARK", KEY_MARK}, + {"KEY_MESSAGE", KEY_MESSAGE}, + {"KEY_MOVE", KEY_MOVE}, + {"KEY_NEXT", KEY_NEXT}, + {"KEY_OPEN", KEY_OPEN}, + {"KEY_OPTIONS", KEY_OPTIONS}, + {"KEY_PREVIOUS", KEY_PREVIOUS}, + {"KEY_REDO", KEY_REDO}, + {"KEY_REFERENCE", KEY_REFERENCE}, + {"KEY_REFRESH", KEY_REFRESH}, + {"KEY_REPLACE", KEY_REPLACE}, + {"KEY_RESTART", KEY_RESTART}, + {"KEY_RESUME", KEY_RESUME}, + {"KEY_SAVE", KEY_SAVE}, + {"KEY_SBEG", KEY_SBEG}, + {"KEY_SCANCEL", KEY_SCANCEL}, + {"KEY_SCOMMAND", KEY_SCOMMAND}, + {"KEY_SCOPY", KEY_SCOPY}, + {"KEY_SCREATE", KEY_SCREATE}, + {"KEY_SDC", KEY_SDC}, + {"KEY_SDL", KEY_SDL}, + {"KEY_SELECT", KEY_SELECT}, + {"KEY_SEND", KEY_SEND}, + {"KEY_SEOL", KEY_SEOL}, + {"KEY_SEXIT", KEY_SEXIT}, + {"KEY_SFIND", KEY_SFIND}, + {"KEY_SHELP", KEY_SHELP}, + {"KEY_SHOME", KEY_SHOME}, + {"KEY_SIC", KEY_SIC}, + {"KEY_SLEFT", KEY_SLEFT}, + {"KEY_SMESSAGE", KEY_SMESSAGE}, + {"KEY_SMOVE", KEY_SMOVE}, + {"KEY_SNEXT", KEY_SNEXT}, + {"KEY_SOPTIONS", KEY_SOPTIONS}, + {"KEY_SPREVIOUS", KEY_SPREVIOUS}, + {"KEY_SPRINT", KEY_SPRINT}, + {"KEY_SREDO", KEY_SREDO}, + {"KEY_SREPLACE", KEY_SREPLACE}, + {"KEY_SRIGHT", KEY_SRIGHT}, + {"KEY_SRSUME", KEY_SRSUME}, + {"KEY_SSAVE", KEY_SSAVE}, + {"KEY_SSUSPEND", KEY_SSUSPEND}, + {"KEY_SUNDO", KEY_SUNDO}, + {"KEY_SUSPEND", KEY_SUSPEND}, + {"KEY_UNDO", KEY_UNDO}, + {"KEY_MOUSE", KEY_MOUSE}, + {"KEY_RESIZE", KEY_RESIZE}, + {"KEY_EVENT", KEY_EVENT}, + {"KEY_MAX", KEY_MAX}, + {"BUTTON1_RELEASED", BUTTON1_RELEASED}, + {"BUTTON1_PRESSED", BUTTON1_PRESSED}, + {"BUTTON1_CLICKED", BUTTON1_CLICKED}, + {"BUTTON1_DOUBLE_CLICKED", BUTTON1_DOUBLE_CLICKED}, + {"BUTTON1_TRIPLE_CLICKED", BUTTON1_TRIPLE_CLICKED}, + {"BUTTON1_RESERVED_EVENT", BUTTON1_RESERVED_EVENT}, + {"BUTTON2_RELEASED", BUTTON2_RELEASED}, + {"BUTTON2_PRESSED", BUTTON2_PRESSED}, + {"BUTTON2_CLICKED", BUTTON2_CLICKED}, + {"BUTTON2_DOUBLE_CLICKED", BUTTON2_DOUBLE_CLICKED}, + {"BUTTON2_TRIPLE_CLICKED", BUTTON2_TRIPLE_CLICKED}, + {"BUTTON2_RESERVED_EVENT", BUTTON2_RESERVED_EVENT}, + {"BUTTON3_RELEASED", BUTTON3_RELEASED}, + {"BUTTON3_PRESSED", BUTTON3_PRESSED}, + {"BUTTON3_CLICKED", BUTTON3_CLICKED}, + {"BUTTON3_DOUBLE_CLICKED", BUTTON3_DOUBLE_CLICKED}, + {"BUTTON3_TRIPLE_CLICKED", BUTTON3_TRIPLE_CLICKED}, + {"BUTTON3_RESERVED_EVENT", BUTTON3_RESERVED_EVENT}, + {"BUTTON4_RELEASED", BUTTON4_RELEASED}, + {"BUTTON4_PRESSED", BUTTON4_PRESSED}, + {"BUTTON4_CLICKED", BUTTON4_CLICKED}, + {"BUTTON4_DOUBLE_CLICKED", BUTTON4_DOUBLE_CLICKED}, + {"BUTTON4_TRIPLE_CLICKED", BUTTON4_TRIPLE_CLICKED}, + {"BUTTON4_RESERVED_EVENT", BUTTON4_RESERVED_EVENT}, + {"BUTTON_CTRL", BUTTON_CTRL}, + {"BUTTON_SHIFT", BUTTON_SHIFT}, + {"BUTTON_ALT", BUTTON_ALT}, + {"ALL_MOUSE_EVENTS", ALL_MOUSE_EVENTS}, + {"REPORT_MOUSE_POSITION", REPORT_MOUSE_POSITION}, + {0, 0} +}; + +const luaL_reg mklualib_curses_window_lib[] = { + {"__tostring", mklualib_curses_window___tostring}, + {"__gc", mklualib_curses_window___gc}, + {"box", mklualib_curses_box}, + {"clearok", mklualib_curses_clearok}, + {"delwin", mklualib_curses_delwin}, + {"derwin", mklualib_curses_derwin}, + {"dupwin", mklualib_curses_dupwin}, + {"getbkgd", mklualib_curses_getbkgd}, + {"idcok", mklualib_curses_idcok}, + {"idlok", mklualib_curses_idlok}, + {"immedok", mklualib_curses_immedok}, + {"intrflush", mklualib_curses_intrflush}, + {"is_linetouched", mklualib_curses_is_linetouched}, + {"is_wintouched", mklualib_curses_is_wintouched}, + {"keypad", mklualib_curses_keypad}, + {"leaveok", mklualib_curses_leaveok}, + {"meta", mklualib_curses_meta}, + {"mvderwin", mklualib_curses_mvderwin}, + {"mvaddch", mklualib_curses_mvwaddch}, + {"mvaddstr", mklualib_curses_mvwaddstr}, + {"mvchgat", mklualib_curses_mvwchgat}, + {"mvdelch", mklualib_curses_mvwdelch}, + {"mvgetch", mklualib_curses_mvwgetch}, + {"mvgetnstr", mklualib_curses_mvwgetnstr}, + {"mvhline", mklualib_curses_mvwhline}, + {"mvin", mklualib_curses_mvwin}, + {"mvinch", mklualib_curses_mvwinch}, + {"mvinnstr", mklualib_curses_mvwinnstr}, + {"mvinsch", mklualib_curses_mvwinsch}, + {"mvinsnstr", mklualib_curses_mvwinsnstr}, + {"mvinsstr", mklualib_curses_mvwinsstr}, + {"mvinstr", mklualib_curses_mvwinstr}, + {"mvvline", mklualib_curses_mvwvline}, + {"nodelay", mklualib_curses_nodelay}, + {"notimeout", mklualib_curses_notimeout}, + {"pechochar", mklualib_curses_pechochar}, + {"pnoutrefresh", mklualib_curses_pnoutrefresh}, + {"prefresh", mklualib_curses_prefresh}, + {"putwin", mklualib_curses_putwin}, + {"redrawwin", mklualib_curses_redrawwin}, + {"scroll", mklualib_curses_scroll}, + {"scrollok", mklualib_curses_scrollok}, + {"touchline", mklualib_curses_touchline}, + {"touchwin", mklualib_curses_touchwin}, + {"untouchwin", mklualib_curses_untouchwin}, + {"addch", mklualib_curses_waddch}, + {"addnstr", mklualib_curses_waddnstr}, + {"addstr", mklualib_curses_waddstr}, + {"attron", mklualib_curses_wattron}, + {"attroff", mklualib_curses_wattroff}, + {"attrset", mklualib_curses_wattrset}, + {"attr_get", mklualib_curses_wattr_get}, + {"attr_on", mklualib_curses_wattr_on}, + {"attr_off", mklualib_curses_wattr_off}, + {"attr_set", mklualib_curses_wattr_set}, + {"bkgd", mklualib_curses_wbkgd}, + {"bkgdset", mklualib_curses_wbkgdset}, + {"border", mklualib_curses_wborder}, + {"chgat", mklualib_curses_wchgat}, + {"clear", mklualib_curses_wclear}, + {"clrtobot", mklualib_curses_wclrtobot}, + {"clrtoeol", mklualib_curses_wclrtoeol}, + {"color_set", mklualib_curses_wcolor_set}, + {"cursyncup", mklualib_curses_wcursyncup}, + {"delch", mklualib_curses_wdelch}, + {"deleteln", mklualib_curses_wdeleteln}, + {"echochar", mklualib_curses_wechochar}, + {"erase", mklualib_curses_werase}, + {"getch", mklualib_curses_wgetch}, + {"getnstr", mklualib_curses_wgetnstr}, + {"hline", mklualib_curses_whline}, + {"inch", mklualib_curses_winch}, + {"innstr", mklualib_curses_winnstr}, + {"insch", mklualib_curses_winsch}, + {"insdelln", mklualib_curses_winsdelln}, + {"insertln", mklualib_curses_winsertln}, + {"insnstr", mklualib_curses_winsnstr}, + {"insstr", mklualib_curses_winsstr}, + {"instr", mklualib_curses_winstr}, + {"move", mklualib_curses_wmove}, + {"noutrefresh", mklualib_curses_wnoutrefresh}, + {"redrawln", mklualib_curses_wredrawln}, + {"refresh", mklualib_curses_wrefresh}, + {"scrl", mklualib_curses_wscrl}, + {"setscrreg", mklualib_curses_wsetscrreg}, + {"standout", mklualib_curses_wstandout}, + {"standend", mklualib_curses_wstandend}, + {"syncdown", mklualib_curses_wsyncdown}, + {"syncup", mklualib_curses_wsyncup}, + {"timeout", mklualib_curses_wtimeout}, + {"touchln", mklualib_curses_wtouchln}, + {"vline", mklualib_curses_wvline}, + {"enclose", mklualib_curses_wenclose}, + {"mouse_trafo", mklualib_curses_wmouse_trafo}, + {0, 0} +}; + +void mklualib_create_curses_window(lua_State* mklualib_lua_state) +{ + luaL_newmetatable(mklualib_lua_state, MKLUALIB_META_CURSES_WINDOW); + lua_pushliteral(mklualib_lua_state, "__index"); + lua_pushvalue(mklualib_lua_state, -2); + lua_rawset(mklualib_lua_state, -3); + luaL_register(mklualib_lua_state, 0, mklualib_curses_window_lib); +} + +const luaL_reg mklualib_curses_screen_lib[] = { + {"delscreen", mklualib_curses_delscreen}, + {"set_term", mklualib_curses_set_term}, + {"__tostring", mklualib_curses_screen___tostring}, + {"__gc", mklualib_curses_screen___gc}, + {0, 0} +}; + +void mklualib_create_curses_screen(lua_State* mklualib_lua_state) +{ + luaL_newmetatable(mklualib_lua_state, MKLUALIB_META_CURSES_SCREEN); + lua_pushliteral(mklualib_lua_state, "__index"); + lua_pushvalue(mklualib_lua_state, -2); + lua_rawset(mklualib_lua_state, -3); + luaL_register(mklualib_lua_state, 0, mklualib_curses_screen_lib); +} + +int luaopen_curses(lua_State* mklualib_lua_state) +{ + mklualib_create_curses_window(mklualib_lua_state); + mklualib_create_curses_screen(mklualib_lua_state); + luaL_register(mklualib_lua_state, MKLUALIB_MODULE_CURSES, mklualib_curses_lib); + mklualib_regnumbers(mklualib_lua_state, mklualib_curses_lib_nums); + return 1; +} + diff --git a/contrib/luacurses/src/src/luacurses.c b/contrib/luacurses/src/src/luacurses.c new file mode 100644 index 000000000..0cbd2fe6a --- /dev/null +++ b/contrib/luacurses/src/src/luacurses.c @@ -0,0 +1,137 @@ + +#include + +#include +#include +#include + +#include +#include "luacurses.h" + +SCREEN* luacurses_toscreen(lua_State* L, int index) +{ + SCREEN** pscreen = (SCREEN**) luaL_checkudata(L, index, MKLUALIB_META_CURSES_SCREEN); + if (!pscreen) luaL_argerror(L, index, "bad screen"); + if (!*pscreen) luaL_error(L, "attempt to use invalid screen"); + return *pscreen; +} + +SCREEN** luacurses_newscreen(lua_State* L) +{ + SCREEN** pscreen = (SCREEN**) lua_newuserdata(L, sizeof(SCREEN*)); + *pscreen = 0; + luaL_getmetatable(L, MKLUALIB_META_CURSES_SCREEN); + lua_setmetatable(L, -2); + return pscreen; +} + +void luacurses_regscreen(lua_State* L, const char* name, SCREEN* userdata) +{ + lua_pushstring(L, name); + SCREEN** pscreen = luacurses_newscreen(L); + *pscreen = userdata; + lua_settable(L, -3); +} + +WINDOW* luacurses_towindow(lua_State* L, int index) +{ + WINDOW** pwindow = (WINDOW**) luaL_checkudata(L, index, MKLUALIB_META_CURSES_WINDOW); + if (!pwindow) luaL_argerror(L, index, "bad window"); + if (!*pwindow) luaL_error(L, "attempt to use invalid window"); + return *pwindow; +} + +WINDOW** luacurses_newwindow(lua_State* L) +{ + WINDOW** pwindow = (WINDOW**) lua_newuserdata(L, sizeof(WINDOW*)); + *pwindow = 0; + luaL_getmetatable(L, MKLUALIB_META_CURSES_WINDOW); + lua_setmetatable(L, -2); + return pwindow; +} + +void luacurses_regwindow(lua_State* L, const char* name, WINDOW* userdata) +{ + lua_pushstring(L, name); + WINDOW** pwindow = luacurses_newwindow(L); + *pwindow = userdata; + lua_settable(L, -3); +} + +FILE* tofile(lua_State* L, int index) +{ + FILE** pf = (FILE**) luaL_checkudata(L, index, MKLUALIB_META_CURSES_FILE); + if (!pf) luaL_argerror(L, index, "bad file"); + if (!*pf) luaL_error(L, "attempt to use invalid file"); + return *pf; +} + +FILE** newfile(lua_State* L) +{ + FILE** pf = (FILE**) lua_newuserdata(L, sizeof(FILE*)); + *pf = 0; + luaL_getmetatable(L, MKLUALIB_META_CURSES_FILE); + lua_setmetatable(L, -2); + return pf; +} + +void luacurses_regfile(lua_State* L, const char* name, FILE* f) +{ + lua_pushstring(L, name); + FILE** pf = newfile(L); + *pf = f; + lua_settable(L, -3); +} + +char* luacurses_wgetnstr(WINDOW* w, int n) +{ + char* s = (char*) malloc(n + 1); + wgetnstr(w, s, n); + return s; +} + +char* luacurses_window_tostring(WINDOW* w) +{ + char* buf = (char*) malloc(64); + sprintf(buf, "window %p", w); + return buf; +} + +char* luacurses_screen_tostring(SCREEN* s) +{ + char* buf = (char*) malloc(64); + sprintf(buf, "screen %p", s); + return buf; +} + +bool luacurses_getmouse(short* id, int* x, int* y, int* z, mmask_t* bstate) +{ + MEVENT e; + int res = getmouse(&e); + + *id = e.id; + *x = e.x; + *y = e.y; + *z = e.z; + *bstate = e.bstate; + return (res == OK); +} + +bool luacurses_ungetmouse (short id, int x, int y, int z, mmask_t bstate) +{ + MEVENT e; + e.id = id; + e.x = x; + e.y = y; + e.z = z; + e.bstate = bstate; + return (ungetmouse(&e) == OK); +} + +mmask_t luacurses_addmousemask(mmask_t m) +{ + mmask_t old; + mousemask(m, &old); + return mousemask(old | m, 0); +} + diff --git a/contrib/luacurses/src/src/luacurses.h b/contrib/luacurses/src/src/luacurses.h new file mode 100644 index 000000000..2dc426c93 --- /dev/null +++ b/contrib/luacurses/src/src/luacurses.h @@ -0,0 +1,38 @@ + +#include + +#define MKLUALIB_META_CURSES_SCREEN "SCREEN*" + +SCREEN* luacurses_toscreen(lua_State* L, int index); +SCREEN** luacurses_newscreen(lua_State* L); +void luacurses_regscreen(lua_State* L, const char* name, SCREEN* userdata); + +#define MKLUALIB_META_CURSES_WINDOW "WINDOW*" + +WINDOW* luacurses_towindow(lua_State* L, int index); +WINDOW** luacurses_newwindow(lua_State* L); +void luacurses_regwindow(lua_State* L, const char* name, WINDOW* userdata); + +#define MKLUALIB_META_CURSES_FILE "FILE*" + +FILE* tofile(lua_State* L, int index); +FILE** newfile(lua_State* L); +void luacurses_regfile(lua_State* L, const char* name, FILE* f); + +char* luacurses_wgetnstr(WINDOW* w, int n); +char* luacurses_wgetstr(WINDOW* w); + +#define luacurses_mvwgetnstr(w, y, x, n) (wmove(w, y, x) == ERR ? 0 : luacurses_wgetnstr(w, n)) +#define luacurses_getnstr(n) luacurses_wgetnstr(stdscr, n) +#define luacurses_mvgetnstr(y, x, n) luacurses_mvwgetnstr(stdscr, y, x, n) + +char* luacurses_window_tostring(WINDOW* w); +char* luacurses_screen_tostring(SCREEN* s); + +#define luacurses_window_free(w) {delwin(w); w = 0;} +#define luacurses_screen_free(s) {delscreen(s); s = 0;} + +bool luacurses_getmouse(short* id, int* x, int* y, int* z, mmask_t* bstate); +bool luacurses_ungetmouse (short id, int x, int y, int z, mmask_t bstate); +mmask_t luacurses_addmousemask(mmask_t m); + diff --git a/contrib/luacurses/src/test/filter.lua b/contrib/luacurses/src/test/filter.lua new file mode 100644 index 000000000..f8f6ef582 --- /dev/null +++ b/contrib/luacurses/src/test/filter.lua @@ -0,0 +1,49 @@ + +require("curses"); + +function read_cmd() + curses.attron(curses.A_BOLD); + curses.addstr("Command: "); + curses.attron(underline); + local s = ""; + while (true) do + local c = string.char(curses.getch()); + if (c == '\n') then break; end + s = s .. c; + end + curses.attroff(underline); + curses.attroff(curses.A_BOLD); + curses.addch("\n"); + + return s; +end + + +curses.filter(); +curses.initscr(); +curses.cbreak(); +curses.keypad(curses.stdscr(), TRUE); + +if (curses.has_colors()) then + curses.start_color(); + curses.init_pair(1, curses.COLOR_CYAN, curses.COLOR_BLACK); + underline = curses.COLOR_PAIR(1); +else + underline = curses.A_UNDERLINE; +end + +while (true) do + local s = read_cmd(); + if (s == "exit") then break; end + curses.reset_shell_mode(); + io.write("\n"); + io.flush(io.stdout); + os.execute(s); + curses.reset_prog_mode(); + curses.touchwin(curses.stdscr()); + curses.erase(); + curses.refresh(); +end + +curses.endwin(); + diff --git a/contrib/luacurses/src/test/getnstr.lua b/contrib/luacurses/src/test/getnstr.lua new file mode 100644 index 000000000..172365ea9 --- /dev/null +++ b/contrib/luacurses/src/test/getnstr.lua @@ -0,0 +1,12 @@ + +require("curses"); + +curses.initscr(); + +curses.keypad(curses.stdscr(), true); +s = curses.mvgetnstr(10, 10, 10); +curses.addstr(s); +curses.getch(); + +curses.endwin(); + diff --git a/contrib/luacurses/src/test/getyx.lua b/contrib/luacurses/src/test/getyx.lua new file mode 100644 index 000000000..4600236bb --- /dev/null +++ b/contrib/luacurses/src/test/getyx.lua @@ -0,0 +1,13 @@ + +require("curses"); + +curses.initscr(); +while (true) do + local s = curses.getnstr(1000); + curses.addstr(s); + curses.addstr(":" .. table.concat({curses.getyx(curses.stdscr())}, ' ') .. "\n"); + if (s == "exit") then break; end +end + +curses.endwin(); + diff --git a/contrib/luacurses/src/test/hello.lua b/contrib/luacurses/src/test/hello.lua new file mode 100644 index 000000000..6a1d28a21 --- /dev/null +++ b/contrib/luacurses/src/test/hello.lua @@ -0,0 +1,20 @@ + +require("curses"); + +function show_message(message) + local width = string.len(message) + 6; + win = curses.newwin(5, width, (curses.LINES() - 5) / 2, (curses.COLS() - width) / 2); + win:box('|', '-'); + win:mvaddstr(2, 3, message); + win:getch(); + win:delwin(); +end + +curses.initscr(); +curses.cbreak(); +curses.mvaddstr((curses.LINES() - 5) / 2, (curses.COLS() - 10) / 2, "Hit any key"); +curses.getch(); +show_message("Hello, World!") + +curses.endwin(); + diff --git a/contrib/luacurses/src/test/mouse.lua b/contrib/luacurses/src/test/mouse.lua new file mode 100644 index 000000000..0129cd8c4 --- /dev/null +++ b/contrib/luacurses/src/test/mouse.lua @@ -0,0 +1,54 @@ + +require("curses"); + +function show_message(m) + local width = string.len(m) + 6; + local win = curses.newwin(5, width, (lines - 5) / 2, (cols - width) / 2); + win:keypad(true); + win:attron(curses.COLOR_PAIR(curses.COLOR_RED)); + win:box('|', '-', '+'); + win:mvaddstr(2, 3, m); + win:refresh(); + win:getch(); + win:delwin(); +end + +curses.initscr(); +curses.start_color(); +curses.init_pair(curses.COLOR_BLUE, curses.COLOR_BLUE, curses.COLOR_WHITE); +curses.init_pair(curses.COLOR_RED, curses.COLOR_RED, curses.COLOR_WHITE); +curses.cbreak(); +curses.noecho(); +curses.keypad(curses.stdscr(), true); + +lines = curses.LINES(); +cols = curses.COLS(); + +mmasks = +{ + curses.BUTTON1_CLICKED, + curses.BUTTON2_CLICKED, + curses.BUTTON3_CLICKED, + curses.BUTTON4_CLICKED +}; + +table.foreachi(mmasks, function(_i, _m) curses.addmousemask(_m) end); +curses.attron(curses.COLOR_PAIR(curses.COLOR_BLUE)); +curses.attron(curses.A_BOLD); +curses.mvaddstr((lines - 5) / 2, (cols - 10) / 2, "click"); + +curses.refresh(); +while(true) do + local c = curses.getch(); + if (c == curses.KEY_MOUSE) then + local r, id, x, y, z, bstate = curses.getmouse(); + if (r) then + show_message("id = " .. id .. ", x = " .. x .. ", y = " .. y .. ", z = " .. z .. ", bstate = " .. + string.format("0x%x", bstate)); + end + break; + end +end + +curses.endwin(); + diff --git a/contrib/luacurses/src/test/pair.lua b/contrib/luacurses/src/test/pair.lua new file mode 100644 index 000000000..f26980061 --- /dev/null +++ b/contrib/luacurses/src/test/pair.lua @@ -0,0 +1,18 @@ + +require("curses"); + +curses.initscr(); + +curses.start_color(); +curses.init_pair(1, curses.COLOR_BLUE, curses.COLOR_YELLOW); +curses.init_pair(2, curses.COLOR_CYAN, curses.COLOR_RED); + +for i = 1, 2 do + local r, f, b = curses.pair_content(i); + curses.attrset(curses.COLOR_PAIR(i)); + curses.addstr(f .. ", " .. b .. "\n"); +end + +curses.getch(); +curses.endwin(); + diff --git a/contrib/luacurses/src/test/rain.lua b/contrib/luacurses/src/test/rain.lua new file mode 100644 index 000000000..35e469102 --- /dev/null +++ b/contrib/luacurses/src/test/rain.lua @@ -0,0 +1,89 @@ + +require("curses"); + +curses.initscr(); +curses.nl(); +curses.noecho(); + + +if (curses.has_colors()) then + curses.start_color(); + curses.init_pair(1, curses.COLOR_BLUE, curses.COLOR_BLACK); + curses.init_pair(2, curses.COLOR_CYAN, curses.COLOR_BLACK); +end + +curses.curs_set(0); +curses.timeout(0); + +math.randomseed(os.time()); + +lines = curses.LINES(); +cols = curses.COLS(); + +xpos = {}; +ypos = {}; +r = lines - 4; +c = cols - 4; +for i = 0, 4 do + xpos[i] = c * math.random() + 2; + ypos[i] = r * math.random() + 2; +end + +function dec(i, max) + if (curses.has_colors()) then + local z = 3 * math.random(); + local c = curses.COLOR_PAIR(z); + curses.attrset(c); + if (math.floor(z) > 0) then + curses.attron(curses.A_BOLD); + end + end + + if (i > 0) then return i - 1; + else return max; + end +end + +i = 0; +while(true) do + x = c * math.random() + 2; + y = r * math.random() + 2; + + curses.mvaddstr(y, x, "."); + + curses.mvaddstr(ypos[i], xpos[i], "o"); + + i = dec(i, 4); + curses.mvaddstr(ypos[i], xpos[i], "O"); + + i = dec(i, 4); + curses.mvaddstr(ypos[i] - 1, xpos[i], "-"); + curses.mvaddstr(ypos[i], xpos[i] - 1, "|.|"); + curses.mvaddstr(ypos[i] + 1, xpos[i], "-"); + + i = dec(i, 4); + curses.mvaddstr(ypos[i] - 2, xpos[i], "-"); + curses.mvaddstr(ypos[i] - 1, xpos[i] - 1, "/ \\"); + curses.mvaddstr(ypos[i], xpos[i] - 2, "| O |"); + curses.mvaddstr(ypos[i] + 1, xpos[i] - 1, "\\ /"); + curses.mvaddstr(ypos[i] + 2, xpos[i], "-"); + + i = dec(i, 4); + curses.mvaddstr(ypos[i] - 2, xpos[i], " "); + curses.mvaddstr(ypos[i] - 1, xpos[i] - 1, " "); + curses.mvaddstr(ypos[i], xpos[i] - 2, " "); + curses.mvaddstr(ypos[i] + 1, xpos[i] - 1, " "); + curses.mvaddstr(ypos[i] + 2, xpos[i], " "); + + + xpos[i] = x; + ypos[i] = y; + + local ch = curses.getch(); + if (ch == string.byte('q', 1)) or (ch == string.byte('Q', 1)) then break; end + curses.refresh(); + curses.napms(50); +end + +curses.endwin(); + -- 2.11.0