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