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