Plugin* Plugin::LoadPlugin(const char* pluginFile)
{
DynamicLibrary* lib = new DynamicLibrary();
if( !lib->Load(pluginFile) )
{
delete lib;
return 0;
}
PluginAccessor accessor = (PluginAccessor)lib->FindFunction("GetPlugin");
if( !accessor )
{
delete lib;
return 0;
}
Plugin* plugin = accessor(Memory::sInstance, Assert::sInstance);
if( !plugin )
{
delete lib;
return 0;
}
plugin->SetLibrary(lib);
return plugin;
}
void Application::RegisterAllPlugins()
{
std::ifstream plugins_file(cpw::ApplicationConfiguration::GetInstance()->GetPluginsFile().c_str());
if (plugins_file.is_open())
{
while (!plugins_file.eof())
{
std::string plugin;
plugins_file >> plugin;
DynamicLibrary *library = new DynamicLibrary();
if (plugin=="")
continue;
library->Load(plugin);
if (library->GetH() != NULL)
{
std::string str1;
library->RegisterPluginMenu(str1);
int id = main_frame->AddPluginMenu(str1);
plugin_map[id] = library;
}
else
if (library)
{
delete library;
library = NULL;
}
}
plugins_file.close();
}
}
Engine::ModuleSpec Engine::createModule(const String& Filename)
{
try
{
DynamicLibrary* lib = AURORA_NEW DynamicLibrary(Filename);
Module* (*moduleCreateFunc)();
// Ugly, ugly cast
moduleCreateFunc = reinterpret_cast<Module*(*)()>(lib->getSymbol("createInstance"));
if (moduleCreateFunc)
{
Module* m = moduleCreateFunc();
if (!m)
throw BadModuleException();
else
{
ModuleSpec spec;
spec.Category = m->getCategory();
spec.Name = m->getName();
spec.Lib = lib;
spec.Mod = m;
spec.SourceFilename = Filename;
spec.Installed = false;
return spec;
}
}
else throw BadModuleException();
}
catch (LibraryCallException&)
{
// Something's bad in the module, don't rethrow an internal error to the caller
throw BadModuleException();
}
}
void PluginManager::loadDynamicPlugins(std::string& plugins_path)
{
LOG_DEBUG("Loading dynamic plugins");
Poco::Path plugin_directory = Poco::Path::forDirectory(plugins_path);
plugin_directory.popDirectory();
plugin_directory.pushDirectory("plugins");
LOG_DEBUG("Plugin directory: " << plugin_directory.toString());
std::set<std::string> dll_files;
Poco::Glob::glob(plugin_directory.append(DynamicLibrary::DL_PREFIX+
"*."+
DynamicLibrary::DL_SUFFIX),
dll_files);
for (std::set<std::string>::iterator it = dll_files.begin();
it!=dll_files.end();
++it)
{
std::string plugin_file = *it;
LOG_DEBUG("Loading library " << plugin_file);
DynamicLibrary* dl = DynamicLibrary::load(plugin_file);
registerPluginFunction registerPlugin =
(registerPluginFunction)dl->getSymbol("registerPlugin");
if (registerPlugin)
{
LOG_DEBUG("Initialize Plugin " << *it);
registerPlugin(this);
} else
{
LOG_WARN("Couldn't find registerPlugin for " << *it);
}
}
}
// --- Plugin Loading ------------------------------------------------------ //
/// Loads a plugin from \p fileName. Returns \c false if an error
/// occurs.
bool PluginManager::loadPlugin(const std::string &fileName)
{
DynamicLibrary *library = new DynamicLibrary;
library->setFileName(fileName);
bool ok = library->open();
if(!ok){
std::cerr << "PluginManager: Error: Failed to load plugin: (" << fileName << "):"
<< library->errorString() << std::endl;
return false;
}
typedef Plugin* (*InitFunction)();
InitFunction initFunction = reinterpret_cast<InitFunction>(library->resolveFunction("chemkit_plugin_init"));
if(!initFunction){
std::cerr << "PluginManager: Error: Failed to load plugin: (" << fileName << "):"
<< "Plugin contains no init() function." << std::endl;
return false;
}
Plugin *plugin = initFunction();
if(!plugin){
std::cerr << "PluginManager: Error: Failed to load plugin: (" << fileName << "):"
<< "Calling the plugin's init() function failed." << std::endl;
return false;
}
plugin->setLibrary(library);
d->plugins.push_back(plugin);
return true;
}
bool Core::LoadModule(const string& cModule)
{
_lDynamicLibrary::iterator it_DynamicLibrary = m_lDynamicLibrary.find(cModule);
if (it_DynamicLibrary == m_lDynamicLibrary.end())
{
DynamicLibrary* pModule = new DynamicLibrary(cModule, mLogger);
if (pModule->CheckWork())
{
START_DLL_MODULE pFunc = (START_DLL_MODULE)pModule->GetAddress("Start_DexDynamicLibrary");
pFunc(this);
m_lDynamicLibrary[cModule] = pModule;
return true;
}
else
{
DrawLine("LoadModule: Ìîäóëü " + cModule + " íå ðàáîòàåò!", MessageTypes::MT_ERROR);
}
}
else
{
DrawLine("LoadModule: Ìîäóëü " + cModule + " óæå çàãðóæåí", MT_WARNING);
}
return false;
}
TEST(DynamicLibrary, Unsupported) {
std::string Err;
DynamicLibrary DL =
DynamicLibrary::getPermanentLibrary(LibPath().c_str(), &Err);
EXPECT_FALSE(DL.isValid());
EXPECT_EQ(Err, "dlopen() not supported on this platform");
}
ClangCheckerRegistry::ClangCheckerRegistry(ArrayRef<std::string> plugins,
DiagnosticsEngine *diags) {
registerBuiltinCheckers(*this);
for (ArrayRef<std::string>::iterator i = plugins.begin(), e = plugins.end();
i != e; ++i) {
// Get access to the plugin.
DynamicLibrary lib = DynamicLibrary::getPermanentLibrary(i->c_str());
// See if it's compatible with this build of clang.
const char *pluginAPIVersion =
(const char *) lib.getAddressOfSymbol("clang_analyzerAPIVersionString");
if (!isCompatibleAPIVersion(pluginAPIVersion)) {
warnIncompatible(diags, *i, pluginAPIVersion);
continue;
}
// Register its checkers.
RegisterCheckersFn registerPluginCheckers =
(RegisterCheckersFn) (intptr_t) lib.getAddressOfSymbol(
"clang_registerCheckers");
if (registerPluginCheckers)
registerPluginCheckers(*this);
}
}
ResourcePtr DynamicLibraryLoader::loadResource(const String& filename)
{
DynamicLibrary* dynlib = AProNew(DynamicLibrary, filename);
if(dynlib->isLoaded())
return ResourcePtr(dynlib);
else
return ResourcePtr();
}
extern "C" LLVMBool LLVMRustLoadDynamicLibrary(const char *path)
{
std::string err;
DynamicLibrary lib = DynamicLibrary::getPermanentLibrary(path, &err);
if (!lib.isValid())
LLVMRustSetLastError(err.c_str());
return lib.isValid();
}
TEST(DynamicLibrary, Shutdown) {
std::string A("PipSqueak"), B, C("SecondLib");
std::vector<std::string> Order;
{
std::string Err;
llvm_shutdown_obj Shutdown;
DynamicLibrary DL =
DynamicLibrary::getPermanentLibrary(LibPath(A).c_str(), &Err);
EXPECT_TRUE(DL.isValid());
EXPECT_TRUE(Err.empty());
SetStrings SS_0 = FuncPtr<SetStrings>(
DynamicLibrary::SearchForAddressOfSymbol("SetStrings"));
EXPECT_TRUE(SS_0 != nullptr);
SS_0(A, B);
EXPECT_EQ(B, "Local::Local(PipSqueak)");
TestOrder TO_0 = FuncPtr<TestOrder>(
DynamicLibrary::SearchForAddressOfSymbol("TestOrder"));
EXPECT_TRUE(TO_0 != nullptr);
DynamicLibrary DL2 =
DynamicLibrary::getPermanentLibrary(LibPath(C).c_str(), &Err);
EXPECT_TRUE(DL2.isValid());
EXPECT_TRUE(Err.empty());
// Should find latest version of symbols in SecondLib
SetStrings SS_1 = FuncPtr<SetStrings>(
DynamicLibrary::SearchForAddressOfSymbol("SetStrings"));
EXPECT_TRUE(SS_1 != nullptr);
EXPECT_TRUE(SS_0 != SS_1);
TestOrder TO_1 = FuncPtr<TestOrder>(
DynamicLibrary::SearchForAddressOfSymbol("TestOrder"));
EXPECT_TRUE(TO_1 != nullptr);
EXPECT_TRUE(TO_0 != TO_1);
B.clear();
SS_1(C, B);
EXPECT_EQ(B, "Local::Local(SecondLib)");
TO_0(Order);
TO_1(Order);
}
EXPECT_EQ(A, "Global::~Global");
EXPECT_EQ(B, "Local::~Local");
EXPECT_TRUE(FuncPtr<SetStrings>(DynamicLibrary::SearchForAddressOfSymbol(
"SetStrings")) == nullptr);
// Test unload/destruction ordering
EXPECT_EQ(Order.size(), 2UL);
EXPECT_EQ(Order.front(), "SecondLib");
EXPECT_EQ(Order.back(), "PipSqueak");
}
bool RustMCJITMemoryManager::loadCrate(const char* file, std::string* err) {
DynamicLibrary crate = DynamicLibrary::getPermanentLibrary(file,
err);
if(crate.isValid()) {
crates.insert(&crate);
return true;
}
return false;
}
void test_desobj()
{
ErrorOr<ObjectFile *> objfile = ObjectFile::createObjectFile("/usr/lib/libQtCore.so");
ObjectFile *pobj = objfile.get();
qDebug()<<"heheho"<<pobj->getFileFormatName().data();
int i = 0;
DynamicLibrary dlib = DynamicLibrary::getPermanentLibrary("/usr/lib/libQt5Core.so");
qDebug()<<dlib.isValid();
void *addr = dlib.SearchForAddressOfSymbol("_ZN7QString4chopEi");
qDebug()<<"addr:"<<addr;
}
LADSPAPluginInstance (const LADSPAModuleHandle::Ptr& m)
: module (m), plugin (nullptr), handle (nullptr),
initialised (false), tempBuffer (1, 1)
{
++insideLADSPACallback;
name = module->file.getFileNameWithoutExtension();
JUCE_LADSPA_LOG ("Creating LADSPA instance: " + name);
if (module->moduleMain != nullptr)
{
plugin = module->moduleMain (shellLADSPAUIDToCreate);
if (plugin == nullptr)
{
JUCE_LADSPA_LOG ("Cannot find any valid descriptor in shared library");
--insideLADSPACallback;
return;
}
}
else
{
JUCE_LADSPA_LOG ("Cannot find any valid plugin in shared library");
--insideLADSPACallback;
return;
}
const double sampleRate = getSampleRate() > 0 ? getSampleRate() : 44100.0;
handle = plugin->instantiate (plugin, (uint32) sampleRate);
--insideLADSPACallback;
}
} TEST_END
TEST_BEGIN(base, dynamic_library) {
DynamicLibrary dync;
rc_t rc = dync.open(_STR("base_unittest.dll"));
ASSERT_EQ(RC_S_OK, rc);
typedef void (*PFN_TEST_CALL)();
PFN_TEST_CALL pfn_call = dync.LocateSymbol<PFN_TEST_CALL>(_STR("base_dynamic_library_test"));
ASSERT_NE(NULL, pfn_call);
(pfn_call)();
ASSERT_EQ(TRUE, gbCall);
} TEST_END
void FaceTrackNoIR::showServerControls() {
if (pProtocolDialog) {
delete pProtocolDialog;
pProtocolDialog = NULL;
}
DynamicLibrary* lib = dlopen_protocols.value(ui.iconcomboProtocol->currentIndex(), (DynamicLibrary*) NULL);
if (lib && lib->Dialog) {
pProtocolDialog = (IProtocolDialog*) lib->Dialog();
if (pProtocolDialog) {
auto foo = dynamic_cast<QWidget*>(pProtocolDialog);
foo->setFixedSize(foo->size());
dynamic_cast<QWidget*>(pProtocolDialog)->show();
}
}
}
void FaceTrackNoIR::showFilterControls() {
if (pFilterDialog) {
delete pFilterDialog;
pFilterDialog = NULL;
}
DynamicLibrary* lib = dlopen_filters.value(ui.iconcomboFilter->currentIndex(), (DynamicLibrary*) NULL);
if (lib && lib->Dialog) {
pFilterDialog = (IFilterDialog*) lib->Dialog();
if (pFilterDialog) {
auto foo = dynamic_cast<QWidget*>(pFilterDialog);
foo->setFixedSize(foo->size());
if (Libraries && Libraries->pFilter)
pFilterDialog->registerFilter(Libraries->pFilter);
dynamic_cast<QWidget*>(pFilterDialog)->show();
}
}
}
void FaceTrackNoIR::showSecondTrackerSettings() {
if (pSecondTrackerDialog) {
delete pSecondTrackerDialog;
pSecondTrackerDialog = NULL;
}
DynamicLibrary* lib = dlopen_trackers.value(ui.cbxSecondTrackerSource->currentIndex() - 1, (DynamicLibrary*) NULL);
if (lib) {
pSecondTrackerDialog = (ITrackerDialog*) lib->Dialog();
if (pSecondTrackerDialog) {
auto foo = dynamic_cast<QWidget*>(pSecondTrackerDialog);
foo->setFixedSize(foo->size());
if (Libraries && Libraries->pSecondTracker)
pSecondTrackerDialog->registerTracker(Libraries->pSecondTracker);
dynamic_cast<QWidget*>(pSecondTrackerDialog)->show();
}
}
}
TEST(DynamicLibrary, Shutdown) {
std::string A, B;
{
std::string Err;
llvm_shutdown_obj Shutdown;
DynamicLibrary DL =
DynamicLibrary::getPermanentLibrary(LibPath().c_str(), &Err);
EXPECT_TRUE(DL.isValid());
EXPECT_TRUE(Err.empty());
SetStrings SS = FuncPtr<SetStrings>(
DynamicLibrary::SearchForAddressOfSymbol("SetStrings"));
EXPECT_TRUE(SS != nullptr);
SS(A, B);
EXPECT_EQ(B, "Local::Local");
}
EXPECT_EQ(A, "Global::~Global");
EXPECT_EQ(B, "Local::~Local");
EXPECT_TRUE(FuncPtr<SetStrings>(DynamicLibrary::SearchForAddressOfSymbol(
"SetStrings")) == nullptr);
}
TEST(DynamicLibrary, Overload) {
{
std::string Err;
llvm_shutdown_obj Shutdown;
DynamicLibrary DL =
DynamicLibrary::getPermanentLibrary(LibPath().c_str(), &Err);
EXPECT_TRUE(DL.isValid());
EXPECT_TRUE(Err.empty());
GetString GS = FuncPtr<GetString>(DL.getAddressOfSymbol("TestA"));
EXPECT_TRUE(GS != nullptr && GS != &TestA);
EXPECT_EQ(StdString(GS()), "LibCall");
GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
EXPECT_TRUE(GS != nullptr && GS != &TestA);
EXPECT_EQ(StdString(GS()), "LibCall");
DL = DynamicLibrary::getPermanentLibrary(nullptr, &Err);
EXPECT_TRUE(DL.isValid());
EXPECT_TRUE(Err.empty());
// Test overloading local symbols does not occur by default
GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
EXPECT_TRUE(GS != nullptr && GS == &TestA);
EXPECT_EQ(StdString(GS()), "ProcessCall");
GS = FuncPtr<GetString>(DL.getAddressOfSymbol("TestA"));
EXPECT_TRUE(GS != nullptr && GS == &TestA);
EXPECT_EQ(StdString(GS()), "ProcessCall");
// Test overloading by forcing library priority when searching for a symbol
DynamicLibrary::SearchOrder = DynamicLibrary::SO_LoadedFirst;
GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
EXPECT_TRUE(GS != nullptr && GS != &TestA);
EXPECT_EQ(StdString(GS()), "LibCall");
DynamicLibrary::AddSymbol("TestA", PtrFunc(&OverloadTestA));
GS = FuncPtr<GetString>(DL.getAddressOfSymbol("TestA"));
EXPECT_TRUE(GS != nullptr && GS != &OverloadTestA);
GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
EXPECT_TRUE(GS != nullptr && GS == &OverloadTestA);
EXPECT_EQ(StdString(GS()), "OverloadCall");
}
EXPECT_TRUE(FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol(
"TestA")) == nullptr);
// Check serach ordering is reset to default after call to llvm_shutdown
EXPECT_TRUE(DynamicLibrary::SearchOrder == DynamicLibrary::SO_Linker);
}
/**
* FWLite entry point.
*
* Function will check if inputfiles argument is specified and print error
* message if not. For a list of supported arguments use:
*
* fwlite.exe -h
*/
int main(int argc, char **argv)
try
{
using grove::DynamicLibrary;
using grove::LibraryAnalyzer;
DynamicLibrary *library = new DynamicLibrary();
library->load("libExamples.so");
try
{
{
LibraryAnalyzer analyzer(library->alloc("EmptyAnalyzer"));
LibraryAnalyzer analyzerCopy = analyzer;
}
LibraryAnalyzer analyzerCopy = library->alloc("EmptyAnalyzer");
analyzerCopy.analyze();
library->unload();
analyzerCopy.analyze();
LibraryAnalyzer emptyAnalyzer = library->alloc("SomeAnalyzer");
throw std::runtime_error("Artificial error");
}
catch(const std::exception &exception)
{
std::cout << "memory cleanup" << std::endl;
delete library;
throw;
}
std::cout << "Normal Exit: memory cleanup" << std::endl;
delete library;
return 0;
}
catch(const std::exception &exception)
{
std::cerr << "Error: " << exception.what() << std::endl;
return 1;
}
catch(...)
{
return 1;
}
OpenSLSession (DynamicLibrary& slLibraryToUse,
int numInputChannels, int numOutputChannels,
double samleRateToUse, int bufferSizeToUse,
int numBuffersToUse)
: inputChannels (numInputChannels), outputChannels (numOutputChannels),
sampleRate (samleRateToUse), bufferSize (bufferSizeToUse), numBuffers (numBuffersToUse),
running (false), audioProcessingEnabled (true), callback (nullptr)
{
jassert (numInputChannels > 0 || numOutputChannels > 0);
if (CreateEngineFunc createEngine = (CreateEngineFunc) slLibraryToUse.getFunction ("slCreateEngine"))
{
SLObjectItf obj = nullptr;
SLresult err = createEngine (&obj, 0, nullptr, 0, nullptr, nullptr);
if (err != SL_RESULT_SUCCESS || obj == nullptr || (*obj)->Realize (obj, 0) != SL_RESULT_SUCCESS)
{
if (obj != nullptr)
(*obj)->Destroy (obj);
return;
}
engine = SlRef<SLEngineItf_>::cast (SlObjectRef (obj));
}
if (outputChannels > 0)
{
SLObjectItf obj = nullptr;
SLresult err = (*engine)->CreateOutputMix (engine, &obj, 0, nullptr, nullptr);
if (err != SL_RESULT_SUCCESS || obj == nullptr || (*obj)->Realize (obj, 0) != SL_RESULT_SUCCESS)
{
if (obj != nullptr)
(*obj)->Destroy (obj);
return;
}
outputMix = SlRef<SLOutputMixItf_>::cast (SlObjectRef (obj));
}
}
TEST(DynamicLibrary, Overload) {
{
std::string Err;
llvm_shutdown_obj Shutdown;
DynamicLibrary DL =
DynamicLibrary::getPermanentLibrary(LibPath().c_str(), &Err);
EXPECT_TRUE(DL.isValid());
EXPECT_TRUE(Err.empty());
GetString GS = FuncPtr<GetString>(DL.getAddressOfSymbol("TestA"));
EXPECT_TRUE(GS != nullptr && GS != &TestA);
EXPECT_EQ(StdString(GS()), "LibCall");
GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
EXPECT_TRUE(GS != nullptr && GS != &TestA);
EXPECT_EQ(StdString(GS()), "LibCall");
DL = DynamicLibrary::getPermanentLibrary(nullptr, &Err);
EXPECT_TRUE(DL.isValid());
EXPECT_TRUE(Err.empty());
GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
EXPECT_TRUE(GS != nullptr && GS == &TestA);
EXPECT_EQ(StdString(GS()), "ProcessCall");
GS = FuncPtr<GetString>(DL.getAddressOfSymbol("TestA"));
EXPECT_TRUE(GS != nullptr && GS == &TestA);
EXPECT_EQ(StdString(GS()), "ProcessCall");
DynamicLibrary::AddSymbol("TestA", PtrFunc(&OverloadTestA));
GS = FuncPtr<GetString>(DL.getAddressOfSymbol("TestA"));
EXPECT_TRUE(GS != nullptr && GS != &OverloadTestA);
GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
EXPECT_TRUE(GS != nullptr && GS == &OverloadTestA);
EXPECT_EQ(StdString(GS()), "OverloadCall");
}
EXPECT_TRUE(FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol(
"TestA")) == nullptr);
}
bool open()
{
module.open (file.getFullPathName());
moduleMain = (LADSPA_Descriptor_Function) module.getFunction ("ladspa_descriptor");
return moduleMain != nullptr;
}
static bool load_dynamicLib(const char *libname)
{
if(dlclang_createIndex) return true;
if(dynamicLib.open(libname))
{
//@write_dynamic_functions_load();
// generated-code:begin
dlclang_createIndex = (clang_createIndex_t) dynamicLib.dlsym("clang_createIndex");
if(!dlclang_createIndex) return false;
dlclang_disposeIndex = (clang_disposeIndex_t) dynamicLib.dlsym("clang_disposeIndex");
if(!dlclang_disposeIndex) return false;
dlclang_parseTranslationUnit = (clang_parseTranslationUnit_t) dynamicLib.dlsym("clang_parseTranslationUnit");
if(!dlclang_parseTranslationUnit) return false;
dlclang_getTranslationUnitCursor = (clang_getTranslationUnitCursor_t) dynamicLib.dlsym("clang_getTranslationUnitCursor");
if(!dlclang_getTranslationUnitCursor) return false;
dlclang_disposeTranslationUnit = (clang_disposeTranslationUnit_t) dynamicLib.dlsym("clang_disposeTranslationUnit");
if(!dlclang_disposeTranslationUnit) return false;
dlclang_visitChildren = (clang_visitChildren_t) dynamicLib.dlsym("clang_visitChildren");
if(!dlclang_visitChildren) return false;
dlclang_getCursorKind = (clang_getCursorKind_t) dynamicLib.dlsym("clang_getCursorKind");
if(!dlclang_getCursorKind) return false;
dlclang_getCursorType = (clang_getCursorType_t) dynamicLib.dlsym("clang_getCursorType");
if(!dlclang_getCursorType) return false;
dlclang_getCursorSpelling = (clang_getCursorSpelling_t) dynamicLib.dlsym("clang_getCursorSpelling");
if(!dlclang_getCursorSpelling) return false;
dlclang_getTypeSpelling = (clang_getTypeSpelling_t) dynamicLib.dlsym("clang_getTypeSpelling");
if(!dlclang_getTypeSpelling) return false;
dlclang_getCursorKindSpelling = (clang_getCursorKindSpelling_t) dynamicLib.dlsym("clang_getCursorKindSpelling");
if(!dlclang_getCursorKindSpelling) return false;
dlclang_getCursorReferenced = (clang_getCursorReferenced_t) dynamicLib.dlsym("clang_getCursorReferenced");
if(!dlclang_getCursorReferenced) return false;
dlclang_getCString = (clang_getCString_t) dynamicLib.dlsym("clang_getCString");
if(!dlclang_getCString) return false;
dlclang_disposeString = (clang_disposeString_t) dynamicLib.dlsym("clang_disposeString");
if(!dlclang_disposeString) return false;
dlclang_getCursorLocation = (clang_getCursorLocation_t) dynamicLib.dlsym("clang_getCursorLocation");
if(!dlclang_getCursorLocation) return false;
dlclang_getPresumedLocation = (clang_getPresumedLocation_t) dynamicLib.dlsym("clang_getPresumedLocation");
if(!dlclang_getPresumedLocation) return false;
dlclang_getCursorLinkage = (clang_getCursorLinkage_t) dynamicLib.dlsym("clang_getCursorLinkage");
if(!dlclang_getCursorLinkage) return false;
dlclang_getResultType = (clang_getResultType_t) dynamicLib.dlsym("clang_getResultType");
if(!dlclang_getResultType) return false;
// generated-code:end
return true;
}
return false;
}
bool isOpenSLAvailable()
{
DynamicLibrary library;
return library.open ("libOpenSLES.so");
}
void close()
{
module.close();
}
static bool load_libmysqlclient(const char *libName)
{
if(dlmysql_init) return true;
if(libmysqlclient.open(libName))
{
//@write_mysql_functions_load();
// generated-code:begin
dlmysql_init = (mysql_init_t) libmysqlclient.dlsym("mysql_init");
if(!dlmysql_init) return false;
dlmysql_real_connect = (mysql_real_connect_t) libmysqlclient.dlsym("mysql_real_connect");
if(!dlmysql_real_connect) return false;
dlmysql_close = (mysql_close_t) libmysqlclient.dlsym("mysql_close");
if(!dlmysql_close) return false;
dlmysql_error = (mysql_error_t) libmysqlclient.dlsym("mysql_error");
if(!dlmysql_error) return false;
dlmysql_ping = (mysql_ping_t) libmysqlclient.dlsym("mysql_ping");
if(!dlmysql_ping) return false;
dlmysql_real_escape_string = (mysql_real_escape_string_t) libmysqlclient.dlsym("mysql_real_escape_string");
if(!dlmysql_real_escape_string) return false;
dlmysql_get_server_version = (mysql_get_server_version_t) libmysqlclient.dlsym("mysql_get_server_version");
if(!dlmysql_get_server_version) return false;
dlmysql_insert_id = (mysql_insert_id_t) libmysqlclient.dlsym("mysql_insert_id");
if(!dlmysql_insert_id) return false;
dlmysql_data_seek = (mysql_data_seek_t) libmysqlclient.dlsym("mysql_data_seek");
if(!dlmysql_data_seek) return false;
dlmysql_store_result = (mysql_store_result_t) libmysqlclient.dlsym("mysql_store_result");
if(!dlmysql_store_result) return false;
dlmysql_real_query = (mysql_real_query_t) libmysqlclient.dlsym("mysql_real_query");
if(!dlmysql_real_query) return false;
dlmysql_num_rows = (mysql_num_rows_t) libmysqlclient.dlsym("mysql_num_rows");
if(!dlmysql_num_rows) return false;
dlmysql_affected_rows = (mysql_affected_rows_t) libmysqlclient.dlsym("mysql_affected_rows");
if(!dlmysql_affected_rows) return false;
dlmysql_num_fields = (mysql_num_fields_t) libmysqlclient.dlsym("mysql_num_fields");
if(!dlmysql_num_fields) return false;
dlmysql_fetch_fields = (mysql_fetch_fields_t) libmysqlclient.dlsym("mysql_fetch_fields");
if(!dlmysql_fetch_fields) return false;
dlmysql_fetch_field_direct = (mysql_fetch_field_direct_t) libmysqlclient.dlsym("mysql_fetch_field_direct");
if(!dlmysql_fetch_field_direct) return false;
dlmysql_fetch_row = (mysql_fetch_row_t) libmysqlclient.dlsym("mysql_fetch_row");
if(!dlmysql_fetch_row) return false;
dlmysql_fetch_lengths = (mysql_fetch_lengths_t) libmysqlclient.dlsym("mysql_fetch_lengths");
if(!dlmysql_fetch_lengths) return false;
dlmysql_free_result = (mysql_free_result_t) libmysqlclient.dlsym("mysql_free_result");
if(!dlmysql_free_result) return false;
dlmysql_eof = (mysql_eof_t) libmysqlclient.dlsym("mysql_eof");
if(!dlmysql_eof) return false;
dlmysql_stmt_init = (mysql_stmt_init_t) libmysqlclient.dlsym("mysql_stmt_init");
if(!dlmysql_stmt_init) return false;
dlmysql_stmt_prepare = (mysql_stmt_prepare_t) libmysqlclient.dlsym("mysql_stmt_prepare");
if(!dlmysql_stmt_prepare) return false;
dlmysql_stmt_execute = (mysql_stmt_execute_t) libmysqlclient.dlsym("mysql_stmt_execute");
if(!dlmysql_stmt_execute) return false;
dlmysql_stmt_param_count = (mysql_stmt_param_count_t) libmysqlclient.dlsym("mysql_stmt_param_count");
if(!dlmysql_stmt_param_count) return false;
dlmysql_stmt_bind_param = (mysql_stmt_bind_param_t) libmysqlclient.dlsym("mysql_stmt_bind_param");
if(!dlmysql_stmt_bind_param) return false;
dlmysql_stmt_reset = (mysql_stmt_reset_t) libmysqlclient.dlsym("mysql_stmt_reset");
if(!dlmysql_stmt_reset) return false;
dlmysql_stmt_free_result = (mysql_stmt_free_result_t) libmysqlclient.dlsym("mysql_stmt_free_result");
if(!dlmysql_stmt_free_result) return false;
dlmysql_stmt_close = (mysql_stmt_close_t) libmysqlclient.dlsym("mysql_stmt_close");
if(!dlmysql_stmt_close) return false;
dlmysql_stmt_error = (mysql_stmt_error_t) libmysqlclient.dlsym("mysql_stmt_error");
if(!dlmysql_stmt_error) return false;
// generated-code:end
return true;
}
return false;
}
void setFuncPtr (Func*& funcPtr, const DynamicLibrary& lib, const string& symname)
{
funcPtr = reinterpret_cast<Func*>(lib.getFunctionPtr(symname.c_str()));
}
dgl_func_ptr APILoader::getGLPointer(const DynamicLibrary& library, Entrypoint entryp) {
return library.getFunction(GetEntryPointName(entryp));
}
