// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. #include "stdafx.h" #include "winmdinterfaces.h" #include "metadataexports.h" #include "inc/adapter.h" #include "strsafe.h" //======================================================================================== // This metadata importer is exposed publically via CoCreateInstance(CLSID_CorMetaDataDispenser...). // when the target is a .winmd file. It applies a small number of on-the-fly // conversions to make the .winmd file look like a regular .NET assembly. // // Despite what the MSDN docs say, this importer only supports the reader interfaces and // a subset of them at that. Supporting the whole set would not be practical with an // on-the-fly translation strategy. //======================================================================================== class WinMDImport : public IMetaDataImport2 , IMetaDataAssemblyImport , IMetaDataWinMDImport , IMetaDataValidate , IMDCommon , IMetaModelCommon , IWinMDImport #ifdef FEATURE_METADATA_INTERNAL_APIS , IGetIMDInternalImport #endif //FEATURE_METADATA_INTERNAL_APIS { public: //========================================================= // Factory //========================================================= static HRESULT Create(IMDCommon *pRawMDCommon, WinMDImport **ppWinMDImport) { HRESULT hr; *ppWinMDImport = NULL; WinMDImport *pNewWinMDImport = new (nothrow) WinMDImport(pRawMDCommon); IfFailGo(pNewWinMDImport->m_pRawMDCommon->QueryInterface(IID_IMetaDataImport2, (void**)&pNewWinMDImport->m_pRawImport)); IfFailGo(pNewWinMDImport->m_pRawImport->QueryInterface(IID_IMetaDataAssemblyImport, (void**)&pNewWinMDImport->m_pRawAssemblyImport)); if (FAILED(pNewWinMDImport->m_pRawImport->QueryInterface(IID_IMetaDataValidate, (void**)&pNewWinMDImport->m_pRawValidate))) { pNewWinMDImport->m_pRawValidate = nullptr; } pNewWinMDImport->m_pRawMetaModelCommonRO = pRawMDCommon->GetMetaModelCommonRO(); IfFailGo(WinMDAdapter::Create(pRawMDCommon, &pNewWinMDImport->m_pWinMDAdapter)); (*ppWinMDImport = pNewWinMDImport)->AddRef(); hr = S_OK; ErrExit: if (pNewWinMDImport) pNewWinMDImport->Release(); return hr; } private: //========================================================= // Ctors, Dtors //========================================================= WinMDImport(IMDCommon * pRawMDCommon) { m_cRef = 1; m_pRawImport = NULL; m_pWinMDAdapter = NULL; m_pRawAssemblyImport = NULL; m_pFreeThreadedMarshaler = NULL; (m_pRawMDCommon = pRawMDCommon)->AddRef(); } //--------------------------------------------------------- ~WinMDImport() { if (m_pRawMDCommon) m_pRawMDCommon->Release(); if (m_pRawImport) m_pRawImport->Release(); if (m_pRawAssemblyImport) m_pRawAssemblyImport->Release(); if (m_pRawValidate) m_pRawValidate->Release(); if (m_pFreeThreadedMarshaler) m_pFreeThreadedMarshaler->Release(); delete m_pWinMDAdapter; } //--------------------------------------------------------- BOOL IsValidNonNilToken(mdToken token, DWORD tkKind) { DWORD tkKindActual = TypeFromToken(token); DWORD rid = RidFromToken(token); if (tkKindActual != tkKind) return FALSE; if (rid == 0) return FALSE; ULONG ulRowCount = m_pRawMetaModelCommonRO->CommonGetRowCount(tkKind); if (tkKind == mdtAssemblyRef) return rid <= ulRowCount + m_pWinMDAdapter->GetExtraAssemblyRefCount(); else return rid <= ulRowCount; } public: //========================================================= // IUnknown methods //========================================================= STDMETHODIMP QueryInterface(REFIID riid, void** ppUnk) { HRESULT hr; *ppUnk = 0; if (riid == IID_IUnknown || riid == IID_IWinMDImport) *ppUnk = (IWinMDImport*)this; else if (riid == IID_IMetaDataImport || riid == IID_IMetaDataImport2) *ppUnk = (IMetaDataImport*)this; else if (riid == IID_IMetaDataWinMDImport) *ppUnk = (IMetaDataWinMDImport*)this; else if (riid == IID_IMetaDataAssemblyImport) *ppUnk = (IMetaDataAssemblyImport*)this; else if (riid == IID_IMDCommon) *ppUnk = (IMDCommon*)this; else if (riid == IID_IMetaDataValidate) { if (m_pRawValidate == NULL) { return E_NOINTERFACE; } *ppUnk = (IMetaDataValidate*)this; } #ifdef FEATURE_METADATA_INTERNAL_APIS else if (riid == IID_IGetIMDInternalImport) *ppUnk = (IGetIMDInternalImport*)this; #endif // FEATURE_METADATA_INTERNAL_APIS else if (riid == IID_IMarshal) { if (m_pFreeThreadedMarshaler == NULL) { ReleaseHolder pFreeThreadedMarshaler = NULL; IfFailRet(CoCreateFreeThreadedMarshaler((IUnknown *)(IMetaDataImport *)this, &pFreeThreadedMarshaler)); if (InterlockedCompareExchangeT(&m_pFreeThreadedMarshaler, pFreeThreadedMarshaler, NULL) == NULL) { // We won the initialization race pFreeThreadedMarshaler.SuppressRelease(); } } return m_pFreeThreadedMarshaler->QueryInterface(riid, ppUnk); } else { #ifndef DACCESS_COMPILE #ifdef _DEBUG if (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_MD_WinMD_AssertOnIllegalUsage)) { if (riid == IID_IMetaDataTables) _ASSERTE(!"WinMDImport::QueryInterface(IID_IMetaDataTables) returning E_NOINTERFACE"); else if (riid == IID_IMetaDataTables2) _ASSERTE(!"WinMDImport::QueryInterface(IID_IMetaDataTables2) returning E_NOINTERFACE"); else if (riid == IID_IMetaDataInfo) _ASSERTE(!"WinMDImport::QueryInterface(IID_IMetaDataInfo) returning E_NOINTERFACE"); else if (riid == IID_IMetaDataEmit) _ASSERTE(!"WinMDImport::QueryInterface(IID_IMetaDataEmit) returning E_NOINTERFACE"); else if (riid == IID_IMetaDataEmit2) _ASSERTE(!"WinMDImport::QueryInterface(IID_IMetaDataEmit2) returning E_NOINTERFACE"); else if (riid == IID_IMetaDataAssemblyEmit) _ASSERTE(!"WinMDImport::QueryInterface(IID_IMetaDataAssemblyEmit) returning E_NOINTERFACE"); else if (riid == IID_IMetaDataValidate) _ASSERTE(!"WinMDImport::QueryInterface(IID_IMetaDataValidate) returning E_NOINTERFACE"); else if (riid == IID_IMetaDataFilter) _ASSERTE(!"WinMDImport::QueryInterface(IID_IMetaDataFilter) returning E_NOINTERFACE"); else if (riid == IID_IMetaDataHelper) _ASSERTE(!"WinMDImport::QueryInterface(IID_IMetaDataHelper) returning E_NOINTERFACE"); else if (riid == IID_IMDInternalEmit) _ASSERTE(!"WinMDImport::QueryInterface(IID_IMDInternalEmit) returning E_NOINTERFACE"); else if (riid == IID_IMetaDataEmitHelper) _ASSERTE(!"WinMDImport::QueryInterface(IID_IMetaDataEmitHelper) returning E_NOINTERFACE"); #ifdef FEATURE_PREJIT else if (riid == IID_IMetaDataCorProfileData) _ASSERTE(!"WinMDImport::QueryInterface(IID_IMetaDataCorProfileData) returning E_NOINTERFACE"); else if (riid == IID_IMDInternalMetadataReorderingOptions) _ASSERTE(!"WinMDImport::QueryInterface(IID_IMDInternalMetadataReorderingOptions) returning E_NOINTERFACE"); #endif else _ASSERTE(!"WinMDImport::QueryInterface() returning E_NOINTERFACE"); } #endif //_DEBUG #endif return E_NOINTERFACE; } AddRef(); return S_OK; } //--------------------------------------------------------- STDMETHODIMP_(ULONG) AddRef(void) { return InterlockedIncrement(&m_cRef); } //--------------------------------------------------------- STDMETHODIMP_(ULONG) Release(void) { ULONG cRef = InterlockedDecrement(&m_cRef); if (!cRef) delete this; return cRef; } public: //========================================================= // IWinMDImport methods //========================================================= STDMETHODIMP IsScenarioWinMDExp(BOOL *pbResult) { if (pbResult == NULL) return E_POINTER; *pbResult = m_pWinMDAdapter->IsScenarioWinMDExp(); return S_OK; } STDMETHODIMP IsRuntimeClassImplementation(mdTypeDef tkTypeDef, BOOL *pbResult) { if (pbResult == NULL) return E_POINTER; return m_pWinMDAdapter->IsRuntimeClassImplementation(tkTypeDef, pbResult); } //========================================================= // IMetaDataImport methods //========================================================= STDMETHODIMP_(void) CloseEnum(HCORENUM hEnum) { m_pRawImport->CloseEnum(hEnum); } STDMETHODIMP CountEnum(HCORENUM hEnum, ULONG *pulCount) { _ASSERTE(pulCount != NULL); // Crash on NULL pulCount (just like real RegMeta) if (hEnum != NULL) { HENUMInternal *henuminternal = static_cast(hEnum); // Special case: We hijack MethodImpl enum's if (henuminternal->m_tkKind == (TBL_MethodImpl << 24)) { *pulCount = henuminternal->m_ulCount / 2; // MethodImpl enum's are weird - their entries are body/decl pairs so the internal count is twice the number the caller wants to see. return S_OK; } } return m_pRawImport->CountEnum(hEnum, pulCount); } STDMETHODIMP ResetEnum(HCORENUM hEnum, ULONG ulPos) { return m_pRawImport->ResetEnum(hEnum, ulPos); } STDMETHODIMP EnumTypeDefs(HCORENUM *phEnum, mdTypeDef rTypeDefs[], ULONG cMax, ULONG *pcTypeDefs) { return m_pRawImport->EnumTypeDefs(phEnum, rTypeDefs, cMax, pcTypeDefs); } STDMETHODIMP EnumInterfaceImpls(HCORENUM *phEnum, mdTypeDef td, mdInterfaceImpl rImpls[], ULONG cMax, ULONG* pcImpls) { return m_pRawImport->EnumInterfaceImpls(phEnum, td, rImpls, cMax, pcImpls); } STDMETHODIMP EnumTypeRefs(HCORENUM *phEnum, mdTypeRef rTypeRefs[], ULONG cMax, ULONG* pcTypeRefs) { // No trick needed: a previous call to EnumTypeRefs must have already taken care of the // extra type refs. return m_pRawImport->EnumTypeRefs(phEnum, rTypeRefs, cMax, pcTypeRefs); } STDMETHODIMP FindTypeDefByName( // S_OK or error. LPCWSTR wszTypeDef, // [IN] Name of the Type. mdToken tkEnclosingClass, // [IN] TypeDef/TypeRef for Enclosing class. mdTypeDef *ptd) // [OUT] Put the TypeDef token here. { if (wszTypeDef == NULL) // E_INVALIDARG on NULL szTypeDef (just like real RegMeta) return E_INVALIDARG; _ASSERTE(ptd != NULL); // AV on NULL ptd (just like real RegMeta) *ptd = mdTypeDefNil; LPUTF8 szFullName; LPCUTF8 szNamespace; LPCUTF8 szName; // Convert the name to UTF8. UTF8STR(wszTypeDef, szFullName); ns::SplitInline(szFullName, szNamespace, szName); return m_pWinMDAdapter->FindTypeDef(szNamespace, szName, tkEnclosingClass, ptd); } STDMETHODIMP GetScopeProps( // S_OK or error. __out_ecount_part_opt(cchName, *pchName) LPWSTR szName, // [OUT] Put the name here. ULONG cchName, // [IN] Size of name buffer in wide chars. ULONG *pchName, // [OUT] Put size of name (wide chars) here. GUID *pmvid) // [OUT, OPTIONAL] Put MVID here. { // Returns error code from name filling (may be CLDB_S_TRUNCTATION) return m_pRawImport->GetScopeProps(szName, cchName, pchName, pmvid); } STDMETHODIMP GetModuleFromScope( // S_OK. mdModule *pmd) // [OUT] Put mdModule token here. { return m_pRawImport->GetModuleFromScope(pmd); } STDMETHODIMP GetTypeDefProps( // S_OK or error. mdTypeDef td, // [IN] TypeDef token for inquiry. __out_ecount_part_opt(cchTypeDef, *pchTypeDef) LPWSTR szTypeDef, // [OUT] Put name here. ULONG cchTypeDef, // [IN] size of name buffer in wide chars. ULONG *pchTypeDef, // [OUT] put size of name (wide chars) here. DWORD *pdwTypeDefFlags, // [OUT] Put flags here. mdToken *ptkExtends) // [OUT] Put base class TypeDef/TypeRef here. { HRESULT hr; LPCSTR szNamespace; LPCSTR szName; if (!IsValidNonNilToken(td, mdtTypeDef)) { // Idiosyncractic edge cases - delegate straight through to inherit the correct idiosyncractic edge results return m_pRawImport->GetTypeDefProps(td, szTypeDef, cchTypeDef, pchTypeDef, pdwTypeDefFlags, ptkExtends); } IfFailRet(m_pWinMDAdapter->GetTypeDefProps(td, &szNamespace, &szName, pdwTypeDefFlags, ptkExtends)); // Returns error code from name filling (may be CLDB_S_TRUNCTATION) return DeliverUtf8NamespaceAndName(szNamespace, szName, szTypeDef, cchTypeDef, pchTypeDef); } STDMETHODIMP GetInterfaceImplProps( // S_OK or error. mdInterfaceImpl iiImpl, // [IN] InterfaceImpl token. mdTypeDef *pClass, // [OUT] Put implementing class token here. mdToken *ptkIface) // [OUT] Put implemented interface token here. { return m_pRawImport->GetInterfaceImplProps(iiImpl, pClass, ptkIface); } STDMETHODIMP GetTypeRefProps( // S_OK or error. mdTypeRef tr, // [IN] TypeRef token. mdToken *ptkResolutionScope, // [OUT] Resolution scope, ModuleRef or AssemblyRef. __out_ecount_part_opt(cchName, *pchName) LPWSTR szName, // [OUT] Name of the TypeRef. ULONG cchName, // [IN] Size of buffer. ULONG *pchName) // [OUT] Size of Name. { HRESULT hr; if (!IsValidNonNilToken(tr, mdtTypeRef)) { // Idiosyncratic edge cases - delegate straight through to inherit the correct idiosyncratic edge result return m_pRawImport->GetTypeRefProps(tr, ptkResolutionScope, szName, cchName, pchName); } LPCUTF8 szUtf8Namespace; LPCUTF8 szUtf8Name; mdToken tkResolutionScope; IfFailRet(CommonGetTypeRefProps(tr, &szUtf8Namespace, &szUtf8Name, &tkResolutionScope)); if (ptkResolutionScope != NULL) { *ptkResolutionScope = tkResolutionScope; } // Returns error code from name filling (may be CLDB_S_TRUNCTATION) return DeliverUtf8NamespaceAndName(szUtf8Namespace, szUtf8Name, szName, cchName, pchName); } STDMETHODIMP ResolveTypeRef(mdTypeRef tr, REFIID riid, IUnknown **ppIScope, mdTypeDef *ptd) { WINMD_COMPAT_ASSERT("IMetaDataImport::ResolveTypeRef() not supported on .winmd files."); return E_NOTIMPL; } STDMETHODIMP EnumMembers( // S_OK, S_FALSE, or error. HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdTypeDef cl, // [IN] TypeDef to scope the enumeration. mdToken rMembers[], // [OUT] Put MemberDefs here. ULONG cMax, // [IN] Max MemberDefs to put. ULONG *pcTokens) // [OUT] Put # put here. { return m_pRawImport->EnumMembers(phEnum, cl, rMembers, cMax, pcTokens); } STDMETHODIMP EnumMembersWithName( // S_OK, S_FALSE, or error. HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdTypeDef cl, // [IN] TypeDef to scope the enumeration. LPCWSTR szName, // [IN] Limit results to those with this name. mdToken rMembers[], // [OUT] Put MemberDefs here. ULONG cMax, // [IN] Max MemberDefs to put. ULONG *pcTokens) // [OUT] Put # put here. { return m_pRawImport->EnumMembersWithName(phEnum, cl, szName, rMembers, cMax, pcTokens); } STDMETHODIMP EnumMethods( // S_OK, S_FALSE, or error. HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdTypeDef cl, // [IN] TypeDef to scope the enumeration. mdMethodDef rMethods[], // [OUT] Put MethodDefs here. ULONG cMax, // [IN] Max MethodDefs to put. ULONG *pcTokens) // [OUT] Put # put here. { return m_pRawImport->EnumMethods(phEnum, cl, rMethods, cMax, pcTokens); } STDMETHODIMP EnumMethodsWithName( // S_OK, S_FALSE, or error. HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdTypeDef cl, // [IN] TypeDef to scope the enumeration. LPCWSTR szName, // [IN] Limit results to those with this name. mdMethodDef rMethods[], // [OU] Put MethodDefs here. ULONG cMax, // [IN] Max MethodDefs to put. ULONG *pcTokens) // [OUT] Put # put here. { return m_pRawImport->EnumMethodsWithName(phEnum, cl, szName, rMethods, cMax, pcTokens); } STDMETHODIMP EnumFields( // S_OK, S_FALSE, or error. HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdTypeDef cl, // [IN] TypeDef to scope the enumeration. mdFieldDef rFields[], // [OUT] Put FieldDefs here. ULONG cMax, // [IN] Max FieldDefs to put. ULONG *pcTokens) // [OUT] Put # put here. { return m_pRawImport->EnumFields(phEnum, cl, rFields, cMax, pcTokens); } STDMETHODIMP EnumFieldsWithName( // S_OK, S_FALSE, or error. HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdTypeDef cl, // [IN] TypeDef to scope the enumeration. LPCWSTR szName, // [IN] Limit results to those with this name. mdFieldDef rFields[], // [OUT] Put MemberDefs here. ULONG cMax, // [IN] Max MemberDefs to put. ULONG *pcTokens) // [OUT] Put # put here. { return m_pRawImport->EnumFieldsWithName(phEnum, cl, szName, rFields, cMax, pcTokens); } STDMETHODIMP EnumParams( // S_OK, S_FALSE, or error. HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdMethodDef mb, // [IN] MethodDef to scope the enumeration. mdParamDef rParams[], // [OUT] Put ParamDefs here. ULONG cMax, // [IN] Max ParamDefs to put. ULONG *pcTokens) // [OUT] Put # put here. { return m_pRawImport->EnumParams(phEnum, mb, rParams, cMax, pcTokens); } STDMETHODIMP EnumMemberRefs( // S_OK, S_FALSE, or error. HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdToken tkParent, // [IN] Parent token to scope the enumeration. mdMemberRef rMemberRefs[], // [OUT] Put MemberRefs here. ULONG cMax, // [IN] Max MemberRefs to put. ULONG *pcTokens) // [OUT] Put # put here. { return m_pRawImport->EnumMemberRefs(phEnum, tkParent, rMemberRefs, cMax, pcTokens); } STDMETHODIMP EnumMethodImpls( // S_OK, S_FALSE, or error HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdTypeDef td, // [IN] TypeDef to scope the enumeration. mdToken rMethodBody[], // [OUT] Put Method Body tokens here. mdToken rMethodDecl[], // [OUT] Put Method Declaration tokens here. ULONG cMax, // [IN] Max tokens to put. ULONG *pcTokens) // [OUT] Put # put here. { // Note: This wrapper emulates the underlying RegMeta's parameter validation semantics: // Pass a bad phEnum: Instant AV // Pass out of range typedef: returns S_FALSE (i.e. generates empty list) // Pass non-typedef: returns S_FALSE with assert // Pass bad output ptr for bodies or decls, AV // Pass bad output ptr for pcTokens, AV (but NULL is allowed.) HRESULT hr; HENUMInternal **ppmdEnum = reinterpret_cast (phEnum); HENUMInternal *pEnum = *ppmdEnum; if ( pEnum == 0 ) { // Create the enumerator, DynamicArrayEnum does not use the token type. IfFailGo( HENUMInternal::CreateDynamicArrayEnum( (TBL_MethodImpl << 24), &pEnum) ); IfFailGo( m_pWinMDAdapter->AddMethodImplsToEnum(td, pEnum)); // set the output parameter *ppmdEnum = pEnum; } // fill the output token buffer hr = HENUMInternal::EnumWithCount(pEnum, cMax, rMethodBody, rMethodDecl, pcTokens); ErrExit: HENUMInternal::DestroyEnumIfEmpty(ppmdEnum); return hr; } STDMETHODIMP EnumPermissionSets( // S_OK, S_FALSE, or error. HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdToken tk, // [IN] if !NIL, token to scope the enumeration. DWORD dwActions, // [IN] if !0, return only these actions. mdPermission rPermission[], // [OUT] Put Permissions here. ULONG cMax, // [IN] Max Permissions to put. ULONG *pcTokens) // [OUT] Put # put here. { return m_pRawImport->EnumPermissionSets(phEnum, tk, dwActions, rPermission, cMax, pcTokens); } STDMETHODIMP FindMember( mdTypeDef td, // [IN] given typedef LPCWSTR szName, // [IN] member name PCCOR_SIGNATURE pvSigBlob, // [IN] point to a blob value of CLR signature ULONG cbSigBlob, // [IN] count of bytes in the signature blob mdToken *pmb) // [OUT] matching memberdef { HRESULT hr = FindMethod( td, szName, pvSigBlob, cbSigBlob, pmb); if (hr == CLDB_E_RECORD_NOTFOUND) { // now try field table hr = FindField( td, szName, pvSigBlob, cbSigBlob, pmb); } return hr; } STDMETHODIMP FindMethod( mdTypeDef td, // [IN] given typedef LPCWSTR szName, // [IN] member name PCCOR_SIGNATURE pvSigBlob, // [IN] point to a blob value of CLR signature ULONG cbSigBlob, // [IN] count of bytes in the signature blob mdMethodDef *pmb) // [OUT] matching memberdef { if (pvSigBlob == NULL || cbSigBlob == 0) { // if signature matching is not needed, we can delegate to the underlying implementation return m_pRawImport->FindMethod(td, szName, pvSigBlob, cbSigBlob, pmb); } // The following code emulates RegMeta::FindMethod. We cannot call the underlying // implementation because we need to compare pvSigBlob to reinterpreted signatures. HRESULT hr = S_OK; HCORENUM hEnum = NULL; CQuickBytes qbSig; // holds non-varargs signature CQuickArray rName; if (szName == NULL || pmb == NULL) IfFailGo(E_INVALIDARG); *pmb = mdMethodDefNil; { // check to see if this is a vararg signature PCCOR_SIGNATURE pvSigTemp = pvSigBlob; if (isCallConv(CorSigUncompressCallingConv(pvSigTemp), IMAGE_CEE_CS_CALLCONV_VARARG)) { // Get the fixed part of VARARG signature IfFailGo(_GetFixedSigOfVarArg(pvSigBlob, cbSigBlob, &qbSig, &cbSigBlob)); pvSigBlob = (PCCOR_SIGNATURE) qbSig.Ptr(); } } // now iterate all methods in td and compare name and signature IfNullGo(rName.AllocNoThrow(wcslen(szName) + 1)); mdMethodDef md; ULONG count; while ((hr = EnumMethods(&hEnum, td, &md, 1, &count)) == S_OK) { PCCOR_SIGNATURE pvMethodSigBlob; ULONG cbMethodSigBlob; ULONG chMethodName; DWORD dwMethodAttr; IfFailGo(GetMethodProps(md, NULL, rName.Ptr(), (ULONG)rName.Size(), &chMethodName, &dwMethodAttr, &pvMethodSigBlob, &cbMethodSigBlob, NULL, NULL)); if (chMethodName == rName.Size() && wcscmp(szName, rName.Ptr()) == 0) { // we have a name match, check signature if (cbSigBlob != cbMethodSigBlob || memcmp(pvSigBlob, pvMethodSigBlob, cbSigBlob) != 0) continue; // ignore PrivateScope methods if (IsMdPrivateScope(dwMethodAttr)) continue; // we found the method *pmb = md; goto ErrExit; } } IfFailGo(hr); hr = CLDB_E_RECORD_NOTFOUND; ErrExit: if (hEnum != NULL) CloseEnum(hEnum); return hr; } STDMETHODIMP FindField( mdTypeDef td, // [IN] given typedef LPCWSTR szName, // [IN] member name PCCOR_SIGNATURE pvSigBlob, // [IN] point to a blob value of CLR signature ULONG cbSigBlob, // [IN] count of bytes in the signature blob mdFieldDef *pmb) // [OUT] matching memberdef { if (pvSigBlob == NULL || cbSigBlob == 0) { // if signature matching is not needed, we can delegate to the underlying implementation return m_pRawImport->FindField(td, szName, pvSigBlob, cbSigBlob, pmb); } // The following code emulates RegMeta::FindField. We cannot call the underlying // implementation because we need to compare pvSigBlob to reinterpreted signatures. HRESULT hr = S_OK; HCORENUM hEnum = NULL; CQuickArray rName; if (szName == NULL || pmb == NULL) IfFailGo(E_INVALIDARG); *pmb = mdFieldDefNil; // now iterate all fields in td and compare name and signature IfNullGo(rName.AllocNoThrow(wcslen(szName) + 1)); mdFieldDef fd; ULONG count; while ((hr = EnumFields(&hEnum, td, &fd, 1, &count)) == S_OK) { PCCOR_SIGNATURE pvFieldSigBlob; ULONG cbFieldSigBlob; ULONG chFieldName; DWORD dwFieldAttr; IfFailGo(GetFieldProps(fd, NULL, rName.Ptr(), (ULONG)rName.Size(), &chFieldName, &dwFieldAttr, &pvFieldSigBlob, &cbFieldSigBlob, NULL, NULL, NULL)); if (chFieldName == rName.Size() && wcscmp(szName, rName.Ptr()) == 0) { // we have a name match, check signature if (cbSigBlob != cbFieldSigBlob || memcmp(pvSigBlob, pvFieldSigBlob, cbSigBlob) != 0) continue; // ignore PrivateScope fields if (IsFdPrivateScope(dwFieldAttr)) continue; // we found the field *pmb = fd; goto ErrExit; } } IfFailGo(hr); hr = CLDB_E_RECORD_NOTFOUND; ErrExit: if (hEnum != NULL) CloseEnum(hEnum); return hr; } STDMETHODIMP FindMemberRef( mdTypeRef td, // [IN] given typeRef LPCWSTR szName, // [IN] member name PCCOR_SIGNATURE pvSigBlob, // [IN] point to a blob value of CLR signature ULONG cbSigBlob, // [IN] count of bytes in the signature blob mdMemberRef *pmr) // [OUT] matching memberref { if (pvSigBlob == NULL || cbSigBlob == 0) { // if signature matching is not needed, we can delegate to the underlying implementation return m_pRawImport->FindMemberRef(td, szName, pvSigBlob, cbSigBlob, pmr); } // The following code emulates RegMeta::FindMemberRef. We cannot call the underlying // implementation because we need to compare pvSigBlob to reinterpreted signatures. HRESULT hr = S_OK; HCORENUM hEnum = NULL; CQuickArray rName; if (szName == NULL || pmr == NULL) IfFailGo(CLDB_E_RECORD_NOTFOUND); *pmr = mdMemberRefNil; // now iterate all members in td and compare name and signature IfNullGo(rName.AllocNoThrow(wcslen(szName) + 1)); mdMemberRef rd; ULONG count; while ((hr = EnumMemberRefs(&hEnum, td, &rd, 1, &count)) == S_OK) { PCCOR_SIGNATURE pvMemberSigBlob; ULONG cbMemberSigBlob; ULONG chMemberName; IfFailGo(GetMemberRefProps(rd, NULL, rName.Ptr(), (ULONG)rName.Size(), &chMemberName, &pvMemberSigBlob, &cbMemberSigBlob)); if (chMemberName == rName.Size() && wcscmp(szName, rName.Ptr()) == 0) { // we have a name match, check signature if (cbSigBlob != cbMemberSigBlob || memcmp(pvSigBlob, pvMemberSigBlob, cbSigBlob) != 0) continue; // we found the member *pmr = rd; goto ErrExit; } } IfFailGo(hr); hr = CLDB_E_RECORD_NOTFOUND; ErrExit: if (hEnum != NULL) CloseEnum(hEnum); return hr; } STDMETHODIMP GetMethodProps( mdMethodDef mb, // The method for which to get props. mdTypeDef *pClass, // Put method's class here. __out_ecount_part_opt(cchMethod, *pchMethod) LPWSTR szMethod, // Put method's name here. ULONG cchMethod, // Size of szMethod buffer in wide chars. ULONG *pchMethod, // Put actual size here DWORD *pdwAttr, // Put flags here. PCCOR_SIGNATURE *ppvSigBlob, // [OUT] point to the blob value of meta data ULONG *pcbSigBlob, // [OUT] actual size of signature blob ULONG *pulCodeRVA, // [OUT] codeRVA DWORD *pdwImplFlags) // [OUT] Impl. Flags { HRESULT hr; HRESULT hrNameTruncation; if (!IsValidNonNilToken(mb, mdtMethodDef)) { // Idiosyncratic edge cases - delegate straight through to inherit the correct idiosyncratic edge result return m_pRawImport->GetMethodProps(mb, pClass, szMethod, cchMethod, pchMethod, pdwAttr, ppvSigBlob, pcbSigBlob, pulCodeRVA, pdwImplFlags); } ULONG cbOrigSigBlob = (ULONG)(-1); PCCOR_SIGNATURE pOrigSig = NULL; IfFailRet(hrNameTruncation = m_pRawImport->GetMethodProps(mb, pClass, szMethod, cchMethod, pchMethod, pdwAttr, &pOrigSig, &cbOrigSigBlob, pulCodeRVA, pdwImplFlags)); IfFailRet((m_pWinMDAdapter->GetSignatureForToken( mb, &pOrigSig, // ppOrigSig &cbOrigSigBlob, // pcbOrigSig ppvSigBlob, pcbSigBlob, m_pRawImport))); LPCSTR szNewName = NULL; IfFailRet(m_pWinMDAdapter->ModifyMethodProps(mb, pdwAttr, pdwImplFlags, pulCodeRVA, &szNewName)); if (szNewName != NULL) { // We want to return name truncation status from the method that really fills the output buffer, rewrite the previous value IfFailRet(hrNameTruncation = DeliverUtf8String(szNewName, szMethod, cchMethod, pchMethod)); } // Return the success code from name filling (S_OK or CLDB_S_TRUNCATION) return hrNameTruncation; } STDMETHODIMP GetMemberRefProps( // S_OK or error. mdMemberRef mr, // [IN] given memberref mdToken *ptk, // [OUT] Put classref or classdef here. __out_ecount_part_opt(cchMember, *pchMember) LPWSTR szMember, // [OUT] buffer to fill for member's name ULONG cchMember, // [IN] the count of char of szMember ULONG *pchMember, // [OUT] actual count of char in member name PCCOR_SIGNATURE *ppvSigBlob, // [OUT] point to meta data blob value ULONG *pbSig) // [OUT] actual size of signature blob { HRESULT hr = S_OK; HRESULT hrNameTruncation; ULONG cbOrigSigBlob = (ULONG)(-1); PCCOR_SIGNATURE pOrigSig = NULL; IfFailRet(hrNameTruncation = m_pRawImport->GetMemberRefProps(mr, ptk, szMember, cchMember, pchMember, &pOrigSig, &cbOrigSigBlob)); LPCSTR szNewName = NULL; IfFailRet(m_pWinMDAdapter->ModifyMemberProps(mr, NULL, NULL, NULL, &szNewName)); IfFailRet((m_pWinMDAdapter->GetSignatureForToken( mr, &pOrigSig, // ppOrigSig &cbOrigSigBlob, // pcbOrigSig ppvSigBlob, pbSig, m_pRawImport))); if (szNewName != NULL) { // We want to return name truncation status from the method that really fills the output buffer, rewrite the previous value IfFailRet(hrNameTruncation = DeliverUtf8String(szNewName, szMember, cchMember, pchMember)); } // Return the success code from name filling (S_OK or CLDB_S_TRUNCATION) return hrNameTruncation; } STDMETHODIMP EnumProperties( // S_OK, S_FALSE, or error. HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdTypeDef td, // [IN] TypeDef to scope the enumeration. mdProperty rProperties[], // [OUT] Put Properties here. ULONG cMax, // [IN] Max properties to put. ULONG *pcProperties) // [OUT] Put # put here. { return m_pRawImport->EnumProperties(phEnum, td, rProperties, cMax, pcProperties); } STDMETHODIMP EnumEvents( // S_OK, S_FALSE, or error. HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdTypeDef td, // [IN] TypeDef to scope the enumeration. mdEvent rEvents[], // [OUT] Put events here. ULONG cMax, // [IN] Max events to put. ULONG *pcEvents) // [OUT] Put # put here. { return m_pRawImport->EnumEvents(phEnum, td, rEvents, cMax, pcEvents); } STDMETHODIMP GetEventProps( // S_OK, S_FALSE, or error. mdEvent ev, // [IN] event token mdTypeDef *pClass, // [OUT] typedef containing the event declarion. LPCWSTR szEvent, // [OUT] Event name ULONG cchEvent, // [IN] the count of wchar of szEvent ULONG *pchEvent, // [OUT] actual count of wchar for event's name DWORD *pdwEventFlags, // [OUT] Event flags. mdToken *ptkEventType, // [OUT] EventType class mdMethodDef *pmdAddOn, // [OUT] AddOn method of the event mdMethodDef *pmdRemoveOn, // [OUT] RemoveOn method of the event mdMethodDef *pmdFire, // [OUT] Fire method of the event mdMethodDef rmdOtherMethod[], // [OUT] other method of the event ULONG cMax, // [IN] size of rmdOtherMethod ULONG *pcOtherMethod) // [OUT] total number of other method of this event { // Returns error code from name filling (may be CLDB_S_TRUNCTATION) return m_pRawImport->GetEventProps(ev, pClass, szEvent, cchEvent, pchEvent, pdwEventFlags, ptkEventType, pmdAddOn, pmdRemoveOn, pmdFire, rmdOtherMethod, cMax, pcOtherMethod); } STDMETHODIMP EnumMethodSemantics( // S_OK, S_FALSE, or error. HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdMethodDef mb, // [IN] MethodDef to scope the enumeration. mdToken rEventProp[], // [OUT] Put Event/Property here. ULONG cMax, // [IN] Max properties to put. ULONG *pcEventProp) // [OUT] Put # put here. { return m_pRawImport->EnumMethodSemantics(phEnum, mb, rEventProp, cMax, pcEventProp); } STDMETHODIMP GetMethodSemantics( // S_OK, S_FALSE, or error. mdMethodDef mb, // [IN] method token mdToken tkEventProp, // [IN] event/property token. DWORD *pdwSemanticsFlags) // [OUT] the role flags for the method/propevent pair { return m_pRawImport->GetMethodSemantics(mb, tkEventProp, pdwSemanticsFlags); } STDMETHODIMP GetClassLayout( mdTypeDef td, // [IN] give typedef DWORD *pdwPackSize, // [OUT] 1, 2, 4, 8, or 16 COR_FIELD_OFFSET rFieldOffset[], // [OUT] field offset array ULONG cMax, // [IN] size of the array ULONG *pcFieldOffset, // [OUT] needed array size ULONG *pulClassSize) // [OUT] the size of the class { return m_pRawImport->GetClassLayout(td, pdwPackSize, rFieldOffset, cMax, pcFieldOffset, pulClassSize); } STDMETHODIMP GetFieldMarshal( mdToken tk, // [IN] given a field's memberdef PCCOR_SIGNATURE *ppvNativeType, // [OUT] native type of this field ULONG *pcbNativeType) // [OUT] the count of bytes of *ppvNativeType { return m_pRawImport->GetFieldMarshal(tk, ppvNativeType, pcbNativeType); } STDMETHODIMP GetRVA( // S_OK or error. mdToken tk, // Member for which to set offset ULONG *pulCodeRVA, // The offset DWORD *pdwImplFlags) // the implementation flags { HRESULT hr; if (!IsValidNonNilToken(tk, mdtMethodDef)) { // Idiosyncratic edge cases - delegate straight through to inherit the correct idiosyncratic edge result return m_pRawImport->GetRVA(tk, pulCodeRVA, pdwImplFlags); } IfFailRet(m_pRawImport->GetRVA(tk, pulCodeRVA, pdwImplFlags)); IfFailRet(m_pWinMDAdapter->ModifyMethodProps(tk, NULL, pdwImplFlags, pulCodeRVA, NULL)); return hr; } STDMETHODIMP GetPermissionSetProps( mdPermission pm, // [IN] the permission token. DWORD *pdwAction, // [OUT] CorDeclSecurity. void const **ppvPermission, // [OUT] permission blob. ULONG *pcbPermission) // [OUT] count of bytes of pvPermission. { return m_pRawImport->GetPermissionSetProps(pm, pdwAction, ppvPermission, pcbPermission); } STDMETHODIMP GetSigFromToken( // S_OK or error. mdSignature mdSig, // [IN] Signature token. PCCOR_SIGNATURE *ppvSig, // [OUT] return pointer to token. ULONG *pcbSig) // [OUT] return size of signature. { // mdSignature is not part of public WinMD surface, so it does not need signature rewriting return m_pRawImport->GetSigFromToken(mdSig, ppvSig, pcbSig); } STDMETHODIMP GetModuleRefProps( // S_OK or error. mdModuleRef mur, // [IN] moduleref token. __out_ecount_part_opt(cchName, *pchName) LPWSTR szName, // [OUT] buffer to fill with the moduleref name. ULONG cchName, // [IN] size of szName in wide characters. ULONG *pchName) // [OUT] actual count of characters in the name. { // Returns error code from name filling (may be CLDB_S_TRUNCTATION) return m_pRawImport->GetModuleRefProps(mur, szName, cchName, pchName); } STDMETHODIMP EnumModuleRefs( // S_OK or error. HCORENUM *phEnum, // [IN|OUT] pointer to the enum. mdModuleRef rModuleRefs[], // [OUT] put modulerefs here. ULONG cmax, // [IN] max memberrefs to put. ULONG *pcModuleRefs) // [OUT] put # put here. { return m_pRawImport->EnumModuleRefs(phEnum, rModuleRefs, cmax, pcModuleRefs); } STDMETHODIMP GetTypeSpecFromToken( // S_OK or error. mdTypeSpec typespec, // [IN] TypeSpec token. PCCOR_SIGNATURE *ppvSig, // [OUT] return pointer to TypeSpec signature ULONG *pcbSig) // [OUT] return size of signature. { return m_pWinMDAdapter->GetSignatureForToken( typespec, NULL, // ppOrigSig NULL, // pcbOrigSig ppvSig, pcbSig, m_pRawImport); } STDMETHODIMP GetNameFromToken( // Not Recommended! May be removed! mdToken tk, // [IN] Token to get name from. Must have a name. MDUTF8CSTR *pszUtf8NamePtr) // [OUT] Return pointer to UTF8 name in heap. { HRESULT hr; if (!IsValidNonNilToken(tk, mdtTypeRef)) { // Handle corner error case IfFailGo(m_pRawImport->GetNameFromToken(tk, pszUtf8NamePtr)); } else { IfFailGo(m_pWinMDAdapter->GetTypeRefProps(tk, NULL, pszUtf8NamePtr, NULL)); } ErrExit: return hr; } STDMETHODIMP EnumUnresolvedMethods( // S_OK, S_FALSE, or error. HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdToken rMethods[], // [OUT] Put MemberDefs here. ULONG cMax, // [IN] Max MemberDefs to put. ULONG *pcTokens) // [OUT] Put # put here. { return m_pRawImport->EnumUnresolvedMethods(phEnum, rMethods, cMax, pcTokens); } STDMETHODIMP GetUserString( // S_OK or error. mdString stk, // [IN] String token. __out_ecount_part_opt(cchString, *pchString) LPWSTR szString, // [OUT] Copy of string. ULONG cchString, // [IN] Max chars of room in szString. ULONG *pchString) // [OUT] How many chars in actual string. { // Returns error code from name filling (may be CLDB_S_TRUNCTATION) return m_pRawImport->GetUserString(stk, szString, cchString, pchString); } STDMETHODIMP GetPinvokeMap( // S_OK or error. mdToken tk, // [IN] FieldDef or MethodDef. DWORD *pdwMappingFlags, // [OUT] Flags used for mapping. __out_ecount_part_opt(cchImportName, *pchImportName) LPWSTR szImportName, // [OUT] Import name. ULONG cchImportName, // [IN] Size of the name buffer. ULONG *pchImportName, // [OUT] Actual number of characters stored. mdModuleRef *pmrImportDLL) // [OUT] ModuleRef token for the target DLL. { // Returns error code from name filling (may be CLDB_S_TRUNCTATION) return m_pRawImport->GetPinvokeMap(tk, pdwMappingFlags, szImportName, cchImportName, pchImportName, pmrImportDLL); } STDMETHODIMP EnumSignatures( // S_OK or error. HCORENUM *phEnum, // [IN|OUT] pointer to the enum. mdSignature rSignatures[], // [OUT] put signatures here. ULONG cmax, // [IN] max signatures to put. ULONG *pcSignatures) // [OUT] put # put here. { return m_pRawImport->EnumSignatures(phEnum, rSignatures, cmax, pcSignatures); } STDMETHODIMP EnumTypeSpecs( // S_OK or error. HCORENUM *phEnum, // [IN|OUT] pointer to the enum. mdTypeSpec rTypeSpecs[], // [OUT] put TypeSpecs here. ULONG cmax, // [IN] max TypeSpecs to put. ULONG *pcTypeSpecs) // [OUT] put # put here. { return m_pRawImport->EnumTypeSpecs(phEnum, rTypeSpecs, cmax, pcTypeSpecs); } STDMETHODIMP EnumUserStrings( // S_OK or error. HCORENUM *phEnum, // [IN/OUT] pointer to the enum. mdString rStrings[], // [OUT] put Strings here. ULONG cmax, // [IN] max Strings to put. ULONG *pcStrings) // [OUT] put # put here. { return m_pRawImport->EnumUserStrings(phEnum, rStrings, cmax, pcStrings); } STDMETHODIMP GetParamForMethodIndex( // S_OK or error. mdMethodDef md, // [IN] Method token. ULONG ulParamSeq, // [IN] Parameter sequence. mdParamDef *ppd) // [IN] Put Param token here. { return m_pRawImport->GetParamForMethodIndex(md, ulParamSeq, ppd); } STDMETHODIMP EnumCustomAttributes( // S_OK or error. HCORENUM *phEnum, // [IN, OUT] COR enumerator. mdToken tk, // [IN] Token to scope the enumeration, 0 for all. mdToken tkType, // [IN] Type of interest, 0 for all. mdCustomAttribute rCustomAttributes[], // [OUT] Put custom attribute tokens here. ULONG cMax, // [IN] Size of rCustomAttributes. ULONG *pcCustomAttributes) // [OUT, OPTIONAL] Put count of token values here. { return m_pRawImport->EnumCustomAttributes(phEnum, tk, tkType, rCustomAttributes, cMax, pcCustomAttributes); } STDMETHODIMP GetCustomAttributeProps( // S_OK or error. mdCustomAttribute cv, // [IN] CustomAttribute token. mdToken *ptkObj, // [OUT, OPTIONAL] Put object token here. mdToken *ptkType, // [OUT, OPTIONAL] Put AttrType token here. void const **ppBlob, // [OUT, OPTIONAL] Put pointer to data here. ULONG *pcbSize) // [OUT, OPTIONAL] Put size of date here. { HRESULT hr; if (!IsValidNonNilToken(cv, mdtCustomAttribute)) { // Idiosyncratic edge cases - delegate straight through to inherit the correct idiosyncratic edge result return m_pRawImport->GetCustomAttributeProps(cv, ptkObj, ptkType, ppBlob, pcbSize); } IfFailRet(m_pRawImport->GetCustomAttributeProps(cv, ptkObj, ptkType, NULL, NULL)); IfFailRet(m_pWinMDAdapter->GetCustomAttributeBlob(cv, ppBlob, pcbSize)); return hr; } STDMETHODIMP FindTypeRef( mdToken tkResolutionScope, // [IN] ModuleRef, AssemblyRef or TypeRef. LPCWSTR wzTypeName, // [IN] TypeRef Name. mdTypeRef *ptr) // [OUT] matching TypeRef. { HRESULT hr; LPUTF8 szFullName; LPCUTF8 szNamespace; LPCUTF8 szName; _ASSERTE(wzTypeName && ptr); *ptr = mdTypeRefNil; // AV if caller passes NULL: just like the real RegMeta. // Convert the name to UTF8. PREFIX_ASSUME(wzTypeName != NULL); // caller might pass NULL, but they'll AV (just like the real RegMeta) UTF8STR(wzTypeName, szFullName); ns::SplitInline(szFullName, szNamespace, szName); hr = m_pWinMDAdapter->FindTypeRef(szNamespace, szName, tkResolutionScope, ptr); return hr; } STDMETHODIMP GetMemberProps( mdToken mb, // The member for which to get props. mdTypeDef *pClass, // Put member's class here. __out_ecount_part_opt(cchMember, *pchMember) LPWSTR szMember, // Put member's name here. ULONG cchMember, // Size of szMember buffer in wide chars. ULONG *pchMember, // Put actual size here DWORD *pdwAttr, // Put flags here. PCCOR_SIGNATURE *ppvSigBlob, // [OUT] point to the blob value of meta data ULONG *pcbSigBlob, // [OUT] actual size of signature blob ULONG *pulCodeRVA, // [OUT] codeRVA DWORD *pdwImplFlags, // [OUT] Impl. Flags DWORD *pdwCPlusTypeFlag, // [OUT] flag for value type. selected ELEMENT_TYPE_* UVCP_CONSTANT *ppValue, // [OUT] constant value ULONG *pcchValue) // [OUT] size of constant string in chars, 0 for non-strings. { HRESULT hr; HRESULT hrNameTruncation; if (!IsValidNonNilToken(mb, mdtMethodDef) && !IsValidNonNilToken(mb, mdtFieldDef)) { // Idiosyncratic edge cases - delegate straight through to inherit the correct idiosyncratic edge result return m_pRawImport->GetMemberProps(mb, pClass, szMember, cchMember, pchMember, pdwAttr, ppvSigBlob, pcbSigBlob, pulCodeRVA, pdwImplFlags, pdwCPlusTypeFlag, ppValue, pcchValue); } PCCOR_SIGNATURE pOrigSig; ULONG cbOrigSig; IfFailRet(hrNameTruncation = m_pRawImport->GetMemberProps(mb, pClass, szMember, cchMember, pchMember, pdwAttr, &pOrigSig, &cbOrigSig, pulCodeRVA, pdwImplFlags, pdwCPlusTypeFlag, ppValue, pcchValue)); LPCSTR szNewName = NULL; IfFailRet(m_pWinMDAdapter->ModifyMemberProps(mb, pdwAttr, pdwImplFlags, pulCodeRVA, &szNewName)); if (IsValidNonNilToken(mb, mdtMethodDef)) { IfFailRet((m_pWinMDAdapter->GetSignatureForToken( mb, &pOrigSig, // ppOrigSig &cbOrigSig, // pcbOrigSig ppvSigBlob, pcbSigBlob, m_pRawImport))); } else if (IsValidNonNilToken(mb, mdtFieldDef)) { IfFailRet((m_pWinMDAdapter->GetSignatureForToken( mb, &pOrigSig, // ppOrigSig &cbOrigSig, // pcbOrigSig ppvSigBlob, pcbSigBlob, m_pRawImport))); } else { if (ppvSigBlob != NULL) *ppvSigBlob = pOrigSig; if (pcbSigBlob != NULL) *pcbSigBlob = cbOrigSig; } if (szNewName != NULL) { // We want to return name truncation status from the method that really fills the output buffer, rewrite the previous value IfFailRet(hrNameTruncation = DeliverUtf8String(szNewName, szMember, cchMember, pchMember)); } // Return the success code from name filling (S_OK or CLDB_S_TRUNCATION) return hrNameTruncation; } STDMETHODIMP GetFieldProps( mdFieldDef mb, // The field for which to get props. mdTypeDef *pClass, // Put field's class here. __out_ecount_part_opt(cchField, *pchField) LPWSTR szField, // Put field's name here. ULONG cchField, // Size of szField buffer in wide chars. ULONG *pchField, // Put actual size here DWORD *pdwAttr, // Put flags here. PCCOR_SIGNATURE *ppvSigBlob, // [OUT] point to the blob value of meta data ULONG *pcbSigBlob, // [OUT] actual size of signature blob DWORD *pdwCPlusTypeFlag, // [OUT] flag for value type. selected ELEMENT_TYPE_* UVCP_CONSTANT *ppValue, // [OUT] constant value ULONG *pcchValue) // [OUT] size of constant string in chars, 0 for non-strings. { HRESULT hr; HRESULT hrNameTruncation; PCCOR_SIGNATURE pOrigSig; ULONG cbOrigSig; IfFailRet(hrNameTruncation = m_pRawImport->GetFieldProps(mb, pClass, szField, cchField, pchField, pdwAttr, &pOrigSig, &cbOrigSig, pdwCPlusTypeFlag, ppValue, pcchValue)); IfFailRet(m_pWinMDAdapter->ModifyFieldDefProps(mb, pdwAttr)); IfFailRet((m_pWinMDAdapter->GetSignatureForToken( mb, &pOrigSig, &cbOrigSig, ppvSigBlob, pcbSigBlob, m_pRawImport))); // Return the success code from name filling (S_OK or CLDB_S_TRUNCATION) return hrNameTruncation; } STDMETHODIMP GetPropertyProps( // S_OK, S_FALSE, or error. mdProperty prop, // [IN] property token mdTypeDef *pClass, // [OUT] typedef containing the property declarion. LPCWSTR szProperty, // [OUT] Property name ULONG cchProperty, // [IN] the count of wchar of szProperty ULONG *pchProperty, // [OUT] actual count of wchar for property name DWORD *pdwPropFlags, // [OUT] property flags. PCCOR_SIGNATURE *ppvSig, // [OUT] property type. pointing to meta data internal blob ULONG *pbSig, // [OUT] count of bytes in *ppvSig DWORD *pdwCPlusTypeFlag, // [OUT] flag for value type. selected ELEMENT_TYPE_* UVCP_CONSTANT *ppDefaultValue, // [OUT] constant value ULONG *pcchDefaultValue, // [OUT] size of constant string in chars, 0 for non-strings. mdMethodDef *pmdSetter, // [OUT] setter method of the property mdMethodDef *pmdGetter, // [OUT] getter method of the property mdMethodDef rmdOtherMethod[], // [OUT] other method of the property ULONG cMax, // [IN] size of rmdOtherMethod ULONG *pcOtherMethod) // [OUT] total number of other method of this property { HRESULT hr = S_OK; HRESULT hrNameTruncation; ULONG cbOrigSigBlob = (ULONG)(-1); PCCOR_SIGNATURE pOrigSig = NULL; IfFailRet(hrNameTruncation = m_pRawImport->GetPropertyProps(prop, pClass, szProperty, cchProperty, pchProperty, pdwPropFlags, &pOrigSig, &cbOrigSigBlob, pdwCPlusTypeFlag, ppDefaultValue, pcchDefaultValue, pmdSetter, pmdGetter, rmdOtherMethod, cMax, pcOtherMethod)); IfFailRet((m_pWinMDAdapter->GetSignatureForToken( prop, &pOrigSig, // ppOrigSig &cbOrigSigBlob, // pcbOrigSig ppvSig, pbSig, m_pRawImport))); // Return the success code from name filling (S_OK or CLDB_S_TRUNCATION) return hrNameTruncation; } STDMETHODIMP GetParamProps( // S_OK or error. mdParamDef tk, // [IN]The Parameter. mdMethodDef *pmd, // [OUT] Parent Method token. ULONG *pulSequence, // [OUT] Parameter sequence. __out_ecount_part_opt(cchName, *pchName) LPWSTR szName, // [OUT] Put name here. ULONG cchName, // [OUT] Size of name buffer. ULONG *pchName, // [OUT] Put actual size of name here. DWORD *pdwAttr, // [OUT] Put flags here. DWORD *pdwCPlusTypeFlag, // [OUT] Flag for value type. selected ELEMENT_TYPE_*. UVCP_CONSTANT *ppValue, // [OUT] Constant value. ULONG *pcchValue) // [OUT] size of constant string in chars, 0 for non-strings. { // Returns error code from name filling (may be CLDB_S_TRUNCTATION) return m_pRawImport->GetParamProps(tk, pmd, pulSequence, szName, cchName, pchName, pdwAttr, pdwCPlusTypeFlag, ppValue, pcchValue); } STDMETHODIMP GetCustomAttributeByName( // S_OK or error. mdToken tkObj, // [IN] Object with Custom Attribute. LPCWSTR wszName, // [IN] Name of desired Custom Attribute. const void **ppData, // [OUT] Put pointer to data here. ULONG *pcbData) // [OUT] Put size of data here. { HRESULT hr; if (wszName == NULL) { hr = S_FALSE; // Questionable response but maintains compatibility with RegMeta } else { MAKE_UTF8PTR_FROMWIDE_NOTHROW(szName, wszName); IfNullGo(szName); IfFailGo(CommonGetCustomAttributeByName(tkObj, szName, ppData, pcbData)); } ErrExit: return hr; } STDMETHODIMP_(BOOL) IsValidToken( // True or False. mdToken tk) // [IN] Given token. { mdToken tokenType = TypeFromToken(tk); if (tokenType == mdtAssemblyRef) return m_pWinMDAdapter->IsValidAssemblyRefToken(tk); return m_pRawImport->IsValidToken(tk); } STDMETHODIMP GetNestedClassProps( // S_OK or error. mdTypeDef tdNestedClass, // [IN] NestedClass token. mdTypeDef *ptdEnclosingClass) // [OUT] EnclosingClass token. { return m_pRawImport->GetNestedClassProps(tdNestedClass, ptdEnclosingClass); } STDMETHODIMP GetNativeCallConvFromSig( // S_OK or error. void const *pvSig, // [IN] Pointer to signature. ULONG cbSig, // [IN] Count of signature bytes. ULONG *pCallConv) // [OUT] Put calling conv here (see CorPinvokemap). { return m_pRawImport->GetNativeCallConvFromSig(pvSig, cbSig, pCallConv); } STDMETHODIMP IsGlobal( // S_OK or error. mdToken pd, // [IN] Type, Field, or Method token. int *pbGlobal) // [OUT] Put 1 if global, 0 otherwise. { return m_pRawImport->IsGlobal(pd, pbGlobal); } public: // ======================================================== // IMetaDataWinMDImport methods // ======================================================== // This method returns the RAW view of the metadata. Essentially removing the Adapter's projection support for the typeRef. STDMETHODIMP GetUntransformedTypeRefProps( mdTypeRef tr, // [IN] TypeRef token. mdToken *ptkResolutionScope, // [OUT] Resolution scope, ModuleRef or AssemblyRef. __out_ecount_part_opt(cchName, *pchName) LPWSTR szName, // [OUT] Unprojected name of the TypeRef. ULONG cchName, // [IN] Size of buffer. ULONG *pchName) // [OUT] Size of Name. { // By-pass the call to the raw importer, removing the adapter layer. return m_pRawImport->GetTypeRefProps(tr, ptkResolutionScope, szName, cchName, pchName); } //========================================================= // IMetaDataImport2 methods //========================================================= STDMETHODIMP EnumGenericParams( HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdToken tk, // [IN] TypeDef or MethodDef whose generic parameters are requested mdGenericParam rGenericParams[], // [OUT] Put GenericParams here. ULONG cMax, // [IN] Max GenericParams to put. ULONG *pcGenericParams) // [OUT] Put # put here. { return m_pRawImport->EnumGenericParams(phEnum, tk, rGenericParams, cMax, pcGenericParams); } STDMETHODIMP GetGenericParamProps( // S_OK or error. mdGenericParam gp, // [IN] GenericParam ULONG *pulParamSeq, // [OUT] Index of the type parameter DWORD *pdwParamFlags, // [OUT] Flags, for future use (e.g. variance) mdToken *ptOwner, // [OUT] Owner (TypeDef or MethodDef) DWORD *reserved, // [OUT] For future use (e.g. non-type parameters) __out_ecount_part_opt(cchName, *pchName) LPWSTR wzname, // [OUT] Put name here ULONG cchName, // [IN] Size of buffer ULONG *pchName) // [OUT] Put size of name (wide chars) here. { // Returns error code from name filling (may be CLDB_S_TRUNCTATION) return m_pRawImport->GetGenericParamProps(gp, pulParamSeq, pdwParamFlags, ptOwner, reserved, wzname, cchName, pchName); } STDMETHODIMP GetMethodSpecProps( mdMethodSpec mi, // [IN] The method instantiation mdToken *tkParent, // [OUT] MethodDef or MemberRef PCCOR_SIGNATURE *ppvSigBlob, // [OUT] point to the blob value of meta data ULONG *pcbSigBlob) // [OUT] actual size of signature blob { HRESULT hr = S_OK; ULONG cbOrigSigBlob = (ULONG)(-1); PCCOR_SIGNATURE pOrigSig = NULL; IfFailRet(m_pRawImport->GetMethodSpecProps(mi, tkParent, &pOrigSig, &cbOrigSigBlob)); return m_pWinMDAdapter->GetSignatureForToken( mi, &pOrigSig, // ppOrigSig &cbOrigSigBlob, // pcbOrigSig ppvSigBlob, pcbSigBlob, m_pRawImport); } STDMETHODIMP EnumGenericParamConstraints( HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdGenericParam tk, // [IN] GenericParam whose constraints are requested mdGenericParamConstraint rGenericParamConstraints[], // [OUT] Put GenericParamConstraints here. ULONG cMax, // [IN] Max GenericParamConstraints to put. ULONG *pcGenericParamConstraints) // [OUT] Put # put here. { return m_pRawImport->EnumGenericParamConstraints(phEnum, tk, rGenericParamConstraints, cMax, pcGenericParamConstraints); } STDMETHODIMP GetGenericParamConstraintProps( // S_OK or error. mdGenericParamConstraint gpc, // [IN] GenericParamConstraint mdGenericParam *ptGenericParam, // [OUT] GenericParam that is constrained mdToken *ptkConstraintType) // [OUT] TypeDef/Ref/Spec constraint { return m_pRawImport->GetGenericParamConstraintProps(gpc, ptGenericParam, ptkConstraintType); } STDMETHODIMP GetPEKind( // S_OK or error. DWORD* pdwPEKind, // [OUT] The kind of PE (0 - not a PE) DWORD* pdwMachine) // [OUT] Machine as defined in NT header { return m_pRawImport->GetPEKind(pdwPEKind, pdwMachine); } STDMETHODIMP GetVersionString( // S_OK or error. __out_ecount_part_opt(ccBufSize, *pccBufSize) LPWSTR pwzBuf, // [OUT] Put version string here. DWORD ccBufSize, // [IN] size of the buffer, in wide chars DWORD *pccBufSize) // [OUT] Size of the version string, wide chars, including terminating nul. { HRESULT hr; LPCSTR szVersion; IfFailRet(GetVersionString(&szVersion)); // Returns error code from name filling (may be CLDB_S_TRUNCTATION) return DeliverUtf8String(szVersion, pwzBuf, ccBufSize, pccBufSize); } STDMETHODIMP EnumMethodSpecs( HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdToken tk, // [IN] MethodDef or MemberRef whose MethodSpecs are requested mdMethodSpec rMethodSpecs[], // [OUT] Put MethodSpecs here. ULONG cMax, // [IN] Max tokens to put. ULONG *pcMethodSpecs) // [OUT] Put actual count here. { return m_pRawImport->EnumMethodSpecs(phEnum, tk, rMethodSpecs, cMax, pcMethodSpecs); } public: //========================================================= // IMetaDataAssemblyImport methods //========================================================= STDMETHODIMP GetAssemblyProps( // S_OK or error. mdAssembly mda, // [IN] The Assembly for which to get the properties. const void **ppbPublicKey, // [OUT] Pointer to the public key. ULONG *pcbPublicKey, // [OUT] Count of bytes in the public key. ULONG *pulHashAlgId, // [OUT] Hash Algorithm. __out_ecount_part_opt(cchName, *pchName) LPWSTR szName, // [OUT] Buffer to fill with assembly's simply name. ULONG cchName, // [IN] Size of buffer in wide chars. ULONG *pchName, // [OUT] Actual # of wide chars in name. ASSEMBLYMETADATA *pMetaData, // [OUT] Assembly MetaData. DWORD *pdwAssemblyFlags) // [OUT] Flags. { return m_pRawAssemblyImport->GetAssemblyProps(mda, ppbPublicKey, pcbPublicKey, pulHashAlgId, szName, cchName, pchName, pMetaData, pdwAssemblyFlags); } STDMETHODIMP GetAssemblyRefProps( // S_OK or error. mdAssemblyRef mdar, // [IN] The AssemblyRef for which to get the properties. const void **ppbPublicKeyOrToken, // [OUT] Pointer to the public key or token. ULONG *pcbPublicKeyOrToken, // [OUT] Count of bytes in the public key or token. __out_ecount_part_opt(cchName, *pchName)LPWSTR szName, // [OUT] Buffer to fill with name. ULONG cchName, // [IN] Size of buffer in wide chars. ULONG *pchName, // [OUT] Actual # of wide chars in name. ASSEMBLYMETADATA *pMetaData, // [OUT] Assembly MetaData. const void **ppbHashValue, // [OUT] Hash blob. ULONG *pcbHashValue, // [OUT] Count of bytes in the hash blob. DWORD *pdwAssemblyRefFlags) // [OUT] Flags. { HRESULT hr; HRESULT hrNameTruncation; if (!IsValidNonNilToken(mdar, mdtAssemblyRef)) { // Idiosyncratic edge cases - delegate straight through to inherit the correct idiosyncratic edge result return m_pRawAssemblyImport->GetAssemblyRefProps(mdar, ppbPublicKeyOrToken, pcbPublicKeyOrToken, szName, cchName, pchName, pMetaData, ppbHashValue, pcbHashValue, pdwAssemblyRefFlags); } mdAssemblyRef md = mdar; if (RidFromToken(md) > m_pWinMDAdapter->GetRawAssemblyRefCount()) { // The extra framework assemblies we add references to should all have the // same verion, key, culture, etc as those of mscorlib. // So we retrieve the mscorlib properties and change the name. md = m_pWinMDAdapter->GetAssemblyRefMscorlib(); } IfFailRet(hrNameTruncation = m_pRawAssemblyImport->GetAssemblyRefProps(md, ppbPublicKeyOrToken, pcbPublicKeyOrToken, szName, cchName, pchName, pMetaData, ppbHashValue, pcbHashValue, pdwAssemblyRefFlags)); LPCSTR szNewName = nullptr; USHORT *pusMajorVersion = nullptr; USHORT *pusMinorVersion = nullptr; USHORT *pusBuildNumber = nullptr; USHORT *pusRevisionNumber = nullptr; if (pMetaData != nullptr) { pusMajorVersion = &pMetaData->usMajorVersion; pusMinorVersion = &pMetaData->usMinorVersion; pusBuildNumber = &pMetaData->usBuildNumber; pusRevisionNumber = &pMetaData->usRevisionNumber; } m_pWinMDAdapter->ModifyAssemblyRefProps( mdar, ppbPublicKeyOrToken, pcbPublicKeyOrToken, &szNewName, pusMajorVersion, pusMinorVersion, pusBuildNumber, pusRevisionNumber, ppbHashValue, pcbHashValue); if (szNewName != nullptr) { IfFailRet(hrNameTruncation = DeliverUtf8String(szNewName, szName, cchName, pchName)); } // Return the success code from name filling (S_OK or CLDB_S_TRUNCATION) return hrNameTruncation; } STDMETHODIMP GetFileProps( // S_OK or error. mdFile mdf, // [IN] The File for which to get the properties. __out_ecount_part_opt(cchName, *pchName) LPWSTR szName, // [OUT] Buffer to fill with name. ULONG cchName, // [IN] Size of buffer in wide chars. ULONG *pchName, // [OUT] Actual # of wide chars in name. const void **ppbHashValue, // [OUT] Pointer to the Hash Value Blob. ULONG *pcbHashValue, // [OUT] Count of bytes in the Hash Value Blob. DWORD *pdwFileFlags) // [OUT] Flags. { // Returns error code from name filling (may be CLDB_S_TRUNCTATION) return m_pRawAssemblyImport->GetFileProps(mdf, szName, cchName, pchName, ppbHashValue, pcbHashValue, pdwFileFlags); } STDMETHODIMP GetExportedTypeProps( // S_OK or error. mdExportedType mdct, // [IN] The ExportedType for which to get the properties. __out_ecount_part_opt(cchName, *pchName) LPWSTR szName, // [OUT] Buffer to fill with name. ULONG cchName, // [IN] Size of buffer in wide chars. ULONG *pchName, // [OUT] Actual # of wide chars in name. mdToken *ptkImplementation, // [OUT] mdFile or mdAssemblyRef or mdExportedType. mdTypeDef *ptkTypeDef, // [OUT] TypeDef token within the file. DWORD *pdwExportedTypeFlags) // [OUT] Flags. { HRESULT hr; LPCSTR szUtf8Namespace; LPCSTR szUtf8Name; if (!IsValidNonNilToken(mdct, mdtExportedType)) { // Idiosyncractic edge cases - delegate straight through to inherit the correct idiosyncractic edge results return m_pRawAssemblyImport->GetExportedTypeProps(mdct, szName, cchName, pchName, ptkImplementation, ptkTypeDef, pdwExportedTypeFlags); } IfFailRet(m_pRawAssemblyImport->GetExportedTypeProps(mdct, NULL, 0, NULL, NULL, ptkTypeDef, pdwExportedTypeFlags)); IfFailRet(this->CommonGetExportedTypeProps(mdct, &szUtf8Namespace, &szUtf8Name, ptkImplementation)); // Returns error code from name filling (may be CLDB_S_TRUNCTATION) return DeliverUtf8NamespaceAndName(szUtf8Namespace, szUtf8Name, szName, cchName, pchName); } STDMETHODIMP GetManifestResourceProps( // S_OK or error. mdManifestResource mdmr, // [IN] The ManifestResource for which to get the properties. __out_ecount_part_opt(cchName, *pchName)LPWSTR szName, // [OUT] Buffer to fill with name. ULONG cchName, // [IN] Size of buffer in wide chars. ULONG *pchName, // [OUT] Actual # of wide chars in name. mdToken *ptkImplementation, // [OUT] mdFile or mdAssemblyRef that provides the ManifestResource. DWORD *pdwOffset, // [OUT] Offset to the beginning of the resource within the file. DWORD *pdwResourceFlags) // [OUT] Flags. { // Returns error code from name filling (may be CLDB_S_TRUNCTATION) return m_pRawAssemblyImport->GetManifestResourceProps(mdmr, szName, cchName, pchName, ptkImplementation, pdwOffset, pdwResourceFlags); } STDMETHODIMP EnumAssemblyRefs( // S_OK or error HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdAssemblyRef rAssemblyRefs[], // [OUT] Put AssemblyRefs here. ULONG cMax, // [IN] Max AssemblyRefs to put. ULONG *pcTokens) // [OUT] Put # put here. { if (*phEnum != NULL) { // No trick needed: a previous call to EnumAssemblyRefs must have already taken care of the // extra assembly refs. return m_pRawAssemblyImport->EnumAssemblyRefs(phEnum, rAssemblyRefs, cMax, pcTokens); } else { // if *phEnum is NULL, we need create the HENUMInternal, adjust the assembly ref count, // and enumerate the number of assembly refs requested. This is done in three steps: HRESULT hr; // Step 1: Call EnumAssemblyRefs with an empty buffer to create the HENUMInternal IfFailGo(m_pRawAssemblyImport->EnumAssemblyRefs(phEnum, NULL, 0, NULL)); { // Step 2: Increment the count to include the extra assembly refs HENUMInternal *phInternalEnum = static_cast(*phEnum); _ASSERTE(phInternalEnum->m_EnumType == MDSimpleEnum); _ASSERTE( phInternalEnum->m_ulCount == m_pWinMDAdapter->GetRawAssemblyRefCount()); int n = m_pWinMDAdapter->GetExtraAssemblyRefCount(); phInternalEnum->m_ulCount += n; phInternalEnum->u.m_ulEnd += n; } // Step 3: Call EnumAssemblyRefs again and pass in the modifed HENUMInternal and the real buffer IfFailGo(m_pRawAssemblyImport->EnumAssemblyRefs(phEnum, rAssemblyRefs, cMax, pcTokens)); ErrExit: return hr; } } STDMETHODIMP EnumFiles( // S_OK or error HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdFile rFiles[], // [OUT] Put Files here. ULONG cMax, // [IN] Max Files to put. ULONG *pcTokens) // [OUT] Put # put here. { return m_pRawAssemblyImport->EnumFiles(phEnum, rFiles, cMax, pcTokens); } STDMETHODIMP EnumExportedTypes( // S_OK or error HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdExportedType rExportedTypes[], // [OUT] Put ExportedTypes here. ULONG cMax, // [IN] Max ExportedTypes to put. ULONG *pcTokens) // [OUT] Put # put here. { return m_pRawAssemblyImport->EnumExportedTypes(phEnum, rExportedTypes, cMax, pcTokens); } STDMETHODIMP EnumManifestResources( // S_OK or error HCORENUM *phEnum, // [IN|OUT] Pointer to the enum. mdManifestResource rManifestResources[], // [OUT] Put ManifestResources here. ULONG cMax, // [IN] Max Resources to put. ULONG *pcTokens) // [OUT] Put # put here. { return m_pRawAssemblyImport->EnumManifestResources(phEnum, rManifestResources, cMax, pcTokens); } STDMETHODIMP GetAssemblyFromScope( // S_OK or error mdAssembly *ptkAssembly) // [OUT] Put token here. { return m_pRawAssemblyImport->GetAssemblyFromScope(ptkAssembly); } STDMETHODIMP FindExportedTypeByName( // S_OK or error LPCWSTR wszName, // [IN] Name of the ExportedType. mdToken mdtExportedType, // [IN] ExportedType for the enclosing class. mdExportedType *ptkExportedType) // [OUT] Put the ExportedType token here. { if (wszName == NULL) return E_INVALIDARG; LPUTF8 szFullName; LPCUTF8 szNamespace; LPCUTF8 szName; // Convert the name to UTF8. UTF8STR(wszName, szFullName); ns::SplitInline(szFullName, szNamespace, szName); return this->CommonFindExportedType(szNamespace, szName, mdtExportedType, ptkExportedType); } STDMETHODIMP FindManifestResourceByName( // S_OK or error LPCWSTR szName, // [IN] Name of the ManifestResource. mdManifestResource *ptkManifestResource) // [OUT] Put the ManifestResource token here. { return m_pRawAssemblyImport->FindManifestResourceByName(szName, ptkManifestResource); } STDMETHODIMP FindAssembliesByName( // S_OK or error LPCWSTR szAppBase, // [IN] optional - can be NULL LPCWSTR szPrivateBin, // [IN] optional - can be NULL LPCWSTR szAssemblyName, // [IN] required - this is the assembly you are requesting IUnknown *ppIUnk[], // [OUT] put IMetaDataAssemblyImport pointers here ULONG cMax, // [IN] The max number to put ULONG *pcAssemblies) // [OUT] The number of assemblies returned. { return m_pRawAssemblyImport->FindAssembliesByName(szAppBase, szPrivateBin, szAssemblyName, ppIUnk, cMax, pcAssemblies); } //========================================================= // IMetaDataValidate //========================================================= STDMETHODIMP ValidatorInit( // S_OK or error. DWORD dwModuleType, // [IN] Specifies the type of the module. IUnknown *pUnk) // [IN] Validation error handler. { if (m_pRawValidate == nullptr) return E_NOTIMPL; return m_pRawValidate->ValidatorInit(dwModuleType, pUnk); } STDMETHODIMP ValidateMetaData() // S_OK or error. { if (m_pRawValidate == nullptr) return E_NOTIMPL; return m_pRawValidate->ValidateMetaData(); } //========================================================= // IMDCommon methods //========================================================= STDMETHODIMP_(IMetaModelCommon*) GetMetaModelCommon() { return this; } STDMETHODIMP_(IMetaModelCommonRO*) GetMetaModelCommonRO() { _ASSERTE(!"WinMDImport does not support GetMetaModelCommonRO(). The most likely cause of this assert is that you're trying to wrap a WinMD adapter around another WinMD adapter."); return NULL; } STDMETHODIMP GetVersionString(LPCSTR *pszVersionString) { return m_pWinMDAdapter->GetVersionString(pszVersionString); } //========================================================= // IMetaModelCommon methods //========================================================= __checkReturn virtual HRESULT CommonGetScopeProps( LPCUTF8 *pszName, GUID *pMvid) { return m_pRawMetaModelCommonRO->CommonGetScopeProps(pszName, pMvid); } __checkReturn virtual HRESULT CommonGetTypeRefProps( mdTypeRef tr, LPCUTF8 *pszNamespace, LPCUTF8 *pszName, mdToken *ptkResolution) { return m_pWinMDAdapter->GetTypeRefProps(tr, pszNamespace, pszName, ptkResolution); } __checkReturn virtual HRESULT CommonGetTypeDefProps( mdTypeDef td, LPCUTF8 *pszNameSpace, LPCUTF8 *pszName, DWORD *pdwFlags, mdToken *pdwExtends, ULONG *pMethodList) { HRESULT hr; IfFailGo(m_pRawMetaModelCommonRO->CommonGetTypeDefProps(td, NULL, NULL, NULL, NULL, pMethodList)); IfFailGo(m_pWinMDAdapter->GetTypeDefProps(td, pszNameSpace, pszName, pdwFlags, pdwExtends)); ErrExit: return hr; } __checkReturn virtual HRESULT CommonGetTypeSpecProps( mdTypeSpec ts, PCCOR_SIGNATURE *ppvSig, ULONG *pcbSig) { return m_pWinMDAdapter->GetSignatureForToken( ts, NULL, // ppOrigSig NULL, // pcbOrigSig ppvSig, pcbSig, m_pRawImport); } __checkReturn virtual HRESULT CommonGetEnclosingClassOfTypeDef( mdTypeDef td, mdTypeDef *ptkEnclosingTypeDef) { return m_pRawMetaModelCommonRO->CommonGetEnclosingClassOfTypeDef(td, ptkEnclosingTypeDef); } __checkReturn virtual HRESULT CommonGetAssemblyProps( USHORT *pusMajorVersion, USHORT *pusMinorVersion, USHORT *pusBuildNumber, USHORT *pusRevisionNumber, DWORD *pdwFlags, const void **ppbPublicKey, ULONG *pcbPublicKey, LPCUTF8 *pszName, LPCUTF8 *pszLocale) { return m_pRawMetaModelCommonRO->CommonGetAssemblyProps(pusMajorVersion, pusMinorVersion, pusBuildNumber, pusRevisionNumber, pdwFlags, ppbPublicKey, pcbPublicKey, pszName, pszLocale); } __checkReturn virtual HRESULT CommonGetAssemblyRefProps( mdAssemblyRef tkAssemRef, USHORT *pusMajorVersion, USHORT *pusMinorVersion, USHORT *pusBuildNumber, USHORT *pusRevisionNumber, DWORD *pdwFlags, const void **ppbPublicKeyOrToken, ULONG *pcbPublicKeyOrToken, LPCUTF8 *pszName, LPCUTF8 *pszLocale, const void **ppbHashValue, ULONG *pcbHashValue) { HRESULT hr; mdAssemblyRef md = tkAssemRef; if (RidFromToken(md) > m_pWinMDAdapter->GetRawAssemblyRefCount()) { // The extra framework assemblies we add references to should all have the // same verion, key, culture, etc as those of mscorlib. // So we retrieve the mscorlib properties and change the name. md = m_pWinMDAdapter->GetAssemblyRefMscorlib(); } IfFailRet(m_pRawMetaModelCommonRO->CommonGetAssemblyRefProps( md, pusMajorVersion, pusMinorVersion, pusBuildNumber, pusRevisionNumber, pdwFlags, ppbPublicKeyOrToken, pcbPublicKeyOrToken, pszName, pszLocale, ppbHashValue, pcbHashValue)); m_pWinMDAdapter->ModifyAssemblyRefProps( tkAssemRef, ppbPublicKeyOrToken, pcbPublicKeyOrToken, pszName, pusMajorVersion, pusMinorVersion, pusBuildNumber, pusRevisionNumber, ppbHashValue, pcbHashValue); return hr; } __checkReturn virtual HRESULT CommonGetModuleRefProps( mdModuleRef tkModuleRef, LPCUTF8 *pszName) { return m_pRawMetaModelCommonRO->CommonGetModuleRefProps(tkModuleRef, pszName); } __checkReturn virtual HRESULT CommonFindExportedType( LPCUTF8 szNamespace, LPCUTF8 szName, mdToken tkEnclosingType, mdExportedType *ptkExportedType) { return m_pWinMDAdapter->FindExportedType(szNamespace, szName, tkEnclosingType, ptkExportedType); } __checkReturn virtual HRESULT CommonGetExportedTypeProps( mdToken tkExportedType, LPCUTF8 *pszNamespace, LPCUTF8 *pszName, mdToken *ptkImpl) { HRESULT hr; IfFailRet(m_pRawMetaModelCommonRO->CommonGetExportedTypeProps(tkExportedType, pszNamespace, pszName, ptkImpl)); IfFailRet(m_pWinMDAdapter->ModifyExportedTypeName(tkExportedType, pszNamespace, pszName)); return hr; } virtual int CommonIsRo() { return m_pRawMetaModelCommonRO->CommonIsRo(); } __checkReturn virtual HRESULT CommonGetCustomAttributeByNameEx( // S_OK or error. mdToken tkObj, // [IN] Object with Custom Attribute. LPCUTF8 szName, // [IN] Name of desired Custom Attribute. mdCustomAttribute *ptkCA, // [OUT] put custom attribute token here const void **ppData, // [OUT] Put pointer to data here. ULONG *pcbData) // [OUT] Put size of data here. { return m_pWinMDAdapter->GetCustomAttributeByName(tkObj, szName, ptkCA, ppData, pcbData); } __checkReturn virtual HRESULT FindParentOfMethodHelper(mdMethodDef md, mdTypeDef *ptd) { return m_pRawMetaModelCommonRO->FindParentOfMethodHelper(md, ptd); } public: //========================================================= // IGetIMDInternalImport methods //========================================================= STDMETHODIMP GetIMDInternalImport(IMDInternalImport ** ppIMDInternalImport) { HRESULT hr = S_OK; ReleaseHolder pMDCommon; ReleaseHolder pRawMDInternalImport; *ppIMDInternalImport = NULL; // Get the raw IMDInternalImport IfFailGo(GetMDInternalInterfaceFromPublic(m_pRawImport, IID_IMDInternalImport, (LPVOID*)(&pRawMDInternalImport))); // Create an adapter around the internal raw interface IfFailGo(pRawMDInternalImport->QueryInterface(IID_IMDCommon, (LPVOID*)(&pMDCommon))); IfFailGo(CreateWinMDInternalImportRO(pMDCommon, IID_IMDInternalImport, (void**)ppIMDInternalImport)); ErrExit: return hr; } //========================================================= // Private methods //========================================================= //------------------------------------------------------------------------------------------------------ // Deliver a result string (Unicode) to a caller's sized output buffer using the standard convention // followed by all metadata api. //------------------------------------------------------------------------------------------------------ static HRESULT DeliverUnicodeString(LPCWSTR wszResult, __out_ecount_part(cchCallerBuffer, *pchSizeNeeded) LPWSTR wszCallerBuffer, ULONG cchCallerBuffer, ULONG *pchSizeNeeded) { ULONG cchActual = (ULONG)(wcslen(wszResult) + 1); if (pchSizeNeeded) { *pchSizeNeeded = cchActual; } if (wszCallerBuffer == NULL || cchCallerBuffer < cchActual) { if (wszCallerBuffer != NULL) { memcpy(wszCallerBuffer, wszResult, cchCallerBuffer * sizeof(WCHAR)); // If buffer too small, return truncated result to be compatible with metadata api conventions if (cchCallerBuffer > 0) { // null-terminate the truncated output string wszCallerBuffer[cchCallerBuffer - 1] = W('\0'); } } return CLDB_S_TRUNCATION; } else { memcpy(wszCallerBuffer, wszResult, cchActual * sizeof(WCHAR)); return S_OK; } } //------------------------------------------------------------------------------------------------------ // Deliver a result string (Utf8) to a caller's sized output buffer using the standard convention // followed by all metadata api. //------------------------------------------------------------------------------------------------------ static HRESULT DeliverUtf8String(LPCSTR szUtf8Result, __out_ecount_part(cchCallerBuffer, *pchSizeNeeded) LPWSTR wszCallerBuffer, ULONG cchCallerBuffer, ULONG *pchSizeNeeded) { MAKE_WIDEPTR_FROMUTF8_NOTHROW(wzResult, szUtf8Result); if (wzResult == NULL) return E_OUTOFMEMORY; return DeliverUnicodeString(wzResult, wszCallerBuffer, cchCallerBuffer, pchSizeNeeded); } //------------------------------------------------------------------------------------------------------ // Combine a result namespace/name string pair (Utf8) to a Unicode fullname and deliver to a caller's // sized output buffer using the standard convention followed by all metadata api. //------------------------------------------------------------------------------------------------------ static HRESULT DeliverUtf8NamespaceAndName(LPCSTR szUtf8Namespace, LPCSTR szUtf8Name, __out_ecount_part(cchCallerBuffer, *pchSizeNeeded) LPWSTR wszCallerBuffer, ULONG cchCallerBuffer, ULONG *pchSizeNeeded) { HRESULT hr; if (wszCallerBuffer != NULL || pchSizeNeeded != NULL) { MAKE_WIDEPTR_FROMUTF8_NOTHROW(wzNamespace, szUtf8Namespace); IfNullRet(wzNamespace); MAKE_WIDEPTR_FROMUTF8_NOTHROW(wzName, szUtf8Name); IfNullRet(wzName); BOOL fTruncation = FALSE; if (wszCallerBuffer != NULL) { fTruncation = !(ns::MakePath(wszCallerBuffer, cchCallerBuffer, wzNamespace, wzName)); if (fTruncation && (cchCallerBuffer > 0)) { // null-terminate the truncated output string wszCallerBuffer[cchCallerBuffer - 1] = W('\0'); } } if (pchSizeNeeded != NULL) { if (fTruncation || (wszCallerBuffer == NULL)) { *pchSizeNeeded = ns::GetFullLength(wzNamespace, wzName); } else { *pchSizeNeeded = (ULONG)(wcslen(wszCallerBuffer) + 1); } } hr = fTruncation ? CLDB_S_TRUNCATION : S_OK; } else { hr = S_OK; // Caller did not request name back. } return hr; } private: //========================================================= // Private instance data //========================================================= IMDCommon *m_pRawMDCommon; IMetaDataImport2 *m_pRawImport; IMetaDataAssemblyImport *m_pRawAssemblyImport; IMetaDataValidate *m_pRawValidate; IMetaModelCommonRO *m_pRawMetaModelCommonRO; IUnknown *m_pFreeThreadedMarshaler; WinMDAdapter *m_pWinMDAdapter; LONG m_cRef; }; // class WinMDImport //======================================================================================== // Entrypoint called by IMetaDataDispenser::OpenScope() //======================================================================================== HRESULT CreateWinMDImport(IMDCommon * pRawMDCommon, REFIID riid, /*[out]*/ void **ppWinMDImport) { HRESULT hr; *ppWinMDImport = NULL; WinMDImport *pWinMDImport = NULL; IfFailGo(WinMDImport::Create(pRawMDCommon, &pWinMDImport)); IfFailGo(pWinMDImport->QueryInterface(riid, ppWinMDImport)); hr = S_OK; ErrExit: if (pWinMDImport) pWinMDImport->Release(); return hr; }