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 represents
llvm::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.
void
TUrlLink::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.
//
void
TUrlLink::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;
}

//----------------------------------------------------------------------------
//  LoadModule
HRESULT 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;
}