void AssertAllUnmappedAfterMatch(IMatches matches, bool special) { foreach (INode node in graph.GetCompatibleNodes(graph.Model.NodeModel.RootType)) { LGSPNode lnode = (LGSPNode)node; if (lnode.mappedTo != 0) { throw new Exception("Node \"" + graph.GetElementName(lnode) + "\" not unmapped by action \"" + matches.Producer.Name + "\"!"); } if (lnode.negMappedTo != 0) { throw new Exception("Node \"" + graph.GetElementName(lnode) + "\" not neg-unmapped by action \"" + matches.Producer.Name + "\"!"); } } foreach (IEdge edge in graph.GetCompatibleEdges(graph.Model.EdgeModel.RootType)) { LGSPEdge ledge = (LGSPEdge)edge; if (ledge.mappedTo != 0) { throw new Exception("Edge \"" + graph.GetElementName(ledge) + "\" not unmapped by action \"" + matches.Producer.Name + "\"!"); } if (ledge.negMappedTo != 0) { throw new Exception("Edge \"" + graph.GetElementName(ledge) + "\" not neg-unmapped by action \"" + matches.Producer.Name + "\"!"); } } }
private void ChangingElementAttribute(LGSPGraphProcessingEnvironment procEnv) { AttributeChangeType changeType; switch (_undoOperation) { case UndoOperation.Assign: changeType = AttributeChangeType.Assign; break; case UndoOperation.PutElement: changeType = AttributeChangeType.PutElement; break; case UndoOperation.RemoveElement: changeType = AttributeChangeType.RemoveElement; break; case UndoOperation.AssignElement: changeType = AttributeChangeType.AssignElement; break; default: throw new Exception("Internal error during transaction handling"); } LGSPNode node = _elem as LGSPNode; if (node != null) { procEnv.graph.ChangingNodeAttribute(node, _attrType, changeType, _value, _keyOfValue); } else { LGSPEdge edge = (LGSPEdge)_elem; procEnv.graph.ChangingEdgeAttribute(edge, _attrType, changeType, _value, _keyOfValue); } }
void DoIt() { graph = new LGSPGraph(new ProgramGraphsOriginalGraphModel()); actions = new ProgramGraphsOriginalActions(graph); procEnv = new LGSPGraphProcessingEnvironment(graph, actions); // use new exact 2.5 interface IClass cls = null; IMethodBody mb = null; bool success = actions.createProgramGraphPullUp.Apply(procEnv, ref cls, ref mb); IMatchesExact<Rule_pullUpMethod.IMatch_pullUpMethod> matchesExact = actions.pullUpMethod.Match(procEnv, 0, cls, mb); Console.WriteLine(matchesExact.Count + " matches found."); Console.WriteLine(matchesExact.FirstExact.node_m5.ToString()); graph.Clear(); // and again with old inexact interface IMatches matchesInexact; object[] returns; Action_createProgramGraphPullUp createProgramGraph = Action_createProgramGraphPullUp.Instance; matchesInexact = createProgramGraph.Match(procEnv, 0); returns = createProgramGraph.Modify(procEnv, matchesInexact.First); IGraphElement[] param = new LGSPNode[2]; param[0] = (Class)returns[0]; param[1] = (MethodBody)returns[1]; matchesInexact = actions.GetAction("pullUpMethod").Match(procEnv, 0, param); Console.WriteLine(matchesInexact.Count + " matches found."); Console.WriteLine(matchesInexact.First.getNodeAt((int)Rule_pullUpMethod.pullUpMethod_NodeNums.m5).ToString()); }
void ClearGraphListener() { foreach (INode node in graph.Nodes) { LGSPNode lgspNode = (LGSPNode)node; if ((lgspNode.lgspFlags & (uint)LGSPElemFlags.HAS_VARIABLES) != 0) { foreach (Variable var in ElementMap[lgspNode]) { VariableMap.Remove(var.Name); } ElementMap.Remove(lgspNode); lgspNode.lgspFlags &= ~(uint)LGSPElemFlags.HAS_VARIABLES; } } foreach (IEdge edge in graph.Edges) { LGSPEdge lgspEdge = (LGSPEdge)edge; if ((lgspEdge.lgspFlags & (uint)LGSPElemFlags.HAS_VARIABLES) != 0) { foreach (Variable var in ElementMap[lgspEdge]) { VariableMap.Remove(var.Name); } ElementMap.Remove(lgspEdge); lgspEdge.lgspFlags &= ~(uint)LGSPElemFlags.HAS_VARIABLES; } } }
public virtual void RemovingNode(INode node) { LGSPNode nodeUnique = (LGSPNode)node; Insert(nodeUnique.uniqueId); //nodeUnique.uniqueId = -1; an index needs to access the old id }
public void Modify(GRGEN_LGSP.LGSPActionExecutionEnvironment actionEnv, GRGEN_LIBGR.IMatch _curMatch) { GRGEN_LGSP.LGSPGraph graph = actionEnv.graph; Match_testRule curMatch = (Match_testRule)_curMatch; GRGEN_LGSP.LGSPNode node_a = curMatch._node_a; GRGEN_LGSP.LGSPNode node_f = curMatch._node_f; GRGEN_LGSP.LGSPNode node_m = curMatch._node_m; graph.SettingAddedNodeNames(testRule_addedNodeNames); GRGEN_LGSP.LGSPNode node_are = graph.Retype(node_a, GRGEN_MODEL.NodeType_D2211_2222_31.typeVar); GRGEN_MODEL.ID2211_2222_31 inode_are = (GRGEN_MODEL.ID2211_2222_31)node_are; GRGEN_LGSP.LGSPNode node_fre = graph.Retype(node_f, GRGEN_MODEL.NodeType_D231_4121.typeVar); GRGEN_MODEL.ID231_4121 inode_fre = (GRGEN_MODEL.ID231_4121)node_fre; GRGEN_LGSP.LGSPNode node_mre = graph.Retype(node_m, GRGEN_MODEL.NodeType_D11_2221.typeVar); GRGEN_MODEL.ID11_2221 inode_mre = (GRGEN_MODEL.ID11_2221)node_mre; graph.SettingAddedEdgeNames(testRule_addedEdgeNames); { // eval_0 int tempvar_0 = (int )1234; graph.ChangingNodeAttribute(node_are, GRGEN_MODEL.NodeType_D2211_2222_31.AttributeType_d2211_2222_31, GRGEN_LIBGR.AttributeChangeType.Assign, tempvar_0, null); inode_are.@d2211_2222_31 = tempvar_0; graph.ChangedNodeAttribute(node_are, GRGEN_MODEL.NodeType_D2211_2222_31.AttributeType_d2211_2222_31); int tempvar_1 = (int )5678; graph.ChangingNodeAttribute(node_fre, GRGEN_MODEL.NodeType_D231_4121.AttributeType_d231_4121, GRGEN_LIBGR.AttributeChangeType.Assign, tempvar_1, null); inode_fre.@d231_4121 = tempvar_1; graph.ChangedNodeAttribute(node_fre, GRGEN_MODEL.NodeType_D231_4121.AttributeType_d231_4121); int tempvar_2 = (int )9012; graph.ChangingNodeAttribute(node_mre, GRGEN_MODEL.NodeType_D11_2221.AttributeType_d11_2221, GRGEN_LIBGR.AttributeChangeType.Assign, tempvar_2, null); inode_mre.@d11_2221 = tempvar_2; graph.ChangedNodeAttribute(node_mre, GRGEN_MODEL.NodeType_D11_2221.AttributeType_d11_2221); } return; }
public virtual void RetypingNode(INode oldNode, INode newNode) { LGSPNode oldNodeUnique = (LGSPNode)oldNode; LGSPNode newNodeUnique = (LGSPNode)newNode; newNodeUnique.uniqueId = oldNodeUnique.uniqueId; //oldNodeUnique.uniqueId = -1; an index needs to access the old id }
public override void RemovingNode(INode node) { LGSPNode nodeUnique = (LGSPNode)node; Insert(nodeUnique.uniqueId); //nodeUnique.uniqueId = -1; an index needs to access the old id index[nodeUnique.uniqueId] = null; }
public void CopyMatchContent(Match_testRule that) { _node_a = that._node_a; _node_f = that._node_f; _node_m = that._node_m; _edge__edge0 = that._edge__edge0; _edge__edge1 = that._edge__edge1; }
public override void RetypingNode(INode oldNode, INode newNode) { LGSPNode oldNodeUnique = (LGSPNode)oldNode; LGSPNode newNodeUnique = (LGSPNode)newNode; newNodeUnique.uniqueId = oldNodeUnique.uniqueId; //oldNodeUnique.uniqueId = -1; an index needs to access the old id index[newNodeUnique.uniqueId] = newNode; }
/// <summary> /// Adds a new edge to the graph and assigns it to the given variable. /// </summary> /// <param name="edgeType">The edge type for the new edge.</param> /// <param name="source">The source of the edge.</param> /// <param name="target">The target of the edge.</param> /// <param name="varName">The name of the variable.</param> /// <returns>The newly created edge.</returns> public LGSPEdge AddEdge(EdgeType edgeType, LGSPNode source, LGSPNode target, String varName) { LGSPEdge edge = (LGSPEdge)edgeType.CreateEdge(source, target); graph.AddEdgeWithoutEvents(edge, edgeType.TypeID); SetVariableValue(varName, edge); graph.EdgeAdded(edge); return(edge); }
/// <summary> /// Adds a new LGSPNode to the graph and assigns it to the given variable. /// </summary> /// <param name="nodeType">The node type for the new node.</param> /// <param name="varName">The name of the variable.</param> /// <returns>The newly created node.</returns> public LGSPNode AddLGSPNode(NodeType nodeType, String varName) { LGSPNode node = (LGSPNode)nodeType.CreateNode(); graph.AddNodeWithoutEvents(node, nodeType.TypeID); SetVariableValue(varName, node); graph.NodeAdded(node); return(node); }
void RemovingNodeListener(INode node) { LGSPNode lgspNode = (LGSPNode)node; if ((lgspNode.lgspFlags & (uint)LGSPElemFlags.HAS_VARIABLES) != 0) { foreach (Variable var in ElementMap[lgspNode]) { VariableMap.Remove(var.Name); } ElementMap.Remove(lgspNode); lgspNode.lgspFlags &= ~(uint)LGSPElemFlags.HAS_VARIABLES; } }
public readonly IGraph _graph; // for ToString only public LGSPUndoElemRedirecting(LGSPEdge edge, LGSPNode source, LGSPNode target, LGSPGraphProcessingEnvironment procEnv) { _edge = edge; _source = source; _target = target; if (procEnv.graph is LGSPNamedGraph) { _name = ((LGSPNamedGraph)procEnv.graph).GetElementName(_edge); } else { _name = "?"; } _graph = procEnv.graph; }
public void DoUndo(IGraphProcessingEnvironment procEnv) { String name; if (procEnv.Graph is LGSPNamedGraph && ((LGSPNamedGraph)procEnv.Graph).ElemToName.TryGetValue(_newElem, out name)) { LGSPNamedGraph lgspGraph = (LGSPNamedGraph)procEnv.Graph; if (_newElem is INode) { LGSPNode newNode = (LGSPNode)_newElem; LGSPNode oldNode = (LGSPNode)_oldElem; lgspGraph.ElemToName[oldNode] = name; lgspGraph.RetypingNode(newNode, oldNode); // this will switch the variables lgspGraph.ReplaceNode(newNode, oldNode); lgspGraph.ElemToName.Remove(newNode); lgspGraph.NameToElem[name] = oldNode; } else { LGSPEdge newEdge = (LGSPEdge)_newElem; LGSPEdge oldEdge = (LGSPEdge)_oldElem; lgspGraph.ElemToName[oldEdge] = name; lgspGraph.RetypingEdge(newEdge, oldEdge); // this will switch the variables lgspGraph.ReplaceEdge(newEdge, oldEdge); lgspGraph.ElemToName.Remove(newEdge); lgspGraph.NameToElem[name] = oldEdge; } } else { LGSPGraph lgspGraph = (LGSPGraph)procEnv.Graph; if (_newElem is INode) { LGSPNode newNode = (LGSPNode)_newElem; LGSPNode oldNode = (LGSPNode)_oldElem; lgspGraph.RetypingNode(newNode, oldNode); // this will switch the variables lgspGraph.ReplaceNode(newNode, oldNode); } else { LGSPEdge newEdge = (LGSPEdge)_newElem; LGSPEdge oldEdge = (LGSPEdge)_oldElem; lgspGraph.RetypingEdge(newEdge, oldEdge); // this will switch the variables lgspGraph.ReplaceEdge(newEdge, oldEdge); } } }
void RetypingNodeListener(INode oldNode, INode newNode) { LGSPNode oldLgspNode = (LGSPNode)oldNode; LGSPNode newLgspNode = (LGSPNode)newNode; if ((oldLgspNode.lgspFlags & (uint)LGSPElemFlags.HAS_VARIABLES) != 0) { LinkedList <Variable> varList = ElementMap[oldLgspNode]; foreach (Variable var in varList) { var.Value = newLgspNode; } ElementMap.Remove(oldLgspNode); ElementMap[newLgspNode] = varList; newLgspNode.lgspFlags |= (uint)LGSPElemFlags.HAS_VARIABLES; } }
public static GRGEN_MODEL.@UEdge CreateEdge(GRGEN_LGSP.LGSPNamedGraph graph, GRGEN_LGSP.LGSPNode source, GRGEN_LGSP.LGSPNode target, string edgeName) { GRGEN_MODEL.@UEdge edge; if (poolLevel == 0) { edge = new GRGEN_MODEL.@UEdge(source, target); } else { edge = pool[--poolLevel]; edge.lgspFlags &= ~(uint)GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES; edge.lgspSource = source; edge.lgspTarget = target; // implicit initialization, container creation of UEdge } graph.AddEdge(edge, edgeName); return(edge); }
public void AddNode(LGSPNode node, String elemName) { if (elemName != null && NameToElem.ContainsKey(elemName)) { throw new ArgumentException("The name \"" + elemName + "\" is already used!"); } if (elemName == null) { elemName = GetNextName(); } AddNodeWithoutEvents(node, node.lgspType.TypeID); NameToElem[elemName] = node; ElemToName[node] = elemName; NodeAdded(node); }
public virtual void NodeAdded(INode node) { LGSPNode nodeUnique = (LGSPNode)node; if (heap.Count == 1) // empty (one dummy needed for simpler arithmetic) { nodeUnique.uniqueId = nextNewId; ++nextNewId; if (graph.flagsPerThreadPerElement != null) // if not null there's some parallel matcher existing { EnlargeFlagsOfParallelizedMatcherAsNeeded(); } } else { nodeUnique.uniqueId = FetchAndRemoveMinimum(); } }
public override LGSPNode Retype(LGSPNode node, NodeType newNodeType) { String name; if (ElemToName.TryGetValue(node, out name)) // give new node the name of the old node in case it was named { LGSPNode newNode = (LGSPNode)newNodeType.CreateNodeWithCopyCommons(node); ElemToName[newNode] = name; RetypingNode(node, newNode); ReplaceNode(node, newNode); ElemToName.Remove(node); NameToElem[name] = newNode; return(newNode); } else { return(base.Retype(node, newNodeType)); } }
public static bool IsMatched(LGSPNode node, IMatch lastMatchAtPreviousNestingLevel) { Debug.Assert(lastMatchAtPreviousNestingLevel != null); // move through matches stack backwards to starting rule, // check if node is already matched somewhere on the derivation path IMatch match = lastMatchAtPreviousNestingLevel; while (match != null) { for (int i = 0; i < match.NumberOfNodes; ++i) { if (match.getNodeAt(i) == node) { return(true); } } match = match.MatchOfEnclosingPattern; } return(false); }
/// <summary> /// Detaches the specified variable from the according graph element. /// If it was the last variable pointing to the element, the variable list for the element is removed. /// This function may only called on variables pointing to graph elements. /// </summary> /// <param name="var">Variable to detach.</param> private void DetachVariableFromElement(Variable var) { IGraphElement elem = (IGraphElement)var.Value; LinkedList <Variable> oldVarList = ElementMap[elem]; oldVarList.Remove(var); if (oldVarList.Count == 0) { ElementMap.Remove(elem); LGSPNode oldNode = elem as LGSPNode; if (oldNode != null) { oldNode.lgspFlags &= ~(uint)LGSPElemFlags.HAS_VARIABLES; } else { LGSPEdge oldEdge = (LGSPEdge)elem; oldEdge.lgspFlags &= ~(uint)LGSPElemFlags.HAS_VARIABLES; } } }
public LGSPEdge AddEdge(EdgeType edgeType, LGSPNode source, LGSPNode target, String elemName) { if (elemName != null && NameToElem.ContainsKey(elemName)) { throw new ArgumentException("The name \"" + elemName + "\" is already used!"); } if (elemName == null) { elemName = GetNextName(); } LGSPEdge edge = (LGSPEdge)edgeType.CreateEdge(source, target); AddEdgeWithoutEvents(edge, edgeType.TypeID); NameToElem[elemName] = edge; ElemToName[edge] = elemName; EdgeAdded(edge); return(edge); }
public LGSPNode AddLGSPNode(NodeType nodeType, String elemName) { if (elemName != null && NameToElem.ContainsKey(elemName)) { throw new ArgumentException("The name \"" + elemName + "\" is already used!"); } if (elemName == null) { elemName = GetNextName(); } // LGSPNode node = new LGSPNode(nodeType); LGSPNode node = (LGSPNode)nodeType.CreateNode(); AddNodeWithoutEvents(node, nodeType.TypeID); NameToElem[elemName] = node; ElemToName[node] = elemName; NodeAdded(node); return(node); }
void CheckNodeInGraph(LGSPNode node) { LGSPNode head = nodesByTypeHeads[node.lgspType.TypeID]; LGSPNode cur = head.lgspTypeNext; while(cur != head) { if(cur == node) return; cur = cur.lgspTypeNext; } throw new Exception("Internal error: Node not in graph"); }
/// <summary> /// Checks whether the type ringlist starting at the given head node is broken. /// Use for debugging purposes. /// </summary> /// <param name="node">The node head to be checked.</param> public void CheckTypeRinglistBroken(LGSPNode head) { LGSPNode headNext = head.lgspTypeNext; if(headNext == null) throw new Exception("Internal error: Ringlist broken"); LGSPNode cur = headNext; LGSPNode next; while(cur != head) { if(cur != cur.lgspTypeNext.lgspTypePrev) throw new Exception("Internal error: Ringlist out of order"); next = cur.lgspTypeNext; if(next == null) throw new Exception("Internal error: Ringlist broken"); if(next == headNext) throw new Exception("Internal error: Ringlist loops bypassing head"); cur = next; } LGSPNode headPrev = head.lgspTypePrev; if(headPrev == null) throw new Exception("Internal error: Ringlist broken"); cur = headPrev; LGSPNode prev; while(cur != head) { if(cur != cur.lgspTypePrev.lgspTypeNext) throw new Exception("Internal error: Ringlist out of order"); prev = cur.lgspTypePrev; if(prev == null) throw new Exception("Internal error: Ringlist broken"); if(prev == headPrev) throw new Exception("Internal error: Ringlist loops bypassing head"); cur = prev; } }
/// <summary> /// Changes the source of the edge from the old source to the given new source, /// and changes the target node of the edge from the old target to the given new target. /// </summary> /// <param name="edge">The edge to redirect.</param> /// <param name="newSource">The new source node of the edge.</param> /// <param name="newTarget">The new target node of the edge.</param> /// <param name="oldSourceName">The name of the old source node (used for debug display of the new edge).</param> /// <param name="oldTargetName">The name of the old target node (used for debug display of the new edge).</param> public void RedirectSourceAndTarget(LGSPEdge edge, LGSPNode newSource, LGSPNode newTarget, string oldSourceName, string oldTargetName) { RedirectingEdge(edge); RemovingEdge(edge); edge.lgspSource.RemoveOutgoing(edge); newSource.AddOutgoing(edge); edge.lgspSource = newSource; edge.lgspTarget.RemoveIncoming(edge); newTarget.AddIncoming(edge); edge.lgspTarget = newTarget; nameOfSingleElementAdded[0] = "redirected from " + oldSourceName + " --> " + oldTargetName; SettingAddedEdgeNames(nameOfSingleElementAdded); EdgeAdded(edge); ++changesCounter; }
/// <summary> /// Merges the source node into the target node, /// i.e. all edges incident to the source node are redirected to the target node, then the source node is deleted. /// </summary> /// <param name="target">The node which remains after the merge.</param> /// <param name="source">The node to be merged.</param> /// <param name="sourceName">The name of the node to be merged (used for debug display of redirected edges).</param> public void Merge(LGSPNode target, LGSPNode source, string sourceName) { if (source == target) return; while(source.lgspOuthead!=null) { if(source.lgspOuthead.Target==source) RedirectSourceAndTarget(source.lgspOuthead, target, target, sourceName, sourceName); else RedirectSource(source.lgspOuthead, target, sourceName); } while (source.lgspInhead != null) { RedirectTarget(source.lgspInhead, target, sourceName); } Remove(source); }
void DoIt() { // create the LibGr Search Plan backend we want to use LGSPBackend backend = new LGSPBackend(); // the graph model we'll use JavaProgramGraphsGraphModel model = new JavaProgramGraphsGraphModel(); // the actions object for the rules we'll to use IActions ba; // import the instance graph we created with gxl2grs, using the the .gm we created by hand // (can't use import gxl for the program graph, because the given .gxl is severly rotten) // we throw away the named graph cause we don't need names here and they require about the same amount of memory as the graph itself; INamedGraph importedNamedGraph = (INamedGraph)Porter.Import("InstanceGraph.grs", backend, model, out ba); LGSPGraph graph = new LGSPGraph((LGSPNamedGraph)importedNamedGraph, "unnamed"); importedNamedGraph = null; // get the actions object for the rules we want to use JavaProgramGraphsActions actions = ba!=null ? (JavaProgramGraphsActions)ba : new JavaProgramGraphsActions(graph); // the graph processing environment we'll use LGSPGraphProcessingEnvironment procEnv = new LGSPGraphProcessingEnvironment(graph, actions); // the instance graph script uses variables to build up the graph, // we query some of them here, to get the elements to refactor // (instead of variables one could use the element names) Class src = (Class)procEnv.GetNodeVarValue("I176"); // class Node Class tgt = (Class)procEnv.GetNodeVarValue("I194"); // class Packet - use if parameter is used in moving method //Class tgt = (Class)graph.GetNodeVarValue("I617"); // class String - use if instance variable is used in moving method MethodBody mb = (MethodBody)procEnv.GetNodeVarValue("I409"); // method body of send // get operation for method body by: // get action, match action pattern with given parameters, apply rewrite filling given out parameters IMatchesExact<Rule_getOperation.IMatch_getOperation> matches = actions.getOperation.Match(procEnv, 1, mb); IOperation op; actions.getOperation.Modify(procEnv, matches.FirstExact, out op); // iterated application of action marking the body of the expression // (shows second way of getting action) int visitedFlagId = graph.AllocateVisitedFlag(); Debug.Assert(visitedFlagId==0); IGraphElement[] param = new LGSPNode[1]; param[0] = mb; IMatches matchesInexact; while((matchesInexact = actions.GetAction("markExpressionOfBody").Match(procEnv, 1, param)).Count == 1) { actions.GetAction("markExpressionOfBody").Modify(procEnv, matchesInexact.First); } // application of a graph rewrite sequence procEnv.SetVariableValue("src", src); procEnv.SetVariableValue("tgt", tgt); procEnv.SetVariableValue("mb", mb); procEnv.SetVariableValue("op", op); procEnv.ApplyGraphRewriteSequence( @"(p)=someParameterOfTargetType(mb,tgt) && !callToSuperExists && !isStatic(mb) && !methodNameExists(mb,tgt) && (!thisIsAccessed || thisIsAccessed && (srcparam)=addSourceParameter(op,src) && useSourceParameter(srcparam)*) && relinkOperationAndMethodBody(op,mb,src,tgt) && ( (call,pe)=getUnprocessedCallWithActualParameter(op,p) && ((def(srcparam) && addSourceToCall(call,srcparam)) || true) && (replaceAccess_Parameter_AccessWithoutLink(c,pe) || replaceAccess_Parameter_AccessWithLinkToExpression(c,pe)) )*"); Console.WriteLine(procEnv.PerformanceInfo.MatchesFound + " matches found."); procEnv.PerformanceInfo.Reset(); // unmark the body of the expression by searching all occurences and modifying them actions.unmarkExpression.ApplyAll(0, procEnv); graph.FreeVisitedFlag(visitedFlagId); // export changed graph (alternatively you may export it as InstanceGraphAfter.gxl) // if we'd use a NamedGraph we'd get the graph exported with its persistent names; so we get it exported with some hash names List<String> exportParameters = new List<string>(); exportParameters.Add("InstanceGraphAfter.grs"); Porter.Export(graph, exportParameters); }
/// <summary> /// Adds an existing LGSPNode object to the graph and assigns it to the given variable. /// The node must not be part of any graph, yet! /// The node may not be connected to any other elements! /// </summary> /// <param name="node">The node to be added.</param> /// <param name="varName">The name of the variable.</param> public void AddNode(LGSPNode node, String varName) { graph.AddNodeWithoutEvents(node, node.lgspType.TypeID); SetVariableValue(varName, node); graph.NodeAdded(node); }
public static Edge_connection CreateEdge(LGSPGraph graph, LGSPNode source, LGSPNode target) { Edge_connection edge = new Edge_connection(source, target); graph.AddEdge(edge); return edge; }
public Edge_fluffway(LGSPNode source, LGSPNode target) : base(EdgeType_fluffway.typeVar, source, target) { }
/// <summary> /// Retypes a node by creating a new node of the given type. /// All incident edges as well as all attributes from common super classes are kept. /// </summary> /// <param name="node">The node to be retyped.</param> /// <param name="newNodeType">The new type for the node.</param> /// <returns>The new node object representing the retyped node.</returns> public virtual LGSPNode Retype(LGSPNode node, NodeType newNodeType) { LGSPNode newNode = (LGSPNode) newNodeType.CreateNodeWithCopyCommons(node); RetypingNode(node, newNode); ReplaceNode(node, newNode); return newNode; }
private @UEdge(GRGEN_MODEL.@UEdge oldElem, GRGEN_LGSP.LGSPNode newSource, GRGEN_LGSP.LGSPNode newTarget) : base(GRGEN_MODEL.EdgeType_UEdge.typeVar, newSource, newTarget) { }
public @UEdge(GRGEN_LGSP.LGSPNode source, GRGEN_LGSP.LGSPNode target) : base(GRGEN_MODEL.EdgeType_UEdge.typeVar, source, target) { // implicit initialization, container creation of UEdge }
public static Edge_fluffway CreateEdge(LGSPGraph graph, LGSPNode source, LGSPNode target) { Edge_fluffway edge = new Edge_fluffway(source, target); graph.AddEdge(edge); return edge; }
public void AddNode(LGSPNode node, String elemName) { if(elemName != null && NameToElem.ContainsKey(elemName)) throw new ArgumentException("The name \"" + elemName + "\" is already used!"); if(elemName == null) elemName = GetNextName(); AddNodeWithoutEvents(node, node.lgspType.TypeID); NameToElem[elemName] = node; ElemToName[node] = elemName; NodeAdded(node); }
public override void AddNode(LGSPNode node) { AddNode(node, null); }
public Edge_connection(LGSPNode source, LGSPNode target) : base(EdgeType_connection.typeVar, source, target) { }
/// <summary> /// Sets source and target to the LGSPEdge object instantiated before with source and target being null. /// </summary> /// <param name="sourceNode">The source node.</param> /// <param name="targetNode">The target node.</param> public void SetSourceAndTarget(LGSPNode sourceNode, LGSPNode targetNode) { lgspSource = sourceNode; lgspTarget = targetNode; }
public override LGSPNode Retype(LGSPNode node, NodeType newNodeType) { String name; if(ElemToName.TryGetValue(node, out name)) // give new node the name of the old node in case it was named { LGSPNode newNode = (LGSPNode)newNodeType.CreateNodeWithCopyCommons(node); ElemToName[newNode] = name; RetypingNode(node, newNode); ReplaceNode(node, newNode); ElemToName.Remove(node); NameToElem[name] = newNode; return newNode; } else return base.Retype(node, newNodeType); }
public override LGSPEdge AddEdge(EdgeType edgeType, LGSPNode source, LGSPNode target) { return AddEdge(edgeType, source, target, null); }
/// <summary> /// Builds a pattern graph out of the graph. /// The pattern graph retains links to the original graph elements and uses them for attribute comparison. /// </summary> /// <param name="graph">The graph which is to be transfered into a pattern</param> /// <returns></returns> private static PatternGraph BuildPatternGraph(IGraph graph) { int numNodes = graph.NumNodes; int numEdges = graph.NumEdges; int count = 0; PatternNode[] nodes = new PatternNode[numNodes]; INode[] correspondingNodes = new INode[numNodes]; foreach (INode node in graph.Nodes) { LGSPNode n = (LGSPNode)node; nodes[count] = new PatternNode( n.Type.TypeID, n.Type, n.Type.PackagePrefixedName, graph.Name + "_node_" + count, "node_" + count, null, null, 1.0f, -1, false, null, null, null, null, null, null, false, null ); correspondingNodes[count] = node; ++count; } count = 0; PatternEdge[] edges = new PatternEdge[numEdges]; IEdge[] correspondingEdges = new IEdge[numEdges]; foreach (IEdge edge in graph.Edges) { LGSPEdge e = (LGSPEdge)edge; edges[count] = new PatternEdge( true, e.Type.TypeID, e.Type, e.Type.PackagePrefixedName, graph.Name + "_edge_" + count, "edge_" + count, null, null, 1.0f, -1, false, null, null, null, null, null, null, false, null ); correspondingEdges[count] = edge; ++count; } bool[,] homNodes = new bool[numNodes, numNodes]; for (int i = 0; i < numNodes; ++i) { for (int j = 0; j < numNodes; ++j) { homNodes[i, j] = false; } } bool[,] homEdges = new bool[numEdges, numEdges]; for (int i = 0; i < numEdges; ++i) { for (int j = 0; j < numEdges; ++j) { homEdges[i, j] = false; } } bool[,] homNodesGlobal = new bool[numNodes, numNodes]; for (int i = 0; i < numNodes; ++i) { for (int j = 0; j < numNodes; ++j) { homNodesGlobal[i, j] = false; } } bool[,] homEdgesGlobal = new bool[numEdges, numEdges]; for (int i = 0; i < numEdges; ++i) { for (int j = 0; j < numEdges; ++j) { homEdgesGlobal[i, j] = false; } } bool[] totallyHomNodes = new bool[numNodes]; for (int i = 0; i < numNodes; ++i) { totallyHomNodes[i] = false; } bool[] totallyHomEdges = new bool[numEdges]; for (int i = 0; i < numEdges; ++i) { totallyHomEdges[i] = false; } List <PatternCondition> pcs = new List <PatternCondition>(); for (int i = 0; i < numNodes; ++i) { if (nodes[i].Type.NumAttributes > 0) { pcs.Add(new PatternCondition(new expression.AreAttributesEqual(correspondingNodes[i], nodes[i]), new string[] { nodes[i].name }, new string[] { }, new string[] { }, new PatternNode[] { nodes[i] }, new PatternEdge[] { }, new PatternVariable[] { })); } } for (int i = 0; i < numEdges; ++i) { if (edges[i].Type.NumAttributes > 0) { pcs.Add(new PatternCondition(new expression.AreAttributesEqual(correspondingEdges[i], edges[i]), new string[] { }, new string[] { edges[i].name }, new string[] { }, new PatternNode[] { }, new PatternEdge[] { edges[i] }, new PatternVariable[] { })); } } PatternCondition[] patternConditions = pcs.ToArray(); PatternGraph patternGraph = new PatternGraph( graph.Name, nodes, edges, patternConditions, homNodes, homEdges, homNodesGlobal, homEdgesGlobal, totallyHomNodes, totallyHomEdges, correspondingNodes, correspondingEdges ); foreach (PatternNode node in nodes) { node.pointOfDefinition = patternGraph; } foreach (PatternEdge edge in edges) { edge.pointOfDefinition = patternGraph; } foreach (IEdge edge in graph.Edges) { int edgeIndex = Array.IndexOf <IEdge>(correspondingEdges, edge); int sourceIndex = Array.IndexOf <INode>(correspondingNodes, edge.Source); int targetIndex = Array.IndexOf <INode>(correspondingNodes, edge.Target); patternGraph.edgeToSourceNode.Add(edges[edgeIndex], nodes[sourceIndex]); patternGraph.edgeToTargetNode.Add(edges[edgeIndex], nodes[targetIndex]); } PatternGraphAnalyzer.PrepareInline(patternGraph); return(patternGraph); }
public static bool IsMatched(LGSPNode node, IMatch lastMatchAtPreviousNestingLevel) { Debug.Assert(lastMatchAtPreviousNestingLevel!=null); // move through matches stack backwards to starting rule, // check if node is already matched somewhere on the derivation path IMatch match = lastMatchAtPreviousNestingLevel; while (match != null) { for (int i = 0; i < match.NumberOfNodes; ++i) { if (match.getNodeAt(i) == node) { return true; } } match = match.MatchOfEnclosingPattern; } return false; }
/// <summary> /// Adds an existing node to this graph. /// The graph may not already contain the node! /// The edge may not be connected to any other elements! /// Intended only for undo, clone, retyping and internal use! /// </summary> public void AddNodeWithoutEvents(LGSPNode node, int typeid) { #if CHECK_RINGLISTS CheckNodeAlreadyInTypeRinglist(node); #endif LGSPNode head = nodesByTypeHeads[typeid]; LGSPNode oldTypeNext = head.lgspTypeNext; LGSPNode oldTypePrev = head.lgspTypePrev; head.lgspTypeNext.lgspTypePrev = node; node.lgspTypeNext = head.lgspTypeNext; node.lgspTypePrev = head; head.lgspTypeNext = node; ++nodesByTypeCounts[typeid]; ++changesCounter; #if CHECK_RINGLISTS CheckTypeRinglistBroken(head); #endif }
/// <summary> /// Changes the source node of the edge from the old source to the given new source. /// </summary> /// <param name="edge">The edge to redirect.</param> /// <param name="newSource">The new source node of the edge.</param> /// <param name="oldSourceName">The name of the old source node (used for debug display of the new edge).</param> public void RedirectSource(LGSPEdge edge, LGSPNode newSource, string oldSourceName) { RedirectingEdge(edge); RemovingEdge(edge); edge.lgspSource.RemoveOutgoing(edge); newSource.AddOutgoing(edge); edge.lgspSource = newSource; nameOfSingleElementAdded[0] = "redirected from " + oldSourceName + " --> ."; SettingAddedEdgeNames(nameOfSingleElementAdded); EdgeAdded(edge); ++changesCounter; }
/// <summary> /// Adds a new edge to the graph. /// </summary> /// <param name="edgeType">The edge type for the new edge.</param> /// <param name="source">The source of the edge.</param> /// <param name="target">The target of the edge.</param> /// <returns>The newly created edge.</returns> public virtual LGSPEdge AddEdge(EdgeType edgeType, LGSPNode source, LGSPNode target) { // LGSPEdge edge = new LGSPEdge(edgeType, source, target); LGSPEdge edge = (LGSPEdge) edgeType.CreateEdge(source, target); AddEdgeWithoutEvents(edge, edgeType.TypeID); EdgeAdded(edge); return edge; }
/// <summary> /// Checks if the given node is already available in its type ringlist /// </summary> public void CheckNodeAlreadyInTypeRinglist(LGSPNode node) { LGSPNode head = nodesByTypeHeads[node.lgspType.TypeID]; LGSPNode cur = head.lgspTypeNext; while(cur != head) { if(cur == node) throw new Exception("Internal error: Node already available in ringlist"); cur = cur.lgspTypeNext; } cur = head.lgspTypePrev; while(cur != head) { if(cur == node) throw new Exception("Internal error: Node already available in ringlist"); cur = cur.lgspTypePrev; } }
public IGraph _graph; // for ToString only public LGSPUndoElemRedirecting(LGSPEdge edge, LGSPNode source, LGSPNode target, LGSPGraphProcessingEnvironment procEnv) { _edge = edge; _source = source; _target = target; if(procEnv.graph is LGSPNamedGraph) _name = ((LGSPNamedGraph)procEnv.graph).GetElementName(_edge); else _name = "?"; _graph = procEnv.graph; }
/// <summary> /// Checks whether the incoming or outgoing ringlists of the given node are broken. /// Use for debugging purposes. /// </summary> /// <param name="node">The node to be checked.</param> public void CheckInOutRinglistsBroken(LGSPNode node) { LGSPEdge inHead = node.lgspInhead; if(inHead != null) { LGSPEdge headNext = inHead.lgspInNext; if(headNext == null) throw new Exception("Internal error: in Ringlist broken"); LGSPEdge cur = headNext; LGSPEdge next; while(cur != inHead) { if(cur != cur.lgspInNext.lgspInPrev) throw new Exception("Internal error: Ringlist out of order"); next = cur.lgspInNext; if(next == null) throw new Exception("Internal error: Ringlist broken"); if(next == headNext) throw new Exception("Internal error: Ringlist loops bypassing head"); cur = next; } } if(inHead != null) { LGSPEdge headPrev = inHead.lgspInPrev; if(headPrev == null) throw new Exception("Internal error: Ringlist broken"); LGSPEdge cur = headPrev; LGSPEdge prev; while(cur != inHead) { if(cur != cur.lgspInPrev.lgspInNext) throw new Exception("Internal error: Ringlist out of order"); prev = cur.lgspInPrev; if(prev == null) throw new Exception("Internal error: Ringlist broken"); if(prev == headPrev) throw new Exception("Internal error: Ringlist loops bypassing head"); cur = prev; } } LGSPEdge outHead = node.lgspOuthead; if(outHead != null) { LGSPEdge headNext = outHead.lgspOutNext; if(headNext == null) throw new Exception("Internal error: Ringlist broken"); LGSPEdge cur = headNext; LGSPEdge next; while(cur != outHead) { if(cur != cur.lgspOutNext.lgspOutPrev) throw new Exception("Internal error: Ringlist out of order"); next = cur.lgspOutNext; if(next == null) throw new Exception("Internal error: Ringlist broken"); if(next == headNext) throw new Exception("Internal error: Ringlist loops bypassing head"); cur = next; } } if(outHead != null) { LGSPEdge headPrev = outHead.lgspOutPrev; if(headPrev == null) throw new Exception("Internal error: Ringlist broken"); LGSPEdge cur = headPrev; LGSPEdge prev; while(cur != outHead) { if(cur != cur.lgspOutPrev.lgspOutNext) throw new Exception("Internal error: Ringlist out of order"); prev = cur.lgspOutPrev; if(prev == null) throw new Exception("Internal error: Ringlist broken"); if(prev == headPrev) throw new Exception("Internal error: Ringlist loops bypassing head"); cur = prev; } } }
public Edge_Edge(LGSPNode source, LGSPNode target) : base(EdgeType_Edge.typeVar, source, target) { }
/// <summary> /// Moves the type list head of the given node after the given node. /// Part of the "list trick". /// </summary> /// <param name="elem">The node.</param> public void MoveHeadAfter(LGSPNode elem) { if(elem.lgspType == null) return; // elem is head LGSPNode head = nodesByTypeHeads[elem.lgspType.TypeID]; head.lgspTypePrev.lgspTypeNext = head.lgspTypeNext; head.lgspTypeNext.lgspTypePrev = head.lgspTypePrev; elem.lgspTypeNext.lgspTypePrev = head; head.lgspTypeNext = elem.lgspTypeNext; head.lgspTypePrev = elem; elem.lgspTypeNext = head; }
public LGSPEdge AddEdge(EdgeType edgeType, LGSPNode source, LGSPNode target, String elemName) { if(elemName != null && NameToElem.ContainsKey(elemName)) throw new ArgumentException("The name \"" + elemName + "\" is already used!"); if(elemName == null) elemName = GetNextName(); // LGSPEdge edge = new LGSPEdge(edgeType, source, target); LGSPEdge edge = (LGSPEdge)edgeType.CreateEdge(source, target); AddEdgeWithoutEvents(edge, edgeType.TypeID); NameToElem[elemName] = edge; ElemToName[edge] = elemName; EdgeAdded(edge); return edge; }
/// <summary> /// Adds an existing LGSPNode object to the graph. /// The node must not be part of any graph, yet! /// The node may not be connected to any other elements! /// </summary> /// <param name="node">The node to be added.</param> public virtual void AddNode(LGSPNode node) { AddNodeWithoutEvents(node, node.lgspType.TypeID); NodeAdded(node); }
public override LGSPEdge AddEdge(EdgeType edgeType, LGSPNode source, LGSPNode target) { return(AddEdge(edgeType, source, target, null)); }
internal void RemoveNodeWithoutEvents(LGSPNode node, int typeid) { node.lgspTypePrev.lgspTypeNext = node.lgspTypeNext; node.lgspTypeNext.lgspTypePrev = node.lgspTypePrev; node.lgspTypeNext = null; node.lgspTypePrev = null; --nodesByTypeCounts[typeid]; ++changesCounter; if(reuseOptimization) node.Recycle(); #if CHECK_RINGLISTS CheckTypeRinglistBroken(nodesByTypeHeads[typeid]); #endif }
/// <summary> /// Adds a new edge to the graph and assigns it to the given variable. /// </summary> /// <param name="edgeType">The edge type for the new edge.</param> /// <param name="source">The source of the edge.</param> /// <param name="target">The target of the edge.</param> /// <param name="varName">The name of the variable.</param> /// <returns>The newly created edge.</returns> public LGSPEdge AddEdge(EdgeType edgeType, LGSPNode source, LGSPNode target, String varName) { // LGSPEdge edge = new LGSPEdge(edgeType, source, target); LGSPEdge edge = (LGSPEdge)edgeType.CreateEdge(source, target); graph.AddEdgeWithoutEvents(edge, edgeType.TypeID); SetVariableValue(varName, edge); graph.EdgeAdded(edge); return edge; }
/// <summary> /// Replaces a given node by another one. /// All incident edges and variables are transferred to the new node. /// The attributes are not touched. /// This function is used for retyping. /// </summary> /// <param name="oldNode">The node to be replaced.</param> /// <param name="newNode">The replacement for the node.</param> public void ReplaceNode(LGSPNode oldNode, LGSPNode newNode) { if(oldNode.lgspType != newNode.lgspType) { if(!oldNode.Valid) throw new Exception("Fatal failure at retyping: The old node is not a member of the graph (any more)."); oldNode.lgspTypePrev.lgspTypeNext = oldNode.lgspTypeNext; oldNode.lgspTypeNext.lgspTypePrev = oldNode.lgspTypePrev; nodesByTypeCounts[oldNode.lgspType.TypeID]--; AddNodeWithoutEvents(newNode, newNode.lgspType.TypeID); } else { newNode.lgspTypeNext = oldNode.lgspTypeNext; newNode.lgspTypePrev = oldNode.lgspTypePrev; oldNode.lgspTypeNext.lgspTypePrev = newNode; oldNode.lgspTypePrev.lgspTypeNext = newNode; } oldNode.lgspTypeNext = newNode; // indicate replacement (checked in rewrite for hom nodes) oldNode.lgspTypePrev = null; // indicate node is node valid anymore // Reassign all outgoing edges LGSPEdge outHead = oldNode.lgspOuthead; if(outHead != null) { LGSPEdge outCur = outHead; do { outCur.lgspSource = newNode; outCur = outCur.lgspOutNext; } while(outCur != outHead); } newNode.lgspOuthead = outHead; // Reassign all incoming edges LGSPEdge inHead = oldNode.lgspInhead; if(inHead != null) { LGSPEdge inCur = inHead; do { inCur.lgspTarget = newNode; inCur = inCur.lgspInNext; } while(inCur != inHead); } newNode.lgspInhead = inHead; ++changesCounter; if(reuseOptimization) oldNode.Recycle(); #if CHECK_RINGLISTS CheckTypeRinglistBroken(nodesByTypeHeads[newNode.lgspType.TypeID]); CheckInOutRinglistsBroken(newNode); #endif }
/// <summary> /// Instantiates an LGSPEdge object. /// </summary> /// <param name="edgeType">The edge type.</param> /// <param name="sourceNode">The source node.</param> /// <param name="targetNode">The target node.</param> protected LGSPEdge(EdgeType edgeType, LGSPNode sourceNode, LGSPNode targetNode) { lgspType = edgeType; lgspSource = sourceNode; lgspTarget = targetNode; }