public Type GetType(string className, bool throwOnError, bool ignoreCase)
{
TypeNameParser parser = TypeNameParser.Parse(className, throwOnError);
if (parser.Error)
{
return(null);
}
if (parser.AssemblyName != null)
{
if (throwOnError)
{
throw new ArgumentException("Type names passed to Module.GetType() must not specify an assembly.");
}
else
{
return(null);
}
}
TypeName typeName = TypeName.Split(TypeNameParser.Unescape(parser.FirstNamePart));
Type type = ignoreCase
? FindTypeIgnoreCase(typeName.ToLowerInvariant())
: FindType(typeName);
if (type == null && __IsMissing)
{
throw new MissingModuleException((MissingModule)this);
}
return(parser.Expand(type, this, throwOnError, className, false, ignoreCase));
}
public Type GetType(string className, bool throwOnError, bool ignoreCase)
{
if (ignoreCase)
{
throw new NotImplementedException();
}
TypeNameParser parser = TypeNameParser.Parse(className, throwOnError);
if (parser.Error)
{
return(null);
}
if (parser.AssemblyName != null)
{
if (throwOnError)
{
throw new ArgumentException("Type names passed to Module.GetType() must not specify an assembly.");
}
else
{
return(null);
}
}
Type type = FindType(TypeName.Split(TypeNameParser.Unescape(parser.FirstNamePart)));
if (type == null && __IsMissing)
{
throw new MissingModuleException((MissingModule)this);
}
return(parser.Expand(type, this.Assembly, throwOnError, className));
}
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 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 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);
}