#include "Internal.h"

#include "MemAccess.h"

#include "Core.h"

#include "VersionInfo.h"

#include "DataDefs.h"

#include "DataIdentity.h"

#include "DataFuncs.h"

#include "LuaWrapper.h"

#include "LuaTools.h"

#include "MiscUtils.h"

#include "DFHackVersion.h"

#include "PluginManager.h"

#include "modules/World.h"

#include "modules/Gui.h"

#include "modules/Job.h"

#include "modules/Screen.h"

#include "modules/Units.h"

#include "df/building.h"

#include "df/enabler.h"

#include "df/entity_position.h"

#include "df/entity_position_assignment.h"

#include "df/extentst.h"

#include "df/historical_entity.h"

#include "df/interface_key.h"

#include "df/item.h"

#include "df/job.h"

#include "df/job_item.h"

#include "df/unit.h"

#include "df/viewscreen.h"

#include "df/world.h"

#include <lua.h>

#include <lauxlib.h>

#include <lualib.h>

#include <lstate.h>

#include <csignal>

#include <string>

#include <vector>

#include <map>

using namespace DFHack;

using namespace DFHack::LuaWrapper;

void dfhack_printerr(lua_State *S, const std::string &str);

inline bool is_null_userdata(lua_State *L, int idx)

{

return lua_islightuserdata(L, idx) && !lua_touserdata(L, idx);

}

inline void AssertCoreSuspend(lua_State *state)

{

assert(!Lua::IsCoreContext(state) || DFHack::Core::getInstance().isSuspended());

}

void DFHack::Lua::Push(lua_State *state, const Units::NoblePosition &pos)

{

lua_createtable(state, 0, 3);

Lua::PushDFObject(state, pos.entity);

lua_setfield(state, -2, "entity");

Lua::PushDFObject(state, pos.assignment);

lua_setfield(state, -2, "assignment");

Lua::PushDFObject(state, pos.position);

lua_setfield(state, -2, "position");

}

void DFHack::Lua::Push(lua_State *state, const df::coord &pos)

{

lua_createtable(state, 0, 3);

lua_pushinteger(state, pos.x);

lua_setfield(state, -2, "x");

lua_pushinteger(state, pos.y);

lua_setfield(state, -2, "y");

lua_pushinteger(state, pos.z);

lua_setfield(state, -2, "z");

}

void DFHack::Lua::Push(lua_State *state, const df::coord2d &pos)

{

lua_createtable(state, 0, 2);

lua_pushinteger(state, pos.x);

lua_setfield(state, -2, "x");

lua_pushinteger(state, pos.y);

lua_setfield(state, -2, "y");

}

void DFHack::Lua::GetVector(lua_State *state, std::vector<std::string> &pvec, int idx)

{

luaL_checktype(state, idx, LUA_TTABLE);

lua_pushnil(state); // first key

while (lua_next(state, idx) != 0)

{

pvec.push_back(lua_tostring(state, -1));

lua_pop(state, 1); // remove value, leave key

}

}

static bool trigger_inhibit_l = false;

static bool trigger_inhibit_r = false;

static bool trigger_inhibit_m = false;

static bool inhibit_l = false;

static bool inhibit_r = false;

static bool inhibit_m = false;

void DFHack::Lua::PushInterfaceKeys(lua_State *L,

const std::set<df::interface_key> &keys) {

lua_createtable(L, 0, keys.size() + 7);

for (auto &key : keys)

{

if (auto name = enum_item_raw_key(key))

lua_pushstring(L, name);

else

lua_pushinteger(L, key);

lua_pushboolean(L, true);

lua_rawset(L, -3);

int charval = Screen::keyToChar(key);

if (charval >= 0)

{

lua_pushinteger(L, charval);

lua_setfield(L, -2, "_STRING");

}

}

if (df::global::enabler) {

if (!inhibit_l && df::global::enabler->mouse_lbut) {

lua_pushboolean(L, true);

lua_setfield(L, -2, "_MOUSE_L");

trigger_inhibit_l = true;

}

if (!inhibit_r && df::global::enabler->mouse_rbut) {

lua_pushboolean(L, true);

lua_setfield(L, -2, "_MOUSE_R");

trigger_inhibit_r = true;

}

if (!inhibit_m && df::global::enabler->mouse_mbut) {

lua_pushboolean(L, true);

lua_setfield(L, -2, "_MOUSE_M");

trigger_inhibit_m = true;

}

if (df::global::enabler->mouse_lbut_down) {

lua_pushboolean(L, true);

lua_setfield(L, -2, "_MOUSE_L_DOWN");

}

if (df::global::enabler->mouse_rbut_down) {

lua_pushboolean(L, true);

lua_setfield(L, -2, "_MOUSE_R_DOWN");

}

if (df::global::enabler->mouse_mbut_down) {

lua_pushboolean(L, true);

lua_setfield(L, -2, "_MOUSE_M_DOWN");

}

}

}

int DFHack::Lua::PushPosXYZ(lua_State *state, const df::coord &pos)

{

if (!pos.isValid())

{

lua_pushnil(state);

return 1;

}

else

{

lua_pushinteger(state, pos.x);

lua_pushinteger(state, pos.y);

lua_pushinteger(state, pos.z);

return 3;

}

}

int DFHack::Lua::PushPosXY(lua_State *state, const df::coord2d &pos)

{

if (!pos.isValid())

{

lua_pushnil(state);

return 1;

}

else

{

lua_pushinteger(state, pos.x);

lua_pushinteger(state, pos.y);

return 2;

}

}

void DFHack::Lua::PushDFObject(lua_State *state, const type_identity *type, void *ptr)

{

push_object_internal(state, type, ptr, false);

}

void *DFHack::Lua::GetDFObject(lua_State *state, const type_identity *type, int val_index, bool exact_type)

{

return get_object_internal(state, type, val_index, exact_type, false);

}

static void check_valid_ptr_index(lua_State *state, int val_index)

}

static void signal_typeid_error(color_ostream* out, lua_State* state,

}

void *DFHack::Lua::CheckDFObject(lua_State *state, const type_identity *type, int val_index, bool exact_type)

{

check_valid_ptr_index(state, val_index);

if (lua_isnil(state, val_index))

return NULL;

if (lua_islightuserdata(state, val_index) && !lua_touserdata(state, val_index))

return NULL;

void *rv = get_object_internal(state, type, val_index, exact_type, false);

if (!rv)

signal_typeid_error(NULL, state, type, "invalid pointer type; expected: {}",

val_index, false, true);

return rv;

}

static int DFHACK_OSTREAM_TOKEN = 0;

color_ostream *DFHack::Lua::GetOutput(lua_State *L)

{

lua_rawgetp(L, LUA_REGISTRYINDEX, &DFHACK_OSTREAM_TOKEN);

auto rv = (color_ostream*)lua_touserdata(L, -1);

lua_pop(L, 1);

return rv;

}

df::cur_lua_ostream_argument::cur_lua_ostream_argument(lua_State *state)

{

out = DFHack::Lua::GetOutput(state);

if (!out)

LuaWrapper::field_error(state, UPVAL_METHOD_NAME, "no output stream", "invoke");

}

static void set_dfhack_output(lua_State *L, color_ostream *p)

}

static Console *get_console(lua_State *state)

{

color_ostream *pstream = Lua::GetOutput(state);

if (!pstream)

{

lua_pushnil(state);

lua_pushstring(state, "no output stream");

return NULL;

}

if (!pstream->is_console())

{

lua_pushnil(state);

lua_pushstring(state, "not an interactive console");

return NULL;

}

return static_cast<Console*>(pstream);

}

static int DFHACK_TOSTRING_TOKEN = 0;

static std::string lua_print_fmt(lua_State *L)

}

static int lua_dfhack_print(lua_State *S)

}

static int lua_dfhack_println(lua_State *S)

}

void dfhack_printerr(lua_State *S, const std::string &str)

}

static int lua_dfhack_printerr(lua_State *S)

}

static int lua_dfhack_color(lua_State *S)

}

static int lua_dfhack_is_interactive(lua_State *S)

}

static int dfhack_lineedit_sync(lua_State *S, Console *pstream)

}

static int DFHACK_QUERY_COROTABLE_TOKEN = 0;

static int yield_helper(lua_State *S)

{

return lua_yield(S, lua_gettop(S));

}

namespace {

int dfhack_lineedit_cont(lua_State *L, int status, lua_KContext)

}

}

static int dfhack_lineedit(lua_State *S)

}

volatile std::sig_atomic_t lstop = 0;

static void interrupt_hook (lua_State *L, lua_Debug *ar);

static void interrupt_init (lua_State *L)

{

lua_sethook(L, interrupt_hook, LUA_MASKCOUNT, 256);

}

static void interrupt_hook (lua_State *L, lua_Debug *ar)

}

bool DFHack::Lua::Interrupt (bool force)

{

lua_State *L = DFHack::Core::getInstance().getLuaState(true);

if (L->hook != interrupt_hook && !force)

return false;

if (force)

lua_sethook(L, interrupt_hook, LUA_MASKCALL | LUA_MASKRET | LUA_MASKLINE | LUA_MASKCOUNT, 1);

lstop = 1;

return true;

}

static int DFHACK_EXCEPTION_META_TOKEN = 0;

static void error_tostring(lua_State *L, bool keep_old = false)

}

static void report_error(lua_State *L, color_ostream *out = NULL, bool pop = false)

}

static bool convert_to_exception(lua_State *L, int slevel, lua_State *thread = NULL)

}

static int dfhack_onerror(lua_State *L)

}

static int dfhack_error(lua_State *L)

}

static int dfhack_exit_error(lua_State *L)

}

static int dfhack_exception_tostring(lua_State *L)

}

static void push_simple_error(lua_State *L, const char *str)

}

static bool do_finish_pcall(lua_State *L, bool success, int base = 1, int space = 2)

}

namespace {

int safecall_cont(lua_State *L, int status, lua_KContext)

}

}

static int dfhack_safecall (lua_State *L)

}

bool DFHack::Lua::SafeCall(color_ostream &out, lua_State *L, int nargs, int nres, bool perr)

{

AssertCoreSuspend(L);

int base = lua_gettop(L) - nargs;

color_ostream *cur_out = Lua::GetOutput(L);

set_dfhack_output(L, &out);

lua_pushcfunction(L, dfhack_onerror);

lua_insert(L, base);

bool ok = lua_pcall(L, nargs, nres, base) == LUA_OK;

if (!ok && perr)

report_error(L, &out, true);

lua_remove(L, base);

set_dfhack_output(L, cur_out);

return ok;

}

bool DFHack::Lua::CallLuaModuleFunction(color_ostream &out, lua_State *L,

const char *module_name, const char *fn_name,

int nargs, int nres, LuaLambda && args_lambda, LuaLambda && res_lambda,

bool perr){

Lua::StackUnwinder top(L);

if (!lua_checkstack(L, 1 + nargs) ||

!Lua::PushModulePublic(out, L, module_name, fn_name)) {

if (perr)

out.printerr("Failed to load {} Lua code\n", module_name);

return false;

}

std::forward<LuaLambda&&>(args_lambda)(L);

if (!Lua::SafeCall(out, L, nargs, nres, perr)) {

if (perr)

out.printerr("Failed Lua call to '{}.{}'\n", module_name, fn_name);

return false;

}

std::forward<LuaLambda&&>(res_lambda)(L);

return true;

}

static int resume_helper(lua_State *L, lua_State *co, int narg, int nres)

}

static int dfhack_coresume (lua_State *L) {

}

static int dfhack_saferesume (lua_State *L) {

}

static int dfhack_coauxwrap (lua_State *L) {

}

static int dfhack_cowrap (lua_State *L) {

}

static void add_luacov_coroutine_wrapper(lua_State *L)

}

lua_State *DFHack::Lua::NewCoroutine(lua_State *L) {

if (Lua::IsCoreContext(L) && getenv("DFHACK_ENABLE_LUACOV"))

add_luacov_coroutine_wrapper(L);

lua_State *NL = lua_newthread(L);

lua_swap(L);

lua_xmove(L, NL, 1); /* move function from L to NL */

return NL;

}

int DFHack::Lua::SafeResume(color_ostream &out, lua_State *from, lua_State *thread, int nargs, int nres, bool perr)

{

AssertCoreSuspend(from);

color_ostream *cur_out = Lua::GetOutput(from);

set_dfhack_output(from, &out);

int rv = resume_helper(from, thread, nargs, nres);

if (!Lua::IsSuccess(rv) && perr)

report_error(from, &out, true);

set_dfhack_output(from, cur_out);

return rv;

}

int DFHack::Lua::SafeResume(color_ostream &out, lua_State *from, int nargs, int nres, bool perr)

{

int base = lua_gettop(from) - nargs;

lua_State *thread = lua_tothread(from, base);

int rv = SafeResume(out, from, thread, nargs, nres, perr);

lua_remove(from, base);

return rv;

}