{

predicate = false;

wakeup = new tthread::condition_variable();

{

while(!predicate)

{

wakeup->wait(*m);

}

predicate = false;

return true;

{

predicate = true;

wakeup->notify_one();

return true;

{

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;

}

while(1)

{

std::string stuff = core->getHotkeyCmd(); // 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;

};

{

ifstream script(path.c_str());

if (script.good())

{

std::string help;

if (getline(script, help) &&

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

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

}

return "No help available.";

{

std::vector<string> files;

getdir(path, files);

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

{

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

{

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

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

}

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

{

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

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

}

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

{

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

}

}

{

ifstream script(path.c_str());

return script.good();

{

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;

{

if (!plug_mgr->ruby || !plug_mgr->ruby->is_enabled())

return CR_FAILURE;

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

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

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

rbcmd += "]\n";

rbcmd += "catch(:script_finished) { load './hack/scripts/" + name + ".rb' }";

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;

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

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

{

const Plugin * plug = (plug_mgr->operator[](i));

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

{

const PluginCommand &pcmd = plug->operator[](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;

listScripts(plug_mgr, scripts, Core::getInstance().getHackPath() + "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;

{

if (!first.empty())

{

// let's see what we actually got

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

{

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 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 " DFHACK_VERSION ".\n");

}

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

{

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;

}

}

auto filename = getHackPath() + "scripts/" + parts[0];

if (fileExists(filename + ".lua"))

{

string help = getScriptHelp(filename + ".lua", "-- ");

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

return CR_OK;

}

if (plug_mgr->ruby && plug_mgr->ruby->is_enabled() && fileExists(filename + ".rb"))

{

string help = getScriptHelp(filename + ".rb", "# ");

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());

}

else

{

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

}

}

else if( first == "load" )

{

if(parts.size())

{

string & plugname = parts[0];

if(plugname == "all")

{

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

{

Plugin * plug = (plug_mgr->operator[](i));

plug->load(con);

}

}

else

{

Plugin * plug = plug_mgr->getPluginByName(plugname);

if(!plug)

{

con.printerr("No such plugin\n");

}

else

{

plug->load(con);

}

}

}

}

else if( first == "reload" )

{

if(parts.size())

{

string & plugname = parts[0];

if(plugname == "all")

{

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

{

Plugin * plug = (plug_mgr->operator[](i));

plug->reload(con);

}

}

else

{

Plugin * plug = plug_mgr->getPluginByName(plugname);

if(!plug)

{

con.printerr("No such plugin\n");

}

else

{

plug->reload(con);

}

}

}

}

else if( first == "unload" )

{

if(parts.size())

{

string & plugname = parts[0];

if(plugname == "all")

{

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

{

Plugin * plug = (plug_mgr->operator[](i));

plug->unload(con);

}

}

else

{

Plugin * plug = plug_mgr->getPluginByName(plugname);

if(!plug)

{

con.printerr("No such plugin\n");

}

else

{

plug->unload(con);

}

}

}

}

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

{

CoreSuspender suspend;

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

if(parts.size())

{

command_result res = CR_OK;

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

{

Plugin * plug = plug_mgr->getPluginByName(parts[i]);

if(!plug)

{

res = CR_NOT_FOUND;

con.printerr("No such plugin: %s\n", parts[i].c_str());

}

else if (!plug->can_set_enabled())

{

res = CR_NOT_IMPLEMENTED;

con.printerr("Cannot %s plugin: %s\n", first.c_str(), parts[i].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(), parts[i].c_str());

}

}

return res;

}

else

{

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

{

Plugin * plug = (plug_mgr->operator[](i));

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(first == "ls" || first == "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->getPluginByName(plugname);

if(!plug)

{

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

}

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

{

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

if (pcmd.isHotkeyCommand())

con.color(COLOR_CYAN);

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

con.reset_color();

}

}

else

{

con.print(

"builtin:\n"

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

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

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

" script FILENAME - Run the commands specified in a file.\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"

"\n"

"plugins:\n"

);

std::set <sortable> out;

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

{

const Plugin * plug = (plug_mgr->operator[](i));

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

con.print(" %-22s- %s\n",(*iter).name.c_str(), (*iter).description.c_str());

con.reset_color();

}

std::map<string, string> scripts;

listScripts(plug_mgr, scripts, getHackPath() + "scripts/", all);

if (!scripts.empty())

{

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

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

con.print(" %-22s- %s\n", iter->first.c_str(), iter->second.c_str());

}

}

}

else if(first == "plug")

{

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

{

const Plugin * plug = (plug_mgr->operator[](i));

if(!plug->size())

continue;

con.print("%s\n", plug->getName().c_str());

}

}

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

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

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

}

else

{

con << "Usage:" << endl

<< " keybinding list <key>" << endl

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

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

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

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

<< "Supported keys: [Ctrl-][Alt-][Shift-](A-Z, or F1-F9, or Enter)." << endl

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

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

<< "Current UI context is: "

<< Gui::getFocusString(Core::getTopViewscreen()) << endl;

}

}

else if(first == "fpause")

{

World::SetPauseState(true);

con.print("The game was forced to pause!\n");

}

else if(first == "cls")

{

if (con.is_console())

((Console&)con).clear();

else

{

con.printerr("No console to clear.\n");

return CR_NEEDS_CONSOLE;

}

}

else if(first == "die")

{

_exit(666);

}

else if(first == "script")

{

if(parts.size() == 1)

{

loadScriptFile(con, parts[0], false);

}

else

{

con << "Usage:" << endl

<< " script <filename>" << endl;

return CR_WRONG_USAGE;

}

}

else

{

command_result res = plug_mgr->InvokeCommand(con, first, parts);

if(res == CR_NOT_IMPLEMENTED)

{

auto filename = getHackPath() + "scripts/" + first;

std::string completed;

if (fileExists(filename + ".lua"))

res = runLuaScript(con, first, parts);

else if (plug_mgr->ruby && plug_mgr->ruby->is_enabled() && fileExists(filename + ".rb"))

res = runRubyScript(con, plug_mgr, first, parts);

else if (try_autocomplete(con, first, completed))

return CR_NOT_IMPLEMENTED;// runCommand(con, completed, parts);

else

con.printerr("%s is not a recognized command.\n", first.c_str());

}

else if (res == CR_NEEDS_CONSOLE)

con.printerr("%s needs interactive console to work.\n", first.c_str());

return res;

}

return CR_OK;

}

return CR_NOT_IMPLEMENTED;

{

if(!silent)

out << "Loading script at " << fname << std::endl;

ifstream script(fname.c_str());

if (script.good())

{

string command;

while (getline(script, command))

{

if (!command.empty())

runCommand(out, command);

}

return true;

}

else

{

if(!silent)

out.printerr("Error loading script\n");

return false;

}

{

if (!core->loadScriptFile(out, "dfhack.init", true))

{

core->runCommand(out, "gui/no-dfhack-init");

core->loadScriptFile(out, "dfhack.init-example", true);

}

{

IODATA * iod = ((IODATA*) iodata);

Core * core = iod->core;

color_ostream_proxy out(core->getConsole());

run_dfhack_init(out, core);

{

IODATA * iod = ((IODATA*) iodata);

Core * core = iod->core;

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

CommandHistory main_history;

main_history.load("dfhack.history");

Console & con = core->getConsole();

if (plug_mgr == 0)

{

con.printerr("Something horrible happened in Core's constructor...\n");

return;

}

run_dfhack_init(con, core);

con.print("DFHack is ready. Have a nice day!\n"

"Type in '?' or 'help' for general help, 'ls' to see all commands.\n");

int clueless_counter = 0;

while (true)

{

string command = "";

int ret = con.lineedit("[DFHack]# ",command, main_history);

if(ret == -2)

{

cerr << "Console is shutting down properly." << endl;

return;

}

else if(ret == -1)

{

cerr << "Console caught an unspecified error." << endl;

continue;

}

else if(ret)

{

// a proper, non-empty command was entered

main_history.add(command);

main_history.save("dfhack.history");

}

auto rv = core->runCommand(con, command);

if (rv == CR_NOT_IMPLEMENTED)

clueless_counter++;

if(clueless_counter == 3)

{

con.print("Do 'help' or '?' for the list of available commands.\n");

clueless_counter = 0;

}

}

{

d = new Private();

// init the console. This must be always the first step!

plug_mgr = 0;

vif = 0;

p = 0;

errorstate = false;

vinfo = 0;

started = false;

memset(&(s_mods), 0, sizeof(s_mods));

// set up hotkey capture

hotkey_set = false;

HotkeyMutex = 0;

HotkeyCond = 0;

misc_data_mutex=0;

last_world_data_ptr = NULL;

last_local_map_ptr = NULL;

last_pause_state = false;

top_viewscreen = NULL;

screen_window = NULL;

server = NULL;

color_ostream::log_errors_to_stderr = true;

{

stringstream out;

out << output ;

if(deactivate)

out << "DFHack will now deactivate.\n";

if(con.isInited())

{

con.printerr("%s", out.str().c_str());

}

fprintf(stderr, "%s\n", out.str().c_str());

#ifndef LINUX_BUILD

out << "Check file stderr.log for details\n";

MessageBox(0,out.str().c_str(),"DFHack error!", MB_OK | MB_ICONERROR);

#endif

{

#ifdef LINUX_BUILD

return p->getPath() + "/hack/";

#else

return p->getPath() + "\\hack\\";

#endif

{

if(started)

return true;

if(errorstate)

return false;

// find out what we are...

#ifdef LINUX_BUILD

const char * path = "hack/symbols.xml";

#else

const char * path = "hack\\symbols.xml";

#endif

vif = new DFHack::VersionInfoFactory();

cerr << "Identifying DF version.\n";

try

{

vif->loadFile(path);

}

catch(Error::All & err)

{

std::stringstream out;

out << "Error while reading symbols.xml:\n";

out << err.what() << std::endl;

delete vif;

vif = NULL;

errorstate = true;

fatal(out.str(), true);

return false;

}

p = new DFHack::Process(vif);

vinfo = p->getDescriptor();

if(!vinfo || !p->isIdentified())

{

fatal ("Not a known DF version.\n", true);

errorstate = true;

delete p;

p = NULL;

return false;

}

cerr << "Version: " << vinfo->getVersion() << endl;

// Init global object pointers

df::global::InitGlobals();

cerr << "Initializing Console.\n";

// init the console.

bool is_text_mode = false;

if(init && init->display.flag.is_set(init_display_flags::TEXT))

{

is_text_mode = true;

con.init(true);

cerr << "Console is not available. Use dfhack-run to send commands.\n";

}