size_t PluginEngine::loadPlugins( const std::string & pluginFldr ) {
// 1. get all files in pluginFldr that conform to a platform-dependent
// naming convention.
// 2. For each one, try to open it and determine if it has the interface
// expected for this plugin engine
// 3. If it does, register it with the appropriate manager.
// (NOt entirely sure what this means yet...ultimately, the manager
// has to be able to provide information about the entity in the
// plug-in and provide the ability to insantiate it. "information"
// may also include the ability to parse itself from the xml.
StringList files;
#ifdef _MSC_VER
std::string extension( "*.dll" );
#else
std::string extension( "*.so" );
#endif
if ( !os::listdir( pluginFldr, files, extension ) ) {
return 0;
}
StringListCItr itr = files.begin();
for ( ; itr != files.end(); ++itr ) {
std::string fullPath;
if ( ! os::path::absPath( os::path::join( 2, pluginFldr.c_str(), (*itr).c_str() ), fullPath ) ) {
logger << Logger::ERR_MSG << "Unable to get absolute path for " << (*itr);
continue;
}
Plugin * plugin;
try {
plugin = new Plugin( fullPath );
} catch ( std::exception & ) {
logger << Logger::ERR_MSG << "Failed loading " << fullPath << " as a plug-in";
continue;
}
logger << Logger::INFO_MSG << "Loaded: " << plugin->getName() << "\n";;
logger << "\t" << plugin->getDescription();
plugin->registerPlugin( this );
_plugins.insert( PluginMap::value_type( (*itr), plugin ) );
}
return files.size();
}
const VampPluginDescriptor *
PluginAdapterBase::Impl::getDescriptor()
{
#ifdef DEBUG_PLUGIN_ADAPTER
std::cerr << "PluginAdapterBase::Impl[" << this << "]::getDescriptor" << std::endl;
#endif
if (m_populated) return &m_descriptor;
Plugin *plugin = m_base->createPlugin(48000);
if (plugin->getVampApiVersion() != VAMP_API_VERSION) {
std::cerr << "Vamp::PluginAdapterBase::Impl::getDescriptor: ERROR: "
<< "Plugin object API version "
<< plugin->getVampApiVersion()
<< " does not match actual API version "
<< VAMP_API_VERSION << std::endl;
delete plugin;
return 0;
}
m_parameters = plugin->getParameterDescriptors();
m_programs = plugin->getPrograms();
m_descriptor.vampApiVersion = plugin->getVampApiVersion();
m_descriptor.identifier = strdup(plugin->getIdentifier().c_str());
m_descriptor.name = strdup(plugin->getName().c_str());
m_descriptor.description = strdup(plugin->getDescription().c_str());
m_descriptor.maker = strdup(plugin->getMaker().c_str());
m_descriptor.pluginVersion = plugin->getPluginVersion();
m_descriptor.copyright = strdup(plugin->getCopyright().c_str());
m_descriptor.parameterCount = m_parameters.size();
m_descriptor.parameters = (const VampParameterDescriptor **)
malloc(m_parameters.size() * sizeof(VampParameterDescriptor));
unsigned int i;
for (i = 0; i < m_parameters.size(); ++i) {
VampParameterDescriptor *desc = (VampParameterDescriptor *)
malloc(sizeof(VampParameterDescriptor));
desc->identifier = strdup(m_parameters[i].identifier.c_str());
desc->name = strdup(m_parameters[i].name.c_str());
desc->description = strdup(m_parameters[i].description.c_str());
desc->unit = strdup(m_parameters[i].unit.c_str());
desc->minValue = m_parameters[i].minValue;
desc->maxValue = m_parameters[i].maxValue;
desc->defaultValue = m_parameters[i].defaultValue;
desc->isQuantized = m_parameters[i].isQuantized;
desc->quantizeStep = m_parameters[i].quantizeStep;
desc->valueNames = 0;
if (desc->isQuantized && !m_parameters[i].valueNames.empty()) {
desc->valueNames = (const char **)
malloc((m_parameters[i].valueNames.size()+1) * sizeof(char *));
for (unsigned int j = 0; j < m_parameters[i].valueNames.size(); ++j) {
desc->valueNames[j] = strdup(m_parameters[i].valueNames[j].c_str());
}
desc->valueNames[m_parameters[i].valueNames.size()] = 0;
}
m_descriptor.parameters[i] = desc;
}
m_descriptor.programCount = m_programs.size();
m_descriptor.programs = (const char **)
malloc(m_programs.size() * sizeof(const char *));
for (i = 0; i < m_programs.size(); ++i) {
m_descriptor.programs[i] = strdup(m_programs[i].c_str());
}
if (plugin->getInputDomain() == Plugin::FrequencyDomain) {
m_descriptor.inputDomain = vampFrequencyDomain;
} else {
m_descriptor.inputDomain = vampTimeDomain;
}
m_descriptor.instantiate = vampInstantiate;
m_descriptor.cleanup = vampCleanup;
m_descriptor.initialise = vampInitialise;
m_descriptor.reset = vampReset;
m_descriptor.getParameter = vampGetParameter;
m_descriptor.setParameter = vampSetParameter;
m_descriptor.getCurrentProgram = vampGetCurrentProgram;
m_descriptor.selectProgram = vampSelectProgram;
m_descriptor.getPreferredStepSize = vampGetPreferredStepSize;
m_descriptor.getPreferredBlockSize = vampGetPreferredBlockSize;
m_descriptor.getMinChannelCount = vampGetMinChannelCount;
m_descriptor.getMaxChannelCount = vampGetMaxChannelCount;
m_descriptor.getOutputCount = vampGetOutputCount;
m_descriptor.getOutputDescriptor = vampGetOutputDescriptor;
m_descriptor.releaseOutputDescriptor = vampReleaseOutputDescriptor;
m_descriptor.process = vampProcess;
m_descriptor.getRemainingFeatures = vampGetRemainingFeatures;
m_descriptor.releaseFeatureSet = vampReleaseFeatureSet;
if (!m_adapterMap) {
m_adapterMap = new AdapterMap;
}
(*m_adapterMap)[&m_descriptor] = this;
delete plugin;
m_populated = true;
return &m_descriptor;
}
LRESULT PluginListView::notify(WPARAM /*wParam*/, LPARAM lParam)
{
switch (((LPNMHDR)lParam)->code)
{
case LVN_GETDISPINFO:
{
if (_listMode == LISTMODE_LIST)
{
NMLVDISPINFO* plvdi = (NMLVDISPINFO*)lParam;
Plugin* plugin = reinterpret_cast<Plugin*>(plvdi->item.lParam);
switch (plvdi->item.iSubItem)
{
case 0:
{
plvdi->item.pszText = const_cast<TCHAR*>(plugin->getName().c_str());
break;
}
case 1:
{
plvdi->item.pszText = const_cast<TCHAR*>(plugin->getCategory().c_str());
break;
}
default:
if (plvdi->item.iSubItem == _nVersionColumns + 2)
{
plvdi->item.pszText = const_cast<TCHAR*>(plugin->getStability().c_str());
}
else
{
switch(_columns[plvdi->item.iSubItem - 2])
{
case VERSION_INSTALLED:
plvdi->item.pszText = plugin->getInstalledVersion().getDisplayString();
plvdi->item.cchTextMax = (int)_tcslen(plvdi->item.pszText);
break;
case VERSION_AVAILABLE:
plvdi->item.pszText = plugin->getVersion().getDisplayString();
plvdi->item.cchTextMax = (int)_tcslen(plvdi->item.pszText);
break;
}
}
break;
}
return TRUE;
}
break;
}
case LVN_COLUMNCLICK:
{
NMLISTVIEW *colInfo = reinterpret_cast<NMLISTVIEW*>(lParam);
int (CALLBACK *compareFunc)(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort) = NULL;
LVSORTCOLUMN sortColumn = LVSORTCOLUMN_NAME;
if (colInfo->iSubItem < 2 || colInfo->iSubItem == _nVersionColumns + 2)
{
compareFunc = PluginListView::stringComparer;
if (colInfo->iSubItem == 1)
{
sortColumn = LVSORTCOLUMN_CATEGORY;
}
else if (colInfo->iSubItem == _nVersionColumns + 2)
{
sortColumn = LVSORTCOLUMN_STABILITY;
}
}
else
{
compareFunc = PluginListView::versionComparer;
switch(_columns[colInfo->iSubItem - 2])
{
case VERSION_AVAILABLE:
sortColumn = LVSORTCOLUMN_VERSIONAVAILABLE;
break;
case VERSION_INSTALLED:
sortColumn = LVSORTCOLUMN_VERSIONINSTALLED;
break;
// Just in case there's another one introduced at some point (beta version or something)
default:
sortColumn = LVSORTCOLUMN_VERSIONAVAILABLE;
break;
}
}
ListView_SortItems(_hListView, compareFunc, static_cast<LPARAM>(sortColumn));
}
break;
case NM_CLICK:
if (_hDescription && lParam)
{
LPNMITEMACTIVATE itemActivate = reinterpret_cast<LPNMITEMACTIVATE>(lParam);
if (itemActivate->iItem >= 0)
{
ListView_SetItemState(_hListView, getCurrentSelectedIndex(), 0, LVIS_SELECTED);
ListView_SetItemState(_hListView, itemActivate->iItem, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
}
}
break;
case LVN_ITEMCHANGED:
{
LPNMLISTVIEW pnmv = reinterpret_cast<LPNMLISTVIEW>(lParam);
if (pnmv->uNewState & LVIS_SELECTED)
{
Plugin* plugin = reinterpret_cast<Plugin*>(pnmv->lParam);
if (plugin && _hDescription)
{
if (_displayUpdateDesc)
::SendMessage(_hDescription, WM_SETTEXT, 0, reinterpret_cast<LPARAM>(plugin->getUpdateDescription().c_str()));
else
::SendMessage(_hDescription, WM_SETTEXT, 0, reinterpret_cast<LPARAM>(plugin->getDescription().c_str()));
}
}
}
}
return FALSE;
}
void
printPluginCategoryList()
{
PluginLoader *loader = PluginLoader::getInstance();
vector<PluginLoader::PluginKey> plugins = loader->listPlugins();
set<string> printedcats;
for (size_t i = 0; i < plugins.size(); ++i) {
PluginLoader::PluginKey key = plugins[i];
PluginLoader::PluginCategoryHierarchy category =
loader->getPluginCategory(key);
Plugin *plugin = loader->loadPlugin(key, 48000);
if (!plugin) continue;
string catstr = "";
if (category.empty()) catstr = '|';
else {
for (size_t j = 0; j < category.size(); ++j) {
catstr += category[j];
catstr += '|';
if (printedcats.find(catstr) == printedcats.end()) {
std::cout << catstr << std::endl;
printedcats.insert(catstr);
}
}
}
std::cout << catstr << key << ":::" << plugin->getName() << ":::" << plugin->getMaker() << ":::" << plugin->getDescription() << std::endl;
}
}
void
enumeratePlugins(Verbosity verbosity)
{
PluginLoader *loader = PluginLoader::getInstance();
if (verbosity == PluginInformation) {
cout << "\nVamp plugin libraries found in search path:" << endl;
}
vector<PluginLoader::PluginKey> plugins = loader->listPlugins();
typedef multimap<string, PluginLoader::PluginKey>
LibraryMap;
LibraryMap libraryMap;
for (size_t i = 0; i < plugins.size(); ++i) {
string path = loader->getLibraryPathForPlugin(plugins[i]);
libraryMap.insert(LibraryMap::value_type(path, plugins[i]));
}
string prevPath = "";
int index = 0;
for (LibraryMap::iterator i = libraryMap.begin();
i != libraryMap.end(); ++i) {
string path = i->first;
PluginLoader::PluginKey key = i->second;
if (path != prevPath) {
prevPath = path;
index = 0;
if (verbosity == PluginInformation) {
cout << "\n " << path << ":" << endl;
} else if (verbosity == PluginInformationDetailed) {
string::size_type ki = i->second.find(':');
string text = "Library \"" + i->second.substr(0, ki) + "\"";
cout << "\n" << header(text, 1);
}
}
Plugin *plugin = loader->loadPlugin(key, 48000);
if (plugin) {
char c = char('A' + index);
if (c > 'Z') c = char('a' + (index - 26));
PluginLoader::PluginCategoryHierarchy category =
loader->getPluginCategory(key);
string catstr;
if (!category.empty()) {
for (size_t ci = 0; ci < category.size(); ++ci) {
if (ci > 0) catstr += " > ";
catstr += category[ci];
}
}
if (verbosity == PluginInformation) {
cout << " [" << c << "] [v"
<< plugin->getVampApiVersion() << "] "
<< plugin->getName() << ", \""
<< plugin->getIdentifier() << "\"" << " ["
<< plugin->getMaker() << "]" << endl;
if (catstr != "") {
cout << " > " << catstr << endl;
}
if (plugin->getDescription() != "") {
cout << " - " << plugin->getDescription() << endl;
}
} else if (verbosity == PluginInformationDetailed) {
cout << header(plugin->getName(), 2);
cout << " - Identifier: "
<< key << endl;
cout << " - Plugin Version: "
<< plugin->getPluginVersion() << endl;
cout << " - Vamp API Version: "
<< plugin->getVampApiVersion() << endl;
cout << " - Maker: \""
<< plugin->getMaker() << "\"" << endl;
cout << " - Copyright: \""
<< plugin->getCopyright() << "\"" << endl;
cout << " - Description: \""
<< plugin->getDescription() << "\"" << endl;
cout << " - Input Domain: "
<< (plugin->getInputDomain() == Vamp::Plugin::TimeDomain ?
"Time Domain" : "Frequency Domain") << endl;
cout << " - Default Step Size: "
<< plugin->getPreferredStepSize() << endl;
cout << " - Default Block Size: "
<< plugin->getPreferredBlockSize() << endl;
cout << " - Minimum Channels: "
<< plugin->getMinChannelCount() << endl;
cout << " - Maximum Channels: "
<< plugin->getMaxChannelCount() << endl;
} else if (verbosity == PluginIds) {
cout << "vamp:" << key << endl;
}
Plugin::OutputList outputs =
plugin->getOutputDescriptors();
if (verbosity == PluginInformationDetailed) {
Plugin::ParameterList params = plugin->getParameterDescriptors();
for (size_t j = 0; j < params.size(); ++j) {
Plugin::ParameterDescriptor &pd(params[j]);
cout << "\nParameter " << j+1 << ": \"" << pd.name << "\"" << endl;
cout << " - Identifier: " << pd.identifier << endl;
cout << " - Description: \"" << pd.description << "\"" << endl;
if (pd.unit != "") {
cout << " - Unit: " << pd.unit << endl;
}
cout << " - Range: ";
cout << pd.minValue << " -> " << pd.maxValue << endl;
cout << " - Default: ";
cout << pd.defaultValue << endl;
if (pd.isQuantized) {
cout << " - Quantize Step: "
<< pd.quantizeStep << endl;
}
if (!pd.valueNames.empty()) {
cout << " - Value Names: ";
for (size_t k = 0; k < pd.valueNames.size(); ++k) {
if (k > 0) cout << ", ";
cout << "\"" << pd.valueNames[k] << "\"";
}
cout << endl;
}
}
if (outputs.empty()) {
cout << "\n** Note: This plugin reports no outputs!" << endl;
}
for (size_t j = 0; j < outputs.size(); ++j) {
Plugin::OutputDescriptor &od(outputs[j]);
cout << "\nOutput " << j+1 << ": \"" << od.name << "\"" << endl;
cout << " - Identifier: " << od.identifier << endl;
cout << " - Description: \"" << od.description << "\"" << endl;
if (od.unit != "") {
cout << " - Unit: " << od.unit << endl;
}
if (od.hasFixedBinCount) {
cout << " - Default Bin Count: " << od.binCount << endl;
}
if (!od.binNames.empty()) {
bool have = false;
for (size_t k = 0; k < od.binNames.size(); ++k) {
if (od.binNames[k] != "") {
have = true; break;
}
}
if (have) {
cout << " - Bin Names: ";
for (size_t k = 0; k < od.binNames.size(); ++k) {
if (k > 0) cout << ", ";
cout << "\"" << od.binNames[k] << "\"";
}
cout << endl;
}
}
if (od.hasKnownExtents) {
cout << " - Default Extents: ";
cout << od.minValue << " -> " << od.maxValue << endl;
}
if (od.isQuantized) {
cout << " - Quantize Step: "
<< od.quantizeStep << endl;
}
cout << " - Sample Type: "
<< (od.sampleType ==
Plugin::OutputDescriptor::OneSamplePerStep ?
"One Sample Per Step" :
od.sampleType ==
Plugin::OutputDescriptor::FixedSampleRate ?
"Fixed Sample Rate" :
"Variable Sample Rate") << endl;
if (od.sampleType !=
Plugin::OutputDescriptor::OneSamplePerStep) {
cout << " - Default Rate: "
<< od.sampleRate << endl;
}
cout << " - Has Duration: "
<< (od.hasDuration ? "Yes" : "No") << endl;
}
}
if (outputs.size() > 1 || verbosity == PluginOutputIds) {
for (size_t j = 0; j < outputs.size(); ++j) {
if (verbosity == PluginInformation) {
cout << " (" << j << ") "
<< outputs[j].name << ", \""
<< outputs[j].identifier << "\"" << endl;
if (outputs[j].description != "") {
cout << " - "
<< outputs[j].description << endl;
}
} else if (verbosity == PluginOutputIds) {
cout << "vamp:" << key << ":" << outputs[j].identifier << endl;
}
}
}
++index;
delete plugin;
}
}
if (verbosity == PluginInformation ||
verbosity == PluginInformationDetailed) {
cout << endl;
}
}
int mtsutil(int argc, char **argv) {
char optchar, *end_ptr = NULL;
try {
/* Default settings */
int nprocs = getProcessorCount();
std::string nodeName = getHostName(),
networkHosts = "", destFile="";
bool quietMode = false;
ELogLevel logLevel = EInfo;
FileResolver *fileResolver = Thread::getThread()->getFileResolver();
bool testCaseMode = false;
if (argc < 2) {
help();
return 0;
}
optind = 1;
/* Parse command-line arguments */
while ((optchar = getopt(argc, argv, "+a:c:s:n:p:qhvt")) != -1) {
switch (optchar) {
case 'a': {
std::vector<std::string> paths = tokenize(optarg, ";");
for (unsigned int i=0; i<paths.size(); ++i)
fileResolver->addPath(paths[i]);
}
break;
case 'c':
networkHosts = networkHosts + std::string(";") + std::string(optarg);
break;
case 't':
testCaseMode = true;
break;
case 's': {
std::ifstream is(optarg);
if (is.fail())
SLog(EError, "Could not open host file!");
std::string host;
while (is >> host) {
if (host.length() < 1 || host.c_str()[0] == '#')
continue;
networkHosts = networkHosts + std::string(";") + host;
}
}
break;
case 'n':
nodeName = optarg;
break;
case 'v':
logLevel = EDebug;
break;
case 'p':
nprocs = strtol(optarg, &end_ptr, 10);
if (*end_ptr != '\0')
SLog(EError, "Could not parse the processor count!");
break;
case 'q':
quietMode = true;
break;
case 'h':
default:
help();
return 0;
}
}
/* Configure the logging subsystem */
ref<Logger> log = Thread::getThread()->getLogger();
log->setLogLevel(logLevel);
/* Initialize OpenMP */
Thread::initializeOpenMP(nprocs);
/* Disable the default appenders */
for (size_t i=0; i<log->getAppenderCount(); ++i) {
Appender *appender = log->getAppender(i);
if (appender->getClass()->derivesFrom(MTS_CLASS(StreamAppender)))
log->removeAppender(appender);
}
log->addAppender(new StreamAppender(formatString("mitsuba.%s.log", nodeName.c_str())));
if (!quietMode)
log->addAppender(new StreamAppender(&std::cout));
SLog(EInfo, "Mitsuba version %s, Copyright (c) " MTS_YEAR " Wenzel Jakob",
Version(MTS_VERSION).toStringComplete().c_str());
/* Configure the scheduling subsystem */
Scheduler *scheduler = Scheduler::getInstance();
for (int i=0; i<nprocs; ++i)
scheduler->registerWorker(new LocalWorker(formatString("wrk%i", i)));
std::vector<std::string> hosts = tokenize(networkHosts, ";");
/* Establish network connections to nested servers */
for (size_t i=0; i<hosts.size(); ++i) {
const std::string &hostName = hosts[i];
ref<Stream> stream;
if (hostName.find("@") == std::string::npos) {
int port = MTS_DEFAULT_PORT;
std::vector<std::string> tokens = tokenize(hostName, ":");
if (tokens.size() == 0 || tokens.size() > 2) {
SLog(EError, "Invalid host specification '%s'!", hostName.c_str());
} else if (tokens.size() == 2) {
port = strtol(tokens[1].c_str(), &end_ptr, 10);
if (*end_ptr != '\0')
SLog(EError, "Invalid host specification '%s'!", hostName.c_str());
}
stream = new SocketStream(tokens[0], port);
} else {
std::string path = "~/mitsuba"; // default path if not specified
std::vector<std::string> tokens = tokenize(hostName, "@:");
if (tokens.size() < 2 || tokens.size() > 3) {
SLog(EError, "Invalid host specification '%s'!", hostName.c_str());
} else if (tokens.size() == 3) {
path = tokens[2];
}
std::vector<std::string> cmdLine;
cmdLine.push_back(formatString("bash -c 'cd %s; . setpath.sh; mtssrv -ls'", path.c_str()));
stream = new SSHStream(tokens[0], tokens[1], cmdLine);
}
try {
scheduler->registerWorker(new RemoteWorker(formatString("net%i", i), stream));
} catch (std::runtime_error &e) {
if (hostName.find("@") != std::string::npos) {
#if defined(WIN32)
SLog(EWarn, "Please ensure that passwordless authentication "
"using plink.exe and pageant.exe is enabled (see the documentation for more information)");
#else
SLog(EWarn, "Please ensure that passwordless authentication "
"is enabled (e.g. using ssh-agent - see the documentation for more information)");
#endif
}
throw e;
}
}
scheduler->start();
if (testCaseMode) {
std::vector<fs::path> dirPaths = fileResolver->resolveAll("plugins");
std::set<std::string> seen;
int executed = 0, succeeded = 0;
for (size_t i=0; i<dirPaths.size(); ++i) {
fs::path dirPath = fs::complete(dirPaths[i]);
if (!fs::exists(dirPath) || !fs::is_directory(dirPath))
break;
fs::directory_iterator end, it(dirPath);
for (; it != end; ++it) {
if (!fs::is_regular_file(it->status()))
continue;
std::string extension(boost::to_lower_copy(it->path().extension()));
#if defined(WIN32)
if (extension != ".dll")
continue;
#elif defined(__OSX__)
if (extension != ".dylib")
continue;
#elif defined(__LINUX__)
if (extension != ".so")
continue;
#else
#error Unknown operating system!
#endif
std::string shortName = it->path().stem();
if (seen.find(shortName) != seen.end() || !boost::starts_with(shortName, "test_"))
continue;
seen.insert(shortName);
Plugin plugin(shortName, it->path());
if (!plugin.isUtility())
continue;
ref<Utility> utility = plugin.createUtility();
TestCase *testCase = static_cast<TestCase *>(utility.get());
if (!utility->getClass()->derivesFrom(MTS_CLASS(TestCase)))
SLog(EError, "This is not a test case!");
if (testCase->run(argc-optind, argv+optind) != 0)
SLog(EError, "Testcase unexpectedly returned with a nonzero value.");
executed += testCase->getExecuted();
succeeded += testCase->getSucceeded();
}
}
SLog(EInfo, "Ran %i tests, %i succeeded, %i failed.", executed, succeeded, executed-succeeded);
} else {
if (argc <= optind) {
std::cerr << "A utility name must be supplied!" << endl;
return -1;
}
fs::path pluginName(argv[optind]);
/* Build the full plugin file name */
#if defined(WIN32)
pluginName.replace_extension(".dll");
#elif defined(__OSX__)
pluginName.replace_extension(".dylib");
#elif defined(__LINUX__)
pluginName.replace_extension(".so");
#else
#error Unknown operating system!
#endif
fs::path fullName = fileResolver->resolve(fs::path("plugins") / pluginName);
if (!fs::exists(fullName)) {
/* Plugin not found! */
SLog(EError, "Utility \"%s\" not found (run \"mtsutil\" without arguments to "
"see a list of available utilities)", fullName.file_string().c_str());
}
SLog(EInfo, "Loading utility \"%s\" ..", argv[optind]);
Plugin *plugin = new Plugin(argv[optind], fullName);
if (!plugin->isUtility())
SLog(EError, "This plugin does not implement the 'Utility' interface!");
Statistics::getInstance()->logPlugin(argv[optind], plugin->getDescription());
ref<Utility> utility = plugin->createUtility();
int retval = utility->run(argc-optind, argv+optind);
scheduler->pause();
utility = NULL;
delete plugin;
return retval;
}
} catch (const std::exception &e) {
std::cerr << "Caught a critical exeption: " << e.what() << std::endl;
} catch (...) {
std::cerr << "Caught a critical exeption of unknown type!" << endl;
}
return 0;
}
