protected override bool PreExecuteInstruction()
{
if (CurrentContext.InstructionPointer >= CurrentContext.Script.Length)
{
return(true);
}
gas_consumed = checked (gas_consumed + GetPrice() * ratio);
if (!testMode && gas_consumed > gas_amount)
{
if (DumpInfo != null)
{
DumpInfo.Error("gas_consumed > gas_amount");
}
return(false);
}
if (!CheckDynamicInvoke())
{
if (DumpInfo != null)
{
DumpInfo.Error("CheckDynamicInvoke");
}
return(false);
}
return(true);
}
internal String GetNodeRealizer(NodeType type, DumpInfo dumpInfo)
{
return(GetNodeRealizer(dumpInfo.GetNodeTypeColor(type),
dumpInfo.GetNodeTypeBorderColor(type),
dumpInfo.GetNodeTypeTextColor(type),
dumpInfo.GetNodeTypeShape(type)).Name);
}
internal String GetEdgeRealizer(EdgeType type, DumpInfo dumpInfo)
{
return(GetEdgeRealizer(dumpInfo.GetEdgeTypeColor(type),
dumpInfo.GetEdgeTypeTextColor(type),
dumpInfo.GetEdgeTypeThickness(type),
dumpInfo.GetEdgeTypeLineStyle(type)).Name);
}
public void DumpToJson()
{
if (dumpInfo != null)
{
return;
}
dumpInfo = new DumpInfo();
dumpInfo.collectionName = this.variantCollection.name;
dumpInfo.shaderInfos = new List <DumpShaderInfo>();
foreach (var shader in this.shaders)
{
ShaderVariants variants;
DumpShaderInfo shaderInfo = new DumpShaderInfo();
shaderInfo.shaderName = shader.name;
if (shaderVariants.TryGetValue(shader, out variants))
{
shaderInfo.keywords = new List <string>(variants.keywordNames);
shaderInfo.keywords.Sort();
}
this.dumpInfo.shaderInfos.Add(shaderInfo);
}
string str = JsonUtility.ToJson(this.dumpInfo);
string dir = ShaderItemUI.SaveDIR + '/' + this.dateStr + "/variants";
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
string jsonFile = Path.Combine(dir, this.variantCollection.name + ".json");
File.WriteAllText(jsonFile, str);
}
private bool PreStepInto(OpCode nextOpcode)
{
if (CurrentContext.InstructionPointer >= CurrentContext.Script.Length)
{
return(true);
}
gas_consumed = checked (gas_consumed + GetPrice(nextOpcode) * ratio);
if (!testMode && gas_consumed > gas_amount)
{
if (DumpInfo != null)
{
DumpInfo.Error("gas_consumed > gas_amount");
}
return(false);
}
if (!CheckItemSize(nextOpcode))
{
if (DumpInfo != null)
{
DumpInfo.Error("CheckItemSize");
}
return(false);
}
if (!CheckArraySize(nextOpcode))
{
if (DumpInfo != null)
{
DumpInfo.Error("CheckArraySize");
}
return(false);
}
if (!CheckInvocationStack(nextOpcode))
{
if (DumpInfo != null)
{
DumpInfo.Error("CheckInvocationStack");
}
return(false);
}
if (!CheckBigIntegers(nextOpcode))
{
if (DumpInfo != null)
{
DumpInfo.Error("CheckBigIntegers");
}
return(false);
}
if (!CheckDynamicInvoke(nextOpcode))
{
if (DumpInfo != null)
{
DumpInfo.Error("CheckDynamicInvoke");
}
return(false);
}
return(true);
}
public static string GetNewDumpPath(DumpInfo dump)
{
string result;
do
{
result = Path.Combine(dump.Location, $"{dump.Name}_{DateTime.Now:yyMMdd_HHmmss}.dmp");
}while (File.Exists(result));
return(result);
}
public ShellGraphProcessingEnvironment(INamedGraph graph, String backendFilename, String[] backendParameters, String modelFilename)
{
LGSPNamedGraph Graph = (LGSPNamedGraph)graph;
DumpInfo = new DumpInfo(Graph.GetElementName);
SubruleDebugConfig = new SubruleDebuggingConfiguration();
BackendFilename = backendFilename;
BackendParameters = backendParameters;
ModelFilename = modelFilename;
ProcEnv = new LGSPGraphProcessingEnvironment(Graph, null);
NameToSubgraph.Add(Graph.Name, Graph);
}
public static void Main(string[] args)
{
LGSPNamedGraph graph;
LGSPActions actions;
LGSPGraphProcessingEnvironment procEnv;
try
{
LGSPBackend.Instance.CreateNamedFromSpec("Mutex.grg", null, 0, out graph, out actions);
procEnv = new LGSPGraphProcessingEnvironment(graph, actions);
}
catch (Exception ex)
{
Console.WriteLine("Unable to create graph from specification: " + ex.Message);
return;
}
DumpInfo dumpInfo = new DumpInfo(graph.GetElementName);
YCompClient ycomp = YCompClient.CreateYCompClient(graph, "Organic", dumpInfo);
// Let yComp observe any changes to the graph
ycomp.RegisterLibGrEvents();
NodeType processType = graph.GetNodeType("Process");
EdgeType nextType = graph.GetEdgeType("next");
LGSPNode p1 = graph.AddLGSPNode(processType);
LGSPNode p2 = graph.AddLGSPNode(processType);
graph.AddEdge(nextType, p1, p2);
graph.AddEdge(nextType, p2, p1);
PrintAndWait("Initial 2-process ring constructed.", ycomp);
procEnv.ApplyGraphRewriteSequence("newRule[5] && mountRule && requestRule[7]");
PrintAndWait("Initialized 7-process ring with resource and requests.", ycomp);
ycomp.UnregisterLibGrEvents();
Console.WriteLine("Do many changes slowing down too much with YComp (not in this example)...");
procEnv.ApplyGraphRewriteSequence("(takeRule && releaseRule && giveRule)*");
PrintAndWait("Nothing changed so far on the display.", ycomp);
ycomp.ClearGraph();
UploadGraph(graph, ycomp);
PrintAndWait("Graph newly uploaded to yComp.", ycomp);
ycomp.RegisterLibGrEvents();
actions.GetAction("newRule").ApplyMinMax(procEnv, 4, 4);
PrintAndWait("Added 4 processes in the ring.", ycomp);
ycomp.Close();
}
public static void Main(string[] args)
{
LGSPNamedGraph graph;
LGSPActions actions;
LGSPGraphProcessingEnvironment procEnv;
try
{
new LGSPBackend().CreateNamedFromSpec("Mutex.grg", null, 0, out graph, out actions);
procEnv = new LGSPGraphProcessingEnvironment(graph, actions);
}
catch(Exception ex)
{
Console.WriteLine("Unable to create graph from specification: " + ex.Message);
return;
}
DumpInfo dumpInfo = new DumpInfo(graph.GetElementName);
YCompClient ycomp = YCompClient.CreateYCompClient(graph, "Organic", dumpInfo);
// Let yComp observe any changes to the graph
ycomp.RegisterLibGrEvents();
NodeType processType = graph.GetNodeType("Process");
EdgeType nextType = graph.GetEdgeType("next");
LGSPNode p1 = graph.AddLGSPNode(processType);
LGSPNode p2 = graph.AddLGSPNode(processType);
graph.AddEdge(nextType, p1, p2);
graph.AddEdge(nextType, p2, p1);
PrintAndWait("Initial 2-process ring constructed.", ycomp);
procEnv.ApplyGraphRewriteSequence("newRule[5] && mountRule && requestRule[7]");
PrintAndWait("Initialized 7-process ring with resource and requests.", ycomp);
ycomp.UnregisterLibGrEvents();
Console.WriteLine("Do many changes slowing down too much with YComp (not in this example)...");
procEnv.ApplyGraphRewriteSequence("(takeRule && releaseRule && giveRule)*");
PrintAndWait("Nothing changed so far on the display.", ycomp);
ycomp.ClearGraph();
UploadGraph(graph, ycomp);
PrintAndWait("Graph newly uploaded to yComp.", ycomp);
ycomp.RegisterLibGrEvents();
actions.GetAction("newRule").ApplyMinMax(procEnv, 4, 4);
PrintAndWait("Added 4 processes in the ring.", ycomp);
ycomp.Close();
}
/// <summary>
/// Creates a new YCompClient instance and connects to the local YComp server.
/// If it is not available a SocketException is thrown
/// </summary>
public YCompClient(INamedGraph graph, String layoutModule, int connectionTimeout, int port, DumpInfo dumpInfo)
{
this.graph = graph;
this.dumpInfo = dumpInfo;
int startTime = Environment.TickCount;
do
{
try
{
ycompClient = new TcpClient("localhost", port);
}
catch (SocketException)
{
ycompClient = null;
Thread.Sleep(1000);
}
} while(ycompClient == null && Environment.TickCount - startTime < connectionTimeout);
if (ycompClient == null)
{
throw new Exception("Connection timeout!");
}
ycompStream = new YCompStream(ycompClient);
SetLayout(layoutModule);
NormalNodeRealizer = GetNodeRealizer(GrColor.Yellow, GrColor.DarkYellow, GrColor.Black, GrNodeShape.Box);
MatchedNodeRealizer = GetNodeRealizer(GrColor.Khaki, GrColor.DarkYellow, GrColor.Black, GrNodeShape.Box);
NewNodeRealizer = GetNodeRealizer(GrColor.LightRed, GrColor.DarkYellow, GrColor.Black, GrNodeShape.Box);
DeletedNodeRealizer = GetNodeRealizer(GrColor.LightGrey, GrColor.DarkYellow, GrColor.Black, GrNodeShape.Box);
NormalEdgeRealizer = GetEdgeRealizer(GrColor.DarkYellow, GrColor.Black, 1, GrLineStyle.Continuous);
MatchedEdgeRealizer = GetEdgeRealizer(GrColor.DarkYellow, GrColor.Black, 2, GrLineStyle.Continuous);
NewEdgeRealizer = GetEdgeRealizer(GrColor.LightRed, GrColor.Black, 2, GrLineStyle.Continuous);
DeletedEdgeRealizer = GetEdgeRealizer(GrColor.LightGrey, GrColor.Black, 2, GrLineStyle.Continuous);
dumpInfo.OnNodeTypeAppearanceChanged += new NodeTypeAppearanceChangedHandler(OnNodeTypeAppearanceChanged);
dumpInfo.OnEdgeTypeAppearanceChanged += new EdgeTypeAppearanceChangedHandler(OnEdgeTypeAppearanceChanged);
dumpInfo.OnTypeInfotagsChanged += new TypeInfotagsChangedHandler(OnTypeInfotagsChanged);
}
/// <summary>
/// Creates a new YCompClient instance and connects to the local YComp server.
/// If it is not available a SocketException is thrown
/// </summary>
public YCompClient(INamedGraph graph, String layoutModule, int connectionTimeout, int port,
DumpInfo dumpInfo, ElementRealizers realizers, Dictionary <string, IObject> nameToClassObject)
{
this.graph = graph;
this.dumpInfo = dumpInfo;
int startTime = Environment.TickCount;
do
{
try
{
ycompClient = new TcpClient("localhost", port);
}
catch (SocketException)
{
ycompClient = null;
Thread.Sleep(1000);
}
}while(ycompClient == null && Environment.TickCount - startTime < connectionTimeout);
if (ycompClient == null)
{
throw new Exception("Connection timeout!");
}
ycompStream = new YCompStream(ycompClient);
SetLayout(layoutModule);
dumpInfo.OnNodeTypeAppearanceChanged += new NodeTypeAppearanceChangedHandler(OnNodeTypeAppearanceChanged);
dumpInfo.OnEdgeTypeAppearanceChanged += new EdgeTypeAppearanceChangedHandler(OnEdgeTypeAppearanceChanged);
dumpInfo.OnTypeInfotagsChanged += new TypeInfotagsChangedHandler(OnTypeInfotagsChanged);
this.realizers = realizers;
realizers.RegisterYComp(this);
this.nameToClassObject = nameToClassObject;
// TODO: Add group related events
}
/// <summary>
/// Creates a new YCompClient instance and connects to the local YComp server.
/// If it is not available a SocketException is thrown
/// </summary>
public YCompClient(INamedGraph graph, String layoutModule, int connectionTimeout, int port, DumpInfo dumpInfo, ElementRealizers realizers)
{
this.graph = graph;
this.dumpInfo = dumpInfo;
int startTime = Environment.TickCount;
do
{
try
{
ycompClient = new TcpClient("localhost", port);
}
catch(SocketException)
{
ycompClient = null;
Thread.Sleep(1000);
}
} while(ycompClient == null && Environment.TickCount - startTime < connectionTimeout);
if(ycompClient == null)
throw new Exception("Connection timeout!");
ycompStream = new YCompStream(ycompClient);
SetLayout(layoutModule);
dumpInfo.OnNodeTypeAppearanceChanged += new NodeTypeAppearanceChangedHandler(OnNodeTypeAppearanceChanged);
dumpInfo.OnEdgeTypeAppearanceChanged += new EdgeTypeAppearanceChangedHandler(OnEdgeTypeAppearanceChanged);
dumpInfo.OnTypeInfotagsChanged += new TypeInfotagsChangedHandler(OnTypeInfotagsChanged);
this.realizers = realizers;
realizers.RegisterYComp(this);
// TODO: Add group related events
}
private static void DumpNode(INode node, GrColor textColor, GrColor color, GrColor borderColor,
GrNodeShape shape, IDumper dumper, DumpInfo dumpInfo)
{
dumper.DumpNode(node, GetElemLabel(node, dumpInfo), DumpAttributes(node), textColor,
color, borderColor, shape);
}
private static void DumpEdge(IEdge edge, GrColor textColor, GrColor color, GrLineStyle style,
int thickness, IDumper dumper, DumpInfo dumpInfo)
{
dumper.DumpEdge(edge.Source, edge.Target, GetElemLabel(edge, dumpInfo), DumpAttributes(edge),
textColor, color, style, thickness);
}
/// <summary>
/// Dumps the given matches.
/// </summary>
/// <param name="dumper">The graph dumper to be used.</param>
/// <param name="dumpInfo">Specifies how the graph shall be dumped.</param>
/// <param name="matches">An IMatches object containing the matches.</param>
/// <param name="which">Which match to dump, or AllMatches for dumping all matches
/// adding connections between them, or OnlyMatches to dump the matches only</param>
public static void DumpMatchOnly(IDumper dumper, DumpInfo dumpInfo, IMatches matches, DumpMatchSpecial which,
ref Set<INode> matchedNodes, ref Set<INode> multiMatchedNodes, ref Set<IEdge> matchedEdges, ref Set<IEdge> multiMatchedEdges)
{
matchedNodes = new Set<INode>();
matchedEdges = new Set<IEdge>();
if((int)which >= 0 && (int)which < matches.Count)
{
// Show exactly one match
IMatch match = matches.GetMatch((int)which);
matchedNodes.Add(match.Nodes);
matchedEdges.Add(match.Edges);
}
else
{
GrColor vnodeColor = dumpInfo.GetNodeDumpTypeColor(GrElemDumpType.VirtualMatch);
GrColor vedgeColor = dumpInfo.GetEdgeDumpTypeColor(GrElemDumpType.VirtualMatch);
GrColor vnodeBorderColor = dumpInfo.GetNodeDumpTypeBorderColor(GrElemDumpType.VirtualMatch);
GrColor vnodeTextColor = dumpInfo.GetNodeDumpTypeTextColor(GrElemDumpType.VirtualMatch);
GrColor vedgeTextColor = dumpInfo.GetEdgeDumpTypeTextColor(GrElemDumpType.VirtualMatch);
GrNodeShape vnodeShape = dumpInfo.GetNodeDumpTypeShape(GrElemDumpType.VirtualMatch);
GrLineStyle vedgeLineStyle = dumpInfo.GetEdgeDumpTypeLineStyle(GrElemDumpType.VirtualMatch);
int vedgeThickness = dumpInfo.GetEdgeDumpTypeThickness(GrElemDumpType.VirtualMatch);
multiMatchedNodes = new Set<INode>();
multiMatchedEdges = new Set<IEdge>();
// TODO: May edges to nodes be dumped before those nodes exist??
// TODO: Should indices in strings start at 0 or 1? (original: 0)
// Dump all matches with virtual nodes
int i = 0;
foreach(IMatch match in matches)
{
VirtualNode virtNode = new VirtualNode(-i - 1);
dumper.DumpNode(virtNode, String.Format("{0}. match of {1}", i + 1, matches.Producer.Name),
null, vnodeTextColor, vnodeColor, vnodeBorderColor, vnodeShape);
int j = 1;
foreach(INode node in match.Nodes)
{
dumper.DumpEdge(virtNode, node, String.Format("node {0}", j++), null,
vedgeTextColor, vedgeColor, vedgeLineStyle, vedgeThickness);
if(matchedNodes.Contains(node)) multiMatchedNodes.Add(node);
else matchedNodes.Add(node);
}
// Collect matched edges
foreach(IEdge edge in match.Edges)
{
if(matchedEdges.Contains(edge)) multiMatchedEdges.Add(edge);
else matchedEdges.Add(edge);
}
i++;
}
if(which == DumpMatchSpecial.OnlyMatches)
{
// Dump the matches only
// First dump the matched nodes
foreach(INode node in matchedNodes)
{
GrElemDumpType dumpType;
if(multiMatchedNodes.Contains(node))
dumpType = GrElemDumpType.MultiMatched;
else
dumpType = GrElemDumpType.SingleMatched;
DumpNode(node, dumpInfo.GetNodeDumpTypeTextColor(dumpType),
dumpInfo.GetNodeDumpTypeColor(dumpType),
dumpInfo.GetNodeDumpTypeBorderColor(dumpType),
dumpInfo.GetNodeDumpTypeShape(dumpType),
dumper, dumpInfo);
}
// Now add the matched edges (possibly including "Not matched" nodes)
foreach(IEdge edge in matchedEdges)
{
if(!matchedNodes.Contains(edge.Source))
DumpNode(edge.Source,
dumpInfo.GetNodeTypeTextColor(edge.Source.Type),
dumpInfo.GetNodeTypeColor(edge.Source.Type),
dumpInfo.GetNodeTypeBorderColor(edge.Source.Type),
dumpInfo.GetNodeTypeShape(edge.Source.Type),
dumper, dumpInfo);
if(!matchedNodes.Contains(edge.Target))
DumpNode(edge.Target,
dumpInfo.GetNodeTypeTextColor(edge.Target.Type),
dumpInfo.GetNodeTypeColor(edge.Target.Type),
dumpInfo.GetNodeTypeBorderColor(edge.Target.Type),
dumpInfo.GetNodeTypeShape(edge.Target.Type),
dumper, dumpInfo);
GrElemDumpType dumpType;
if(multiMatchedEdges.Contains(edge))
dumpType = GrElemDumpType.MultiMatched;
else
dumpType = GrElemDumpType.SingleMatched;
DumpEdge(edge, dumpInfo.GetEdgeDumpTypeTextColor(dumpType),
dumpInfo.GetEdgeDumpTypeColor(dumpType),
dumpInfo.GetEdgeDumpTypeLineStyle(dumpType),
dumpInfo.GetEdgeDumpTypeThickness(dumpType),
dumper, dumpInfo);
}
return;
}
}
}
/// <summary>
/// Dumps one or more matches with a given graph dumper.
/// </summary>
/// <param name="graph">The graph to be dumped.</param>
/// <param name="dumper">The graph dumper to be used.</param>
/// <param name="dumpInfo">Specifies how the graph shall be dumped.</param>
/// <param name="matches">An IMatches object containing the matches.</param>
/// <param name="which">Which match to dump, or AllMatches for dumping all matches
/// adding connections between them, or OnlyMatches to dump the matches only</param>
public static void DumpMatch(IGraph graph, IDumper dumper, DumpInfo dumpInfo, IMatches matches, DumpMatchSpecial which)
{
Set<INode> matchedNodes = null;
Set<INode> multiMatchedNodes = null;
Set<IEdge> matchedEdges = null;
Set<IEdge> multiMatchedEdges = null;
if(matches != null)
{
DumpMatchOnly(dumper, dumpInfo, matches, which,
ref matchedNodes, ref multiMatchedNodes, ref matchedEdges, ref multiMatchedEdges);
}
// Dump the graph, but color the matches if any exist
DumpContext dc = new DumpContext(dumper, dumpInfo,
matchedNodes, multiMatchedNodes, matchedEdges, multiMatchedEdges);
foreach(NodeType nodeType in graph.Model.NodeModel.Types)
{
if(dumpInfo.IsExcludedNodeType(nodeType)) continue;
dc.Nodes.Add(graph.GetExactNodes(nodeType));
}
dc.InitialNodes = new Set<INode>(dc.Nodes);
Set<INode> nodes = new Set<INode>(dc.Nodes);
DumpGroups(graph, nodes, dc);
}
public void Dump(DumpInfo info) => Dump(info.ProcessId, GetNewDumpPath(info));
/// <summary>
/// Dumps the graph with a given graph dumper.
/// </summary>
/// <param name="graph">The graph to be dumped.</param>
/// <param name="dumper">The graph dumper to be used.</param>
/// <param name="dumpInfo">Specifies how the graph shall be dumped.</param>
public static void Dump(IGraph graph, IDumper dumper, DumpInfo dumpInfo)
{
DumpMatch(graph, dumper, dumpInfo, null, 0);
}
private static String GetElemLabel(IGraphElement elem, DumpInfo dumpInfo)
{
List<InfoTag> infoTagTypes = dumpInfo.GetTypeInfoTags(elem.Type);
String label = dumpInfo.GetElemTypeLabel(elem.Type);
bool first = true;
if(label == null)
{
label = dumpInfo.GetElementName(elem) + ":" + elem.Type.Name;
first = false;
}
if(infoTagTypes != null)
{
foreach(InfoTag infoTag in infoTagTypes)
{
object attr = elem.GetAttribute(infoTag.AttributeType.Name);
if(attr == null) continue;
if(!first) label += "\n";
else first = false;
if(infoTag.ShortInfoTag)
label += attr.ToString();
else
label += infoTag.AttributeType.Name + " = " + attr.ToString();
}
}
return label;
}
public new bool Execute()
{
try
{
while (true)
{
OpCode nextOpcode = CurrentContext.InstructionPointer >= CurrentContext.Script.Length ? OpCode.RET : CurrentContext.NextInstruction;
if (this.DumpInfo != null)
{
this.DumpInfo.NextOp(CurrentContext.InstructionPointer, nextOpcode);
this.CurrentContext.EvaluationStack.ClearRecord();
}
if (!PreStepInto(nextOpcode))
{
State |= VMState.FAULT;
return(false);
}
StepInto();
if (State.HasFlag(VMState.HALT) || State.HasFlag(VMState.FAULT))
{
break;
}
if (DumpInfo != null)
{
if (State.HasFlag(VMState.HALT) || State.HasFlag(VMState.FAULT))
{
continue;
}
var EvaluationStackRec = this.CurrentContext.EvaluationStack;
VM.StackItem result = null;
ExecutionStackRecord.Op[] record = EvaluationStackRec.record.ToArray();
var ltype = EvaluationStackRec.GetLastRecordType();
if (ltype == ExecutionStackRecord.OpType.Push)
{
result = EvaluationStackRec.PeekWithoutLog();
}
else if (ltype == ExecutionStackRecord.OpType.Insert)
{
result = EvaluationStackRec.PeekWithoutLog(EvaluationStackRec.record.Last().ind);
}
else if (ltype == ExecutionStackRecord.OpType.Set)
{
result = EvaluationStackRec.PeekWithoutLog(EvaluationStackRec.record.Last().ind);
}
else if (ltype == ExecutionStackRecord.OpType.Peek)
{
result = EvaluationStackRec.PeekWithoutLog();
}
LogResult(nextOpcode, record, result);
}
}
}
catch
{
State |= VMState.FAULT;
return(false);
}
if (DumpInfo != null)
{
DumpInfo.Finish(State);
}
return(!State.HasFlag(VMState.FAULT));
}
/// <summary>
/// Starts YComp on a free TCP port in the range 4242-4251.
/// </summary>
/// <param name="graph">The named graph to be displayed.</param>
/// <param name="layout">Sets the layouter in YComp.
/// Can be one of:
/// - Random
/// - Hierarchic
/// - Organic
/// - Orthogonal
/// - Circular
/// - Tree
/// - Diagonal
/// - Incremental Hierarchic
/// - Compilergraph
/// </param>
/// <param name="dumpInfo">Sets the dump information setting colors, shapes,
/// excluded types, etc.</param>
/// <returns>An YCompClient object, or null on error.</returns>
public static YCompClient CreateYCompClient(INamedGraph graph, String layout, DumpInfo dumpInfo)
{
int ycompPort = GetFreeTCPPort();
if (ycompPort < 0)
{
Console.WriteLine("Didn't find a free TCP port in the range 4242-4251!");
return(null);
}
try
{
Process.Start("ycomp", "-p " + ycompPort);
}
catch (Exception e)
{
Console.WriteLine("Unable to start ycomp: " + e.ToString());
return(null);
}
try
{
return(new YCompClient(graph, layout, 20000, ycompPort, dumpInfo));
}
catch (Exception ex)
{
Console.WriteLine("Unable to connect to YComp at port " + ycompPort + ": " + ex.Message);
return(null);
}
}
public DumpContext(IDumper dumper, DumpInfo dumpInfo, Set<INode> matchedNodes, Set<INode> multiMatchedNodes,
Set<IEdge> matchedEdges, Set<IEdge> multiMatchedEdges)
{
Dumper = dumper;
DumpInfo = dumpInfo;
MatchedNodes = matchedNodes;
MultiMatchedNodes = multiMatchedNodes;
MatchedEdges = matchedEdges;
MultiMatchedEdges = multiMatchedEdges;
}
