public void RemoveMethod(IMethodHolder <TNode> owner, string methodName)
{
var methodId = Methods.Find(methodName);
Trace.Assert(methodId.HasValue);
RemoveMethod(owner, new ResolvedMethodId(methodId.Value));
}
public void UpdateMethod(IMethodHolder <Node> owner, Common.Types.Method source)
{
var method = myProgram.GetOrCreateMethod(owner, source.Id.Value);
myProgram.ClearMethod(method);
// Variables.
var localVariables = source.Variables.Cast <LocalVariableReference>()
.Select(reference =>
{
var defaultType = reference.DefaultType == null ? -1 :
myProgram.GetOrCreateClass(reference.DefaultType).Id.GlobalId;
return(new ResolvedLocalVariable(reference.Index, defaultType));
});
if (owner is ResolvedMethod <Node> owningMethod)
{
var possibleVariables = owningMethod.Variables.ToDictionary(pair => pair.Key, pair => pair.Value);
foreach (var local in localVariables)
{
if (!possibleVariables.ContainsKey(local.LocalId))
{
possibleVariables.Add(local.LocalId, local);
}
}
localVariables = possibleVariables.Values;
}
foreach (var localVariable in localVariables)
{
method.AddLocalVariable(localVariable);
}
foreach (var attribute in source.Attributes)
{
var attributeId = myProgram.GetOrCreateAttribute(attribute);
method.AddAttribute(attributeId);
}
// LocalFunctions.
if (source.LocalMethods != null)
{
foreach (var localMethod in source.LocalMethods)
{
UpdateMethod(method, localMethod);
}
}
// Body.
var bodyAdapter = new CommonMethodAsNodeBasedProgram(source);
UpdateMethodBody(owner, source.Id, bodyAdapter);
}
public void UpdateMethodBody(IMethodHolder <Node> owner, MethodId id, INodeBasedProgram <int> body)
{
var method = myProgram.GetOrCreateMethod(owner, id.Value);
var mapper = GetLocalMapper(method);
var identity = new IdentityTransducer <Node>();
var invocationsResolver = new InvocationsResolvingTransducer <Node>();
var assignmentsResolver = new AssignmentsResolvingTransducer <Node>();
var transducer = assignmentsResolver.Compose(invocationsResolver).Compose(identity);
transducer.Transform(body, myProgram, method, mapper);
//myProgram.DumpToDot("C:/work/graph.dot");
}
public void RemoveMethod(IMethodHolder <TNode> owner, ResolvedMethodId methodId)
{
var method = owner.FindLocalMethod(methodId);
var toRemove = method.Methods.Keys.ToList();
foreach (var localFunction in toRemove)
{
RemoveMethod(method, localFunction);
}
var toDelete = method.GetOwnedNodes();
foreach (var node in toDelete)
{
RemoveVertex(node);
myOnNodeRemovedHandler(node);
}
var exists = owner.RemoveMethod(methodId);
Trace.Assert(exists);
}
public ResolvedMethod <TNode> GetOrCreateMethod(IMethodHolder <TNode> owner, string name)
{
var rawMethodId = Methods.FindOrAdd(name);
var methodId = new ResolvedMethodId(rawMethodId);
var method = owner.FindLocalMethod(methodId);
if (method == null)
{
var start = myNodesProvider();
var end = myNodesProvider();
AddVertex(start);
AddVertex(end);
method = new ResolvedMethod <TNode>(methodId, start, end);
owner.AddMethod(methodId, method);
return(method);
}
return(method);
}
