Module* VirtualMachine::LoadModule(const ModuleName &name, bool noreflection, bool debug, Module *hint) { // Check for an already loaded module. // TODO: Add security. LoadedModulesByName::iterator it = loadedModulesByName.find(name.name); if(it != loadedModulesByName.end()) return it->second; // Use the filename if present if(!name.filename.empty()) return LoadModule(name.filename, debug); // Try to load the module. std::string baseName = name.name + ".cbm"; std::string fileName; if(FindModule(baseName, &fileName, hint)) return LoadModule(fileName, noreflection, debug); // Try to load embedded module. // ELF module. baseName = "lib" + name.name + ".so"; if(FindModule(baseName, &fileName, hint)) return LoadModule(fileName, noreflection, debug); // PE module. baseName = name.name + ".dll"; if(FindModule(baseName, &fileName, hint)) return LoadModule(fileName, noreflection, debug); return NULL; }
void LoadSos(LLDBServices *services) { if (m_sosHandle == NULL) { if (g_coreclrDirectory == NULL) { const char *coreclrModule = MAKEDLLNAME_A("coreclr"); const char *directory = services->GetModuleDirectory(coreclrModule); if (directory != NULL) { std::string path(directory); path.append("/"); g_coreclrDirectory = strdup(path.c_str()); } else { services->Output(DEBUG_OUTPUT_WARNING, "The %s module is not loaded yet in the target process\n", coreclrModule); } } if (g_coreclrDirectory != NULL) { // Load the DAC module first explicitly because SOS and DBI // have implicit references to the DAC's PAL. LoadModule(services, MAKEDLLNAME_A("mscordaccore")); m_sosHandle = LoadModule(services, MAKEDLLNAME_A("sos")); } } }
// // Setup server: create sockets, load modules, etc // INT_32 MainProcess::Setup(Logger & oLogger, bool & bLoggerStarted) { // Initialize loggers, before of all other modules oLogger.Info("Starting logger subsystem"); STLW::vector<ModuleConfig>::const_iterator itvLoggers = oGlobalContext.config.loggers.begin(); while (itvLoggers != oGlobalContext.config.loggers.end()) { const INT_32 iRC = LoadModule(itvLoggers -> type, itvLoggers -> name, itvLoggers -> library, itvLoggers -> driver, itvLoggers -> params, oGlobalContext.config.libexec_dirs, oLogger); if (iRC != 0) { return iRC; } oLogger.Info("Logger `%s` started", itvLoggers -> name.c_str()); ++itvLoggers; } // Get logger from factory for main process Object * pObject = oGlobalContext.factory.GetObject("Logger/" + oGlobalContext.config.logger_type); if (pObject == NULL) { oLogger.Emerg("Can't get main process logger `%s`", oGlobalContext.config.logger_type.c_str()); return -1; } oLogger.Info("Logger subsystem started"); // Start logger subsystem oGlobalContext.error_log = static_cast<LoggerObject *>(pObject) -> GetErrorLog(NULL); oGlobalContext.error_log -> Notice("Log started"); oGlobalContext.transfer_log = static_cast<LoggerObject *>(pObject) -> GetCustomLog(NULL); oGlobalContext.transfer_log -> Notice("Log started"); bLoggerStarted = true; // Load modules oGlobalContext.error_log -> Info("Starting modules"); STLW::vector<ModuleConfig>::const_iterator itvModules = oGlobalContext.config.modules.begin(); while(itvModules != oGlobalContext.config.modules.end()) { const INT_32 iRC = LoadModule(itvModules -> type, itvModules -> name, itvModules -> library, itvModules -> driver, itvModules -> params, oGlobalContext.config.libexec_dirs, *oGlobalContext.error_log); if (iRC != 0) { return iRC; } ++itvModules; } oGlobalContext.error_log -> Info("All modules started"); return 0; }
TSharedPtr<IModuleInterface> FModuleManager::LoadModuleChecked( const FName InModuleName, const bool bWasReloaded ) { TSharedPtr<IModuleInterface> Module = LoadModule(InModuleName, bWasReloaded); check(Module.IsValid()); return Module; }
// //The actual do something code. // int main( void ) { unsigned char *DLL; void _cdecl (*DLLFunction)(char *); printf( "EXE File name: %s\n", GetModuleFileName( _psp ) ); printf( "Program name: %s\n", _LpPgmName ); printf( "Load module: %s\n", ModuleName ); // Try and load the module. DLL = LoadModule( ModuleName ); if( DLL ) { printf( "Module %s loaded sucessfully\n", ModuleName ); // Fetch the test function address DLLFunction = GetProcAddress( DLL, "_SayHello" ); if( DLLFunction ) { // Give the test function a shout DLLFunction( "Hello World!" ); } else { printf( "Failed to GetProcAddress\n" ); } printf( "Free module: %s\n", ModuleName ); // Lose the module again FreeModule( DLL ); printf( "Module %s discarded\n", ModuleName ); } else { printf( "Failed to load %s module...\n", ModuleName ); } return( 0 ); }
long DICE_CV os2exec_load_component (CORBA_Object _dice_corba_obj, unsigned long hmod /* in */, os2exec_module_t *s /* out */, CORBA_Server_Environment *_dice_corba_env) { unsigned long rc; char chLoadError[CCHMAXPATH]; IXFModule *ixf; IXFSYSDEP *sysdep; rc = LoadModule(chLoadError, sizeof(chLoadError), &hmod); ixf = (IXFModule *)hmod; s->ip = ixf->EntryPoint; sysdep = (IXFSYSDEP *)(ixf->hdlSysDep); s->sp = sysdep->stack_high; s->sp_limit = sysdep->stack_low; s->hmod = hmod; LOG("load_component exited"); return rc; }
APIRET LoadModulePerf(PSZ pszModuleName, PHMODULE phModule) { PERFSTRUCT TS_Start; PERFSTRUCT TS_End; ULONG ulFreeStart; ULONG ulFreeEnd; double seconds; APIRET rc; /* operation return code */ printf ("Loading %s ...\n", pszModuleName); ulFreeStart = QueryFreeMemory(); ToolsPerfQuery (&TS_Start); /* exact time measurement */ rc = LoadModule(pszModuleName, phModule); ToolsPerfQuery (&TS_End); /* exact time measurement */ seconds = TS_End.fSeconds - TS_Start.fSeconds; /* calculate duration */ ulFreeEnd = QueryFreeMemory(); printf("%u kb used, %11.6f ms\n", /* print report */ (ulFreeStart - ulFreeEnd) / 1024, seconds * 1000.0); return rc; /* OK */ }
void ModuleManager::LoadModulesInFolder( const Char* pModuleDir ) { Vector<String> moduleNames; Vector<String>::iterator itList; String moduleName; Char searchFor[256]; sprintf( searchFor, "*%s", LIBRARY_EXTENSION ); FileManager::FindFiles( pModuleDir, searchFor, moduleNames ); // If we're in release mode on windows, ignore debug dlls #if !defined(GD_DEBUG) && defined(GD_WINDOWS) for( itList = moduleNames.begin(); itList != moduleNames.end(); ) { if( (*itList).substr( (*itList).length() - strlen(LIBRARY_EXTENSION_DEBUG) ) == LIBRARY_EXTENSION_DEBUG ) moduleNames.erase( itList ); else ++itList; } #endif // Remove LIBRARY_EXTENSION from the end // Call LoadModule on each item. for( itList = moduleNames.begin(); itList != moduleNames.end(); ++itList ) { moduleName = (*itList).substr( 0, (*itList).length() - strlen(LIBRARY_EXTENSION) ); LoadModule( moduleName.c_str(), pModuleDir ); } }
void tweakbukconv::Init(std::string configfile) { reader = new ConfigReader(); groups = new Groups(); users = new Users(); if (reader->ReadFile(configfile)) { std::cout << "W00p config is gelezen \\o/" << std::endl; } else { std::cout << "Kon niet lezen :/" << std::endl; } std::string loadmodsstr; loadmodsstr = reader->GetString("loadmods"); moduledir = reader->GetString("moduledir"); hostname_str = reader->GetString("hostname"); databasename_str = reader->GetString("databasename"); username_str = reader->GetString("username"); pass_str = reader->GetString("password"); GetGroupsDB(); std::vector< std::string > loadmods; boost::split( loadmods, loadmodsstr, boost::is_any_of(" "), boost::token_compress_on ); for (unsigned int i = 0; i < loadmods.size(); i++) { LoadModule(loadmods[i]); } tweakloop = true; assert(!tweak_thread); tweak_thread = boost::shared_ptr<boost::thread>(new boost::thread(boost::bind(&tweakbukconv::tweakrun, this))); }
/* * xf86LoadOneModule loads a single module. */ pointer xf86LoadOneModule(char *name, pointer opt) { int errmaj, errmin; char *Name; pointer mod; if (!name) return NULL; /* Normalise the module name */ Name = xf86NormalizeName(name); /* Skip empty names */ if (Name == NULL) return NULL; if (*Name == '\0') { free(Name); return NULL; } mod = LoadModule(Name, NULL, NULL, NULL, opt, NULL, &errmaj, &errmin); if (!mod) LoaderErrorMsg(NULL, Name, errmaj, errmin); free(Name); return mod; }
void Initialize() override { if (FOculusAudioPlugin::NumInstances == 0) { if (!LoadModule()) { UE_LOG(LogAudio, Error, TEXT("Failed to load OVR Audio dll")); return; } } FOculusAudioPlugin::NumInstances++; if (!FOculusAudioPlugin::bInitialized) { // Check the version number int32 MajorVersionNumber; int32 MinorVersionNumber; int32 PatchNumber; // Initialize the OVR Audio SDK before making any calls to ovrAudio ovrResult Result = ovrAudio_Initialize(); OVR_AUDIO_CHECK(Result, "Failed to initialize OVR Audio system"); const char* OvrVersionString = ovrAudio_GetVersion(&MajorVersionNumber, &MinorVersionNumber, &PatchNumber); if (MajorVersionNumber != OVR_AUDIO_MAJOR_VERSION || MinorVersionNumber != OVR_AUDIO_MINOR_VERSION) { UE_LOG(LogAudio, Warning, TEXT("Using mismatched OVR Audio SDK Versiont! %d.%d vs. %d.%d"), OVR_AUDIO_MAJOR_VERSION, OVR_AUDIO_MINOR_VERSION, MajorVersionNumber, MinorVersionNumber); return; } FOculusAudioPlugin::bInitialized = true; } }
void LibFiles::Extract(FILE *stream, const ObjString &Name) { int count = 0; ObjIeeeIndexManager im1; ObjFactory fact1(&im1); for (FileIterator it = FileBegin(); it != FileEnd(); ++it) { if ((*it)->name == Name) { ObjFile *p = LoadModule(stream, count, &fact1); if (p) { FILE *ostr = fopen(Name.c_str(), "wb"); if (ostr != NULL) { WriteData(ostr, p, (*it)->name); fclose(ostr); } else { std::cout << "Warning: Module '" << Name << "' not extracted, could not open output file" << std::endl; } } else { std::cout << "Warning: Module '" << Name << "' not extracted, library corrupt" << std::endl; } return; } } std::cout << "Warning: Module '" << Name << "' not in library and could not be extracted" << std::endl; }
// Load the CSV, create servers for each entry int32_t ModuleManager::LoadAllModules() { int32_t ServerCount{}; CSVManager FileManager; // Read the entries from the CSV. FileManager.ReadFile("Plugins\\OpennetStorage\\Modules.csv", 3); // Decrypt and load all modules. for (uint32_t i = 0; i < FileManager.Buffer->size(); ++i) { // Check for duplicates. for (uint32_t c = 0; c < ModuleList.size(); ++c) { if (!_stricmp(ModuleList[c]->Filename.c_str(), (*FileManager.Buffer)[i][1].c_str())) { goto LABEL_SKIP_LOADING; } } // Decrypt and load. if (DecryptModule((*FileManager.Buffer)[i][1].c_str(), (*FileManager.Buffer)[i][2].c_str())) { if (!LoadModule(ModuleList.back())) ModuleList.pop_back(); } else { fDebugPrint("%s: Failed to load module \"%s\".", __func__, (*FileManager.Buffer)[i][1].c_str()); } LABEL_SKIP_LOADING:; } // Load all requested servers. for (uint32_t i = 0; i < FileManager.Buffer->size(); ++i) { for (uint32_t c = 0; c < ModuleList.size(); ++c) { if (!_stricmp(ModuleList[c]->Filename.c_str(), (*FileManager.Buffer)[i][1].c_str())) { static IServer *NewServer; NewServer = CreateServerInstance(ModuleList[c], (*FileManager.Buffer)[i][0].c_str()); #ifdef _WIN32 if (NewServer != nullptr) { NTServerManager::RegisterServerInterface(NewServer); ServerCount++; } #else #endif } } } fDebugPrint("%s: Loaded %i modules.", __func__, ServerCount); return ServerCount; }
BOOL My_LoadModule() { LPCSTR lpModuleName=NULL; LPVOID lpParameterBlock=NULL; DWORD returnVal_Real = NULL; DWORD returnVal_Intercepted = NULL; DWORD error_Real = 0; DWORD error_Intercepted = 0; disableInterception(); returnVal_Real = LoadModule (lpModuleName,lpParameterBlock); error_Real = GetLastError(); enableInterception(); returnVal_Intercepted = LoadModule (lpModuleName,lpParameterBlock); error_Intercepted = GetLastError(); return ((returnVal_Real == returnVal_Intercepted) && (error_Real == error_Intercepted)); }
void CCore::LoadModules() { for (int i = 0; i < s_ServerConfig->GetSettingSize("luamodules"); i++) { std::string moduleName = s_ServerConfig->GetSetting("luamodules", i); CUtility::printf("Loading module: %s", moduleName.c_str()); LoadModule(moduleName); } }
BOOL My_LoadModule() { LPCSTR lpModuleName=NULL; LPVOID lpParameterBlock=NULL; DWORD returnVal_Real = NULL; DWORD returnVal_Intercepted = NULL; DWORD error_Real = 0; DWORD error_Intercepted = 0; __try{ disableInterception(); returnVal_Real = LoadModule (lpModuleName,lpParameterBlock); error_Real = GetLastError(); enableInterception(); returnVal_Intercepted = LoadModule (lpModuleName,lpParameterBlock); error_Intercepted = GetLastError(); }__except(puts("in filter"), 1){puts("exception caught");} return ((returnVal_Real == returnVal_Intercepted) && (error_Real == error_Intercepted)); }
IdentInterface *ModuleManager::CreateProviderInstance(const PluginID & providerID, const wxString & path) { if (path.IsEmpty() && mDynModules.find(providerID) != mDynModules.end()) { return mDynModules[providerID]; } return LoadModule(path); }
// // Initialize handlers // INT_32 MainProcess::InitHandlers() { // Load handlers oGlobalContext.error_log -> Info("Starting handlers"); STLW::vector<HandlerConfig>::const_iterator itvHandlers = oGlobalContext.config.handlers.begin(); while (itvHandlers != oGlobalContext.config.handlers.end()) { const INT_32 iRC = LoadModule(itvHandlers -> type, itvHandlers -> name, itvHandlers -> library, itvHandlers -> driver, itvHandlers -> params, oGlobalContext.config.libexec_dirs, *oGlobalContext.error_log); if (iRC != 0) { return iRC; } oGlobalContext.error_log -> Info("Handler `%s` started", itvHandlers -> name.c_str()); ++itvHandlers; } // Initialize handlers itvHandlers = oGlobalContext.config.handlers.begin(); while (itvHandlers != oGlobalContext.config.handlers.end()) { // Initialize handler Handler * pHandler = static_cast<Handler *>(oGlobalContext.factory.GetObject(itvHandlers -> type + '/' + itvHandlers -> name)); const INT_32 iRC = pHandler -> InitHandler(oGlobalContext, *itvHandlers, *oGlobalContext.error_log); if (iRC != 0) { return iRC; } oGlobalContext.error_log -> Info("Handler `%s` initialized", itvHandlers -> name.c_str()); ++itvHandlers; } oGlobalContext.error_log -> Info("All handlers started"); oGlobalContext.error_log -> Info("Adding handlers to listeners"); STLW::vector<ServiceConfig>::iterator itvServices = oGlobalContext.config.services.begin(); while (itvServices != oGlobalContext.config.services.end()) { // Get handler from factory Object * pObject = oGlobalContext.factory.GetObject("Handler/" + itvServices -> handler_name); if (pObject == NULL) { oGlobalContext.error_log -> Emerg("Can't find handler `%s`", itvServices -> handler_name.c_str()); return -1; } itvServices -> handler = pObject; ++itvServices; } oGlobalContext.error_log -> Info("Adding handlers to listeners finished"); return 0; }
//---------------------------------------------------------------------------- // ExecuteGlobal STDMETHODIMP CMagpieApplication::ExecuteGlobal( const OLECHAR* lpszModuleID, VARIANT *result) { // load the module CComPtr<CMagpieModuleComObject> pModule; // note that scripts executed in global context DON'T GET WRAPPED! // 4th arg to LoadModule is FALSE for this reason. // See stdafx.h, gJscript9ModuleWrapperIntro and CMagpieModule::Init() IF_FAILED_RET(LoadModule(NULL, lpszModuleID, NULL, FALSE, pModule.p)); return m_ScriptEngine.ExecuteGlobal((CMagpieModule*)pModule.p, result); }
//----------------------------------------------------------------------------- // The application object //----------------------------------------------------------------------------- bool CUnitTestApp::Create() { // Install a special Spew handler that ignores all assertions and lets us // run for as long as possible SpewOutputFunc( UnitTestSpew ); // FIXME: This list of dlls should come from the unittests themselves AppSystemInfo_t appSystems[] = { { "vstdlib.dll", PROCESS_UTILS_INTERFACE_VERSION }, { "", "" } // Required to terminate the list }; if ( !AddSystems( appSystems ) ) return false; // Very simple... just iterate over all .DLLs in the current directory // see if they export UNITTEST_INTERFACE_VERSION. If not, then unload them // just as quick. // We may want to make this more sophisticated, giving it a search path, // or giving test DLLs special extensions, or statically linking the test DLLs // to this program. WIN32_FIND_DATA findFileData; HANDLE hFind= FindFirstFile("*.dll", &findFileData); while (hFind != INVALID_HANDLE_VALUE) { CSysModule* hLib = Sys_LoadModule(findFileData.cFileName); if ( hLib ) { CreateInterfaceFn factory = Sys_GetFactory( hLib ); if ( factory && factory( UNITTEST_INTERFACE_VERSION, NULL ) ) { AppModule_t module = LoadModule( factory ); AddSystem( module, UNITTEST_INTERFACE_VERSION ); } else { Sys_UnloadModule( hLib ); } } if (!FindNextFile( hFind, &findFileData )) break; } return true; }
bool CModules::ReloadModule(const CString& sModule, const CString& sArgs, CUser* pUser, CString& sRetMsg) { CString sMod = sModule; // Make a copy incase the reference passed in is from CModule::GetModName() sRetMsg = ""; if (!UnloadModule(sMod, sRetMsg)) { return false; } if (!LoadModule(sMod, sArgs, pUser, sRetMsg)) { return false; } sRetMsg = "Reloaded module [" + sMod + "]"; return true; }
void rootlogon() { char* c = getenv("TARTSYS"); if(c){ std::string install_dir(c); }else{ std::cout << "set environment variable \"TARTSYS\"" << std::endl; std::cout << "quit ROOT" << std::endl; gROOT->ProcessLine(".q"); } AddIncludePath(install_dir); AddLinkedLibs(); LoadModule(install_dir); //Base Style // gROOT->SetStyle("Plain"); gROOT->SetStyle("Modern"); // gROOT->SetStyle("Classic"); //Force Style gStyle->SetHistFillColor(7); gStyle->SetHistFillStyle(3002); gStyle->SetHistLineColor(kBlue); gStyle->SetFuncColor(kRed); gStyle->SetFrameLineWidth(2); gStyle->SetPadGridX(1); gStyle->SetPadGridY(1); gStyle->SetCanvasColor(0); gStyle->SetTitleFillColor(0); gStyle->SetTitleStyle(0); gStyle->SetStatColor(0); gStyle->SetStatStyle(0); gStyle->SetStatX(0.9); gStyle->SetStatY(0.9); gStyle->SetPalette(1); gStyle->SetOptLogz(1); // gStyle->SetOptTitle(0); gStyle->SetOptFit(1); gStyle->SetOptStat(1111111); gStyle->SetPadBorderMode(1); // gStyle->SetOptDate(1); gStyle->SetLabelFont(132,"XYZ"); gStyle->SetTitleFont(132,"XYZ"); gStyle->SetTitleFont(132,""); gStyle->SetTextFont(132); gStyle->SetStatFont(132); }
IModule * ModuleManager::FindModule(const char * moduleName) { std::string mName(moduleName); if (g_ModuleMap.find(moduleName) != g_ModuleMap.end()) { return g_ModuleMap[mName]; } else { if(LoadModule(moduleName)) return g_ModuleMap[mName]; } return nullptr; }
bool CModules::Load( const char* strName ) { void* pLibrary = LoadModule( (m_strLocation + Holly::Platform::LibraryPretension() + "holly_" + strName + Holly::Platform::LibraryExtension()).c_str() ); if ( !pLibrary ) pLibrary = LoadModule( strName ); if ( !pLibrary ) return false; void* pFunction = Holly::Platform::FindFunction( pLibrary, "Holly_Module_Dynamic" ); if ( !pFunction ) { Holly::Errors::Add( "Invalid Module" ); Holly::Platform::FreeLibrary( pLibrary ); return false; } Module mod; mod.pInstance = pLibrary; mod.pModuleQuery = (fnModuleQuery)pFunction; m_Modules[ strName ] = mod; return true; }
unsigned long ModLoadExeModule(char * pszName, unsigned long cbName, char const * pszModname, unsigned long * phmod) { int rc = 0; rc = OpenModule(pszName, cbName, pszModname, 1, phmod); if (rc) return rc; rc = LoadModule(pszName, cbName, phmod); return rc;
//----------------------------------------------------------------------------- // Create necessary interfaces //----------------------------------------------------------------------------- bool CSteamApplication::Create() { FileSystem_SetErrorMode( FS_ERRORMODE_AUTO ); char pFileSystemDLL[MAX_PATH]; if ( FileSystem_GetFileSystemDLLName( pFileSystemDLL, MAX_PATH, m_bSteam ) != FS_OK ) return false; FileSystem_SetupSteamInstallPath(); // Add in the cvar factory AppModule_t cvarModule = LoadModule( VStdLib_GetICVarFactory() ); AddSystem( cvarModule, CVAR_INTERFACE_VERSION ); AppModule_t fileSystemModule = LoadModule( pFileSystemDLL ); m_pFileSystem = (IFileSystem*)AddSystem( fileSystemModule, FILESYSTEM_INTERFACE_VERSION ); if ( !m_pFileSystem ) { Error( "Unable to load %s", pFileSystemDLL ); return false; } return true; }
// start loading based on the vector of library names. First success // terminates the loading attempts. Needed for CentOS6 and OpenCL. // The Catalyst installer (at least in Catalyst 12.1) creates libOpenCL.so.1 // but no symbolic link to libOpenCL.so. This symbolic link exists on other // distributions where multi-step repackaging is required (build a .deb, run it) bool DynamicLibraryModule::LoadModule(const std::vector<std::string>& names) { bool loaded = false; for (std::vector<std::string>::const_iterator it = names.begin(); it != names.end(); it++) { loaded = LoadModule(*it); if (loaded) { return loaded; } } return loaded; }
//---------------------------------------------------------------------------- // RunModule HRESULT CMagpieApplication::RunModule( CMagpieModule * pSrcModule, LPCOLESTR lpszModuleID, CMagpieModuleComObject ** ppRet) { // load the module CComPtr<CMagpieModuleComObject> module; IF_FAILED_RET(LoadModule(pSrcModule, lpszModuleID, module.p)); if (ppRet) { module.CopyTo(ppRet); } // and run return module->Run(); }
//---------------------------------------------------------------------------- // RunScriptAsModule HRESULT CMagpieApplication::RunScriptAsModule( CMagpieModule * pSrcModule, LPCOLESTR lpszModuleID, LPCOLESTR lpszModuleSource, CMagpieModuleComObject ** ppRet) { // load the module CComPtr<CMagpieModuleComObject> module; IF_FAILED_RET(LoadModule(pSrcModule, lpszModuleID, lpszModuleSource, 9 == m_ScriptEngine.mJscriptVersion, module.p)); if (ppRet) { module.CopyTo(ppRet); } // and run return module->Run(); }
//---------------------------------------------------------------------------- // RunModule HRESULT CMagpieApplication::RunModule( CMagpieModule * pSrcModule, LPCOLESTR lpszModuleID, CMagpieModuleComObject ** ppRet) { ATLTRACE(_T("CMagpieApplication::RunModule %s\n"), lpszModuleID); // load the module CComPtr<CMagpieModuleComObject> module; IF_FAILED_RET(LoadModule(pSrcModule, lpszModuleID, NULL, 9 == m_ScriptEngine.mJscriptVersion, module.p)); if (ppRet) { module.CopyTo(ppRet); } // and run return module->Run(); }