// Martin Baulig (martin@ximian.com)
// Raja R Harinath (rharinath@novell.com)
//
-// (C) 2001, 2002, 2003 Ximian, Inc.
+// Copyright 2001, 2002, 2003 Ximian, Inc.
+// Copyright 2003-2008 Novell, Inc.
//
using System;
using System.Text;
-using System.Collections;
+using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;
using System.Diagnostics;
// part of a block headed by a jump target
Labeled,
- // Try/Catch block.
+ // TryCatch block.
+ TryCatch,
+
+ // TryFinally, Using, Lock, CollectionForeach
Exception,
// Switch block.
Switch,
- // Switch section.
- SwitchSection,
-
// The toplevel block of a function
- Toplevel
+ Toplevel,
+
+ // An iterator block
+ Iterator
}
// <summary>
case BranchingType.Exception:
case BranchingType.Labeled:
case BranchingType.Toplevel:
+ case BranchingType.TryCatch:
throw new InvalidOperationException ();
case BranchingType.Switch:
return new FlowBranchingBreakable (parent, type, SiblingType.SwitchSection, block, loc);
- case BranchingType.SwitchSection:
- return new FlowBranchingBlock (parent, type, SiblingType.Block, block, loc);
-
case BranchingType.Block:
return new FlowBranchingBlock (parent, type, SiblingType.Block, block, loc);
locals |= child.locals;
+ // throw away un-necessary information about variables in child blocks
+ if (locals.Count != CountLocals)
+ locals = new MyBitVector (locals, CountLocals);
+
if (overwrite)
is_unreachable = new_isunr;
else
protected abstract UsageVector Merge ();
- // <summary>
- // Merge a child branching.
- // </summary>
public UsageVector MergeChild (FlowBranching child)
{
- bool overwrite = false;
-
- switch (child.Type) {
- case BranchingType.Labeled:
- overwrite = true;
- break;
- case BranchingType.Block:
- if (child.Block != null && child.Block != child.Block.Explicit)
- overwrite = true;
- break;
- }
-
- Report.Debug (2, " MERGING CHILD", this, child);
- UsageVector result = CurrentUsageVector.MergeChild (child.Merge (), overwrite);
- Report.Debug (2, " MERGING CHILD DONE", this, result);
- return result;
+ return CurrentUsageVector.MergeChild (child.Merge (), true);
}
- public virtual bool InTryWithCatch ()
+ public virtual bool CheckRethrow (Location loc)
{
- return Parent.InTryWithCatch ();
+ return Parent.CheckRethrow (loc);
+ }
+
+ public virtual bool AddResumePoint (ResumableStatement stmt, Location loc, out int pc)
+ {
+ return Parent.AddResumePoint (stmt, loc, out pc);
}
// returns true if we crossed an unwind-protected region (try/catch/finally, lock, using, ...)
}
// returns true if we crossed an unwind-protected region (try/catch/finally, lock, using, ...)
- public virtual bool AddReturnOrigin (UsageVector vector, Location loc)
+ public virtual bool AddReturnOrigin (UsageVector vector, ExitStatement stmt)
{
- return Parent.AddReturnOrigin (vector, loc);
+ return Parent.AddReturnOrigin (vector, stmt);
}
// returns true if we crossed an unwind-protected region (try/catch/finally, lock, using, ...)
return Parent.AddGotoOrigin (vector, goto_stmt);
}
- // returns true if we crossed an unwind-protected region (try/catch/finally, lock, using, ...)
- public virtual bool StealFinallyClauses (ref ArrayList list)
- {
- return Parent.StealFinallyClauses (ref list);
- }
-
public bool IsAssigned (VariableInfo vi)
{
return CurrentUsageVector.IsAssigned (vi, false);
return CurrentUsageVector.IsAssigned (vi, false) || CurrentUsageVector.IsFieldAssigned (vi, field_name);
}
+ protected static Report Report {
+ get { return RootContext.ToplevelTypes.Compiler.Report; }
+ }
+
public void SetAssigned (VariableInfo vi)
{
CurrentUsageVector.SetAssigned (vi);
protected override void AddSibling (UsageVector sibling)
{
+ if (sibling_list != null && sibling_list.Type == SiblingType.Block)
+ throw new InternalErrorException ("Blocks don't have sibling flow paths");
sibling.Next = sibling_list;
sibling_list = sibling;
}
return false;
}
- public static void Error_UnknownLabel (Location loc, string label)
+ public static void Error_UnknownLabel (Location loc, string label, Report Report)
{
Report.Error(159, loc, "The label `{0}:' could not be found within the scope of the goto statement",
label);
}
}
+ public class FlowBranchingIterator : FlowBranchingBlock
+ {
+ Iterator iterator;
+ public FlowBranchingIterator (FlowBranching parent, Iterator iterator)
+ : base (parent, BranchingType.Iterator, SiblingType.Block, null, iterator.Location)
+ {
+ this.iterator = iterator;
+ }
+
+ public override bool AddResumePoint (ResumableStatement stmt, Location loc, out int pc)
+ {
+ pc = iterator.AddResumePoint (stmt);
+ return false;
+ }
+ }
+
public class FlowBranchingToplevel : FlowBranchingBlock
{
UsageVector return_origins;
{
}
- public override bool InTryWithCatch ()
+ public override bool CheckRethrow (Location loc)
{
+ Report.Error (156, loc, "A throw statement with no arguments is not allowed outside of a catch clause");
return false;
}
+ public override bool AddResumePoint (ResumableStatement stmt, Location loc, out int pc)
+ {
+ throw new InternalErrorException ("A yield in a non-iterator block");
+ }
+
public override bool AddBreakOrigin (UsageVector vector, Location loc)
{
Report.Error (139, loc, "No enclosing loop out of which to break or continue");
return false;
}
- public override bool AddReturnOrigin (UsageVector vector, Location loc)
+ public override bool AddReturnOrigin (UsageVector vector, ExitStatement stmt)
{
vector = vector.Clone ();
- vector.Location = loc;
+ vector.Location = stmt.loc;
vector.Next = return_origins;
return_origins = vector;
return false;
}
- public override bool StealFinallyClauses (ref ArrayList list)
- {
- return false;
- }
-
public override bool AddGotoOrigin (UsageVector vector, Goto goto_stmt)
{
string name = goto_stmt.Target;
throw new InternalErrorException ("Shouldn't get here");
if (Parent == null) {
- Error_UnknownLabel (goto_stmt.loc, name);
+ Error_UnknownLabel (goto_stmt.loc, name, Report);
return false;
}
}
}
+ public class FlowBranchingTryCatch : FlowBranchingBlock
+ {
+ TryCatch stmt;
+ public FlowBranchingTryCatch (FlowBranching parent, TryCatch stmt)
+ : base (parent, BranchingType.Block, SiblingType.Try, null, stmt.loc)
+ {
+ this.stmt = stmt;
+ }
+
+ public override bool CheckRethrow (Location loc)
+ {
+ return CurrentUsageVector.Next != null || Parent.CheckRethrow (loc);
+ }
+
+ public override bool AddResumePoint (ResumableStatement stmt, Location loc, out int pc)
+ {
+ int errors = Report.Errors;
+ Parent.AddResumePoint (stmt, loc, out pc);
+ if (errors == Report.Errors) {
+ if (CurrentUsageVector.Next == null)
+ Report.Error (1626, loc, "Cannot yield a value in the body of a try block with a catch clause");
+ else
+ Report.Error (1631, loc, "Cannot yield a value in the body of a catch clause");
+ }
+ return true;
+ }
+
+ public override bool AddBreakOrigin (UsageVector vector, Location loc)
+ {
+ Parent.AddBreakOrigin (vector, loc);
+ stmt.SomeCodeFollows ();
+ return true;
+ }
+
+ public override bool AddContinueOrigin (UsageVector vector, Location loc)
+ {
+ Parent.AddContinueOrigin (vector, loc);
+ stmt.SomeCodeFollows ();
+ return true;
+ }
+
+ public override bool AddReturnOrigin (UsageVector vector, ExitStatement exit_stmt)
+ {
+ Parent.AddReturnOrigin (vector, exit_stmt);
+ stmt.SomeCodeFollows ();
+ return true;
+ }
+
+ public override bool AddGotoOrigin (UsageVector vector, Goto goto_stmt)
+ {
+ Parent.AddGotoOrigin (vector, goto_stmt);
+ return true;
+ }
+ }
+
public class FlowBranchingException : FlowBranching
{
ExceptionStatement stmt;
UsageVector current_vector;
- UsageVector catch_vectors;
+ UsageVector try_vector;
UsageVector finally_vector;
- UsageVector break_origins;
- UsageVector continue_origins;
- UsageVector return_origins;
- GotoOrigin goto_origins;
-
- class GotoOrigin {
- public GotoOrigin Next;
- public Goto GotoStmt;
- public UsageVector Vector;
+ abstract class SavedOrigin {
+ public readonly SavedOrigin Next;
+ public readonly UsageVector Vector;
- public GotoOrigin (UsageVector vector, Goto goto_stmt, GotoOrigin next)
+ protected SavedOrigin (SavedOrigin next, UsageVector vector)
{
- Vector = vector;
- GotoStmt = goto_stmt;
Next = next;
+ Vector = vector.Clone ();
+ }
+
+ protected abstract void DoPropagateFinally (FlowBranching parent);
+ public void PropagateFinally (UsageVector finally_vector, FlowBranching parent)
+ {
+ if (finally_vector != null)
+ Vector.MergeChild (finally_vector, false);
+ DoPropagateFinally (parent);
+ }
+ }
+
+ class BreakOrigin : SavedOrigin {
+ Location Loc;
+ public BreakOrigin (SavedOrigin next, UsageVector vector, Location loc)
+ : base (next, vector)
+ {
+ Loc = loc;
+ }
+
+ protected override void DoPropagateFinally (FlowBranching parent)
+ {
+ parent.AddBreakOrigin (Vector, Loc);
+ }
+ }
+
+ class ContinueOrigin : SavedOrigin {
+ Location Loc;
+ public ContinueOrigin (SavedOrigin next, UsageVector vector, Location loc)
+ : base (next, vector)
+ {
+ Loc = loc;
+ }
+
+ protected override void DoPropagateFinally (FlowBranching parent)
+ {
+ parent.AddContinueOrigin (Vector, Loc);
}
}
- bool emit_finally;
+ class ReturnOrigin : SavedOrigin {
+ public ExitStatement Stmt;
+
+ public ReturnOrigin (SavedOrigin next, UsageVector vector, ExitStatement stmt)
+ : base (next, vector)
+ {
+ Stmt = stmt;
+ }
+
+ protected override void DoPropagateFinally (FlowBranching parent)
+ {
+ parent.AddReturnOrigin (Vector, Stmt);
+ }
+ }
+
+ class GotoOrigin : SavedOrigin {
+ public Goto Stmt;
+
+ public GotoOrigin (SavedOrigin next, UsageVector vector, Goto stmt)
+ : base (next, vector)
+ {
+ Stmt = stmt;
+ }
+
+ protected override void DoPropagateFinally (FlowBranching parent)
+ {
+ parent.AddGotoOrigin (Vector, Stmt);
+ }
+ }
+
+ SavedOrigin saved_origins;
public FlowBranchingException (FlowBranching parent,
ExceptionStatement stmt)
null, stmt.loc)
{
this.stmt = stmt;
- this.emit_finally = true;
}
protected override void AddSibling (UsageVector sibling)
{
switch (sibling.Type) {
case SiblingType.Try:
- case SiblingType.Catch:
- sibling.Next = catch_vectors;
- catch_vectors = sibling;
+ try_vector = sibling;
break;
case SiblingType.Finally:
finally_vector = sibling;
get { return current_vector; }
}
- public override bool InTryWithCatch ()
+ public override bool CheckRethrow (Location loc)
{
- if (finally_vector == null) {
- Try t = stmt as Try;
- if (t != null && t.HasCatch)
- return true;
- }
+ if (!Parent.CheckRethrow (loc))
+ return false;
+ if (finally_vector == null)
+ return true;
+ Report.Error (724, loc, "A throw statement with no arguments is not allowed inside of a finally clause nested inside of the innermost catch clause");
+ return false;
+ }
- return base.InTryWithCatch ();
+ public override bool AddResumePoint (ResumableStatement stmt, Location loc, out int pc)
+ {
+ int errors = Report.Errors;
+ Parent.AddResumePoint (this.stmt, loc, out pc);
+ if (errors == Report.Errors) {
+ if (finally_vector == null)
+ this.stmt.AddResumePoint (stmt, pc);
+ else
+ Report.Error (1625, loc, "Cannot yield in the body of a finally clause");
+ }
+ return true;
}
public override bool AddBreakOrigin (UsageVector vector, Location loc)
{
- vector = vector.Clone ();
if (finally_vector != null) {
- vector.MergeChild (finally_vector, false);
int errors = Report.Errors;
Parent.AddBreakOrigin (vector, loc);
if (errors == Report.Errors)
Report.Error (157, loc, "Control cannot leave the body of a finally clause");
} else {
- vector.Location = loc;
- vector.Next = break_origins;
- break_origins = vector;
+ saved_origins = new BreakOrigin (saved_origins, vector, loc);
}
+
+ // either the loop test or a back jump will follow code
+ stmt.SomeCodeFollows ();
return true;
}
public override bool AddContinueOrigin (UsageVector vector, Location loc)
{
- vector = vector.Clone ();
if (finally_vector != null) {
- vector.MergeChild (finally_vector, false);
int errors = Report.Errors;
Parent.AddContinueOrigin (vector, loc);
if (errors == Report.Errors)
Report.Error (157, loc, "Control cannot leave the body of a finally clause");
} else {
- vector.Location = loc;
- vector.Next = continue_origins;
- continue_origins = vector;
+ saved_origins = new ContinueOrigin (saved_origins, vector, loc);
}
+
+ // either the loop test or a back jump will follow code
+ stmt.SomeCodeFollows ();
return true;
}
- public override bool AddReturnOrigin (UsageVector vector, Location loc)
+ public override bool AddReturnOrigin (UsageVector vector, ExitStatement exit_stmt)
{
- vector = vector.Clone ();
if (finally_vector != null) {
- vector.MergeChild (finally_vector, false);
int errors = Report.Errors;
- Parent.AddReturnOrigin (vector, loc);
+ Parent.AddReturnOrigin (vector, exit_stmt);
if (errors == Report.Errors)
- Report.Error (157, loc, "Control cannot leave the body of a finally clause");
+ exit_stmt.Error_FinallyClause (Report);
} else {
- vector.Location = loc;
- vector.Next = return_origins;
- return_origins = vector;
+ saved_origins = new ReturnOrigin (saved_origins, vector, exit_stmt);
}
+
+ // sets ec.NeedReturnLabel()
+ stmt.SomeCodeFollows ();
return true;
}
if (s != null)
throw new InternalErrorException ("Shouldn't get here");
- vector = vector.Clone ();
if (finally_vector != null) {
- vector.MergeChild (finally_vector, false);
int errors = Report.Errors;
Parent.AddGotoOrigin (vector, goto_stmt);
if (errors == Report.Errors)
Report.Error (157, goto_stmt.loc, "Control cannot leave the body of a finally clause");
} else {
- goto_origins = new GotoOrigin (vector, goto_stmt, goto_origins);
+ saved_origins = new GotoOrigin (saved_origins, vector, goto_stmt);
}
return true;
}
- public override bool StealFinallyClauses (ref ArrayList list)
- {
- if (list == null)
- list = new ArrayList ();
- list.Add (stmt);
- emit_finally = false;
- base.StealFinallyClauses (ref list);
- return true;
- }
-
- public bool EmitFinally {
- get { return emit_finally; }
- }
-
protected override UsageVector Merge ()
{
- Report.Debug (2, " MERGING TRY/CATCH", Name);
- UsageVector vector = UsageVector.MergeSiblings (catch_vectors, Location);
- Report.Debug (2, " MERGING TRY/CATCH DONE", vector);
+ UsageVector vector = try_vector.Clone ();
if (finally_vector != null)
vector.MergeChild (finally_vector, false);
- for (UsageVector origin = break_origins; origin != null; origin = origin.Next) {
- if (finally_vector != null)
- origin.MergeChild (finally_vector, false);
- Parent.AddBreakOrigin (origin, origin.Location);
- }
-
- for (UsageVector origin = continue_origins; origin != null; origin = origin.Next) {
- if (finally_vector != null)
- origin.MergeChild (finally_vector, false);
- Parent.AddContinueOrigin (origin, origin.Location);
- }
-
- for (UsageVector origin = return_origins; origin != null; origin = origin.Next) {
- if (finally_vector != null)
- origin.MergeChild (finally_vector, false);
- Parent.AddReturnOrigin (origin, origin.Location);
- }
-
- for (GotoOrigin origin = goto_origins; origin != null; origin = origin.Next) {
- if (finally_vector != null)
- origin.Vector.MergeChild (finally_vector, false);
- Parent.AddGotoOrigin (origin.Vector, origin.GotoStmt);
- }
+ for (SavedOrigin origin = saved_origins; origin != null; origin = origin.Next)
+ origin.PropagateFinally (finally_vector, Parent);
return vector;
}
// </summary>
public class TypeInfo
{
- public readonly Type Type;
+ public readonly TypeSpec Type;
// <summary>
// Total number of bits a variable of this type consumes in the flow vector.
// </summary>
public TypeInfo[] SubStructInfo;
- protected readonly StructInfo struct_info;
- private static Hashtable type_hash = new Hashtable ();
+ readonly StructInfo struct_info;
+ private static Dictionary<TypeSpec, TypeInfo> type_hash;
+
+ static TypeInfo ()
+ {
+ Reset ();
+ }
+
+ public static void Reset ()
+ {
+ type_hash = new Dictionary<TypeSpec, TypeInfo> ();
+ StructInfo.field_type_hash = new Dictionary<TypeSpec, StructInfo> ();
+ }
- public static TypeInfo GetTypeInfo (Type type)
+ public static TypeInfo GetTypeInfo (TypeSpec type)
{
- TypeInfo info = (TypeInfo) type_hash [type];
- if (info != null)
+ TypeInfo info;
+ if (type_hash.TryGetValue (type, out info))
return info;
info = new TypeInfo (type);
public static TypeInfo GetTypeInfo (TypeContainer tc)
{
- TypeInfo info = (TypeInfo) type_hash [tc.TypeBuilder];
- if (info != null)
+ TypeInfo info;
+ if (type_hash.TryGetValue (tc.Definition, out info))
return info;
info = new TypeInfo (tc);
- type_hash.Add (tc.TypeBuilder, info);
+ type_hash.Add (tc.Definition, info);
return info;
}
- private TypeInfo (Type type)
+ private TypeInfo (TypeSpec type)
{
this.Type = type;
private TypeInfo (TypeContainer tc)
{
- this.Type = tc.TypeBuilder;
+ this.Type = tc.Definition;
struct_info = StructInfo.GetStructInfo (tc);
if (struct_info != null) {
}
}
- protected TypeInfo (StructInfo struct_info, int offset)
+ TypeInfo (StructInfo struct_info, int offset)
{
this.struct_info = struct_info;
this.Offset = offset;
// A struct's constructor must always assign all fields.
// This method checks whether it actually does so.
// </summary>
- public bool IsFullyInitialized (FlowBranching branching, VariableInfo vi, Location loc)
+ public bool IsFullyInitialized (BlockContext ec, VariableInfo vi, Location loc)
{
if (struct_info == null)
return true;
bool ok = true;
+ FlowBranching branching = ec.CurrentBranching;
for (int i = 0; i < struct_info.Count; i++) {
- FieldInfo field = struct_info.Fields [i];
+ var field = struct_info.Fields [i];
if (!branching.IsFieldAssigned (vi, field.Name)) {
- Report.Error (171, loc,
- "Field `{0}' must be fully assigned before control leaves the constructor",
- TypeManager.GetFullNameSignature (field));
+ if (field.MemberDefinition is Property.BackingField) {
+ ec.Report.Error (843, loc,
+ "An automatically implemented property `{0}' must be fully assigned before control leaves the constructor. Consider calling default contructor",
+ field.GetSignatureForError ());
+ } else {
+ ec.Report.Error (171, loc,
+ "Field `{0}' must be fully assigned before control leaves the constructor",
+ field.GetSignatureForError ());
+ }
ok = false;
}
}
Type, Offset, Length, TotalLength);
}
- protected class StructInfo {
- public readonly Type Type;
- public readonly FieldInfo[] Fields;
+ class StructInfo {
+ public readonly TypeSpec Type;
+ public readonly FieldSpec[] Fields;
public readonly TypeInfo[] StructFields;
public readonly int Count;
public readonly int CountPublic;
public readonly int TotalLength;
public readonly bool HasStructFields;
- private static Hashtable field_type_hash = new Hashtable ();
- private Hashtable struct_field_hash;
- private Hashtable field_hash;
+ public static Dictionary<TypeSpec, StructInfo> field_type_hash;
+ private Dictionary<string, TypeInfo> struct_field_hash;
+ private Dictionary<string, int> field_hash;
protected bool InTransit = false;
// Private constructor. To save memory usage, we only need to create one instance
// of this class per struct type.
- private StructInfo (Type type)
+ private StructInfo (TypeSpec type)
{
this.Type = type;
field_type_hash.Add (type, this);
- if (type is TypeBuilder) {
- TypeContainer tc = TypeManager.LookupTypeContainer (type);
+ TypeContainer tc = type.MemberDefinition as TypeContainer;
- ArrayList fields = null;
- if (tc != null)
- fields = tc.Fields;
+ var public_fields = new List<FieldSpec> ();
+ var non_public_fields = new List<FieldSpec> ();
- ArrayList public_fields = new ArrayList ();
- ArrayList non_public_fields = new ArrayList ();
+ if (tc != null) {
+ var fields = tc.Fields;
if (fields != null) {
foreach (FieldBase field in fields) {
if ((field.ModFlags & Modifiers.STATIC) != 0)
continue;
if ((field.ModFlags & Modifiers.PUBLIC) != 0)
- public_fields.Add (field.FieldBuilder);
+ public_fields.Add (field.Spec);
else
- non_public_fields.Add (field.FieldBuilder);
+ non_public_fields.Add (field.Spec);
}
}
+ }
- CountPublic = public_fields.Count;
- CountNonPublic = non_public_fields.Count;
- Count = CountPublic + CountNonPublic;
+ CountPublic = public_fields.Count;
+ CountNonPublic = non_public_fields.Count;
+ Count = CountPublic + CountNonPublic;
- 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 FieldSpec[Count];
+ public_fields.CopyTo (Fields, 0);
+ non_public_fields.CopyTo (Fields, CountPublic);
- Fields = new FieldInfo [0];
-#endif
- } else {
- FieldInfo[] public_fields = type.GetFields (
- BindingFlags.Instance|BindingFlags.Public);
- FieldInfo[] non_public_fields = type.GetFields (
- BindingFlags.Instance|BindingFlags.NonPublic);
-
- CountPublic = public_fields.Length;
- CountNonPublic = non_public_fields.Length;
- Count = CountPublic + CountNonPublic;
-
- Fields = new FieldInfo [Count];
- public_fields.CopyTo (Fields, 0);
- non_public_fields.CopyTo (Fields, CountPublic);
- }
-
- struct_field_hash = new Hashtable ();
- field_hash = new Hashtable ();
+ struct_field_hash = new Dictionary<string, TypeInfo> ();
+ field_hash = new Dictionary<string, int> ();
Length = 0;
StructFields = new TypeInfo [Count];
InTransit = true;
for (int i = 0; i < Count; i++) {
- FieldInfo field = (FieldInfo) Fields [i];
+ var field = Fields [i];
- sinfo [i] = GetStructInfo (field.FieldType);
+ sinfo [i] = GetStructInfo (field.MemberType);
if (sinfo [i] == null)
field_hash.Add (field.Name, ++Length);
else if (sinfo [i].InTransit) {
- Report.Error (523, String.Format (
- "Struct member `{0}.{1}' of type `{2}' causes " +
- "a cycle in the structure layout",
- type, field.Name, sinfo [i].Type));
sinfo [i] = null;
return;
}
TotalLength = Length + 1;
for (int i = 0; i < Count; i++) {
- FieldInfo field = (FieldInfo) Fields [i];
+ var field = Fields [i];
if (sinfo [i] == null)
continue;
public int this [string name] {
get {
- if (field_hash.Contains (name))
- return (int) field_hash [name];
- else
+ int val;
+ if (!field_hash.TryGetValue (name, out val))
return 0;
+
+ return val;
}
}
public TypeInfo GetStructField (string name)
{
- return (TypeInfo) struct_field_hash [name];
+ TypeInfo ti;
+ if (struct_field_hash.TryGetValue (name, out ti))
+ return ti;
+
+ return null;
}
- public static StructInfo GetStructInfo (Type type)
+ public static StructInfo GetStructInfo (TypeSpec type)
{
if (!TypeManager.IsValueType (type) || TypeManager.IsEnumType (type) ||
TypeManager.IsBuiltinType (type))
return null;
- StructInfo info = (StructInfo) field_type_hash [type];
- if (info != null)
+ if (TypeManager.IsGenericParameter (type))
+ return null;
+
+ StructInfo info;
+ if (field_type_hash.TryGetValue (type, out info))
return info;
return new StructInfo (type);
public static StructInfo GetStructInfo (TypeContainer tc)
{
- StructInfo info = (StructInfo) field_type_hash [tc.TypeBuilder];
- if (info != null)
+ StructInfo info;
+ if (field_type_hash.TryGetValue (tc.Definition, out info))
return info;
- return new StructInfo (tc.TypeBuilder);
+ return new StructInfo (tc.Definition);
}
}
}
readonly VariableInfo Parent;
VariableInfo[] sub_info;
- protected VariableInfo (string name, Type type, int offset)
+ bool is_ever_assigned;
+ public bool IsEverAssigned {
+ get { return is_ever_assigned; }
+ }
+
+ protected VariableInfo (string name, TypeSpec type, int offset)
{
this.Name = name;
this.Offset = offset;
this.IsParameter = false;
}
- public VariableInfo (Parameters ip, int i, int offset)
- : this (ip.ParameterName (i), TypeManager.GetElementType (ip.ParameterType (i)), offset)
+ public VariableInfo (ParametersCompiled ip, int i, int offset)
+ : this (ip.FixedParameters [i].Name, ip.Types [i], offset)
{
this.IsParameter = true;
}
- public bool IsAssigned (EmitContext ec)
+ public bool IsAssigned (ResolveContext ec)
{
return !ec.DoFlowAnalysis ||
ec.OmitStructFlowAnalysis && TypeInfo.IsStruct ||
ec.CurrentBranching.IsAssigned (this);
}
- public bool IsAssigned (EmitContext ec, Location loc)
+ public bool IsAssigned (ResolveContext ec, Location loc)
{
if (IsAssigned (ec))
return true;
- Report.Error (165, loc,
+ ec.Report.Error (165, loc,
"Use of unassigned local variable `" + Name + "'");
ec.CurrentBranching.SetAssigned (this);
return false;
}
vector [Offset] = true;
+ is_ever_assigned = true;
return true;
}
- public void SetAssigned (EmitContext ec)
+ public void SetAssigned (ResolveContext ec)
{
if (ec.DoFlowAnalysis)
ec.CurrentBranching.SetAssigned (this);
vector [Offset] = true;
else
vector.SetRange (Offset, Length);
+ is_ever_assigned = true;
}
- public bool IsFieldAssigned (EmitContext ec, string name, Location loc)
+ public bool IsFieldAssigned (ResolveContext ec, string name, Location loc)
{
if (!ec.DoFlowAnalysis ||
ec.OmitStructFlowAnalysis && TypeInfo.IsStruct ||
ec.CurrentBranching.IsFieldAssigned (this, name))
return true;
- Report.Error (170, loc,
+ ec.Report.Error (170, loc,
"Use of possibly unassigned field `" + name + "'");
ec.CurrentBranching.SetFieldAssigned (this, name);
return false;
return vector [Offset + field_idx];
}
- public void SetFieldAssigned (EmitContext ec, string name)
+ public void SetFieldAssigned (ResolveContext ec, string name)
{
if (ec.DoFlowAnalysis)
ec.CurrentBranching.SetFieldAssigned (this, name);
return;
vector [Offset + field_idx] = true;
+ is_ever_assigned = true;
}
public VariableInfo GetSubStruct (string name)
// 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;
+ System.Collections.BitArray vector, shared;
MyBitVector ()
{
- shared = new BitArray (0, false);
+ shared = new System.Collections.BitArray (0, false);
}
public MyBitVector (MyBitVector InheritsFrom, int Count)
{
if (InheritsFrom != null)
- shared = InheritsFrom.Shared;
+ shared = InheritsFrom.MakeShared (Count);
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;
- }
- return shared;
+ System.Collections.BitArray MakeShared (int new_count)
+ {
+ // Post-condition: vector == null
+
+ // ensure we don't leak out dirty bits from the BitVector we inherited from
+ if (new_count > Count &&
+ ((shared != null && shared.Count > Count) ||
+ (shared == null && vector == null)))
+ initialize_vector ();
+
+ if (vector != null) {
+ shared = vector;
+ vector = null;
}
+
+ return shared;
}
// <summary>
public bool this [int index] {
get {
if (index >= Count)
- throw new ArgumentOutOfRangeException ();
+ // FIXME: Disabled due to missing anonymous method flow analysis
+ // throw new ArgumentOutOfRangeException ();
+ return true;
if (vector != null)
return vector [index];
if (Count == 0 || new_vector.Count == 0)
return this;
- BitArray o = new_vector.vector != null ? new_vector.vector : new_vector.shared;
+ var o = new_vector.vector != null ? new_vector.vector : new_vector.shared;
if (o == null) {
int n = new_vector.Count;
if (Count == 0)
return this;
- BitArray o = new_vector.vector != null ? new_vector.vector : new_vector.shared;
+ var o = new_vector.vector != null ? new_vector.vector : new_vector.shared;
if (o == null) {
for (int i = new_vector.Count; i < Count; ++i)
if (Count == o.Count) {
if (vector == null) {
if (shared == null) {
- shared = new_vector.Shared;
+ shared = new_vector.MakeShared (Count);
return this;
}
initialize_vector ();
// Don't clobber Empty
if (Count == 0)
return;
- shared = value ? null : Empty.Shared;
+ shared = value ? null : Empty.MakeShared (Count);
vector = null;
}
{
// Post-condition: vector != null
if (shared == null) {
- vector = new BitArray (Count, true);
+ vector = new System.Collections.BitArray (Count, true);
return;
}
- vector = new BitArray (shared);
+ vector = new System.Collections.BitArray (shared);
if (Count != vector.Count)
vector.Length = Count;
shared = null;
StringBuilder Dump (StringBuilder sb)
{
- BitArray dump = vector == null ? shared : vector;
+ var dump = vector == null ? shared : vector;
if (dump == null)
return sb.Append ("/");
if (dump == shared)
projects / mono.git / blobdiff