public IEnumerable <Traceable> GetHeapTraceables(SimplePTGNode node, IFieldReference field)
{
var location = new Location(node, field);
var originalTraceables = GetLocationTraceables(location);
var traceables = new HashSet <Traceable>();
if (field.Type.IsClassOrStruct())
{
foreach (var target in PTG.GetTargets(node, field))
{
if (Dependencies.A2_References.ContainsKey(target) && target != SimplePointsToGraph.NullNode)
{
traceables.UnionWith(Dependencies.A2_References[target]);
}
}
}
if (traceables.Count > originalTraceables.Count)
{
}
originalTraceables.UnionWith(traceables);
return(originalTraceables);
}
public void AssignHeapTraceables(SimplePTGNode SimplePTGNode, IFieldReference field, IEnumerable <Traceable> traceables)
{
var newTraceables = new HashSet <Traceable>(traceables);
// If it is a scalar field we modify A3_Field
if (!field.Type.IsClassOrStruct())
{
var location = new Location(SimplePTGNode, field);
//this.Dependencies.A3_Fields[location] = new HashSet<Traceable>(traceables);
// TODO: a weak update
this.Dependencies.A3_Fields[location] = newTraceables;
}
// This should be only for references
// we modify A2_Refs(n) where n \in PT(SimplePTGNode, field)
if (field.Type.IsClassOrStruct())
{
var targets = PTG.GetTargets(SimplePTGNode, field);// .Except(new HashSet<SimplePTGNode>() { SimplePointsToGraph.NullNode } );
if (targets.Any())
{
foreach (var targetNode in targets)
{
if (targetNode != SimplePointsToGraph.NullNode)
{
// TODO: Change for Add
this.Dependencies.A2_References[targetNode] = newTraceables;
//this.Dependencies.A2_References[targetNode] = new HashSet<Traceable>(traceables);
}
}
}
else
{
}
}
}
private void barButtonItem4_ItemClick(object sender, ItemClickEventArgs e)
{
PTG f = new PTG(Sess);
this.Hide();
f.ShowDialog();
this.Show();
}
public IEnumerable <Traceable> GetHeapTraceables(IVariable arg, IFieldReference field)
{
var result = new HashSet <Traceable>();
var nodes = PTG.GetTargets(arg); // , field);
foreach (var node in nodes)
{
result.UnionWith(GetHeapTraceables(node, field));
}
return(result);
}
/// <summary>
/// This one is just for debugging
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
public IEnumerable <Tuple <IFieldReference, IEnumerable <Traceable> > > GetHeapTraceables(IVariable arg)
{
var result = new HashSet <Tuple <IFieldReference, IEnumerable <Traceable> > >();
var nodes = PTG.GetTargets(arg);
foreach (var node in nodes)
{
var locations = this.PTG.GetTargets(node).Select(nf => new Location(node, nf.Key));
result.UnionWith(locations.Select(location => new Tuple <IFieldReference, IEnumerable <Traceable> >(location.Field, GetLocationTraceables(location))));
}
return(result);
}
private HashSet <Traceable> GetTraceablesForReferences(IVariable arg)
{
var traceables = new HashSet <Traceable>();
if (arg.Type.IsClassOrStruct())
{
foreach (var SimplePTGNode in PTG.GetTargets(arg))
{
if (SimplePTGNode != SimplePointsToGraph.NullNode && Dependencies.A2_References.ContainsKey(SimplePTGNode))
{
traceables.UnionWith(Dependencies.A2_References[SimplePTGNode]);
}
}
}
return(traceables);
}
public void AddTraceables(IVariable destination, IEnumerable <Traceable> traceables)
{
// TODO: In the future only assign A2_Variable to Scalaras
//if (!destination.Type.IsClassOrStruct())
{
this.Dependencies.A2_Variables.AddRange(destination, traceables);
}
if (destination.Type.IsClassOrStruct())
{
foreach (var targetNode in PTG.GetTargets(destination))
{
if (targetNode != SimplePointsToGraph.NullNode)
{
this.Dependencies.A2_References.AddRange(targetNode, traceables);
}
}
}
}
public bool AssignHeapTraceables(IVariable destination, IFieldReference field, IEnumerable <Traceable> traceables)
{
var nodes = PTG.GetTargets(destination);
if (nodes.Any())
{
// This should be only for scalars
foreach (var SimplePTGNode in nodes)
{
if (SimplePTGNode != SimplePointsToGraph.NullNode)
{
AssignHeapTraceables(SimplePTGNode, field, traceables);
}
}
}
else
{
return(false);
}
return(true);
}
public override int GetHashCode()
{
return(Dependencies.GetHashCode() + PTG.GetHashCode());
}
