自学教程：C++ GetModule函数代码示例

bool ModuleContainer::RemoveModule(uint32 itemID){    GenericModule * mod = GetModule(itemID);	if( mod == NULL )		return false;	// NO module pointer found at this slot flag, DO NOT attempt to dereference    _removeModule(mod->flag(), mod);    //delete the module    delete mod;    mod = NULL;	return true;}

llvm::Value *CodeGen::CallMulWithOverflow(llvm::Value *left, llvm::Value *right,                                          llvm::Value *&overflow_bit) {  PELOTON_ASSERT(left->getType() == right->getType());  llvm::Function *mul_func = llvm::Intrinsic::getDeclaration(      &GetModule(), llvm::Intrinsic::smul_with_overflow, left->getType());  // Perform the multiplication  llvm::Value *mul_result = CallFunc(mul_func, {left, right});  // Pull out the overflow bit from the resulting aggregate/struct  overflow_bit = GetBuilder().CreateExtractValue(mul_result, 1);  // Pull out the actual result of the subtraction  return GetBuilder().CreateExtractValue(mul_result, 0);}

bool CFlowGraphModuleManager::DeleteModuleXML( const char* moduleName ){	if(m_ModulesPathInfo.empty())		return false;	TModulesPathInfo::iterator modulePathEntry = m_ModulesPathInfo.find(moduleName);	if (m_ModulesPathInfo.end() != modulePathEntry)	{		if(remove(modulePathEntry->second) == 0)		{			m_ModulesPathInfo.erase(moduleName);			// also remove module itself			TModuleIdMap::iterator idIt = m_ModuleIds.find(moduleName);			assert(idIt != m_ModuleIds.end());			TModuleId id = idIt->second;			TModuleMap::iterator modIt = m_Modules.find(id);			assert(modIt != m_Modules.end());			if(modIt != m_Modules.end() && idIt != m_ModuleIds.end())			{				for(CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next() )				{					notifier->OnModuleDestroyed(GetModule(id));				}				m_Modules[id]->Destroy();				delete m_Modules[id];				m_Modules[id] = NULL;				m_ModuleIds.erase(idIt);				m_Modules.erase(modIt);				if (m_Modules.empty())					m_moduleIdMaker = 0;				for(CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next() )				{						notifier->OnPostModuleDestroyed();				}			}			return true;		}	}		return false;}

LibraryLoader* LoaderContainer::FindModule(const char* sName, const char* sCurrentDir, bool bLoadSymbols){	if (CURL::IsFullPath(sName)) 	{ //  Has a path, just try to load		return LoadDll(sName, bLoadSymbols);	}	if (sCurrentDir) 	{ // in the path of the parent dll?		std::string strPath = sCurrentDir;		strPath += sName;		LibraryLoader* pLoader = LoadDll(strPath.c_str(), bLoadSymbols);		if (pLoader)			return pLoader;	}	//  in environment variable?	StringArray vecEnv;	StringUtils::SplitString(ENV_PATH, ";", vecEnv);	LibraryLoader* pDll = NULL;	for (int i = 0; i < (int)vecEnv.size(); ++i) 	{		std::string strPath = vecEnv[i];		strPath += '/';#ifdef LOGALL		LOGDEBUG("Searching for the dll %s in directory %s", sName, strPath.c_str());#endif		strPath += sName;		// Have we already loaded this dll		if ((pDll = GetModule(strPath.c_str())) != NULL)			return pDll;		if ((pDll = LoadDll(strPath.c_str(), bLoadSymbols)) != NULL)			return pDll;	}	// can't find it in any of our paths - could be a system dll	if ((pDll = LoadDll(sName, bLoadSymbols)) != NULL)		return pDll;	LOGDEBUG("Dll %s was not found in path", sName);	return NULL;}

void CFlowGraphModuleManager::OnModuleFinished(TModuleId const& moduleId, TModuleInstanceId instanceId, bool bSuccess, TModuleParams const& params){	TModuleMap::iterator moduleEntry = m_Modules.find(moduleId);	if (m_Modules.end() != moduleEntry)	{		CFlowGraphModule *pModule = moduleEntry->second;		if (pModule)		{			for(CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next() )			{				notifier->OnModuleInstanceDestroyed(GetModule(pModule->GetId()), instanceId);			}			pModule->DestroyInstance(instanceId, bSuccess, params);		}	}}

JEventBody* JModuleThread::MakeEventBody(JEVT_TYPE eType, JCHAR* pModName){	JEventBody* pEventBody = JNULL;	JModule* pModule = JNULL;    JLogAutoPtr clsLogAutoPtr(JSingleton<JLog>::instance(),         JLOG_MOD_THREAD, "JModuleThread::MakeEventBody");	pModule = GetModule(pModName);	if (pModule)	{		pEventBody = pModule->MakeEventBody(static_cast<JUINT32>(eType));	}	return pEventBody;}

    void FunctionInstance::Read(ModuleReader &reader, const MemberHeader &header)    {        // Read the function id.        uint32_t functionId;        reader >> functionId;        // Get the function.        Module *module = GetModule();        function = module->GetFunction(functionId);        // Read the generic instance        instance.Read(reader);        // Use the function generic prototype.        instance.SetPrototype(function->GetGenericPrototype());    }

CExeModuleInstance* CRunningProcesses::GetProcessById(DWORD dwProcessId){	CExeModuleInstance* pResult = NULL;	CExeModuleInstance* pProcess;	for (DWORD i = 0; i < GetCount(); i++)	{		pProcess = static_cast<CExeModuleInstance*>( GetModule(i) );		if (pProcess->Get_ProcessId() == dwProcessId)		{			pResult = pProcess;			break;		} // if	} // for	return pResult;}

ErrorCode ComponentManager::LoadLibrary( const char *name ){	TRACE_BEGIN( LOG_LVL_INFO );	IModule *mod = NULL;	ErrorCode result = kNoError;		LOG_NOTICE( "Opening Library: %s", name );		ErrorCode (*LoadLibrary)( IComponentManager *mgr );	IModule *(*GetModule)();	void *handle = dlopen( name, RTLD_LAZY );		if ( handle == NULL )	{		result = kLoadFailed;		LOG_WARN( "Failed to open shared lib /"%s/": %s", name, dlerror() );	}	else	{		LoadLibrary = (ErrorCode (*)(IComponentManager *mgr))dlsym( handle, "JHCOM_LibraryEntry" );		GetModule = (IModule *(*)())dlsym( handle, "JHCOM_GetModule" );		if ( GetModule == NULL || LoadLibrary == NULL )		{			result = kLoadFailed;			LOG_WARN( "Failed to get symbol" );		}		else		{			LOG( "LoadLibrary is %p", LoadLibrary );			LOG( "RegisterServices is %p", GetModule );			result = LoadLibrary( this );						if ( result == kNoError )			{				mod = GetModule();				mod->AddRef();				mod->loadComponents();				ModuleInfo *info = jh_new ModuleInfo( name, mod, handle );				mModules.push_back( info );			}		}	}		return result;}

void GadWorkspace::newObject(int index, int x, int y){  qDebug("GadWorksapce::newObject(%d, (%d,%d))/n", index, x, y);  if (!classNameMenu_)    return;  if (index < 0)    return;  qDebug("  className=%s/n   name=%s/n",         (const char *) classNameMenu_[index].className,         (const char *) classNameMenu_[index].name);  GadModule *module = GetModule(*classDict_,                                classNameMenu_[index].className,                                classNameMenu_[index].name);  GadObject *obj = new GadObject(module, this);  obj->move(x, y);  obj->show();  resize();}

void CException::ReportStd(ostream& out, TDiagPostFlags flags) const{    string text(GetMsg());    string err_type(GetType());    err_type += "::";    err_type += GetErrCodeString();    SDiagMessage diagmsg(        GetSeverity(),        text.c_str(),        text.size(),        GetFile().c_str(),        GetLine(),        flags, NULL, 0, 0, err_type.c_str(),        GetModule().c_str(),        GetClass().c_str(),        GetFunction().c_str());    diagmsg.Write(out, SDiagMessage::fNoEndl | SDiagMessage::fNoPrefix);}

void CFlowGraphModuleManager::LoadModuleGraph(const char* moduleName, const char* fileName){	// first check for existing module - must exist by this point	CFlowGraphModule *pModule = static_cast<CFlowGraphModule*>(GetModule(moduleName));	assert(pModule);	if(pModule)	{		if (pModule->LoadModuleGraph(moduleName, fileName))		{			for(CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next() )			{				notifier->OnRootGraphChanged(pModule);			}		}			}}

void CreateProjectDlg::UpdateVersionsCombo(){	wxArrayString versions;	if ( Lua::Get().call( "getModuleVersions", GetModule().ToStdString() ) )	{		Helpers::PullTableOfStrings( versions );	}	mVersionsCombo->Clear();	if (versions.size() > 0)	{		mVersionsCombo->Append( versions );		mVersionsCombo->SetSelection(0);	}	mVersionsCombo->Enable(versions.size() > 0);}

    llvm::GlobalVariable *Property::GetMemberInfo()    {        if(!propertyInfo)        {            // Only create the property info variable when reflection is enabled.            Module *module = GetModule();            if(!module->HasReflection())                return NULL;            // Get the property info class.            VirtualMachine *vm = module->GetVirtualMachine();            Class *propInfoClass = vm->GetPropertyInfoClass();            llvm::Module *targetModule = module->GetTargetModule();            propertyInfo = new llvm::GlobalVariable(*targetModule, propInfoClass->GetTargetType(),                                    false, ComputeMetadataLinkage(), NULL, GetMangledName() + "_propinfo_");        }        return propertyInfo;    }

// Register the given function symbol and the LLVM function type it representsllvm::Function *CodeGen::RegisterBuiltin(const std::string &fn_name,                                         llvm::FunctionType *fn_type,                                         void *func_impl) {  // Check if this is already registered as a built in, quit if to  auto *builtin = LookupBuiltin(fn_name);  if (builtin != nullptr) {    return builtin;  }  // TODO: Function attributes here  // Construct the function  auto *function = llvm::Function::Create(      fn_type, llvm::Function::ExternalLinkage, fn_name, &GetModule());  // Register the function in the context  code_context_.RegisterBuiltin(function, func_impl);  // That's it  return function;}

CFlowGraphModule* CFlowGraphModuleManager::PreLoadModuleFile(const char* moduleName, const char* fileName, bool bGlobal){	// NB: the module name passed in might be a best guess based on the filename. The actual name	// comes from within the module xml.	// first check for existing module	CFlowGraphModule *pModule = static_cast<CFlowGraphModule*>(GetModule(moduleName));	if(pModule)	{		for(CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next() )		{			notifier->OnModuleDestroyed(pModule);		}		// exists, reload 		pModule->Destroy();		pModule->PreLoadModule(fileName);		for(CListenerSet<IFlowGraphModuleListener*>::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next() )		{				notifier->OnPostModuleDestroyed();		}	}	else	{		// not found, create		pModule = new CFlowGraphModule(m_moduleIdMaker++);		pModule->SetType(bGlobal ? IFlowGraphModule::eT_Global : IFlowGraphModule::eT_Level);		TModuleId id = pModule->GetId();		m_Modules[id] = pModule;		pModule->PreLoadModule(fileName);		AddModulePathInfo(pModule->GetName(), fileName);		m_ModuleIds[pModule->GetName()] = id;	}	return pModule;}

///// Loads a "hand" cursor from the winhlp32.exe module.///// /note It appeared in Paul DiLascia's Jan 1998 MSJ articles.voidTUrlLink::SetupCursor(){  SetCursor(GetModule(), IDC_HANDCURSOR);  if(HCursor == 0){    // if was problem try load cursor from winhlp32.exe    // Get the windows directory    TAPointer<tchar> Buffer(new tchar[MAX_PATH]);    ::GetWindowsDirectory(Buffer, MAX_PATH);     _tcscat(Buffer,_T("//winhlp32.exe"));    // This retrieves cursor #106 from winhlp32.exe, which is a hand pointer    HMODULE hModule = ::LoadLibrary(Buffer);    if (hModule) {      HCURSOR hHandCursor = ::LoadCursor(hModule, TResId(106));      if (hHandCursor)        HCursor = CopyCursor(hHandCursor); // it is a macro in Win32      ::FreeLibrary(hModule);    }  }}

/// Override TWindow virtual member function to fills out information about the/// Window class associated with a TUrlLink control. /// /note The class information is based on the system's "STATIC" class.//voidTUrlLink::GetWindowClass(WNDCLASS& wndClass){  // Grab a the attributes of the native "STATIC" control  if (::GetClassInfo(0, _T("STATIC"), &wndClass)){    wndClass.hInstance       = *GetModule();    wndClass.style           = CS_HREDRAW|CS_VREDRAW|CS_PARENTDC;    wndClass.lpszClassName   = GetClassName();    wndClass.lpfnWndProc     = UrlLinkProc;    wndClass.hCursor         = HCursor;    //wndClass.hbrBackground  = HBRUSH(COLOR_BTNFACE+1);    wndClass.hbrBackground  = NULL; // Use the background of the parent  }  else {    TStatic::GetWindowClass(wndClass);    wndClass.style           = CS_HREDRAW|CS_VREDRAW|CS_PARENTDC;    //wndClass.hbrBackground  = HBRUSH(COLOR_BTNFACE+1);    wndClass.hbrBackground  = NULL; // Use the background of the parent    wndClass.hCursor         = HCursor;  }}

bool Cx_PluginLoader::RegisterPlugin(HMODULE instance){    if (FindModule(instance) >= 0)    {        return false;    }    Ix_Module* pModule = GetModule(instance);    if (pModule != NULL)    {        MODULE moduleInfo;        moduleInfo.hdll = instance;        moduleInfo.module = pModule;        moduleInfo.owned = false;        moduleInfo.inited = false;        GetModuleFileNameW(moduleInfo.hdll, moduleInfo.filename, MAX_PATH);        int moduleIndex = GetPluginIndex(moduleInfo.filename);        if (moduleIndex >= 0)        {            ASSERT(m_modules[moduleIndex] != NULL);            *m_modules[moduleIndex] = moduleInfo;        }        else        {            moduleIndex = x3::GetSize(m_modules);            MODULE* module = new MODULE;            *module = moduleInfo;            m_modules.push_back(module);        }        RegisterClassEntryTable(moduleIndex);        return true;    }    return false;}

//----------------------------------------------------------------------------//  LoadModuleHRESULT CMagpieApplication::LoadModule(  CMagpieModule           *   pSrcModule,  LPCOLESTR                   lpszModuleID,  CMagpieModuleComObject  *&  pRet){  CString sModuleID;  IF_FAILED_RET(ResolveModuleID(    pSrcModule, lpszModuleID, sModuleID));  CComPtr<CMagpieModuleComObject> module;  // is the module already loaded?  HRESULT hr = E_FAIL;  hr = GetModule(sModuleID, module.p);  if (SUCCEEDED(hr))  {    // yes, return module    pRet = module.Detach();    return S_FALSE;  // means: already loaded  }  // create a real path from the module ID...  CString sModulePath, sModuleIDPath(sModuleID);  sModuleIDPath.Replace(_T('/'), _T('//'));  // ...assuming that the file type is always 'js'  // @TODO: Might change in future.  sModulePath = m_RootPath + sModuleIDPath + _T(".js");  if (!PathFileExists(sModulePath))  {    return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);  }  IF_FAILED_RET(CMagpieModule::CreateObject(    *this, sModuleID, sModulePath, module.p));  m_Modules[sModuleID] = module;  pRet = module.Detach();  return S_OK;}

    // decref handled internally    PyObject* LoadModule(std::string moduleName) {        PyObject* module = GetModule(moduleName);        if(module)            return module;        char* unConstName = const_cast<char*>(moduleName.c_str()); // lol        // seriously, python's api implementers didn't get the const right?        // or they are actually modifying stuff...        module = PyImport_ImportModuleEx(unConstName,            /*globals*/ NULL, /*locals*/ NULL, /*fromlist*/ NULL);        if(!module || !PyModule_Check(module)) {            printf("Error loading module:%s/n", moduleName.c_str());            PyErr_Print();            if(module) { Py_DECREF(module); }            return NULL;        }        _modules.insert(std::make_pair(moduleName, module));                PyObject* dict = PyModule_GetDict(module); // borrowed reference        _dictionaries.insert(std::make_pair(moduleName, dict));        return module;    }

VOID BuildNewImport(ULONG_PTR IATStart, ULONG_PTR IATEnd){    ULONG_PTR Current;    PMODULE ActualModule = NULL;    PEXPORTENTRY ActualExport = NULL;    ImportEntryModule(IATStart);    for (Current = IATStart; Current <= IATEnd; Current += SIZE_IMPORT_ENTRY) {        if (!IsBadReadMemory((PVOID)Current, SIZE_IMPORT_ENTRY) && !IsBadReadMemory((PVOID)*(PULONG_PTR)Current, SIZE_IMPORT_ENTRY)) {            if ((ActualModule = GetModule((ULONG_PTR)*(PVOID*)Current)) != NULL) {                if ((ActualExport = GetExport(ActualModule, (ULONG_PTR)*(PVOID*)Current)) != NULL) {                    AddNewModuleApi(&pinfo.Importer, ActualModule, ActualExport, Current - (ULONG_PTR)GetModuleHandle(NULL));                }                else {                    DbgMsg("[-] Meh can't find exports?!/n");                    ExitProcess(42);                }            }        }    }    PrintInfoImporter(&pinfo.Importer);    ComputeAllITSize(&pinfo.Importer);}

HWND	TUnixDialogBox ::  DoCreate  ( void )   {	char far *			globalp ;// Récupération du pointeur vers le template	globalp      = ( char far * ) GlobalLock  ( MemoryHandle ) ;// Création de la boiboite	DialogHandle = CreateDialogIndirectParam (				* GetModule ( ), globalp,				  ( ParentWindow  !=  NULL ) ?					ParentWindow -> HWindow : NULL,				     ( DLGPROC ) ( FARPROC ) DialogProcInstance,					 Attr. Param ) ;// Déverrouillage du template	GlobalUnlock ( MemoryHandle ) ;// C'est bon	return ( DialogHandle ) ;    }

void ObjExtract (const char* Name)/* Extract a module from the library */{    FILE* Obj;    /* Make a module name from the file name */    const char* Module = GetModule (Name);    /* Try to find the module in the library */    const ObjData* O = FindObjData (Module);    /* Bail out if the module does not exist */    if (O == 0) {        Error ("Module `%s' not found in library `%s'", Module, LibName);    }    /* Open the output file */    Obj = fopen (Name, "w+b");    if (Obj == 0) {        Error ("Cannot open target file `%s': %s", Name, strerror (errno));    }    /* Copy the complete object file data from the library to the new object     * file.     */    LibCopyFrom (O->Start, O->Size, Obj);    /* Close the file */    if (fclose (Obj) != 0) {        Error ("Problem closing object file `%s': %s", Name, strerror (errno));    }    /* Set access and modification time */    if (SetFileTimes (Name, O->MTime) != 0) {        Error ("Cannot set mod time on `%s': %s", Name, strerror (errno));    }}

    void TypeGroup::ReadStructure(ModuleReader &reader, const MemberHeader &header)    {        // Read the group members.        Member *parent = GetParent();        Module *module = GetModule();        int count = header.memberSize/4;        for(int i = 0; i < count; i++)        {            uint32_t id;            reader >> id;            // Get the member and check it..            Member *member = module->GetMember(id);            if(!member->IsClass() && !member->IsStructure() && !member->IsInterface())                throw ModuleException("expected class/structure/interface member in type group.");            // Store the member.            buildings.push_back(static_cast<Structure*> (member));            // Update his parent.            if(member && parent)                member->UpdateParent(parent);        }    }

//-----------------------------------------------------------------------------// Get a ICorDebugValue for a static field on this class.//// Parameters://   fieldDef - metadata token for field on this class. Can not be from an //      inherited class.//   pFrame - frame used to resolve Thread-static, AppDomain-static, etc.//   ppValue - OUT: gets value of the field.//// Returns://    S_OK on success.//    CORDBG_E_STATIC_VAR_NOT_AVAILABLE //-----------------------------------------------------------------------------HRESULT CordbClass::GetStaticFieldValue(mdFieldDef fieldDef,                                        ICorDebugFrame *pFrame,                                        ICorDebugValue **ppValue){    PUBLIC_REENTRANT_API_ENTRY(this);    FAIL_IF_NEUTERED(this);    VALIDATE_POINTER_TO_OBJECT(ppValue, ICorDebugValue **);    ATT_REQUIRE_STOPPED_MAY_FAIL(GetProcess());    HRESULT          hr = S_OK;    *ppValue = NULL;    BOOL             fEnCHangingField = FALSE;    IMetaDataImport * pImport = NULL;    EX_TRY    {        pImport = GetModule()->GetMetaDataImporter(); // throws        // Validate the token.        if (!pImport->IsValidToken(fieldDef) || (TypeFromToken(fieldDef) != mdtFieldDef))        {            ThrowHR(E_INVALIDARG);        }        // Make sure we have enough info about the class.        Init();        // Uninstantiated generics (eg, Foo<T>) don't have static data. Must use instantiated (eg Foo<int>)        // But all CordbClass instances are uninstantiated. So this should fail for all generic types.        // Normally, debuggers should be using ICorDebugType instead.        // Though in the forward compat case, they'll hit this.        if (HasTypeParams())        {            ThrowHR(CORDBG_E_STATIC_VAR_NOT_AVAILABLE);        }        // Lookup the field given its metadata token.        FieldData *pFieldData;        hr = GetFieldInfo(fieldDef, &pFieldData);        // This field was added by EnC, need to use EnC specific code path        if (hr == CORDBG_E_ENC_HANGING_FIELD)        {            // Static fields added with EnC hang off the EnCFieldDesc            hr = GetEnCHangingField(fieldDef,                &pFieldData,                NULL);            if (SUCCEEDED(hr))            {                fEnCHangingField = TRUE;            }            // Note: the FieldOffset in pFieldData has been cooked to produce            // the correct address of the field in the syncBlock.            // @todo: extend Debugger_IPCEFieldData so we don't have to cook the offset here        }        IfFailThrow(hr);        {            Instantiation emptyInst;            hr = CordbClass::GetStaticFieldValue2(GetModule(),                pFieldData,                fEnCHangingField,                &emptyInst,                pFrame,                ppValue);            // Let hr fall through        }    }    EX_CATCH_HRESULT(hr);    // Translate Failure HRs.    if (pImport != NULL)    {        hr = CordbClass::PostProcessUnavailableHRESULT(hr, pImport, fieldDef);    }    return hr;}

void CRouteTimeout::RunJob() {    CRouteRepliesMod* pMod = (CRouteRepliesMod*)GetModule();    pMod->Timeout();}