internal CA_ST(CABuilder_ST cab, int initialState, Expr[] initalCounterValues,
IEnumerable <Move <Rule <Expr> > > movesandfinals, string name = "CA")
{
this.cab = cab;
this.nrOfCounters = initalCounterValues.Length;
this.st = ST <FuncDecl, Expr, Sort> .Create(cab.z3p, name,
(initalCounterValues.Length > 0 ?
cab.z3p.MkList(initalCounterValues) :
cab.z3p.GetNil(cab.z3p.MkListSort(cab.z3p.IntSort))),
cab.z3p.CharSort,
cab.z3p.CharSort,
cab.z3p.MkListSort(cab.z3p.IntSort),
initialState,
movesandfinals);
}
public STb <F, T, S> Mk(string regex, params Tuple <string, STb <F, T, S> >[] args)
{
var K = args.Length;
bool isLoop;
var patternAutomataPairs = solver.CharSetProvider.ConvertCaptures(regex, out isLoop);
var captureAutomata = new Dictionary <string, Automaton <BDD> >();
var stbs = new Dictionary <string, STb <F, T, S> >();
foreach (var arg in args)
{
if (stbs.ContainsKey(arg.Item1) || string.IsNullOrEmpty(arg.Item1))
{
throw new AutomataException(AutomataExceptionKind.InvalidArguments);
}
stbs[arg.Item1] = arg.Item2;
}
foreach (var pair in patternAutomataPairs)
{
if (pair.Item1 != "")
{
captureAutomata[pair.Item1] = pair.Item2;
}
}
var captureSortPos = new Dictionary <string, int>();
var captureSortName = new Dictionary <string, string>();
for (int i = 0; i < args.Length; i += 1)
{
captureSortName[args[i].Item1] = args[i].Item2.OutputSort.ToString();
captureSortPos[args[i].Item1] = i;
}
if (Array.Exists(patternAutomataPairs, pair => (pair.Item1 != "" && !captureSortName.ContainsKey(pair.Item1))))
{
throw new AutomataException(AutomataExceptionKind.InvalidArguments);
}
S[] argSorts = new S[K];
for (int i = 0; i < K; i++)
{
if (!captureAutomata.ContainsKey(args[i].Item1))
{
throw new AutomataException(AutomataExceptionKind.InvalidArguments);
}
if (!args[i].Item2.OutputSort.Equals(args[i].Item2.RegisterSort))
{
throw new AutomataException(AutomataExceptionKind.InvalidArguments);
}
argSorts[i] = args[i].Item2.OutputSort;
}
var regSort = solver.MkTupleSort(argSorts);
var regVar = solver.MkVar(1, regSort);
var initReg = solver.MainSolver.FindOneMember(solver.MkEq(regVar, regVar)).Value;
var inpVar = solver.MkVar(0, solver.CharSort);
var stb = new STb <F, T, S>(solver, "stb", solver.CharSort, regSort, regSort, initReg, 0);
var nextStateId = 0;
var stateIdMap = new Dictionary <Tuple <int, int, int>, int>();
Func <int, int, int, int> MkState = (n, q1, q2) =>
{
int p;
var nq = new Tuple <int, int, int>(n, q1, q2);
if (stateIdMap.TryGetValue(nq, out p))
{
return(p);
}
else
{
p = nextStateId;
nextStateId += 1;
stateIdMap[nq] = p;
return(p);
}
};
var resSTB = new STb <F, T, S>(solver, "STB", solver.CharSort, solver.CharSort, solver.UnitSort, solver.UnitConst, 0);
resSTB.AssignRule(0, new BaseRule <T>(new Sequence <T>(solver.MkCharVar(0)), solver.UnitConst, 0));
resSTB.AssignFinalRule(0, new BaseRule <T>(Sequence <T> .Empty, solver.UnitConst, 0));
for (int i = 0; i < patternAutomataPairs.Length; i++)
{
var aut = patternAutomataPairs[i].Item2;
if (patternAutomataPairs[i].Item1 == "")
{
var autSTMoves = new List <Move <Rule <T> > >();
foreach (var move in aut.GetMoves())
{
//move cannot be epsilon here
var cond = solver.ConvertFromCharSet(move.Label);
autSTMoves.Add(Move <Rule <T> > .Create(move.SourceState, move.TargetState, Rule <T> .Mk(cond, solver.UnitConst)));
}
foreach (var f in aut.GetFinalStates())
{
//collect guards of all moves exitingfrom f
var allGuardsFromF = solver.CharSetProvider.False;
foreach (var fmove in aut.GetMovesFrom(f))
{
allGuardsFromF = solver.CharSetProvider.MkOr(allGuardsFromF, fmove.Label);
}
var elseFromF = solver.ConvertFromCharSet(solver.CharSetProvider.MkNot(allGuardsFromF));
autSTMoves.Add(Move <Rule <T> > .Create(f, f, Rule <T> .Mk(elseFromF, solver.UnitConst, solver.MkCharVar(0))));
autSTMoves.Add(Move <Rule <T> > .Create(f, f, Rule <T> .MkFinal(solver.True)));
}
var autST = ST <F, T, S> .Create(solver, patternAutomataPairs[i].Item1, solver.UnitConst, solver.CharSort,
solver.CharSort, solver.UnitSort, aut.InitialState, autSTMoves);
var autSTb = autST.ToSTb();
resSTB = resSTB.Compose(autSTb);
}
else
{
var stb1 = stbs[patternAutomataPairs[i].Item1];
if (!stb1.InputSort.Equals(solver.CharSort))
{
throw new AutomataException(AutomataExceptionKind.InvalidArguments);
}
var autSTMoves = new List <Move <Rule <T> > >();
foreach (var move in aut.GetMoves())
{
//move cannot be epsilon here
var cond = solver.ConvertFromCharSet(move.Label);
autSTMoves.Add(Move <Rule <T> > .Create(move.SourceState, move.TargetState, Rule <T> .Mk(cond, solver.UnitConst, inpVar)));
}
foreach (var f in aut.GetFinalStates())
{
autSTMoves.Add(Move <Rule <T> > .Create(f, f, Rule <T> .MkFinal(solver.True)));
}
var autST = ST <F, T, S> .Create(solver, patternAutomataPairs[i].Item1, solver.UnitConst, solver.CharSort,
solver.CharSort, solver.UnitSort, aut.InitialState, autSTMoves);
var autSTb = autST.ToSTb();
var stb2 = autSTb.Compose(stb1);
foreach (var f in stb.States)
{
var frule = stb.GetFinalRuleFrom(f);
if (frule.IsNotUndef)
{
//var frule1 =
}
}
}
}
throw new NotImplementedException();
}
private static ST <FuncDecl, Expr, Sort> MkDecodeST(IContext <FuncDecl, Expr, Sort> z3p, Sort charSort)
{
Expr tt = z3p.True;
Expr[] eps = new Expr[] { };
List <Move <Rule <Expr> > > rules = new List <Move <Rule <Expr> > >();
Expr x = z3p.MkVar(0, charSort);
Sort regSort = z3p.MkTupleSort(charSort, charSort);
//the compound register
Expr yz = z3p.MkVar(1, regSort);
//the individual registers
Expr y = z3p.MkProj(0, yz);
Expr z = z3p.MkProj(1, yz);
//constant characer values
Expr amp = z3p.MkNumeral((int)'&', charSort);
Expr sharp = z3p.MkNumeral((int)'#', charSort);
Expr semi = z3p.MkNumeral((int)';', charSort);
Expr zero = z3p.MkNumeral((int)'0', charSort);
Expr nine = z3p.MkNumeral((int)'9', charSort);
Expr _1 = z3p.MkNumeral(1, charSort);
Expr _0 = z3p.MkNumeral(0, charSort);
Expr _10 = z3p.MkNumeral(10, charSort);
Expr _48 = z3p.MkNumeral(48, charSort);
//initial register value
Expr _11 = z3p.MkTuple(_1, _1);
//various terms
Expr xNEQ0 = z3p.MkNeq(x, _0);
Expr xEQ0 = z3p.MkEq(x, _0);
Expr xNEQamp = z3p.MkNeq(x, amp);
Expr xEQamp = z3p.MkEq(x, amp);
Expr xNEQsharp = z3p.MkNeq(x, sharp);
Expr xEQsharp = z3p.MkEq(x, sharp);
Expr xNEQsemi = z3p.MkNeq(x, semi);
Expr xEQsemi = z3p.MkEq(x, semi);
Expr xIsDigit = z3p.MkAnd(z3p.MkCharLe(zero, x), z3p.MkCharLe(x, nine));
Expr yIsDigit = z3p.MkAnd(z3p.MkCharLe(zero, y), z3p.MkCharLe(y, nine));
Expr zIsDigit = z3p.MkAnd(z3p.MkCharLe(zero, z), z3p.MkCharLe(z, nine));
Expr yzAreDigits = z3p.MkAnd(yIsDigit, zIsDigit);
Expr xIsNotDigit = z3p.MkNot(xIsDigit);
Expr decode = z3p.MkCharAdd(z3p.MkCharMul(_10, z3p.MkCharSub(y, _48)), z3p.MkCharSub(z, _48));
//final state
rules.Add(Move <Rule <Expr> > .Create(5, 5, Rule <Expr> .MkFinal(tt)));
//terminating rules
rules.Add(Move <Rule <Expr> > .Create(0, 5, Rule <Expr> .Mk(xEQ0, _11, _0)));
rules.Add(Move <Rule <Expr> > .Create(1, 5, Rule <Expr> .Mk(xEQ0, _11, amp, _0)));
rules.Add(Move <Rule <Expr> > .Create(2, 5, Rule <Expr> .Mk(xEQ0, _11, amp, sharp, _0)));
rules.Add(Move <Rule <Expr> > .Create(3, 5, Rule <Expr> .Mk(xEQ0, _11, amp, sharp, y, _0)));
rules.Add(Move <Rule <Expr> > .Create(4, 5, Rule <Expr> .Mk(xEQ0, _11, amp, sharp, y, z, _0)));
//main rules
//rules from state q0
rules.Add(Move <Rule <Expr> > .Create(0, 0, Rule <Expr> .Mk(z3p.MkAnd(xNEQ0, xNEQamp), yz, x)));
rules.Add(Move <Rule <Expr> > .Create(0, 1, Rule <Expr> .Mk(z3p.MkAnd(xNEQ0, xEQamp), yz)));
//rules from state q1
rules.Add(Move <Rule <Expr> > .Create(1, 0, Rule <Expr> .Mk(z3p.MkAnd(xNEQ0, z3p.MkAnd(xNEQamp, xNEQsharp)), yz, amp, x)));
rules.Add(Move <Rule <Expr> > .Create(1, 1, Rule <Expr> .Mk(z3p.MkAnd(xNEQ0, xEQamp), yz, amp)));
rules.Add(Move <Rule <Expr> > .Create(1, 2, Rule <Expr> .Mk(z3p.MkAnd(xNEQ0, xEQsharp), yz)));
//rules from state q2
rules.Add(Move <Rule <Expr> > .Create(2, 0, Rule <Expr> .Mk(z3p.MkAnd(xNEQ0, z3p.MkAnd(xNEQamp, xIsNotDigit)), yz, amp, sharp, x)));
rules.Add(Move <Rule <Expr> > .Create(2, 1, Rule <Expr> .Mk(z3p.MkAnd(xNEQ0, xEQamp), yz, amp, sharp)));
rules.Add(Move <Rule <Expr> > .Create(2, 3, Rule <Expr> .Mk(z3p.MkAnd(xNEQ0, xIsDigit), z3p.MkTuple(x, z))));
//rules from state q3
rules.Add(Move <Rule <Expr> > .Create(3, 0, Rule <Expr> .Mk(z3p.MkAnd(xNEQ0, z3p.MkAnd(xNEQamp, xIsNotDigit)), _11, amp, sharp, y, x)));
rules.Add(Move <Rule <Expr> > .Create(3, 1, Rule <Expr> .Mk(z3p.MkAnd(xNEQ0, xEQamp), _11, amp, sharp, y)));
rules.Add(Move <Rule <Expr> > .Create(3, 4, Rule <Expr> .Mk(z3p.MkAnd(xNEQ0, xIsDigit), z3p.MkTuple(y, x))));
//rules from state q4
rules.Add(Move <Rule <Expr> > .Create(4, 0, Rule <Expr> .Mk(z3p.MkAnd(xNEQ0, xEQsemi), _11, decode)));
rules.Add(Move <Rule <Expr> > .Create(4, 0, Rule <Expr> .Mk(z3p.MkAnd(xNEQ0, z3p.MkAnd(xNEQsemi, xNEQamp)), _11, amp, sharp, y, z, x)));
rules.Add(Move <Rule <Expr> > .Create(4, 1, Rule <Expr> .Mk(z3p.MkAnd(xNEQ0, xEQamp), _11, amp, sharp, y, z)));
ST <FuncDecl, Expr, Sort> st = ST <FuncDecl, Expr, Sort> .Create(z3p, "Decode", _11, charSort, charSort, regSort, 0, rules);
return(st);
}
/// <summary>
/// Create an ST with the given solver. Calls ST.Create(solver,...)
/// </summary>
public ST <FUNC, TERM, SORT> MkST(string name, TERM initialRegister, SORT inSort, SORT outSort, SORT regSort,
int initialState,
IEnumerable <Move <Rule <TERM> > > rulesAndFinalOutputs)
{
return(ST <FUNC, TERM, SORT> .Create(solver, name, initialRegister, inSort, outSort, regSort, initialState, rulesAndFinalOutputs));
}
