//! MainThread::suspend keeps the main DF thread suspended from Core::Init to

//! thread exit.

static CoreSuspenderBase& suspend() {

static thread_local CoreSuspenderBase lock(std::defer_lock);

return lock;

}

{

static const int MAX_DEPTH = 20;

static thread_local int depth;

CommandDepthCounter() { depth++; }

~CommandDepthCounter() { depth--; }

bool ok() { return depth < MAX_DEPTH; }

{

std::string *cur = NULL;

size_t i = 0;

// Check the first non-space character

while (i < input.size() && isspace(input[i])) i++;

// Special verbatim argument mode?

if (i < input.size() && input[i] == ':')

{

// Read the command

std::string cmd;

i++;

while (i < input.size() && !isspace(input[i]))

cmd.push_back(input[i++]);

if (!cmd.empty())

output.push_back(cmd);

// Find the argument

while (i < input.size() && isspace(input[i])) i++;

if (i < input.size())

output.push_back(input.substr(i));

return;

}

// Otherwise, parse in the regular quoted mode

for (; i < input.size(); i++)

{

unsigned char c = input[i];

if (isspace(c)) {

cur = NULL;

} else {

if (!cur) {

output.push_back("");

cur = &output.back();

}

if (c == '"') {

for (i++; i < input.size(); i++) {

c = input[i];

if (c == '"')

break;

else if (c == '\\') {

if (++i < input.size())

cur->push_back(input[i]);

}

else

cur->push_back(c);

}

} else {

cur->push_back(c);

}

}

}

{

Core * core;

PluginManager * plug_mgr;

{

Core * core = ((IODATA*) iodata)->core;

PluginManager * plug_mgr = ((IODATA*) iodata)->plug_mgr;

if(plug_mgr == 0 || core == 0)

{

std::cerr << "Hotkey thread has croaked." << std::endl;

return;

}

bool keep_going = true;

while(keep_going)

{

std::string stuff = core->getHotkeyCmd(keep_going); // waits on mutex!

if(!stuff.empty())

{

color_ostream_proxy out(core->getConsole());

auto rv = core->runCommand(out, stuff);

if (rv == CR_NOT_IMPLEMENTED)

out.printerr("Invalid hotkey command: '%s'\n", stuff.c_str());

}

}

{

bool recolor;

std::string name;

std::string description;

//FIXME: Nuke when MSVC stops failing at being C++11 compliant

sortable(bool recolor_,const std::string& name_,const std::string & description_): recolor(recolor_), name(name_), description(description_){};

bool operator <(const sortable & rhs) const

{

if( name < rhs.name )

return true;

return false;

};

{

std::stringstream s;

s << Version::dfhack_version() << " ";

if (Version::is_release())

s << "(release)";

else

s << "(git: " << Version::git_commit(true) << ")";

s << " on " << (sizeof(void*) == 8 ? "x86_64" : "x86");

if (strlen(Version::dfhack_build_id()))

s << " [build ID: " << Version::dfhack_build_id() << "]";

return s.str();

{

auto args = (ScriptArgs*)info;

if (!lua_checkstack(state, args->pargs->size()+10))

return false;

Lua::PushDFHack(state);

lua_getfield(state, -1, "run_script");

lua_remove(state, -2);

lua_pushstring(state, args->pcmd->c_str());

for (size_t i = 0; i < args->pargs->size(); i++)

lua_pushstring(state, (*args->pargs)[i].c_str());

return true;

{

ScriptArgs data;

data.pcmd = &name;

data.pargs = &args;

bool ok = Lua::RunCoreQueryLoop(out, Lua::Core::State, init_run_script, &data);

return ok ? CR_OK : CR_FAILURE;

{

auto args = (ScriptEnableState*)info;

if (!lua_checkstack(state, 4))

return false;

Lua::PushDFHack(state);

lua_getfield(state, -1, "enable_script");

lua_remove(state, -2);

lua_pushstring(state, args->pcmd->c_str());

lua_pushboolean(state, args->pstate);

return true;

{

ScriptEnableState data;

data.pcmd = &name;

data.pstate = state;

bool ok = Lua::RunCoreQueryLoop(out, Lua::Core::State, init_enable_script, &data);

return ok ? CR_OK : CR_FAILURE;

{

if (!command.empty())

{

std::vector <std::string> parts;

Core::cheap_tokenise(command,parts);

if(parts.size() == 0)

return CR_NOT_IMPLEMENTED;

std::string first = parts[0];

parts.erase(parts.begin());

if (first[0] == '#')

return CR_OK;

std::cerr << "Invoking: " << command << std::endl;

return runCommand(out, first, parts);

}

else

return CR_NOT_IMPLEMENTED;

CoreSuspender suspend;

auto L = Lua::Core::State;

Lua::StackUnwinder top(L);

if (!lua_checkstack(L, 1) ||

!Lua::PushModulePublic(con, L, "helpdb", "is_builtin")) {

con.printerr("Failed to load helpdb Lua code\n");

return false;

}

Lua::Push(L, command);

if (!Lua::SafeCall(con, L, 1, 1)) {

con.printerr("Failed Lua call to helpdb.is_builtin.\n");

return false;

}

return lua_toboolean(L, -1);

CoreSuspender suspend;

auto L = Lua::Core::State;

Lua::StackUnwinder top(L);

if (!lua_checkstack(L, 1) ||

!Lua::PushModulePublic(con, L, "helpdb", "get_commands")) {

con.printerr("Failed to load helpdb Lua code\n");

return;

}

if (!Lua::SafeCall(con, L, 0, 1)) {

con.printerr("Failed Lua call to helpdb.get_commands.\n");

}

Lua::GetVector(L, commands);

{

std::vector<std::string> commands, possible;

for (auto &command : commands)

if (command.substr(0, first.size()) == first)

possible.push_back(command);

if (possible.size() == 1)

{

completed = possible[0];

//fprintf(stderr, "Autocompleted %s to %s\n", , );

con.printerr("%s is not recognized. Did you mean %s?\n", first.c_str(), completed.c_str());

return true;

}

if (possible.size() > 1 && possible.size() < 8)

{

std::string out;

for (size_t i = 0; i < possible.size(); i++)

out += " " + possible[i];

con.printerr("%s is not recognized. Possible completions:%s\n", first.c_str(), out.c_str());

return true;

}

return false;

{

std::lock_guard<std::mutex> lock(script_path_mutex);

std::vector<std::string> &vec = script_paths[search_before ? 0 : 1];

if (std::find(vec.begin(), vec.end(), path) != vec.end())

return false;

if (!Filesystem::isdir(path))

return false;

vec.push_back(path);

return true;

std::lock_guard<std::mutex> lock(script_path_mutex);

script_paths[2] = mod_script_paths;

return true;

{

std::lock_guard<std::mutex> lock(script_path_mutex);

bool found = false;

for (int i = 0; i < 2; i++)

{

std::vector<std::string> &vec = script_paths[i];

while (1)

{

auto it = std::find(vec.begin(), vec.end(), path);

if (it == vec.end())

break;

vec.erase(it);

found = true;

}

}

return found;

{

std::lock_guard<std::mutex> lock(script_path_mutex);

dest->clear();

std::string df_path = this->p->getPath() + "/";

for (auto & path : script_paths[0])

dest->emplace_back(path);

dest->push_back(df_path + CONFIG_PATH + "scripts");

if (df::global::world && isWorldLoaded()) {

std::string save = World::ReadWorldFolder();

if (save.size())

dest->emplace_back(df_path + "save/" + save + "/scripts");

}

dest->emplace_back(df_path + "hack/scripts");

for (auto & path : script_paths[2])

dest->emplace_back(path);

for (auto & path : script_paths[1])

dest->emplace_back(path);

{

std::vector<std::string> paths;

getScriptPaths(&paths);

for (auto it = paths.begin(); it != paths.end(); ++it)

{

std::string path = *it + "/" + name;

if (Filesystem::isfile(path))

return path;

}

return "";

{

using namespace std;

std::string filename(CONFIG_PATH + "script-paths.txt");

ifstream file(filename);

if (!file)

{

if (!silent)

out.printerr("Could not load %s\n", filename.c_str());

return false;

}

std::string raw;

int line = 0;

while (getline(file, raw))

{

++line;

istringstream ss(raw);

char ch;

ss >> skipws;

if (!(ss >> ch) || ch == '#')

continue;

ss >> ws; // discard whitespace

std::string path;

getline(ss, path);

if (ch == '+' || ch == '-')

{

if (!Core::getInstance().addScriptPath(path, ch == '+') && !silent)

out.printerr("%s:%i: Failed to add path: %s\n", filename.c_str(), line, path.c_str());

}

else if (!silent)

out.printerr("%s:%i: Illegal character: %c\n", filename.c_str(), line, ch);

}

return true;

auto L = Lua::Core::State;

Lua::StackUnwinder top(L);

std::vector<std::string> mod_script_paths;

Lua::CallLuaModuleFunction(out, L, "script-manager", "get_mod_script_paths", 0, 1,

Lua::DEFAULT_LUA_LAMBDA,

[&](lua_State *L) {

Lua::GetVector(L, mod_script_paths);

});

DEBUG(script,out).print("final mod script paths:\n");

for (auto & path : mod_script_paths)

DEBUG(script,out).print(" %s\n", path.c_str());

Core::getInstance().setModScriptPaths(mod_script_paths);

if (!state_change_event_map.size())

{

#define insert(name) state_change_event_map.insert(std::pair<std::string, state_change_event>(#name, name))

insert(SC_WORLD_LOADED);

insert(SC_WORLD_UNLOADED);

insert(SC_MAP_LOADED);

insert(SC_MAP_UNLOADED);

insert(SC_VIEWSCREEN_CHANGED);

insert(SC_PAUSED);

insert(SC_UNPAUSED);

#undef insert

}

sc_event_map_init();

auto it = state_change_event_map.find(name);

if (it != state_change_event_map.end())

return it->second;

if (name.find("SC_") != 0)

return sc_event_id(std::string("SC_") + name);

return SC_UNKNOWN;

sc_event_map_init();

for (auto it = state_change_event_map.begin(); it != state_change_event_map.end(); ++it)

{

if (it->second == id)

return it->first;

}

return "SC_UNKNOWN";

CoreSuspender suspend;

auto L = Lua::Core::State;

Lua::StackUnwinder top(L);

if (!lua_checkstack(L, 2) ||

!Lua::PushModulePublic(con, L, "helpdb", "help")) {

con.printerr("Failed to load helpdb Lua code\n");

return;

}

Lua::Push(L, entry_name);

if (!Lua::SafeCall(con, L, 1, 0)) {

con.printerr("Failed Lua call to helpdb.help.\n");

}

CoreSuspender suspend;

auto L = Lua::Core::State;

Lua::StackUnwinder top(L);

if (!lua_checkstack(L, 1) ||

!Lua::PushModulePublic(con, L, "helpdb", "tags")) {

con.printerr("Failed to load helpdb Lua code\n");

return;

}

Lua::Push(L, tag);

if (!Lua::SafeCall(con, L, 1, 0)) {

con.printerr("Failed Lua call to helpdb.tags.\n");

}

std::vector<std::string> filter;

bool skip_tags = false;

bool show_dev_commands = false;

std::string exclude_strs = "";

bool in_exclude = false;

for (auto str : params) {

if (in_exclude)

exclude_strs = str;

else if (str == "--notags")

skip_tags = true;

else if (str == "--dev")

show_dev_commands = true;

else if (str == "--exclude")

in_exclude = true;

else

filter.push_back(str);

}

CoreSuspender suspend;

auto L = Lua::Core::State;

Lua::StackUnwinder top(L);

if (!lua_checkstack(L, 5) ||

!Lua::PushModulePublic(con, L, "helpdb", "ls")) {

con.printerr("Failed to load helpdb Lua code\n");

return;

}

Lua::PushVector(L, filter);

Lua::Push(L, skip_tags);

Lua::Push(L, show_dev_commands);

Lua::Push(L, exclude_strs);

if (!Lua::SafeCall(con, L, 4, 0)) {

con.printerr("Failed Lua call to helpdb.ls.\n");

}

{

std::string first = first_;

CommandDepthCounter counter;

if (!counter.ok())

{

con.printerr("Cannot invoke \"%s\": maximum command depth exceeded (%i)\n",

first.c_str(), CommandDepthCounter::MAX_DEPTH);

return CR_FAILURE;

}

if (first.empty())

return CR_NOT_IMPLEMENTED;

if (first.find('\\') != std::string::npos)

{

con.printerr("Replacing backslashes with forward slashes in \"%s\"\n", first.c_str());

for (size_t i = 0; i < first.size(); i++)

{

if (first[i] == '\\')

first[i] = '/';

}

}

// let's see what we actually got

command_result res;

if (first == "help" || first == "man" || first == "?")

{

if(!parts.size())

{

if (con.is_console())

{

con.print("This is the DFHack console. You can type commands in and manage DFHack plugins from it.\n"

"Some basic editing capabilities are included (single-line text editing).\n"

"The console also has a command history - you can navigate it with Up and Down keys.\n"

"On Windows, you may have to resize your console window. The appropriate menu is accessible\n"

"by clicking on the program icon in the top bar of the window.\n\n");

}

con.print("Here are some basic commands to get you started:\n"

" help|?|man - This text.\n"

" help <tool> - Usage help for the given plugin, command, or script.\n"

" tags - List the tags that the DFHack tools are grouped by.\n"

" ls|dir [<filter>] - List commands, optionally filtered by a tag or substring.\n"

" Optional parameters:\n"

" --notags: skip printing tags for each command.\n"

" --dev: include commands intended for developers and modders.\n"

" cls|clear - Clear the console.\n"

" fpause - Force DF to pause.\n"

" die - Force DF to close immediately, without saving.\n"

" keybinding - Modify bindings of commands to in-game key shortcuts.\n"

"\n"

"See more commands by running 'ls'.\n\n"

);

con.print("DFHack version %s\n", dfhack_version_desc().c_str());

}

else

{

help_helper(con, parts[0]);

}

}

else if (first == "tags")

{

tags_helper(con, parts.size() ? parts[0] : "");

}

else if (first == "load" || first == "unload" || first == "reload")

{

bool all = false;

bool load = (first == "load");

bool unload = (first == "unload");

if (parts.size())

{

for (auto p = parts.begin(); p != parts.end(); p++)

{

if (p->size() && (*p)[0] == '-')

{

if (p->find('a') != std::string::npos)

all = true;

}

}

if (all)

{

if (load)

plug_mgr->loadAll();

else if (unload)

plug_mgr->unloadAll();

else

plug_mgr->reloadAll();

return CR_OK;

}

for (auto p = parts.begin(); p != parts.end(); p++)

{

if (!p->size() || (*p)[0] == '-')

continue;

if (load)

plug_mgr->load(*p);

else if (unload)

plug_mgr->unload(*p);

else

plug_mgr->reload(*p);

}

}

else

con.printerr("%s: no arguments\n", first.c_str());

}

else if( first == "enable" || first == "disable" )

{

CoreSuspender suspend;

bool enable = (first == "enable");

if(parts.size())

{

for (size_t i = 0; i < parts.size(); i++)

{

std::string part = parts[i];

if (part.find('\\') != std::string::npos)

{

con.printerr("Replacing backslashes with forward slashes in \"%s\"\n", part.c_str());

for (size_t j = 0; j < part.size(); j++)

{

if (part[j] == '\\')

part[j] = '/';

}

}

part = GetAliasCommand(part, true);

Plugin * plug = (*plug_mgr)[part];

if(!plug)

{

std::string lua = findScript(part + ".lua");

if (lua.size())

{

res = enableLuaScript(con, part, enable);

}

else

{

res = CR_NOT_FOUND;

con.printerr("No such plugin or Lua script: %s\n", part.c_str());

}

}

else if (!plug->can_set_enabled())

{

res = CR_NOT_IMPLEMENTED;

con.printerr("Cannot %s plugin: %s\n", first.c_str(), part.c_str());

}

else

{

res = plug->set_enabled(con, enable);

if (res != CR_OK || plug->is_enabled() != enable)

con.printerr("Could not %s plugin: %s\n", first.c_str(), part.c_str());

}

}

return res;

}

else

{

for (auto it = plug_mgr->begin(); it != plug_mgr->end(); ++it)

{

Plugin * plug = it->second;

if (!plug->can_be_enabled()) continue;

con.print(

"%21s %-3s%s\n",

(plug->getName()+":").c_str(),

plug->is_enabled() ? "on" : "off",

plug->can_set_enabled() ? "" : " (controlled internally)"

);

}

auto L = Lua::Core::State;

Lua::StackUnwinder top(L);

Lua::CallLuaModuleFunction(con, L, "script-manager", "list");

}

}

else if (first == "ls" || first == "dir")

{

ls_helper(con, parts);

}

else if (first == "plug")

{

const char *header_format = "%30s %10s %4s %8s\n";

const char *row_format = "%30s %10s %4i %8s\n";

con.print(header_format, "Name", "State", "Cmds", "Enabled");

plug_mgr->refresh();

for (auto it = plug_mgr->begin(); it != plug_mgr->end(); ++it)

{

Plugin * plug = it->second;

if (!plug)

continue;

if (parts.size() && std::find(parts.begin(), parts.end(), plug->getName()) == parts.end())

continue;

color_value color;

switch (plug->getState())

{

case Plugin::PS_LOADED:

color = COLOR_RESET;

break;

case Plugin::PS_UNLOADED:

case Plugin::PS_UNLOADING:

color = COLOR_YELLOW;

break;

case Plugin::PS_LOADING:

color = COLOR_LIGHTBLUE;

break;

case Plugin::PS_BROKEN:

color = COLOR_LIGHTRED;

break;

default:

color = COLOR_LIGHTMAGENTA;

break;

}

con.color(color);

con.print(row_format,

plug->getName().c_str(),

Plugin::getStateDescription(plug->getState()),

plug->size(),

(plug->can_be_enabled()

? (plug->is_enabled() ? "enabled" : "disabled")

: "n/a")

);

con.color(COLOR_RESET);

}

}

else if (first == "type")

{

if (!parts.size())

{

con.printerr("type: no argument\n");

return CR_WRONG_USAGE;

}

con << parts[0];

bool builtin = is_builtin(con, parts[0]);

std::string lua_path = findScript(parts[0] + ".lua");

Plugin *plug = plug_mgr->getPluginByCommand(parts[0]);

if (builtin)

{

con << " is a built-in command";

con << std::endl;

}

else if (IsAlias(parts[0]))

{

con << " is an alias: " << GetAliasCommand(parts[0]) << std::endl;

}

else if (plug)

{

con << " is a command implemented by the plugin " << plug->getName() << std::endl;

}

else if (lua_path.size())

{

con << " is a Lua script: " << lua_path << std::endl;

}

else

{

con << " is not a recognized command." << std::endl;

plug = plug_mgr->getPluginByName(parts[0]);

if (plug)

con << "Plugin " << parts[0] << " exists and implements " << plug->size() << " commands." << std::endl;

return CR_FAILURE;

}

}

else if (first == "keybinding")

{

if (parts.size() >= 3 && (parts[0] == "set" || parts[0] == "add"))

{

std::string keystr = parts[1];

if (parts[0] == "set")

ClearKeyBindings(keystr);

for (int i = parts.size()-1; i >= 2; i--)

{

if (!AddKeyBinding(keystr, parts[i])) {

con.printerr("Invalid key spec: %s\n", keystr.c_str());

break;

}

}

}

else if (parts.size() >= 2 && parts[0] == "clear")

{

for (size_t i = 1; i < parts.size(); i++)

{

if (!ClearKeyBindings(parts[i])) {

con.printerr("Invalid key spec: %s\n", parts[i].c_str());

break;

}

}

}

else if (parts.size() == 2 && parts[0] == "list")

{

std::vector<std::string> list = ListKeyBindings(parts[1]);

if (list.empty())

con << "No bindings." << std::endl;

for (size_t i = 0; i < list.size(); i++)

con << " " << list[i] << std::endl;

}

else

{

con << "Usage:" << std::endl

<< " keybinding list <key>" << std::endl

<< " keybinding clear <key>[@context]..." << std::endl

<< " keybinding set <key>[@context] \"cmdline\" \"cmdline\"..." << std::endl

<< " keybinding add <key>[@context] \"cmdline\" \"cmdline\"..." << std::endl

<< "Later adds, and earlier items within one command have priority." << std::endl

<< "Supported keys: [Ctrl-][Alt-][Shift-](A-Z, 0-9, F1-F12, `, or Enter)." << std::endl

<< "Context may be used to limit the scope of the binding, by" << std::endl

<< "requiring the current context to have a certain prefix." << std::endl

<< "Current UI context is: " << std::endl

<< join_strings("\n", Gui::getCurFocus(true)) << std::endl;

}

}

else if (first == "alias")

{

if (parts.size() >= 3 && (parts[0] == "add" || parts[0] == "replace"))

{

const std::string &name = parts[1];

std::vector<std::string> cmd(parts.begin() + 2, parts.end());

if (!AddAlias(name, cmd, parts[0] == "replace"))

{

con.printerr("Could not add alias %s - already exists\n", name.c_str());

return CR_FAILURE;

}

}

else if (parts.size() >= 2 && (parts[0] == "delete" || parts[0] == "clear"))

{

if (!RemoveAlias(parts[1]))

{

con.printerr("Could not remove alias %s\n", parts[1].c_str());

return CR_FAILURE;

}

}

else if (parts.size() >= 1 && (parts[0] == "list"))

{

auto aliases = ListAliases();

for (auto p : aliases)