// note that context is slightly different from the calling assembly (System.Type.GetType),
// because context is passed to the AssemblyResolve event as the RequestingAssembly
public Type GetType(Assembly context, string assemblyQualifiedTypeName, bool throwOnError, bool ignoreCase)
{
TypeNameParser parser = TypeNameParser.Parse(assemblyQualifiedTypeName, throwOnError);
if (parser.Error)
{
return(null);
}
return(parser.GetType(this, context, throwOnError, assemblyQualifiedTypeName, false, ignoreCase));
}
// this is similar to GetType(Assembly context, string assemblyQualifiedTypeName, bool throwOnError),
// but instead it assumes that the type must exist (i.e. if EnableMissingMemberResolution is enabled
// it will create a missing type)
public Type ResolveType(Assembly context, string assemblyQualifiedTypeName)
{
TypeNameParser parser = TypeNameParser.Parse(assemblyQualifiedTypeName, false);
if (parser.Error)
{
return(null);
}
return(parser.GetType(this, context, false, assemblyQualifiedTypeName, true, false));
}
internal Type GetTypeImpl(string typeName)
{
Type type = FindType(TypeName.Split(TypeNameParser.Unescape(typeName)));
if (type == null && __IsMissing)
{
throw new MissingAssemblyException((MissingAssembly)this);
}
return(type);
}
internal Type GetMissingTypeOrThrow(Module module, Type declaringType, TypeName typeName)
{
if (resolveMissingMembers || module.Assembly.__IsMissing)
{
return(GetMissingType(module, declaringType, typeName));
}
string fullName = TypeNameParser.Escape(typeName.ToString());
if (declaringType != null)
{
fullName = declaringType.FullName + "+" + fullName;
}
throw new TypeLoadException(String.Format("Type '{0}' not found in assembly '{1}'", fullName, module.Assembly.FullName));
}
private static Type ReadType(Assembly asm, ByteReader br)
{
string typeName = br.ReadString();
if (typeName == null)
{
return(null);
}
if (typeName.Length > 0 && typeName[typeName.Length - 1] == 0)
{
// there are broken compilers that emit an extra NUL character after the type name
typeName = typeName.Substring(0, typeName.Length - 1);
}
return(TypeNameParser.Parse(typeName, true).GetType(asm.universe, asm, true, typeName, true, false));
}
public Type GetType(string typeName, bool throwOnError)
{
TypeNameParser parser = TypeNameParser.Parse(typeName, throwOnError);
if (parser.Error)
{
return(null);
}
if (parser.AssemblyName != null)
{
if (throwOnError)
{
throw new ArgumentException("Type names passed to Assembly.GetType() must not specify an assembly.");
}
else
{
return(null);
}
}
return(parser.Expand(GetTypeImpl(parser.FirstNamePart), this, throwOnError, typeName));
}
internal Type Expand(Type type, Module context, bool throwOnError, string originalName, bool resolve, bool ignoreCase)
{
Debug.Assert(!resolve || !ignoreCase);
if (type == null)
{
if (throwOnError)
{
throw new TypeLoadException(originalName);
}
return(null);
}
if (nested != null)
{
Type outer;
foreach (string nest in nested)
{
outer = type;
TypeName name = TypeName.Split(TypeNameParser.Unescape(nest));
type = ignoreCase
? outer.FindNestedTypeIgnoreCase(name.ToLowerInvariant())
: outer.FindNestedType(name);
if (type == null)
{
if (resolve)
{
type = outer.Module.universe.GetMissingTypeOrThrow(context, outer.Module, outer, name);
}
else if (throwOnError)
{
throw new TypeLoadException(originalName);
}
else
{
return(null);
}
}
}
}
if (genericParameters != null)
{
Type[] typeArgs = new Type[genericParameters.Length];
for (int i = 0; i < typeArgs.Length; i++)
{
typeArgs[i] = genericParameters[i].GetType(type.Assembly.universe, context, throwOnError, originalName, resolve, ignoreCase);
if (typeArgs[i] == null)
{
return(null);
}
}
type = type.MakeGenericType(typeArgs);
}
if (modifiers != null)
{
foreach (short modifier in modifiers)
{
switch (modifier)
{
case SZARRAY:
type = type.MakeArrayType();
break;
case BYREF:
type = type.MakeByRefType();
break;
case POINTER:
type = type.MakePointerType();
break;
default:
type = type.MakeArrayType(modifier);
break;
}
}
}
return(type);
}
internal static bool ReadFieldMarshal(Module module, int token, out FieldMarshal fm)
{
fm = new FieldMarshal();
foreach (int i in module.FieldMarshal.Filter(token))
{
ByteReader blob = module.GetBlob(module.FieldMarshal.records[i].NativeType);
fm.UnmanagedType = (UnmanagedType)blob.ReadCompressedInt();
if (fm.UnmanagedType == UnmanagedType.LPArray)
{
fm.ArraySubType = (UnmanagedType)blob.ReadCompressedInt();
if (fm.ArraySubType == NATIVE_TYPE_MAX)
{
fm.ArraySubType = null;
}
if (blob.Length != 0)
{
fm.SizeParamIndex = (short)blob.ReadCompressedInt();
if (blob.Length != 0)
{
fm.SizeConst = blob.ReadCompressedInt();
if (blob.Length != 0 && blob.ReadCompressedInt() == 0)
{
fm.SizeParamIndex = null;
}
}
}
}
else if (fm.UnmanagedType == UnmanagedType.SafeArray)
{
if (blob.Length != 0)
{
fm.SafeArraySubType = (VarEnum)blob.ReadCompressedInt();
if (blob.Length != 0)
{
fm.SafeArrayUserDefinedSubType = ReadType(module, blob);
}
}
}
else if (fm.UnmanagedType == UnmanagedType.ByValArray)
{
fm.SizeConst = blob.ReadCompressedInt();
if (blob.Length != 0)
{
fm.ArraySubType = (UnmanagedType)blob.ReadCompressedInt();
}
}
else if (fm.UnmanagedType == UnmanagedType.ByValTStr)
{
fm.SizeConst = blob.ReadCompressedInt();
}
else if (fm.UnmanagedType == UnmanagedType.Interface ||
fm.UnmanagedType == UnmanagedType.IDispatch ||
fm.UnmanagedType == UnmanagedType.IUnknown)
{
if (blob.Length != 0)
{
fm.IidParameterIndex = blob.ReadCompressedInt();
}
}
else if (fm.UnmanagedType == UnmanagedType.CustomMarshaler)
{
blob.ReadCompressedInt();
blob.ReadCompressedInt();
fm.MarshalType = ReadString(blob);
fm.MarshalCookie = ReadString(blob);
TypeNameParser parser = TypeNameParser.Parse(fm.MarshalType, false);
if (!parser.Error)
{
fm.MarshalTypeRef = parser.GetType(module.universe, module.Assembly, false, fm.MarshalType, false, false);
}
}
return(true);
}
return(false);
}
internal static CustomAttributeData GetMarshalAsAttribute(Module module, int token)
{
// TODO use binary search?
for (int i = 0; i < module.FieldMarshal.records.Length; i++)
{
if (module.FieldMarshal.records[i].Parent == token)
{
ByteReader blob = module.GetBlob(module.FieldMarshal.records[i].NativeType);
UnmanagedType unmanagedType = (UnmanagedType)blob.ReadCompressedInt();
UnmanagedType?arraySubType = null;
short? sizeParamIndex = null;
int? sizeConst = null;
VarEnum? safeArraySubType = null;
Type safeArrayUserDefinedSubType = null;
int? iidParameterIndex = null;
string marshalType = null;
string marshalCookie = null;
Type marshalTypeRef = null;
if (unmanagedType == UnmanagedType.LPArray)
{
arraySubType = (UnmanagedType)blob.ReadCompressedInt();
if (arraySubType == NATIVE_TYPE_MAX)
{
arraySubType = null;
}
if (blob.Length != 0)
{
sizeParamIndex = (short)blob.ReadCompressedInt();
if (blob.Length != 0)
{
sizeConst = blob.ReadCompressedInt();
if (blob.Length != 0 && blob.ReadCompressedInt() == 0)
{
sizeParamIndex = null;
}
}
}
}
else if (unmanagedType == UnmanagedType.SafeArray)
{
if (blob.Length != 0)
{
safeArraySubType = (VarEnum)blob.ReadCompressedInt();
if (blob.Length != 0)
{
safeArrayUserDefinedSubType = ReadType(module, blob);
}
}
}
else if (unmanagedType == UnmanagedType.ByValArray)
{
sizeConst = blob.ReadCompressedInt();
if (blob.Length != 0)
{
arraySubType = (UnmanagedType)blob.ReadCompressedInt();
}
}
else if (unmanagedType == UnmanagedType.ByValTStr)
{
sizeConst = blob.ReadCompressedInt();
}
else if (unmanagedType == UnmanagedType.Interface ||
unmanagedType == UnmanagedType.IDispatch ||
unmanagedType == UnmanagedType.IUnknown)
{
if (blob.Length != 0)
{
iidParameterIndex = blob.ReadCompressedInt();
}
}
else if (unmanagedType == UnmanagedType.CustomMarshaler)
{
blob.ReadCompressedInt();
blob.ReadCompressedInt();
marshalType = ReadString(blob);
marshalCookie = ReadString(blob);
TypeNameParser parser = TypeNameParser.Parse(marshalType, false);
if (!parser.Error)
{
marshalTypeRef = parser.GetType(module.universe, module.Assembly, false, marshalType, false);
}
}
Type typeofMarshalAs = module.universe.System_Runtime_InteropServices_MarshalAsAttribute;
Type typeofUnmanagedType = module.universe.System_Runtime_InteropServices_UnmanagedType;
Type typeofVarEnum = module.universe.System_Runtime_InteropServices_VarEnum;
Type typeofType = module.universe.System_Type;
List <CustomAttributeNamedArgument> named = new List <CustomAttributeNamedArgument>();
if (arraySubType != null)
{
AddNamedArgument(named, typeofMarshalAs, "ArraySubType", typeofUnmanagedType, arraySubType.Value);
}
if (sizeParamIndex != null)
{
AddNamedArgument(named, typeofMarshalAs, "SizeParamIndex", module.universe.System_Int16, sizeParamIndex.Value);
}
if (sizeConst != null)
{
AddNamedArgument(named, typeofMarshalAs, "SizeConst", module.universe.System_Int32, sizeConst.Value);
}
if (safeArraySubType != null)
{
AddNamedArgument(named, typeofMarshalAs, "SafeArraySubType", typeofVarEnum, safeArraySubType.Value);
}
if (safeArrayUserDefinedSubType != null)
{
AddNamedArgument(named, typeofMarshalAs, "SafeArrayUserDefinedSubType", typeofType, safeArrayUserDefinedSubType);
}
if (iidParameterIndex != null)
{
AddNamedArgument(named, typeofMarshalAs, "IidParameterIndex", module.universe.System_Int32, iidParameterIndex.Value);
}
if (marshalType != null)
{
AddNamedArgument(named, typeofMarshalAs, "MarshalType", module.universe.System_String, marshalType);
}
if (marshalTypeRef != null)
{
AddNamedArgument(named, typeofMarshalAs, "MarshalTypeRef", module.universe.System_Type, marshalTypeRef);
}
if (marshalCookie != null)
{
AddNamedArgument(named, typeofMarshalAs, "MarshalCookie", module.universe.System_String, marshalCookie);
}
ConstructorInfo constructor = typeofMarshalAs.GetPseudoCustomAttributeConstructor(typeofUnmanagedType);
return(new CustomAttributeData(module, constructor, new object[] { unmanagedType }, named));
}
}
throw new BadImageFormatException();
}
internal Type Expand(Type type, Assembly context, bool throwOnError, string originalName)
{
if (type == null)
{
if (throwOnError)
{
throw new TypeLoadException(originalName);
}
return(null);
}
if (nested != null)
{
foreach (string nest in nested)
{
type = type.FindNestedType(TypeName.Split(TypeNameParser.Unescape(nest)));
if (type == null)
{
if (throwOnError)
{
throw new TypeLoadException(originalName);
}
return(null);
}
}
}
if (genericParameters != null)
{
Type[] typeArgs = new Type[genericParameters.Length];
for (int i = 0; i < typeArgs.Length; i++)
{
typeArgs[i] = genericParameters[i].GetType(type.Assembly.universe, context, throwOnError, originalName);
if (typeArgs[i] == null)
{
return(null);
}
}
type = type.MakeGenericType(typeArgs);
}
if (modifiers != null)
{
foreach (short modifier in modifiers)
{
switch (modifier)
{
case SZARRAY:
type = type.MakeArrayType();
break;
case BYREF:
type = type.MakeByRefType();
break;
case POINTER:
type = type.MakePointerType();
break;
default:
type = type.MakeArrayType(modifier);
break;
}
}
}
return(type);
}
