public STb <FuncDecl, Expr, Sort> Compose(int K = 3, bool benchmarkK = false)
{
_minimizeRemoved = 0;
_simplifyRemoved = 0;
if (benchmarkK)
{
if (_inner is TransducerComposition)
{
var t = _inner as TransducerComposition;
t._transducer = t.Compose(K, benchmarkK);
}
if (_outer is TransducerComposition)
{
var t = _outer as TransducerComposition;
t._transducer = t.Compose(K, benchmarkK);
}
}
var inner = _inner.Transducer;
var outer = _outer.Transducer;
if (!benchmarkK)
{
var innerName = _inner.DeclarationType.ContainingNamespace.Name + "." +
(_inner.DeclarationType.ContainingType == null ? "" : _inner.DeclarationType.ContainingType.Name + ".") + _inner.DeclarationType.Name;
var outerName = _outer.DeclarationType.ContainingNamespace.Name + "." +
(_outer.DeclarationType.ContainingType == null ? "" : _outer.DeclarationType.ContainingType.Name + ".") + _outer.DeclarationType.Name;
Console.WriteLine("Composing " + innerName + " with " + outerName);
}
var stb = inner.Compose(outer);
var stb1 = stb;
if (ShowGraphStages.Contains(ShowGraph.Stage.UnSimplified))
{
stb.ToST().ShowGraph();
}
//stb1 = stb.Minimize();
//_minimizeRemoved += StatesRemoved(stb, stb1);
//stb = stb1;
var k = (K < 0 ? (stb.StateCount == 1 ? 2 : stb.StateCount) : K);
stb1 = stb.Simplify(K);
_simplifyRemoved += TotalIteRules(stb) - TotalIteRules(stb1);
stb = stb1;
stb = stb.Flatten();
//stb1 = stb.Minimize();
//_minimizeRemoved += StatesRemoved(stb, stb1);
//stb = stb1;
if (ShowGraphStages.Contains(ShowGraph.Stage.Simplified))
{
stb.ToST().ShowGraph();
}
Console.WriteLine(DeclarationType.Name + ": K=" + k + " Min=" + MinimizeRemoved + " Simp=" + SimplifyRemoved + " TotalCS=" + stb.StateCount + " TotalITE=" + TotalIteRules(stb));
return(stb);
}
STb <FuncDecl, Expr, Sort> GenerateSTb()
{
var name = DeclarationType.ContainingNamespace.Name + "." +
(DeclarationType.ContainingType == null ? "" : DeclarationType.ContainingType.Name + ".") + DeclarationType.Name;
Console.WriteLine("Exploring " + name);
Expr inputVar = _info.AutomataCtx.MkVar(0, Mapper.GetSortMapping(_transducerType.TypeArguments[0]).Sort);
Expr registerVar = _info.AutomataCtx.MkVar(1, Mapper.GetSortMapping(DeclarationType).Sort);
Mutator register = Mapper.GetSortMapping(DeclarationType).MutatorForValue(registerVar);
var methods = DeclarationType.DeclaringSyntaxReferences.Select(r => r.GetSyntax())
.SelectMany(s => s.DescendantNodes(n => !(n is MethodDeclarationSyntax)))
.OfType <MethodDeclarationSyntax>().Select(Syntax => new { Syntax, Symbol = Model.GetDeclaredSymbol(Syntax) as IMethodSymbol })
.Where(x => x.Symbol != null);
// Find the Update function
var updateMethods = methods.Where(x => x.Symbol.MetadataName == "Update" && x.Symbol.IsOverride &&
x.Symbol.Parameters.Length == 1 && x.Symbol.Parameters[0].Type == InputTypeSymbol).ToArray();
if (updateMethods.Length == 0)
{
throw new SyntaxErrorException("No IEnumerable<" + OutputTypeSymbol + "> Update(" + InputTypeSymbol + ") method declared");
}
else if (updateMethods.Length > 1)
{
throw new SyntaxErrorException("Multiple Update methods declared");
}
var updateMethod = updateMethods[0];
// Explore the Update function
var updateCfg = new ControlFlowGraph(updateMethod.Syntax.Body, Model);
Dictionary <ISymbol, Mutator> parameters = updateMethod.Symbol.Parameters
.ToDictionary(p => (ISymbol)p, p => Mapper.GetSortMapping(_transducerType.TypeArguments[0]).MutatorForValue(inputVar));
var updateEntryState = new MainExplorationState(_info, updateCfg.EntryPoint, register, parameters, new[] { inputVar, registerVar });
var updateRule = updateEntryState.Explore();
// Find the Finish function
var finishMethods = methods.Where(x => x.Symbol.MetadataName == "Finish" && x.Symbol.IsOverride &&
x.Symbol.Parameters.Length == 0).ToArray();
STbRule <Expr> finishRule;
if (finishMethods.Length == 0)
{
finishRule = new BaseRule <Expr>(Sequence <Expr> .Empty, register.CreateUpdate(), 0);
}
else
{
if (finishMethods.Length > 1)
{
throw new SyntaxErrorException("Multiple Finish methods declared");
}
var finishMethod = finishMethods[0];
// Explore the Finish function
var finishCfg = new ControlFlowGraph(finishMethod.Syntax.Body, Model);
var finishEntryState = new MainExplorationState(_info, finishCfg.EntryPoint, register, new Dictionary <ISymbol, Mutator>(), new[] { registerVar });
finishRule = finishEntryState.Explore();
}
var outputSort = Mapper.GetSortMapping(_transducerType.TypeArguments[1]).Sort;
var stb = new STb <FuncDecl, Expr, Sort>(_info.AutomataCtx, DeclarationType.Name, inputVar.Sort, outputSort, registerVar.Sort,
Mapper.GetSortMapping(DeclarationType).MutatorForDefaultValue().CreateUpdate().SafeSimplify(Ctx), 0);
stb.AssignRule(0, updateRule);
stb.AssignFinalRule(0, finishRule);
if (ShowGraphStages.Contains(ShowGraph.Stage.UnSimplified))
{
stb.ShowGraph();
}
stb = stb.Flatten();
if (ShowGraphStages.Contains(ShowGraph.Stage.Simplified))
{
stb.ToST().ShowGraph();
}
return(stb);
}
