private static void WriteRuleLinks <T>(string cat, string prefix, STbRule <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 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);
}
}
private static void WriteRuleNodes <T>(string prefix, STbRule <T> rule, System.IO.TextWriter tw, ISTb <T> stb, bool endcase)
{
STbRule <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);
}
}
static ComputationNode ToComputationTree(Context ctx, STbRule <Expr> rule, Expr registerVar, Expr registerProjection, Func <int, Expr[], Expr, Expr> createResult)
{
var iteRule = rule as IteRule <Expr>;
if (iteRule != null)
{
var trueNode = ToComputationTree(ctx, iteRule.TrueCase, registerVar, registerProjection, createResult);
var falseNode = ToComputationTree(ctx, iteRule.FalseCase, registerVar, registerProjection, createResult);
var lifted = iteRule.Condition.Substitute(registerVar, registerProjection);
return(new IteNode(lifted, trueNode, falseNode));
}
var baseRule = rule as BaseRule <Expr>;
if (baseRule != null)
{
return(new ResultNode(createResult(baseRule.State, baseRule.Yields.ToArray(), baseRule.Register)));
}
var raiseRule = rule as UndefRule <Expr>;
if (raiseRule != null)
{
return(new UndefinedNode());
}
throw new CodeGenerationException("Unsupported STb rule type");
}
int IteRules(STbRule <Expr> rule)
{
switch (rule.RuleKind)
{
case STbRuleKind.Ite:
return(1 + IteRules(rule.TrueCase) + IteRules(rule.FalseCase));
case STbRuleKind.Switch:
throw new Exception("Switch rules are not supported");
default:
return(0);
}
}
public override STModel Convert(iterexpr ie, Symtab stab)
{
VarInfo I = new VarInfo(stb, stab, ie, charsort);
var iterCases = ConsList <itercase> .Create(ie.GetNormalCases());
var endCases = ConsList <itercase> .Create(ie.GetEndCases());
STbRule <Expr> rule = CreateBranchingRule(iterCases, stb.Solver.True, I);
STbRule <Expr> frule = CreateBranchingRule(endCases, stb.Solver.True, I);
STModel st = new STModel(stb.Solver, "iterSTb", charsort, charsort, I.regSort, I.initReg, 0);
st.AssignRule(0, rule);
st.AssignFinalRule(0, frule);
return(st);
}
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);
}
}
protected override STbRule <Expr> HandleBranch(BoolExpr condition, STbRule <Expr> ifTrueResult, STbRule <Expr> ifFalseResult)
{
return(new IteRule <Expr>(condition, ifTrueResult, ifFalseResult));
}
