//
// (C) Ximian, Inc. http://www.ximian.com
//
-// TODO: Mucho left to implement.
+
+//
+// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
+using System.Diagnostics;
using System.Reflection;
+using System.Reflection.Emit;
using System.Collections;
+using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using System.Globalization;
namespace System {
- //
- // FIXME: Implement the various IReflect dependencies
- //
-
- [MonoTODO]
[Serializable]
- public abstract class Type : MemberInfo, IReflect {
+ [ClassInterface (ClassInterfaceType.None)]
+#if NET_2_0
+ [ComVisible (true)]
+ [ComDefaultInterface (typeof (_Type))]
+#endif
+ public abstract class Type : MemberInfo, IReflect, _Type, _MemberInfo {
internal RuntimeTypeHandle _impl;
public static readonly MemberFilter FilterNameIgnoreCase = new MemberFilter (FilterNameIgnoreCase_impl);
public static readonly object Missing;
- private const BindingFlags DefaultBindingFlags =
+ internal const BindingFlags DefaultBindingFlags =
BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance;
/* implementation of the delegates for MemberFilter */
static bool FilterName_impl (MemberInfo m, object filterCriteria)
{
string name = (string) filterCriteria;
- return name.Equals (m.Name);
+ if (name == null || name.Length == 0 )
+ return false; // because m.Name cannot be null or empty
+
+ if (name [name.Length-1] == '*')
+ return string.Compare (name, 0, m.Name, 0, name.Length-1, false, CultureInfo.InvariantCulture) == 0;
+
+ return name.Equals (m.Name);
}
-
+
static bool FilterNameIgnoreCase_impl (MemberInfo m, object filterCriteria)
{
string name = (string) filterCriteria;
- return String.Compare (name, m.Name, true) == 0;
+ if (name == null || name.Length == 0 )
+ return false; // because m.Name cannot be null or empty
+
+ if (name [name.Length-1] == '*')
+ return string.Compare (name, 0, m.Name, 0, name.Length-1, true, CultureInfo.InvariantCulture) == 0;
+
+ return String.Compare (name, m.Name, true, CultureInfo.InvariantCulture) == 0;
}
-
- [MonoTODO]
+
static bool FilterAttribute_impl (MemberInfo m, object filterCriteria)
{
- throw new NotImplementedException ("FilterAttribute_impl");
+ int flags = ((IConvertible)filterCriteria).ToInt32 (null);
+ if (m is MethodInfo)
+ return ((int)((MethodInfo)m).Attributes & flags) != 0;
+ if (m is FieldInfo)
+ return ((int)((FieldInfo)m).Attributes & flags) != 0;
+ if (m is PropertyInfo)
+ return ((int)((PropertyInfo)m).Attributes & flags) != 0;
+ if (m is EventInfo)
+ return ((int)((EventInfo)m).Attributes & flags) != 0;
+ return false;
}
protected Type ()
return GetAttributeFlagsImpl ();
}
}
-
+
/// <summary>
/// Returns the basetype for this type
/// </summary>
public abstract Type BaseType {
get;
}
-
+
/// <summary>
/// Returns the class that declares the member.
/// </summary>
return Binder.DefaultBinder;
}
}
-
+
/// <summary>
/// The full name of the type including its namespace
/// </summary>
return true;
if (IsInterface)
return false;
- return !type_is_subtype_of (this, typeof (System.ValueType), false);
+ return !is_subtype_of (this, typeof (System.ValueType), false);
}
}
public bool IsEnum {
get {
- return type_is_subtype_of (this, typeof (System.Enum), false) &&
+ // This hack is needed because EnumBuilder's UnderlyingSystemType returns the enum's basetype
+ if (this is EnumBuilder)
+ return true;
+
+ return is_subtype_of (this, typeof (System.Enum), false) &&
this != typeof (System.Enum);
}
}
public bool IsNotPublic {
get {
- return !IsPublic;
+ return (Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NotPublic;
}
}
get {
// Enums and delegates are always serializable
return (Attributes & TypeAttributes.Serializable) != 0 || IsEnum ||
- type_is_subtype_of (this, typeof (System.Delegate), false);
+ is_subtype_of (this, typeof (System.Delegate), false);
}
}
get {return MemberTypes.TypeInfo;}
}
+#if NET_2_0 || BOOTSTRAP_NET_2_0
+ override
+#endif
public abstract Module Module {get;}
public abstract string Namespace {get;}
public abstract RuntimeTypeHandle TypeHandle {get;}
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public ConstructorInfo TypeInitializer {
get {
return GetConstructorImpl (
return false;
return Equals (cmp);
}
-
+
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public extern bool Equals (Type type);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public extern static TypeCode GetTypeCode (Type type);
+ internal extern static TypeCode GetTypeCodeInternal (Type type);
+
+ public static TypeCode GetTypeCode (Type type) {
+ type = type.UnderlyingSystemType;
+
+ if (!type.IsSystemType)
+ return Type.GetTypeCode (typeof (object));
+ else
+ return GetTypeCodeInternal (type);
+ }
[MonoTODO]
public static Type GetTypeFromCLSID (Guid clsid)
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern bool type_is_assignable_from (Type a, Type b);
-
+
+ internal static bool is_subtype_of (Type a, Type b, bool check_interfaces)
+ {
+ a = a.UnderlyingSystemType;
+ b = b.UnderlyingSystemType;
+
+ if (!a.IsSystemType || !b.IsSystemType)
+ return false;
+ else
+ return type_is_subtype_of (a, b, check_interfaces);
+ }
+
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public virtual bool IsSubclassOf (Type c)
{
if (c == null)
return false;
- return (this != c) && type_is_subtype_of (this, c, false);
+ return (this != c) && is_subtype_of (this, c, false);
}
public virtual Type[] FindInterfaces (TypeFilter filter, object filterCriteria)
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern void GetInterfaceMapData (Type t, Type iface, out MethodInfo[] targets, out MethodInfo[] methods);
-
+
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public virtual InterfaceMapping GetInterfaceMap (Type interfaceType) {
InterfaceMapping res;
if (interfaceType == null)
throw new ArgumentNullException ("interfaceType");
if (!interfaceType.IsInterface)
- throw new ArgumentException ("type argument must be an interface", "interfaceType");
+ throw new ArgumentException (Locale.GetText ("Argument must be an interface."), "interfaceType");
res.TargetType = this;
res.InterfaceType = interfaceType;
GetInterfaceMapData (this, interfaceType, out res.TargetMethods, out res.InterfaceMethods);
if (res.TargetMethods == null)
- throw new ArgumentException ("interface not found", "interfaceType");
+ throw new ArgumentException (Locale.GetText ("Interface not found"), "interfaceType");
return res;
}
if (Equals (c))
return true;
- return type_is_assignable_from (this, c);
- }
+ if (c is TypeBuilder)
+ return ((TypeBuilder)c).IsAssignableTo (this);
- public virtual bool IsInstanceOfType (object o) {
- if (o != null)
- return IsAssignableFrom (o.GetType ());
+ /* Handle user defined type classes */
+ if (!IsSystemType) {
+ Type systemType = UnderlyingSystemType;
+ if (!systemType.IsSystemType)
+ return false;
+ return systemType.IsAssignableFrom (c);
+ }
- return false;
+ if (!c.IsSystemType) {
+ Type underlyingType = c.UnderlyingSystemType;
+ if (!underlyingType.IsSystemType)
+ return false;
+ return IsAssignableFrom (underlyingType);
+ }
+
+ return type_is_assignable_from (this, c);
}
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ public extern virtual bool IsInstanceOfType (object o);
+
public virtual int GetArrayRank ()
{
throw new NotSupportedException (); // according to MSDN
return (int)_impl.Value;
}
- public MemberInfo[] GetMember( string name)
+ public MemberInfo[] GetMember (string name)
{
return GetMember (name, DefaultBindingFlags);
}
- public virtual MemberInfo[] GetMember( string name, BindingFlags bindingAttr)
+ public virtual MemberInfo[] GetMember (string name, BindingFlags bindingAttr)
{
return GetMember (name, MemberTypes.All, bindingAttr);
}
- public virtual MemberInfo[] GetMember (string name, MemberTypes type,
- BindingFlags bindingAttr)
+ public virtual MemberInfo[] GetMember (string name, MemberTypes type, BindingFlags bindingAttr)
{
- return FindMembers (type, bindingAttr, FilterName, name);
+ if ((bindingAttr & BindingFlags.IgnoreCase) != 0)
+ return FindMembers (type, bindingAttr, FilterNameIgnoreCase, name);
+ else
+ return FindMembers (type, bindingAttr, FilterName, name);
}
- public MemberInfo[] GetMembers()
+ public MemberInfo[] GetMembers ()
{
return GetMembers (DefaultBindingFlags);
}
return GetMethod (name, DefaultBindingFlags, null, CallingConventions.Any, types, null);
}
- public MethodInfo GetMethod( string name, Type[] types, ParameterModifier[] modifiers)
+ public MethodInfo GetMethod (string name, Type[] types, ParameterModifier[] modifiers)
{
- return GetMethod (name, DefaultBindingFlags, null,
- CallingConventions.Any, types, modifiers);
+ return GetMethod (name, DefaultBindingFlags, null, CallingConventions.Any, types, modifiers);
}
public MethodInfo GetMethod (string name, BindingFlags bindingAttr, Binder binder,
- Type[] types, ParameterModifier[] modifiers)
+ Type[] types, ParameterModifier[] modifiers)
{
- return GetMethod (name, bindingAttr, binder,
- CallingConventions.Any, types, modifiers);
+ return GetMethod (name, bindingAttr, binder, CallingConventions.Any, types, modifiers);
}
- public MethodInfo GetMethod (string name, BindingFlags bindingAttr,
- Binder binder, CallingConventions callConvention,
- Type[] types, ParameterModifier[] modifiers)
+ public MethodInfo GetMethod (string name, BindingFlags bindingAttr, Binder binder,
+ CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
{
if (name == null)
throw new ArgumentNullException ("name");
if (types == null)
throw new ArgumentNullException ("types");
+ for (int i = 0; i < types.Length; i++)
+ if (types[i] == null)
+ throw new ArgumentNullException ("types");
+
+ return GetMethodImpl (name, bindingAttr, binder, callConvention, types, modifiers);
+ }
+
+ protected abstract MethodInfo GetMethodImpl (string name, BindingFlags bindingAttr, Binder binder,
+ CallingConventions callConvention, Type[] types,
+ ParameterModifier[] modifiers);
+
+ internal MethodInfo GetMethodImplInternal (string name, BindingFlags bindingAttr, Binder binder,
+ CallingConventions callConvention, Type[] types,
+ ParameterModifier[] modifiers)
+ {
return GetMethodImpl (name, bindingAttr, binder, callConvention, types, modifiers);
}
- protected abstract MethodInfo GetMethodImpl (string name, BindingFlags bindingAttr,
- Binder binder,
- CallingConventions callConvention,
- Type[] types, ParameterModifier[] modifiers);
+ internal virtual MethodInfo GetMethod (MethodInfo fromNoninstanciated)
+ {
+ throw new System.InvalidOperationException ("can only be called in generic type");
+ }
+
+ internal virtual ConstructorInfo GetConstructor (ConstructorInfo fromNoninstanciated)
+ {
+ throw new System.InvalidOperationException ("can only be called in generic type");
+ }
+
+ internal virtual FieldInfo GetField (FieldInfo fromNoninstanciated)
+ {
+ throw new System.InvalidOperationException ("can only be called in generic type");
+ }
+
public MethodInfo[] GetMethods ()
{
return GetMethods (DefaultBindingFlags);
if (name == null)
throw new ArgumentNullException ("name");
- return GetPropertyImpl (name, DefaultBindingFlags, null, null, new Type[0], null);
+ return GetPropertyImpl (name, DefaultBindingFlags, null, null, null, null);
}
public PropertyInfo GetProperty (string name, BindingFlags bindingAttr)
{
if (name == null)
throw new ArgumentNullException ("name");
- return GetPropertyImpl (name, bindingAttr, null, null, new Type[0], null);
+ return GetPropertyImpl (name, bindingAttr, null, null, null, null);
}
public PropertyInfo GetProperty (string name, Type returnType)
{
if (name == null)
throw new ArgumentNullException ("name");
- return GetPropertyImpl (name, DefaultBindingFlags, null, returnType, new Type[0], null);
+ return GetPropertyImpl (name, DefaultBindingFlags, null, returnType, null, null);
}
public PropertyInfo GetProperty (string name, Type[] types)
return GetProperty (name, DefaultBindingFlags, null, returnType, types, null);
}
- public PropertyInfo GetProperty( string name, Type returnType, Type[] types,
- ParameterModifier[] modifiers)
+ public PropertyInfo GetProperty( string name, Type returnType, Type[] types, ParameterModifier[] modifiers)
{
return GetProperty (name, DefaultBindingFlags, null, returnType, types, modifiers);
}
- public PropertyInfo GetProperty (string name, BindingFlags bindingAttr,
- Binder binder, Type returnType,
- Type[] types, ParameterModifier[] modifiers)
+ public PropertyInfo GetProperty (string name, BindingFlags bindingAttr, Binder binder, Type returnType,
+ Type[] types, ParameterModifier[] modifiers)
{
if (name == null)
throw new ArgumentNullException ("name");
return GetPropertyImpl (name, bindingAttr, binder, returnType, types, modifiers);
}
- protected abstract PropertyInfo GetPropertyImpl (string name,
- BindingFlags bindingAttr,
- Binder binder, Type returnType,
- Type[] types,
- ParameterModifier[] modifiers);
+ protected abstract PropertyInfo GetPropertyImpl (string name, BindingFlags bindingAttr, Binder binder,
+ Type returnType, Type[] types, ParameterModifier[] modifiers);
+
+ internal PropertyInfo GetPropertyImplInternal (string name, BindingFlags bindingAttr, Binder binder,
+ Type returnType, Type[] types, ParameterModifier[] modifiers)
+ {
+ return GetPropertyImpl (name, bindingAttr, binder, returnType, types, modifiers);
+ }
protected abstract ConstructorInfo GetConstructorImpl (BindingFlags bindingAttr,
Binder binder,
return typeof (MarshalByRefObject).IsAssignableFrom (this);
}
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public ConstructorInfo GetConstructor (Type[] types)
{
return GetConstructorImpl (
DefaultBindingFlags, null, CallingConventions.Any, types, null);
}
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public ConstructorInfo GetConstructor (BindingFlags bindingAttr, Binder binder,
Type[] types, ParameterModifier[] modifiers)
{
bindingAttr, binder, CallingConventions.Any, types, modifiers);
}
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public ConstructorInfo GetConstructor (BindingFlags bindingAttr, Binder binder,
CallingConventions callConvention,
Type[] types, ParameterModifier[] modifiers)
return GetConstructorImpl (bindingAttr, binder, callConvention, types, modifiers);
}
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public ConstructorInfo[] GetConstructors ()
{
return GetConstructors (BindingFlags.Public | BindingFlags.Instance);
}
-
+
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public abstract ConstructorInfo[] GetConstructors (BindingFlags bindingAttr);
public virtual MemberInfo[] GetDefaultMembers ()
return result;
}
- public object InvokeMember (string name, BindingFlags invokeAttr, Binder binder,
- object target, object[] args)
+ [DebuggerHidden]
+ [DebuggerStepThrough]
+ public object InvokeMember (string name, BindingFlags invokeAttr, Binder binder, object target, object[] args)
{
return InvokeMember (name, invokeAttr, binder, target, args, null, null, null);
}
+ [DebuggerHidden]
+ [DebuggerStepThrough]
public object InvokeMember (string name, BindingFlags invokeAttr, Binder binder,
object target, object[] args, CultureInfo culture)
{
return FullName;
}
-#if GENERICS
- public Type [] GetGenericParameters ()
- {
- if (HasGenericParameters == false)
- return new Type [0];
+ internal bool IsSystemType {
+ get {
+ return _impl.Value != IntPtr.Zero;
+ }
+ }
+
+#if NET_2_0 || BOOTSTRAP_NET_2_0
+ public abstract Type[] GetGenericArguments ();
- throw new Exception ("Unimplemented");
+ public abstract bool HasGenericArguments {
+ get;
}
- public abstract bool HasGenericParameters {
+ public abstract bool ContainsGenericParameters {
get;
}
- public abstract bool HasUnboundGenericParameters {
+ public extern bool IsGenericTypeDefinition {
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
get;
}
- public Type GetGenericTypeDefinition ()
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern Type GetGenericTypeDefinition_impl ();
+
+ public virtual Type GetGenericTypeDefinition ()
{
- throw new Exception ("Unimplemented");
+ Type res = GetGenericTypeDefinition_impl ();
+ if (res == null)
+ throw new InvalidOperationException ();
+
+ return res;
}
- public Type IsGenericTypeDefinition ()
- {
- throw new Exception ("Unimplemented");
+ public extern bool IsGenericInstance {
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ get;
}
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ static extern Type BindGenericParameters (Type gt, Type [] types);
+
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public Type BindGenericParameters (Type [] types)
{
- throw new Exception ("Unimplemented");
+ if (types == null)
+ throw new ArgumentNullException ("types");
+ foreach (Type t in types) {
+ if (t == null)
+ throw new ArgumentNullException ("types");
+ }
+ Type res = BindGenericParameters (this, types);
+ if (res == null)
+ throw new TypeLoadException ();
+ return res;
}
- public abstract bool IsUnboundGenericParameter {
+ public Type MakeGenericType (Type[] types)
+ {
+ return BindGenericParameters (types);
+ }
+
+ public abstract bool IsGenericParameter {
get;
}
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern int GetGenericParameterPosition ();
+
public virtual int GenericParameterPosition {
get {
- throw new Exception ("Unimplemented");
+ int res = GetGenericParameterPosition ();
+ if (res < 0)
+ throw new InvalidOperationException ();
+ return res;
+ }
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern GenericParameterAttributes GetGenericParameterAttributes ();
+
+ public virtual GenericParameterAttributes GenericParameterAttributes {
+ get {
+ if (!IsGenericParameter)
+ throw new InvalidOperationException ();
+
+ return GetGenericParameterAttributes ();
+ }
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern Type[] GetGenericParameterConstraints_impl ();
+
+ public virtual Type[] GetGenericParameterConstraints ()
+ {
+ if (!IsGenericParameter)
+ throw new InvalidOperationException ();
+
+ return GetGenericParameterConstraints_impl ();
+ }
+
+ public abstract MethodInfo DeclaringMethod {
+ get;
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern Type make_array_type (int rank);
+
+ public virtual Type MakeArrayType ()
+ {
+ return MakeArrayType (1);
+ }
+
+ public virtual Type MakeArrayType (int rank)
+ {
+ if (rank < 1)
+ throw new IndexOutOfRangeException ();
+ return make_array_type (rank);
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern Type make_byref_type ();
+
+ public virtual Type MakeByRefType ()
+ {
+ return make_byref_type ();
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ public extern virtual Type MakePointerType ();
+
+ [MonoTODO]
+ public static Type ReflectionOnlyGetType (string typeName,
+ bool throwIfNotFound,
+ bool ignoreCase)
+ {
+ throw new NotImplementedException ();
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern void GetPacking (out int packing, out int size);
+
+ public virtual StructLayoutAttribute StructLayoutAttribute {
+ get {
+ LayoutKind kind;
+
+ if (IsLayoutSequential)
+ kind = LayoutKind.Sequential;
+ else if (IsExplicitLayout)
+ kind = LayoutKind.Explicit;
+ else
+ kind = LayoutKind.Auto;
+
+ StructLayoutAttribute attr = new StructLayoutAttribute (kind);
+
+ if (IsUnicodeClass)
+ attr.CharSet = CharSet.Unicode;
+ else if (IsAnsiClass)
+ attr.CharSet = CharSet.Ansi;
+ else
+ attr.CharSet = CharSet.Auto;
+
+ if (kind != LayoutKind.Auto)
+ GetPacking (out attr.Pack, out attr.Size);
+
+ return attr;
}
}
+
+ internal object[] GetPseudoCustomAttributes () {
+ int count = 0;
+
+ if (IsSerializable)
+ count ++;
+
+ if (count == 0)
+ return null;
+ object[] attrs = new object [count];
+ count = 0;
+
+ if (IsSerializable)
+ attrs [count ++] = new SerializableAttribute ();
+
+ return attrs;
+ }
+
#endif
}
}
projects / mono.git / blobdiff