2007-02-06 Marek Safar <marek.safar@gmail.com>

[mono.git] / mcs / mcs / flowanalysis.cs

diff --git a/mcs/mcs/flowanalysis.cs b/mcs/mcs/flowanalysis.cs
index d29b45b51193a0655f5e9b98ec1ac1fcf34a2d7a..3eab67dfa3393d4917b93cdf5240f417f12eb4dc 100644 (file)
--- a/mcs/mcs/flowanalysis.cs
+++ b/mcs/mcs/flowanalysis.cs
@@ -1327,7 +1327,7 @@ namespace Mono.CSharp
                                        ArrayList non_public_fields = new ArrayList ();
 
                                        if (fields != null) {
-                                               foreach (FieldMember field in fields) {
+                                               foreach (FieldBase field in fields) {
                                                        if ((field.ModFlags & Modifiers.STATIC) != 0)
                                                                continue;
                                                        if ((field.ModFlags & Modifiers.PUBLIC) != 0)
@@ -1344,6 +1344,12 @@ namespace Mono.CSharp
                                        Fields = new FieldInfo [Count];
                                        public_fields.CopyTo (Fields, 0);
                                        non_public_fields.CopyTo (Fields, CountPublic);
+#if GMCS_SOURCE
+                               } else if (type is GenericTypeParameterBuilder) {
+                                       CountPublic = CountNonPublic = Count = 0;
+
+                                       Fields = new FieldInfo [0];
+#endif
                                } else {
                                        FieldInfo[] public_fields = type.GetFields (
                                                BindingFlags.Instance|BindingFlags.Public);
@@ -1755,24 +1761,29 @@ namespace Mono.CSharp
                public readonly int Count;
                public static readonly MyBitVector Empty = new MyBitVector ();
 
+               // Invariant: vector != null => vector.Count == Count
+               // Invariant: vector == null || shared == null
+               //            i.e., at most one of 'vector' and 'shared' can be non-null.  They can both be null -- that means all-ones
+               // The object in 'shared' cannot be modified, while 'vector' can be freely modified
                BitArray vector, shared;
 
                MyBitVector ()
                {
-                       vector = null;
                        shared = new BitArray (0, false);
-                       Count = 0;
                }
 
                public MyBitVector (MyBitVector InheritsFrom, int Count)
                {
-                       vector = null;
-                       shared = InheritsFrom == null ? null : InheritsFrom.Shared;
+                       if (InheritsFrom != null)
+                               shared = InheritsFrom.Shared;
+
                        this.Count = Count;
                }
 
+               // Use this accessor to get a shareable copy of the underlying BitArray representation
                BitArray Shared {
                        get {
+                               // Post-condition: vector == null
                                if (shared == null) {
                                        shared = vector;
                                        vector = null;
@@ -1814,28 +1825,86 @@ namespace Mono.CSharp
                // </summary>
                private MyBitVector Or (MyBitVector new_vector)
                {
-                       int min = new_vector.Count;
+                       if (Count == 0 || new_vector.Count == 0)
+                               return this;
+
+                       BitArray o = new_vector.vector != null ? new_vector.vector : new_vector.shared;
+
+                       if (o == null) {
+                               int n = new_vector.Count;
+                               if (n < Count) {
+                                       for (int i = 0; i < n; ++i)
+                                               this [i] = true;
+                               } else {
+                                       SetAll (true);
+                               }
+                               return this;
+                       }
+
+                       if (Count == o.Count) {
+                               if (vector == null) {
+                                       if (shared == null)
+                                               return this;
+                                       initialize_vector ();
+                               }
+                               vector.Or (o);
+                               return this;
+                       }
+
+                       int min = o.Count;
                        if (Count < min)
                                min = Count;
 
-                       for (int i = 0; i < min; i++)
-                               this [i] |= new_vector [i];
+                       for (int i = 0; i < min; i++) {
+                               if (o [i])
+                                       this [i] = true;
+                       }
 
                        return this;
                }
 
                // <summary>
-               //   Perfonrms an `and' operation on the bit vector.  The `new_vector' may have
+               //   Performs an `and' operation on the bit vector.  The `new_vector' may have
                //   a different size than the current one.
                // </summary>
                private MyBitVector And (MyBitVector new_vector)
                {
-                       int min = new_vector.Count;
+                       if (Count == 0)
+                               return this;
+
+                       BitArray o = new_vector.vector != null ? new_vector.vector : new_vector.shared;
+
+                       if (o == null) {
+                               for (int i = new_vector.Count; i < Count; ++i)
+                                       this [i] = false;
+                               return this;
+                       }
+
+                       if (o.Count == 0) {
+                               SetAll (false);
+                               return this;
+                       }
+
+                       if (Count == o.Count) {
+                               if (vector == null) {
+                                       if (shared == null) {
+                                               shared = new_vector.Shared;
+                                               return this;
+                                       }
+                                       initialize_vector ();
+                               }
+                               vector.And (o);
+                               return this;
+                       }
+
+                       int min = o.Count;
                        if (Count < min)
                                min = Count;
 
-                       for (int i = 0; i < min; i++)
-                               this [i] &= new_vector [i];
+                       for (int i = 0; i < min; i++) {
+                               if (! o [i])
+                                       this [i] = false;
+                       }
 
                        for (int i = min; i < Count; i++)
                                this [i] = false;
@@ -1845,8 +1914,8 @@ namespace Mono.CSharp
 
                public static MyBitVector operator & (MyBitVector a, MyBitVector b)
                {
-                       if (a == null && b == null)
-                               return null;
+                       if (a == b)
+                               return a;
                        if (a == null)
                                return b.Clone ();
                        if (b == null)
@@ -1859,8 +1928,8 @@ namespace Mono.CSharp
 
                public static MyBitVector operator | (MyBitVector a, MyBitVector b)
                {
-                       if (a == null && b == null)
-                               return null;
+                       if (a == b)
+                               return a;
                        if (a == null)
                                return new MyBitVector (null, b.Count);
                        if (b == null)
@@ -1887,20 +1956,15 @@ namespace Mono.CSharp
 
                void initialize_vector ()
                {
+                       // Post-condition: vector != null
                        if (shared == null) {
                                vector = new BitArray (Count, true);
                                return;
                        }
 
-                       vector = new BitArray (Count, false);
-
-                       int min = shared.Count;
-                       if (min > Count)
-                               min = Count;
-
-                       for (int i = 0; i < min; i++)
-                               vector [i] = shared [i];
-
+                       vector = new BitArray (shared);
+                       if (Count != vector.Count)
+                               vector.Length = Count;
                        shared = null;
                }