/*?*/
internal override IModuleTypeReference GetAsTypeReference(
PEFileToObjectModel peFileToObjectModel,
IModuleModuleReference module
)
{
foreach (AssemblyReference aref in peFileToObjectModel.GetAssemblyReferences()) {
if (aref.AssemblyIdentity.Equals(this.AssemblyIdentity))
return this.TypeName.GetAsTypeReference(peFileToObjectModel, aref);
}
if (module.ContainingAssembly.AssemblyIdentity.Equals(this.AssemblyIdentity))
return this.TypeName.GetAsTypeReference(peFileToObjectModel, module);
AssemblyFlags flags = this.Retargetable ? AssemblyFlags.Retargetable : (AssemblyFlags)0;
return this.TypeName.GetAsTypeReference(peFileToObjectModel, new AssemblyReference(peFileToObjectModel, 0, this.AssemblyIdentity, flags));
}
/*?*/
internal abstract IModuleTypeReference GetAsTypeReference(
PEFileToObjectModel peFileToObjectModel,
IModuleModuleReference module
);
/*?*/
internal override IModuleTypeReference GetAsTypeReference(
PEFileToObjectModel peFileToObjectModel,
IModuleModuleReference module
)
{
IModuleTypeReference/*?*/ elementType = this.ElementType.GetAsTypeReference(peFileToObjectModel, module);
if (elementType == null)
return null;
if (this.Rank == 0) {
return new VectorType(
peFileToObjectModel,
0xFFFFFFFF,
elementType
);
} else {
return new MatrixType(
peFileToObjectModel,
0xFFFFFFFF,
elementType,
this.Rank,
TypeCache.EmptyUlongArray,
TypeCache.EmptyIntArray
);
}
}
internal override IModuleTypeReference GetAsTypeReference(
PEFileToObjectModel peFileToObjectModel, IModuleModuleReference module
)
{
return this.GetAsNomimalType(peFileToObjectModel, module);
}
/*?*/
internal override IModuleTypeReference GetAsTypeReference(
PEFileToObjectModel peFileToObjectModel,
IModuleModuleReference module
)
{
IModuleTypeReference/*?*/ targetType = this.TargetType.GetAsTypeReference(peFileToObjectModel, module);
if (targetType == null)
return null;
return new PointerType(
peFileToObjectModel,
0xFFFFFFFF,
targetType
);
}
/*?*/
internal abstract IModuleNominalType GetAsNomimalType(
PEFileToObjectModel peFileToObjectModel,
IModuleModuleReference module
);
/*?*/
internal override IModuleNominalType GetAsNomimalType(
PEFileToObjectModel peFileToObjectModel,
IModuleModuleReference module
)
{
return new NestedTypeNameTypeReference(module, this, peFileToObjectModel);
}
/*?*/
internal override IModuleTypeReference GetAsTypeReference(
PEFileToObjectModel peFileToObjectModel,
IModuleModuleReference module
)
{
IModuleNominalType/*?*/ nominalType = this.GenericTemplate.GetAsNomimalType(peFileToObjectModel, module);
if (nominalType == null)
return null;
int len = this.GenericArguments.Count;
IModuleTypeReference/*?*/[] moduleTypeReferenceList = new IModuleTypeReference/*?*/[len];
for (int i = 0; i < len; ++i) {
moduleTypeReferenceList[i] = this.GenericArguments[i].GetAsTypeReference(peFileToObjectModel, peFileToObjectModel.Module);
}
return peFileToObjectModel.typeCache.GetGenericTypeInstanceReference(
0xFFFFFFFF,
nominalType,
moduleTypeReferenceList
);
}
internal NamespaceReference GetNamespaceReferenceForString(
IModuleModuleReference moduleReference,
IName iNamespaceFullName
) {
NamespaceReference/*?*/ retNamespaceReference = this.NamespaceReferenceINameHashtable.Find(moduleReference.InternedModuleId, (uint)iNamespaceFullName.UniqueKey);
if (retNamespaceReference != null)
return retNamespaceReference;
string namespaceFullName = iNamespaceFullName.Value;
if (namespaceFullName.Length == 0) {
retNamespaceReference = new RootNamespaceReference(this, moduleReference);
} else {
int lastDot = namespaceFullName.LastIndexOf('.');
string namespaceName = namespaceFullName;
string namespacePrefix = "";
if (lastDot != -1) {
namespacePrefix = namespaceFullName.Substring(0, lastDot);
namespaceName = namespaceFullName.Substring(lastDot + 1, namespaceFullName.Length - lastDot - 1);
}
IName iNamespacePrefix = this.NameTable.GetNameFor(namespacePrefix);
NamespaceReference parentNamespaceReference = this.GetNamespaceReferenceForString(moduleReference, iNamespacePrefix);
IName iNamespaceName = this.NameTable.GetNameFor(namespaceName);
retNamespaceReference = new NestedNamespaceReference(this, iNamespaceName, iNamespaceFullName, parentNamespaceReference);
}
this.NamespaceReferenceINameHashtable.Add(moduleReference.InternedModuleId, (uint)iNamespaceFullName.UniqueKey, retNamespaceReference);
return retNamespaceReference;
}
//^ invariant this.PEFileReader.TypeSpecTable.NumberOfRows >= 1 ==> this.ModuleTypeSpecHashtable != null;
TypeRefReference CreateTypeRefReference(
uint typeRefRowId,
TypeRefRow typeRefRow,
TypeRefReference/*?*/ parentModuleTypeReference,
IModuleModuleReference moduleReference,
ModuleSignatureTypeCode signatureTypeCode
) {
IName mangledTypeName = this.GetNameFromOffset(typeRefRow.Name);
ushort genericParamCount;
string typeName;
TypeCache.SplitMangledTypeName(mangledTypeName.Value, out typeName, out genericParamCount);
TypeRefReference moduleTypeRefReference;
if (parentModuleTypeReference == null) {
IName namespaceFullName = this.GetNameFromOffset(typeRefRow.Namespace);
NamespaceReference namespaceReference = this.GetNamespaceReferenceForString(moduleReference, namespaceFullName);
if (genericParamCount == 0) {
if (signatureTypeCode == ModuleSignatureTypeCode.NotModulePrimitive) {
moduleTypeRefReference = new NamespaceTypeRefReferenceWithoutPrimitiveTypeCode(
this,
mangledTypeName,
typeRefRowId,
moduleReference,
namespaceReference,
signatureTypeCode == ModuleSignatureTypeCode.ValueType
);
} else {
moduleTypeRefReference = new NamespaceTypeRefReferenceWithPrimitiveTypeCode(
this,
mangledTypeName,
typeRefRowId,
moduleReference,
namespaceReference,
signatureTypeCode
);
}
} else {
IName iTypeName = this.NameTable.GetNameFor(typeName);
moduleTypeRefReference = new GenericNamespaceTypeRefReference(
this,
iTypeName,
typeRefRowId,
moduleReference,
namespaceReference,
mangledTypeName,
genericParamCount,
signatureTypeCode == ModuleSignatureTypeCode.ValueType
);
}
} else {
if (genericParamCount == 0) {
moduleTypeRefReference = new NonGenericNestedTypeRefReference(
this,
mangledTypeName,
typeRefRowId,
moduleReference,
parentModuleTypeReference,
signatureTypeCode == ModuleSignatureTypeCode.ValueType
);
} else {
IName iTypeName = this.NameTable.GetNameFor(typeName);
moduleTypeRefReference = new GenericNestedTypeRefReference(
this,
iTypeName,
typeRefRowId,
moduleReference,
parentModuleTypeReference,
mangledTypeName,
genericParamCount,
signatureTypeCode == ModuleSignatureTypeCode.ValueType
);
}
}
return moduleTypeRefReference;
}
