395 lines
9.3 KiB
C++
395 lines
9.3 KiB
C++
/*
|
|
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 "dfhack/Core.h"
|
|
#include "dfhack/Process.h"
|
|
#include "dfhack/PluginManager.h"
|
|
#include "dfhack/Console.h"
|
|
using namespace DFHack;
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <map>
|
|
using namespace std;
|
|
|
|
#ifdef LINUX_BUILD
|
|
#include <dirent.h>
|
|
#include <errno.h>
|
|
#else
|
|
#include "wdirent.h"
|
|
#endif
|
|
|
|
static int getdir (string dir, vector<string> &files)
|
|
{
|
|
DIR *dp;
|
|
struct dirent *dirp;
|
|
if((dp = opendir(dir.c_str())) == NULL)
|
|
{
|
|
return errno;
|
|
}
|
|
while ((dirp = readdir(dp)) != NULL) {
|
|
files.push_back(string(dirp->d_name));
|
|
}
|
|
closedir(dp);
|
|
return 0;
|
|
}
|
|
|
|
bool hasEnding (std::string const &fullString, std::string const &ending)
|
|
{
|
|
if (fullString.length() > ending.length())
|
|
{
|
|
return (0 == fullString.compare (fullString.length() - ending.length(), ending.length(), ending));
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
struct Plugin::RefLock
|
|
{
|
|
RefLock()
|
|
{
|
|
refcount = 0;
|
|
wakeup = SDL_CreateCond();
|
|
mut = SDL_CreateMutex();
|
|
}
|
|
~RefLock()
|
|
{
|
|
SDL_DestroyCond(wakeup);
|
|
SDL_DestroyMutex(mut);
|
|
}
|
|
void lock()
|
|
{
|
|
SDL_mutexP(mut);
|
|
}
|
|
void unlock()
|
|
{
|
|
SDL_mutexV(mut);
|
|
}
|
|
void lock_add()
|
|
{
|
|
SDL_mutexP(mut);
|
|
refcount ++;
|
|
SDL_mutexV(mut);
|
|
}
|
|
void lock_sub()
|
|
{
|
|
SDL_mutexP(mut);
|
|
refcount --;
|
|
SDL_CondSignal(wakeup);
|
|
SDL_mutexV(mut);
|
|
}
|
|
void operator++()
|
|
{
|
|
refcount ++;
|
|
}
|
|
void operator--()
|
|
{
|
|
refcount --;
|
|
SDL_CondSignal(wakeup);
|
|
}
|
|
void wait()
|
|
{
|
|
while(refcount)
|
|
{
|
|
SDL_CondWait(wakeup, mut);
|
|
}
|
|
}
|
|
SDL::Cond * wakeup;
|
|
SDL::Mutex * mut;
|
|
int refcount;
|
|
};
|
|
Plugin::Plugin(Core * core, const std::string & filepath, const std::string & _filename, PluginManager * pm)
|
|
{
|
|
filename = filepath;
|
|
parent = pm;
|
|
name.reserve(_filename.size());
|
|
for(int i = 0; i < _filename.size();i++)
|
|
{
|
|
char ch = _filename[i];
|
|
if(ch == '.')
|
|
break;
|
|
name.append(1,ch);
|
|
}
|
|
Console & con = core->con;
|
|
plugin_lib = 0;
|
|
plugin_init = 0;
|
|
plugin_shutdown = 0;
|
|
plugin_status = 0;
|
|
plugin_onupdate = 0;
|
|
state = PS_UNLOADED;
|
|
access = new RefLock();
|
|
}
|
|
|
|
Plugin::~Plugin()
|
|
{
|
|
if(state == PS_LOADED)
|
|
{
|
|
unload();
|
|
}
|
|
delete access;
|
|
}
|
|
|
|
bool Plugin::load()
|
|
{
|
|
access->lock();
|
|
if(state == PS_BROKEN)
|
|
{
|
|
access->unlock();
|
|
return false;
|
|
}
|
|
else if(state == PS_LOADED)
|
|
{
|
|
access->unlock();
|
|
return true;
|
|
}
|
|
Core & c = Core::getInstance();
|
|
Console & con = c.con;
|
|
DFLibrary * plug = OpenPlugin(filename.c_str());
|
|
if(!plug)
|
|
{
|
|
con.printerr("Can't load plugin %s\n", filename.c_str());
|
|
state = PS_BROKEN;
|
|
access->unlock();
|
|
return false;
|
|
}
|
|
const char * (*_PlugName)() =(const char * (*)()) LookupPlugin(plug, "plugin_name");
|
|
if(!_PlugName)
|
|
{
|
|
con.printerr("Plugin %s has no name.\n", filename.c_str());
|
|
ClosePlugin(plug);
|
|
state = PS_BROKEN;
|
|
access->unlock();
|
|
return false;
|
|
}
|
|
plugin_init = (command_result (*)(Core *, std::vector <PluginCommand> &)) LookupPlugin(plug, "plugin_init");
|
|
if(!plugin_init)
|
|
{
|
|
con.printerr("Plugin %s has no init function.\n", filename.c_str());
|
|
ClosePlugin(plug);
|
|
state = PS_BROKEN;
|
|
access->unlock();
|
|
return false;
|
|
}
|
|
plugin_status = (command_result (*)(Core *, std::string &)) LookupPlugin(plug, "plugin_status");
|
|
plugin_onupdate = (command_result (*)(Core *)) LookupPlugin(plug, "plugin_onupdate");
|
|
plugin_shutdown = (command_result (*)(Core *)) LookupPlugin(plug, "plugin_shutdown");
|
|
//name = _PlugName();
|
|
plugin_lib = plug;
|
|
if(plugin_init(&c,commands) == CR_OK)
|
|
{
|
|
state = PS_LOADED;
|
|
parent->registerCommands(this);
|
|
access->unlock();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
con.printerr("Plugin %s has failed to initialize properly.\n", filename.c_str());
|
|
ClosePlugin(plugin_lib);
|
|
state = PS_BROKEN;
|
|
access->unlock();
|
|
return false;
|
|
}
|
|
// not reachable
|
|
}
|
|
|
|
bool Plugin::unload()
|
|
{
|
|
Core & c = Core::getInstance();
|
|
Console & con = c.con;
|
|
// get the mutex
|
|
access->lock();
|
|
// if we are actually loaded
|
|
if(state == PS_LOADED)
|
|
{
|
|
// notify plugin about shutdown
|
|
command_result cr = plugin_shutdown(&Core::getInstance());
|
|
// wait for all calls to finish
|
|
access->wait();
|
|
// cleanup...
|
|
parent->unregisterCommands(this);
|
|
if(cr == CR_OK)
|
|
{
|
|
ClosePlugin(plugin_lib);
|
|
state = PS_UNLOADED;
|
|
access->unlock();
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
con.printerr("Plugin %s has failed to shutdown!\n",name.c_str());
|
|
state = PS_BROKEN;
|
|
access->unlock();
|
|
return false;
|
|
}
|
|
}
|
|
else if(state == PS_UNLOADED)
|
|
{
|
|
access->unlock();
|
|
return true;
|
|
}
|
|
access->unlock();
|
|
return false;
|
|
}
|
|
|
|
bool Plugin::reload()
|
|
{
|
|
if(state != PS_LOADED)
|
|
return false;
|
|
if(!unload())
|
|
return false;
|
|
if(!load())
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
command_result Plugin::invoke( std::string & command, std::vector <std::string> & parameters)
|
|
{
|
|
Core & c = Core::getInstance();
|
|
command_result cr = CR_NOT_IMPLEMENTED;
|
|
access->lock_add();
|
|
if(state == PS_LOADED)
|
|
{
|
|
for (int i = 0; i < commands.size();i++)
|
|
{
|
|
if(commands[i].name == command)
|
|
{
|
|
cr = commands[i].function(&c, parameters);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
access->lock_sub();
|
|
return cr;
|
|
}
|
|
|
|
command_result Plugin::on_update()
|
|
{
|
|
Core & c = Core::getInstance();
|
|
command_result cr = CR_NOT_IMPLEMENTED;
|
|
access->lock_add();
|
|
if(state == PS_LOADED && plugin_onupdate)
|
|
{
|
|
cr = plugin_onupdate(&c);
|
|
}
|
|
access->lock_sub();
|
|
return cr;
|
|
}
|
|
|
|
Plugin::plugin_state Plugin::getState() const
|
|
{
|
|
return state;
|
|
}
|
|
|
|
PluginManager::PluginManager(Core * core)
|
|
{
|
|
#ifdef LINUX_BUILD
|
|
string path = core->p->getPath() + "/plugins/";
|
|
const string searchstr = ".plug.so";
|
|
#else
|
|
string path = core->p->getPath() + "\\plugins\\";
|
|
const string searchstr = ".plug.dll";
|
|
#endif
|
|
cmdlist_mutex = SDL_CreateMutex();
|
|
vector <string> filez;
|
|
getdir(path, filez);
|
|
for(int i = 0; i < filez.size();i++)
|
|
{
|
|
if(hasEnding(filez[i],searchstr))
|
|
{
|
|
Plugin * p = new Plugin(core, path + filez[i], filez[i], this);
|
|
all_plugins.push_back(p);
|
|
// make all plugins load by default (until a proper design emerges).
|
|
p->load();
|
|
}
|
|
}
|
|
}
|
|
|
|
PluginManager::~PluginManager()
|
|
{
|
|
for(int i = 0; i < all_plugins.size();i++)
|
|
{
|
|
delete all_plugins[i];
|
|
}
|
|
all_plugins.clear();
|
|
SDL_DestroyMutex(cmdlist_mutex);
|
|
}
|
|
|
|
Plugin *PluginManager::getPluginByName (const std::string & name)
|
|
{
|
|
for(int i = 0; i < all_plugins.size(); i++)
|
|
{
|
|
if(name == all_plugins[i]->name)
|
|
return all_plugins[i];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// FIXME: handle name collisions...
|
|
command_result PluginManager::InvokeCommand( std::string & command, std::vector <std::string> & parameters)
|
|
{
|
|
command_result cr = CR_NOT_IMPLEMENTED;
|
|
Core * c = &Core::getInstance();
|
|
SDL_mutexP(cmdlist_mutex);
|
|
map <string, Plugin *>::iterator iter = belongs.find(command);
|
|
if(iter != belongs.end())
|
|
{
|
|
cr = iter->second->invoke(command, parameters);
|
|
}
|
|
SDL_mutexV(cmdlist_mutex);
|
|
return cr;
|
|
}
|
|
|
|
void PluginManager::OnUpdate( void )
|
|
{
|
|
for(int i = 0; i < all_plugins.size(); i++)
|
|
{
|
|
all_plugins[i]->on_update();
|
|
}
|
|
}
|
|
// FIXME: doesn't check name collisions!
|
|
void PluginManager::registerCommands( Plugin * p )
|
|
{
|
|
SDL_mutexP(cmdlist_mutex);
|
|
vector <PluginCommand> & cmds = p->commands;
|
|
for(int i = 0; i < cmds.size();i++)
|
|
{
|
|
belongs[cmds[i].name] = p;
|
|
}
|
|
SDL_mutexV(cmdlist_mutex);
|
|
}
|
|
|
|
// FIXME: doesn't check name collisions!
|
|
void PluginManager::unregisterCommands( Plugin * p )
|
|
{
|
|
SDL_mutexP(cmdlist_mutex);
|
|
vector <PluginCommand> & cmds = p->commands;
|
|
for(int i = 0; i < cmds.size();i++)
|
|
{
|
|
belongs.erase(cmds[i].name);
|
|
}
|
|
SDL_mutexV(cmdlist_mutex);
|
|
} |