/// <summary>
/// Write the automaton in dgml format in the current directory and open the file in a new process.
/// </summary>
/// <param name="fa">the automaton to write</param>
/// <param name="name">the name of the output file, if filename does not end with .dgml then .dgml is added as suffix</param>
internal static void ShowSTb <T>(int k, ISTb <T> stb)
{
string filename = stb.Name + (stb.Name.EndsWith(".dgml") ? "" : ".dgml");
System.IO.StreamWriter sw = new System.IO.StreamWriter(filename);
STbToDgml(k, stb, sw);
sw.Close();
OpenFileInNewProcess(filename);
}
//private static string Describe<T>(ISTb<T> stb, BaseRule<T> basic, bool endcase)
//{
// List<string> lab = new List<string>();
// for (int i = 0; i < basic.Yields.Length; i++)
// {
// lab.Add("yield " + stb.PrettyPrint(basic.Yields[i]));
// }
// string rhs = stb.PrettyPrint(basic.Register);
// if (!endcase && !(rhs.Equals(STbInfo.__empty_tuple) || rhs.Equals(STbInfo.__register_variable))) //either registers are not used, or the assignment is trivial
// lab.Add(string.Format("{0}:={1}", STbInfo.__register_variable, rhs));
// lab = ShortenWidth(lab);
// int k = 0;
// foreach (string s in lab)
// k = Math.Max(s.Length, k);
// //add spaces to simulate left alignment
// for (int i = 0; i < lab.Count; i++)
// lab[i] = lab[i] + MkSpaces(k - lab[i].Length);
// var labStr = "";
// for (int i = 0; i < lab.Count; i++)
// {
// if (i > 0)
// labStr += "\\n";
// labStr += lab[i];
// }
// return labStr;
//}
private static string Describe <T>(ISTb <T> stb, BaseRule <T> basic, bool endcase)
{
List <string> lab = new List <string>();
string labYield = "[";
for (int i = 0; i < basic.Yields.Length; i++)
{
if (i > 0)
{
labYield += ", ";
}
labYield += stb.PrettyPrint(basic.Yields[i]);
}
labYield += "]";
lab.Add(labYield);
string rhs = stb.PrettyPrint(basic.Register);
if (!endcase && !(rhs.Equals(STbInfo.__empty_tuple) || rhs.Equals(STbInfo.__register_variable))) //either registers are not used, or the assignment is trivial
{
lab.Add(string.Format("{0}:={1}", STbInfo.__register_variable, rhs));
}
lab = ShortenWidth(lab);
int k = 0;
foreach (string s in lab)
{
k = Math.Max(s.Length, k);
}
//add spaces to simulate left alignment
for (int i = 0; i < lab.Count; i++)
{
lab[i] = lab[i] + MkSpaces(k - lab[i].Length);
}
var labStr = "";
for (int i = 0; i < lab.Count; i++)
{
if (i > 0)
{
labStr += "\\n";
}
labStr += lab[i];
}
return(labStr);
}
private static string Describe <T>(ISTb <T> stb, BaseRule <T> basic, bool endcase)
{
StringBuilder lab = new StringBuilder("yield (");
for (int i = 0; i < basic.Yields.Length; i++)
{
if (i > 0)
{
lab.Append(",");
}
lab.Append(stb.PrettyPrint(basic.Yields[i]));
}
lab.Append(")");
string rhs = stb.PrettyPrint(basic.Register);
if (!endcase && !(rhs.Equals(STbInfo.__empty_tuple) || rhs.Equals(STbInfo.__register_variable))) //either registers are not used, or the assignment is trivial
{
lab.AppendFormat("; {0}:={1}", STbInfo.__register_variable, rhs);
}
var labStr = lab.ToString();
return(labStr);
}
private static void WriteRuleLinks <T>(string cat, string source, STbRule <T> rule, System.IO.TextWriter tw, ISTb <T> stb, bool endcase, bool writegrouping)
{
if ((rule is UndefRule <T>) || (endcase && (rule is BaseRule <T>)))
{
return; //there are no further links
}
if (rule is BaseRule <T> )
{
tw.WriteLine("{0} -> s{1};", source, ((BaseRule <T>)rule).State);
}
else
{
IteRule <T> ite = (IteRule <T>)rule;
tw.WriteLine("{0} -> {1} [label = \"T\"];", source, source + "T");
tw.WriteLine("{0} -> {1} [label = \"F\"];", source, source + "F");
WriteRuleLinks(cat, source + "T", ite.TrueCase, tw, stb, endcase, writegrouping);
WriteRuleLinks(cat, source + "F", ite.FalseCase, tw, stb, endcase, writegrouping);
}
}
private static void WriteRuleNodes <T>(string source, STbRule <T> rule, System.IO.TextWriter tw, ISTb <T> stb, bool endcase)
{
UndefRule <T> raise = rule as UndefRule <T>;
if (raise != null)
{
tw.WriteLine("{0} [fillcolor = {2}, label =\"{1}\"];", source, ShortenLabel(DisplayLabel(raise.Exc)), excColor);
return;
}
BaseRule <T> block = rule as BaseRule <T>;
if (block != null)
{
string lab = Describe(stb, block, endcase);
if (endcase)
{
tw.WriteLine("{0} [fillcolor={1}, peripheries = 2, label =\"{2}\"];", source, accColor, DisplayLabel(lab));
}
else
{
tw.WriteLine("{0} [label =\"{1}\"];", source, DisplayLabel(lab));
}
return;
}
else
{
IteRule <T> ite = (IteRule <T>)rule;
string lab = stb.PrettyPrint(ite.Condition);
tw.WriteLine("{0} [label =\"{1}\", style=rounded];", source, ShortenLabel(DisplayLabel(lab)));
WriteRuleNodes(source + "T", ite.TrueCase, tw, stb, endcase);
WriteRuleNodes(source + "F", ite.FalseCase, tw, stb, endcase);
}
}
internal static void STbToDot <T>(int maxLabel, ISTb <T> stb, System.IO.TextWriter tw)
{
maxLabelLength = maxLabel;
tw.WriteLine("digraph \"" + stb.Name + "\" {");
tw.WriteLine(string.Format("rankdir={0};", direction));
tw.WriteLine();
tw.WriteLine("//name");
tw.WriteLine(string.Format("node [style = filled, shape = plaintext, color = white, width = .3 cm, height = .3 cm, fillcolor = white, {0}];", stbFont));
tw.WriteLine("preInit [label = \"{0}\", color = white];", (inclName ? stb.Name + ":" : ""));
var edges = new StringBuilder();
var edgeMap = new Dictionary <Pair <string, string>, string>();
var edgeCat = new Dictionary <Pair <string, string>, string>();
Func <Pair <string, string>, string> getEdge =
(p => (edgeMap.ContainsKey(p) ? edgeMap[p] : ""));
Action <string, string, string, string> AddEdge =
((s, t, l, cat) =>
{
var p = new Pair <string, string>(s, t);
string v = getEdge(p);
edgeMap[p] = (v == "" ? l : v + "," + l);
edgeCat[p] = cat;
});
tw.WriteLine();
tw.WriteLine("//control states");
tw.WriteLine(string.Format("node [style = filled, shape = circle, color = black, fillcolor = white, width = .3 cm, height = .3 cm, {0}];", stbFont));
foreach (int state in stb.States)
{
tw.WriteLine(string.Format("s{0} [label = {0}, shape = circle];", state));
}
tw.WriteLine();
tw.WriteLine("//branch conditions");
tw.WriteLine(string.Format("node [style = filled, shape = box, width = .3 cm, height = .3 cm, fillcolor = white, {0}];", stbFont));
foreach (int state in stb.States)
{
var rule = stb.GetRuleFrom(state);
if (rule.IsNotUndef)
{
WriteRuleNodes("s" + state + "r", rule, tw, stb, false);
}
var frule = stb.GetFinalRuleFrom(state);
if (frule.IsNotUndef)
{
WriteRuleNodes("s" + state + "f", frule, tw, stb, true);
}
}
tw.WriteLine();
tw.WriteLine("//edges");
tw.WriteLine("edge [{0}];", stbFont);
string rhs = stb.PrettyPrint(stb.InitialRegister);
if (!(rhs.Equals(STbInfo.__empty_tuple) || rhs.Equals(STbInfo.__register_variable))) //either registers are not used, or the assignment is trivial
{
rhs = string.Format("{0}:={1}", STbInfo.__register_variable, rhs);
}
else
{
rhs = "";
}
tw.WriteLine("preInit -> s{0} [label = \"{1}\"];", stb.InitialState, ShortenLabel(DisplayLabel(rhs)));
foreach (int state in stb.States)
{
var rule = stb.GetRuleFrom(state);
if (rule.IsNotUndef)
{
tw.WriteLine("s{0} -> s{0}r;", state);
WriteRuleLinks("Rule" + state, "s" + state + "r", rule, tw, stb, false, rule is IteRule <T>);
}
var frule = stb.GetFinalRuleFrom(state);
if (frule.IsNotUndef)
{
tw.WriteLine("s{0} -> s{0}f [style = dashed, color = gray];", state);
WriteRuleLinks("Final" + state, "s" + state + "f", frule, tw, stb, true, frule is IteRule <T>);
}
}
tw.WriteLine("}");
}
private static void WriteRuleLinks <T>(string cat, string prefix, BranchingRule <T> rule, System.IO.TextWriter tw, ISTb <T> stb, bool endcase, bool writegrouping)
{
//TBD: better visualization for switch rules
rule = (rule is SwitchRule <T>?(rule as SwitchRule <T>).ToIteForVisualization() : rule);
if (writegrouping)
{
tw.WriteLine("<Link Source=\"{0}\" Target=\"{1}\" Category=\"Contains\" />", cat, prefix);
}
if ((rule is UndefRule <T>) || (endcase && (rule is BaseRule <T>)))
{
return; //there are no further links
}
if (rule is BaseRule <T> )
{
tw.WriteLine("<Link Source=\"{0}\" Target=\"{1}\" Category=\"RuleExit\" />", prefix, ((BaseRule <T>)rule).State);
}
else //if (rule is IteRule<T>)
{
IteRule <T> ite = (IteRule <T>)rule;
tw.WriteLine("<Link Source=\"{0}\" Target=\"{1}\" Label=\"T\" Category=\"BranchCase\" />", prefix, prefix + "." + "T");
tw.WriteLine("<Link Source=\"{0}\" Target=\"{1}\" Label=\"F\" Category=\"BranchCase\" />", prefix, prefix + "." + "F");
WriteRuleLinks(cat, prefix + "." + "T", ite.TrueCase, tw, stb, endcase, writegrouping);
WriteRuleLinks(cat, prefix + "." + "F", ite.FalseCase, tw, stb, endcase, writegrouping);
}
//else //switch rule
//{
//}
}
private static void WriteRuleNodes <T>(string prefix, BranchingRule <T> rule, System.IO.TextWriter tw, ISTb <T> stb, bool endcase)
{
BranchingRule <T> rule1 = (rule is SwitchRule <T>?(rule as SwitchRule <T>).ToIteForVisualization() : rule);
UndefRule <T> raise = rule as UndefRule <T>;
if (raise != null)
{
tw.WriteLine("<Node Id=\"{0}\" {1} Category=\"Reject\" />", prefix, DisplayLabel(raise.Exc));
return;
}
BaseRule <T> block = rule as BaseRule <T>;
if (block != null)
{
string lab = Describe(stb, block, endcase);
string cat = (endcase ? "Accept" : "BasicBlock");
tw.WriteLine("<Node Id=\"{0}\" {1} Category=\"{2}\" />", prefix, DisplayLabel(lab), cat);
return;
}
else
{
IteRule <T> ite = (IteRule <T>)rule1;
string lab = stb.PrettyPrint(ite.Condition);
tw.WriteLine("<Node Id=\"{0}\" {1} Category=\"BranchCondition\" />", prefix, DisplayLabel(lab));
WriteRuleNodes(prefix + "." + "T", ite.TrueCase, tw, stb, endcase);
WriteRuleNodes(prefix + "." + "F", ite.FalseCase, tw, stb, endcase);
}
}
internal static void STbToDgml <T>(int maxLabel, ISTb <T> stb, System.IO.TextWriter tw)
{
maxLabelLength = maxLabel;
tw.WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
tw.WriteLine("<DirectedGraph xmlns=\"http://schemas.microsoft.com/vs/2009/dgml\" ZoomLevel=\"1.5\" GraphDirection=\"TopToBottom\" >");
//-------------------- states ---------------------
tw.WriteLine("<Nodes>");
//--- initial state ---
tw.WriteLine("<Node Id=\"init\" Label=\"{0}\" Stroke=\"white\" Background=\"white\"/>", stb.Name);
var edges = new StringBuilder();
var edgeMap = new Dictionary <Tuple <string, string>, string>();
var edgeCat = new Dictionary <Tuple <string, string>, string>();
Func <Tuple <string, string>, string> getEdge =
(p => (edgeMap.ContainsKey(p) ? edgeMap[p] : ""));
Action <string, string, string, string> AddEdge =
((s, t, l, cat) =>
{
var p = new Tuple <string, string>(s, t);
string v = getEdge(p);
edgeMap[p] = (v == "" ? l : v + "," + l);
edgeCat[p] = cat;
});
foreach (int state in stb.States)
{
if (state == stb.InitialState)
{
tw.WriteLine("<Node Id=\"{0}\" Label=\"{0}\" Category=\"InitialState\" />", state);
}
else
{
tw.WriteLine("<Node Id=\"{0}\" Label=\"{0}\" Category=\"State\" />", state);
}
}
foreach (int state in stb.States)
{
var rule = stb.GetRuleFrom(state);
if (rule.IsNotUndef)
{
if (rule is IteRule <T> )
{
tw.WriteLine("<Node Id=\"Rule{0}\" Category=\"{1}\" Group=\"Collapsed\" Label=\"Rule {0}\" />", state, rule.IsPartial ? "PartialRule" : "Rule");
}
WriteRuleNodes(state + ".r", rule, tw, stb, false);
}
var frule = stb.GetFinalRuleFrom(state);
if (frule.IsNotUndef)
{
if (frule is IteRule <T> )
{
tw.WriteLine("<Node Id=\"Final{0}\" Category=\"{1}\" Group=\"Collapsed\" Label=\"Final {0}\" />", state, frule.IsPartial ? "FinalPartialRule" : "FinalRule");
}
WriteRuleNodes(state + ".f", frule, tw, stb, true);
}
}
tw.WriteLine("</Nodes>");
tw.WriteLine("<Links>");
string rhs = stb.PrettyPrint(stb.InitialRegister);
if (!(rhs.Equals(STbInfo.__empty_tuple) || rhs.Equals(STbInfo.__register_variable))) //either registers are not used, or the assignment is trivial
{
rhs = string.Format("{0}:={1}", STbInfo.__register_variable, rhs);
}
else
{
rhs = "";
}
tw.WriteLine("<Link Source=\"init\" Target=\"{0}\" {1} Category=\"InitialTransition\" />", stb.InitialState, DisplayLabel(rhs));
foreach (int state in stb.States)
{
var rule = stb.GetRuleFrom(state);
if (rule.IsNotUndef)
{
tw.WriteLine("<Link Source=\"{0}\" Target=\"{1}\" Category=\"RuleEntry\" />", state, state + ".r");
WriteRuleLinks("Rule" + state, state.ToString() + "." + "r", rule, tw, stb, false, rule is IteRule <T>);
}
var frule = stb.GetFinalRuleFrom(state);
if (frule.IsNotUndef)
{
tw.WriteLine("<Link Source=\"{0}\" Target=\"{1}\" Category=\"FinalTransition\" />", state, state + ".f");
WriteRuleLinks("Final" + state, state.ToString() + "." + "f", frule, tw, stb, true, frule is IteRule <T>);
}
}
tw.WriteLine("</Links>");
WriteSTbCategoriesAndStyles(tw);
tw.WriteLine("</DirectedGraph>");
}
