/// <summary>
/// Tests the and create implicit object.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="values">The values.</param>
private void testAndCreateImplicitObject(MemoryCollectorNode node, HashSet <Value> values)
{
if (node.HasNewImplicitObject)
{
ObjectValue value = Snapshot.MemoryAssistant.CreateImplicitObject();
values.Add(value);
IObjectValueContainerBuilder objectValues = Structure.GetObjects(node.TargetIndex).Builder(Structure);
objectValues.Add(value);
Structure.SetObjects(node.TargetIndex, objectValues.Build(Structure));
IObjectDescriptor oldDescriptor = Structure.GetDescriptor(value);
IObjectDescriptorBuilder builder = oldDescriptor.Builder(Structure);
foreach (var newChild in node.ImplicitObjectNode.UndefinedChildren)
{
string childName = newChild.Item1;
MemoryCollectorNode childNode = newChild.Item2;
MemoryIndex index = ObjectIndex.Create(value, childName);
childNode.TargetIndex = index;
builder.AddIndex(childName, index);
}
IObjectDescriptor newDescriptor = builder.Build(Structure);
Structure.SetDescriptor(value, newDescriptor);
enqueueChildNodes(node.ImplicitObjectNode);
}
}
/// <summary>
/// Tests the and create implicit array.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="values">The values.</param>
public void testAndCreateImplicitArray(MemoryCollectorNode node, ICollection <Value> values)
{
if (node.HasNewImplicitArray)
{
createArray(node, values);
}
}
/// <summary>
/// Processes the source array.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="arrayValue">The array value.</param>
/// <param name="values">The values.</param>
private void processSourceArray(MemoryCollectorNode node, AssociativeArray arrayValue, ICollection <Value> values)
{
if (arrayValue != null)
{
IArrayDescriptor sourceArray = Structure.GetDescriptor(arrayValue);
if (node.AnyChildNode == null)
{
node.CreateMemoryIndexAnyChild(sourceArray.UnknownIndex);
}
foreach (var item in sourceArray.Indexes)
{
string name = item.Key;
MemoryIndex index = item.Value;
if (!node.NamedChildNodes.ContainsKey(name))
{
LocationCollectorNode newChild = node.CreateMemoryIndexChildFromAny(name, sourceArray.UnknownIndex);
newChild.IsMust = node.IsMust;
}
}
createArray(node, values);
}
else
{
testAndCreateImplicitArray(node, values);
}
}
/// <summary>
/// Processes the source aliases.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="memoryAlias">The memory alias.</param>
private void processSourceAliases(MemoryCollectorNode node, IMemoryAlias memoryAlias)
{
if (memoryAlias != null && memoryAlias.HasAliases)
{
if (node.IsMust)
{
foreach (MemoryIndex alias in memoryAlias.MustAliases)
{
Snapshot.AddAlias(alias, node.TargetIndex, null);
}
foreach (MemoryIndex alias in memoryAlias.MayAliases)
{
Snapshot.AddAlias(alias, null, node.TargetIndex);
}
Snapshot.MustSetAliases(node.TargetIndex, memoryAlias.MustAliases, memoryAlias.MayAliases);
}
else
{
HashSet <MemoryIndex> aliases = new HashSet <MemoryIndex>();
CollectionMemoryUtils.AddAll(aliases, memoryAlias.MustAliases);
CollectionMemoryUtils.AddAll(aliases, memoryAlias.MayAliases);
foreach (MemoryIndex alias in aliases)
{
Snapshot.AddAlias(alias, null, node.TargetIndex);
}
Snapshot.MaySetAliases(node.TargetIndex, aliases);
}
}
}
/// <summary>
/// Processes the source objects.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="objects">The objects.</param>
private void processSourceObjects(MemoryCollectorNode node, IObjectValueContainer objects)
{
if (objects != null && objects.Count > 0)
{
IObjectValueContainer targetObjects = Factories.StructuralContainersFactories.ObjectValueContainerFactory.CreateObjectValueContainer(Structure, objects);
Structure.SetObjects(node.TargetIndex, targetObjects);
}
}
/// <summary>
/// Creates the array.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="values">The values.</param>
/// <returns>New created array</returns>
public AssociativeArray createArray(MemoryCollectorNode node, ICollection <Value> values)
{
AssociativeArray createdArrayValue = Snapshot.CreateArray(node.TargetIndex);
values.Add(createdArrayValue);
if (node.AnyChildNode != null)
{
IArrayDescriptor descriptor = Structure.GetDescriptor(createdArrayValue);
node.AnyChildNode.TargetIndex = descriptor.UnknownIndex;
}
return(createdArrayValue);
}
/// <summary>
/// Processes the variables.
/// </summary>
/// <param name="stackLevel">The stack level.</param>
/// <param name="node">The node.</param>
private void processVariables(int stackLevel, CollectorNode node)
{
if (node.HasUndefinedChildren)
{
IWriteableIndexContainer writeableVariableContainer = Structure.GetWriteableStackContext(stackLevel).WriteableVariables;
foreach (var newChild in node.UndefinedChildren)
{
string childName = newChild.Item1;
MemoryCollectorNode childNode = newChild.Item2;
MemoryIndex index = VariableIndex.Create(childName, stackLevel);
childNode.TargetIndex = index;
writeableVariableContainer.AddIndex(childName, index);
}
}
enqueueChildNodes(node);
}
/// <summary>
/// Processes the object.
/// </summary>
/// <param name="objectValue">The object value.</param>
/// <param name="node">The node.</param>
private void processObject(ObjectValue objectValue, ContainerCollectorNode node)
{
if (node.HasUndefinedChildren)
{
IObjectDescriptor oldDescriptor = Structure.GetDescriptor(objectValue);
IObjectDescriptorBuilder builder = oldDescriptor.Builder(Structure);
foreach (var newChild in node.UndefinedChildren)
{
string childName = newChild.Item1;
MemoryCollectorNode childNode = newChild.Item2;
MemoryIndex index = ObjectIndex.Create(objectValue, childName);
childNode.TargetIndex = index;
builder.AddIndex(childName, index);
}
IObjectDescriptor newDescriptor = builder.Build(Structure);
Structure.SetDescriptor(objectValue, newDescriptor);
}
enqueueChildNodes(node);
}
/// <summary>
/// Tests the and create undefined children.
/// </summary>
/// <param name="node">The node.</param>
private void testAndCreateUndefinedChildren(MemoryCollectorNode node)
{
if (node.HasUndefinedChildren)
{
AssociativeArray arrayValue = Structure.GetArray(node.TargetIndex);
IArrayDescriptor oldDescriptor = Structure.GetDescriptor(arrayValue);
IArrayDescriptorBuilder builder = oldDescriptor.Builder(Structure);
foreach (var newChild in node.UndefinedChildren)
{
string childName = newChild.Item1;
MemoryCollectorNode childNode = newChild.Item2;
MemoryIndex index = node.TargetIndex.CreateIndex(childName);
childNode.TargetIndex = index;
builder.AddIndex(childName, index);
}
IArrayDescriptor newDescriptor = builder.Build(Structure);
Structure.SetDescriptor(arrayValue, newDescriptor);
}
}
