/// <summary>
/// Processes the root indexes. This is the beginning of an computation which creates the root node from given sets of indexes.
/// Used to collect all data from aliased locations.
/// </summary>
/// <param name="mustIndexes">The must indexes.</param>
/// <param name="mayIndexes">The may indexes.</param>
/// <param name="values">The values.</param>
public void ProcessRootIndexes(HashSet <MemoryIndex> mustIndexes, HashSet <MemoryIndex> mayIndexes, IEnumerable <Value> values)
{
RootNode = new MemoryEntryCollectorNode();
RootNode.SourceIndexes = new List <SourceIndex>();
RootNode.IsMust = true;
foreach (MemoryIndex index in mustIndexes)
{
RootNode.SourceIndexes.Add(new SourceIndex(index, Snapshot));
RootNode.CollectAliases(index, Snapshot, true);
}
foreach (MemoryIndex index in mayIndexes)
{
RootNode.SourceIndexes.Add(new SourceIndex(index, Snapshot));
RootNode.CollectAliases(index, Snapshot, false);
}
RootNode.CollectValuesFromSources(this);
RootNode.VisitValues(values);
RootNode.CollectChildren(this);
processQueue();
RootMemoryEntry = RootNode.GenerateMemeoryEntry(values);
}
/// <summary>
/// Processes the root memory entry. This is the beginning of an computation which creates the root node from given memory entry.
/// </summary>
/// <param name="entry">The entry.</param>
public void ProcessRootMemoryEntry(MemoryEntry entry)
{
RootNode = new MemoryEntryCollectorNode();
RootNode.IsMust = true;
RootNode.CollectValuesFromMemoryEntry(entry);
RootNode.CollectChildren(this);
processQueue();
RootMemoryEntry = entry;
}
/// <summary>
/// Process all nodes stored in the queue to build the tree.
/// </summary>
private void processQueue()
{
while (collectingQueue.Count > 0)
{
MemoryEntryCollectorNode node = collectingQueue.First.Value;
collectingQueue.RemoveFirst();
node.CollectAliasesFromSources(this);
node.CollectValuesFromSources(this);
node.CollectChildren(this);
}
}
/// <summary>
/// Produce an empty node with no inner data an no childs. This node can be used as
/// an unknown node in the assign algorithm.
/// </summary>
/// <param name="snapshot">The snapshot.</param>
/// <returns>An empty node.</returns>
public static MemoryEntryCollectorNode GetEmptyNode(Snapshot snapshot)
{
if (emptyNode != null)
{
return(emptyNode);
}
else
{
emptyNode = new MemoryEntryCollectorNode();
emptyNode.ScalarValues = new HashSet <Value>();
emptyNode.ScalarValues.Add(snapshot.UndefinedValue);
return(emptyNode);
}
}
public void CollectChildren(MemoryEntryCollector collector)
{
if (Arrays != null && Arrays.Count > 0)
{
// Create new collection for named children
NamedChildren = new Dictionary <string, MemoryEntryCollectorNode>();
// Any child node
AnyChild = new MemoryEntryCollectorNode();
AnyChild.SourceIndexes = new List <SourceIndex>();
AnyChild.IsMust = false;
collector.AddNode(AnyChild);
// Collect child names and adds any child sources
HashSet <string> names = new HashSet <string>();
List <Tuple <Snapshot, IArrayDescriptor> > sourceDescriptors = new List <Tuple <Snapshot, IArrayDescriptor> >();
foreach (AssociativeArray arrayValue in Arrays)
{
var descriptors = getIArrayDescriptors(collector, arrayValue);
foreach (var tuple in descriptors)
{
sourceDescriptors.Add(tuple);
Snapshot sourceSnapshot = tuple.Item1;
IArrayDescriptor descriptor = tuple.Item2;
AnyChild.SourceIndexes.Add(new SourceIndex(descriptor.UnknownIndex, sourceSnapshot));
foreach (var item in descriptor.Indexes)
{
names.Add(item.Key);
}
}
}
// Test whether new array as MAY or MUST
bool mustHaveChildren = this.IsMust && mustHaveArray;
mustHaveChildren &= (ScalarValues == null || ScalarValues.Count == 0);
mustHaveChildren &= (Objects == null || Objects.Count == 0);
// Iterates collected names and stors them into the structure
foreach (string name in names)
{
MemoryEntryCollectorNode childNode = new MemoryEntryCollectorNode();
childNode.SourceIndexes = new List <SourceIndex>();
childNode.IsMust = mustHaveChildren;
collector.AddNode(childNode);
NamedChildren.Add(name, childNode);
// Collect sources for named child
foreach (var tuple in sourceDescriptors)
{
Snapshot sourceSnapshot = tuple.Item1;
IArrayDescriptor descriptor = tuple.Item2;
MemoryIndex index;
if (descriptor.TryGetIndex(name, out index))
{
childNode.SourceIndexes.Add(new SourceIndex(index, sourceSnapshot));
}
else
{
childNode.IsMust = false;
childNode.SourceIndexes.Add(new SourceIndex(descriptor.UnknownIndex, sourceSnapshot));
}
}
}
}
}
/// <summary>
/// Adds the node to the collecting queue.
/// </summary>
/// <param name="node">The node.</param>
public void AddNode(MemoryEntryCollectorNode node)
{
collectingQueue.AddLast(node);
}
