bool loadGLJumpTable( GLJumpTable& jt, const char* dllPath ) { #ifndef LOAD_JUMPTABLE_STATICALLY void *handle = loadDynamicLibrary(dllPath); if ( !handle ) /* Error loading library */ panic("", "loadGLJumpTable()","Error getting handle to Dinamic Library"); int i; unsigned int func; unsigned int* ptr = (unsigned int*)&jt; for ( i = 0; i < GLResolver::countFunctions(); i++ ) { func = (unsigned int)getFunction(handle, GLResolver::getFunctionName((APICall)i)); if ( func ) /* function found */ ptr[i] = func; } return true; #else // STATICALLY LOAD //_this text generate an error _if #_else is selected. #define _JT jt // rename names /** * Code added (example) * * ... * _JT.glBegin = glBegin; * * ... * * _JT.glVertex3f = glVertex3f; * ... * */ #include "GLJumpTableSL.gen" // SL means: Static Link return true; #endif }
/** * Compiles all models and generates a dynamic library. * * @param compiler The compiler used to compile the sources and create * the dynamic library * @param loadLib Whether or not to load the dynamic library * @return The dynamic library if loadLib is true, nullptr otherwise */ DynamicLib<Base>* createDynamicLibrary(CCompiler<Base>& compiler, bool loadLib = true) throw (CGException) { // backup output format so that it can be restored OStreamConfigRestore coutb(std::cout); this->modelLibraryHelper_->startingJob("", JobTimer::DYNAMIC_MODEL_LIBRARY); const std::map<std::string, ModelCSourceGen<Base>*>& models = this->modelLibraryHelper_->getModels(); try { for (const auto& p : models) { const std::map<std::string, std::string>& modelSources = this->getSources(*p.second); this->modelLibraryHelper_->startingJob("", JobTimer::COMPILING_FOR_MODEL); compiler.compileSources(modelSources, true, this->modelLibraryHelper_); this->modelLibraryHelper_->finishedJob(); } const std::map<std::string, std::string>& sources = this->getLibrarySources(); compiler.compileSources(sources, true, this->modelLibraryHelper_); const std::map<std::string, std::string>& customSource = this->modelLibraryHelper_->getCustomSources(); compiler.compileSources(customSource, true, this->modelLibraryHelper_); std::string libname = _libraryName; if (_customLibExtension != nullptr) libname += *_customLibExtension; else libname += system::SystemInfo<>::DYNAMIC_LIB_EXTENSION; compiler.buildDynamic(libname, this->modelLibraryHelper_); } catch (...) { compiler.cleanup(); throw; } compiler.cleanup(); this->modelLibraryHelper_->finishedJob(); if (loadLib) return loadDynamicLibrary(); else return nullptr; }
void PionPlugin::openPlugin(const std::string& plugin_file, PionPluginData& plugin_data) { // get the name of the plugin (for create/destroy symbol names) plugin_data.m_plugin_name = getPluginName(plugin_file); // attempt to open the plugin; note that this tries all search paths // and also tries a variety of platform-specific extensions plugin_data.m_lib_handle = loadDynamicLibrary(plugin_file.c_str()); if (plugin_data.m_lib_handle == NULL) { #ifndef PION_WIN32 char *error_msg = dlerror(); if (error_msg != NULL) { std::string error_str(plugin_file); error_str += " ("; error_str += error_msg; error_str += ')'; throw OpenPluginException(error_str); } else #endif throw OpenPluginException(plugin_file); } // find the function used to create new plugin objects plugin_data.m_create_func = getLibrarySymbol(plugin_data.m_lib_handle, PION_PLUGIN_CREATE + plugin_data.m_plugin_name); if (plugin_data.m_create_func == NULL) { closeDynamicLibrary(plugin_data.m_lib_handle); throw PluginMissingCreateException(plugin_file); } // find the function used to destroy existing plugin objects plugin_data.m_destroy_func = getLibrarySymbol(plugin_data.m_lib_handle, PION_PLUGIN_DESTROY + plugin_data.m_plugin_name); if (plugin_data.m_destroy_func == NULL) { closeDynamicLibrary(plugin_data.m_lib_handle); throw PluginMissingDestroyException(plugin_file); } }
int test1_22_mutatee() { int retval = 0; #if defined(os_linux_test) \ || defined(os_windows_test) \ || defined(os_freebsd_test) /* libtestA.so should already be loaded (by the mutator), but we need to use the dl interface to get pointers to the functions it defines. */ /* int (*call22_5)(int); */ /* int (*call22_6)(int); */ call_type call22_5; call_type call22_6; /* Why shadowing the top-level declaration? */ void *handleA; char dlopenName[128]; int result; unused = sprintf(dlopenName, "%s", libNameA); handleA = loadDynamicLibrary(dlopenName); if (! handleA) { logerror("**Failed test #22 (replaceFunction)\n"); logerror(" Mutatee couldn't get handle for %s\n", libNameA); retval = -1; /* Test failed */ } /* call22_5 = (int(*)(int)) getFuncFromDLL(handleA, "call22_5"); */ call22_5 = (call_type) getFuncFromDLL(handleA, "call22_5a"); if (! call22_5) { logerror("**Failed test #22 (replaceFunction)\n"); logerror(" Mutatee couldn't get handle for call22_5 in %s\n", libNameA); retval = -1; /* Test failed */ } /* call22_6 = (int(*)(int)) getFuncFromDLL(handleA, "call22_6"); */ call22_6 = (call_type) getFuncFromDLL(handleA, "call22_6"); if (! call22_6) { logerror("**Failed test #22 (replaceFunction)\n"); logerror(" Mutatee couldn't get handle for call22_6 in %s\n", libNameA); retval = -1; /* Test failed */ } /* Call functions that have been replaced by the mutator. The side effects of these calls (replaced, not replaced, or otherwise) are independent of each other. */ result = test1_22_call1(10); /* replaced by test1_22_call2 */ if (result != 10 + MAGIC22_2) { logerror("**Failed test #22 (replace function) (a.out -> a.out)\n"); retval = -1; /* Test failed */ } result = test1_22_call3(20); /* replaced by call22_4 */ if (result != 20 + MAGIC22_4) { logerror("**Failed test #22 (replace function) (a.out -> shlib)\n"); retval = -1; /* Test failed */ } if (call22_5 != NULL) { result = call22_5(30); /* replaced by call22_5 (in libtestB) */ if (result != 30 + MAGIC22_5B) { logerror("**Failed test #22 (replace function) (shlib -> shlib)\n"); retval = -1; /* Test failed */ } } if (call22_6 != NULL) { result = call22_6(40); /* replaced by test1_22_call7 */ if (result != 40 + MAGIC22_7) { logerror("**Failed test #22 (replace function) (shlib -> a.out)\n"); retval = -1; /* Test failed */ } } if (0 == retval) { logerror("Passed test #22 (replace function)\n"); test_passes(testname); } #else logerror("Skipped test #22 (replace function)\n"); logerror("\t- not implemented on this platform\n"); test_passes(testname); #endif return retval; }