/// <summary>
/// Prepares operation for every descendant index of target array.
/// </summary>
/// <param name="operation">The operation.</param>
/// <returns>Array where the input arrays is merged into.</returns>
private void mergeArrays(MergeOperation operation)
{
AssociativeArray targetArray = Structure.GetArray(operation.TargetIndex);
ArrayDescriptor targetDescriptor = Structure.GetDescriptor(targetArray);
ContainerOperations collectIndexes = new ContainerOperations(this, targetDescriptor.Builder(), operation.TargetIndex, targetDescriptor.UnknownIndex);
foreach (var operationData in operation.Indexes)
{
MemoryIndex index = operationData.Item1;
Snapshot snapshot = operationData.Item2;
AssociativeArray arrayValue;
if (snapshot.Structure.TryGetArray(index, out arrayValue))
{
ArrayDescriptor descriptor = snapshot.Structure.GetDescriptor(arrayValue);
collectIndexes.AddContainer(descriptor, snapshot);
}
else
{
collectIndexes.SetUndefined();
}
}
collectIndexes.MergeContainers();
}
/// <summary>
/// Creates the merge operation for all fields of specified object.
/// </summary>
/// <param name="objectValue">The object value.</param>
private void mergeObject(ObjectValue objectValue)
{
ObjectDescriptorBuilder builder =
new ObjectDescriptor(objectValue, null, ObjectIndex.CreateUnknown(objectValue))
.Builder();
ContainerOperations collectVariables = new ContainerOperations(this, builder, builder.UnknownIndex, builder.UnknownIndex);
foreach (Snapshot snapshot in sourceSnapshots)
{
ObjectDescriptor descriptor;
if (snapshot.Structure.TryGetDescriptor(objectValue, out descriptor))
{
collectVariables.CollectIndexes(snapshot, builder.UnknownIndex, descriptor);
builder.Type = descriptor.Type;
}
else
{
collectVariables.SetUndefined();
}
}
collectVariables.MergeContainers();
Structure.ObjectDescriptors.Add(objectValue, builder.Build());
}
/// <summary>
/// Prepares operation for every descendant index and merge the array into one which will be
/// stored in the target memory entry.
/// </summary>
/// <param name="operation">The operation.</param>
/// <returns>Array where the input arrays is merged into.</returns>
private Value mergeArrays(MergeOperation operation)
{
ArrayDescriptorBuilder builder = new ArrayDescriptorBuilder();
builder.SetParentVariable(operation.TargetIndex);
builder.SetUnknownField(operation.TargetIndex.CreateUnknownIndex());
ContainerOperations collectVariables = new ContainerOperations(this, builder, operation.TargetIndex, builder.UnknownIndex);
// Collecting possible indexes of merged array
AssociativeArray targetArray = null;
foreach (var operationData in operation.Indexes)
{
MemoryIndex index = operationData.Item1;
Snapshot snapshot = operationData.Item2;
AssociativeArray arrayValue;
if (snapshot.Structure.TryGetArray(index, out arrayValue))
{
// Target array value will be the firs one
if (targetArray == null)
{
if (index.Equals(operation.TargetIndex))
{
targetArray = arrayValue;
}
}
ArrayDescriptor descriptor = snapshot.Structure.GetDescriptor(arrayValue);
collectVariables.CollectIndexes(snapshot, index, descriptor);
}
else
{
collectVariables.SetUndefined();
}
}
if (targetArray == null)
{
targetArray = targetSnapshot.CreateArray();
}
builder.SetArrayValue(targetArray);
collectVariables.MergeContainers();
Structure.SetArray(operation.TargetIndex, targetArray);
Structure.SetDescriptor(targetArray, builder.Build());
return(targetArray);
}
/// <summary>
/// Main method of merge algorithm.
///
/// iI first phase prepares new empty data collection. Then collects all root memory locations and
/// prepares their operations. As the final step process all merge operations which traverses the
/// memory tree and merges data from all source indexes.
/// </summary>
internal void Merge()
{
ContainerOperations[] collectVariables = new ContainerOperations[targetSnapshot.CallLevel + 1];
ContainerOperations[] collectControl = new ContainerOperations[targetSnapshot.CallLevel + 1];
MergeOperation returnOperation = new MergeOperation();
for (int x = 0; x <= targetSnapshot.CallLevel; x++)
{
IndexContainer variables = Structure.Variables[x];
collectVariables[x] = new ContainerOperations(this, variables, variables.UnknownIndex, variables.UnknownIndex);
IndexContainer control = Structure.ContolVariables[x];
collectControl[x] = new ContainerOperations(this, control, control.UnknownIndex, control.UnknownIndex);
}
foreach (Snapshot snapshot in sourceSnapshots)
{
for (int sourceLevel = 0, targetLevel = 0; targetLevel <= targetSnapshot.CallLevel; sourceLevel++, targetLevel++)
{
if (sourceLevel == snapshot.CallLevel && snapshot.CallLevel != targetSnapshot.CallLevel)
{
if (isCallMerge)
{
break;
}
else
{
targetLevel = targetSnapshot.CallLevel;
}
}
collectVariables[targetLevel].AddContainer(snapshot.Structure.Variables[sourceLevel], snapshot);
collectControl[targetLevel].AddContainer(snapshot.Structure.ContolVariables[sourceLevel], snapshot);
}
}
mergeObjects();
for (int x = 0; x <= targetSnapshot.CallLevel; x++)
{
collectVariables[x].MergeContainers();
collectControl[x].MergeContainers();
mergeTemporary(x);
}
processMerge();
}
/// <summary>
/// Creates the merge operation for all fields of specified object.
/// </summary>
/// <param name="objectValue">The object value.</param>
private void mergeObject(ObjectValue objectValue)
{
ObjectDescriptor targetDescriptor = Structure.GetDescriptor(objectValue);
ContainerOperations collectVariables = new ContainerOperations(this, targetDescriptor.Builder(), targetDescriptor.UnknownIndex, targetDescriptor.UnknownIndex);
foreach (Snapshot snapshot in sourceSnapshots)
{
ObjectDescriptor descriptor;
if (snapshot.Structure.TryGetDescriptor(objectValue, out descriptor))
{
collectVariables.AddContainer(descriptor, snapshot);
}
else
{
collectVariables.SetUndefined();
}
}
collectVariables.MergeContainers();
}
/// <summary>
/// Main method of merge algorithm.
///
/// in first phase prepares new empty structure and data collections. Then collects all root memory locations
/// and prepares their operations. As the final step process all merge operations which traverses the memory tree
/// and creates new memory locations in target structure with the data from all source indexes.
/// </summary>
internal void Merge()
{
ContainerOperations[] collectVariables = new ContainerOperations[targetSnapshot.CallLevel + 1];
ContainerOperations[] collectControl = new ContainerOperations[targetSnapshot.CallLevel + 1];
MergeOperation returnOperation = new MergeOperation();
// Prepares empty structure for target snapshot
for (int x = 0; x <= targetSnapshot.CallLevel; x++)
{
IndexContainer variables = new IndexContainer(VariableIndex.CreateUnknown(x));
Structure.Variables[x] = variables;
collectVariables[x] = new ContainerOperations(this, variables, variables.UnknownIndex, variables.UnknownIndex);
IndexContainer control = new IndexContainer(ControlIndex.CreateUnknown(x));
Structure.ContolVariables[x] = control;
collectControl[x] = new ContainerOperations(this, control, control.UnknownIndex, control.UnknownIndex);
Structure.Temporary[x] = new IndexSet <TemporaryIndex>();
Structure.Arrays[x] = new IndexSet <AssociativeArray>();
}
// Collects all objects and root locations from the source objects
foreach (Snapshot snapshot in sourceSnapshots)
{
collectObjects(snapshot);
for (int sourceLevel = 0, targetLevel = 0; targetLevel <= targetSnapshot.CallLevel; sourceLevel++, targetLevel++)
{
// Local levels of snaphot has to be merged together no matter to call level of each snapshot.
if (sourceLevel == snapshot.CallLevel && snapshot.CallLevel != targetSnapshot.CallLevel)
{
if (isCallMerge)
{
// When this is the call merge the local level is forgotten
break;
}
else
{
targetLevel = targetSnapshot.CallLevel;
}
}
// Gets all root locations
collectVariables[targetLevel].CollectIndexes(snapshot, Structure.Variables[targetLevel].UnknownIndex, snapshot.Structure.Variables[sourceLevel]);
collectControl[targetLevel].CollectIndexes(snapshot, Structure.ContolVariables[targetLevel].UnknownIndex, snapshot.Structure.ContolVariables[sourceLevel]);
collectTemporary(snapshot, sourceLevel, targetLevel);
}
mergeDeclarations(Structure.FunctionDecl, snapshot.Structure.FunctionDecl);
mergeDeclarations(Structure.ClassDecl, snapshot.Structure.ClassDecl);
// When is it call merge remember which arrays was forgotten in order to support arrays in returns
if (isCallMerge)
{
foreach (AssociativeArray array in snapshot.Structure.Arrays.Local)
{
Structure.AddCallArray(array, snapshot);
}
}
}
mergeObjects();
// Prepares operations for all root locations
for (int x = 0; x <= targetSnapshot.CallLevel; x++)
{
collectVariables[x].MergeContainers();
collectControl[x].MergeContainers();
mergeTemporary(x);
}
processMerge();
// Build aliases
foreach (var alias in memoryAliases)
{
Structure.SetAlias(alias.Key, alias.Value.Build());
}
}
