/// <summary>
/// Assigns the must memory index.
/// </summary>
/// <param name="mustIndex">Index of the must.</param>
/// <param name="composedValues">The composed values.</param>
private void assignMust(MemoryIndex mustIndex, CollectComposedValuesVisitor composedValues)
{
IIndexDefinition data = snapshot.Structure.Readonly.GetIndexDefinition(mustIndex);
HashSet <Value> values = new HashSet <Value>(composedValues.Values);
if (snapshot.CurrentMode == SnapshotMode.MemoryLevel)
{
if (data.Array != null)
{
values.Add(data.Array);
}
if (composedValues.Objects.Count > 0)
{
IObjectValueContainer objects = Factories.StructuralContainersFactories.ObjectValueContainerFactory.CreateObjectValueContainer(snapshot.Structure.Writeable, composedValues.Objects);
snapshot.Structure.Writeable.SetObjects(mustIndex, objects);
if (data.Objects != null)
{
CollectionMemoryUtils.AddAll(values, data.Objects);
}
}
}
snapshot.CurrentData.Writeable.SetMemoryEntry(mustIndex, snapshot.CreateMemoryEntry(values));
}
/// <summary>
/// Assigns the given memory entry into all collected indexes in the collector.
/// Must indexes are strongly updated may indexes weakly.
/// </summary>
/// <param name="collector">The collector.</param>
/// <param name="value">The value.</param>
internal void Assign(AssignCollector collector, AnalysisFramework.Memory.MemoryEntry value)
{
CollectComposedValuesVisitor composedValues = new CollectComposedValuesVisitor();
composedValues.VisitMemoryEntry(value);
foreach (MemoryIndex mustIndex in collector.MustIndexes)
{
assignMust(mustIndex, composedValues);
}
foreach (MemoryIndex mayIndex in collector.MayIndexes)
{
assignMay(mayIndex, composedValues);
}
if (snapshot.CurrentMode == SnapshotMode.InfoLevel)
{
InfoLocationVisitor mustVisitor = new InfoLocationVisitor(snapshot, value, true);
foreach (ValueLocation mustLocation in collector.MustLocation)
{
mustLocation.Accept(mustVisitor);
}
InfoLocationVisitor mayVisitor = new InfoLocationVisitor(snapshot, value, false);
foreach (ValueLocation mustLocation in collector.MayLocaton)
{
mustLocation.Accept(mayVisitor);
}
}
}
/// <inheritdoc />
public IEnumerable <MemberIdentifier> GetIndexes(Snapshot snapshot, MemoryEntry values)
{
CollectComposedValuesVisitor visitor = new CollectComposedValuesVisitor();
visitor.VisitMemoryEntry(values);
return(visitor.CollectIndexes(snapshot));
}
/// <inheritdoc />
public IEnumerable <VariableIdentifier> GetFields(Snapshot snapshot, MemoryEntry values)
{
CollectComposedValuesVisitor visitor = new CollectComposedValuesVisitor();
visitor.VisitMemoryEntry(values);
return(visitor.CollectFields(snapshot));
}
/// <inheritdoc />
public IEnumerable <TypeValue> GetObjectType(Snapshot snapshot, MemoryEntry values)
{
CollectComposedValuesVisitor visitor = new CollectComposedValuesVisitor();
visitor.VisitMemoryEntry(values);
return(visitor.ResolveObjectsTypes(snapshot));
}
public void MergeMemoryEntry(MemoryIndex targetIndex, MemoryEntry entry)
{
CollectComposedValuesVisitor visitor = new CollectComposedValuesVisitor();
visitor.VisitMemoryEntry(entry);
arrayCount = visitor.Arrays.Count;
HashSet <Value> values = getValues(targetIndex, visitor, false);
processMerge();
targetSnapshot.CurrentData.Writeable.SetMemoryEntry(targetIndex, targetSnapshot.CreateMemoryEntry(values));
}
/// <summary>
/// Gets all values which can be in target memory entry. If sources contains some arrays merge this arrays together
/// and traverse their indexes.
/// </summary>
/// <param name="operation">The operation.</param>
/// <param name="visitor">The visitor.</param>
/// <returns>Values for the target memory entry.</returns>
private HashSet <Value> getValues(MergeOperation operation, CollectComposedValuesVisitor visitor)
{
HashSet <Value> values = visitor.Values;
bool noScalarValue = visitor.Values.Count == 0;
if (visitor.Arrays.Count > 0)
{
values.Add(mergeArrays(operation));
}
foreach (ObjectValue value in visitor.Objects)
{
values.Add(value);
}
return(values);
}
/// <summary>
/// Assigns the may memory index.
/// </summary>
/// <param name="mayIndex">Index of the may.</param>
/// <param name="composedValues">The composed values.</param>
private void assignMay(MemoryIndex mayIndex, CollectComposedValuesVisitor composedValues)
{
IIndexDefinition data = snapshot.Structure.Readonly.GetIndexDefinition(mayIndex);
HashSet <Value> values = new HashSet <Value>(composedValues.Values);
if (composedValues.Objects.Count > 0)
{
HashSet <ObjectValue> objectsSet = new HashSet <ObjectValue>(data.Objects);
CollectionMemoryUtils.AddAll(objectsSet, composedValues.Objects);
IObjectValueContainer objects = Factories.StructuralContainersFactories.ObjectValueContainerFactory.CreateObjectValueContainer(snapshot.Structure.Writeable, composedValues.Objects);
snapshot.Structure.Writeable.SetObjects(mayIndex, objects);
//if (data.Objects != null)
CollectionMemoryUtils.AddAll(values, data.Objects);
}
MemoryEntry entry = SnapshotDataUtils.GetMemoryEntry(snapshot, snapshot.CurrentData.Readonly, mayIndex);
CollectionMemoryUtils.AddAll(values, entry.PossibleValues);
snapshot.CurrentData.Writeable.SetMemoryEntry(mayIndex, snapshot.CreateMemoryEntry(values));
}
/// <summary>
/// Processes single merge operation - prepares all valid values and alias informations from the source indexes.
/// When the source indexes contains some array values 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>
private void processMergeOperation(MergeOperation operation)
{
CollectComposedValuesVisitor visitor = new CollectComposedValuesVisitor();
ReferenceCollector references = new ReferenceCollector();
// Collect all data from source indexes
foreach (var operationData in operation.Indexes)
{
MemoryIndex index = operationData.Item1;
Snapshot snapshot = operationData.Item2;
MemoryEntry entry = SnapshotDataUtils.GetMemoryEntry(snapshot, snapshot.CurrentData.Readonly, index);
visitor.VisitMemoryEntry(entry);
IMemoryAlias aliases;
if (snapshot.Structure.Readonly.TryGetAliases(index, out aliases))
{
references.CollectMust(aliases.MustAliases, targetSnapshotCallLevel);
references.CollectMay(aliases.MayAliases, targetSnapshotCallLevel);
}
else
{
references.InvalidateMust();
}
}
references.SetAliases(operation.TargetIndex, this, !operation.IsUndefined);
//repares the set of values - array values are traversed
HashSet <Value> values = getValues(operation, visitor);
// If some index in operation can be undefined add undefined value into result
if (operation.IsUndefined)
{
values.Add(targetSnapshot.UndefinedValue);
}
Data.Writeable.SetMemoryEntry(operation.TargetIndex, targetSnapshot.CreateMemoryEntry(values));
writeableStrucure.SetObjects(operation.TargetIndex, Factories.StructuralContainersFactories.ObjectValueContainerFactory.CreateObjectValueContainer(writeableStrucure, visitor.Objects));
}
private HashSet <Value> getValues(MemoryIndex targetIndex, CollectComposedValuesVisitor visitor, bool includeUndefined)
{
HashSet <Value> values = visitor.Values;
bool noScalarValue = visitor.Values.Count == 0;
if (visitor.Arrays.Count > 0)
{
bool mustBeArray = !includeUndefined &&
noScalarValue &&
visitor.Objects.Count == 0 &&
visitor.Arrays.Count == arrayCount;
values.Add(mergeArrays(targetIndex, visitor.Arrays, !mustBeArray));
}
if (visitor.Objects.Count > 0)
{
bool mustBeObject = !includeUndefined && noScalarValue && visitor.Arrays.Count == 0;
mergeObjects(targetIndex, visitor.Objects, mustBeObject, values);
}
return(values);
}
private MemoryEntry setNewMemoryEntry(MemoryIndex index, MemoryEntry currentEntry, MemoryEntry modifiedEntry)
{
CollectComposedValuesVisitor currentVisitor = new CollectComposedValuesVisitor();
currentVisitor.VisitMemoryEntry(currentEntry);
CollectComposedValuesVisitor modifiedVisitor = new CollectComposedValuesVisitor();
modifiedVisitor.VisitMemoryEntry(modifiedEntry);
if (currentVisitor.Arrays.Count != modifiedVisitor.Arrays.Count)
{
snapshot.DestroyArray(index);
}
if (modifiedVisitor.Objects.Count != currentVisitor.Objects.Count)
{
IObjectValueContainer objects = Factories.StructuralContainersFactories.ObjectValueContainerFactory.CreateObjectValueContainer(newStructure.Writeable, currentVisitor.Objects);
snapshot.Structure.Writeable.SetObjects(index, objects);
}
newData.Writeable.SetMemoryEntry(index, modifiedEntry);
return(modifiedEntry);
}
private void processMergeOperation(MergeOperation operation)
{
CollectComposedValuesVisitor visitor = new CollectComposedValuesVisitor();
ReferenceCollector references = new ReferenceCollector();
foreach (var item in operation.Indexes)
{
Snapshot snapshot = item.Item2;
MemoryIndex index = item.Item1;
MemoryEntry entry = SnapshotDataUtils.GetMemoryEntry(snapshot, snapshot.CurrentData.Readonly, index);
visitor.VisitMemoryEntry(entry);
IMemoryAlias aliases;
if (snapshot.Structure.Readonly.TryGetAliases(index, out aliases))
{
references.CollectMust(aliases.MustAliases, snapshot.CallLevel);
references.CollectMay(aliases.MayAliases, snapshot.CallLevel);
}
else
{
references.InvalidateMust();
}
}
if (references.HasAliases && !operation.IsRoot)
{
if (!operation.IsUndefined && operation.Indexes.Count == 1 && references.HasMustAliases)
{
if (targetSnapshot == operation.Indexes.First().Item2)
{
references.AddMustAlias(operation.Indexes.First().Item1);
}
}
else
{
HashSet <MemoryIndex> referenceIndexes = new HashSet <MemoryIndex>();
foreach (var item in operation.Indexes)
{
MemoryIndex index = item.Item1;
Snapshot snapshot = item.Item2;
if (index != operation.TargetIndex && targetSnapshot == snapshot)
{
referenceIndexes.Add(index);
}
}
references.CollectMay(referenceIndexes, targetSnapshot.CallLevel);
}
}
references.SetAliases(operation.TargetIndex, targetSnapshot, !operation.IsUndefined);
HashSet <Value> values = getValues(operation.TargetIndex, visitor, operation.IsUndefined);
if (operation.IsUndefined)
{
values.Add(targetSnapshot.UndefinedValue);
}
targetSnapshot.CurrentData.Writeable.SetMemoryEntry(operation.TargetIndex, targetSnapshot.CreateMemoryEntry(values));
}
