internal IndexStorageVisitor(SnapshotStorageEntry indexedEntry, Snapshot context, MemberIdentifier index)
{
_context = context;
_index = index;
var indexedValues = indexedEntry.ReadMemory(context);
VisitMemoryEntry(indexedValues);
if (implicitArray != null)
{
//TODO replace only undefined values
indexedEntry.WriteMemoryWithoutCopy(context, new MemoryEntry(implicitArray));
}
var forceStrong = indexedEntry.ForceStrong;
if (_hasOnlyArrays && indexedEntry.HasDirectIdentifier && index.IsDirect)
{
//optimization
forceStrong = true;
}
if (_needsTemporaryIndex)
{
foreach (var key in indexedEntry.Storages)
{
_indexStorages.Add(new VariableIndexKey(key, _index));
}
}
IndexedValue = new SnapshotStorageEntry(null, forceStrong, _indexStorages.ToArray());
}
public override void Foreach(MemoryEntry enumeree, ReadWriteSnapshotEntryBase keyVariable,
ReadWriteSnapshotEntryBase valueVariable)
{
var values = new HashSet <Value>();
var array = enumeree.PossibleValues.First() as AssociativeArray;
var arrayEntry = OutSet.CreateSnapshotEntry(new MemoryEntry(array));
var indexes = arrayEntry.IterateIndexes(OutSnapshot);
foreach (var index in indexes)
{
var indexEntry = arrayEntry.ReadIndex(OutSnapshot, index);
var element = indexEntry.ReadMemory(OutSnapshot);
values.UnionWith(element.PossibleValues);
}
valueVariable.WriteMemory(OutSnapshot, new MemoryEntry(values));
}
public void Write(ReadWriteSnapshotEntryBase snapshotEntry, int value)
{
Write(snapshotEntry, Snapshot.CreateInt(value));
}
public void Write(ReadWriteSnapshotEntryBase snapshotEntry, Value value)
{
AddOperation(new WriteOperation <T>(snapshotEntry, value));
}
public void Read(ReadWriteSnapshotEntryBase snapshotEntry)
{
AddOperation(new ReadOperation <T>(snapshotEntry));
}
internal void Alias(ReadWriteSnapshotEntryBase targetEntry, ReadWriteSnapshotEntryBase sourceEntry)
{
AddOperation(new AliasOperation <T>(targetEntry, sourceEntry));
}
public ReadOperation(ReadWriteSnapshotEntryBase snapshotEntry)
{
// TODO: Complete member initialization
this.snapshotEntry = snapshotEntry;
}
/// <summary> /// Determine whether a variable is considered to be empty (i.e. null, false, 0, 0.0, "" etc.) /// </summary> /// <param name="snapshotEntry">A variable to be checked</param> /// <returns><c>true</c> whether a variable is empty, otherwise <c>false</c></returns> public abstract MemoryEntry EmptyEx(ReadWriteSnapshotEntryBase snapshotEntry);
/// <summary> /// Assign possible values to given target /// </summary> /// <param name="target">Target snapshot entry</param> /// <param name="entry">Possible values to be assigned</param> public abstract void Assign(ReadWriteSnapshotEntryBase target, MemoryEntry entry);
public SnapshotEntryFactory(SnapshotTester <T> tester, ReadWriteSnapshotEntryBase readWriteSnapshotEntryBase)
{
this.snapshotEntry = readWriteSnapshotEntryBase;
this.tester = tester;
}
public override void AliasAssign(ReadWriteSnapshotEntryBase target, ReadSnapshotEntryBase aliasedValue)
{
target.SetAliases(OutSnapshot, aliasedValue);
}
public override MemoryEntry EmptyEx(ReadWriteSnapshotEntryBase variable)
{
throw new NotImplementedException();
}
public override void Assign(ReadWriteSnapshotEntryBase target, MemoryEntry value)
{
target.WriteMemory(OutSnapshot, value);
}
public WriteFromMemoryOperation(ReadWriteSnapshotEntryBase targetEntry, ReadWriteSnapshotEntryBase sourceEntry)
{
this.targetEntry = targetEntry;
this.sourceEntry = sourceEntry;
}
public WriteOperation(ReadWriteSnapshotEntryBase snapshotEntry, Value value)
{
// TODO: Complete member initialization
this.snapshotEntry = snapshotEntry;
this.value = value;
}
public void Write(ReadWriteSnapshotEntryBase snapshotEntry, string value)
{
Write(snapshotEntry, Snapshot.CreateString(value));
}
/// <summary>
/// Assign possible aliases to given target
/// </summary>
/// <param name="target">Target variable specifier</param>
/// <param name="aliasedValue">Possible aliases to be assigned</param>
public abstract void AliasAssign(ReadWriteSnapshotEntryBase target,
ReadSnapshotEntryBase aliasedValue);
private void setTaint(ReadWriteSnapshotEntryBase variable, bool taint)
{
var infoValue = Output.CreateInfo(taint);
variable.WriteMemory(Output, new MemoryEntry(infoValue));
}
/// <summary>
/// Process foreach statement on given variables
/// </summary>
/// <remarks>
/// Is intended to store all possible values from enumeration into keyVariable and valueVariable
/// </remarks>
/// <param name="enumeree">Enumerated value</param>
/// <param name="keyVariable">Variable where keys are stored</param>
/// <param name="valueVariable">Variable where values are stored</param>
public abstract void Foreach(MemoryEntry enumeree, ReadWriteSnapshotEntryBase keyVariable,
ReadWriteSnapshotEntryBase valueVariable);
internal void Write(ReadWriteSnapshotEntryBase targetEntry, ReadWriteSnapshotEntryBase sourceEntry)
{
AddOperation(new WriteFromMemoryOperation <T>(targetEntry, sourceEntry));
}
private void setPropagation(ReadWriteSnapshotEntryBase variable, PropagationInfo propagation)
{
var infoValue = Output.CreateInfo(propagation);
variable.WriteMemory(Output, new MemoryEntry(infoValue));
}
public AliasOperation(ReadWriteSnapshotEntryBase targetEntry, ReadWriteSnapshotEntryBase sourceEntry)
{
this.targetEntry = targetEntry;
this.sourceEntry = sourceEntry;
}
