private int FindStartIndex(CFGBlock from)
{
//binary search
int l = 0;
int r = this.edges.Count;
while (l < r)
{
int median = (l + r) / 2;
int medianBlockIndex = this.edges [median].From.Index;
if (medianBlockIndex == from.Index)
{
while (median > 0 && this.edges [median - 1].From.Index == medianBlockIndex)
{
--median;
}
return(median);
}
if (medianBlockIndex < from.Index)
{
l = median + 1;
}
else
{
r = median;
}
}
return(this.edges.Count);
}
public bool TryGetContainingMethod(out Method method)
{
Sequence <Edge <CFGBlock, EdgeTag> > list = this.SubroutineContext;
CFGBlock block = this.Block;
while (block != null)
{
var mi = block.Subroutine as IMethodInfo;
if (mi != null)
{
method = mi.Method;
return(true);
}
if (list != null)
{
block = list.Head.From;
list = list.Tail;
}
else
{
block = null;
}
}
method = default(Method);
return(false);
}
Sequence <Pair <EdgeTag, Subroutine> > IEdgeSubroutineAdaptor.GetOrdinaryEdgeSubroutinesInternal(
CFGBlock @from, CFGBlock to,
Sequence <Edge <CFGBlock, EdgeTag> > context)
{
return(DecoratorHelper.Inner <IEdgeSubroutineAdaptor> (this)
.GetOrdinaryEdgeSubroutinesInternal(from, to, context).Where(
(pair) => !pair.Value.IsContract && !pair.Value.IsOldValue));
}
public abstract void AddEdgeSubroutine(CFGBlock from, CFGBlock to, Subroutine subroutine, EdgeTag tag);
public abstract bool IsSplitPoint(CFGBlock block);
public abstract bool IsJoinPoint(CFGBlock block);
IEnumerable <Pair <Tag, CFGBlock> > IGraph <CFGBlock, Tag> .Successors(CFGBlock node)
{
return(this [node]);
}
public abstract IEnumerable <CFGBlock> ExceptionHandlers <Data, Type> (CFGBlock block, Subroutine innerSubroutine,
Data data, IHandlerFilter <Data> handlerPredicate);
public abstract Sequence <Pair <EdgeTag, Subroutine> > EdgeSubroutinesOuterToInner(CFGBlock current, CFGBlock succ, out bool isExceptionHandlerEdge, Sequence <Edge <CFGBlock, EdgeTag> > context);
public abstract bool IsCatchFilterHeader(CFGBlock block);
public APC(CFGBlock block, int index, Sequence <Edge <CFGBlock, EdgeTag> > subroutineContext)
{
this.Block = block;
this.Index = index;
this.SubroutineContext = subroutineContext;
}
public static APC ForStart(CFGBlock block, Sequence <Edge <CFGBlock, EdgeTag> > subroutineContext)
{
return(new APC(block, 0, subroutineContext));
}
public static APC ForEnd(CFGBlock block, Sequence <Edge <CFGBlock, EdgeTag> > subroutineContext)
{
return(new APC(block, block.Count, subroutineContext));
}
public abstract LispList <Pair <EdgeTag, Subroutine> > GetOrdinaryEdgeSubroutines(CFGBlock current, CFGBlock succ, LispList <Edge <CFGBlock, EdgeTag> > context);
public abstract bool IsSubroutineEnd(CFGBlock block);
public abstract bool IsSubroutineStart(CFGBlock block);
bool IsJoinPoint(CFGBlock block)
{
return(block.Subroutine.IsJoinPoint(block));
}
public abstract APC ComputeTargetFinallyContext(APC pc, CFGBlock succ);
public IEnumerable <Pair <EdgeTag, CFGBlock> > SuccessorEdgesFor(CFGBlock block)
{
return(SuccessorEdges [block]);
}
public abstract Sequence <Pair <EdgeTag, Subroutine> > GetOrdinaryEdgeSubroutines(CFGBlock current, CFGBlock succ, Sequence <Edge <CFGBlock, EdgeTag> > context);
public abstract IEnumerable <CFGBlock> PredecessorBlocks(CFGBlock block);
private bool IsSplitPoint(CFGBlock block)
{
return(block.Subroutine.IsSplitPoint(block));
}
public ICollection <Pair <Tag, CFGBlock> > this [CFGBlock node]
{
get { return(new Successors(this, FindStartIndex(node))); }
}