public sealed class Reachability
{
- TriState returns, throws, barrier;
+ TriState returns, barrier;
public TriState Returns {
get { return returns; }
}
- public TriState Throws {
- get { return throws; }
- }
public TriState Barrier {
get { return barrier; }
}
- Reachability (TriState returns, TriState throws, TriState barrier)
+ Reachability (TriState returns, TriState barrier)
{
this.returns = returns;
- this.throws = throws;
this.barrier = barrier;
}
public Reachability Clone ()
{
- return new Reachability (returns, throws, barrier);
+ return new Reachability (returns, barrier);
}
public static TriState TriState_Meet (TriState a, TriState b)
else
returns = TriState_Meet (returns, b.returns);
- throws = TriState_Meet (throws, b.throws);
barrier = TriState_Meet (barrier, b.barrier);
}
public void Or (Reachability b)
{
returns = TriState_Max (returns, b.returns);
- throws = TriState_Max (throws, b.throws);
barrier = TriState_Max (barrier, b.barrier);
}
public static Reachability Always ()
{
- return new Reachability (TriState.Never, TriState.Never, TriState.Never);
+ return new Reachability (TriState.Never, TriState.Never);
}
TriState Unreachable {
- get { return TriState_Max (returns, TriState_Max (throws, barrier)); }
+ get { return TriState_Max (returns, barrier); }
}
TriState Reachable {
get { return returns == TriState.Always; }
}
- public bool AlwaysThrows {
- get { return throws == TriState.Always; }
- }
-
public bool AlwaysHasBarrier {
get { return barrier == TriState.Always; }
}
returns = TriState.Always;
}
- public void SetThrows ()
- {
- throws = TriState.Always;
- }
-
public void SetBarrier ()
{
barrier = TriState.Always;
public override string ToString ()
{
- return String.Format ("[{0}:{1}:{2}:{3}]",
- ShortName (returns), ShortName (throws), ShortName (barrier),
- ShortName (Reachable));
+ return String.Format ("[{0}:{1}:{2}]",
+ ShortName (returns), ShortName (barrier), ShortName (Reachable));
}
}
reachability.SetReturns ();
}
- public void Throw ()
- {
- if (!reachability.IsUnreachable) {
- reachability.SetThrows ();
- reachability.SetBarrier ();
- }
- }
-
public void Goto ()
{
if (!reachability.IsUnreachable)
MyBitVector locals = null;
MyBitVector parameters = null;
- Reachability reachability = null;
+ Reachability reachability = sibling_list.Reachability.Clone ();
- for (UsageVector child = sibling_list; child != null; child = child.Next) {
- Report.Debug (2, " MERGING SIBLING ", reachability, child);
+ if (!sibling_list.Reachability.IsUnreachable) {
+ locals &= sibling_list.locals;
+ parameters &= sibling_list.parameters;
+ }
- if (reachability == null)
- reachability = child.Reachability.Clone ();
- else
- reachability.Meet (child.Reachability);
-
- // A local variable is initialized after a flow branching if it
- // has been initialized in all its branches which do neither
- // always return or always throw an exception.
- //
- // If a branch may return, but does not always return, then we
- // can treat it like a never-returning branch here: control will
- // only reach the code position after the branching if we did not
- // return here.
- //
- // It's important to distinguish between always and sometimes
- // returning branches here:
- //
- // 1 int a;
- // 2 if (something) {
- // 3 return;
- // 4 a = 5;
- // 5 }
- // 6 Console.WriteLine (a);
- //
- // The if block in lines 3-4 always returns, so we must not look
- // at the initialization of `a' in line 4 - thus it'll still be
- // uninitialized in line 6.
- //
- // On the other hand, the following is allowed:
- //
- // 1 int a;
- // 2 if (something)
- // 3 a = 5;
- // 4 else
- // 5 return;
- // 6 Console.WriteLine (a);
- //
- // Here, `a' is initialized in line 3 and we must not look at
- // line 5 since it always returns.
- //
- bool unreachable = child.Reachability.IsUnreachable;
-
- Report.Debug (2, " MERGING SIBLING #1", reachability,
- child.Type, child.Reachability.IsUnreachable, unreachable);
-
- if (!unreachable)
- locals &= child.locals;
+ for (UsageVector child = sibling_list.Next; child != null; child = child.Next) {
+ reachability.Meet (child.Reachability);
- // An `out' parameter must be assigned in all branches which do
- // not always throw an exception.
- if (!child.Reachability.AlwaysThrows)
+ if (!child.Reachability.IsUnreachable) {
+ locals &= child.locals;
parameters &= child.parameters;
-
- Report.Debug (2, " MERGING SIBLING #2", parameters, locals);
+ }
}
-
- if (reachability == null)
- throw new InternalErrorException ("Cannot happen: the loop above runs at least twice");
return new UsageVector (parameters, locals, reachability, null, loc);
}
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)
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 ()
this.Count = Count;
}
- //FIXME: This property is `dirty', reading changes internal status
+ // 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;
if (Count == 0 || new_vector.Count == 0)
return this;
- // Try to avoid using the indexer as it is very slow way
- if (new_vector.vector != null) {
- // TODO: Implement this correctly
- //if (vector == null) {
- // vector = new BitArray (new_vector.vector);
- // vector.Length = Count;
- // return this;
- //}
-
- if (vector != null && vector.Count == new_vector.vector.Count) {
- vector.Or (new_vector.vector);
- 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);
}
- } else if (new_vector.shared != null) {
- if (shared == null)
- return this;
+ return this;
+ }
- if (shared.Count == new_vector.shared.Count) {
- shared.Or (new_vector.shared);
- return this;
+ if (Count == o.Count) {
+ if (vector == null) {
+ if (shared == null)
+ return this;
+ initialize_vector ();
}
+ vector.Or (o);
+ return this;
}
- int min = new_vector.Count;
+ int min = o.Count;
if (Count < min)
min = Count;
for (int i = 0; i < min; i++) {
- bool b = new_vector [i];
- if (b)
- this [i] |= b;
+ if (o [i])
+ this [i] = true;
}
return this;
// </summary>
private MyBitVector And (MyBitVector new_vector)
{
- // Try to avoid using the indexer as it is very slow
- if (new_vector.vector != null) {
- if (vector == null)
- return this;
+ if (Count == 0)
+ return this;
- if (vector.Count == new_vector.vector.Count) {
- vector.And (new_vector.vector);
- 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;
}
- else if (new_vector.shared != null) {
- if (shared == null)
- return this;
-
- if (shared.Count == new_vector.shared.Count) {
- vector = new BitArray (shared).And (new_vector.shared);
- if (Count != vector.Count)
- vector.Length = Count;
- shared = null;
- 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 = new_vector.Count;
+ int min = o.Count;
if (Count < min)
min = Count;
for (int i = 0; i < min; i++) {
- bool b = new_vector [i];
- if (!b)
- this [i] &= b;
+ if (! o [i])
+ this [i] = false;
}
for (int i = min; i < Count; i++)
void initialize_vector ()
{
+ // Post-condition: vector != null
if (shared == null) {
vector = new BitArray (Count, true);
return;