/* vi:set ts=8 sts=4 sw=4:
 *
 * VIM - Vi IMproved	by Bram Moolenaar
 *
 * Lua interface by Luis Carvalho
 *
 * Do ":help uganda"  in Vim to read copying and usage conditions.
 * Do ":help credits" in Vim to see a list of people who contributed.
 * See README.txt for an overview of the Vim source code.
 */

#include <stdio.h>
#include <string.h>
#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>
#include "vim.h"

/* Only do the following when the feature is enabled.  Needed for "make
 * depend". */
#if defined(FEAT_LUA) || defined(PROTO)

#define LUAVIM_CHUNKNAME "vim chunk"
#define LUAVIM_NAME "vim"

typedef buf_T *luaV_Buffer;
typedef win_T *luaV_Window;
typedef void (*msgfunc_T)(char_u *);

static const char LUAVIM_BUFFER[] = "buffer";
static const char LUAVIM_WINDOW[] = "window";
static const char LUAVIM_FREE[] = "luaV_free";

#define luaV_getfield(L, s) \
    lua_pushlightuserdata((L), (void *)(s)); \
    lua_rawget((L), LUA_REGISTRYINDEX)
#define luaV_checksandbox(L) \
    if (sandbox) luaL_error((L), "not allowed in sandbox")
#define luaV_msg(L) luaV_msgfunc((L), (msgfunc_T) msg)
#define luaV_emsg(L) luaV_msgfunc((L), (msgfunc_T) emsg)


#ifdef DYNAMIC_LUA
/* lauxlib */
#define luaL_register dll_luaL_register
#define luaL_typerror dll_luaL_typerror
#define luaL_checklstring dll_luaL_checklstring
#define luaL_checkinteger dll_luaL_checkinteger
#define luaL_optinteger dll_luaL_optinteger
#define luaL_checktype dll_luaL_checktype
#define luaL_error dll_luaL_error
#define luaL_loadfile dll_luaL_loadfile
#define luaL_loadbuffer dll_luaL_loadbuffer
#define luaL_newstate dll_luaL_newstate
#define luaL_buffinit dll_luaL_buffinit
#define luaL_prepbuffer dll_luaL_prepbuffer
#define luaL_addlstring dll_luaL_addlstring
#define luaL_pushresult dll_luaL_pushresult
/* lua */
#define lua_close dll_lua_close
#define lua_gettop dll_lua_gettop
#define lua_settop dll_lua_settop
#define lua_pushvalue dll_lua_pushvalue
#define lua_replace dll_lua_replace
#define lua_isnumber dll_lua_isnumber
#define lua_isstring dll_lua_isstring
#define lua_type dll_lua_type
#define lua_rawequal dll_lua_rawequal
#define lua_tonumber dll_lua_tonumber
#define lua_tointeger dll_lua_tointeger
#define lua_toboolean dll_lua_toboolean
#define lua_tolstring dll_lua_tolstring
#define lua_touserdata dll_lua_touserdata
#define lua_pushnil dll_lua_pushnil
#define lua_pushnumber dll_lua_pushnumber
#define lua_pushinteger dll_lua_pushinteger
#define lua_pushlstring dll_lua_pushlstring
#define lua_pushstring dll_lua_pushstring
#define lua_pushfstring dll_lua_pushfstring
#define lua_pushcclosure dll_lua_pushcclosure
#define lua_pushboolean dll_lua_pushboolean
#define lua_pushlightuserdata dll_lua_pushlightuserdata
#define lua_getfield dll_lua_getfield
#define lua_rawget dll_lua_rawget
#define lua_createtable dll_lua_createtable
#define lua_newuserdata dll_lua_newuserdata
#define lua_getmetatable dll_lua_getmetatable
#define lua_setfield dll_lua_setfield
#define lua_rawset dll_lua_rawset
#define lua_rawseti dll_lua_rawseti
#define lua_setmetatable dll_lua_setmetatable
#define lua_call dll_lua_call
#define lua_pcall dll_lua_pcall
/* libs */
#define luaopen_base dll_luaopen_base
#define luaopen_table dll_luaopen_table
#define luaopen_string dll_luaopen_string
#define luaopen_math dll_luaopen_math
#define luaopen_os dll_luaopen_os
#define luaopen_package dll_luaopen_package
#define luaopen_debug dll_luaopen_debug

/* lauxlib */
void (*dll_luaL_register) (lua_State *L, const char *libname, const luaL_Reg *l);
int (*dll_luaL_typerror) (lua_State *L, int narg, const char *tname);
const char *(*dll_luaL_checklstring) (lua_State *L, int numArg, size_t *l);
lua_Integer (*dll_luaL_checkinteger) (lua_State *L, int numArg);
lua_Integer (*dll_luaL_optinteger) (lua_State *L, int nArg, lua_Integer def);
void (*dll_luaL_checktype) (lua_State *L, int narg, int t);
int (*dll_luaL_error) (lua_State *L, const char *fmt, ...);
int (*dll_luaL_loadfile) (lua_State *L, const char *filename);
int (*dll_luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz, const char *name);
lua_State *(*dll_luaL_newstate) (void);
void (*dll_luaL_buffinit) (lua_State *L, luaL_Buffer *B);
char *(*dll_luaL_prepbuffer) (luaL_Buffer *B);
void (*dll_luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
void (*dll_luaL_pushresult) (luaL_Buffer *B);
/* lua */
void       (*dll_lua_close) (lua_State *L);
int (*dll_lua_gettop) (lua_State *L);
void (*dll_lua_settop) (lua_State *L, int idx);
void (*dll_lua_pushvalue) (lua_State *L, int idx);
void (*dll_lua_replace) (lua_State *L, int idx);
int (*dll_lua_isnumber) (lua_State *L, int idx);
int (*dll_lua_isstring) (lua_State *L, int idx);
int (*dll_lua_type) (lua_State *L, int idx);
int (*dll_lua_rawequal) (lua_State *L, int idx1, int idx2);
lua_Number (*dll_lua_tonumber) (lua_State *L, int idx);
lua_Integer (*dll_lua_tointeger) (lua_State *L, int idx);
int (*dll_lua_toboolean) (lua_State *L, int idx);
const char *(*dll_lua_tolstring) (lua_State *L, int idx, size_t *len);
void *(*dll_lua_touserdata) (lua_State *L, int idx);
void (*dll_lua_pushnil) (lua_State *L);
void (*dll_lua_pushnumber) (lua_State *L, lua_Number n);
void (*dll_lua_pushinteger) (lua_State *L, lua_Integer n);
void (*dll_lua_pushlstring) (lua_State *L, const char *s, size_t l);
void (*dll_lua_pushstring) (lua_State *L, const char *s);
const char *(*dll_lua_pushfstring) (lua_State *L, const char *fmt, ...);
void (*dll_lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
void (*dll_lua_pushboolean) (lua_State *L, int b);
void (*dll_lua_pushlightuserdata) (lua_State *L, void *p);
void (*dll_lua_getfield) (lua_State *L, int idx, const char *k);
void (*dll_lua_rawget) (lua_State *L, int idx);
void (*dll_lua_createtable) (lua_State *L, int narr, int nrec);
void *(*dll_lua_newuserdata) (lua_State *L, size_t sz);
int (*dll_lua_getmetatable) (lua_State *L, int objindex);
void (*dll_lua_setfield) (lua_State *L, int idx, const char *k);
void (*dll_lua_rawset) (lua_State *L, int idx);
void (*dll_lua_rawseti) (lua_State *L, int idx, int n);
int (*dll_lua_setmetatable) (lua_State *L, int objindex);
void (*dll_lua_call) (lua_State *L, int nargs, int nresults);
int (*dll_lua_pcall) (lua_State *L, int nargs, int nresults, int errfunc);
/* libs */
int (*dll_luaopen_base) (lua_State *L);
int (*dll_luaopen_table) (lua_State *L);
int (*dll_luaopen_string) (lua_State *L);
int (*dll_luaopen_math) (lua_State *L);
int (*dll_luaopen_os) (lua_State *L);
int (*dll_luaopen_package) (lua_State *L);
int (*dll_luaopen_debug) (lua_State *L);

typedef void **luaV_function;
typedef struct {
    const char *name;
    luaV_function func;
} luaV_Reg;

static const luaV_Reg luaV_dll[] = {
    /* lauxlib */
    {"luaL_register", (luaV_function) &dll_luaL_register},
    {"luaL_typerror", (luaV_function) &dll_luaL_typerror},
    {"luaL_checklstring", (luaV_function) &dll_luaL_checklstring},
    {"luaL_checkinteger", (luaV_function) &dll_luaL_checkinteger},
    {"luaL_optinteger", (luaV_function) &dll_luaL_optinteger},
    {"luaL_checktype", (luaV_function) &dll_luaL_checktype},
    {"luaL_error", (luaV_function) &dll_luaL_error},
    {"luaL_loadfile", (luaV_function) &dll_luaL_loadfile},
    {"luaL_loadbuffer", (luaV_function) &dll_luaL_loadbuffer},
    {"luaL_newstate", (luaV_function) &dll_luaL_newstate},
    {"luaL_buffinit", (luaV_function) &dll_luaL_buffinit},
    {"luaL_prepbuffer", (luaV_function) &dll_luaL_prepbuffer},
    {"luaL_addlstring", (luaV_function) &dll_luaL_addlstring},
    {"luaL_pushresult", (luaV_function) &dll_luaL_pushresult},
    /* lua */
    {"lua_close", (luaV_function) &dll_lua_close},
    {"lua_gettop", (luaV_function) &dll_lua_gettop},
    {"lua_settop", (luaV_function) &dll_lua_settop},
    {"lua_pushvalue", (luaV_function) &dll_lua_pushvalue},
    {"lua_replace", (luaV_function) &dll_lua_replace},
    {"lua_isnumber", (luaV_function) &dll_lua_isnumber},
    {"lua_isstring", (luaV_function) &dll_lua_isstring},
    {"lua_type", (luaV_function) &dll_lua_type},
    {"lua_rawequal", (luaV_function) &dll_lua_rawequal},
    {"lua_tonumber", (luaV_function) &dll_lua_tonumber},
    {"lua_tointeger", (luaV_function) &dll_lua_tointeger},
    {"lua_toboolean", (luaV_function) &dll_lua_toboolean},
    {"lua_tolstring", (luaV_function) &dll_lua_tolstring},
    {"lua_touserdata", (luaV_function) &dll_lua_touserdata},
    {"lua_pushnil", (luaV_function) &dll_lua_pushnil},
    {"lua_pushnumber", (luaV_function) &dll_lua_pushnumber},
    {"lua_pushinteger", (luaV_function) &dll_lua_pushinteger},
    {"lua_pushlstring", (luaV_function) &dll_lua_pushlstring},
    {"lua_pushstring", (luaV_function) &dll_lua_pushstring},
    {"lua_pushfstring", (luaV_function) &dll_lua_pushfstring},
    {"lua_pushcclosure", (luaV_function) &dll_lua_pushcclosure},
    {"lua_pushboolean", (luaV_function) &dll_lua_pushboolean},
    {"lua_pushlightuserdata", (luaV_function) &dll_lua_pushlightuserdata},
    {"lua_getfield", (luaV_function) &dll_lua_getfield},
    {"lua_rawget", (luaV_function) &dll_lua_rawget},
    {"lua_createtable", (luaV_function) &dll_lua_createtable},
    {"lua_newuserdata", (luaV_function) &dll_lua_newuserdata},
    {"lua_getmetatable", (luaV_function) &dll_lua_getmetatable},
    {"lua_setfield", (luaV_function) &dll_lua_setfield},
    {"lua_rawset", (luaV_function) &dll_lua_rawset},
    {"lua_rawseti", (luaV_function) &dll_lua_rawseti},
    {"lua_setmetatable", (luaV_function) &dll_lua_setmetatable},
    {"lua_call", (luaV_function) &dll_lua_call},
    {"lua_pcall", (luaV_function) &dll_lua_pcall},
    /* libs */
    {"luaopen_base", (luaV_function) &dll_luaopen_base},
    {"luaopen_table", (luaV_function) &dll_luaopen_table},
    {"luaopen_string", (luaV_function) &dll_luaopen_string},
    {"luaopen_math", (luaV_function) &dll_luaopen_math},
    {"luaopen_os", (luaV_function) &dll_luaopen_os},
    {"luaopen_package", (luaV_function) &dll_luaopen_package},
    {"luaopen_debug", (luaV_function) &dll_luaopen_debug},
    {NULL, NULL}
};

static HINSTANCE hinstLua = 0;

static void end_dynamic_lua (void) {
    if (hinstLua) {
        FreeLibrary(hinstLua);
        hinstLua = 0;
    }
}

static int lua_link_init (char *libname, int verbose) {
    const luaV_Reg *reg;
    if (hinstLua) return OK;
    hinstLua = LoadLibrary(libname);
    if (!hinstLua) {
        if (verbose) EMSG2(_(e_loadlib), libname);
        return FAIL;
    }
    for (reg = luaV_dll; reg->func; reg++) {
	if ((*reg->func = GetProcAddress(hinstLua, reg->name)) == NULL) {
            FreeLibrary(hinstLua);
            hinstLua = 0;
            if (verbose) EMSG2(_(e_loadfunc), reg->name);
            return FAIL;
        }
    }
    return OK;
}

int lua_enabled (int verbose) {
    return lua_link_init(DYNAMIC_LUA_DLL, verbose) == OK;
}

#endif /* DYNAMIC_LUA */


/* =======   Internal   ======= */

static void luaV_newmetatable (lua_State *L, const char *tname) {
    lua_newtable(L);
    lua_pushlightuserdata(L, (void *) tname);
    lua_pushvalue(L, -2);
    lua_rawset(L, LUA_REGISTRYINDEX);
}

static void *luaV_toudata (lua_State *L, int ud, const char *tname) {
    void *p = lua_touserdata(L, ud);
    if (p != NULL) { /* value is userdata? */
        if (lua_getmetatable(L, ud)) { /* does it have a metatable? */
            luaV_getfield(L, tname); /* get metatable */
            if (lua_rawequal(L, -1, -2)) { /* MTs match? */
                lua_pop(L, 2); /* MTs */
                return p;
            }
        }
    }
    return NULL;
}

static void *luaV_checkudata (lua_State *L, int ud, const char *tname) {
    void *p = luaV_toudata(L, ud, tname);
    if (p == NULL) luaL_typerror(L, ud, tname);
    return p;
}

static void luaV_pushtypval (lua_State *L, typval_T *tv) {
    if (tv == NULL) luaL_error(L, "null type");
    switch (tv->v_type) {
        case VAR_STRING:
            lua_pushstring(L, (char *) tv->vval.v_string);
            break;
        case VAR_NUMBER:
            lua_pushinteger(L, (int) tv->vval.v_number);
            break;
#ifdef FEAT_FLOAT
        case VAR_FLOAT:
            lua_pushnumber(L, (lua_Number) tv->vval.v_float);
            break;
#endif
        case VAR_LIST: {
            list_T *l = tv->vval.v_list;
            if (l != NULL) {
                /* check cache */
                lua_pushlightuserdata(L, (void *) l);
                lua_rawget(L, LUA_ENVIRONINDEX);
                if (lua_isnil(L, -1)) { /* not interned? */
                    listitem_T *li;
                    int n = 0;
                    lua_pop(L, 1); /* nil */
                    lua_newtable(L);
                    lua_pushlightuserdata(L, (void *) l);
                    lua_pushvalue(L, -2);
                    lua_rawset(L, LUA_ENVIRONINDEX);
                    for (li = l->lv_first; li != NULL; li = li->li_next) {
                        luaV_pushtypval(L, &li->li_tv);
                        lua_rawseti(L, -2, ++n);
                    }
                }
            }
            else lua_pushnil(L);
            break;
        }
        case VAR_DICT: {
            dict_T *d = tv->vval.v_dict;
            if (d != NULL) {
                /* check cache */
                lua_pushlightuserdata(L, (void *) d);
                lua_rawget(L, LUA_ENVIRONINDEX);
                if (lua_isnil(L, -1)) { /* not interned? */
                    hashtab_T *ht = &d->dv_hashtab;
                    hashitem_T *hi;
                    int n = ht->ht_used; /* remaining items */
                    lua_pop(L, 1); /* nil */
                    lua_newtable(L);
                    lua_pushlightuserdata(L, (void *) d);
                    lua_pushvalue(L, -2);
                    lua_rawset(L, LUA_ENVIRONINDEX);
                    for (hi = ht->ht_array; n > 0; hi++) {
                        if (!HASHITEM_EMPTY(hi)) {
                            dictitem_T *di = dict_lookup(hi);
                            luaV_pushtypval(L, &di->di_tv);
                            lua_setfield(L, -2, (char *) hi->hi_key);
                            n--;
                        }
                    }
                }
            }
            else lua_pushnil(L);
            break;
        }
        default:
            luaL_error(L, "invalid type");
    }
}

/* similar to luaL_addlstring, but replaces \0 with \n if toline and
 * \n with \0 otherwise */
static void luaV_addlstring (luaL_Buffer *b, const char *s, size_t l,
        int toline) {
    while (l--) {
        if (*s == '\0' && toline) luaL_addchar(b, '\n');
        else if (*s == '\n' && !toline) luaL_addchar(b, '\0');
        else luaL_addchar(b, *s);
        s++;
    }
}

static void luaV_pushline (lua_State *L, buf_T *buf, linenr_T n) {
    const char *s = (const char *) ml_get_buf(buf, n, FALSE);
    luaL_Buffer b;
    luaL_buffinit(L, &b);
    luaV_addlstring(&b, s, strlen(s), 0);
    luaL_pushresult(&b);
}

static char_u *luaV_toline (lua_State *L, int pos) {
    size_t l;
    const char *s = lua_tolstring(L, pos, &l);
    luaL_Buffer b;
    luaL_buffinit(L, &b);
    luaV_addlstring(&b, s, l, 1);
    luaL_pushresult(&b);
    return (char_u *) lua_tostring(L, -1);
}

/* pops a string s from the top of the stack and calls mf(t) for pieces t of
 * s separated by newlines */
static void luaV_msgfunc (lua_State *L, msgfunc_T mf) {
    luaL_Buffer b;
    size_t l;
    const char *p, *s = lua_tolstring(L, -1, &l);
    luaL_buffinit(L, &b);
    luaV_addlstring(&b, s, l, 0);
    luaL_pushresult(&b);
    /* break string */
    p = s = lua_tolstring(L, -1, &l);
    while (l--) {
        if (*p++ == '\0') { /* break? */
            mf((char_u *) s);
            s = p;
        }
    }
    mf((char_u *) s);
    lua_pop(L, 2); /* original and modified strings */
}


/* =======   Buffer type   ======= */

static luaV_Buffer *luaV_newbuffer (lua_State *L, buf_T *buf) {
    luaV_Buffer *b = (luaV_Buffer *) lua_newuserdata(L, sizeof(luaV_Buffer));
    *b = buf;
    lua_pushlightuserdata(L, (void *) buf);
    lua_pushvalue(L, -2);
    lua_rawset(L, LUA_ENVIRONINDEX); /* env[buf] = udata */
    /* to avoid GC, store as key in env */
    lua_pushvalue(L, -1);
    lua_pushboolean(L, 1);
    lua_rawset(L, LUA_ENVIRONINDEX); /* env[udata] = true */
    /* set metatable */
    luaV_getfield(L, LUAVIM_BUFFER);
    lua_setmetatable(L, -2);
    return b;
}

static luaV_Buffer *luaV_pushbuffer (lua_State *L, buf_T *buf) {
    luaV_Buffer *b = NULL;
    if (buf == NULL)
        lua_pushnil(L);
    else {
        lua_pushlightuserdata(L, (void *) buf);
        lua_rawget(L, LUA_ENVIRONINDEX);
        if (lua_isnil(L, -1)) { /* not interned? */
            lua_pop(L, 1);
            b = luaV_newbuffer(L, buf);
        }
        else b = (luaV_Buffer *) lua_touserdata(L, -1);
    }
    return b;
}

/* Buffer metamethods */

static int luaV_buffer_tostring (lua_State *L) {
    lua_pushfstring(L, "%s: %p", LUAVIM_BUFFER, lua_touserdata(L, 1));
    return 1;
}

static int luaV_buffer_len (lua_State *L) {
    luaV_Buffer *b = lua_touserdata(L, 1);
    lua_pushinteger(L, (*b)->b_ml.ml_line_count);
    return 1;
}

static int luaV_buffer_call (lua_State *L) {
    luaV_Buffer *b = (luaV_Buffer *) lua_touserdata(L, 1);
    lua_settop(L, 1);
    set_curbuf(*b, DOBUF_SPLIT);
    return 1;
}

static int luaV_buffer_index (lua_State *L) {
    luaV_Buffer *b = (luaV_Buffer *) lua_touserdata(L, 1);
    linenr_T n = (linenr_T) lua_tointeger(L, 2);
    if (n > 0 && n <= (*b)->b_ml.ml_line_count)
        luaV_pushline(L, *b, n);
    else if (lua_isstring(L, 2)) {
        const char *s = lua_tostring(L, 2);
        if (strncmp(s, "name", 4) == 0)
            lua_pushstring(L, (char *) (*b)->b_sfname);
        else if (strncmp(s, "fname", 5) == 0)
            lua_pushstring(L, (char *) (*b)->b_ffname);
        else if (strncmp(s, "number", 6) == 0)
            lua_pushinteger(L, (*b)->b_fnum);
        /* methods */
        else if (strncmp(s,   "insert", 6) == 0
                || strncmp(s, "next", 4) == 0
                || strncmp(s, "previous", 8) == 0
                || strncmp(s, "isvalid", 7) == 0) {
            lua_getmetatable(L, 1);
            lua_getfield(L, -1, s);
        }
        else lua_pushnil(L);
    }
    else lua_pushnil(L);
    return 1;
}

static int luaV_buffer_newindex (lua_State *L) {
    luaV_Buffer *b = (luaV_Buffer *) lua_touserdata(L, 1);
    linenr_T n = (linenr_T) luaL_checkinteger(L, 2);
#ifdef HAVE_SANDBOX
    luaV_checksandbox(L);
#endif
    if (n < 1 || n > (*b)->b_ml.ml_line_count)
        luaL_error(L, "invalid line number");
    if (lua_isnil(L, 3)) { /* delete line */
        buf_T *buf = curbuf;
        curbuf = *b;
        if (u_savedel(n, 1L) == FAIL) {
            curbuf = buf;
            luaL_error(L, "cannot save undo information");
        }
        else if (ml_delete(n, FALSE) == FAIL) {
            curbuf = buf;
            luaL_error(L, "cannot delete line");
        }
        else {
            deleted_lines_mark(n, 1L);
            if (*b == curwin->w_buffer) { /* fix cursor in current window? */
                if (curwin->w_cursor.lnum >= n) {
                    if (curwin->w_cursor.lnum > n) {
                        curwin->w_cursor.lnum -= 1;
                        check_cursor_col();
                    }
                    else check_cursor();
                    changed_cline_bef_curs();
                }
                invalidate_botline();
            }
        }
        curbuf = buf;
    }
    else if (lua_isstring(L, 3)) { /* update line */
        buf_T *buf = curbuf;
        curbuf = *b;
        if (u_savesub(n) == FAIL) {
            curbuf = buf;
            luaL_error(L, "cannot save undo information");
        }
        else if (ml_replace(n, luaV_toline(L, 3), TRUE) == FAIL) {
            curbuf = buf;
            luaL_error(L, "cannot replace line");
        }
        else changed_bytes(n, 0);
        curbuf = buf;
        if (*b == curwin->w_buffer)
            check_cursor_col();
    }
    else
        luaL_error(L, "wrong argument to change line");
    return 0;
}

static int luaV_buffer_insert (lua_State *L) {
    luaV_Buffer *b = luaV_checkudata(L, 1, LUAVIM_BUFFER);
    linenr_T last = (*b)->b_ml.ml_line_count;
    linenr_T n = (linenr_T) luaL_optinteger(L, 3, last);
    buf_T *buf;
    luaL_checktype(L, 2, LUA_TSTRING);
#ifdef HAVE_SANDBOX
    luaV_checksandbox(L);
#endif
    /* fix insertion line */
    if (n < 0) n = 0;
    if (n > last) n = last;
    /* insert */
    buf = curbuf;
    curbuf = *b;
    if (u_save(n, n + 1) == FAIL) {
        curbuf = buf;
        luaL_error(L, "cannot save undo information");
    }
    else if (ml_append(n, luaV_toline(L, 2), 0, FALSE) == FAIL) {
        curbuf = buf;
        luaL_error(L, "cannot insert line");
    }
    else
        appended_lines_mark(n, 1L);
    curbuf = buf;
    update_screen(VALID);
    return 0;
}

static int luaV_buffer_next (lua_State *L) {
    luaV_Buffer *b = luaV_checkudata(L, 1, LUAVIM_BUFFER);
    luaV_pushbuffer(L, (*b)->b_next);
    return 1;
}

static int luaV_buffer_previous (lua_State *L) {
    luaV_Buffer *b = luaV_checkudata(L, 1, LUAVIM_BUFFER);
    luaV_pushbuffer(L, (*b)->b_prev);
    return 1;
}

static int luaV_buffer_isvalid (lua_State *L) {
    luaV_Buffer *b = luaV_checkudata(L, 1, LUAVIM_BUFFER);
    lua_pushlightuserdata(L, (void *) (*b));
    lua_rawget(L, LUA_ENVIRONINDEX);
    lua_pushboolean(L, !lua_isnil(L, -1));
    return 1;
}

static const luaL_Reg luaV_Buffer_mt[] = {
    {"__tostring", luaV_buffer_tostring},
    {"__len", luaV_buffer_len},
    {"__call", luaV_buffer_call},
    {"__index", luaV_buffer_index},
    {"__newindex", luaV_buffer_newindex},
    {"insert", luaV_buffer_insert},
    {"next", luaV_buffer_next},
    {"previous", luaV_buffer_previous},
    {"isvalid", luaV_buffer_isvalid},
    {NULL, NULL}
};


/* =======   Window type   ======= */

static luaV_Window *luaV_newwindow (lua_State *L, win_T *win) {
    luaV_Window *w = (luaV_Window *) lua_newuserdata(L, sizeof(luaV_Window));
    *w = win;
    lua_pushlightuserdata(L, (void *) win);
    lua_pushvalue(L, -2);
    lua_rawset(L, LUA_ENVIRONINDEX); /* env[win] = udata */
    /* to avoid GC, store as key in env */
    lua_pushvalue(L, -1);
    lua_pushboolean(L, 1);
    lua_rawset(L, LUA_ENVIRONINDEX); /* env[udata] = true */
    /* set metatable */
    luaV_getfield(L, LUAVIM_WINDOW);
    lua_setmetatable(L, -2);
    return w;
}

static luaV_Window *luaV_pushwindow (lua_State *L, win_T *win) {
    luaV_Window *w = NULL;
    if (win == NULL)
        lua_pushnil(L);
    else {
        lua_pushlightuserdata(L, (void *) win);
        lua_rawget(L, LUA_ENVIRONINDEX);
        if (lua_isnil(L, -1)) { /* not interned? */
            lua_pop(L, 1);
            w = luaV_newwindow(L, win);
        }
        else w = (luaV_Window *) lua_touserdata(L, -1);
    }
    return w;
}

/* Window metamethods */

static int luaV_window_tostring (lua_State *L) {
    lua_pushfstring(L, "%s: %p", LUAVIM_WINDOW, lua_touserdata(L, 1));
    return 1;
}

static int luaV_window_call (lua_State *L) {
    luaV_Window *w = (luaV_Window *) lua_touserdata(L, 1);
    lua_settop(L, 1);
    win_goto(*w);
    return 1;
}

static int luaV_window_index (lua_State *L) {
    luaV_Window *w = (luaV_Window *) lua_touserdata(L, 1);
    const char *s = luaL_checkstring(L, 2);
    if (strncmp(s, "buffer", 6) == 0)
        luaV_pushbuffer(L, (*w)->w_buffer);
    else if (strncmp(s, "line", 4) == 0)
        lua_pushinteger(L, (*w)->w_cursor.lnum);
    else if (strncmp(s, "col", 3) == 0)
        lua_pushinteger(L, (*w)->w_cursor.col + 1);
#ifdef FEAT_VERTSPLIT
    else if (strncmp(s, "width", 5) == 0)
        lua_pushinteger(L, W_WIDTH((*w)));
#endif
    else if (strncmp(s, "height", 6) == 0)
        lua_pushinteger(L, (*w)->w_height);
    /* methods */
    else if (strncmp(s,   "next", 4) == 0
            || strncmp(s, "previous", 8) == 0
            || strncmp(s, "isvalid", 7) == 0) {
        lua_getmetatable(L, 1);
        lua_getfield(L, -1, s);
    }
    else
        lua_pushnil(L);
    return 1;
}

static int luaV_window_newindex (lua_State *L) {
    luaV_Window *w = (luaV_Window *) lua_touserdata(L, 1);
    const char *s = luaL_checkstring(L, 2);
    int v = luaL_checkinteger(L, 3);
    if (strncmp(s, "line", 4) == 0) {
#ifdef HAVE_SANDBOX
        luaV_checksandbox(L);
#endif
        if (v < 1 || v > (*w)->w_buffer->b_ml.ml_line_count)
            luaL_error(L, "line out of range");
        (*w)->w_cursor.lnum = v;
        update_screen(VALID);
    }
    else if (strncmp(s, "col", 3) == 0) {
#ifdef HAVE_SANDBOX
        luaV_checksandbox(L);
#endif
        (*w)->w_cursor.col = v - 1;
        update_screen(VALID);
    }
#ifdef FEAT_VERTSPLIT
    else if (strncmp(s, "width", 5) == 0) {
        win_T *win = curwin;
#ifdef FEAT_GUI
        need_mouse_correct = TRUE;
#endif
        curwin = *w;
        win_setwidth(v);
        curwin = win;
    }
#endif
    else if (strncmp(s, "height", 6) == 0) {
        win_T *win = curwin;
#ifdef FEAT_GUI
        need_mouse_correct = TRUE;
#endif
        curwin = *w;
        win_setheight(v);
        curwin = win;
    }
    else
        luaL_error(L, "invalid window property: `%s'", s);
    return 0;
}

static int luaV_window_next (lua_State *L) {
    luaV_Window *w = luaV_checkudata(L, 1, LUAVIM_WINDOW);
    luaV_pushwindow(L, (*w)->w_next);
    return 1;
}

static int luaV_window_previous (lua_State *L) {
    luaV_Window *w = luaV_checkudata(L, 1, LUAVIM_WINDOW);
    luaV_pushwindow(L, (*w)->w_prev);
    return 1;
}

static int luaV_window_isvalid (lua_State *L) {
    luaV_Window *w = luaV_checkudata(L, 1, LUAVIM_WINDOW);
    lua_pushlightuserdata(L, (void *) (*w));
    lua_rawget(L, LUA_ENVIRONINDEX);
    lua_pushboolean(L, !lua_isnil(L, -1));
    return 1;
}

static const luaL_Reg luaV_Window_mt[] = {
    {"__tostring", luaV_window_tostring},
    {"__call", luaV_window_call},
    {"__index", luaV_window_index},
    {"__newindex", luaV_window_newindex},
    {"next", luaV_window_next},
    {"previous", luaV_window_previous},
    {"isvalid", luaV_window_isvalid},
    {NULL, NULL}
};


/* =======   Vim module   ======= */

static int luaV_print (lua_State *L) {
    int i, n = lua_gettop(L); /* nargs */
    const char *s;
    size_t l;
    luaL_Buffer b;
    luaL_buffinit(L, &b);
    lua_getglobal(L, "tostring");
    for (i = 1; i <= n; i++) {
        lua_pushvalue(L, -1); /* tostring */
        lua_pushvalue(L, i); /* arg */
        lua_call(L, 1, 1);
        s = lua_tolstring(L, -1, &l);
        if (s == NULL)
            return luaL_error(L, "cannot convert to string");
        if (i > 1) luaL_addchar(&b, ' '); /* use space instead of tab */
        luaV_addlstring(&b, s, l, 0);
        lua_pop(L, 1);
    }
    luaL_pushresult(&b);
    luaV_msg(L);
    return 0;
}

static int luaV_command (lua_State *L) {
    do_cmdline_cmd((char_u *) luaL_checkstring(L, 1));
    update_screen(VALID);
    return 0;
}

static int luaV_eval (lua_State *L) {
    typval_T *tv = eval_expr((char_u *) luaL_checkstring(L, 1), NULL);
    if (tv == NULL) luaL_error(L, "invalid expression");
    luaV_pushtypval(L, tv);
    return 1;
}

static int luaV_beep (lua_State *L) {
    vim_beep();
    return 0;
}

static int luaV_line (lua_State *L) {
    luaV_pushline(L, curbuf, curwin->w_cursor.lnum);
    return 1;
}

static int luaV_buffer (lua_State *L) {
    buf_T *buf;
    if (lua_isstring(L, 1)) { /* get by number or name? */
        if (lua_isnumber(L, 1)) { /* by number? */
            int n = lua_tointeger(L, 1);
            for (buf = firstbuf; buf != NULL; buf = buf->b_next)
                if (buf->b_fnum == n) break;
        }
        else { /* by name */
            size_t l;
            const char *s = lua_tolstring(L, 1, &l);
            for (buf = firstbuf; buf != NULL; buf = buf->b_next) {
                if (buf->b_ffname == NULL || buf->b_sfname == NULL) {
                    if (l == 0) break;
                }
                else if (strncmp(s, buf->b_ffname, l) == 0
                        || strncmp(s, buf->b_sfname, l) == 0)
                    break;
            }
        }
        if (buf == NULL) /* not found? */
            lua_pushnil(L);
        else
            luaV_pushbuffer(L, buf);
    }
    else {
        buf = (lua_toboolean(L, 1)) ? firstbuf : curbuf; /* first buffer? */
        luaV_pushbuffer(L, buf);
    }
    return 1;
}

static int luaV_window (lua_State *L) {
    win_T *win;
    if (lua_isnumber(L, 1)) { /* get by number? */
        int n = lua_tointeger(L, 1);
        for (win = firstwin; win != NULL; win = win->w_next, n--)
            if (n == 1) break;
        if (win == NULL) /* not found? */
            lua_pushnil(L);
        else
            luaV_pushwindow(L, win);
    }
    else {
        win = (lua_toboolean(L, 1)) ? firstwin : curwin; /* first window? */
        luaV_pushwindow(L, win);
    }
    return 1;
}

static int luaV_open (lua_State *L) {
    luaV_Buffer *b;
    char_u *s = NULL;
#ifdef HAVE_SANDBOX
    luaV_checksandbox(L);
#endif
    if (lua_isstring(L, 1)) s = (char_u *) lua_tostring(L, 1);
    b = luaV_pushbuffer(L, buflist_new(s, NULL, 1L, BLN_LISTED));
    return 1;
}

static int luaV_isbuffer (lua_State *L) {
    lua_pushboolean(L, luaV_toudata(L, 1, LUAVIM_BUFFER) != NULL);
    return 1;
}

static int luaV_iswindow (lua_State *L) {
    lua_pushboolean(L, luaV_toudata(L, 1, LUAVIM_WINDOW) != NULL);
    return 1;
}

/* for freeing buffer and window objects; lightuserdata as arg */
static luaV_free (lua_State *L) {
    lua_pushvalue(L, 1); /* lightudata */
    lua_rawget(L, LUA_ENVIRONINDEX);
    if (!lua_isnil(L, -1)) {
        lua_pushnil(L);
        lua_rawset(L, LUA_ENVIRONINDEX); /* env[udata] = nil */
        lua_pushnil(L);
        lua_rawset(L, LUA_ENVIRONINDEX); /* env[lightudata] = nil */
    }
    return 0;
}

static const luaL_Reg luaV_module[] = {
    {"command", luaV_command},
    {"eval", luaV_eval},
    {"beep", luaV_beep},
    {"line", luaV_line},
    {"buffer", luaV_buffer},
    {"window", luaV_window},
    {"open", luaV_open},
    {"isbuffer", luaV_isbuffer},
    {"iswindow", luaV_iswindow},
    {NULL, NULL}
};

static int luaopen_vim (lua_State *L) {
    /* set environment */
    lua_newtable(L);
    lua_newtable(L);
    lua_pushliteral(L, "v");
    lua_setfield(L, -2, "__mode");
    lua_setmetatable(L, -2);
    lua_replace(L, LUA_ENVIRONINDEX);
    /* print */
    lua_pushcfunction(L, luaV_print);
    lua_setglobal(L, "print");
    /* free */
    lua_pushlightuserdata(L, (void *) LUAVIM_FREE);
    lua_pushcfunction(L, luaV_free);
    lua_rawset(L, LUA_REGISTRYINDEX);
    /* register */
    luaV_newmetatable(L, LUAVIM_BUFFER);
    luaL_register(L, NULL, luaV_Buffer_mt);
    luaV_newmetatable(L, LUAVIM_WINDOW);
    luaL_register(L, NULL, luaV_Window_mt);
    luaL_register(L, LUAVIM_NAME, luaV_module);
    return 0;
}

static lua_State *luaV_newstate (void) {
    lua_State *L = luaL_newstate();
    const luaL_Reg luaV_core_libs[] = {
        {"", luaopen_base},
        {LUA_TABLIBNAME, luaopen_table},
        {LUA_STRLIBNAME, luaopen_string},
        {LUA_MATHLIBNAME, luaopen_math},
        {LUA_OSLIBNAME, luaopen_os}, /* restricted */
        {LUA_LOADLIBNAME, luaopen_package},
        {LUA_DBLIBNAME, luaopen_debug},
        {NULL, NULL}
    };
    const char *os_funcs[] = {
        "date", "clock", "time", "difftime", "getenv", NULL
    };
    const luaL_Reg *reg = luaV_core_libs;
    const char **s = os_funcs;
    /* core libs */
    for ( ; reg->func; reg++) {
        lua_pushcfunction(L, reg->func);
        lua_pushstring(L, reg->name);
        lua_call(L, 1, 0);
    }
    /* restricted os lib */
    lua_getglobal(L, LUA_OSLIBNAME);
    lua_newtable(L);
    for ( ; *s; s++) {
        lua_getfield(L, -2, *s);
        lua_setfield(L, -2, *s);
    }
    lua_setglobal(L, LUA_OSLIBNAME);
    lua_pop(L, 1); /* os table */
    /* vim */
    lua_pushcfunction(L, luaopen_vim);
    lua_call(L, 0, 0);
    return L;
}

static void luaV_setrange (lua_State *L, int line1, int line2) {
    lua_getglobal(L, LUAVIM_NAME);
    lua_pushinteger(L, line1);
    lua_setfield(L, -2, "firstline");
    lua_pushinteger(L, line2);
    lua_setfield(L, -2, "lastline");
    lua_pop(L, 1); /* vim table */
}


/* =======   Interface   ======= */

static lua_State *L = NULL;

static int lua_init (void) {
    if (L == NULL) {
#ifdef DYNAMIC_LUA
        if (!lua_enabled(TRUE)) {
            EMSG(_("Lua library cannot be loaded."));
            return FAIL;
        }
#endif
        L = luaV_newstate();
    }
    return OK;
}

void lua_end (void) {
    if (L != NULL) {
        lua_close(L);
        L = NULL;
#ifdef DYNAMIC_LUA
        end_dynamic_lua();
#endif
    }
}

/* ex commands */
void ex_lua (exarg_T *eap) {
    char *script;
    if (lua_init() == FAIL) return;
    script = (char *) script_get(eap, eap->arg);
    if (!eap->skip) {
        char *s = (script) ? script :  (char *) eap->arg;
        luaV_setrange(L, eap->line1, eap->line2);
        if (luaL_loadbuffer(L, s, strlen(s), LUAVIM_CHUNKNAME)
                || lua_pcall(L, 0, 0, 0))
            luaV_emsg(L);
    }
    if (script != NULL) vim_free(script);
}

void ex_luado (exarg_T *eap) {
    linenr_T l;
    const char *s = (const char *) eap->arg;
    luaL_Buffer b;
    size_t len;
    if (lua_init() == FAIL) return;
    if (u_save(eap->line1 - 1, eap->line2 + 1) == FAIL) {
        EMSG(_("cannot save undo information"));
        return;
    }
    luaV_setrange(L, eap->line1, eap->line2);
    luaL_buffinit(L, &b);
    luaL_addlstring(&b, "return function(line) ", 22); /* header */
    luaL_addlstring(&b, s, strlen(s));
    luaL_addlstring(&b, " end", 4); /* footer */
    luaL_pushresult(&b);
    s = lua_tolstring(L, -1, &len);
    if (luaL_loadbuffer(L, s, len, LUAVIM_CHUNKNAME)) {
        luaV_emsg(L);
        lua_pop(L, 1); /* function body */
        return;
    }
    lua_call(L, 0, 1);
    lua_replace(L, -2); /* function -> body */
    for (l = eap->line1; l <= eap->line2; l++) {
        lua_pushvalue(L, -1); /* function */
        luaV_pushline(L, curbuf, l); /* current line as arg */
        if (lua_pcall(L, 1, 1, 0)) {
            luaV_emsg(L);
            break;
        }
        if (lua_isstring(L, -1)) { /* update line? */
#ifdef HAVE_SANDBOX
            luaV_checksandbox(L);
#endif
            ml_replace(l, luaV_toline(L, -1), TRUE);
            changed_bytes(l, 0);
            lua_pop(L, 1); /* result from luaV_toline */
        }
        lua_pop(L, 1); /* line */
    }
    lua_pop(L, 1); /* function */
    check_cursor();
    update_screen(NOT_VALID);
}

void ex_luafile (exarg_T *eap) {
    if (lua_init() == FAIL) return;
    if (!eap->skip) {
        luaV_setrange(L, eap->line1, eap->line2);
        if (luaL_loadfile(L, (char *) eap->arg) || lua_pcall(L, 0, 0, 0))
            luaV_emsg(L);
    }
}

/* buffer */
void lua_buffer_free (buf_T *buf) {
    if (lua_init() == FAIL) return;
    luaV_getfield(L, LUAVIM_FREE);
    lua_pushlightuserdata(L, (void *) buf);
    lua_call(L, 1, 0);
}

/* window */
void lua_window_free (win_T *win) {
    if (lua_init() == FAIL) return;
    luaV_getfield(L, LUAVIM_FREE);
    lua_pushlightuserdata(L, (void *) win);
    lua_call(L, 1, 0);
}

#endif