/// <summary> /// Compares this structure object with given copy of old data and applies simplify limit when new memory entry is bigger than given simplify limit. /// </summary> /// <param name="oldValue">The old value.</param> /// <param name="simplifyLimit">The simplify limit.</param> /// <param name="assistant">The assistant.</param> /// <returns><c>true</c> if the data are same; otherwise, <c>false</c>.</returns> private bool compareDataAndSimplify(SnapshotStructure oldValue, int simplifyLimit, MemoryAssistantBase assistant) { HashSet <MemoryIndex> usedIndexes = new HashSet <MemoryIndex>(); HashSetTools.AddAll(usedIndexes, this.IndexData.Keys); HashSetTools.AddAll(usedIndexes, oldValue.IndexData.Keys); IndexData emptyStructure = new CopyMemoryModel.IndexData(null, null, null); bool areEqual = true; foreach (MemoryIndex index in usedIndexes) { if (index is TemporaryIndex) { continue; } IndexData newStructure = getDataOrUndefined(index, this, emptyStructure); IndexData oldStructure = getDataOrUndefined(index, oldValue, emptyStructure); if (!newStructure.DataEquals(oldStructure)) { areEqual = false; } if (!Data.DataEqualsAndSimplify(oldValue.Data, index, simplifyLimit, assistant)) { areEqual = false; } } return(areEqual); }
/// <summary> /// Compares this structure object with given copy of old data and applies widening operation on memory entry which differs. /// </summary> /// <param name="oldValue">The old value.</param> /// <param name="simplifyLimit">The simplify limit.</param> /// <param name="assistant">The assistant.</param> /// <returns><c>true</c> if the data are same; otherwise, <c>false</c>.</returns> private bool widenNotEqualData(SnapshotStructure oldValue, int simplifyLimit, MemoryAssistantBase assistant) { HashSet <MemoryIndex> indexes = new HashSet <MemoryIndex>(); HashSetTools.AddAll(indexes, this.IndexData.Keys); HashSetTools.AddAll(indexes, oldValue.IndexData.Keys); IndexData emptyData = new CopyMemoryModel.IndexData(null, null, null); bool areEqual = true; foreach (MemoryIndex index in indexes) { if (index is TemporaryIndex) { continue; } IndexData newData = getDataOrUndefined(index, this, emptyData); IndexData oldData = getDataOrUndefined(index, oldValue, emptyData); Data.DataWiden(oldValue.Data, index, assistant); if (!Data.DataEqualsAndSimplify(oldValue.Data, index, simplifyLimit, assistant)) { areEqual = false; } } return(areEqual); }
/// <summary> /// Compares this structure object with given copy of old data. /// </summary> /// <param name="oldValue">The old value.</param> /// <returns><c>true</c> if the data are same; otherwise, <c>false</c>.</returns> private bool compareData(SnapshotStructure oldValue) { HashSet <MemoryIndex> usedIndexes = new HashSet <MemoryIndex>(); HashSetTools.AddAll(usedIndexes, this.IndexData.Keys); HashSetTools.AddAll(usedIndexes, oldValue.IndexData.Keys); IndexData emptyStructure = new CopyMemoryModel.IndexData(null, null, null); foreach (MemoryIndex index in usedIndexes) { if (index is TemporaryIndex) { continue; } IndexData newStructure = getDataOrUndefined(index, this, emptyStructure); IndexData oldStructure = getDataOrUndefined(index, oldValue, emptyStructure); if (!newStructure.DataEquals(oldStructure)) { return(false); } if (!Data.DataEquals(oldValue.Data, index)) { return(false); } } return(true); }
/// <summary> /// Compares this structure object with given copy of old data and applies simplify limit when new memory entry is bigger than given simplify limit. /// </summary> /// <param name="oldValue">The old value.</param> /// <param name="simplifyLimit">The simplify limit.</param> /// <param name="assistant">The assistant.</param> /// <returns> /// <c>true</c> if the data are same; otherwise, <c>false</c>. /// </returns> public bool DataEqualsAndSimplify(SnapshotStructure oldValue, int simplifyLimit, MemoryAssistantBase assistant) { if (!compareDataAndSimplify(oldValue, simplifyLimit, assistant)) { return(false); } return(compareDeclarations(oldValue)); }
/// <summary> /// Compares this structure object with given copy of old data. /// </summary> /// <param name="oldValue">The old value.</param> /// <returns><c>true</c> if the data are same; otherwise, <c>false</c>.</returns> public bool DataEquals(SnapshotStructure oldValue) { if (!compareData(oldValue)) { return(false); } return(compareDeclarations(oldValue)); }
/// <summary> /// Initializes a new instance of the <see cref="MergeWorker"/> class. /// </summary> /// <param name="targetSnapshot">The target snapshot.</param> /// <param name="sourceSnapshots">The source snapshots.</param> /// <param name="isCallMerge">if set to <c>true</c> [is call merge].</param> public MergeWorker(Snapshot targetSnapshot, List <Snapshot> sourceSnapshots, bool isCallMerge = false) { Data = SnapshotData.CreateEmpty(targetSnapshot); Structure = SnapshotStructure.CreateEmpty(targetSnapshot); Structure.Data = Data; this.targetSnapshot = targetSnapshot; this.sourceSnapshots = sourceSnapshots; this.isCallMerge = isCallMerge; }
/// <summary> /// Gets the data is set in structure or returns given empty data. /// </summary> /// <param name="index">The index.</param> /// <param name="snapshotStructure">The snapshot structure.</param> /// <param name="emptyData">The empty data.</param> /// <returns>Data is set in structure or returns given empty data.</returns> private CopyMemoryModel.IndexData getDataOrUndefined(MemoryIndex index, SnapshotStructure snapshotStructure, IndexData emptyData) { IndexData data = null; if (!snapshotStructure.IndexData.TryGetValue(index, out data)) { data = emptyData; } return(data); }
/// <summary> /// Compares this structure object with given copy of old data and applies widening operation on memory entry which differs. /// </summary> /// <param name="oldValue">The old value.</param> /// <param name="simplifyLimit">The simplify limit.</param> /// <param name="assistant">The assistant.</param> /// <returns><c>true</c> if the data are same; otherwise, <c>false</c>.</returns> public bool WidenNotEqual(SnapshotStructure oldValue, int simplifyLimit, MemoryAssistantBase assistant) { lockedTest(); bool funcCount = this.FunctionDecl.Count == oldValue.FunctionDecl.Count; bool classCount = this.ClassDecl.Count == oldValue.ClassDecl.Count; if (!widenNotEqualData(oldValue, simplifyLimit, assistant)) { return(false); } return(compareDeclarations(oldValue)); }
/// <summary> /// Creates empty structure which contains no data in containers. /// </summary> /// <param name="snapshot">The snapshot.</param> /// <returns>New empty structure which contains no data in containers.</returns> public static SnapshotStructure CreateEmpty(Snapshot snapshot) { SnapshotStructure data = new SnapshotStructure(snapshot); data.ArrayDescriptors = new Dictionary <AssociativeArray, ArrayDescriptor>(); data.ObjectDescriptors = new Dictionary <ObjectValue, ObjectDescriptor>(); data.IndexData = new Dictionary <MemoryIndex, IndexData>(); data.Variables = new VariableStack(snapshot.CallLevel); data.ContolVariables = new VariableStack(snapshot.CallLevel); data.FunctionDecl = new DeclarationContainer <FunctionValue>(); data.ClassDecl = new DeclarationContainer <TypeValue>(); data.Temporary = new MemoryStack <IndexSet <TemporaryIndex> >(snapshot.CallLevel); data.Arrays = new MemoryStack <IndexSet <AssociativeArray> >(snapshot.CallLevel); data.CallArrays = new Dictionary <AssociativeArray, IndexSet <Snapshot> >(); return(data); }
/// <summary> /// Creates new structure object as copy of this structure and adds new local level into memory stacks. /// </summary> /// <param name="snapshot">The snapshot.</param> /// <param name="snapshotData">The snapshot data.</param> /// <returns>New copy of this structure and adds new local level into memory stacks.</returns> public SnapshotStructure CopyAndAddLocalLevel(Snapshot snapshot, SnapshotData snapshotData) { SnapshotStructure data = new SnapshotStructure(snapshot); data.Data = snapshotData; data.ArrayDescriptors = new Dictionary <AssociativeArray, ArrayDescriptor>(ArrayDescriptors); data.ObjectDescriptors = new Dictionary <ObjectValue, ObjectDescriptor>(ObjectDescriptors); data.IndexData = new Dictionary <MemoryIndex, IndexData>(IndexData); data.FunctionDecl = new DeclarationContainer <FunctionValue>(FunctionDecl); data.ClassDecl = new DeclarationContainer <TypeValue>(ClassDecl); data.Variables = new VariableStack(Variables, data.createIndexContainer(VariableIndex.CreateUnknown(Variables.Length))); data.ContolVariables = new VariableStack(ContolVariables, data.createIndexContainer(ControlIndex.CreateUnknown(ContolVariables.Length))); data.Temporary = new MemoryStack <IndexSet <TemporaryIndex> >(Temporary, new IndexSet <TemporaryIndex>()); data.Arrays = new MemoryStack <IndexSet <AssociativeArray> >(Arrays, new IndexSet <AssociativeArray>()); data.CallArrays = new Dictionary <AssociativeArray, IndexSet <Snapshot> >(CallArrays); return(data); }
/// <summary> /// Creates new structure object as copy of this structure which contains the same data as this instace. /// </summary> /// <param name="snapshot">The snapshot.</param> /// <param name="snapshotData">The snapshot data.</param> /// <returns>New copy of this structure which contains the same data as this instace.</returns> public SnapshotStructure Copy(Snapshot snapshot, SnapshotData snapshotData) { SnapshotStructure data = new SnapshotStructure(snapshot); data.Data = snapshotData; data.ArrayDescriptors = new Dictionary <AssociativeArray, ArrayDescriptor>(ArrayDescriptors); data.ObjectDescriptors = new Dictionary <ObjectValue, ObjectDescriptor>(ObjectDescriptors); data.IndexData = new Dictionary <MemoryIndex, IndexData>(IndexData); data.FunctionDecl = new DeclarationContainer <FunctionValue>(FunctionDecl); data.ClassDecl = new DeclarationContainer <TypeValue>(ClassDecl); data.Variables = new VariableStack(Variables); data.ContolVariables = new VariableStack(ContolVariables); data.Temporary = new MemoryStack <IndexSet <TemporaryIndex> >(Temporary); data.Arrays = new MemoryStack <IndexSet <AssociativeArray> >(Arrays); data.CallArrays = new Dictionary <AssociativeArray, IndexSet <Snapshot> >(CallArrays); return(data); }
/// <summary> /// Creates the structure with memory stack with global level only. /// </summary> /// <param name="snapshot">The snapshot.</param> /// <param name="snapshotData">The snapshot data.</param> /// <returns>New structure with memory stack with global level only.</returns> public static SnapshotStructure CreateGlobal(Snapshot snapshot, SnapshotData snapshotData) { SnapshotStructure data = new SnapshotStructure(snapshot); data.Data = snapshotData; data.ArrayDescriptors = new Dictionary <AssociativeArray, ArrayDescriptor>(); data.ObjectDescriptors = new Dictionary <ObjectValue, ObjectDescriptor>(); data.IndexData = new Dictionary <MemoryIndex, IndexData>(); data.Variables = data.createMemoryStack(VariableIndex.CreateUnknown(Snapshot.GLOBAL_CALL_LEVEL)); data.ContolVariables = data.createMemoryStack(ControlIndex.CreateUnknown(Snapshot.GLOBAL_CALL_LEVEL)); data.FunctionDecl = new DeclarationContainer <FunctionValue>(); data.ClassDecl = new DeclarationContainer <TypeValue>(); data.Temporary = new MemoryStack <IndexSet <TemporaryIndex> >(new IndexSet <TemporaryIndex>()); data.Arrays = new MemoryStack <IndexSet <AssociativeArray> >(new IndexSet <AssociativeArray>()); data.CallArrays = new Dictionary <AssociativeArray, IndexSet <Snapshot> >(); return(data); }
/// <summary> /// Compares the declarations of functions and classes whether there is some structural changes between this and old structure object. /// </summary> /// <param name="oldValue">The old value.</param> /// <returns><c>true</c> if the data are same; otherwise, <c>false</c>.</returns> private bool compareDeclarations(SnapshotStructure oldValue) { bool funcCount = this.FunctionDecl.Count == oldValue.FunctionDecl.Count; bool classCount = this.ClassDecl.Count == oldValue.ClassDecl.Count; if (classCount && funcCount) { if (!this.FunctionDecl.DataEquals(oldValue.FunctionDecl)) { return(false); } if (!this.ClassDecl.DataEquals(oldValue.ClassDecl)) { return(false); } } else { return(false); } return(true); }