/// <summary>
/// Resolve method on current snapshot entry with given methodName
/// </summary>
/// <param name="context">Context where methods are resolved</param>
/// <param name="methodName">Name of resolved method</param>
/// <returns>
/// Resolved methods
/// </returns>
protected override IEnumerable <FunctionValue> resolveMethod(SnapshotBase context, PHP.Core.QualifiedName methodName)
{
Snapshot snapshot = SnapshotEntry.ToSnapshot(context);
snapshot.Factories.Logger.Log(context, "resolve method - " + this.ToString() + " method: " + methodName);
if (isTemporarySet(context))
{
return(getTemporary(context).ResolveMethod(context, methodName));
}
else
{
snapshot.Factories.Logger.Log(snapshot, "iterate fields: " + this.ToString());
MemoryEntry values = readMemory(snapshot);
snapshot.Factories.Benchmark.StartOperation(snapshot);
snapshot.Factories.Benchmark.StartAlgorithm(snapshot, AlgorithmType.RESOLVE_METHOD);
var methods = snapshot.Algorithms.ReadAlgorithm.GetMethod(snapshot, values, methodName);
snapshot.Factories.Benchmark.FinishAlgorithm(snapshot, AlgorithmType.RESOLVE_METHOD);
snapshot.Factories.Benchmark.FinishOperation(snapshot);
return(methods);
}
}
/// <summary>
/// Write given value at memory represented by snapshot entry
/// </summary>
/// <param name="context">Context snapshot where operation is proceeded</param>
/// <param name="value">Written value</param>
/// <param name="forceStrongWrite">Determine that current write should be processed as strong</param>
/// <exception cref="System.NotSupportedException">Current mode: + snapshot.CurrentMode</exception>
protected override void writeMemory(SnapshotBase context, MemoryEntry value, bool forceStrongWrite)
{
Snapshot snapshot = SnapshotEntry.ToSnapshot(context);
snapshot.Factories.Logger.Log(context, "write memory - " + this.ToString());
switch (snapshot.CurrentMode)
{
case SnapshotMode.MemoryLevel:
getTemporary(context).WriteMemory(context, value, forceStrongWrite);
break;
case SnapshotMode.InfoLevel:
if (isTemporarySet(context))
{
getTemporary(context).WriteMemory(context, value, forceStrongWrite);
}
else
{
infoEntry = value;
}
break;
default:
throw new NotSupportedException("Current mode: " + snapshot.CurrentMode);
}
}
/// <summary>
/// Read memory represented by current snapshot entry
/// </summary>
/// <param name="context">Context snapshot where operation is proceeded</param>
/// <returns>
/// Memory represented by current snapshot entry
/// </returns>
/// <exception cref="System.NotSupportedException">Current mode: + snapshot.CurrentMode</exception>
protected override MemoryEntry readMemory(SnapshotBase context)
{
Snapshot snapshot = SnapshotEntry.ToSnapshot(context);
snapshot.Factories.Logger.Log(context, "read memory - " + this.ToString());
if (isTemporarySet(context))
{
snapshot.Factories.Logger.Log(context, "read from temporary location - " + this.ToString());
return(temporaryLocation.ReadMemory(context));
}
else
{
snapshot.Factories.Logger.Log(context, "read just value - " + this.ToString());
switch (snapshot.CurrentMode)
{
case SnapshotMode.MemoryLevel:
return(dataEntry);
case SnapshotMode.InfoLevel:
return(infoEntry);
default:
throw new NotSupportedException("Current mode: " + snapshot.CurrentMode);
}
}
}
/// <summary>
/// Set aliases to current snapshot entry. Aliases can be set even to those entries
/// that doesn't belongs to any variable, field,..
/// </summary>
/// <param name="context">Context snapshot where operation is proceeded</param>
/// <param name="aliasedEntry">Snapshot entry which will be aliased from current entry</param>
protected override void setAliases(SnapshotBase context, ReadSnapshotEntryBase aliasedEntry)
{
Snapshot snapshot = SnapshotEntry.ToSnapshot(context);
snapshot.Factories.Logger.Log(context, "set aliases - " + this.ToString());
getTemporary(context).SetAliases(context, aliasedEntry);
}
/// <summary>
/// Read memory represented by given field identifier resolved on current
/// snapshot entry (resulting snapshot entry can encapsulate merging, alias resolving and
/// other stuff based on nondeterminism of identifier and current snapshot entry)
/// </summary>
/// <param name="context">Context snapshot where operation is proceeded</param>
/// <param name="field">Identifier of an field</param>
/// <returns>
/// Snapshot entry representing field resolving on current entry
/// </returns>
protected override ReadWriteSnapshotEntryBase readField(SnapshotBase context, AnalysisFramework.VariableIdentifier field)
{
Snapshot snapshot = SnapshotEntry.ToSnapshot(context);
snapshot.Factories.Logger.Log(context, "read index - " + this.ToString());
return(getTemporary(context).ReadField(context, field));
}
/// <summary>
/// Read memory represented by given index identifier resolved on current
/// snapshot entry (resulting snapshot entry can encapsulate merging, alias resolving and
/// other stuff based on nondeterminism of identifier and current snapshot entry)
/// </summary>
/// <param name="context">Context snapshot where operation is proceeded</param>
/// <param name="index">Identifier of an index</param>
/// <returns>
/// Snapshot entry representing index resolving on current entry
/// </returns>
protected override ReadWriteSnapshotEntryBase readIndex(SnapshotBase context, MemberIdentifier index)
{
Snapshot snapshot = SnapshotEntry.ToSnapshot(context);
snapshot.Factories.Logger.Log(context, "read index - " + this.ToString());
return(getTemporary(context).ReadIndex(context, index));
}
/// <summary>
/// Returns aliases that can be used for making alias join
/// to current snapshot entry
/// </summary>
/// <param name="context">Context snapshot where operation is proceeded</param>
/// <returns>
/// Aliases of current snapshot entry
/// </returns>
protected override IEnumerable <AliasEntry> aliases(SnapshotBase context)
{
Snapshot snapshot = SnapshotEntry.ToSnapshot(context);
snapshot.Factories.Logger.Log(context, "aliases - " + this.ToString());
if (isTemporarySet(context))
{
return(temporaryLocation.Aliases(context));
}
else
{
return(new AliasEntry[] { });
}
}
/// <summary>
/// Determine that memory represented by current snapshot entry Is already defined.
/// If not, reading memory returns UndefinedValue. But UndefinedValue can be returned
/// even for defined memory entries - this can be used to distinct
/// between null/undefined semantic of PHP.
/// </summary>
/// <param name="context">Context snapshot where operation is proceeded</param>
/// <returns>True whether that memory represented by current snapshot entry Is already defined.</returns>
protected override bool isDefined(SnapshotBase context)
{
Snapshot snapshot = SnapshotEntry.ToSnapshot(context);
snapshot.Factories.Logger.Log(context, "is defined - " + this.ToString());
if (isTemporarySet(context))
{
return(temporaryLocation.IsDefined(context));
}
else
{
return(true);
}
}
/// <summary>
/// Gets the snapshot entry of temporary index associated with this memory entry.
/// </summary>
/// <param name="context">The context.</param>
private SnapshotEntry getTemporary(SnapshotBase context)
{
Snapshot snapshot = SnapshotEntry.ToSnapshot(context);
if (temporaryLocation == null)
{
temporaryIndex = snapshot.CreateTemporary();
temporaryLocation = new SnapshotEntry(MemoryPath.MakePathTemporary(temporaryIndex));
snapshot.Factories.Benchmark.StartAlgorithm(snapshot, AlgorithmType.MERGE_TO_TEMPORARY);
snapshot.Algorithms.MergeAlgorithm.MergeMemoryEntry(snapshot, temporaryIndex, dataEntry);
snapshot.Factories.Benchmark.FinishAlgorithm(snapshot, AlgorithmType.MERGE_TO_TEMPORARY);
}
return(temporaryLocation);
}
/// <summary>
/// Resolve type of objects in snapshot entry
/// </summary>
/// <param name="context">Context where types are resolved</param>
/// <returns>
/// Resolved types
/// </returns>
protected override IEnumerable <TypeValue> resolveType(SnapshotBase context)
{
if (isTemporarySet(context))
{
return(getTemporary(context).ResolveType(context));
}
else
{
Snapshot snapshot = SnapshotEntry.ToSnapshot(context);
snapshot.Factories.Logger.Log(snapshot, "iterate fields: " + this.ToString());
MemoryEntry values = readMemory(snapshot);
snapshot.Factories.Benchmark.StartAlgorithm(snapshot, AlgorithmType.RESOLVE_TYPE);
var types = snapshot.Algorithms.ReadAlgorithm.GetObjectType(snapshot, values);
snapshot.Factories.Benchmark.FinishAlgorithm(snapshot, AlgorithmType.RESOLVE_TYPE);
return(types);
}
}
/// <summary>
/// Iterate indexes defined on array
/// </summary>
/// <param name="context">Context where indexes are searched</param>
/// <returns>
/// Enumeration of available fields
/// </returns>
protected override IEnumerable <MemberIdentifier> iterateIndexes(SnapshotBase context)
{
if (isTemporarySet(context))
{
return(getTemporary(context).IterateIndexes(context));
}
else
{
Snapshot snapshot = SnapshotEntry.ToSnapshot(context);
snapshot.Factories.Logger.Log(snapshot, "iterate fields: " + this.ToString());
MemoryEntry values = readMemory(snapshot);
snapshot.Factories.Benchmark.StartAlgorithm(snapshot, AlgorithmType.ITERATE_INDEXES);
var indexes = snapshot.Algorithms.ReadAlgorithm.GetIndexes(snapshot, values);
snapshot.Factories.Benchmark.FinishAlgorithm(snapshot, AlgorithmType.ITERATE_INDEXES);
return(indexes);
}
}
/// <summary>
/// Write given value at memory represented by snapshot entry and doesn't process any
/// array copy. Is needed for correct increment/decrement semantic.
/// </summary>
/// <param name="context">Context snapshot where operation is proceeded</param>
/// <param name="value">Written value</param>
protected override void writeMemoryWithoutCopy(SnapshotBase context, MemoryEntry value)
{
if (isTemporarySet(context))
{
getTemporary(context).WriteMemoryWithoutCopy(context, value);
}
else
{
Snapshot snapshot = SnapshotEntry.ToSnapshot(context);
switch (snapshot.CurrentMode)
{
case SnapshotMode.MemoryLevel:
dataEntry = value;
break;
case SnapshotMode.InfoLevel:
infoEntry = value;
break;
default:
throw new NotSupportedException("Current mode: " + snapshot.CurrentMode);
}
}
}
/// <summary>
/// Determines whether there is associated temporary index with memory entry in the specified context.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>True whether there is associated temporary index with memory entry in the specified context.</returns>
private bool isTemporarySet(SnapshotBase context)
{
Snapshot snapshot = SnapshotEntry.ToSnapshot(context);
return(temporaryIndex != null && snapshot.IsTemporarySet(temporaryIndex));
}