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)); }