dfhack/library/LuaWrapper.cpp

/*
https://github.com/peterix/dfhack
Copyright (c) 2009-2011 Petr Mrázek (peterix@gmail.com)

This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
damages arising from the use of this software.

Permission is granted to anyone to use this software for any
purpose, including commercial applications, and to alter it and
redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product documentation
would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and
must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source
distribution.
*/

#include "Internal.h"

#include <string>
#include <vector>
#include <map>

#include "MemAccess.h"
#include "Core.h"
#include "VersionInfo.h"
#include "tinythread.h"
// must be last due to MS stupidity
#include "DataDefs.h"
#include "DataIdentity.h"

#include "MiscUtils.h"

#include <lua.h>
#include <lauxlib.h>

using namespace DFHack;

static luaL_Reg no_functions[] = { { NULL, NULL } };

inline void lua_dup(lua_State *state) { lua_pushvalue(state, -1); }
inline void lua_swap(lua_State *state) { lua_insert(state, -2); }

#define UPVAL_TYPETABLE lua_upvalueindex(1)
#define UPVAL_METATABLE lua_upvalueindex(2)
#define UPVAL_FIELDTABLE lua_upvalueindex(3)

namespace {
    struct DFRefHeader {
        void *ptr;
    };

    inline bool is_self_contained(DFRefHeader *ptr) {
        void **pp = &ptr->ptr;
        return **(void****)pp == (pp + 1);
    }
}

static void field_error(lua_State *state, int index, const char *err, const char *mode = "read")
{
    lua_getfield(state, UPVAL_METATABLE, "__metatable");
    const char *cname = lua_tostring(state, -1);
    const char *fname = lua_tostring(state, index);
    luaL_error(state, "Cannot %s field %s.%s: %s.",
               mode, (cname ? cname : "?"), (fname ? fname : "?"), err);
}

static int push_object_internal(lua_State *state, type_identity *type, void *ptr, bool in_method = true);
static void *get_object_internal(lua_State *state, type_identity *type, int val_index, bool in_method = true);

int DFHack::PushDFObject(lua_State *state, type_identity *type, void *ptr)
{
    return push_object_internal(state, type, ptr, false);
}

void *DFHack::GetDFObject(lua_State *state, type_identity *type, int val_index)
{
    return get_object_internal(state, type, val_index, false);
}

/* Primitive identity methods */

int constructed_identity::lua_read(lua_State *state, int fname_idx, void *ptr)
{
    return push_object_internal(state, this, ptr);
}

void constructed_identity::lua_write(lua_State *state, int fname_idx, void *ptr, int val_index)
{
    field_error(state, fname_idx, "complex object", "write");
}

int enum_identity::lua_read(lua_State *state, int fname_idx, void *ptr)
{
    return base_type->lua_read(state, fname_idx, ptr);
}

void enum_identity::lua_write(lua_State *state, int fname_idx, void *ptr, int val_index)
{
    base_type->lua_write(state, fname_idx, ptr, val_index);
}

int df::number_identity_base::lua_read(lua_State *state, int fname_idx, void *ptr)
{
    lua_pushnumber(state, read(ptr));
    return 1;
}

void df::number_identity_base::lua_write(lua_State *state, int fname_idx, void *ptr, int val_index)
{
    if (!lua_isnumber(state, val_index))
        field_error(state, fname_idx, "number expected", "write");

    write(ptr, lua_tonumber(state, val_index));
}

int df::bool_identity::lua_read(lua_State *state, int fname_idx, void *ptr)
{
    lua_pushboolean(state, *(bool*)ptr);
    return 1;
}

void df::bool_identity::lua_write(lua_State *state, int fname_idx, void *ptr, int val_index)
{
    char *pb = (char*)ptr;

    if (lua_isboolean(state, val_index))
        *pb = lua_toboolean(state, val_index);
    else if (lua_isnumber(state, val_index))
        *pb = lua_tonumber(state, val_index);
    else
        field_error(state, fname_idx, "boolean or number expected", "write");
}

int df::stl_string_identity::lua_read(lua_State *state, int fname_idx, void *ptr)
{
    auto pstr = (std::string*)ptr;
    lua_pushlstring(state, pstr->data(), pstr->size());
    return 1;
}

void df::stl_string_identity::lua_write(lua_State *state, int fname_idx, void *ptr, int val_index)
{
    size_t size;
    const char *bytes = lua_tolstring(state, val_index, &size);
    if (!bytes)
        field_error(state, fname_idx, "string expected", "write");

    *(std::string*)ptr = std::string(bytes, size);
}

static int do_read_pointer(lua_State *state, int, void *ptr, type_identity *target)
{
    void *val = *(void**)ptr;

    if (val == NULL)
    {
        lua_pushnil(state);
        return 1;
    }
    else
        return push_object_internal(state, target, val);
}

int df::pointer_identity::lua_read(lua_State *state, int fname_idx, void *ptr)
{
    return do_read_pointer(state, fname_idx, ptr, target);
}

static void do_write_pointer(lua_State *state, int fname_idx, void *ptr, type_identity *target, int val_index)
{
    auto pptr = (void**)ptr;

    if (lua_isnil(state, val_index))
        *pptr = NULL;
    else
    {
        void *nval = get_object_internal(state, target, val_index);
        if (nval)
            *pptr = nval;
        else
            field_error(state, fname_idx, "incompatible pointer type", "write");
    }
}

void df::pointer_identity::lua_write(lua_State *state, int fname_idx, void *ptr, int val_index)
{
    do_write_pointer(state, fname_idx, ptr, target, val_index);
}

/* */

static int change_error(lua_State *state)
{
    luaL_error(state, "Attempt to change a read-only table.\n");
}

static void freeze_table(lua_State *state, bool leave_metatable = false, const char *name = NULL)
{
    // rv = {}; setmetatable(rv, { __index = in, __newindex = change_error, __metatable = name })
    int base = lua_gettop(state);
    lua_newtable(state);
    lua_swap(state);
    lua_setfield(state, base, "__index");
    lua_getfield(state, LUA_REGISTRYINDEX, "DFHack.ChangeError");
    lua_setfield(state, base, "__newindex");
    lua_newtable(state);
    lua_swap(state);
    lua_dup(state);
    lua_setmetatable(state, base);
    if (name)
    {
        lua_pushstring(state, name);
        lua_setfield(state, -2, "__metatable");
    }
    // result: [frozen table] [metatable]
    if (!leave_metatable)
        lua_pop(state, 1);
}

static void SaveTypeInfo(lua_State *state, void *node)
{
    lua_getfield(state, LUA_REGISTRYINDEX, "DFHack.DFTypes");
    lua_pushlightuserdata(state, node);
    lua_pushvalue(state, -3);
    lua_settable(state, -3);
    lua_pop(state, 1);
}

static bool RegisterTypeInfo(lua_State *state, void *node)
{
    lua_getfield(state, LUA_REGISTRYINDEX, "DFHack.DFTypes");
    int base = lua_gettop(state);

    lua_pushlightuserdata(state, node);
    lua_rawget(state, base);

    bool added = false;

    if (lua_isnil(state, -1))
    {
        lua_pop(state, 1);

        lua_newtable(state);
        lua_pushlightuserdata(state, node);
        lua_pushvalue(state, -2);
        lua_rawset(state, base);

        added = true;
    }

    lua_remove(state, -2);
    return added;
}

static const struct_field_info *find_field(lua_State *state, int index, const char *mode = "read")
{
    lua_pushvalue(state, index);
    lua_rawget(state, UPVAL_FIELDTABLE);

    if (!lua_islightuserdata(state, -1))
        field_error(state, index, "not found");

    void *p = lua_touserdata(state, -1);
    lua_pop(state, 1);
    return (struct_field_info*)p;
}

static int read_field(lua_State *state, const struct_field_info *field, void *ptr)
{
    switch (field->mode)
    {
        case struct_field_info::STATIC_STRING:
        {
            int len = strnlen((char*)ptr, field->count);
            lua_pushlstring(state, (char*)ptr, len);
            return 1;
        }

        case struct_field_info::PRIMITIVE:
        case struct_field_info::SUBSTRUCT:
        case struct_field_info::CONTAINER:
            return field->type->lua_read(state, 2, ptr);

        case struct_field_info::POINTER:
            return do_read_pointer(state, 2, ptr, field->type);

        case struct_field_info::STATIC_ARRAY:
        case struct_field_info::STL_VECTOR_PTR:

        case struct_field_info::END:
            return 0;
    }
}

static void write_field(lua_State *state, const struct_field_info *field, void *ptr)
{
    switch (field->mode)
    {
        case struct_field_info::STATIC_STRING:
        {
            size_t size;
            const char *str = lua_tolstring(state, -1, &size);
            if (!str)
                field_error(state, 2, "string expected", "write");
            memcpy(ptr, str, std::min(size+1, size_t(field->count)));
            return;
        }

        case struct_field_info::PRIMITIVE:
        case struct_field_info::SUBSTRUCT:
        case struct_field_info::CONTAINER:
            field->type->lua_write(state, 2, ptr, 3);
            return;

        case struct_field_info::POINTER:
            do_write_pointer(state, 2, ptr, field->type, 3);

        case struct_field_info::STATIC_ARRAY:
        case struct_field_info::STL_VECTOR_PTR:
            field_error(state, 2, "complex object", "write");

        case struct_field_info::END:
            return;
    }
}

static int meta_global_index(lua_State *state)
{
    const struct_field_info *field = find_field(state, 2);
    void *ptr = *(void**)field->offset;
    if (!ptr)
        field_error(state, 2, "global address not known");
    return read_field(state, field, ptr);
}

static int meta_global_newindex(lua_State *state)
{
    const struct_field_info *field = find_field(state, 2);
    void *ptr = *(void**)field->offset;
    if (!ptr)
        field_error(state, 2, "global address not known", "write");
    write_field(state, field, ptr);
    return 0;
}

static void IndexFields(lua_State *state, const struct_field_info *fields)
{
    int base = lua_gettop(state);
    lua_newtable(state); // read
    lua_newtable(state); // write

    for (; fields->mode != struct_field_info::END; ++fields)
    {
        switch (fields->mode)
        {
            case struct_field_info::END:
                break;

            case struct_field_info::PRIMITIVE:
            case struct_field_info::STATIC_STRING:
            case struct_field_info::POINTER:
                lua_pushstring(state,fields->name);
                lua_pushlightuserdata(state,(void*)fields);
                lua_settable(state,base+2);
                // fallthrough

            case struct_field_info::STATIC_ARRAY:
            case struct_field_info::SUBSTRUCT:
            case struct_field_info::CONTAINER:
            case struct_field_info::STL_VECTOR_PTR:
                lua_pushstring(state,fields->name);
                lua_pushlightuserdata(state,(void*)fields);
                lua_settable(state,base+1);
                break;
        }
    }
}

static void MakeFieldMetatable(lua_State *state, struct_identity *pstruct,
                               lua_CFunction reader, lua_CFunction writer)
{
    int base = lua_gettop(state);

    lua_newtable(state); // metatable
    IndexFields(state, pstruct->getFields()); // read, write

    lua_pushstring(state, pstruct->getName());
    lua_setfield(state, base+1, "__metatable");

    lua_pushlightuserdata(state, pstruct);
    lua_setfield(state, base+1, "_identity");

    lua_getfield(state, LUA_REGISTRYINDEX, "DFHack::DFTypes");
    lua_pushvalue(state, base+1);
    lua_pushvalue(state, base+2);
    lua_pushcclosure(state, reader, 3);
    lua_setfield(state, base+1, "__index");

    lua_getfield(state, LUA_REGISTRYINDEX, "DFHack::DFTypes");
    lua_pushvalue(state, base+1);
    lua_pushvalue(state, base+3);
    lua_pushcclosure(state, writer, 3);
    lua_setfield(state, base+1, "__newindex");

    // returns: [metatable readfields writefields];
}

static int push_object_internal(lua_State *state, type_identity *type, void *ptr, bool in_method)
{
    return 0;
}

static void *get_object_internal(lua_State *state, type_identity *type, int val_index, bool in_method)
{
    return NULL;
}

static void RenderTypeChildren(lua_State *state, const std::vector<compound_identity*> &children);

static void RenderType(lua_State *state, compound_identity *node)
{
    assert(node->getName());

    lua_newtable(state);
    if (!lua_checkstack(state, 20))
        return;

    int base = lua_gettop(state);

    lua_pushlightuserdata(state, node);
    lua_setfield(state, base, "_identity");

    switch (node->type())
    {
    case IDTYPE_ENUM:
        {
            enum_identity *eid = (enum_identity*)node;
            const char *const *keys = eid->getKeys();

            // For enums, set mapping between keys and values
            for (int64_t i = eid->getFirstItem(), j = 0; i <= eid->getLastItem(); i++, j++)
            {
                if (!keys[j])
                    continue;

                lua_pushinteger(state, i);
                lua_pushstring(state, keys[j]);
                lua_dup(state);
                lua_pushinteger(state, i);

                lua_settable(state, base);
                lua_settable(state, base);
            }

            if (eid->getFirstItem() <= eid->getLastItem())
            {
                lua_pushinteger(state, eid->getFirstItem());
                lua_setfield(state, base, "_first_item");

                lua_pushinteger(state, eid->getLastItem());
                lua_setfield(state, base, "_last_item");
            }

            SaveTypeInfo(state, node);
        }
        break;

    default:
        break;
    }

    RenderTypeChildren(state, node->getScopeChildren());

    assert(base == lua_gettop(state));

    if (node->type() == IDTYPE_GLOBAL)
    {
        auto gid = (global_identity*)node;

        MakeFieldMetatable(state, gid, meta_global_index, meta_global_newindex);
        lua_pop(state, 2);

        lua_dup(state);
        lua_setmetatable(state, base);
        lua_swap(state); // -> meta curtable

        freeze_table(state, true, "global");
        lua_getfield(state, base, "__newindex");
        lua_setfield(state, -2, "__newindex");
        lua_pop(state, 1);

        lua_remove(state, base);
    }
    else
        freeze_table(state, false, node->getName());
}

static void RenderTypeChildren(lua_State *state, const std::vector<compound_identity*> &children)
{
    for (size_t i = 0; i < children.size(); i++)
    {
        RenderType(state, children[i]);
        lua_pushstring(state, children[i]->getName());
        lua_swap(state);
        lua_settable(state, -3);
    }
}

static void DoAttach(lua_State *state)
{
    int base = lua_gettop(state);

    lua_pushcfunction(state, change_error);
    lua_setfield(state, LUA_REGISTRYINDEX, "DFHack.ChangeError");

    luaL_register(state, "df", no_functions);

    {
        // Assign df a metatable with read-only contents
        lua_newtable(state);

        // Render the type structure
        RenderTypeChildren(state, compound_identity::getTopScope());

        freeze_table(state, true, "df");
        lua_remove(state, -2);
        lua_setmetatable(state, -2);
    }

    lua_pop(state, 1);
}

void DFHack::AttachDFGlobals(lua_State *state)
{
    if (luaL_newmetatable(state, "DFHack.DFTypes"))
        DoAttach(state);

    lua_pop(state, 1);
}