//------------------------------------------------------------
// CAsmLink::AddImport (sscli)
//------------------------------------------------------------
//virtual internal HRESULT AddImport(
// mdAssembly AssemblyID,
// mdToken ImportToken,
// DWORD dwFlags,
// mdFile * pFileToken)
//{
// // If we have already emitted the manifest, and then we import
// // a file with a CA that maps to an assembly option, we're in trouble!
// ASSERT(m_bInited && !m_bAssemblyEmitted && !m_bPreClosed && !m_bManifestEmitted);
//
// HRESULT hr;
// CFile *file = NULL;
// if (TypeFromToken(ImportToken) == mdtModule) {
// ASSERT(RidFromToken(ImportToken) < m_pModules->CountFiles());
// hr = m_pModules->GetFile( ImportToken, &file);
// } else {
// ASSERT(TypeFromToken(ImportToken) == mdtAssemblyRef && RidFromToken(ImportToken) < m_pImports->CountFiles());
// hr = m_pImports->GetFile( ImportToken, &file);
// }
// if (FAILED(hr))
// return hr;
// ASSERT(file != NULL);
// if (FAILED(hr = m_pAssem->AddFile(file, dwFlags, pFileToken)))
// return hr;
// else if (AssemblyID == AssemblyIsUBM) {
// if (pFileToken)
// *pFileToken = ImportToken;
// return S_FALSE;
// }
// ASSERT(AssemblyID == TokenFromRid(mdtAssembly, 1));
// if (FAILED(hr = m_pModules->RemoveFile( ImportToken)))
// return hr;
// if (FAILED(hr = file->ImportFile( NULL, m_pAssem)))
// return hr;
// return file->ImportResources(m_pAssem);
//}
// virtual internal HRESULT GetScope(mdAssembly AssemblyID, mdToken FileToken, DWORD dwScope, IMetaDataImport** ppImportScope);
// virtual internal HRESULT GetScope2(mdAssembly AssemblyID, mdToken FileToken, DWORD dwScope, IMetaDataImport2** ppImportScope);
// virtual internal HRESULT GetAssemblyRefHash(mdToken FileToken, const void** ppvHash, DWORD* pcbHash);
// virtual internal HRESULT GetPublicKeyToken(LPCWSTR pszKeyFile, LPCWSTR pszKeyContainer, void * pvPublicKeyToken, DWORD * pcbPublicKeyToken);
//------------------------------------------------------------
// CAsmLink.SetPEKind (1)
//
/// <summary>
/// Set PE kind and machin of a given CAssemblyBuilder instance.
/// </summary>
/// <param name="builder"></param>
/// <param name="peKind"></param>
/// <param name="machine"></param>
/// <returns></returns>
//------------------------------------------------------------
virtual internal bool SetPEKind(
CAssemblyBuilderEx builder,
PortableExecutableKinds peKind,
ImageFileMachine machine)
{
if (builder == null)
{
return(false);
}
builder.SetPEKind(peKind, machine);
return(true);
}
//------------------------------------------------------------
// CAsmLink::Init (sscli) (2)
//------------------------------------------------------------
//virtual internal HRESULT Init(IMetaDataDispenserEx *pDispenser, IMetaDataError *pError);
//{
//
//#ifdef _DEBUG
// DEBUG_BEGIN_IF_NZ("Break")
// DebugBreak();
// DEBUG_END_IF
//#endif
// VARIANT v;
// HRESULT hr;
// ASSERT(!m_bInited && pDispenser != NULL);
// m_pDisp = pDispenser;
// m_pDisp->AddRef();
//
// VariantInit(&v);
// if (SUCCEEDED(hr = m_pDisp->GetOption(MetaDataCheckDuplicatesFor, &v))) {
// V_UI4(&v) |= MDDupModuleRef | MDDupAssemblyRef | MDDupAssembly | MDDupManifestResource | MDDupExportedType;
// hr = m_pDisp->SetOption(MetaDataCheckDuplicatesFor, &v);
// }
//
// if (pError != NULL) {
// m_pError = pError;
// m_pError->AddRef();
// } else
// m_pError = NULL;
// m_bInited = true;
// return hr;
//}
//------------------------------------------------------------
// CAsmLink.SetAssemblyFile (1)
//
/// <summary>
/// Create a CAssemblyBuilder instance.
/// </summary>
/// <param name="fileName"></param>
/// <param name="flags"></param>
/// <returns></returns>
//------------------------------------------------------------
virtual internal bool SetAssemblyFile(
string fileName,
AssemblyFlagsEnum flags)
{
if (fileName == null)
{
fileName = "";
}
this.assemblyBuilderEx = new CAssemblyBuilderEx(this.controller);
return(this.assemblyBuilderEx.Init(flags, this));
}
//------------------------------------------------------------
// CAsmLink::ImportFileEx2 (sscli)
//------------------------------------------------------------
//virtual internal HRESULT ImportFileEx2(
// LPCWSTR pszFilename,
// LPCWSTR pszTargetName,
// IMetaDataAssemblyImport *pAssemblyScopeIn,
// BOOL fSmartImport,
// DWORD dwOpenFlags,
// mdToken *pFileToken,
// IMetaDataAssemblyImport **ppAssemblyScope,
// DWORD *pdwCountOfScopes)
//{
// ASSERT(m_bInited);
// LPWSTR newTarget = NULL;
// bool bNewTarget = false;
// bool fIsInMemory = (pAssemblyScopeIn != NULL);
//
// IMetaDataAssemblyImport *pAImport = NULL;
// IMetaDataImport *pImport = NULL;
// mdAssembly tkAssembly;
//
// //--------------------------------------------------
// // Check if pszFilename is valid.
// // If pszTargetName is NULL, assign pszFilename to it.
// //--------------------------------------------------
// if (pszFilename == NULL)
// return E_INVALIDARG;
// if (wcslen(pszFilename) > MAX_PATH)
// return FileNameTooLong(pszFilename);
// if (pszTargetName && wcslen(pszTargetName) > MAX_PATH)
// return FileNameTooLong(pszTargetName); // File name too long
//
// if (pszTargetName == NULL)
// newTarget = VSAllocStr(pszFilename);
// else
// newTarget = VSAllocStr(pszTargetName);
// if (newTarget == NULL)
// return E_OUTOFMEMORY;
//
// if (_wcsicmp(newTarget, pszFilename) == 0) {
// } else {
// bNewTarget = true;
// }
//
// //--------------------------------------------------
// // If pAssemblyScopeIn is valid, use it.
// //--------------------------------------------------
// if ((pAImport = pAssemblyScopeIn) != NULL)
// {
// //EDMAURER If bNewTarget is true and the source file is not an assembly, then pAImport
// //must be an object from which one can QI for IID_IMetaDataEmit. And it may not be
// //depending on the openflags used when it was created.
// //Becomes an issue with UpdateModuleName () below.
// pAImport->AddRef();
// }
// //--------------------------------------------------
// // If pAssemblyScopeIn is null, search the RegMeta instance by pszFilename,
// // if not found, create a RegMeta instace, and use it as pAImport.
// //--------------------------------------------------
// else
// {
// if (bNewTarget && IsOfReadOnly (dwOpenFlags)) {
// //EDMAURER would like to also check for !IsAssembly (pszFilename) in this IF.
// //Massage OpenFlags such that ofReadOnly is not used. Fall back on ofRead
// //which was used before the introduction of ofReadOnly. That permits QI for IMetadataEmit.
// //This is done to satisfy the UpdateModuleName () call below.
// dwOpenFlags &= ~ofReadOnly;
// dwOpenFlags |= ofRead;
// }
//
// // Search or create the RegMeta instance.
// // The metadata section is opened in the RegMeta instance.
// HRESULT hr = m_pDisp->OpenScope(pszFilename, dwOpenFlags, IID_IMetaDataAssemblyImport, (IUnknown**)&pAImport);
// if (FAILED(hr)) {
// *pFileToken = 0;
// if (ppAssemblyScope) *ppAssemblyScope = NULL;
// if (pdwCountOfScopes) *pdwCountOfScopes = 0;
// delete [] newTarget;
// return hr;
// }
// }
//
// HRESULT hr;
// if (FAILED(hr = pAImport->QueryInterface( IID_IMetaDataImport, (void**)&pImport))) {
// *pFileToken = 0;
// if (ppAssemblyScope) *ppAssemblyScope = NULL;
// if (pdwCountOfScopes) *pdwCountOfScopes = 0;
// delete [] newTarget;
// return hr;
// }
//
// //--------------------------------------------------
// // this file is not an assembly (does not have a manifest).
// //--------------------------------------------------
// if (FAILED(hr = pAImport->GetAssemblyFromScope( &tkAssembly))) {
//
// hr = S_FALSE;
// // This is NOT an assembly
// if (ppAssemblyScope) *ppAssemblyScope = NULL;
// if (pdwCountOfScopes) *pdwCountOfScopes = 1;
// *pFileToken = mdTokenNil;
// CFile* file = new CFile();
// if (file == NULL) {
// hr = E_OUTOFMEMORY;
// } else if (SUCCEEDED(hr = file->Init(newTarget, pImport, m_pError, this))) {
// if (bNewTarget) {
// if (SUCCEEDED(hr = file->SetSource(pszFilename)))
// hr = file->UpdateModuleName();
// }
// } else {
// delete file;
// file = NULL;
// }
// pAImport->Release();
// pImport->Release();
//
// if (SUCCEEDED(hr) && SUCCEEDED(hr = m_pModules->AddFile( file, 0, pFileToken))) {
// if (fSmartImport)
// hr = file->ImportFile( NULL, NULL);
// *pFileToken = TokenFromRid(RidFromToken(*pFileToken), mdtModule);
// } else if (file != NULL) {
// delete file;
// file = NULL;
// }
// if (ppAssemblyScope) *ppAssemblyScope = NULL;
// if (SUCCEEDED(hr) && pdwCountOfScopes) *pdwCountOfScopes = 1;
// delete [] newTarget;
// return hr == S_OK ? S_FALSE : hr;
// }
// //--------------------------------------------------
// // this file is an assembly (has a manifest).
// //--------------------------------------------------
// else {
// // It is an Assembly
// CAssembly* assembly = new CAssembly();
// if (assembly == NULL) {
// hr = E_OUTOFMEMORY;
// } else if (SUCCEEDED(hr = assembly->Init( pszFilename, pAImport, pImport, m_pError, this))){
// if (ppAssemblyScope)
// *ppAssemblyScope = pAImport;
// else
// pAImport->Release();
// if (m_bDontDoHashes)
// assembly->DontDoHash();
// if (fIsInMemory)
// assembly->SetInMemory();
// // Get the informations of assembly, custum attributes, types.
// hr = assembly->ImportAssembly(pdwCountOfScopes, fSmartImport, dwOpenFlags, m_pDisp);
// } else {
// delete assembly;
// assembly = NULL;
// }
// pImport->Release();
//
// if (SUCCEEDED(hr) && bNewTarget)
// hr = assembly->ReportError( ERR_CantRenameAssembly, mdTokenNil, NULL, pszFilename);
//
// if (SUCCEEDED(hr) && m_pAssem != NULL)
// hr = m_pAssem->ComparePEKind( assembly, false);
//
// delete [] newTarget;
// if (FAILED(hr)) {
// delete assembly;
// assembly = NULL;
// return hr;
// }
//
// if (FAILED(hr = m_pImports->AddFile( assembly, 0, pFileToken)))
// delete assembly;
// return SUCCEEDED(hr) ? S_OK : hr;
// }
//}
//------------------------------------------------------------
// CAsmLink.AddFile
//------------------------------------------------------------
virtual internal bool AddFile(
OUTFILESYM outfileSym)
{
DebugUtil.Assert(this.inited && !this.assemblyEmitted && !this.preClosed);
if (outfileSym.AssemblyBuilderEx != null)
{
this.assemblyBuilderEx = outfileSym.AssemblyBuilderEx;
return(true);
}
this.assemblyBuilderEx = null;
return(false);
}
//------------------------------------------------------------
// CAsmLink.
//------------------------------------------------------------
// virtual internal HRESULT SetAssemblyFile2(
// LPCWSTR pszFilename,
// IMetaDataEmit2 *pEmitter,
// AssemblyFlags afFlags,
// mdAssembly *pAssemblyID);
//------------------------------------------------------------
// CAsmLink.CreateTempAssemblyBuilder
//
/// <summary></summary>
//------------------------------------------------------------
private void CreateTempAssemblyBuilder()
{
Exception excp = null;
this.tempAssemblyBuilder = new CAssemblyBuilderEx(this.controller);
this.tempAssemblyBuilder.Init(AssemblyFlagsEnum.None, this);
this.tempAssemblyBuilder.DefineAssembly(
tempAssemblyBuilderName,
null,
AssemblyBuilderAccess.RunAndSave,
this.controller.OptionManager,
null,
null,
null,
null,
out excp);
}
//------------------------------------------------------------
// CAsmLink::PreCloseAssembly (sscli)
//------------------------------------------------------------
//HRESULT CAsmLink::PreCloseAssembly(mdAssembly AssemblyID)
//{
// ASSERT(m_bInited && !m_bPreClosed);
// ASSERT(AssemblyID == TokenFromRid(mdtAssembly, 1));
//
// HRESULT hr = S_OK;
// if (!m_bAssemblyEmitted)
// {
// hr = EmitAssembly(AssemblyID);
// }
//
// m_bPreClosed = true;
// m_pAssem->PreClose();
// return hr;
//}
//------------------------------------------------------------
// CAsmLink.CloseAssembly
//
/// <summary>
/// <para>Clear this.assemblyBuilderEx.</para>
/// </summary>
/// <param name="assemblyId"></param>
/// <returns></returns>
//------------------------------------------------------------
virtual internal bool CloseAssembly(uint assemblyId)
{
DebugUtil.Assert(this.inited && (this.preClosed || (assemblyId == AssemblyUtil.AssemblyIsUBM)));
this.preClosed = false;
this.manifestEmitted = false;
this.assemblyEmitted = false;
bool br = false;
if (assemblyId == AssemblyUtil.AssemblyIsUBM)
{
return(true);
}
else
{
// Sign the assembly
br = this.assemblyBuilderEx.SignAssembly();
}
this.assemblyBuilderEx = null;
return(br);
}
//------------------------------------------------------------
// CAsmLink::SetAssemblyFile (sscli)
//
// #define TokenFromRid(rid,tktype) ((rid) | (tktype)) : src\inc\corhdr.h(1411)
//------------------------------------------------------------
//virtual internal HRESULT SetAssemblyFile(
// LPCWSTR pszFilename,
// IMetaDataEmit *pEmitter,
// AssemblyFlags afFlags,
// mdAssembly *pAssemblyID)
//{
// ASSERT(m_bInited && !m_bAssemblyEmitted && !m_bPreClosed && !m_pAssem);
// ASSERT(pEmitter != NULL && pAssemblyID != NULL);
// HRESULT hr = E_FAIL;
//
// // NULL filename means 'InMemory' assembly, but we need a filename so convert it to the
// // empty string.
// if (pszFilename == NULL) {
// ASSERT(afFlags & afInMemory);
// pszFilename = L"";
// }
//
// if (FAILED(hr = SetNonAssemblyFlags(afFlags)))
// return hr;
//
// if (wcslen(pszFilename) > MAX_PATH)
// return FileNameTooLong(pszFilename); // File name too long
//
// CComPtr<IMetaDataAssemblyEmit> pAEmitter;
// hr = pEmitter->QueryInterface(IID_IMetaDataAssemblyEmit, (void**)&pAEmitter);
// if (SUCCEEDED(hr)) {
// m_pAssem = new CAssembly();
// if (m_pAssem == NULL) {
// hr = E_OUTOFMEMORY;
// } else if (SUCCEEDED(hr = m_pAssem->Init(pszFilename, afFlags, pAEmitter, pEmitter, m_pError, this))) {
// *pAssemblyID = TokenFromRid(mdtAssembly, 1);
// }
// }
//
// return hr;
//}
//------------------------------------------------------------
// CAsmLink.SetAssemblyFile (2)
//
/// <summary></summary>
/// <param name="builder"></param>
/// <returns></returns>
//------------------------------------------------------------
virtual internal bool SetAssemblyFile(CAssemblyBuilderEx builder)
{
this.assemblyBuilderEx = builder;
return(this.assemblyBuilderEx != null);
}