2003-07-24 Miguel de Icaza <miguel@ximian.com>

	* Type.cs: Added generics stubs.

2003-07-24  Miguel de Icaza  <miguel@ximian.com>

	* ArrayList.cs: Removed MonoTODO.

2003-07-24  Miguel de Icaza  <miguel@ximian.com>

	* TypeDelegator.cs: Added generics stubs.

2003-07-24  Miguel de Icaza  <miguel@ximian.com>

	* TypeBuilder.cs: Added generics stubs.

	* EnumBuilder.cs: Added generics  stubs, changed bracing style for
	routines.

svn path=/trunk/mcs/; revision=16621

diff --git a/mcs/class/corlib/System.Collections/ArrayList.cs b/mcs/class/corlib/System.Collections/ArrayList.cs
index 8026959a128a5655729cf689f4255918adc3430f..54abb141eb0c82cd4111bb298e4fc7891b4fd02f 100644 (file)
--- a/mcs/class/corlib/System.Collections/ArrayList.cs
+++ b/mcs/class/corlib/System.Collections/ArrayList.cs
@@ -15,7 +15,6 @@ using System;
 \r
 namespace System.Collections {\r
 \r
-       [MonoTODO ("add versioning, changing the arraylist should invalidate all enumerators")]\r
        [Serializable]\r
        public class ArrayList : IList, ICollection, IEnumerable, ICloneable {\r
 \r

diff --git a/mcs/class/corlib/System.Collections/ChangeLog b/mcs/class/corlib/System.Collections/ChangeLog
index 295de34cc78779d4fff606b005438d79892e4a58..276051d4f0c4c885cc787b809e77c0da31c967f3 100644 (file)
--- a/mcs/class/corlib/System.Collections/ChangeLog
+++ b/mcs/class/corlib/System.Collections/ChangeLog
@@ -1,3 +1,7 @@
+2003-07-24  Miguel de Icaza  <miguel@ximian.com>
+
+       * ArrayList.cs: Removed MonoTODO.
+
 2003-07-07  Gonzalo Paniagua Javier <gonzalo@ximian.com>
 
        * Hashtable.cs: made SynchedHashtable serializable. Fixes bug #45918.

diff --git a/mcs/class/corlib/System.IO/StreamReader.cs b/mcs/class/corlib/System.IO/StreamReader.cs
index 11d02ec889923781b54b4587d48dc568719b869c..0a180dff57e220b86349e8db2a23ad8ace02dba3 100644 (file)
--- a/mcs/class/corlib/System.IO/StreamReader.cs
+++ b/mcs/class/corlib/System.IO/StreamReader.cs
@@ -283,7 +283,7 @@ namespace System.IO {
                                decoded_count += decoder.GetChars (input_buffer, parse_start, cbEncoded, decoded_buffer, 0);
                                parse_start = 0;
                        } while (decoded_count == 0);
-                       
+
                        return decoded_count;
                }
 

diff --git a/mcs/class/corlib/System.Reflection.Emit/ChangeLog b/mcs/class/corlib/System.Reflection.Emit/ChangeLog
index 87f741237273e6e7bcd2813ddb9abb31288b1157..3ddf9c47e4e1e9b46ac83a6fbed01bf908be5094 100644 (file)
--- a/mcs/class/corlib/System.Reflection.Emit/ChangeLog
+++ b/mcs/class/corlib/System.Reflection.Emit/ChangeLog
@@ -1,3 +1,10 @@
+2003-07-24  Miguel de Icaza  <miguel@ximian.com>
+
+       * TypeBuilder.cs: Added generics stubs.
+
+       * EnumBuilder.cs: Added generics  stubs, changed bracing style for
+       routines.
+
 2003-07-23  Duncan Mak  <duncan@ximian.com>
 
        * SignatureHelper.cs: This class does not have the

diff --git a/mcs/class/corlib/System.Reflection.Emit/EnumBuilder.cs b/mcs/class/corlib/System.Reflection.Emit/EnumBuilder.cs
index d82d116ad840db5be240cb7248140c41f46519b4..62d0056e6406bb87bab7acf35ec46d5178a4b1ae 100755 (executable)
--- a/mcs/class/corlib/System.Reflection.Emit/EnumBuilder.cs
+++ b/mcs/class/corlib/System.Reflection.Emit/EnumBuilder.cs
@@ -19,46 +19,46 @@ namespace System.Reflection.Emit {
                CustomAttributeBuilder[] cattrs;
 
                public override Assembly Assembly {
-                       get {return null;}
+                       get { return null; }
                }
                public override string AssemblyQualifiedName {
-                       get {return null;}
+                       get { return null; }
                }
                public override Type BaseType {
-                       get {return null;}
+                       get { return null; }
                }
                public override Type DeclaringType {
-                       get {return null;}
+                       get { return null; }
                }
                public override string FullName {
-                       get {return null;}
+                       get { return null; }
                }
                public override Guid GUID {
-                       get {return Guid.Empty;}
+                       get { return Guid.Empty; }
                }
                public override Module Module {
-                       get {return null;}
+                       get { return null; }
                }
                public override string Name {
-                       get {return null;}
+                       get { return null; }
                }
                public override string Namespace {
-                       get {return null;}
+                       get { return null; }
                }
                public override Type ReflectedType {
-                       get {return null;}
+                       get { return null; }
                }
                public override RuntimeTypeHandle TypeHandle {
-                       get {return new RuntimeTypeHandle ();}
+                       get { return new RuntimeTypeHandle (); }
                }
                public TypeToken TypeToken {
-                       get {return new TypeToken ();}
+                       get { return new TypeToken (); }
                }
                public FieldBuilder UnderlyingField {
-                       get {return null;}
+                       get { return null; }
                }
                public override Type UnderlyingSystemType {
-                       get {return null;}
+                       get { return null; }
                }
 /* no need to override
                public override MemberTypes MemberType {
@@ -66,111 +66,189 @@ namespace System.Reflection.Emit {
                }
 */
 
-               internal EnumBuilder (ModuleBuilder mb, string name, TypeAttributes visibility, Type underlyingType) {
+               internal EnumBuilder (ModuleBuilder mb, string name, TypeAttributes visibility, Type underlyingType)
+               {
                }
-               public Type CreateType() {
+
+               public Type CreateType ()
+               {
                        return null;
                }
-               public FieldBuilder DefineLiteral( string literalName, object literalValue) {
+
+               public FieldBuilder DefineLiteral (string literalName, object literalValue)
+               {
                        return null;
                }
-               protected override TypeAttributes GetAttributeFlagsImpl() {
+               protected override TypeAttributes GetAttributeFlagsImpl ()
+               {
                        return (TypeAttributes)0;
                }
-               protected override ConstructorInfo GetConstructorImpl( BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) {
+
+               protected override ConstructorInfo GetConstructorImpl (
+                       BindingFlags bindingAttr, Binder binder, CallingConventions cc,
+                       Type[] types, ParameterModifier[] modifiers)
+               {
                        return null;
                }
-               public override ConstructorInfo[] GetConstructors( BindingFlags bindingAttr) {
+
+               public override ConstructorInfo[] GetConstructors( BindingFlags bindingAttr)
+               {
                        return null;
                }
-               public override object[] GetCustomAttributes(bool inherit) {
+
+               public override object[] GetCustomAttributes(bool inherit)
+               {
                        return null;
                }
-               public override object[] GetCustomAttributes(Type attributeType, bool inherit) {
+
+               public override object[] GetCustomAttributes(Type attributeType, bool inherit)
+               {
                        return null;
                }
-               public override Type GetElementType() {
+
+               public override Type GetElementType()
+               {
                        throw new NotSupportedException ();
                }
-               public override EventInfo GetEvent( string name, BindingFlags bindingAttr) {
+
+               public override EventInfo GetEvent( string name, BindingFlags bindingAttr)
+               {
                        return null;
                }
-               public override EventInfo[] GetEvents() {
+
+               public override EventInfo[] GetEvents()
+               {
                        return null;
                }
-               public override EventInfo[] GetEvents( BindingFlags bindingAttr) {
+
+               public override EventInfo[] GetEvents( BindingFlags bindingAttr)
+               {
                        return null;
                }
-               public override FieldInfo GetField( string name, BindingFlags bindingAttr) {
+
+               public override FieldInfo GetField( string name, BindingFlags bindingAttr)
+               {
                        return null;
                }
-               public override FieldInfo[] GetFields( BindingFlags bindingAttr) {
+
+               public override FieldInfo[] GetFields( BindingFlags bindingAttr)
+               {
                        return null;
                }
-               public override Type GetInterface( string name, bool ignoreCase) {
+
+               public override Type GetInterface( string name, bool ignoreCase)
+               {
                        return null;
                }
-               public override InterfaceMapping GetInterfaceMap( Type interfaceType) {
+
+               public override InterfaceMapping GetInterfaceMap( Type interfaceType)
+               {
                        throw new NotImplementedException ();
                }
-               public override Type[] GetInterfaces() {
+
+               public override Type[] GetInterfaces()
+               {
                        return null;
                }
-               public override MemberInfo[] GetMember( string name, MemberTypes type, BindingFlags bindingAttr) {
+
+               public override MemberInfo[] GetMember( string name, MemberTypes type, BindingFlags bindingAttr)
+               {
                        return null;
                }
-               public override MemberInfo[] GetMembers( BindingFlags bindingAttr) {
+
+               public override MemberInfo[] GetMembers( BindingFlags bindingAttr)
+               {
                        return null;
                }
-               protected override MethodInfo GetMethodImpl( string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) {
+
+               protected override MethodInfo GetMethodImpl (
+                       string name, BindingFlags bindingAttr, Binder binder,
+                       CallingConventions callConvention, Type[] types,
+                       ParameterModifier[] modifiers)
+               {
                        // FIXME
                        return null;
                }
                
-               public override MethodInfo[] GetMethods( BindingFlags bindingAttr) {
+               public override MethodInfo[] GetMethods( BindingFlags bindingAttr)
+               {
                        return null;
                }
-               public override Type GetNestedType( string name, BindingFlags bindingAttr) {
+
+               public override Type GetNestedType( string name, BindingFlags bindingAttr)
+               {
                        return null;
                }
-               public override Type[] GetNestedTypes( BindingFlags bindingAttr) {
+
+               public override Type[] GetNestedTypes( BindingFlags bindingAttr)
+               {
                        return null;
                }
-               public override PropertyInfo[] GetProperties( BindingFlags bindingAttr) {
+
+               public override PropertyInfo[] GetProperties( BindingFlags bindingAttr)
+                       {
                        return null;
                }
-               protected override PropertyInfo GetPropertyImpl( string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers) {
+
+               protected override PropertyInfo GetPropertyImpl (
+                       string name, BindingFlags bindingAttr, Binder binder,
+                       Type returnType, Type[] types,
+                       ParameterModifier[] modifiers)
+               {
                        return null;
                }
-               protected override bool HasElementTypeImpl() {
+
+               protected override bool HasElementTypeImpl()
+                       {
                        throw new NotSupportedException ();
                }
-               public override object InvokeMember( string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)  {
+
+               public override object InvokeMember (
+                       string name, BindingFlags invokeAttr, Binder binder,
+                       object target, object[] args,
+                       ParameterModifier[] modifiers, CultureInfo culture,
+                       string[] namedParameters)
+               {
                        return null;
                }
-               protected override bool IsArrayImpl() {
+
+               protected override bool IsArrayImpl()
+               {
                        return false;
                }
-               protected override bool IsByRefImpl() {
+
+               protected override bool IsByRefImpl()
+               {
                        return false;
                }
-               protected override bool IsCOMObjectImpl() {
+
+               protected override bool IsCOMObjectImpl()
+               {
                        return false;
                }
-               protected override bool IsPointerImpl() {
+
+               protected override bool IsPointerImpl()
+               {
                        return false;
                }
-               protected override bool IsPrimitiveImpl() {
+
+               protected override bool IsPrimitiveImpl()
+               {
                        return false;
                }
-               protected override bool IsValueTypeImpl() {
+               
+               protected override bool IsValueTypeImpl()
+               {
                        return true;
                }
-               public override bool IsDefined( Type attributeType, bool inherit) {
+
+               public override bool IsDefined( Type attributeType, bool inherit)
+               {
                        return false;
                }
                
-               public void SetCustomAttribute( CustomAttributeBuilder customBuilder) {
+               public void SetCustomAttribute( CustomAttributeBuilder customBuilder)
+               {
                        if (cattrs != null) {
                                CustomAttributeBuilder[] new_array = new CustomAttributeBuilder [cattrs.Length + 1];
                                cattrs.CopyTo (new_array, 0);
@@ -181,8 +259,36 @@ namespace System.Reflection.Emit {
                                cattrs [0] = customBuilder;
                        }
                }
-               public void SetCustomAttribute( ConstructorInfo con, byte[] binaryAttribute) {
+
+               public void SetCustomAttribute( ConstructorInfo con, byte[] binaryAttribute)
+               {
                        SetCustomAttribute (new CustomAttributeBuilder (con, binaryAttribute));
                }
+
+#if GENERICS
+               public override bool HasGenericParameters {
+                       get {
+                               throw new NotImplementedException ();
+                       }
+               }
+
+               public override bool HasUnboundGenericParameters {
+                       get {
+                               throw new NotImplementedException ();
+                       }
+               }
+
+               public override bool IsUnboundGenericParameter {
+                       get {
+                               throw new NotImplementedException ();
+                       }
+               }
+
+               public override int GenericParameterPosition {
+                       get {
+                               throw new Exception ("Unimplemented");
+                       }
+               }
+#endif
        }
 }

diff --git a/mcs/class/corlib/System.Reflection.Emit/TypeBuilder.cs b/mcs/class/corlib/System.Reflection.Emit/TypeBuilder.cs
index 24bcfa602ca76cf3c03558206a616c90baa78cb2..e82ce82bd00f32bb17ae174a52528e255df9ecfc 100644 (file)
--- a/mcs/class/corlib/System.Reflection.Emit/TypeBuilder.cs
+++ b/mcs/class/corlib/System.Reflection.Emit/TypeBuilder.cs
@@ -881,7 +881,8 @@ namespace System.Reflection.Emit {
                        if (is_created)
                                throw not_after_created ();
 
-                       TypeBuilder datablobtype = DefineNestedType ("$ArrayType$"+InitializedDataCount.ToString(),
+                       string s = "$ArrayType$"+InitializedDataCount.ToString();
+                       TypeBuilder datablobtype = DefineNestedType (s,
                                TypeAttributes.NestedPrivate|TypeAttributes.ExplicitLayout|TypeAttributes.Sealed,
                                pmodule.assemblyb.corlib_value_type, null, PackingSize.Size1, data.Length);
                        datablobtype.CreateType ();
@@ -952,5 +953,31 @@ namespace System.Reflection.Emit {
                        if (name.IndexOf ((char)0) != -1)
                                throw new ArgumentException (argName, "Illegal name.");
                }
+
+#if GENERICS
+               public override bool HasGenericParameters {
+                       get {
+                               throw new NotImplementedException ();
+                       }
+               }
+
+               public override bool HasUnboundGenericParameters {
+                       get {
+                               throw new NotImplementedException ();
+                       }
+               }
+
+               public override bool IsUnboundGenericParameter {
+                       get {
+                               throw new NotImplementedException ();
+                       }
+               }
+
+               public override int GenericParameterPosition {
+                       get {
+                               throw new Exception ("Unimplemented");
+                       }
+               }
+#endif
        }
 }

diff --git a/mcs/class/corlib/System.Reflection/ChangeLog b/mcs/class/corlib/System.Reflection/ChangeLog
index e742e182f538aa9cc81a301b141ec1bce7688cce..8d4d3eb55ed4c1fecfe1cfc8ebdcece031971378 100644 (file)
--- a/mcs/class/corlib/System.Reflection/ChangeLog
+++ b/mcs/class/corlib/System.Reflection/ChangeLog
@@ -1,3 +1,7 @@
+2003-07-24  Miguel de Icaza  <miguel@ximian.com>
+
+       * TypeDelegator.cs: Added generics stubs.
+
 2003-07-21  Lluis Sanchez Gual  <lluis@ximian.com>
 
        * ParameterInfo.cs: Position is zero-based in ParameterInfo.

diff --git a/mcs/class/corlib/System.Reflection/TypeDelegator.cs b/mcs/class/corlib/System.Reflection/TypeDelegator.cs
index b25962a4660d249795288e37708bf427461d91c4..024a015194cdbf9641289aa18c8d03c495089aa7 100755 (executable)
--- a/mcs/class/corlib/System.Reflection/TypeDelegator.cs
+++ b/mcs/class/corlib/System.Reflection/TypeDelegator.cs
@@ -17,63 +17,69 @@ namespace System.Reflection {
                protected TypeDelegator () {
                }
 
-               public TypeDelegator( Type delegatingType) {
+               public TypeDelegator( Type delegatingType)
+               {
                        if (delegatingType == null)
                                throw new ArgumentNullException ("delegatingType must be non-null");
                        typeImpl = delegatingType;
                }
 
                public override Assembly Assembly {
-                       get {return typeImpl.Assembly;}
+                       get { return typeImpl.Assembly; }
                }
 
                public override string AssemblyQualifiedName {
-                       get {return typeImpl.AssemblyQualifiedName;}
+                       get { return typeImpl.AssemblyQualifiedName; }
                }
 
                public override Type BaseType {
-                       get {return typeImpl.BaseType;}
+                       get { return typeImpl.BaseType; }
                }
 
                public override string FullName {
-                       get {return typeImpl.FullName;}
+                       get { return typeImpl.FullName; }
                }
 
                public override Guid GUID {
-                       get {return typeImpl.GUID;}
+                       get { return typeImpl.GUID; }
                }
 
                public override Module Module {
-                       get {return typeImpl.Module;}
+                       get { return typeImpl.Module; }
                }
 
                public override string Name {
-                       get {return typeImpl.Name;}
+                       get { return typeImpl.Name; }
                }
 
                public override string Namespace {
-                       get {return typeImpl.Namespace;}
+                       get { return typeImpl.Namespace; }
                }
 
                public override RuntimeTypeHandle TypeHandle {
-                       get {return typeImpl.TypeHandle;}
+                       get { return typeImpl.TypeHandle; }
                }
 
                public override Type UnderlyingSystemType {
-                       get {return typeImpl.UnderlyingSystemType;}
+                       get { return typeImpl.UnderlyingSystemType; }
                }
 
-               protected override TypeAttributes GetAttributeFlagsImpl () {
+               protected override TypeAttributes GetAttributeFlagsImpl ()
+               {
                        throw new NotImplementedException ();
                        //return typeImpl.GetAttributeFlagsImpl ();
                }
                
-               protected override ConstructorInfo GetConstructorImpl (BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) {
+               protected override ConstructorInfo GetConstructorImpl (
+                       BindingFlags bindingAttr, Binder binder, CallingConventions cc,
+                       Type[] types, ParameterModifier[] modifiers)
+               {
                        throw new NotImplementedException ();
                        //return typeImpl.GetConstructorImpl (bindingAttr, binder, callConvention, types, modifiers);
                }
 
-               public override ConstructorInfo[] GetConstructors( BindingFlags bindingAttr) {
+               public override ConstructorInfo[] GetConstructors( BindingFlags bindingAttr)
+               {
                        return typeImpl.GetConstructors (bindingAttr);
                }
 
@@ -87,77 +93,95 @@ namespace System.Reflection {
                        return typeImpl.GetCustomAttributes (attributeType, inherit);
                }
 
-               public override Type GetElementType() {
+               public override Type GetElementType()
+               {
                        return typeImpl.GetElementType ();
                }
 
-               public override EventInfo GetEvent( string name, BindingFlags bindingAttr) {
+               public override EventInfo GetEvent( string name, BindingFlags bindingAttr)
+               {
                        return typeImpl.GetEvent (name, bindingAttr);
                }
 
-               public override EventInfo[] GetEvents() {
+               public override EventInfo[] GetEvents()
+               {
                        return GetEvents (BindingFlags.Public);
                }
 
-               public override EventInfo[] GetEvents( BindingFlags bindingAttr) {
+               public override EventInfo[] GetEvents (BindingFlags bindingAttr)
+               {
                        return typeImpl.GetEvents (bindingAttr);
                }
 
-               public override FieldInfo GetField( string name, BindingFlags bindingAttr) {
+               public override FieldInfo GetField (string name, BindingFlags bindingAttr)
+               {
                        return typeImpl.GetField (name, bindingAttr);
                }
 
-               public override FieldInfo[] GetFields( BindingFlags bindingAttr) {
+               public override FieldInfo[] GetFields( BindingFlags bindingAttr)
+               {
                        return typeImpl.GetFields (bindingAttr);
                }
 
-               public override Type GetInterface( string name, bool ignoreCase) {
+               public override Type GetInterface( string name, bool ignoreCase)
+               {
                        return typeImpl.GetInterface (name, ignoreCase);
                }
 
-               public override InterfaceMapping GetInterfaceMap( Type interfaceType) {
+               public override InterfaceMapping GetInterfaceMap( Type interfaceType)
+               {
                        return typeImpl.GetInterfaceMap (interfaceType);
                }
                
-               public override Type[] GetInterfaces() {
+               public override Type[] GetInterfaces ()
+               {
                        return typeImpl.GetInterfaces ();
                }
 
-               public override MemberInfo[] GetMember( string name, MemberTypes type, BindingFlags bindingAttr) {
+               public override MemberInfo[] GetMember( string name, MemberTypes type, BindingFlags bindingAttr)
+               {
                        return typeImpl.GetMember (name, type, bindingAttr);
                }
 
-               public override MemberInfo[] GetMembers( BindingFlags bindingAttr) {
+               public override MemberInfo[] GetMembers( BindingFlags bindingAttr)
+               {
                        return typeImpl.GetMembers (bindingAttr);
                }
 
-               protected override MethodInfo GetMethodImpl( string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) {
+               protected override MethodInfo GetMethodImpl( string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
+               {
                        throw new NotImplementedException ();
                        //return typeImpl.GetMethodImpl (name, bindingAttr, binder, callConvention, types, modifiers);
                }
 
-               public override MethodInfo[] GetMethods( BindingFlags bindingAttr) {
+               public override MethodInfo[] GetMethods( BindingFlags bindingAttr)
+               {
                        return typeImpl.GetMethods (bindingAttr);
                }
 
-               public override Type GetNestedType( string name, BindingFlags bindingAttr) {
+               public override Type GetNestedType( string name, BindingFlags bindingAttr)
+               {
                        return typeImpl.GetNestedType (name, bindingAttr);
                }
 
-               public override Type[] GetNestedTypes( BindingFlags bindingAttr) {
+               public override Type[] GetNestedTypes( BindingFlags bindingAttr)
+               {
                        return typeImpl.GetNestedTypes (bindingAttr);
                }
 
-               public override PropertyInfo[] GetProperties( BindingFlags bindingAttr) {
+               public override PropertyInfo[] GetProperties( BindingFlags bindingAttr)
+               {
                        return typeImpl.GetProperties (bindingAttr);
                }
 
-               protected override PropertyInfo GetPropertyImpl( string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers) {
+               protected override PropertyInfo GetPropertyImpl( string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
+               {
                        throw new NotImplementedException ();
                        //return typeImpl.GetPropertyImpl (name, bindingAttr, bindingAttr, returnType, types, modifiers);
                }
 
-               protected override bool HasElementTypeImpl() {
+               protected override bool HasElementTypeImpl()
+               {
                        throw new NotImplementedException ();
                        //return typeImpl.HasElementTypeImpl ();
                }
@@ -166,17 +190,20 @@ namespace System.Reflection {
                        return typeImpl.InvokeMember (name, invokeAttr, binder, target, args, modifiers, culture, namedParameters);
                }
 
-               protected override bool IsArrayImpl() {
+               protected override bool IsArrayImpl()
+               {
                        throw new NotImplementedException ();
                        //return typeImpl.IsArrayImpl ();
                }
 
-               protected override bool IsByRefImpl() {
+               protected override bool IsByRefImpl()
+               {
                        throw new NotImplementedException ();
                        //return typeImpl.IsByRefImpl ();
                }
 
-               protected override bool IsCOMObjectImpl() {
+               protected override bool IsCOMObjectImpl()
+               {
                        throw new NotImplementedException ();
                        //return typeImpl.IsCOMObjectImpl ();
                }
@@ -185,20 +212,48 @@ namespace System.Reflection {
                        return typeImpl.IsDefined (attributeType, inherit);
                }
 
-               protected override bool IsPointerImpl() {
+               protected override bool IsPointerImpl()
+               {
                        throw new NotImplementedException ();
                        //return typeImpl.IsPointerImpl ();
                }
 
-               protected override bool IsPrimitiveImpl() {
+               protected override bool IsPrimitiveImpl()
+               {
                        throw new NotImplementedException ();
                        //return typeImpl.IsPrimitiveImpl ();
                }
 
-               protected override bool IsValueTypeImpl() {
+               protected override bool IsValueTypeImpl()
+               {
                        throw new NotImplementedException ();
                        //return typeImpl.IsValueTypeImpl ();
                }
+#if GENERICS
+               public override bool HasGenericParameters {
+                       get {
+                               throw new NotImplementedException ();
+                       }
+               }
+
+               public override bool HasUnboundGenericParameters {
+                       get {
+                               throw new NotImplementedException ();
+                       }
+               }
+
+               public override bool IsUnboundGenericParameter {
+                       get {
+                               throw new NotImplementedException ();
+                       }
+               }
+
+               public override int GenericParameterPosition {
+                       get {
+                               throw new Exception ("Unimplemented");
+                       }
+               }
+#endif
 
        }
 }

diff --git a/mcs/class/corlib/System/ChangeLog b/mcs/class/corlib/System/ChangeLog
index 5ddbcf462a61ac8a0c98d945804133ab1ccc0ca0..0df74354b7ceb9640766ed2a7ef6418269c2ccd5 100644 (file)
--- a/mcs/class/corlib/System/ChangeLog
+++ b/mcs/class/corlib/System/ChangeLog
@@ -1,7 +1,6 @@
-2003-07-24  Duncan Mak  <duncan@ximian.com>
+2003-07-24  Miguel de Icaza  <miguel@ximian.com>
 
-       * Environment.cs (GetFolderPath): Make it not print out CS0162
-       warnings.
+       * Type.cs: Added generics stubs.
 
 2003-07-23  Duncan Mak  <duncan@ximian.com>
 

diff --git a/mcs/class/corlib/System/MonoType.cs b/mcs/class/corlib/System/MonoType.cs
index a2af09be6f49218cdc01bd555208bb6bfb774580..cdda751ec47fee8630130384b996487b721fc16f 100644 (file)
--- a/mcs/class/corlib/System/MonoType.cs
+++ b/mcs/class/corlib/System/MonoType.cs
@@ -533,9 +533,35 @@ namespace System
                        return info.rank;
                }
 
-               public void GetObjectData(SerializationInfo info, StreamingContext context)\r
-               {\r
-                       UnitySerializationHolder.GetTypeData (this, info, context);\r
-               }\r
+               public void GetObjectData(SerializationInfo info, StreamingContext context)
+               {
+                       UnitySerializationHolder.GetTypeData (this, info, context);
+               }
+
+#if GENERICS
+               public override bool HasGenericParameters {
+                       get {
+                               throw new NotImplementedException ();
+                       }
+               }
+
+               public override bool HasUnboundGenericParameters {
+                       get {
+                               throw new NotImplementedException ();
+                       }
+               }
+
+               public override bool IsUnboundGenericParameter {
+                       get {
+                               throw new NotImplementedException ();
+                       }
+               }
+
+               public override int GenericParameterPosition {
+                       get {
+                               throw new Exception ("Unimplemented");
+                       }
+               }
+#endif
        }
 }

diff --git a/mcs/class/corlib/System/Type.cs b/mcs/class/corlib/System/Type.cs
index 7674a7c603a499f10bb43bf853bfc178300f5f52..f4fc8a2cc4dd4532470b6c207762658d01778724 100644 (file)
--- a/mcs/class/corlib/System/Type.cs
+++ b/mcs/class/corlib/System/Type.cs
@@ -928,5 +928,48 @@ namespace System {
                {
                        return FullName;
                }
+
+#if GENERICS
+               public Type [] GetGenericParameters ()
+               {
+                       if (HasGenericParameters == false)
+                               return new Type [0];
+
+                       throw new Exception ("Unimplemented");
+               }
+
+               public abstract bool HasGenericParameters {
+                       get;
+               }
+
+               public abstract bool HasUnboundGenericParameters {
+                       get;
+               }
+
+               public Type GetGenericTypeDefinition ()
+               {
+                       throw new Exception ("Unimplemented");
+               }
+
+               public Type IsGenericTypeDefinition ()
+               {
+                       throw new Exception ("Unimplemented");
+               }
+
+               public Type BindGenericParameters (Type [] types)
+               {
+                       throw new Exception ("Unimplemented");
+               }
+
+               public abstract bool IsUnboundGenericParameter {
+                       get;
+               }
+
+               public virtual int GenericParameterPosition {
+                       get {
+                               throw new Exception ("Unimplemented");
+                       }
+               }
+#endif
        }
 }