private void CheckForAssignment(AssignmentFlowNode node)
{
if(node.NodeState != AssignmentNodeState.Unknown)
{
return;
}
IList<Expression> expressions = expressionsData.BlockExpressions[node.CFGBlock.First.Offset];
foreach (Expression expression in expressions)
{
UsageFinderSearchResult searchResult = visitor.SearchForUsage(expression);
if (searchResult == UsageFinderSearchResult.Assigned)
{
node.NodeState = AssignmentNodeState.ContainsAssignment;
return;
}
else if (searchResult == UsageFinderSearchResult.Used)
{
node.NodeState = AssignmentNodeState.ContainsUsage;
return;
}
}
node.NodeState = AssignmentNodeState.NotAssigned;
}
private void CheckHandler(AssignmentFlowNode handlerEntry, AssignmentAnalyzer analyzer, ref AssignmentType result)
{
V_0 = analyzer.CheckAssignmentType(handlerEntry);
switch (V_0 - 1)
{
case 0:
case 2:
{
result = V_0;
break;
}
case 1:
{
if ((int)result == 3)
{
break;
}
result = V_0;
return;
}
default:
{
return;
}
}
return;
}
private void CheckForAssignment(AssignmentFlowNode node)
{
if (node.NodeState != AssignmentNodeState.Unknown)
{
return;
}
IList <Expression> expressions = expressionsData.BlockExpressions[node.CFGBlock.First.Offset];
foreach (Expression expression in expressions)
{
UsageFinderSearchResult searchResult = visitor.SearchForUsage(expression);
if (searchResult == UsageFinderSearchResult.Assigned)
{
node.NodeState = AssignmentNodeState.ContainsAssignment;
return;
}
else if (searchResult == UsageFinderSearchResult.Used)
{
node.NodeState = AssignmentNodeState.ContainsUsage;
return;
}
}
node.NodeState = AssignmentNodeState.NotAssigned;
}
protected AssignmentType AnalyzeAssignmentType(BaseUsageFinder usageFinder)
{
PrepareNodes();
AssignmentAnalyzer analyzer = new AssignmentAnalyzer(usageFinder, this.context.MethodContext.Expressions);
AssignmentType regularControlFlowResult = analyzer.CheckAssignmentType(mappedNodes[0]);
if (regularControlFlowResult == AssignmentType.NotAssigned)
{
return(AssignmentType.NotAssigned);
}
AssignmentType result = regularControlFlowResult;
List <ExceptionHandler> exceptionHandlers = new List <ExceptionHandler>(this.context.MethodContext.ControlFlowGraph.RawExceptionHandlers);
int initialCount;
do
{
initialCount = exceptionHandlers.Count;
for (int i = 0; i < exceptionHandlers.Count; i++)
{
ExceptionHandler handler = exceptionHandlers[i];
AssignmentFlowNode tryEntryNode = GetNodeFromBlockOffset(handler.TryStart.Offset);
if (tryEntryNode.NodeState == AssignmentNodeState.Unknown)
{
continue;
}
exceptionHandlers.RemoveAt(i--);
CheckHandler(GetNodeFromBlockOffset(handler.HandlerStart.Offset), analyzer, ref result);
if (result == AssignmentType.NotAssigned)
{
return(AssignmentType.NotAssigned);
}
if (handler.HandlerType != ExceptionHandlerType.Filter)
{
continue;
}
CheckHandler(GetNodeFromBlockOffset(handler.FilterStart.Offset), analyzer, ref result);
if (result == AssignmentType.NotAssigned)
{
return(AssignmentType.NotAssigned);
}
}
} while (initialCount != exceptionHandlers.Count);
return(result);
}
public AssignmentType CheckAssignmentType(AssignmentFlowNode entryNode)
{
int assignmentsCount = 0;
Queue<AssignmentFlowNode> traversalQueue = new Queue<AssignmentFlowNode>();
CheckForAssignment(entryNode);
if (entryNode.NodeState == AssignmentNodeState.ContainsAssignment)
{
return AssignmentType.SingleAssignment;
}
else if (entryNode.NodeState == AssignmentNodeState.ContainsUsage)
{
return AssignmentType.NotAssigned;
}
traversalQueue.Enqueue(entryNode);
while (traversalQueue.Count > 0)
{
AssignmentFlowNode currentNode = traversalQueue.Dequeue();
foreach (AssignmentFlowNode successor in currentNode.Successors)
{
if (successor.NodeState != AssignmentNodeState.Unknown)
{
continue;
}
CheckForAssignment(successor);
if (successor.NodeState == AssignmentNodeState.NotAssigned)
{
traversalQueue.Enqueue(successor);
}
else if (successor.NodeState == AssignmentNodeState.ContainsAssignment)
{
assignmentsCount++;
}
else if (successor.NodeState == AssignmentNodeState.ContainsUsage)
{
return AssignmentType.NotAssigned;
}
}
}
return assignmentsCount == 0 ? AssignmentType.NotUsed :
assignmentsCount == 1 ? AssignmentType.SingleAssignment : AssignmentType.MultipleAssignments;
}
public AssignmentType CheckAssignmentType(AssignmentFlowNode entryNode)
{
int assignmentsCount = 0;
Queue <AssignmentFlowNode> traversalQueue = new Queue <AssignmentFlowNode>();
CheckForAssignment(entryNode);
if (entryNode.NodeState == AssignmentNodeState.ContainsAssignment)
{
return(AssignmentType.SingleAssignment);
}
else if (entryNode.NodeState == AssignmentNodeState.ContainsUsage)
{
return(AssignmentType.NotAssigned);
}
traversalQueue.Enqueue(entryNode);
while (traversalQueue.Count > 0)
{
AssignmentFlowNode currentNode = traversalQueue.Dequeue();
foreach (AssignmentFlowNode successor in currentNode.Successors)
{
if (successor.NodeState != AssignmentNodeState.Unknown)
{
continue;
}
CheckForAssignment(successor);
if (successor.NodeState == AssignmentNodeState.NotAssigned)
{
traversalQueue.Enqueue(successor);
}
else if (successor.NodeState == AssignmentNodeState.ContainsAssignment)
{
assignmentsCount++;
}
else if (successor.NodeState == AssignmentNodeState.ContainsUsage)
{
return(AssignmentType.NotAssigned);
}
}
}
return(assignmentsCount == 0 ? AssignmentType.NotUsed :
assignmentsCount == 1 ? AssignmentType.SingleAssignment : AssignmentType.MultipleAssignments);
}
private void CheckHandler(AssignmentFlowNode handlerEntry, AssignmentAnalyzer analyzer, ref AssignmentType result)
{
AssignmentType handlerResult = analyzer.CheckAssignmentType(handlerEntry);
switch (handlerResult)
{
case AssignmentType.SingleAssignment:
if (result != AssignmentType.MultipleAssignments)
{
result = handlerResult;
}
break;
case AssignmentType.NotAssigned:
case AssignmentType.MultipleAssignments:
result = handlerResult;
break;
}
}
private void CheckForAssignment(AssignmentFlowNode node)
{
if (node.get_NodeState() != AssignmentNodeState.Unknown)
{
return;
}
V_0 = this.expressionsData.get_BlockExpressions().get_Item(node.get_CFGBlock().get_First().get_Offset()).GetEnumerator();
try
{
while (V_0.MoveNext())
{
V_1 = V_0.get_Current();
V_2 = this.visitor.SearchForUsage(V_1);
if (V_2 != 1)
{
if (V_2 != 2)
{
continue;
}
node.set_NodeState(3);
goto Label0;
}
else
{
node.set_NodeState(2);
goto Label0;
}
}
}
finally
{
if (V_0 != null)
{
V_0.Dispose();
}
}
node.set_NodeState(1);
Label0:
return;
}
public AssignmentType CheckAssignmentType(AssignmentFlowNode entryNode)
{
V_0 = 0;
V_1 = new Queue <AssignmentFlowNode>();
this.CheckForAssignment(entryNode);
if (entryNode.get_NodeState() == 2)
{
return(2);
}
if (entryNode.get_NodeState() == 3)
{
return(1);
}
V_1.Enqueue(entryNode);
while (V_1.get_Count() > 0)
{
V_2 = V_1.Dequeue().get_Successors().GetEnumerator();
try
{
while (V_2.MoveNext())
{
V_3 = V_2.get_Current();
if (V_3.get_NodeState() != AssignmentNodeState.Unknown)
{
continue;
}
this.CheckForAssignment(V_3);
if (V_3.get_NodeState() != 1)
{
if (V_3.get_NodeState() != 2)
{
if (V_3.get_NodeState() != 3)
{
continue;
}
V_4 = 1;
goto Label0;
}
else
{
V_0 = V_0 + 1;
}
}
else
{
V_1.Enqueue(V_3);
}
}
continue;
}
finally
{
if (V_2 != null)
{
V_2.Dispose();
}
}
Label0:
return(V_4);
}
if (V_0 == 0)
{
return(0);
}
if (V_0 != 1)
{
return(3);
}
return(2);
}
private void CheckHandler(AssignmentFlowNode handlerEntry, AssignmentAnalyzer analyzer, ref AssignmentType result)
{
AssignmentType handlerResult = analyzer.CheckAssignmentType(handlerEntry);
switch (handlerResult)
{
case AssignmentType.SingleAssignment:
if (result != AssignmentType.MultipleAssignments)
{
result = handlerResult;
}
break;
case AssignmentType.NotAssigned:
case AssignmentType.MultipleAssignments:
result = handlerResult;
break;
}
}
