# curses.c

    /*************************************************************************
     * Library: lcurses - Lua 5.1 interface to the curses library            *
     *                                                                       *
     * (c) Reuben Thomas <rrt@sc3d.org> 2009-2012                            *
     * (c) Tiago Dionizio <tiago.dionizio AT gmail.com> 2004-2007            *
     *                                                                       *
     * Permission is hereby granted, free of charge, to any person obtaining *
     * a copy of this software and associated documentation files (the       *
     * "Software"), to deal in the Software without restriction, including   *
     * without limitation the rights to use, copy, modify, merge, publish,   *
     * distribute, sublicense, and/or sell copies of the Software, and to    *
     * permit persons to whom the Software is furnished to do so, subject to *
     * the following conditions:                                             *
     *                                                                       *
     * The above copyright notice and this permission notice shall be        *
     * included in all copies or substantial portions of the Software.       *
     *                                                                       *
     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       *
     * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    *
     * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*
     * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  *
     * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  *
     * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     *
     * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                *
     ************************************************************************/

    #include <config.h>

    #include <stdlib.h>
    #include <string.h>
    #include <lua.h>
    #include <lauxlib.h>
    #include "lua52compat.h"
    #if HAVE_NCURSESW_CURSES_H
    #  include <ncursesw/curses.h>
    #elif HAVE_NCURSESW_H
    #  include <ncursesw.h>
    #elif HAVE_NCURSES_CURSES_H
    #  include <ncurses/curses.h>
    #elif HAVE_NCURSES_H
    #  include <ncurses.h>
    #elif HAVE_CURSES_H
    #  include <curses.h>
    #else
    #  error "SysV or X/Open-compatible Curses header file required"
    #endif
    #include <term.h>

    /* The extra indirection to these macros is required so that if the
       arguments are themselves macros, they will get expanded too.  */
    #define LCURSES__SPLICE(_s, _t)	_s##_t
    #define LCURSES_SPLICE(_s, _t)	LCURSES__SPLICE(_s, _t)

    #define LCURSES__STR(_s)	#_s
    #define LCURSES_STR(_s)		LCURSES__STR(_s)

    /* The +1 is to step over the leading '_' that is required to prevent
       premature expansion of MENTRY arguments if we didn't add it.  */
    #define LCURSES__STR_1(_s)	(#_s + 1)
    #define LCURSES_STR_1(_s)	LCURSES__STR_1(_s)

    /* strlcpy() implementation for non-BSD based Unices.
       strlcpy() is a safer less error-prone replacement for strncpy(). */
    #include "strlcpy.c"

    /*
    ** =======================================================
    ** defines
    ** =======================================================
    */
    static const char *STDSCR_REGISTRY     = "curses:stdscr";
    static const char *WINDOWMETA          = "curses:window";
    static const char *CHSTRMETA           = "curses:chstr";
    static const char *RIPOFF_TABLE        = "curses:ripoffline";

    #define B(v) ((((int) (v)) == OK))

    /* ======================================================= */

    #define LC_NUMBER(v)                        \
        static int C ## v(lua_State *L)         \
        {                                       \
            lua_pushinteger(L, v());            \
            return 1;                           \
        }

    #define LC_NUMBER2(n,v)                     \
        static int n(lua_State *L)              \
        {                                       \
            lua_pushinteger(L, v);              \
            return 1;                           \
        }

    /* ======================================================= */

    #define LC_STRING(v)                        \
        static int C ## v(lua_State *L)         \
        {                                       \
            lua_pushstring(L, v());             \
            return 1;                           \
        }

    #define LC_STRING2(n,v)                     \
        static int n(lua_State *L)              \
        {                                       \
            lua_pushstring(L, v);               \
            return 1;                           \
        }

    /* ======================================================= */

    #define LC_BOOL(v)                          \
        static int C ## v(lua_State *L)         \
        {                                       \
            lua_pushboolean(L, v());            \
            return 1;                           \
        }

    /* ======================================================= */

    #define LC_BOOLOK(v)                        \
        static int C ## v(lua_State *L)         \
        {                                       \
            lua_pushboolean(L, B(v()));         \
            return 1;                           \
        }

    /* ======================================================= */

    #define LCW_BOOLOK(n)                       \
        static int W ## n(lua_State *L)         \
        {                                       \
            WINDOW *w = checkwin(L, 1);         \
            lua_pushboolean(L, B(n(w)));        \
            return 1;                           \
        }

    #define LCW_BOOLOK2(n,v)                    \
        static int n(lua_State *L)              \
        {                                       \
            WINDOW *w = checkwin(L, 1);         \
            lua_pushboolean(L, B(v(w)));        \
            return 1;                           \
        }

    /*
    ** =======================================================
    ** privates
    ** =======================================================
    */
    static void lc_newwin(lua_State *L, WINDOW *nw)
    {
        if (nw)
        {
            WINDOW **w = lua_newuserdata(L, sizeof(WINDOW*));
            luaL_getmetatable(L, WINDOWMETA);
            lua_setmetatable(L, -2);
            *w = nw;
        }
        else
        {
            lua_pushliteral(L, "failed to create window");
            lua_error(L);
        }
    }

    static WINDOW **lc_getwin(lua_State *L, int offset)
    {
        WINDOW **w = (WINDOW**)luaL_checkudata(L, offset, WINDOWMETA);
        if (w == NULL) luaL_argerror(L, offset, "bad curses window");
        return w;
    }

    static WINDOW *checkwin(lua_State *L, int offset)
    {
        WINDOW **w = lc_getwin(L, offset);
        if (*w == NULL) luaL_argerror(L, offset, "attempt to use closed curses window");
        return *w;
    }

    static int W__tostring(lua_State *L)
    {
        WINDOW **w = lc_getwin(L, 1);
        char buff[34];
        if (*w == NULL)
            strcpy(buff, "closed");
        else
            sprintf(buff, "%p", lua_touserdata(L, 1));
        lua_pushfstring(L, "curses window (%s)", buff);
        return 1;
    }

    /*
    ** =======================================================
    ** chtype handling
    ** =======================================================
    */
    static chtype checkch(lua_State *L, int offset)
    {
        if (lua_type(L, offset) == LUA_TNUMBER)
            return luaL_checknumber(L, offset);
        if (lua_type(L, offset) == LUA_TSTRING)
            return *lua_tostring(L, offset);

        luaL_typerror(L, offset, "chtype");
        /* never executes */
        return 0;
    }

    static chtype optch(lua_State *L, int offset, chtype def)
    {
        if (lua_isnoneornil(L, offset))
            return def;
        return checkch(L, offset);
    }

    /****c* classes/chstr
     * FUNCTION
     *   Line drawing buffer.
     *
     * SEE ALSO
     *   curses.new_chstr
     ****/

    typedef struct
    {
        unsigned int len;
        chtype str[1];
    } chstr;
    #define CHSTR_SIZE(len) (sizeof(chstr) + len * sizeof(chtype))

    /* create new chstr object and leave it in the lua stack */
    static chstr* chstr_new(lua_State *L, int len)
    {
        if (len < 1)
        {
            lua_pushliteral(L, "invalid chstr length");
            lua_error(L);
        }
        {
            chstr *cs = lua_newuserdata(L, CHSTR_SIZE(len));
            luaL_getmetatable(L, CHSTRMETA);
            lua_setmetatable(L, -2);
            cs->len = len;
            return cs;
        }
    }

    /* get chstr from lua (convert if needed) */
    static chstr* checkchstr(lua_State *L, int offset)
    {
        chstr *cs = (chstr*)luaL_checkudata(L, offset, CHSTRMETA);
        if (cs) return cs;

        luaL_argerror(L, offset, "bad curses chstr");
        return NULL;
    }

    /****f* curses/curses.new_chstr
     * FUNCTION
     *   Create a new line drawing buffer instance.
     *
     * SEE ALSO
     *   chstr
     ****/
    static int Cnew_chstr(lua_State *L)
    {
        int len = luaL_checkint(L, 1);
        chstr* ncs = chstr_new(L, len);
        memset(ncs->str, ' ', len*sizeof(chtype));
        return 1;
    }

    /* change the contents of the chstr */
    static int chstr_set_str(lua_State *L)
    {
        chstr *cs = checkchstr(L, 1);
        int offset = luaL_checkint(L, 2);
        const char *str = luaL_checkstring(L, 3);
        int len = lua_strlen(L, 3);
        int attr = luaL_optnumber(L, 4, A_NORMAL);
        int rep = luaL_optint(L, 5, 1);
        int i;

        if (offset < 0)
            return 0;

        while (rep-- > 0 && offset <= (int)cs->len)
        {
            if (offset + len - 1 > (int)cs->len)
                len = cs->len - offset + 1;

            for (i = 0; i < len; ++i)
                cs->str[offset + i] = str[i] | attr;
            offset += len;
        }

        return 0;
    }

    /****m* chstr/set_ch
     * FUNCTION
     *   Set a character in the buffer.
     *
     * SYNOPSIS
     *   chstr:set_ch(offset, char, attribute [, repeat])
     *
     * EXAMPLE
     *   Set the buffer with 'a's where the first one is capitalized
     *   and has bold.
     *       size = 10
     *       str = curses.new_chstr(10)
     *       str:set_ch(0, 'A', curses.A_BOLD)
     *       str:set_ch(1, 'a', curses.A_NORMAL, size - 1)
     ****/
    static int chstr_set_ch(lua_State *L)
    {
        chstr* cs = checkchstr(L, 1);
        int offset = luaL_checkint(L, 2);
        chtype ch = checkch(L, 3);
        int attr = luaL_optnumber(L, 4, A_NORMAL);
        int rep = luaL_optint(L, 5, 1);

        while (rep-- > 0)
        {
            if (offset < 0 || offset >= (int) cs->len)
                return 0;

            cs->str[offset] = ch | attr;

            ++offset;
        }
        return 0;
    }

    /* get information from the chstr */
    static int chstr_get(lua_State *L)
    {
        chstr* cs = checkchstr(L, 1);
        int offset = luaL_checkint(L, 2);
        chtype ch;

        if (offset < 0 || offset >= (int) cs->len)
            return 0;

        ch = cs->str[offset];

        lua_pushinteger(L, ch & A_CHARTEXT);
        lua_pushinteger(L, ch & A_ATTRIBUTES);
        lua_pushinteger(L, ch & A_COLOR);
        return 3;
    }

    /* retrieve chstr length */
    static int chstr_len(lua_State *L)
    {
        chstr *cs = checkchstr(L, 1);
        lua_pushinteger(L, cs->len);
        return 1;
    }

    /* duplicate chstr */
    static int chstr_dup(lua_State *L)
    {
        chstr *cs = checkchstr(L, 1);
        chstr *ncs = chstr_new(L, cs->len);

        memcpy(ncs->str, cs->str, CHSTR_SIZE(cs->len));
        return 1;
    }

    /*
    ** =======================================================
    ** initscr
    ** =======================================================
    */

    #define CCR(n, v)                       \
        lua_pushstring(L, n);               \
        lua_pushinteger(L, v);              \
        lua_settable(L, lua_upvalueindex(1));

    #define CC(s)       CCR(#s, s)
    #define CF(i)       CCR(LCURSES_STR(LCURSES_SPLICE(KEY_F, i)), KEY_F(i))

    /*
    ** these values may be fixed only after initialization, so this is
    ** called from Cinitscr, after the curses driver is initialized
    **
    ** curses table is kept at upvalue position 1, in case the global
    ** name is changed by the user or even in the registration phase by
    ** the developer
    **
    ** some of these values are not constant so need to register
    ** them directly instead of using a table
    */
    static void register_curses_constants(lua_State *L)
    {
        /* colors */
        CC(COLOR_BLACK)     CC(COLOR_RED)       CC(COLOR_GREEN)
        CC(COLOR_YELLOW)    CC(COLOR_BLUE)      CC(COLOR_MAGENTA)
        CC(COLOR_CYAN)      CC(COLOR_WHITE)

        /* alternate character set */
        CC(ACS_BLOCK)       CC(ACS_BOARD)

        CC(ACS_BTEE)        CC(ACS_TTEE)
        CC(ACS_LTEE)        CC(ACS_RTEE)
        CC(ACS_LLCORNER)    CC(ACS_LRCORNER)
        CC(ACS_URCORNER)    CC(ACS_ULCORNER)

        CC(ACS_LARROW)      CC(ACS_RARROW)
        CC(ACS_UARROW)      CC(ACS_DARROW)

        CC(ACS_HLINE)       CC(ACS_VLINE)

        CC(ACS_BULLET)      CC(ACS_CKBOARD)     CC(ACS_LANTERN)
        CC(ACS_DEGREE)      CC(ACS_DIAMOND)

        CC(ACS_PLMINUS)     CC(ACS_PLUS)
        CC(ACS_S1)          CC(ACS_S9)

        /* attributes */
        CC(A_NORMAL)        CC(A_STANDOUT)      CC(A_UNDERLINE)
        CC(A_REVERSE)       CC(A_BLINK)         CC(A_DIM)
        CC(A_BOLD)          CC(A_PROTECT)       CC(A_INVIS)
        CC(A_ALTCHARSET)    CC(A_CHARTEXT)
        CC(A_ATTRIBUTES)

        /* key functions */
        CC(KEY_BREAK)       CC(KEY_DOWN)        CC(KEY_UP)
        CC(KEY_LEFT)        CC(KEY_RIGHT)       CC(KEY_HOME)
        CC(KEY_BACKSPACE)

        CC(KEY_DL)          CC(KEY_IL)          CC(KEY_DC)
        CC(KEY_IC)          CC(KEY_EIC)         CC(KEY_CLEAR)
        CC(KEY_EOS)         CC(KEY_EOL)         CC(KEY_SF)
        CC(KEY_SR)          CC(KEY_NPAGE)       CC(KEY_PPAGE)
        CC(KEY_STAB)        CC(KEY_CTAB)        CC(KEY_CATAB)
        CC(KEY_ENTER)       CC(KEY_SRESET)      CC(KEY_RESET)
        CC(KEY_PRINT)       CC(KEY_LL)          CC(KEY_A1)
        CC(KEY_A3)          CC(KEY_B2)          CC(KEY_C1)
        CC(KEY_C3)          CC(KEY_BTAB)        CC(KEY_BEG)
        CC(KEY_CANCEL)      CC(KEY_CLOSE)       CC(KEY_COMMAND)
        CC(KEY_COPY)        CC(KEY_CREATE)      CC(KEY_END)
        CC(KEY_EXIT)        CC(KEY_FIND)        CC(KEY_HELP)
        CC(KEY_MARK)        CC(KEY_MESSAGE)     CC(KEY_MOUSE)
        CC(KEY_MOVE)        CC(KEY_NEXT)        CC(KEY_OPEN)
        CC(KEY_OPTIONS)     CC(KEY_PREVIOUS)    CC(KEY_REDO)
        CC(KEY_REFERENCE)   CC(KEY_REFRESH)     CC(KEY_REPLACE)
        CC(KEY_RESIZE)      CC(KEY_RESTART)     CC(KEY_RESUME)
        CC(KEY_SAVE)        CC(KEY_SBEG)        CC(KEY_SCANCEL)
        CC(KEY_SCOMMAND)    CC(KEY_SCOPY)       CC(KEY_SCREATE)
        CC(KEY_SDC)         CC(KEY_SDL)         CC(KEY_SELECT)
        CC(KEY_SEND)        CC(KEY_SEOL)        CC(KEY_SEXIT)
        CC(KEY_SFIND)       CC(KEY_SHELP)       CC(KEY_SHOME)
        CC(KEY_SIC)         CC(KEY_SLEFT)       CC(KEY_SMESSAGE)
        CC(KEY_SMOVE)       CC(KEY_SNEXT)       CC(KEY_SOPTIONS)
        CC(KEY_SPREVIOUS)   CC(KEY_SPRINT)      CC(KEY_SREDO)
        CC(KEY_SREPLACE)    CC(KEY_SRIGHT)      CC(KEY_SRSUME)
        CC(KEY_SSAVE)       CC(KEY_SSUSPEND)    CC(KEY_SUNDO)
        CC(KEY_SUSPEND)     CC(KEY_UNDO)

        /* KEY_Fx  0 <= x <= 63 */
        CC(KEY_F0)
        CF(1)  CF(2)  CF(3)  CF(4)  CF(5)  CF(6)  CF(7)  CF(8)
        CF(9)  CF(10) CF(11) CF(12) CF(13) CF(14) CF(15) CF(16)
        CF(17) CF(18) CF(19) CF(20) CF(21) CF(22) CF(23) CF(24)
        CF(25) CF(26) CF(27) CF(28) CF(29) CF(30) CF(21) CF(32)
        CF(33) CF(34) CF(35) CF(36) CF(37) CF(38) CF(39) CF(40)
        CF(41) CF(42) CF(43) CF(44) CF(45) CF(46) CF(47) CF(48)
        CF(49) CF(50) CF(51) CF(52) CF(53) CF(54) CF(55) CF(56)
        CF(57) CF(58) CF(59) CF(60) CF(61) CF(62) CF(63)
    }

    /*
    ** make sure screen is restored (and cleared) at exit
    ** (for the situations where program is aborted without a
    ** proper cleanup)
    */
    static void cleanup(void)
    {
        if (!isendwin())
        {
            wclear(stdscr);
            wrefresh(stdscr);
            endwin();
        }
    }

    static int Cinitscr(lua_State *L)
    {
        WINDOW *w;

        /* initialize curses */
        w = initscr();

        /* no longer used, so clean it up */
        lua_pushstring(L, RIPOFF_TABLE);
        lua_pushnil(L);
        lua_settable(L, LUA_REGISTRYINDEX);

        /* failed to initialize */
        if (w == NULL)
            return 0;

        /* return stdscr - main window */
        lc_newwin(L, w);

        /* save main window on registry */
        lua_pushstring(L, STDSCR_REGISTRY);
        lua_pushvalue(L, -2);
        lua_rawset(L, LUA_REGISTRYINDEX);

        /* setup curses constants - curses.xxx numbers */
        register_curses_constants(L);

        /* install cleanup handler to help in debugging and screen trashing */
        atexit(cleanup);

        return 1;
    }

    /* FIXME: Avoid cast to void. */
    static int Cendwin(lua_State *L)
    {
        (void) L;
        endwin();
        return 0;
    }

    LC_BOOL(isendwin)

    static int Cstdscr(lua_State *L)
    {
        lua_pushstring(L, STDSCR_REGISTRY);
        lua_rawget(L, LUA_REGISTRYINDEX);
        return 1;
    }

    LC_NUMBER2(Ccols, COLS)
    LC_NUMBER2(Clines, LINES)

    /*
    ** =======================================================
    ** color
    ** =======================================================
    */

    LC_BOOLOK(start_color)
    LC_BOOL(has_colors)
    LC_BOOLOK(use_default_colors)

    static int Cinit_pair(lua_State *L)
    {
        short pair = luaL_checkint(L, 1);
        short f = luaL_checkint(L, 2);
        short b = luaL_checkint(L, 3);

        lua_pushboolean(L, B(init_pair(pair, f, b)));
        return 1;
    }

    static int Cpair_content(lua_State *L)
    {
        short pair = luaL_checkint(L, 1);
        short f;
        short b;
        int ret = pair_content(pair, &f, &b);

        if (ret == ERR)
            return 0;

        lua_pushinteger(L, f);
        lua_pushinteger(L, b);
        return 2;
    }

    LC_NUMBER2(Ccolors, COLORS)
    LC_NUMBER2(Ccolor_pairs, COLOR_PAIRS)

    static int Ccolor_pair(lua_State *L)
    {
        int n = luaL_checkint(L, 1);
        lua_pushinteger(L, COLOR_PAIR(n));
        return 1;
    }

    /*
    ** =======================================================
    ** termattrs
    ** =======================================================
    */

    LC_NUMBER(baudrate)
    LC_NUMBER(erasechar)
    LC_BOOL(has_ic)
    LC_BOOL(has_il)
    LC_NUMBER(killchar)

    static int Ctermattrs(lua_State *L)
    {
        if (lua_gettop(L) < 1)
            lua_pushinteger(L, termattrs());
        else
        {
            int a = luaL_checkint(L, 1);
            lua_pushboolean(L, termattrs() & a);
        }
        return 1;
    }

    LC_STRING(termname)
    LC_STRING(longname)

    /*
    ** =======================================================
    ** kernel
    ** =======================================================
    */

    /* there is no easy way to implement this... */
    static lua_State *rip_L = NULL;
    static int ripoffline_cb(WINDOW* w, int cols)
    {
        static int line = 0;
        int top = lua_gettop(rip_L);

        /* better be safe */
        if (!lua_checkstack(rip_L, 5))
            return 0;

        /* get the table from the registry */
        lua_pushstring(rip_L, RIPOFF_TABLE);
        lua_gettable(rip_L, LUA_REGISTRYINDEX);

        /* get user callback function */
        if (lua_isnil(rip_L, -1)) {
            lua_pop(rip_L, 1);
            return 0;
        }

        lua_rawgeti(rip_L, -1, ++line); /* function to be called */
        lc_newwin(rip_L, w);            /* create window object */
        lua_pushinteger(rip_L, cols);   /* push number of columns */

        lua_pcall(rip_L, 2,  0, 0);     /* call the lua function */

        lua_settop(rip_L, top);
        return 1;
    }

    static int Cripoffline(lua_State *L)
    {
        static int rip = 0;
        int top_line = lua_toboolean(L, 1);

        if (!lua_isfunction(L, 2))
        {
            lua_pushliteral(L, "invalid callback passed as second parameter");
            lua_error(L);
        }

        /* need to save the lua state somewhere... */
        rip_L = L;

        /* get the table where we are going to save the callbacks */
        lua_pushstring(L, RIPOFF_TABLE);
        lua_gettable(L, LUA_REGISTRYINDEX);

        if (lua_isnil(L, -1))
        {
            lua_pop(L, 1);
            lua_newtable(L);

            lua_pushstring(L, RIPOFF_TABLE);
            lua_pushvalue(L, -2);
            lua_settable(L, LUA_REGISTRYINDEX);
        }

        /* save function callback in registry table */
        lua_pushvalue(L, 2);
        lua_rawseti(L, -2, ++rip);

        /* and tell curses we are going to take the line */
        lua_pushboolean(L, B(ripoffline(top_line ? 1 : -1, ripoffline_cb)));
        return 1;
    }

    static int Ccurs_set(lua_State *L)
    {
        int vis = luaL_checkint(L, 1);
        int state = curs_set(vis);
        if (state == ERR)
            return 0;

        lua_pushinteger(L, state);
        return 1;
    }

    static int Cnapms(lua_State *L)
    {
        int ms = luaL_checkint(L, 1);
        lua_pushboolean(L, B(napms(ms)));
        return 1;
    }

    /*
    ** =======================================================
    ** resizeterm
    ** =======================================================
    */

    static int Cresizeterm(lua_State *L)
    {
        int nlines  = luaL_checkint(L, 1);
        int ncols   = luaL_checkint(L, 2);
    #if HAVE_RESIZETERM
        lua_pushboolean(L, B(resizeterm (nlines, ncols)));
        return 1;
    #else
        return luaL_error (L, "`resizeterm' is not implemented by your curses library");
    #endif
    }

    /*
    ** =======================================================
    ** beep
    ** =======================================================
    */
    LC_BOOLOK(beep)
    LC_BOOLOK(flash)

    /*
    ** =======================================================
    ** window
    ** =======================================================
    */

    static int Cnewwin(lua_State *L)
    {
        int nlines  = luaL_checkint(L, 1);
        int ncols   = luaL_checkint(L, 2);
        int begin_y = luaL_checkint(L, 3);
        int begin_x = luaL_checkint(L, 4);

        lc_newwin(L, newwin(nlines, ncols, begin_y, begin_x));
        return 1;
    }

    static int Wclose(lua_State *L)
    {
        WINDOW **w = lc_getwin(L, 1);
        if (*w != NULL && *w != stdscr)
        {
            delwin(*w);
            *w = NULL;
        }
        return 0;
    }

    static int Wmove_window(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);
        lua_pushboolean(L, B(mvwin(w, y, x)));
        return 1;
    }

    static int Wsub(lua_State *L)
    {
        WINDOW *orig = checkwin(L, 1);
        int nlines  = luaL_checkint(L, 2);
        int ncols   = luaL_checkint(L, 3);
        int begin_y = luaL_checkint(L, 4);
        int begin_x = luaL_checkint(L, 5);

        lc_newwin(L, subwin(orig, nlines, ncols, begin_y, begin_x));
        return 1;
    }

    static int Wderive(lua_State *L)
    {
        WINDOW *orig = checkwin(L, 1);
        int nlines  = luaL_checkint(L, 2);
        int ncols   = luaL_checkint(L, 3);
        int begin_y = luaL_checkint(L, 4);
        int begin_x = luaL_checkint(L, 5);

        lc_newwin(L, derwin(orig, nlines, ncols, begin_y, begin_x));
        return 1;
    }

    static int Wmove_derived(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int par_y = luaL_checkint(L, 2);
        int par_x = luaL_checkint(L, 3);
        lua_pushboolean(L, B(mvderwin(w, par_y, par_x)));
        return 1;
    }

    static int Wresize(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int height = luaL_checkint(L, 2);
        int width = luaL_checkint(L, 3);

        int c = wresize(w, height, width);
        if (c == ERR) return 0;

        lua_pushboolean(L, B(true));
        return 1;
    }

    #define LCW_WIN2(n, v)                      \
        static int n(lua_State *L)              \
        {                                       \
            WINDOW *w = checkwin(L, 1);         \
            v(w);                               \
            return 0;                           \
        }

    static int Wclone(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        lc_newwin(L, dupwin(w));
        return 1;
    }

    LCW_WIN2(Wsyncup, wsyncup)

    static int Wsyncok(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int bf = lua_toboolean(L, 2);
        lua_pushboolean(L, B(syncok(w, bf)));
        return 1;
    }

    LCW_WIN2(Wcursyncup, wcursyncup)
    LCW_WIN2(Wsyncdown, wsyncdown)

    /*
    ** =======================================================
    ** refresh
    ** =======================================================
    */
    LCW_BOOLOK2(Wrefresh, wrefresh)
    LCW_BOOLOK2(Wnoutrefresh, wnoutrefresh)
    LCW_BOOLOK(redrawwin)

    static int Wredrawln(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int beg_line = luaL_checkint(L, 2);
        int num_lines = luaL_checkint(L, 3);
        lua_pushboolean(L, B(wredrawln(w, beg_line, num_lines)));
        return 1;
    }

    LC_BOOLOK(doupdate)

    /*
    ** =======================================================
    ** move
    ** =======================================================
    */

    static int Wmove(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);
        lua_pushboolean(L, B(wmove(w, y, x)));
        return 1;
    }

    /*
    ** =======================================================
    ** scroll
    ** =======================================================
    */

    static int Wscrl(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int n = luaL_checkint(L, 2);
        lua_pushboolean(L, B(wscrl(w, n)));
        return 1;
    }

    /*
    ** =======================================================
    ** touch
    ** =======================================================
    */

    static int Wtouch(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int changed;
        if (lua_isnoneornil(L, 2))
            changed = TRUE;
        else
            changed = lua_toboolean(L, 2);

        if (changed)
            lua_pushboolean(L, B(touchwin(w)));
        else
            lua_pushboolean(L, B(untouchwin(w)));
        return 1;
    }

    static int Wtouchline(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int n = luaL_checkint(L, 3);
        int changed;
        if (lua_isnoneornil(L, 4))
            changed = TRUE;
        else
            changed = lua_toboolean(L, 4);
        lua_pushboolean(L, B(wtouchln(w, y, n, changed)));
        return 1;
    }

    static int Wis_linetouched(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int line = luaL_checkint(L, 2);
        lua_pushboolean(L, is_linetouched(w, line));
        return 1;
    }

    static int Wis_wintouched(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        lua_pushboolean(L, is_wintouched(w));
        return 1;
    }

    /*
    ** =======================================================
    ** getyx
    ** =======================================================
    */

    #define LCW_WIN2YX(v)                       \
        static int W ## v(lua_State *L)         \
        {                                       \
            WINDOW *w = checkwin(L, 1);         \
            int y, x;                           \
            v(w, y, x);                         \
            lua_pushinteger(L, y);              \
            lua_pushinteger(L, x);              \
            return 2;                           \
        }

    LCW_WIN2YX(getyx)
    LCW_WIN2YX(getparyx)
    LCW_WIN2YX(getbegyx)
    LCW_WIN2YX(getmaxyx)

    /*
    ** =======================================================
    ** border
    ** =======================================================
    */

    static int Wborder(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        chtype ls = optch(L, 2, 0);
        chtype rs = optch(L, 3, 0);
        chtype ts = optch(L, 4, 0);
        chtype bs = optch(L, 5, 0);
        chtype tl = optch(L, 6, 0);
        chtype tr = optch(L, 7, 0);
        chtype bl = optch(L, 8, 0);
        chtype br = optch(L, 9, 0);

        lua_pushinteger(L, B(wborder(w, ls, rs, ts, bs, tl, tr, bl, br)));
        return 1;
    }

    static int Wbox(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        chtype verch = checkch(L, 2);
        chtype horch = checkch(L, 3);

        lua_pushinteger(L, B(box(w, verch, horch)));
        return 1;
    }

    static int Whline(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        chtype ch = checkch(L, 2);
        int n = luaL_checkint(L, 3);

        lua_pushboolean(L, B(whline(w, ch, n)));
        return 1;
    }

    static int Wvline(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        chtype ch = checkch(L, 2);
        int n = luaL_checkint(L, 3);

        lua_pushboolean(L, B(wvline(w, ch, n)));
        return 1;
    }

    static int Wmvhline(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);
        chtype ch = checkch(L, 4);
        int n = luaL_checkint(L, 5);

        lua_pushboolean(L, B(mvwhline(w, y, x, ch, n)));
        return 1;
    }

    static int Wmvvline(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);
        chtype ch = checkch(L, 4);
        int n = luaL_checkint(L, 5);

        lua_pushboolean(L, B(mvwvline(w, y, x, ch, n)));
        return 1;
    }

    /*
    ** =======================================================
    ** clear
    ** =======================================================
    */

    LCW_BOOLOK2(Werase, werase)
    LCW_BOOLOK2(Wclear, wclear)
    LCW_BOOLOK2(Wclrtobot, wclrtobot)
    LCW_BOOLOK2(Wclrtoeol, wclrtoeol)

    /*
    ** =======================================================
    ** slk
    ** =======================================================
    */
    static int Cslk_init(lua_State *L)
    {
        int fmt = luaL_checkint(L, 1);
        lua_pushboolean(L, B(slk_init(fmt)));
        return 1;
    }

    static int Cslk_set(lua_State *L)
    {
        int labnum = luaL_checkint(L, 1);
        const char* label = luaL_checkstring(L, 2);
        int fmt = luaL_checkint(L, 3);

        lua_pushboolean(L, B(slk_set(labnum, label, fmt)));
        return 1;
    }

    LC_BOOLOK(slk_refresh)
    LC_BOOLOK(slk_noutrefresh)

    static int Cslk_label(lua_State *L)
    {
        int labnum = luaL_checkint(L, 1);
        lua_pushstring(L, slk_label(labnum));
        return 1;
    }

    LC_BOOLOK(slk_clear)
    LC_BOOLOK(slk_restore)
    LC_BOOLOK(slk_touch)

    #define LC_ATTROK(v)                        \
        static int C ## v(lua_State *L)         \
        {                                       \
            chtype attrs = checkch(L, 1);       \
            lua_pushboolean(L, B(v(attrs)));    \
            return 1;                           \
        }

    LC_ATTROK(slk_attron)
    LC_ATTROK(slk_attroff)
    LC_ATTROK(slk_attrset)

    /*
    ** =======================================================
    ** addch
    ** =======================================================
    */

    static int Waddch(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        chtype ch = checkch(L, 2);
        lua_pushboolean(L, B(waddch(w, ch)));
        return 1;
    }

    static int Wmvaddch(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);
        chtype ch = checkch(L, 4);

        lua_pushboolean(L, B(mvwaddch(w, y, x, ch)));
        return 1;
    }

    static int Wechoch(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        chtype ch = checkch(L, 2);

        lua_pushboolean(L, B(wechochar(w, ch)));
        return 1;
    }

    /*
    ** =======================================================
    ** addchstr
    ** =======================================================
    */

    static int Waddchstr(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int n = luaL_optint(L, 3, -1);
        chstr *cs = checkchstr(L, 2);

        if (n < 0 || n > (int) cs->len)
            n = cs->len;

        lua_pushboolean(L, B(waddchnstr(w, cs->str, n)));
        return 1;
    }

    static int Wmvaddchstr(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);
        int n = luaL_optint(L, 5, -1);
        chstr *cs = checkchstr(L, 4);

        if (n < 0 || n > (int) cs->len)
            n = cs->len;

        lua_pushboolean(L, B(mvwaddchnstr(w, y, x, cs->str, n)));
        return 1;
    }

    /*
    ** =======================================================
    ** addstr
    ** =======================================================
    */

    static int Waddstr(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        const char *str = luaL_checkstring(L, 2);
        int n = luaL_optint(L, 3, -1);
        lua_pushboolean(L, B(waddnstr(w, str, n)));
        return 1;
    }

    static int Wmvaddstr(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);
        const char *str = luaL_checkstring(L, 4);
        int n = luaL_optint(L, 5, -1);
        lua_pushboolean(L, B(mvwaddnstr(w, y, x, str, n)));
        return 1;
    }

    /*
    ** =======================================================
    ** bkgd
    ** =======================================================
    */

    static int Wwbkgdset(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        chtype ch = checkch(L, 2);
        wbkgdset(w, ch);
        return 0;
    }

    static int Wwbkgd(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        chtype ch = checkch(L, 2);
        lua_pushboolean(L, B(wbkgd(w, ch)));
        return 1;
    }

    static int Wgetbkgd(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        lua_pushboolean(L, B(getbkgd(w)));
        return 1;
    }

    /*
    ** =======================================================
    ** inopts
    ** =======================================================
    */

    #define LC_TOGGLEOK(v)                                   \
        static int C ## v(lua_State *L)                      \
        {                                                    \
            if (lua_isnoneornil(L, 1) || lua_toboolean(L, 1))\
                lua_pushboolean(L, B(v()));                  \
            else                                             \
                lua_pushboolean(L, B(no ## v()));            \
            return 1;                                        \
        }

    LC_TOGGLEOK(cbreak)
    LC_TOGGLEOK(echo)
    LC_TOGGLEOK(raw)

    static int Chalfdelay(lua_State *L)
    {
        int tenths = luaL_checkint(L, 1);
        lua_pushboolean(L, B(halfdelay(tenths)));
        return 1;
    }
    #define LCW_WINBOOLOK(v)                   \
        static int W ## v(lua_State *L)        \
        {                                      \
            WINDOW *w = checkwin(L, 1);        \
            int bf = lua_toboolean(L, 2);      \
            lua_pushboolean(L, B(v(w, bf)));   \
            return 1;                          \
        }

    LCW_WINBOOLOK(intrflush)

    static int Wkeypad(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int bf = lua_isnoneornil(L, 2) ? 1 : lua_toboolean(L, 2);
        lua_pushboolean(L, B(keypad(w, bf)));
        return 1;
    }

    LCW_WINBOOLOK(meta)
    LCW_WINBOOLOK(nodelay)

    static int Wtimeout(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int delay = luaL_checkint(L, 2);
        wtimeout(w, delay);
        return 0;
    }

    static int Wnotimeout(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int bf = lua_toboolean(L, 2);
        lua_pushboolean(L, B(notimeout(w, bf)));
        return 1;
    }

    /*
    ** =======================================================
    ** outopts
    ** =======================================================
    */

    LC_TOGGLEOK(nl)
    LCW_WINBOOLOK(clearok)
    LCW_WINBOOLOK(idlok)
    LCW_WINBOOLOK(leaveok)
    LCW_WINBOOLOK(scrollok)

    static int Widcok(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int bf = lua_toboolean(L, 2);
        idcok(w, bf);
        return 0;
    }

    static int Wimmedok(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int bf = lua_toboolean(L, 2);
        immedok(w, bf);
        return 0;
    }

    static int Wwsetscrreg(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int top = luaL_checkint(L, 2);
        int bot = luaL_checkint(L, 3);
        lua_pushboolean(L, B(wsetscrreg(w, top, bot)));
        return 1;
    }

    /*
    ** =======================================================
    ** overlay
    ** =======================================================
    */

    static int Woverlay(lua_State *L)
    {
        WINDOW *srcwin = checkwin(L, 1);
        WINDOW *dstwin = checkwin(L, 2);

        lua_pushboolean(L, B(overlay(srcwin, dstwin)));
        return 1;
    }

    static int Woverwrite(lua_State *L)
    {
        WINDOW *srcwin = checkwin(L, 1);
        WINDOW *dstwin = checkwin(L, 2);

        lua_pushboolean(L, B(overwrite(srcwin, dstwin)));
        return 1;
    }

    static int Wcopywin(lua_State *L)
    {
        WINDOW *srcwin = checkwin(L, 1);
        WINDOW *dstwin = checkwin(L, 2);
        int sminrow = luaL_checkint(L, 3);
        int smincol = luaL_checkint(L, 4);
        int dminrow = luaL_checkint(L, 5);
        int dmincol = luaL_checkint(L, 6);
        int dmaxrow = luaL_checkint(L, 7);
        int dmaxcol = luaL_checkint(L, 8);
        int woverlay = lua_toboolean(L, 9);

        lua_pushboolean(L, B(copywin(srcwin, dstwin, sminrow,
            smincol, dminrow, dmincol, dmaxrow, dmaxcol, woverlay)));

        return 1;
    }

    /*
    ** =======================================================
    ** util
    ** =======================================================
    */

    static int Cunctrl(lua_State *L)
    {
        chtype c = luaL_checknumber(L, 1);
        lua_pushstring(L, unctrl(c));
        return 1;
    }

    static int Ckeyname(lua_State *L)
    {
        int c = luaL_checkint(L, 1);
        lua_pushstring(L, keyname(c));
        return 1;
    }

    static int Cdelay_output(lua_State *L)
    {
        int ms = luaL_checkint(L, 1);
        lua_pushboolean(L, B(delay_output(ms)));
        return 1;
    }

    LC_BOOL(flushinp)

    /*
    ** =======================================================
    ** delch
    ** =======================================================
    */

    LCW_BOOLOK2(Wdelch, wdelch)

    static int Wmvdelch(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);

        lua_pushboolean(L, B(mvwdelch(w, y, x)));
        return 1;
    }

    /*
    ** =======================================================
    ** deleteln
    ** =======================================================
    */

    LCW_BOOLOK2(Wdeleteln, wdeleteln)
    LCW_BOOLOK2(Winsertln, winsertln)

    static int Wwinsdelln(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int n = luaL_checkint(L, 2);
        lua_pushboolean(L, B(winsdelln(w, n)));
        return 1;
    }

    /*
    ** =======================================================
    ** getch
    ** =======================================================
    */

    static int Wgetch(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int c = wgetch(w);

        if (c == ERR) return 0;

        lua_pushinteger(L, c);
        return 1;
    }

    static int Wmvgetch(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);
        int c;

        if (wmove(w, y, x) == ERR) return 0;

        c = wgetch(w);

        if (c == ERR) return 0;

        lua_pushinteger(L, c);
        return 1;
    }

    static int Cungetch(lua_State *L)
    {
        int c = luaL_checkint(L, 1);
        lua_pushboolean(L, B(ungetch(c)));
        return 1;
    }

    /*
    ** =======================================================
    ** getstr
    ** =======================================================
    */

    static int Wgetstr(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int n = luaL_optint(L, 2, 0);
        char buf[LUAL_BUFFERSIZE];

        if (n == 0 || n >= LUAL_BUFFERSIZE) n = LUAL_BUFFERSIZE - 1;
        if (wgetnstr(w, buf, n) == ERR)
            return 0;

        lua_pushstring(L, buf);
        return 1;
    }

    static int Wmvgetstr(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);
        int n = luaL_optint(L, 4, -1);
        char buf[LUAL_BUFFERSIZE];

        if (n == 0 || n >= LUAL_BUFFERSIZE) n = LUAL_BUFFERSIZE - 1;
        if (mvwgetnstr(w, y, x, buf, n) == ERR)
            return 0;

        lua_pushstring(L, buf);
        return 1;
    }

    /*
    ** =======================================================
    ** inch
    ** =======================================================
    */

    static int Wwinch(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        lua_pushinteger(L, winch(w));
        return 1;
    }

    static int Wmvwinch(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);
        lua_pushinteger(L, mvwinch(w, y, x));
        return 1;
    }

    /*
    ** =======================================================
    ** inchstr
    ** =======================================================
    */

    static int Wwinchnstr(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int n = luaL_checkint(L, 2);
        chstr *cs = chstr_new(L, n);

        if (winchnstr(w, cs->str, n) == ERR)
            return 0;

        return 1;
    }

    static int Wmvwinchnstr(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);
        int n = luaL_checkint(L, 4);
        chstr *cs = chstr_new(L, n);

        if (mvwinchnstr(w, y, x, cs->str, n) == ERR)
            return 0;

        return 1;
    }

    /*
    ** =======================================================
    ** instr
    ** =======================================================
    */

    static int Wwinnstr(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int n = luaL_checkint(L, 2);
        char buf[LUAL_BUFFERSIZE];

        if (n >= LUAL_BUFFERSIZE) n = LUAL_BUFFERSIZE - 1;
        if (winnstr(w, buf, n) == ERR)
            return 0;

        lua_pushlstring(L, buf, n);
        return 1;
    }

    static int Wmvwinnstr(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);
        int n = luaL_checkint(L, 4);
        char buf[LUAL_BUFFERSIZE];

        if (n >= LUAL_BUFFERSIZE) n = LUAL_BUFFERSIZE - 1;
        if (mvwinnstr(w, y, x, buf, n) == ERR)
            return 0;

        lua_pushlstring(L, buf, n);
        return 1;
    }

    /*
    ** =======================================================
    ** insch
    ** =======================================================
    */

    static int Wwinsch(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        chtype ch = checkch(L, 2);
        lua_pushboolean(L, B(winsch(w, ch)));
        return 1;
    }

    static int Wmvwinsch(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);
        chtype ch = checkch(L, 4);
        lua_pushboolean(L, B(mvwinsch(w, y, x, ch)));
        return 1;
    }

    /*
    ** =======================================================
    ** insstr
    ** =======================================================
    */

    static int Wwinsstr(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        const char *str = luaL_checkstring(L, 2);
        lua_pushboolean(L, B(winsnstr(w, str, lua_strlen(L, 2))));
        return 1;
    }

    static int Wmvwinsstr(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);
        const char *str = luaL_checkstring(L, 4);
        lua_pushboolean(L, B(mvwinsnstr(w, y, x, str, lua_strlen(L, 2))));
        return 1;
    }

    static int Wwinsnstr(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        const char *str = luaL_checkstring(L, 2);
        int n = luaL_checkint(L, 3);
        lua_pushboolean(L, B(winsnstr(w, str, n)));
        return 1;
    }

    static int Wmvwinsnstr(lua_State *L)
    {
        WINDOW *w = checkwin(L, 1);
        int y = luaL_checkint(L, 2);
        int x = luaL_checkint(L, 3);
        const char *str = luaL_checkstring(L, 4);
        int n = luaL_checkint(L, 5);
        lua_pushboolean(L, B(mvwinsnstr(w, y, x, str, n)));
        return 1;
    }

    /*
    ** =======================================================
    ** pad
    ** =======================================================
    */

    static int Cnewpad(lua_State *L)
    {
        int nlines = luaL_checkint(L, 1);
        int ncols = luaL_checkint(L, 2);
        lc_newwin(L, newpad(nlines, ncols));
        return 1;
    }

    static int Wsubpad(lua_State *L)
    {
        WINDOW *orig = checkwin(L, 1);
        int nlines  = luaL_checkint(L, 2);
        int ncols   = luaL_checkint(L, 3);
        int begin_y = luaL_checkint(L, 4);
        int begin_x = luaL_checkint(L, 5);

        lc_newwin(L, subpad(orig, nlines, ncols, begin_y, begin_x));
        return 1;
    }

    static int Wprefresh(lua_State *L)
    {
        WINDOW *p = checkwin(L, 1);
        int pminrow = luaL_checkint(L, 2);
        int pmincol = luaL_checkint(L, 3);
        int sminrow = luaL_checkint(L, 4);
        int smincol = luaL_checkint(L, 5);
        int smaxrow = luaL_checkint(L, 6);
        int smaxcol = luaL_checkint(L, 7);

        lua_pushboolean(L, B(prefresh(p, pminrow, pmincol,
            sminrow, smincol, smaxrow, smaxcol)));
        return 1;
    }

    static int Wpnoutrefresh(lua_State *L)
    {
        WINDOW *p = checkwin(L, 1);
        int pminrow = luaL_checkint(L, 2);
        int pmincol = luaL_checkint(L, 3);
        int sminrow = luaL_checkint(L, 4);
        int smincol = luaL_checkint(L, 5);
        int smaxrow = luaL_checkint(L, 6);
        int smaxcol = luaL_checkint(L, 7);

        lua_pushboolean(L, B(pnoutrefresh(p, pminrow, pmincol,
            sminrow, smincol, smaxrow, smaxcol)));
        return 1;
    }

    static int Wpechochar(lua_State *L)
    {
        WINDOW *p = checkwin(L, 1);
        chtype ch = checkch(L, 2);

        lua_pushboolean(L, B(pechochar(p, ch)));
        return 1;
    }

    /*
    ** =======================================================
    ** attr
    ** =======================================================
    */

    #define LCW_WININTOK(v)                         \
        static int W ## v(lua_State *L)             \
        {                                           \
            WINDOW *w = checkwin(L, 1);             \
            int bf = luaL_checkint(L, 2);           \
            lua_pushboolean(L, B(w ## v(w, bf)));   \
            return 1;                               \
        }

    LCW_WININTOK(attroff)
    LCW_WININTOK(attron)
    LCW_WININTOK(attrset)

    LCW_BOOLOK2(Wstandend, wstandend)
    LCW_BOOLOK2(Wstandout, wstandout)

    /*
    ** =======================================================
    ** query terminfo database
    ** =======================================================
    */

    static char ti_capname[32];

    static int Ctigetflag (lua_State *L)
    {
        int res;

        strlcpy (ti_capname, luaL_checkstring (L, 1), sizeof (ti_capname));
        res = tigetflag (ti_capname);
        if (-1 == res)
            return luaL_error (L, "`%s' is not a boolean capability", ti_capname);
        else
            lua_pushboolean (L, res);
        return 1;
    }

    static int Ctigetnum (lua_State *L)
    {
        int res;

        strlcpy (ti_capname, luaL_checkstring (L, 1), sizeof (ti_capname));
        res = tigetnum (ti_capname);
        if (-2 == res)
            return luaL_error (L, "`%s' is not a numeric capability", ti_capname);
        else if (-1 == res)
            lua_pushnil (L);
        else
            lua_pushinteger(L, res);
        return 1;
    }

    static int Ctigetstr (lua_State *L)
    {
        const char *res;

        strlcpy (ti_capname, luaL_checkstring (L, 1), sizeof (ti_capname));
        res = tigetstr (ti_capname);
        if ((char *) -1 == res)
            return luaL_error (L, "`%s' is not a string capability", ti_capname);
        else if (NULL == res)
            lua_pushnil (L);
        else
            lua_pushstring(L, res);
        return 1;
    }

    /*
    ** =======================================================
    ** register functions
    ** =======================================================
    */
    /* chstr members */
    static const luaL_Reg chstrlib[] =
    {
    #define MENTRY(_f) { LCURSES_STR(_f), LCURSES_SPLICE(chstr_, _f) }
        MENTRY( len		),
        MENTRY( set_ch	),
        MENTRY( set_str	),
        MENTRY( get		),
        MENTRY( dup		),
    #undef MENTRY

        { NULL, NULL }
    };

    static const luaL_Reg windowlib[] =
    {
    #define MENTRY(_f) { LCURSES_STR_1(_f), (_f) }
        /* window */
        MENTRY( Wclose		),
        MENTRY( Wsub		),
        MENTRY( Wderive		),
        MENTRY( Wmove_window	),
        MENTRY( Wmove_derived	),
        MENTRY( Wresize		),
        MENTRY( Wclone		),
        MENTRY( Wsyncup		),
        MENTRY( Wsyncdown		),
        MENTRY( Wsyncok		),
        MENTRY( Wcursyncup		),

        /* inopts */
        MENTRY( Wintrflush	),
        MENTRY( Wkeypad	),
        MENTRY( Wmeta	),
        MENTRY( Wnodelay	),
        MENTRY( Wtimeout	),
        MENTRY( Wnotimeout	),

        /* outopts */
        MENTRY( Wclearok	),
        MENTRY( Widlok	),
        MENTRY( Wleaveok	),
        MENTRY( Wscrollok	),
        MENTRY( Widcok	),
        MENTRY( Wimmedok	),
        MENTRY( Wwsetscrreg	),

        /* pad */
        MENTRY( Wsubpad		),
        MENTRY( Wprefresh		),
        MENTRY( Wpnoutrefresh	),
        MENTRY( Wpechochar		),

        /* move */
        MENTRY( Wmove	),

        /* scroll */
        MENTRY( Wscrl	),

        /* refresh */
        MENTRY( Wrefresh		),
        MENTRY( Wnoutrefresh	),
        MENTRY( Wredrawwin		),
        MENTRY( Wredrawln		),

        /* clear */
        MENTRY( Werase	),
        MENTRY( Wclear	),
        MENTRY( Wclrtobot	),
        MENTRY( Wclrtoeol	),

        /* touch */
        MENTRY( Wtouch		),
        MENTRY( Wtouchline		),
        MENTRY( Wis_linetouched	),
        MENTRY( Wis_wintouched	),

        /* attrs */
        MENTRY( Wattroff	),
        MENTRY( Wattron	),
        MENTRY( Wattrset	),
        MENTRY( Wstandout	),
        MENTRY( Wstandend	),

        /* getch */
        MENTRY( Wgetch	),
        MENTRY( Wmvgetch	),

        /* getyx */
        MENTRY( Wgetyx	),
        MENTRY( Wgetparyx	),
        MENTRY( Wgetbegyx	),
        MENTRY( Wgetmaxyx	),

        /* border */
        MENTRY( Wborder	),
        MENTRY( Wbox	),
        MENTRY( Whline	),
        MENTRY( Wvline	),
        MENTRY( Wmvhline	),
        MENTRY( Wmvvline	),

        /* addch */
        MENTRY( Waddch	),
        MENTRY( Wmvaddch	),
        MENTRY( Wechoch	),

        /* addchstr */
        MENTRY( Waddchstr	),
        MENTRY( Wmvaddchstr	),

        /* addstr */
        MENTRY( Waddstr	),
        MENTRY( Wmvaddstr	),

        /* bkgd */
        MENTRY( Wwbkgdset	),
        MENTRY( Wwbkgd	),
        MENTRY( Wgetbkgd	),

        /* overlay */
        MENTRY( Woverlay	),
        MENTRY( Woverwrite	),
        MENTRY( Wcopywin	),

        /* delch */
        MENTRY( Wdelch	),
        MENTRY( Wmvdelch	),

        /* deleteln */
        MENTRY( Wdeleteln	),
        MENTRY( Winsertln	),
        MENTRY( Wwinsdelln	),

        /* getstr */
        MENTRY( Wgetstr	),
        MENTRY( Wmvgetstr	),

        /* inch */
        MENTRY( Wwinch		),
        MENTRY( Wmvwinch		),
        MENTRY( Wwinchnstr		),
        MENTRY( Wmvwinchnstr	),

        /* instr */
        MENTRY( Wwinnstr	),
        MENTRY( Wmvwinnstr	),

        /* insch */
        MENTRY( Wwinsch	),
        MENTRY( Wmvwinsch	),

        /* insstr */
        MENTRY( Wwinsstr	),
        MENTRY( Wwinsnstr	),
        MENTRY( Wmvwinsstr	),
        MENTRY( Wmvwinsnstr	),

        /* misc */
        MENTRY( W__tostring	),
    #undef MENTRY
        {"__gc",        Wclose  }, /* rough safety net */

        {NULL, NULL}
    };

    static const luaL_Reg curseslib[] =
    {
    #define MENTRY(_f) { LCURSES_STR_1(_f), (_f) }
        /* chstr helper function */
        MENTRY( Cnew_chstr	),

        /* initscr */
        MENTRY( Cendwin	),
        MENTRY( Cisendwin	),
        MENTRY( Cstdscr	),
        MENTRY( Ccols	),
        MENTRY( Clines	),

        /* color */
        MENTRY( Cstart_color	),
        MENTRY( Chas_colors		),
        MENTRY( Cuse_default_colors	),
        MENTRY( Cinit_pair		),
        MENTRY( Cpair_content	),
        MENTRY( Ccolors		),
        MENTRY( Ccolor_pairs	),
        MENTRY( Ccolor_pair		),

        /* termattrs */
        MENTRY( Cbaudrate	),
        MENTRY( Cerasechar	),
        MENTRY( Ckillchar	),
        MENTRY( Chas_ic	),
        MENTRY( Chas_il	),
        MENTRY( Ctermattrs	),
        MENTRY( Ctermname	),
        MENTRY( Clongname	),

        /* kernel */
        MENTRY( Cripoffline	),
        MENTRY( Cnapms	),
        MENTRY( Ccurs_set	),

        /* resize */
        MENTRY( Cresizeterm	),

        /* beep */
        MENTRY( Cbeep	),
        MENTRY( Cflash	),

        /* window */
        MENTRY( Cnewwin	),

        /* pad */
        MENTRY( Cnewpad	),

        /* refresh */
        MENTRY( Cdoupdate	),

        /* inopts */
        MENTRY( Ccbreak	),
        MENTRY( Cecho	),
        MENTRY( Craw	),
        MENTRY( Chalfdelay	),

        /* util */
        MENTRY( Cunctrl		),
        MENTRY( Ckeyname		),
        MENTRY( Cdelay_output	),
        MENTRY( Cflushinp		),

        /* getch */
        MENTRY( Cungetch	),

        /* outopts */
        MENTRY( Cnl	),

        /* query terminfo database */
        MENTRY( Ctigetflag	),
        MENTRY( Ctigetnum	),
        MENTRY( Ctigetstr	),

        /* slk */
        MENTRY( Cslk_init		),
        MENTRY( Cslk_set		),
        MENTRY( Cslk_refresh	),
        MENTRY( Cslk_noutrefresh	),
        MENTRY( Cslk_label		),
        MENTRY( Cslk_clear		),
        MENTRY( Cslk_restore	),
        MENTRY( Cslk_touch		),
        MENTRY( Cslk_attron		),
        MENTRY( Cslk_attroff	),
        MENTRY( Cslk_attrset	),
    #undef MENTRY

        /* terminator */
        {NULL, NULL}
    };

    /* Prototype to keep compiler happy. */
    LUALIB_API int luaopen_curses_c (lua_State *L);

    int luaopen_curses_c (lua_State *L)
    {
        /*
        ** create new metatable for window objects
        */
        luaL_newmetatable(L, WINDOWMETA);
        lua_pushliteral(L, "__index");
        lua_pushvalue(L, -2);               /* push metatable */
        lua_rawset(L, -3);                  /* metatable.__index = metatable */
        luaL_openlib(L, NULL, windowlib, 0);

        lua_pop(L, 1);                      /* remove metatable from stack */

        /*
        ** create new metatable for chstr objects
        */
        luaL_newmetatable(L, CHSTRMETA);
        lua_pushliteral(L, "__index");
        lua_pushvalue(L, -2);               /* push metatable */
        lua_rawset(L, -3);                  /* metatable.__index = metatable */
        luaL_openlib(L, NULL, chstrlib, 0);

        lua_pop(L, 1);                      /* remove metatable from stack */

        /*
        ** create global table with curses methods/variables/constants
        */
        luaL_register(L, "curses", curseslib);

        lua_pushstring(L, "initscr");
        lua_pushvalue(L, -2);
        lua_pushcclosure(L, Cinitscr, 1);
        lua_settable(L, -3);

        return 1;
    }

    /* Local Variables: */
    /* c-basic-offset: 4 */
    /* End:             */