//! 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; }

{

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)

{

cerr << "Hotkey thread has croaked." << 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;

string name;

string description;

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

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

bool operator <(const sortable & rhs) const

{

if( name < rhs.name )

return true;

return false;

};

{

stringstream s;

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

if (Version::is_release())

s << "(release)";

else

s << "(development build " << Version::git_description() << ")";

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

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

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

return s.str();

{

ifstream script(path.c_str());

if (script.good())

{

std::string help;

if (getline(script, help) &&

help.substr(0,helpprefix.length()) == helpprefix)

{

help = help.substr(helpprefix.length());

while (help.size() && help[0] == ' ')

help = help.substr(1);

return help;

}

}

return "No help available.";

{

std::vector<string> files;

Filesystem::listdir(path, files);

path += '/';

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

{

if (hasEnding(files[i], ".lua"))

{

string help = getScriptHelp(path + files[i], "--");

string key = prefix + files[i].substr(0, files[i].size()-4);

if (pset.find(key) == pset.end()) {

pset[key] = help;

}

}

else if (plug_mgr->ruby && plug_mgr->ruby->is_enabled() && hasEnding(files[i], ".rb"))

{

string help = getScriptHelp(path + files[i], "#");

string key = prefix + files[i].substr(0, files[i].size()-3);

if (pset.find(key) == pset.end()) {

pset[key] = help;

}

}

else if (all && !files[i].empty() && files[i][0] != '.' && files[i] != "internal" && files[i] != "test")

{

listScripts(plug_mgr, pset, path+files[i]+"/", all, prefix+files[i]+"/");

}

}

{

vector<string> paths;

Core::getInstance().getScriptPaths(&paths);

for (string path : paths)

listScripts(Core::getInstance().getPluginManager(), pset, path, all);

{

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 (!plug_mgr->ruby || !plug_mgr->ruby->is_enabled())

return CR_FAILURE;

// ugly temporary patch for https://github.com/DFHack/dfhack/issues/1146

string cwd = Filesystem::getcwd();

if (filename.find(cwd) == 0)

{

filename = filename.substr(cwd.size());

while (!filename.empty() && (filename[0] == '/' || filename[0] == '\\'))

filename = filename.substr(1);

}

std::string rbcmd = "$script_args = [";

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

rbcmd += "'" + args[i] + "', ";

rbcmd += "]\n";

rbcmd += "catch(:script_finished) { load '" + filename + "' }";

return plug_mgr->ruby->eval_ruby(out, rbcmd.c_str());

{

if (!command.empty())

{

vector <string> parts;

Core::cheap_tokenise(command,parts);

if(parts.size() == 0)

return CR_NOT_IMPLEMENTED;

string first = parts[0];

parts.erase(parts.begin());

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

return CR_OK;

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

return runCommand(out, first, parts);

}

else

return CR_NOT_IMPLEMENTED;

{

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

// Check for possible built in commands to autocomplete first

for (auto const &command : built_in_commands)

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

possible.push_back(command);

auto plug_mgr = Core::getInstance().getPluginManager();

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

{

const Plugin * plug = it->second;

for (size_t j = 0; j < plug->size(); j++)

{

const PluginCommand &pcmd = (*plug)[j];

if (pcmd.isHotkeyCommand())

continue;

if (pcmd.name.substr(0, first.size()) == first)

possible.push_back(pcmd.name);

}

}

bool all = (first.find('/') != std::string::npos);

std::map<string, string> scripts;

listAllScripts(scripts, all);

for (auto iter = scripts.begin(); iter != scripts.end(); ++iter)

if (iter->first.substr(0, first.size()) == first)

possible.push_back(iter->first);

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;

{

lock_guard<mutex> lock(script_path_mutex);

vector<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;

{

lock_guard<mutex> lock(script_path_mutex);

bool found = false;

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

{

vector<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;

{

lock_guard<mutex> lock(script_path_mutex);

dest->clear();

string df_path = this->p->getPath();

for (auto it = script_paths[0].begin(); it != script_paths[0].end(); ++it)

dest->push_back(*it);

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

string save = World::ReadWorldFolder();

if (save.size())

dest->push_back(df_path + "/data/save/" + save + "/raw/scripts");

}

dest->push_back(df_path + "/raw/scripts");

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

for (auto it = script_paths[1].begin(); it != script_paths[1].end(); ++it)

dest->push_back(*it);

{

vector<string> paths;

getScriptPaths(&paths);

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

{

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

if (Filesystem::isfile(path))

return path;

}

return "";

{

using namespace std;

string filename("dfhack-config/script-paths.txt");

ifstream file(filename);

if (!file)

{

if (!silent)

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

return false;

}

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

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;

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";

{

std::string builtin = "";

// Check our list of builtin commands from the header

if (built_in_commands.count(cmd))

builtin = cmd;

// Check for some common aliases for built in commands

else if (cmd == "?" || cmd == "man")

builtin = "help";

else if (cmd == "dir")

builtin = "ls";

else if (cmd == "clear")

builtin = "cls";

else if (cmd == "devel/dump-rpc")

builtin = "devel/dump-rpc";

return builtin;

{

const size_t help_line_length = 80 - 22 - 5;

const string padding = string(80 - help_line_length, ' ');

vector<string> lines;

con.print(" %-22s - ", name.c_str());

word_wrap(&lines, desc, help_line_length);

// print first line, then any additional lines preceded by padding

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

con.print("%s%s\n", i ? padding.c_str() : "", lines[i].c_str());

{

if (pcmd.isHotkeyCommand())

con.color(COLOR_CYAN);

ls_helper(con, pcmd.name, pcmd.description);

con.reset_color();

{

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;

}

command_result res;

if (!first.empty())

{

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

string builtin = getBuiltinCommand(first);

if (builtin == "help")

{

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("Basic commands:\n"

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

" help COMMAND - Usage help for the given command.\n"

" ls|dir [-a] [PLUGIN] - List available commands. Optionally for single plugin.\n"

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

" fpause - Force DF to pause.\n"

" die - Force DF to close immediately\n"

" keybinding - Modify bindings of commands to keys\n"

"Plugin management (useful for developers):\n"

" plug [PLUGIN|v] - List plugin state and description.\n"

" load PLUGIN|-all - Load a plugin by name or load all possible plugins.\n"

" unload PLUGIN|-all - Unload a plugin or all loaded plugins.\n"

" reload PLUGIN|-all - Reload a plugin or all loaded plugins.\n"

);

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

}

else if (parts.size() == 1)

{

if (getBuiltinCommand(parts[0]).size())

{

con << parts[0] << ": built-in command; Use `ls`, `help`, or check hack/Readme.html for more information" << std::endl;

return CR_NOT_IMPLEMENTED;

}

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

if (plug) {

for (size_t j = 0; j < plug->size();j++)

{

const PluginCommand & pcmd = (plug->operator[](j));

if (pcmd.name != parts[0])

continue;

if (pcmd.isHotkeyCommand())

con.color(COLOR_CYAN);

con.print("%s: %s\n",pcmd.name.c_str(), pcmd.description.c_str());

con.reset_color();

if (!pcmd.usage.empty())

con << "Usage:\n" << pcmd.usage << flush;

return CR_OK;

}

}

string file = findScript(parts[0] + ".lua");

if ( file != "" ) {

string help = getScriptHelp(file, "--");

con.print("%s: %s\n", parts[0].c_str(), help.c_str());

return CR_OK;

}

if (plug_mgr->ruby && plug_mgr->ruby->is_enabled() ) {

file = findScript(parts[0] + ".rb");

if ( file != "" ) {

string help = getScriptHelp(file, "#");

con.print("%s: %s\n", parts[0].c_str(), help.c_str());

return CR_OK;

}

}

con.printerr("Unknown command: %s\n", parts[0].c_str());

return CR_FAILURE;

}

else

{

con.printerr("not implemented yet\n");

return CR_NOT_IMPLEMENTED;

}

}

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

{

bool all = false;

bool load = (builtin == "load");

bool unload = (builtin == "unload");

if (parts.size())

{

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

{

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

{

if (p->find('a') != 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", builtin.c_str());

}

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

{

CoreSuspender suspend;

bool enable = (builtin == "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] = '/';

}

}

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", builtin.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", builtin.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(

"%20s\t%-3s%s\n",

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

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

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

);

}

}

}

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

{

bool all = false;

if (parts.size() && parts[0] == "-a")

{

all = true;

vector_erase_at(parts, 0);

}

if(parts.size())

{

string & plugname = parts[0];

const Plugin * plug = (*plug_mgr)[plugname];

if(!plug)

{

con.printerr("There's no plugin called %s!\n", plugname.c_str());

}

else if (plug->getState() != Plugin::PS_LOADED)

{

con.printerr("Plugin %s is not loaded.\n", plugname.c_str());

}

else if (!plug->size())

{

con.printerr("Plugin %s is loaded but does not implement any commands.\n", plugname.c_str());

}

else for (size_t j = 0; j < plug->size();j++)

{

ls_helper(con, plug->operator[](j));

}

}

else

{

con.print(

"builtin:\n"

" help|?|man - This text or help specific to a plugin.\n"

" ls|dir [-a] [PLUGIN] - List available commands. Optionally for single plugin.\n"

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

" fpause - Force DF to pause.\n"

" die - Force DF to close immediately\n"

" kill-lua - Stop an active Lua script\n"

" keybinding - Modify bindings of commands to keys\n"

" script FILENAME - Run the commands specified in a file.\n"

" sc-script - Automatically run specified scripts on state change events\n"

" plug [PLUGIN|v] - List plugin state and detailed description.\n"

" load PLUGIN|-all [...] - Load a plugin by name or load all possible plugins.\n"

" unload PLUGIN|-all [...] - Unload a plugin or all loaded plugins.\n"

" reload PLUGIN|-all [...] - Reload a plugin or all loaded plugins.\n"

" enable/disable PLUGIN [...] - Enable or disable a plugin if supported.\n"

" type COMMAND - Display information about where a command is implemented\n"

"\n"

"plugins:\n"

);

std::set <sortable> out;

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

{

const Plugin * plug = it->second;

if(!plug->size())

continue;

for (size_t j = 0; j < plug->size();j++)

{

const PluginCommand & pcmd = (plug->operator[](j));

out.insert(sortable(pcmd.isHotkeyCommand(),pcmd.name,pcmd.description));

}

}

for(auto iter = out.begin();iter != out.end();iter++)

{

if ((*iter).recolor)

con.color(COLOR_CYAN);

ls_helper(con, iter->name, iter->description);

con.reset_color();

}

std::map<string, string> scripts;

listAllScripts(scripts, all);

if (!scripts.empty())

{

con.print("\nscripts:\n");

for (auto iter = scripts.begin(); iter != scripts.end(); ++iter)

ls_helper(con, iter->first, iter->second);

}

}

}

else if (builtin == "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;