Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

214 lines (193 sloc) 6.163 kB
/*
Copyright (C) 2008-2012 Jeroen Frijters
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
Jeroen Frijters
jeroen@frijters.net
*/
using System;
#if STATIC_COMPILER || STUB_GENERATOR
using IKVM.Reflection;
using IKVM.Reflection.Emit;
using Type = IKVM.Reflection.Type;
#else
using System.Reflection;
using System.Reflection.Emit;
#endif
namespace IKVM.Internal
{
static class ReflectUtil
{
#if !NET_4_0 && !STATIC_COMPILER && !STUB_GENERATOR
private static readonly bool clr_v4 = Environment.Version.Major >= 4;
private static Predicate<Assembly> get_IsDynamic;
#endif
internal static bool IsSameAssembly(Type type1, Type type2)
{
return type1.Assembly.Equals(type2.Assembly);
}
internal static bool IsFromAssembly(Type type, Assembly assembly)
{
return type.Assembly.Equals(assembly);
}
internal static Assembly GetAssembly(Type type)
{
return type.Assembly;
}
internal static bool IsDynamicAssembly(Assembly asm)
{
#if STATIC_COMPILER || STUB_GENERATOR
return false;
#elif NET_4_0
return asm.IsDynamic;
#else
if (clr_v4)
{
// on .NET 4.0 dynamic assemblies have a non-AssemblyBuilder derived peer, so we have to call IsDynamic
if (get_IsDynamic == null)
{
get_IsDynamic = (Predicate<Assembly>)Delegate.CreateDelegate(typeof(Predicate<Assembly>), typeof(Assembly).GetMethod("get_IsDynamic"));
}
return get_IsDynamic(asm);
}
return asm is AssemblyBuilder;
#endif
}
internal static bool IsReflectionOnly(Type type)
{
while (type.HasElementType)
{
type = type.GetElementType();
}
Assembly asm = type.Assembly;
if (asm != null && asm.ReflectionOnly)
{
return true;
}
if (!type.IsGenericType || type.IsGenericTypeDefinition)
{
return false;
}
// we have a generic type instantiation, it might have ReflectionOnly type arguments
foreach (Type arg in type.GetGenericArguments())
{
if (IsReflectionOnly(arg))
{
return true;
}
}
return false;
}
internal static bool ContainsTypeBuilder(Type type)
{
while (type.HasElementType)
{
type = type.GetElementType();
}
if (!type.IsGenericType || type.IsGenericTypeDefinition)
{
return type is TypeBuilder;
}
foreach (Type arg in type.GetGenericArguments())
{
if (ContainsTypeBuilder(arg))
{
return true;
}
}
return type.GetGenericTypeDefinition() is TypeBuilder;
}
internal static bool IsVector(Type type)
{
#if STATIC_COMPILER || STUB_GENERATOR
return type.__IsVector;
#else
// there's no API to distinguish an array of rank 1 from a vector,
// so we check if the type name ends in [], which indicates it's a vector
// (non-vectors will have [*] or [,]).
return type.IsArray && type.Name.EndsWith("[]");
#endif
}
internal static bool IsDynamicMethod(MethodInfo method)
{
// there's no way to distinguish a baked DynamicMethod from a RuntimeMethodInfo and
// on top of that Mono behaves completely different from .NET
try
{
// on Mono 2.10 the MetadataToken property returns zero instead of throwing InvalidOperationException
return method.MetadataToken == 0;
}
catch (InvalidOperationException)
{
return true;
}
}
internal static MethodBuilder DefineTypeInitializer(TypeBuilder typeBuilder)
{
MethodAttributes attr = MethodAttributes.Static | MethodAttributes.RTSpecialName | MethodAttributes.SpecialName;
if (typeBuilder.IsInterface)
{
// LAMESPEC the ECMA spec says (part. I, sect. 8.5.3.2) that all interface members must be public, so we make
// the class constructor public.
// NOTE it turns out that on .NET 2.0 this isn't necessary anymore (neither Ref.Emit nor the CLR verifier complain about it),
// but the C# compiler still considers interfaces with non-public methods to be invalid, so to keep interop with C# we have
// to keep making the .cctor method public.
attr |= MethodAttributes.Public;
}
else
{
attr |= MethodAttributes.Private;
}
return typeBuilder.DefineMethod(ConstructorInfo.TypeConstructorName, attr, null, Type.EmptyTypes);
}
internal static bool MatchNameAndPublicKeyToken(AssemblyName name1, AssemblyName name2)
{
return name1.Name.Equals(name2.Name, StringComparison.InvariantCultureIgnoreCase)
&& CompareKeys(name1.GetPublicKeyToken(), name2.GetPublicKeyToken());
}
private static bool CompareKeys(byte[] b1, byte[] b2)
{
int len1 = b1 == null ? 0 : b1.Length;
int len2 = b2 == null ? 0 : b2.Length;
if (len1 != len2)
{
return false;
}
for (int i = 0; i < len1; i++)
{
if (b1[i] != b2[i])
{
return false;
}
}
return true;
}
internal static bool IsConstructor(MethodBase method)
{
return method.IsSpecialName && method.Name == ConstructorInfo.ConstructorName;
}
internal static MethodBuilder DefineConstructor(TypeBuilder tb, MethodAttributes attribs, Type[] parameterTypes)
{
return tb.DefineMethod(ConstructorInfo.ConstructorName, attribs | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, null, parameterTypes);
}
internal static bool CanOwnDynamicMethod(Type type)
{
return type != null
&& !type.IsInterface
&& !type.HasElementType
&& !type.IsGenericTypeDefinition
&& !type.IsGenericParameter;
}
}
}
Jump to Line
Something went wrong with that request. Please try again.