private static void RunTestForGivenSize(int K)
{
Console.WriteLine(K);
Z3Provider Z = new Z3Provider();
var A = (Z.TT.MkRankedAlphabet("A", Z.IntSort, new string[] { "zero", "two" }, new int[] { 0, 2 }));
Func<int, Expr> beta = (i => Z.MkEq(Z.MkInt(1), Z.MkMod(Z.MkDiv(A.AttrVar, Z.MkInt(1 << (i%32))), Z.MkInt(2))));
Expr e1 = Z.MkEq(Z.MkInt(1), A.AttrVar);
Expr e2 = Z.MkEq(Z.MkInt(2), A.AttrVar);
Expr e3 = Z.MkEq(Z.MkInt(3), A.AttrVar);
var r1 = Z.TT.MkTreeAcceptorRule(A, 0, "zero", e1);
var r2 = Z.TT.MkTreeAcceptorRule(A, 1, "zero", e2);
var r3 = Z.TT.MkTreeAcceptorRule(A, 2, "zero", e3);
var rules = new List<TreeRule>();
rules.Add(r1);
rules.Add(r2);
rules.Add(r3);
for (int i = 0; i < K; i++)
{
rules.Add(Z.TT.MkTreeAcceptorRule(A, 3 * i + 3, "two", beta(i), 3 * i, 3 * i + 2));
rules.Add(Z.TT.MkTreeAcceptorRule(A, 3 * i + 4, "two", beta(i), 3 * i + 1, 3 * i + 2));
rules.Add(Z.TT.MkTreeAcceptorRule(A, 3 * i + 5, "two", beta(i), 3 * i + 2, 3 * i + 2));
}
var T = Z.TT.MkTreeAutomaton(new int[] { 3 * K , 3 * K +1 }, A, A, rules);
var comp = T.Complete();
Util.RunAllAlgorithms(T, comp, K.ToString(), Program.largeAlphabetFile);
}
public void TestBitvectorOps()
{
string noop = @"
program noop(w) {
return iter(c in w) {
case (c <= 0xFF):
yield((((c >> 4) & 0xF) << 4)|(c & 0xF));
case (true):
yield(c);
};
}
";
string triv = @"
program triv(w) {
return iter(c in w) {
case (true):
yield(c);
};
}
";
var solver = new Z3Provider();
var A = BekConverter.BekToST(solver, noop);
var B = BekConverter.BekToST(solver, triv);
bool equiv = A.Eq1(B);
Assert.IsTrue(equiv);
//A.ShowGraph();
}
public Automaton<Expr> getAutomata(Z3Provider z3p, Expr universe, Expr var, Sort sort)
{ //Sort for pairs (input theory, BV)
var bv = z3p.Z3.MkBitVecSort(BVConst.BVSIZE);
var pairSort = z3p.MkTupleSort(sort, bv);
var dfapair = this.Normalize().PushQuantifiers().getAutomata(z3p, new List<string>(), universe, var, sort);
//Compute the new moves by dropping the last bit of every element in the phiMoves
var newMoves = Automaton<Expr>.Empty.GetMoves().ToList();
foreach (var oldMove in dfapair.GetMoves())
{
var oldCond = oldMove.Label;
//Compute the new condition as ()
Expr newCond = oldCond;
//Update the new set of moves
newMoves.Add(new Move<Expr>(oldMove.SourceState, oldMove.TargetState, newCond));
}
//Build the new dfa with the new moves
var automaton = Automaton<Expr>.Create(dfapair.InitialState, dfapair.GetFinalStates(), newMoves);
return automaton.Determinize(z3p).Minimize(z3p);
}
public void HexProjTest2()
{
Z3Provider z3p = new Z3Provider();
Sort bv64 = z3p.MkBitVecSort(64);
Sort bv16 = z3p.MkBitVecSort(16);
Expr _0x654321 = z3p.MkNumeral((uint)0xF54321, bv64);
Expr _6 = z3p.MkHexProj(5, _0x654321, bv16).Simplify();
Expr _5 = z3p.MkHexProj(4, _0x654321, bv16).Simplify();
Expr _4 = z3p.MkHexProj(3, _0x654321, bv16).Simplify();
Expr _3 = z3p.MkHexProj(2, _0x654321, bv16).Simplify();
Expr _2 = z3p.MkHexProj(1, _0x654321, bv16).Simplify();
Expr _1 = z3p.MkHexProj(0, _0x654321, bv16).Simplify();
int _6v = (int)z3p.GetNumeralInt(_6);
int _5v = (int)z3p.GetNumeralInt(_5);
int _4v = (int)z3p.GetNumeralInt(_4);
int _3v = (int)z3p.GetNumeralInt(_3);
int _2v = (int)z3p.GetNumeralInt(_2);
int _1v = (int)z3p.GetNumeralInt(_1);
Assert.AreEqual<int>(0xF, _6v);
Assert.AreEqual<int>(5, _5v);
Assert.AreEqual<int>(4, _4v);
Assert.AreEqual<int>(3, _3v);
Assert.AreEqual<int>(2, _2v);
Assert.AreEqual<int>(1, _1v);
}
//[TestMethod]
public void TestCssEncode5()
{
var solver = new Z3Provider();
var stb = BekConverter.BekFileToSTb(solver, sampleDir + "bek/CssEncode5.bek");
//stb.Explore().ShowGraph();
var st = stb.ToST();
//st.ShowGraph(10);
var sft = st.Explore();
//sft.ShowGraph(10);
//just to get longer input strings
var restr = sft.RestrictDomain("(.){3,}$");
restr.Simplify();
//restr.ShowGraph(10);
restr.AssertTheory();
Expr inputConst = solver.MkFreshConst("input", sft.InputListSort);
Expr outputConst = solver.MkFreshConst("output", sft.OutputListSort);
solver.MainSolver.Assert(restr.MkAccept(inputConst, outputConst));
int okCnt = 0;
int error0Cnt = 0;
int error1Cnt = 0;
//validate correctness for some values against the actual CssEncode
//TBD: validate also exceptional behavior
int K = 10;
for (int i = 0; i < K; i++)
{
var model = solver.MainSolver.GetModel(solver.True, inputConst, outputConst);
string input = model[inputConst].StringValue;
string output = model[outputConst].StringValue;
Assert.IsFalse(string.IsNullOrEmpty(input));
Assert.IsFalse(string.IsNullOrEmpty(output));
if ((input != ""))
{
char lastChar = '\0'; //output[output.Length - 1];
try
{
var output_expected = System.Web.Security.AntiXss.AntiXssEncoder.CssEncode(input);
Assert.AreEqual<string>(output_expected, output);
okCnt += 1;
}
catch (Exception)
{
Assert.AreEqual<char>('\0', lastChar);
error0Cnt += 1;
}
}
//exclude this solution, before picking the next one
solver.MainSolver.Assert(solver.MkNeq(inputConst, model[inputConst].Value));
}
Assert.AreEqual(K, okCnt);
}
// [TestMethod]
public void DecodeDecode()
{
Z3Provider solver = new Z3Provider();
var A = BekConverter.BekToSTb(solver, BekConverter.BekFileToBekProgram(sampleDir + "bek/Base64decode.bek")).ExploreBools().ToST();
var ID = ST<FuncDecl, Expr, Sort>.MkId(solver, solver.CharSort);
var st = A.Compose(A);
//st.ShowGraph();
var sfa1 = st.ToSFA().Automaton;
var sfa = ConvertToAutomatonOverBvSet(solver, sfa1).Determinize().MinimizeHopcroft();
//solver.CharSetProvider.ShowGraph(sfa, "test");
}
public void EmptyTupleTest()
{
Z3Provider Z = new Z3Provider();
Sort sort = Z.MkTupleSort();
Expr unit = Z.MkTuple();
Expr t = Z.MkVar(0, sort);
Expr t_eq_unit = Z.MkEq(t, unit);
var v = new List<IValue<Expr>>(Z.MainSolver.FindAllMembers(t_eq_unit));
Assert.IsTrue(v.Count == 1);
Assert.AreEqual(unit, v[0].Value);
}
public void TestCreationOfTwoAlphabets1()
{
Z3Provider Z = new Z3Provider();
var A = Z.TT.MkRankedAlphabet("A", Z.IntSort, new string[] { "zero", "one", "two" }, new int[] { 0, 1, 2 });
var B = Z.TT.MkRankedAlphabet("B", Z.IntSort, new string[] { "zero", "one", "two" }, new int[] { 0, 1, 2 });
Assert.IsTrue(A.ContainsConstructor("two"));
Assert.IsTrue(B.ContainsConstructor("two"));
var twoA = A.GetConstructor("two");
var twoB = B.GetConstructor("two");
Assert.AreNotEqual<FuncDecl>(twoA, twoB);
Assert.AreEqual<string>("two", twoA.Name.ToString());
Assert.AreEqual<string>("two", twoB.Name.ToString());
}
public void ZeroOneTwoAlphabetTest2()
{
Z3Provider z3p = new Z3Provider();
try
{ //number of ranks is wrong
var A = z3p.TT.MkRankedAlphabet("A", z3p.IntSort, new string[] { "zero", "one", "two" }, new int[] { 0, 1 });
Assert.IsTrue(false, "expecting exception RankedAlphabet_IsInvalid");
}
catch (AutomataException e)
{
Assert.IsTrue(AutomataExceptionKind.RankedAlphabet_IsInvalid == e.kind);
}
}
public void TestCreationOfTwoAlphabets2()
{
try
{
Z3Provider Z = new Z3Provider();
var A = Z.TT.MkRankedAlphabet("A", Z.IntSort, new string[] { "zero", "one", "two" }, new int[] { 0, 1, 2 });
var B = Z.TT.MkRankedAlphabet("A", Z.IntSort, new string[] { "zero", "two" }, new int[] { 0, 1 });
Assert.IsTrue(false, "expecting exception RankedAlphabet_IsAlreadyDefined");
}
catch (AutomataException e)
{
Assert.IsTrue(e.kind == AutomataExceptionKind.RankedAlphabet_IsAlreadyDefined);
}
}
public void TestBase64Decode()
{
Z3Provider solver = new Z3Provider();
var bek = BekConverter.BekFileToBekProgram(sampleDir + "bek/Base64decode.bek");
var st = BekConverter.BekToSTb(solver, bek).ExploreBools().ToST();
st.Simplify();
//st.ShowGraph();
var st0 = st.RestrictDomain(@"^([AB]{3})*$");
//st0.ShowGraph();
var st1 = st0.Explore();
//st1.Simplify();
//st1.ShowGraph();
//st.ToDot("c:/tmp/b64d.dot");
var sft = st.Explore();
var Q = sft.StateCount;
int M = 0;
int F = 0;
int tot = 0;
var tmp = new Dictionary<Expr, int>();
foreach (var m in sft.GetMoves())
{
if (m.Label.IsFinal)
{
F += 1;
tot += 1;
}
else
{
M += 1;
int k = 0;
if (tmp.TryGetValue(m.Label.Guard, out k))
tot += k;
else
{
foreach (var v in solver.MainSolver.FindAllMembers(m.Label.Guard))
k += 1;
tot += k;
tmp[m.Label.Guard] = k;
}
}
}
Console.WriteLine(tot);
Assert.AreEqual<int>(87, Q);
}
public void FuncDeclTest3()
{
try
{
Z3Provider Z = new Z3Provider();
Z.MainSolver.Push();
FuncDecl f = Z.MkFuncDecl("temp", Z.IntSort, Z.IntSort);
Z.MainSolver.Push();
Z.MainSolver.Push();
Z.MainSolver.Pop();
Z.MainSolver.Pop();
FuncDecl g = Z.MkFuncDecl("temp", Z.IntSort, Z.IntSort);
Z.MainSolver.Push();
Z.MainSolver.Pop();
}
catch (AutomataException e)
{
Assert.AreEqual(e.kind, AutomataExceptionKind.FunctionIsAlreadyDeclared);
}
}
public void Test_aaa2b_Keep()
{
string bek = @"
program a2b(_){
replace {
""aaa"" ==> [#1 + 1];
else ==> [#0];
}
}";
Z3Provider solver = new Z3Provider();
var st = BekConverter.BekToSTb(solver, bek).ToST();
//st.ShowGraph();
var st1 = st.ExploreBools();
//st1.ShowGraph();
var stb = st1.ToSTb();
//stb.ShowGraph();
var meth = stb.Compile();
var res = meth.Apply("ac_aaaaGGhh");
Assert.AreEqual<string>("ac_baGGhh", res);
}
public Const(ConstDef def, FastTransducerInstance fti, Z3Provider z3p)
{
this.z3p = z3p;
this.name = def.id.text;
switch (def.sort.kind)
{
case (FastSortKind.Real):
{
sort = z3p.RealSort;
break;
}
case (FastSortKind.Bool):
{
sort = z3p.BoolSort;
break;
}
case (FastSortKind.Int):
{
sort = z3p.IntSort;
break;
}
case (FastSortKind.String):
{
sort = z3p.MkListSort(z3p.CharSort);
break;
}
case (FastSortKind.Tree):
{
foreach (var enumSort in fti.enums)
{
if (enumSort.name == def.sort.name.text)
{
sort = enumSort.sort;
break;
}
}
break;
}
}
this.value = GenerateZ3ExprFromExpr(def.expr, fti).Simplify();
}
internal override Automaton<Expr> getAutomata(Z3Provider z3p, List<string> variables, Expr universe, Expr var, Sort sort)
{
//var bit1 = z3p.Z3.MkInt2Bv(1,
// z3p.MkInt(1));
var bit1 = z3p.Z3.MkInt2BV(BVConst.BVSIZE, (IntExpr)z3p.MkInt(1));
//Sort for pairs (input theory, BV)
var bv = z3p.Z3.MkBitVecSort(BVConst.BVSIZE);
var pairSort = z3p.MkTupleSort(sort, bv);
//Add the representation of the existential variable to the list of variables
var newVariables = variables.ToArray().ToList();
newVariables.Insert(0, variable);
//Compute the DFA for the formula phi
var phiDfa = phi.getAutomata(z3p, newVariables, universe, var, sort);
//Compute the new moves by dropping the last bit of every element in the phiMoves
var newMoves = Automaton<Expr>.Empty.GetMoves().ToList();
foreach (var oldMove in phiDfa.GetMoves())
{
var oldCond = oldMove.Label;
var t = z3p.MkProj(1,var);
//Compute the new conditions
var newCond0 = z3p.ApplySubstitution(oldCond, t,
z3p.Z3.MkBVSHL((BitVecExpr)t, (BitVecExpr)bit1));
var newCond1 = z3p.ApplySubstitution(oldCond, t,
z3p.MkBvAdd(
z3p.Z3.MkBVSHL((BitVecExpr)t, (BitVecExpr)bit1),
bit1));
//Update the new set of moves
newMoves.Add(new Move<Expr>(oldMove.SourceState, oldMove.TargetState, z3p.MkOr(z3p.Simplify(newCond0),z3p.Simplify(newCond1))));
}
//Build the new dfa with the new moves
return Automaton<Expr>.Create(phiDfa.InitialState, phiDfa.GetFinalStates(), newMoves);
//.Determinize(z3p).MinimizeClassical(z3p, int.MaxValue,false);
}
public void ZeroOneTwoAlphabetTest1()
{
Z3Provider z3p = new Z3Provider();
var A = z3p.TT.MkRankedAlphabet("A", z3p.IntSort, new string[] { "zero", "one", "two" }, new int[] { 0, 1, 2 });
var Asort = A.AlphabetSort;
Assert.IsTrue(A.AlphabetSort.Equals(Asort));
Assert.IsTrue(A.ContainsConstructor("one"));
Assert.IsFalse(A.ContainsConstructor("one1"));
Assert.IsTrue(A.GetRank("one") == 1);
Assert.IsTrue(z3p.GetDomain(A.GetTester("one")).Length == 1);
Assert.IsTrue(z3p.GetDomain(A.GetTester("one"))[0].Equals(Asort));
Assert.IsTrue(z3p.GetDomain(A.GetConstructor("one")).Length == 2);
Assert.IsTrue(z3p.GetDomain(A.GetConstructor("one"))[0].Equals(z3p.IntSort));
Assert.IsTrue(z3p.GetDomain(A.GetConstructor("one"))[1].Equals(Asort));
Assert.IsTrue(z3p.GetRange(A.GetConstructor("one")).Equals(Asort));
Assert.IsTrue(z3p.GetDomain(A.GetChildAccessor("one", 1)).Length.Equals(1));
Assert.IsTrue(z3p.GetDomain(A.GetChildAccessor("one", 1))[0].Equals(Asort));
Assert.IsTrue(z3p.GetRange(A.GetChildAccessor("one", 1)).Equals(Asort));
Assert.IsTrue(z3p.GetDomain(A.GetAttributeAccessor("one")).Length.Equals(1));
Assert.IsTrue(z3p.GetDomain(A.GetAttributeAccessor("one"))[0].Equals(Asort));
Assert.IsTrue(z3p.GetRange(A.GetAttributeAccessor("one")).Equals(z3p.IntSort));
}
public void TestCssEncode4eq5()
{
var solver = new Z3Provider();
var stb5 = BekConverter.BekFileToSTb(solver, sampleDir + "bek/CssEncode5.bek");
var stb4 = BekConverter.BekFileToSTb(solver, sampleDir + "bek/CssEncode4.bek");
//stb5.ShowGraph(10);
var fst4 = stb4.ToST().Explore();
var fst5 = stb5.ToST().Explore();
var dom4 = fst4.ToSFA();
var dom5 = fst5.ToSFA();
bool dom4_subsetof_dom5 = dom4.IsSubsetOf(dom5);
//var tmp = dom4.Minus(dom5);
//tmp.ShowGraph();
//var member = new List<Expr>(tmp.ChoosePathToSomeFinalState()).ToArray();
//var str = new String(Array.ConvertAll(member, m => solver.GetCharValue(solver.FindOneMember(m).Value)));
bool dom5_subsetof_dom4 = dom5.IsSubsetOf(dom4);
bool partial_equiv = fst4.Eq1(fst5);
Assert.IsTrue(dom4_subsetof_dom5);
Assert.IsTrue(partial_equiv);
Assert.IsTrue(dom5_subsetof_dom4);
}
public static string GetDTAMINFormatString(TreeTransducer aut)
{
Z3Provider Z = new Z3Provider();
StringBuilder sb = new StringBuilder();
var transition = aut.GetRules();
foreach (var rule in transition)
{
sb.Append(Z.GetNumeralInt(rule.State) + 1);
sb.Append(" ");
sb.Append(rule.Symbol.Name.ToString());
for (int j = 1; j <= rule.Rank; j++)
{
var args_j = rule.Lookahead(j - 1);
if (args_j.ToList().Count > 1)
throw new Exception("Some i has more than one state");
foreach (var rlastate in args_j)
{
sb.Append(" ");
sb.Append(Z.GetNumeralInt(rlastate)+1);
}
}
sb.AppendLine();
}
int c = 0;
foreach (var st in aut.roots)
{
if(c==aut.roots.Count-1)
sb.Append("0 " + (Z.GetNumeralInt(st) + 1));
else
sb.AppendLine("0 " + (Z.GetNumeralInt(st) + 1));
c++;
}
return sb.ToString();
}
public static string GetVataFormatString(TreeTransducer aut)
{
Z3Provider Z = new Z3Provider();
StringBuilder sb = new StringBuilder();
sb.Append("Ops");
var alph = aut.InputAlphabet;
foreach (var constructor in alph.constructors)
{
sb.AppendFormat(" {0}:{1}", constructor.Name, constructor.Arity - 1);
}
sb.AppendLine();
sb.AppendLine();
sb.AppendLine("Automaton a");
sb.AppendLine();
sb.Append("States");
var states = aut.GetStates();
foreach (var state in states)
{
sb.AppendFormat(" q{0}", int.Parse(state.ToString()));
}
sb.AppendLine();
sb.Append("Final States");
var finalStates = aut.roots;
foreach (var state in finalStates)
{
sb.AppendFormat(" q{0}", int.Parse(state.ToString()));
}
sb.AppendLine();
sb.AppendLine("Transitions");
var transition = aut.GetRules();
foreach (var rule in transition)
{
sb.Append(rule.Symbol.Name.ToString());
sb.Append("(");
for (int j = 1; j <= rule.Rank; j++)
{
var args_j = rule.Lookahead(j - 1);
if (args_j.ToList().Count > 1)
{
throw new Exception("Some i has more than one state");
}
foreach (var rlastate in args_j)
{
if (j > 1)
{
sb.Append(",");
}
sb.Append("q" + Z.GetNumeralInt(rlastate));
}
}
sb.Append(") -> ");
sb.AppendLine("q" + Z.GetNumeralInt(rule.State));
}
sb.AppendLine();
return(sb.ToString());
}
//[TestMethod]
public void TestUTF8Encode()
{
Z3Provider solver = new Z3Provider();
var stb = BekConverter.BekFileToSTb(solver, sampleDir + "bek/UTF8Encode.bek");
var tmp = stb.ToST();
var sft = stb.Explore();
var sft1 = sft.ToST();
//sft.ShowGraph();
//sft1.SaveAsDot("C:/tmp/dot/utf8encode.dot");
#region data for the popl paper
var st = sft.ToST();
int n = st.StateCount;
var moves = new List <Move <Rule <Expr> > >(st.GetMoves());
moves.RemoveAll(x => x.Label.IsFinal);
int m = moves.Count;
int t = System.Environment.TickCount;
var st_o_st = st + st;
int n1 = st_o_st.StateCount;
var moves1 = new List <Move <Rule <Expr> > >(st_o_st.GetMoves());
moves1.RemoveAll(y => y.Label.IsFinal);
int m1 = moves1.Count;
bool diff = st.Eq1(st_o_st);
t = System.Environment.TickCount - t;
#endregion
var restr = sft.ToST().RestrictDomain(".+");
restr.AssertTheory();
Expr inputConst = solver.MkFreshConst("input", restr.InputListSort);
Expr outputConst = solver.MkFreshConst("output", restr.OutputListSort);
solver.MainSolver.Assert(restr.MkAccept(inputConst, outputConst));
//validate correctness for some values against the actual UTF8Encode
//TBD: validate also exceptional behavior, when the generated code throws an exception
//the builtin one must contain the character 0xFFFD
int K = 50;
for (int i = 0; i < K; i++)
{
var model = solver.MainSolver.GetModel(solver.True, inputConst, outputConst);
string input = model[inputConst].StringValue;
string output = model[outputConst].StringValue;
Assert.IsFalse(string.IsNullOrEmpty(input));
Assert.IsFalse(string.IsNullOrEmpty(output));
byte[] encoding = Encoding.UTF8.GetBytes(input);
char[] chars = Array.ConvertAll(encoding, b => (char)b);
string output_expected = new String(chars);
string output_generated = UTF8Encode_F.Apply(input);
string output_generated2 = UTF8Encode.Apply(input);
string output_generated3 = UTF8Encode_B.Apply(input);
Assert.AreEqual <string>(output_expected, output_generated);
Assert.AreEqual <string>(output_expected, output_generated2);
Assert.AreEqual <string>(output_expected, output_generated3);
Assert.AreEqual <string>(output_expected, output);
//exclude this solution, before picking the next one
solver.MainSolver.Assert(solver.MkNeq(inputConst, model[inputConst].Value));
}
}
private static void LDiffExperimentZ3(BitWidth encoding)
{
List<string> regexes = new List<string>(SampleRegexes.regexes);
regexes.RemoveRange(2, regexes.Count - 2); //just consider the first 5 cases
long timeout = 5 * Microsoft.Automata.Internal.Utilities.HighTimer.Frequency; //5 sec
for (int i = 0; i < regexes.Count; i++)
for (int j = 0; j < regexes.Count; j++)
{
string regexA = regexes[i];
string regexB = regexes[j];
var z3p = new Z3Provider(encoding);
z3p.MainSolver.Push();
var A = z3p.RegexConverter.Convert(regexA, System.Text.RegularExpressions.RegexOptions.None);
var B = z3p.RegexConverter.Convert(regexB, System.Text.RegularExpressions.RegexOptions.None);
//A.ShowGraph();
try
{
List<Expr> witness;
var AmB = Automaton<Expr>.MkDifference(A, B, (int)timeout).Determinize().Minimize();
//AmB.ShowGraph();
bool isNonempty = Automaton<Expr>.CheckDifference(A, B, (int)timeout, out witness);
if (isNonempty)
{
string s = new String(Array.ConvertAll(witness.ToArray(), c => z3p.GetCharValue(z3p.MainSolver.FindOneMember(c).Value)));
Assert.IsTrue(Regex.IsMatch(s, regexA), s + " must match " + regexA);
Assert.IsFalse(Regex.IsMatch(s, regexB), s + " must not match " + regexB);
}
}
catch (TimeoutException)
{
Console.WriteLine("Timeout {0},{1}", i, j);
}
z3p.MainSolver.Pop();
}
}
private static void DiffExperimentZ3(BitWidth encoding)
{
List<string> regexes = new List<string>(SampleRegexes.regexes);
regexes.RemoveRange(3, regexes.Count - 3); //just consider the first few cases
long timeout = 5 * Microsoft.Automata.Internal.Utilities.HighTimer.Frequency; //5 sec
for (int i = 0; i < regexes.Count; i++)
if (i != 6)
for (int j = 0; j < regexes.Count; j++)
{
string regexA = regexes[i];
string regexB = regexes[j];
var z3p = new Z3Provider(encoding);
z3p.MainSolver.Push();
var A = z3p.RegexConverter.Convert(regexA, System.Text.RegularExpressions.RegexOptions.None);
var B = z3p.RegexConverter.Convert(regexB, System.Text.RegularExpressions.RegexOptions.None);
try
{
var C = Automaton<Expr>.MkDifference(A, B, (int)timeout);
if (!C.IsEmpty)
{
string s = GetMember(z3p, C);
Assert.IsTrue(Regex.IsMatch(s, regexA), s + " must match " + regexA);
Assert.IsFalse(Regex.IsMatch(s, regexB), s + " must not match " + regexB);
}
}
catch (TimeoutException)
{
Console.WriteLine("Timeout {0},{1}", i, j);
}
z3p.MainSolver.Pop();
}
}
internal ValueExpr(Z3Provider z3p, Expr t)
{
this.z3p = z3p;
this.value = t;
}
public void TestPositionConflict2()
{
string bek1 = @"
program decode(input){
replace {
""&"" ==> ""&"";
""<"" ==> ""<"";
"">"" ==> "">"";
@""&\d{3}$"" ==> [(#1|#2)|#3];
else ==> [#0];
}
}
";
string bek2 = @"
program decode(input){
replace {
""&"" ==> ""&"";
""<"" ==> ""<"";
"">"" ==> "">"";
@""&[0-9]{3}$"" ==> [(#1|#2)|#3];
else ==> [#0];
}
}
";
Tuple<int, string> foo = Tuple.Create(34, "abc");
Tuple<int, string> bar = Tuple.Create(34, "ab" + "c");
bool b = foo.Equals(bar);
Z3Provider solver = new Z3Provider(BitWidth.BV16);
var d1 = BekConverter.BekToSTb(solver, bek1).ToST();
var d2 = BekConverter.BekToSTb(solver, bek2).ToST();
var witness = d1.Neq1(d2);
Assert.IsFalse(witness == null);
var inp = new String(Array.ConvertAll(witness.ToArray(), x => (char)solver.GetNumeralInt(x)));
var out1 = new String(Array.ConvertAll(new List<Expr>(d1.Apply(witness)).ToArray(), x => (char)solver.GetNumeralInt(x)));
var out2 = new String(Array.ConvertAll(new List<Expr>(d2.Apply(witness)).ToArray(), x => (char)solver.GetNumeralInt(x)));
solver.Dispose();
Assert.AreNotEqual<string>(out1, out2);
}
public void TestLengthConflict()
{
string bek = @"
program decode(input){
replace {
""&"" ==> ""&"";
""<"" ==> ""<"";
"">"" ==> "">"";
else ==> [#0];
}
}
";
Z3Provider solver = new Z3Provider(BitWidth.BV16);
var test = BekConverter.BekToSTb(solver, bek);
var test1 = test.ExploreBools();
//test1.ShowGraph();
//var meth = test1.Compile();
//just test on couple of samples
//Assert.AreEqual<string>("<", meth.Apply("<"));
//Assert.AreEqual<string>(">", meth.Apply(">"));
//Assert.AreEqual<string>("&g>", meth.Apply("&g>"));
//Assert.AreEqual<string>("&g>", meth.Apply("&g>"));
var dec = test.ToST();
var d = dec.Explore();
var dd = d.Compose(d);
//var ddmeth = dd.ToSTb().Compile();
var witness = d.Neq1(dd);
Assert.IsFalse(witness == null);
var inp = new String(Array.ConvertAll(witness.ToArray(), x => (char)solver.GetNumeralInt(x)));
//var out1 = meth.Apply(inp);
//var out2 = ddmeth.Apply(inp);
var out1b = new String(Array.ConvertAll(new List<Expr>(dec.Apply(witness)).ToArray(), x => ((char)solver.GetNumeralInt(x))));
var out2b = new String(Array.ConvertAll(new List<Expr>(dd.Apply(witness)).ToArray(), x => ((char)solver.GetNumeralInt(x))));
//Assert.AreEqual<string>(out1, out1b);
//Assert.AreEqual<string>(out2, out2b);
Assert.AreNotEqual<string>(out1b, out2b);
}
private void ProdExperimentZ3(BitWidth encoding)
{
List<string> regexes = new List<string>(SampleRegexes.regexes);
regexes.RemoveRange(6, regexes.Count - 6); //just consider the first 6 cases
int nonemptyCount = 0;
var z3p = new Z3Provider(encoding);
for (int i = 0; i < regexes.Count; i++)
for (int j = 0; j < regexes.Count; j++)
{
string regexA = regexes[i];
string regexB = regexes[j];
z3p.MainSolver.Push();
var A = z3p.RegexConverter.Convert(regexA, System.Text.RegularExpressions.RegexOptions.None);
var B = z3p.RegexConverter.Convert(regexB, System.Text.RegularExpressions.RegexOptions.None);
var C = Automaton<Expr>.MkProduct(A, B);
if (i == j)
Assert.IsFalse(C.IsEmpty);
if (!C.IsEmpty)
{
nonemptyCount += 1;
string s = GetMember(z3p, C);
Assert.IsTrue(Regex.IsMatch(s, regexA, RegexOptions.None), "regex mismatch");
Assert.IsTrue(Regex.IsMatch(s, regexB, RegexOptions.None), "regex mismatch");
}
z3p.MainSolver.Pop();
}
Assert.AreEqual<int>(10, nonemptyCount, "wrong number of empty intersections");
}
public void TestComplement()
{
#region copied from above: creates the tree acceptor D
Z3Provider Z = new Z3Provider();
var A = (Z.TT.MkRankedAlphabet("A", Z.IntSort, new string[] { "zero", "one", "two" }, new int[] { 0, 1, 2 }));
var B = (Z.TT.MkRankedAlphabet("B", Z.IntSort, new string[] { "nolla", "yksi", "kaksi" }, new int[] { 0, 1, 2 }));
var C = (Z.TT.MkRankedAlphabet("C", Z.IntSort, new string[] { "noll", "ett", "tva" }, new int[] { 0, 1, 2 }));
Expr _0 = A.TT.Z.MkInt(0);
Expr _1 = A.TT.Z.MkInt(1);
Expr _11 = A.TT.Z.MkInt(11);
Expr _22 = A.TT.Z.MkInt(22);
Expr _33 = A.TT.Z.MkInt(33);
Expr _111 = A.TT.Z.MkInt(111);
Expr _222 = A.TT.Z.MkInt(222);
Expr _333 = A.TT.Z.MkInt(333);
Func <Expr, Expr> one = t => A.MkTree("one", _11, t);
Func <Expr, Expr, Expr> two = (t1, t2) => A.MkTree("two", _22, t1, t2);
Expr zero = A.MkTree("zero", _33);
Func <int, int, Expr> q = (state, var) => { return(A.MkTrans(B, state, var)); };
Func <Expr, Expr> yksi = t => B.MkTree("yksi", _111, t);
Func <Expr, Expr, Expr> kaksi = (t1, t2) => B.MkTree("kaksi", _222, t1, t2);
Expr nolla = B.MkTree("nolla", _333);
var AB_rule0 = Z.TT.MkTreeRule(A, B, 0, "zero", Z.True, nolla);
var AB_rule1 = Z.TT.MkTreeRule(A, B, 0, "two", Z.True, yksi(q(0, 1)), new int[] { 0 }, new int[] { 1 });
var AB_rule2 = A.MkAcceptorRule(1, "zero");
var AB_rule3 = A.MkAcceptorRule(1, "one", 1);
var AB_rule4 = Z.TT.MkTreeRule(A, B, 0, "one", Z.True, yksi(q(0, 1)), new int[] { 0 });
var AB = Z.TT.MkTreeAutomaton(0, A, B, new TreeRule[] { AB_rule0, AB_rule1, AB_rule2, AB_rule3, AB_rule4 });
var D_rule1 = A.MkAcceptorRule(1, "zero");
var D_rule2 = A.MkAcceptorRule(1, "two", 1, 1);
var D = Z.TT.MkTreeAutomaton(1, A, A, new TreeRule[] { D_rule1, D_rule2 });
var AB_D = AB.RestrictDomain(D);
Assert.AreEqual <int>(3, AB_D.RuleCount);
var inp1 = two(two(two(zero, zero), zero), zero);
var inp2 = two(two(two(zero, zero), zero), one(one(zero)));
var out1_actual = AB[inp1];
var out2_actual = AB[inp2];
var out_expected = yksi(yksi(yksi(nolla)));
Assert.AreEqual <int>(1, out1_actual.Length);
Assert.AreEqual <int>(1, out2_actual.Length);
Assert.AreEqual <Expr>(out_expected, out1_actual[0]);
Assert.AreEqual <Expr>(out_expected, out2_actual[0]);
var out1_actual2 = AB_D[inp1];
var out2_actual2 = AB_D[inp2];
bool acc = AB_D.Accepts(inp2);
var out_expected2 = yksi(yksi(yksi(nolla)));
Assert.AreEqual <int>(1, out1_actual2.Length);
Assert.AreEqual <int>(0, out2_actual2.Length);
Assert.IsFalse(acc);
Assert.AreEqual <Expr>(out_expected, out1_actual2[0]);
#endregion
var dta = D.Determinize();
var cdta = dta.Complement();
Assert.AreEqual(2, cdta.StateCount);
Assert.AreEqual(7, cdta.RuleCount);
}
public void TupleTest()
{
Z3Provider z3p = new Z3Provider();
//create the tuple sort for mouth
FuncDecl mouth;
FuncDecl[] mouth_accessors;
var MOUTH = z3p.MkTupleSort("MOUTH", new string[] { "open", "teeth" }, new Sort[] { z3p.BoolSort, z3p.IntSort }, out mouth, out mouth_accessors);
Func <Expr, Expr, Expr> mk_mouth = ((o, t) => z3p.MkApp(mouth, o, t));
Func <Expr, Expr> get_open = (m => z3p.MkApp(mouth_accessors[0], m));
Func <Expr, Expr> get_teeth = (m => z3p.MkApp(mouth_accessors[1], m));
//create the tuple sort for nose
FuncDecl nose;
FuncDecl[] nose_accessors;
var NOSE = z3p.MkTupleSort("NOSE", new string[] { "size" }, new Sort[] { z3p.IntSort }, out nose, out nose_accessors);
Func <Expr, Expr> mk_nose = (s => z3p.MkApp(nose, s));
Func <Expr, Expr> get_size = (n => z3p.MkApp(nose_accessors[0], n));
//create the tuple sort for head
FuncDecl head;
FuncDecl[] head_accessors;
var HEAD = z3p.MkTupleSort("HEAD", new string[] { "bald", "nose", "mouth" }, new Sort[] { z3p.BoolSort, NOSE, MOUTH }, out head, out head_accessors);
Func <Expr, Expr, Expr, Expr> mk_head = ((b, n, m) => z3p.MkApp(head, b, n, m));
Func <Expr, Expr> get_bald = (h => z3p.MkApp(head_accessors[0], h));
Func <Expr, Expr> get_nose = (h => z3p.MkApp(head_accessors[1], h));
Func <Expr, Expr> get_mouth = (h => z3p.MkApp(head_accessors[2], h));
//------------------------
// create a transformation "punch" from HEAD tp HEAD that removes k teeth, k is the second parameter of the transformation
var punch = z3p.MkFuncDecl("punch", new Sort[] { HEAD, z3p.IntSort }, HEAD);
var x = z3p.MkVar(0, HEAD); // <-- this is the input HEAD
var y = z3p.MkVar(1, z3p.IntSort); // <-- this is the n parameter
//this is the actual transformation of x that removes one tooth
var new_mouth = mk_mouth(get_open(get_mouth(x)), z3p.MkSub(get_teeth(get_mouth(x)), y));
var old_nose = get_nose(x);
var old_bald = get_bald(x);
var punch_def = mk_head(old_bald, old_nose, new_mouth);
var punch_axiom = z3p.MkEqForall(z3p.MkApp(punch, x, y), punch_def, x, y);
Func <Expr, Expr, Expr> punch_app = ((h, k) => z3p.MkApp(punch, h, k));
z3p.MainSolver.Assert(punch_axiom);
//------------------------
// create a transformation "hit" from HEAD tp HEAD that doubles the size of the nose
var hit = z3p.MkFuncDecl("hit", HEAD, HEAD);
var hit_def = mk_head(get_bald(x), mk_nose(z3p.MkMul(z3p.MkInt(2), get_size(get_nose(x)))), get_mouth(x));
var hit_axiom = z3p.MkEqForall(z3p.MkApp(hit, x), hit_def, x);
Func <Expr, Expr> hit_app = (h => z3p.MkApp(hit, h));
z3p.MainSolver.Assert(hit_axiom);
//-------------------------------
// Analysis
var H = z3p.MkConst("H", HEAD);
var N = z3p.MkConst("N", z3p.IntSort);
// check that hit and punch commute
z3p.MainSolver.Push();
z3p.MainSolver.Assert(z3p.MkNeq(punch_app(hit_app(H), N), hit_app(punch_app(H, N))));
Status status = z3p.Check(); //here status must be UNSATISFIABLE
z3p.MainSolver.Pop(); //remove the temporary context
//check that hit is not idempotent
z3p.MainSolver.Push();
z3p.MainSolver.Assert(z3p.MkNeq(hit_app(hit_app(H)), hit_app(H)));
status = z3p.Check(); //here status must not be UNSATISFIABLE (it is UNKNOWN due to use of axioms)
var model1 = z3p.Z3S.Model;
var witness1 = model1.Evaluate(H, true); //a concrete instance of HEAD that shows when hitting twice is not the same as hitting once
z3p.MainSolver.Pop();
//but it is possible that hitting twice does no harm (when nose has size 0)
z3p.MainSolver.Push();
z3p.MainSolver.Assert(z3p.MkEq(hit_app(hit_app(H)), hit_app(H)));
status = z3p.Check();
var model2 = z3p.Z3S.Model;
var witness2 = model2.Evaluate(H, true);
z3p.MainSolver.Pop();
}
public void TestCssCombinedCodepoint()
{
var kkkk = 0x7FFF - 65532;
Z3Provider solver = new Z3Provider();
Sort bv64 = solver.MkBitVecSort(64);
Sort bv16 = solver.CharacterSort;
Expr hs = solver.MkConst("hs", bv16);
Expr ls = solver.MkConst("ls", bv16);
Expr res = solver.MkConst("res", bv64);
Expr maxVal = solver.MkNumeral(0x10FFFF, bv64); //max 16 bit nr
Expr x = solver.ConvertBitVector(hs, bv64);
Expr y = solver.ConvertBitVector(ls, bv64);
Expr _0x10000 = solver.MkNumeral(0x10000, bv64);
Expr _0xD800 = solver.MkNumeral(0xD800, bv64);
Expr _0x400 = solver.MkNumeral(0x400, bv64);
Expr _0xDC00 = solver.MkNumeral(0xDC00, bv64);
ushort tmpLS = ((ushort)0xdfff) - ((ushort)0xdc00);
for (int i = 0xdc00; i <= 0xdfff; i++)
{
int j = (i - 0xdc00) >> 8;
int k = (i >> 8) & 3;
Assert.AreEqual <int>(j, k);
}
int tmpHS = (((int)0xdbff) - ((int)0xd800)) * ((int)0x400);
//int tmpHS = (((int)0xdbff) - ((int)0xd800)) << 10;
int tmpHSLS = tmpLS + tmpHS;
int maxcodepoint = tmpHSLS + 0x10000;
Expr cp = solver.MkCharAdd(_0x10000,
solver.MkCharAdd(solver.MkCharMul(solver.MkCharSub(x, _0xD800), _0x400),
solver.MkCharSub(y, _0xDC00)));
Expr ls_is_lowSurrogate =
solver.MkAnd(solver.MkCharGe(ls, solver.MkNumeral(0xdc00, bv16)),
solver.MkCharLe(ls, solver.MkNumeral(0xdfff, bv16)));
Expr hs_is_highSurrogate =
solver.MkAnd(solver.MkCharGe(hs, solver.MkNumeral(0xd800, bv16)),
solver.MkCharLe(hs, solver.MkNumeral(0xdbff, bv16)));
Expr assert = solver.Simplify(solver.MkAnd(
ls_is_lowSurrogate,
hs_is_highSurrogate,
solver.MkEq(res, cp)));
//string s = solver.PrettyPrint(assert);
solver.MainSolver.Assert(assert);
var model = solver.MainSolver.GetModel(solver.MkCharLt(maxVal, res), hs, ls, res);
Assert.IsNull(model);
//if (model != null)
//{
// int hsVal = solver.GetNumeralInt(model[hs].Value);
// int lsVal = solver.GetNumeralInt(model[ls].Value);
// long resval = solver.GetNumeralUInt(model[res].Value);
// Assert.AreEqual<long>(CssCombinedCodepoint(hsVal, lsVal), resval);
//}
}
private static IEnumerable <TransducerCompilation> GetCompilations(Z3Provider ctx, Compilation compilation, IEnumerable <SyntaxTree> trees)
{
var transducers = new Dictionary <INamedTypeSymbol, TransducerCompilation>();
var genericTransducerBaseType = compilation.GetTypeByMetadataName(typeof(Transducer <,>).FullName);
var composedTransducerBaseType = compilation.GetTypeByMetadataName(typeof(Composition <,>).FullName);
var specialTransducerBaseType = compilation.GetTypeByMetadataName(typeof(SpecialTransducer).FullName);
var charType = compilation.GetTypeByMetadataName(typeof(Int32).FullName);
foreach (var tree in trees)
{
var model = compilation.GetSemanticModel(tree);
var root = tree.GetRoot();
// Find all transducer declarations
foreach (var declaration in root.DescendantNodes().OfType <ClassDeclarationSyntax>())
{
var declarationType = model.GetDeclaredSymbol(declaration) as INamedTypeSymbol;
Debug.Assert(declarationType != null, "A class declaration's symbol is not an INamedTypeSymbol?!");
var attributes = declaration.AttributeLists.SelectMany(x => x.Attributes);
TransducerCompilation transducer = null;
// User defined transducers
var transducerType = GetConstructedBase(declarationType, genericTransducerBaseType);
if (transducerType != null && !declarationType.IsAbstract && !transducers.ContainsKey(declarationType))
{
transducer = new TransducerSource(ctx, model, declarationType, transducerType);
}
// Compositions
transducerType = GetConstructedBase(declarationType, composedTransducerBaseType);
if (transducerType != null && !declarationType.IsAbstract && !transducers.ContainsKey(declarationType))
{
transducer = new TransducerComposition(declarationType);
}
// Special transducers
transducerType = GetConstructedBase(declarationType, specialTransducerBaseType);
if (transducerType != null && !declarationType.IsAbstract)
{
if (transducers.ContainsKey(declarationType))
{
throw new TransducerCompilationException("SpecialTransducers must have only one declaration (even though they must be partial).");
}
transducer = GetSpecialCompilation(ctx, compilation, model, declarationType, attributes);
}
// Handle the [ShowGraph()] and [SuppressCodeGeneration()] attributes
if (transducer != null)
{
transducer.ShowGraphStages = GetShowGraphStages(compilation, model, attributes);
transducer.SuppressCodeGeneration = GetSuppressCodeGeneration(compilation, model, attributes);
transducers.Add(declarationType, transducer);
}
}
}
// Resolve the arguments for compositions
foreach (var composition in transducers.Values.OfType <TransducerComposition>())
{
var compositionType = GetConstructedBase(composition.DeclarationType, composedTransducerBaseType);
var innerDecl = compositionType.TypeArguments[0] as INamedTypeSymbol;
var outerDecl = compositionType.TypeArguments[1] as INamedTypeSymbol;
TransducerCompilation inner, outer;
if (!transducers.TryGetValue(innerDecl, out inner) || !transducers.TryGetValue(outerDecl, out outer))
{
throw new TransducerCompilationException("The " + composition.DeclarationType.Name + " composition's type parameters must be other transducers");
}
composition.SetOperands(inner, outer);
}
return(transducers.Values);
}
public void TestSTb_UTf8DecodeAndParse()
{
string utf8decode_bek = @"
function fuse(r,c) = ((r << 6) | (c & 0x3F));
function one(c) = ((0 <= c) && (c <= 0x7F));
function C2_DF(c) = ((0xC2 <= c) && (c <= 0xDF));
function E1_EF(c) = ((0xE1 <= c) && (c <= 0xEF));
function A0_BF(c) = ((0xA0 <= c) && (c <= 0xBF));
function x80_BF(c) = ((0x80 <= c) && (c <= 0xBF));
function x80_9F(c) = ((0x80 <= c) && (c <= 0x9F));
program utf8decode(input){
return iter(c in input)[q := 0; r := 0;]
{
case (q == 0):
if (one(c)) {yield (c);}
else if (C2_DF(c)) {q := 2; r := (c & 0x1F);} // ------ 2 bytes --------
else if (c == 0xE0) {q := 4; r := (c & 0x0F);} // ------ 3 bytes --------
else if (c == 0xED) {q := 5; r := (c & 0x0F);} // ------ 3 bytes --------
else if (E1_EF(c)) {q := 3; r := (c & 0x0F);} // ------ 3 bytes --------
else {raise InvalidInput;}
case (q == 2):
if (x80_BF(c)) {q := 0; yield(fuse(r,c)); r := 0;}
else {raise InvalidInput;}
case (q == 3):
if (x80_BF(c)) {q := 2; r := fuse(r,c);}
else {raise InvalidInput;}
case (q == 4):
if (A0_BF(c)) {q := 2; r := fuse(r,c);}
else {raise InvalidInput;}
case (q == 5):
if (x80_9F(c)) {q := 2; r := fuse(r,c);}
else {raise InvalidInput;}
end case (!(q == 0)):
raise InvalidInput;
};
}
";
Z3Provider solver = new Z3Provider(BitWidth.BV16);
var dec = BekConverter.BekToSTb(solver, utf8decode_bek);
var utf8decode = dec.ExploreBools();
STbFromRegexBuilder <FuncDecl, Expr, Sort> builder = new STbFromRegexBuilder <FuncDecl, Expr, Sort>(solver);
var parse = builder.Mk(@"((?<i>[1-9][0-9]*),)*", "i", "int");
var comp = utf8decode.Compose(parse);
//utf8decode.ToST().ShowGraph();
//parse.ToST().ShowGraph();
//comp.ToST().ShowGraph();
var simpl = comp.Simplify();
//simpl.ToST().ShowGraph();
}
public void TestHtmlDecode()
{
string bekprefix = @"
//helpers
function D1(c) = ite(('0' <= c) && (c <= '9'), c -'0', 10 + ite(('A' <= c) && (c <= 'F'), c -'A', c - 'a'));
function D2(b,x0,x1) = (b*D1(x0) + D1(x1));
function D3(b,x0,x1,x2) = (b*D2(b,x0,x1) + D1(x2));
function D4(b,x0,x1,x2,x3) = (b*D3(b,x0,x1,x2) + D1(x3));
function D5(b,x0,x1,x2,x3,x4) = (b*D4(b,x0,x1,x2,x3) + D1(x4));
program HtmlDecode(_){
replace {
//most common cases should come first for efficiency
""[^&]"" ==> [#0];
""&"" ==> ""&"";
""<"" ==> ""<"";
"">"" ==> "">"";
""""" ==> ""\"""";
""'"" ==> ""\'"";
//exceptions, do not rewrite 0
//""�"" ==> ""�"";
//""�"" ==> ""�"";
//""�"" ==> ""�"";
//""�"" ==> ""�"";
//""�"" ==> ""�"";
//""�"" ==> ""�"";
//""�"" ==> ""�"";
//""�"" ==> ""�"";
//""�"" ==> ""�"";
//""�"" ==> ""�"";
//""�"" ==> ""�"";
//""�"" ==> ""�"";
//""�"" ==> ""�"";
//decimal encodings
""&#[0-9];"" ==> [D1(#2)];
""&#[0-9][0-9];"" ==> [D2(10,#2,#3)];
""&#[0-9][0-9][0-9];"" ==> [D3(10,#2,#3,#4)];
""&#[0-9]{4};"" ==> [D4(10,#2,#3,#4,#5)];
""&#[0-5][0-9]{4};"" ==> [D5(10,#2,#3,#4,#5,#6)];
""[0-4][0-9]{3};"" ==> [D5(10,#2,#3,#4,#5,#6)];
""A[0-4][0-9]{2};"" ==> [D5(10,#2,#3,#4,#5,#6)];
""ʏ[0-2][0-9];"" ==> [D5(10,#2,#3,#4,#5,#6)];
""ᦙ[0-5];"" ==> [D5(10,#2,#3,#4,#5,#6)];
//hexadecimal encodings
""&#[xX][0-9A-Fa-f]{1};""==> [D1(#3)];
""&#[xX][0-9A-Fa-f]{2};""==> [D2(16,#3,#4)];
""&#[xX][0-9A-Fa-f]{3};""==> [D3(16,#3,#4,#5)];
""&#[xX][0-9A-Fa-f]{4};""==> [D4(16,#3,#4,#5,#6)];
//other, less common fixed patterns
";
//fixed HtmlDecode patterns
var time = System.Environment.TickCount;
StringBuilder sb = new StringBuilder(bekprefix);
HashSet <string> newones = new HashSet <string>();
foreach (var p in fixedPatterns)
{
if (newones.Add(p))
{
var c = System.Net.WebUtility.HtmlDecode("&" + p + ";");
Assert.AreEqual <int>(1, c.Length);
sb.AppendLine(string.Format(" \"&{0};\" ==> ['{1}'];", p, StringUtility.Escape(c[0])));
}
}
sb.AppendLine(" else ==> [#0];");
sb.AppendLine(" };");
sb.AppendLine("}");
Z3Provider solver = new Z3Provider(BitWidth.BV16);
var test = BekConverter.BekToSTb(solver, sb.ToString());
var test1 = test.ExploreBools();
//test1.ShowGraph();
var methS = test1.Compile("Microsoft.Bek.Query.Tests", "HtmlDecodeS");
time = System.Environment.TickCount - time;
Console.WriteLine("states : " + test1.StateCount);
Console.WriteLine("time : " + time);
var methA = test1.Compile("Microsoft.Bek.Query.Tests", "HtmlDecodeA", true);
//just test on couple of samples first
string[] samples = new string[] { "<&gt;", "AA&#x&apos'aaa", "�", "�", "
", "" };
for (int i = 0; i < samples.Length; i++)
{
var expected = System.Web.HttpUtility.HtmlDecode(samples[i]);
var actualS = methS.Apply(samples[i]);
Assert.AreEqual <string>(expected, actualS);
var actualA = methA.Apply(samples[i]);
Assert.AreEqual <string>(expected, actualA);
}
}
public void TestPositionConflictMiddle()
{
string bek1 = @"
program decode(input) {
return iter(c in input)[pc := 0;]{
case ((pc == 0) && (c == 'a')) :
pc := 1;
yield (c,c+1);
case ((pc == 1) && ((c == 'b') || (c == 'd'))) :
pc := 1;
yield (c,c);
case ((pc == 1) && (c == 'a')) :
pc := 2;
yield (c);
case (true):
raise Error;
} end {
case (pc == 2):
yield ('a');
case (true):
raise Error;
};
}
";
string bek2 = @"
program decode(input) {
return iter(c in input)[pc := 0;]{
case ((pc == 0) && (c == 'a')) :
pc := 1;
yield (c);
case ((pc == 1) && ((c == 'b') || (c == 'd'))) :
pc := 1;
yield (c,c);
case ((pc == 1) && (c == 'a')) :
pc := 2;
yield (c+1,c);
case (true):
raise Error;
} end {
case (pc == 2):
yield ('a');
case (true):
raise Error;
};
}
";
Z3Provider solver = new Z3Provider(BitWidth.BV16);
Func<IEnumerable<Expr>, string> GetString = w =>
{
return new String(Array.ConvertAll(new List<Expr>(w).ToArray(), x => (char)solver.GetNumeralInt(x)));
};
var A = BekConverter.BekToSTb(solver, bek1).ExploreBools().ToST().Explore();
var B = BekConverter.BekToSTb(solver, bek2).ExploreBools().ToST().Explore();
var witness = A.Neq1(B);
Assert.IsFalse(witness == null);
var inp = GetString(witness);
var out1 = GetString(A.Apply(witness));
var out2 = GetString(B.Apply(witness));
Assert.AreNotEqual<string>(out1, out2);
}
public void TestSTbSimplify()
{
string utf8decode_bek = @"
function fuse(r,c) = ((r << 6) | (c & 0x3F));
function one(c) = ((0 <= c) && (c <= 0x7F));
function C2_DF(c) = ((0xC2 <= c) && (c <= 0xDF));
function E1_EF(c) = ((0xE1 <= c) && (c <= 0xEF));
function A0_BF(c) = ((0xA0 <= c) && (c <= 0xBF));
function x80_BF(c) = ((0x80 <= c) && (c <= 0xBF));
function x80_9F(c) = ((0x80 <= c) && (c <= 0x9F));
program utf8decode(input){
return iter(c in input)[q := 0; r := 0;]
{
case (q == 0):
if (one(c)) {yield (c);}
else if (C2_DF(c)) {q := 2; r := (c & 0x1F);} // ------ 2 bytes --------
else if (c == 0xE0) {q := 4; r := (c & 0x0F);} // ------ 3 bytes --------
else if (c == 0xED) {q := 5; r := (c & 0x0F);} // ------ 3 bytes --------
else if (E1_EF(c)) {q := 3; r := (c & 0x0F);} // ------ 3 bytes --------
else {raise InvalidInput;}
case (q == 2):
if (x80_BF(c)) {q := 0; yield(fuse(r,c)); r := 0;}
else {raise InvalidInput;}
case (q == 3):
if (x80_BF(c)) {q := 2; r := fuse(r,c);}
else {raise InvalidInput;}
case (q == 4):
if (A0_BF(c)) {q := 2; r := fuse(r,c);}
else {raise InvalidInput;}
case (q == 5):
if (x80_9F(c)) {q := 2; r := fuse(r,c);}
else {raise InvalidInput;}
end case (!(q == 0)):
raise InvalidInput;
};
}
";
Z3Provider solver = new Z3Provider(BitWidth.BV16);
var dec = BekConverter.BekToSTb(solver, utf8decode_bek);
var utf8decode = dec.ExploreBools();
Sort bv32 = solver.MkBitVecSort(32);
Sort outSort = solver.MkTupleSort(solver.StringSort, bv32);
var initReg = solver.MkTuple(solver.GetNil(solver.StringSort), solver.MkNumeral(0, bv32));
var regVar = solver.MkVar(1, outSort);
var reg1 = solver.MkProj(1, regVar);
var reg0 = solver.MkProj(0, regVar);
STb <FuncDecl, Expr, Sort> parse = new STbModel(solver, "Parse", solver.CharacterSort, outSort, outSort, initReg, 0);
var letter = solver.MkOr( //solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('\xC0'), solver.CharVar),
// solver.MkCharLe(solver.CharVar, solver.MkCharExpr('\xFF'))),
solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('a'), solver.CharVar),
solver.MkCharLe(solver.CharVar, solver.MkCharExpr('z'))),
solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('A'), solver.CharVar),
solver.MkCharLe(solver.CharVar, solver.MkCharExpr('Z'))));
//var not_letter = solver.MkNot(letter);
var digit = solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('0'), solver.CharVar),
solver.MkCharLe(solver.CharVar, solver.MkCharExpr('9')));
var nl = solver.MkEq(solver.CharVar, solver.MkCharExpr('\n'));
var space = solver.MkEq(solver.CharVar, solver.MkCharExpr(' '));
//var not_nl = solver.MkNot(nl);
var _0 = solver.MkNumeral((int)'0', bv32);
//var z = solver.Z3.MkFreshConst("z", solver.CharacterSort);
//var constr = solver.MkNot(solver.Z3.MkExists(new Expr[] { z }, nl.Substitute(solver.CharVar, z)));
////var constr = nl.Substitute(solver.CharVar, z);
//solver.Z3S.Push();
//solver.Z3S.Assert((BoolExpr)solver.MkNot(constr));
//var status = solver.Check();
//var m = solver.Z3S.Model;
//var zval = m.Evaluate(z, true);
//solver.Z3S.Pop();
var loop_0 = new BaseRule <Expr>(Sequence <Expr> .Empty, regVar, 0);
var brule0_1 = new BaseRule <Expr>(Sequence <Expr> .Empty, solver.MkTuple(solver.MkListCons(solver.CharVar, reg0), reg1), 1);
var rule0 = new IteRule <Expr>(letter, brule0_1, new IteRule <Expr>(space, loop_0, UndefRule <Expr> .Default));
parse.AssignRule(0, rule0);
var brule1_2 = new BaseRule <Expr>(Sequence <Expr> .Empty, solver.MkTuple(solver.MkListCons(solver.CharVar, reg0), reg1), 2);
var brule_4 = new BaseRule <Expr>(Sequence <Expr> .Empty, regVar, 4);
var rule1 = new IteRule <Expr>(letter, brule1_2, new IteRule <Expr>(space, brule_4, UndefRule <Expr> .Default));
parse.AssignRule(1, rule1);
var brule2_3 = new BaseRule <Expr>(Sequence <Expr> .Empty, solver.MkTuple(solver.MkListCons(solver.CharVar, reg0), reg1), 4);
var rule2 = new IteRule <Expr>(letter, brule2_3, new IteRule <Expr>(space, brule_4, UndefRule <Expr> .Default));
parse.AssignRule(2, rule2);
var bv32var = solver.Z3.MkZeroExt(16, (BitVecExpr)solver.CharVar);
var brule4_5 = new BaseRule <Expr>(Sequence <Expr> .Empty, solver.MkTuple(reg0, solver.MkBvAdd(
solver.MkBvMul(solver.MkNumeral(10, bv32), reg1),
solver.MkBvSub(bv32var, _0))), 5);
var rule4 = new IteRule <Expr>(digit, brule4_5, new IteRule <Expr>(space, brule_4, UndefRule <Expr> .Default));
parse.AssignRule(4, rule4);
var brule_0 = new BaseRule <Expr>(Sequence <Expr> .Empty.Append(regVar), initReg, 0);
var brule_7 = new BaseRule <Expr>(Sequence <Expr> .Empty, regVar, 7);
var brule5_6 = new BaseRule <Expr>(Sequence <Expr> .Empty, solver.MkTuple(reg0, solver.MkBvAdd(
solver.MkBvMul(solver.MkNumeral(10, bv32), reg1),
solver.MkBvSub(bv32var, _0))), 6);
var rule5 = new IteRule <Expr>(digit, brule5_6, new IteRule <Expr>(nl, brule_0, new IteRule <Expr>(space, brule_7, UndefRule <Expr> .Default)));
parse.AssignRule(5, rule5);
var brule6_7 = new BaseRule <Expr>(Sequence <Expr> .Empty, solver.MkTuple(reg0, solver.MkBvAdd(
solver.MkBvMul(solver.MkNumeral(10, bv32), reg1),
solver.MkBvSub(bv32var, _0))), 7);
var rule6 = new IteRule <Expr>(digit, brule6_7, new IteRule <Expr>(nl, brule_0, new IteRule <Expr>(space, brule_7, UndefRule <Expr> .Default)));
parse.AssignRule(6, rule6);
var rule7 = new IteRule <Expr>(nl, brule_0, new IteRule <Expr>(space, brule_7, UndefRule <Expr> .Default));
parse.AssignRule(7, rule7);
parse.AssignFinalRule(0, new BaseRule <Expr>(Sequence <Expr> .Empty, initReg, 0));
var comp = utf8decode.Compose(parse);
//utf8decode.ToST().ShowGraph();
//parse.ToST().ShowGraph();
//comp.ToST().ShowGraph();
//var comp1 = new STbSimulator<FuncDecl,Expr,Sort>(comp);
//comp1.Explore();
//Console.WriteLine(comp1.exploredSteps);
//var rules = Array.ConvertAll(comp1.UncoveredMoves.ToArray(), r => new Tuple<int, int>(r.Item3.SourceState, r.Item3.TargetState));
var simpl = comp.Simplify();
Assert.AreEqual <int>(35, comp.StateCount);
Assert.AreEqual <int>(7, simpl.StateCount);
//simpl.ShowGraph();
}
internal TreeTheory(Z3Provider z)
{
this.Z = z;
this.identityState = z.MkInt(IdentityStateId);
}
public Automaton <Expr> getAutomata(Z3Provider z3p, Expr universe, Expr var, Sort sort)
{
return(this.ToWS1SZ3().getAutomata(z3p, universe, var, sort));
}
internal LibraryProvider(Z3Provider z3p)
{
this.z3p = z3p;
library = new Dictionary <string, Tuple <FuncDecl, Expr> >();
}
internal Z3Solver(Solver solver, Z3Provider z3p)
{
this.solver = solver;
this.z3p = z3p;
}
public void TestFastGeneration()
{
Z3Provider Z = new Z3Provider();
Sort color = Z.MkEnumSort("Color", "blue", "green", "red");
string enum_sort_name = color.Name.ToString();
Assert.AreEqual <string>("Color", enum_sort_name);
Assert.AreEqual <string>("green", Z.GetEnumElement("Color", "green").FuncDecl.Name.ToString());
FuncDecl[] fields = new FuncDecl[5];
FuncDecl mkTuple;
Sort attrSort = Z.MkTupleSort("$", new string[] { "i", "b", "e", "s", "r" }, new Sort[] { Z.IntSort, Z.BoolSort, color, Z.StringSort, Z.RealSort }, out mkTuple, out fields);
string tuple_sort_name = attrSort.Name.ToString();
string tuple_contructor_name = mkTuple.Name.ToString();
Assert.AreEqual <string>("$", tuple_sort_name);
Assert.AreEqual <string>("$", tuple_contructor_name);
Assert.AreEqual <string>("i", fields[0].Name.ToString());
Assert.AreEqual <string>("b", fields[1].Name.ToString());
Assert.AreEqual <string>("e", fields[2].Name.ToString());
Assert.AreEqual <string>("Int", Z.GetRange(fields[0]).Name.ToString());
Assert.AreEqual <string>("Bool", Z.GetRange(fields[1]).Name.ToString());
Assert.AreEqual <string>("Color", Z.GetRange(fields[2]).Name.ToString());
var A = (Z.TT.MkRankedAlphabet("A", attrSort, new string[] { "zero", "one", "two" }, new int[] { 0, 1, 2 }));
Expr _i_plus_1 = Z.MkApp(mkTuple, Z.MkAdd(Z.MkProj(0, A.AttrVar), Z.MkInt(1)), Z.True,
Z.MkIte(Z.MkGe(Z.MkProj(0, A.AttrVar), Z.MkInt(4)), Z.GetEnumElement("Color", "green"), Z.GetEnumElement("Color", "blue")), Z.MkProj(3, A.AttrVar), Z.MkAdd(Z.MkProj(4, A.AttrVar), Z.MkNumeral("9/3", Z.RealSort)));
Expr _i_plus_1_foo = Z.MkApp(mkTuple, Z.MkAdd(Z.MkProj(0, A.AttrVar), Z.MkInt(1)), Z.True,
Z.MkIte(Z.MkGe(Z.MkProj(0, A.AttrVar), Z.MkInt(4)), Z.GetEnumElement("Color", "green"), Z.GetEnumElement("Color", "blue")), Z.MkListFromString("foo", Z.CharacterSort), Z.MkNumeral("5.06", Z.RealSort));
var proj = Z.GetTupleField(attrSort, 0);
var proj_term = Z.MkApp(proj, _i_plus_1);
var proj_term2 = Z.MkProj(0, _i_plus_1);
var r1 = Z.TT.MkTreeRule(A, A, 0, "two", Z.MkGe(Z.MkProj(0, A.AttrVar), Z.MkInt(2)),
A.MkTree("two", _i_plus_1, A.MkTree("one", _i_plus_1, A.MkTrans(A, 0, 1)),
A.MkTree("two", _i_plus_1, A.MkTrans(A, 0, 2), A.MkTrans(A, 1, 2))));
var r2 = Z.TT.MkTreeRule(A, A, 1, "two", Z.MkLe(Z.MkProj(0, A.AttrVar), Z.MkInt(5)),
A.MkTree("two", _i_plus_1, A.MkTree("one", _i_plus_1, A.MkTrans(A, 0, 1)),
A.MkTree("two", _i_plus_1, A.MkTrans(A, 0, 1), A.MkTrans(A, 1, 2))));
var r3 = Z.TT.MkTreeRule(A, A, 1, "one", Z.True, A.MkTree("zero", _i_plus_1));
var r4 = Z.TT.MkTreeRule(A, A, 0, "one", Z.True, A.MkTree("zero", _i_plus_1_foo));
var r5 = Z.TT.MkTreeRule(A, A, 0, "zero", Z.True, A.MkTree("zero", _i_plus_1_foo));
var T = Z.TT.MkTreeAutomaton(0, A, A, new TreeRule[] { r1, r2, r3, r4, r5 });
var D = T.ComputeDomainAcceptor();
var sb = new StringBuilder();
var fastgen = new FastGen(Z);
fastgen.ToFast(enum_sort_name, sb);
fastgen.ToFast(A, sb);
fastgen.ToFast("A", T, sb, false);
fastgen.GetStateName = (x => "p_" + x);
fastgen.ToFast("A", D, sb, true);
Console.WriteLine(sb.ToString());
}
static string GetMember(Z3Provider z3p, Automaton<Expr> C)
{
//z3p.Chooser.RandomSeed = 123;
var sExpr = new List<Expr>(C.ChoosePathToSomeFinalState(z3p.Chooser)).ToArray();
string s = new String(Array.ConvertAll(sExpr, m => z3p.GetCharValue(z3p.MainSolver.FindOneMember(m).Value)));
return s;
}
public static TreeTransducer ParseVataFormat(string vataString)
{
var lines = vataString.Split('\r', '\n');
Z3Provider Z = new Z3Provider();
RankedAlphabet A = null;
string name = null;
List <int> finStates = new List <int>();
var rules = new List <TreeRule>();
Dictionary <string, int> names = new Dictionary <string, int>();
List <string> constructorNames = new List <string>();
List <int> constructorArities = new List <int>();
bool transitionsStarted = false;
foreach (var line in lines)
{
if (!transitionsStarted)
{
if (line.StartsWith("Ops"))
{
var constructors = line.Split(' ');
foreach (var constructor in constructors)
{
var sp = constructor.Split(':');
if (sp.Length > 1)
{
if (!constructorNames.Contains(sp[0]))
{
constructorNames.Add(sp[0]);
int ar = int.Parse(sp[1]);
constructorArities.Add(ar);
}
}
}
if (constructorNames.Count == 0)
{
return(null);
}
A = Z.TT.MkRankedAlphabet("A", Z.UnitSort, constructorNames.ToArray(), constructorArities.ToArray());
}
if (line.StartsWith("Automaton"))
{
var sp = line.Split(' ');
name = sp[1];
}
if (line.StartsWith("Final"))
{
var sp = line.Split(' ');
for (int i = 2; i < sp.Length; i++)
{
if (sp[i].Length > 0)
{
finStates.Add(GetState(sp[i], names));
}
}
}
if (line.StartsWith("Transit"))
{
transitionsStarted = true;
}
}
else
{
var sp = line.Split('-', '>');
if (sp.Length > 1)
{
var pieces = sp[0].Split('(', ',', ')', ' ');
var constructor = pieces[0];
List <int> from = new List <int>();
for (int i = 1; i < pieces.Length - 1; i++)
{
if (pieces[i].Length > 0)
{
from.Add(GetState(pieces[i], names));
}
}
var to = GetState(sp[sp.Length - 1], names);
rules.Add(Z.TT.MkTreeAcceptorRule(A, to, constructor, Z.True, from.ToArray()));
}
}
}
return(Z.TT.MkTreeAutomaton(finStates, A, A, rules));
}
private void LProdExperimentZ3(BitWidth encoding)
{
List<string> regexes = new List<string>(SampleRegexes.regexes);
regexes.RemoveRange(6, regexes.Count - 6); //just consider the first 100 cases
int nonemptyCount = 0;
for (int i = 0; i < regexes.Count; i++)
for (int j = 0; j < regexes.Count; j++)
{
string regexA = regexes[i];
string regexB = regexes[j];
var z3p = new Z3Provider(encoding);
z3p.MainSolver.Push();
var A = z3p.RegexConverter.Convert(regexA, System.Text.RegularExpressions.RegexOptions.None);
var B = z3p.RegexConverter.Convert(regexB, System.Text.RegularExpressions.RegexOptions.None);
List<Expr> witness;
bool C = Automaton<Expr>.CheckProduct(A, B, 0, out witness);
if (i == j)
Assert.IsTrue(C, "product must me nonempty");
if (C)
{
nonemptyCount += 1;
string s = new String(Array.ConvertAll(witness.ToArray(), cs => { return z3p.GetCharValue(z3p.MainSolver.FindOneMember(cs).Value); }));
Assert.IsTrue(Regex.IsMatch(s, regexA, RegexOptions.None), "regex mismatch");
Assert.IsTrue(Regex.IsMatch(s, regexB, RegexOptions.None), "regex mismatch");
}
z3p.MainSolver.Pop();
}
Assert.AreEqual<int>(10, nonemptyCount, "wrong number of empty intersections");
}
//[TestMethod]
public void TestUTF8Decode()
{
Z3Provider solver = new Z3Provider();
var dec = BekConverter.BekFileToSTb(solver, sampleDir + "bek/UTF8Decode.bek").ToST().ExploreBools();
var enc = BekConverter.BekFileToSTb(solver, sampleDir + "bek/UTF8Encode.bek").ToST().Explore();
var id = STModel.MkId(solver, solver.CharacterSort);
//var id = BekConverter.BekFileToSTb(solver, sampleDir + "bek/identity.bek").ToST();
var ed = enc + dec; //first encode then decode
var de = dec + enc; //first decode then encode
ed.Simplify();
//ed.ShowGraph(10);
//ed.ShowGraph(5);
//return;
//id.ShowGraph();
//de.ShowGraph(5);
int timeE = System.Environment.TickCount;
var encF = enc.Explore();
timeE = System.Environment.TickCount - timeE;
int timeD = System.Environment.TickCount;
var decF = dec.Explore();
timeD = System.Environment.TickCount - timeD;
decF.Simplify();
Console.WriteLine(timeE);
Console.WriteLine(timeD);
var encRuleCnt = encF.MoveCount;
var decRuleCnt = decF.MoveCount;
var tmp = new Dictionary <Expr, int>();
int m = 0;
//foreach (var move in decF.GetMoves())
//{
// int k = 0;
// if (move.Condition.IsFinal && move.Condition.Guard.Equals(solver.True))
// k = 1;
// else if (!tmp.TryGetValue(move.Condition.Guard, out k))
// {
// foreach (var v in solver.FindAllMembers(move.Condition.Guard))
// k += 1;
// tmp[move.Condition.Guard] = k;
// }
// m += k;
//}
//var dec_filtered = dec.RestrictDomain(@"^[^\xE0\xED\xF0\xF4]*$");
//dec_filtered.ShowGraph(5);
//var dec_filtered_e = dec_filtered.Explore();
//int stateCount = dec_filtered_e.StateCount;
//int moveCount = dec_filtered_e.MoveCount;
string utf16 = @"^([\0-\uD7FF\uE000-\uFFFF]|([\uD800-\uDBFF][\uDC00-\uDFFF]))*$";
var one = @"[\x00-\x7F]";
var two = @"[\xC2-\xDF][\x80-\xBF]";
var thr = @"(\xE0[\xA0-\xBF]|\xED[\x80-\x9F]|[\xE1-\xEC\xEE\xEF][\x80-\xBF])[\x80-\xBF]";
var fou = @"(\xF0[\x90-\xBF]|[\xF1-\xF3][\x80-\xBF]|\xF4[\x80-\x8F])[\x80-\xBF]{2}";
var utf8 = string.Format("^(({0})|({1})|({2})|({3}))*$", one, two, thr, fou);
var UTF_8 = new SFAModel(solver, solver.CharacterSort, solver.RegexConverter.Convert(utf8).Determinize().MinimizeHopcroft());
//UTF_8.ShowGraph();
//var F0 = new SFAModel(solver, solver.CharacterSort, solver.RegexConverter.Convert("^(\xF0[\0-\uFFFF]{3})*$").Determinize(solver).Minimize(solver));
//var decF0 = dec.RestrictDomain(F0);
//var decF0_E = decF0.Explore();
//var surr = @"^([\uD800-\uDBFF][\uDC00-\uDFFF])*$";
//var ed_surr = ed.RestrictDomain(surr);
//ed_surr.Simplify();
//ed_surr.ShowGraph(10);
//F0.ShowGraph();
//ed_F0.ShowGraph(5);
//var decE = dec.Explore();
//dec.STb.ShowGraph();
//enc.STb.ShowGraph();
var decDom = dec.ToSFA();
var edDom = ed.ToSFA();
var eDom = enc.ToSFA();
var UTF_16 = solver.RegexConverter.Convert(utf16);
int timeDEdom = System.Environment.TickCount;
var deDom = de.ToSFA();
bool equivDomDE = UTF_8.Automaton.IsEquivalentWith(deDom.Automaton);
timeDEdom = System.Environment.TickCount - timeDEdom;
Console.WriteLine(timeDEdom);
bool equivDom = UTF_16.IsEquivalentWith(edDom.Automaton);
Assert.IsTrue(equivDom);
bool equivDom2 = UTF_16.IsEquivalentWith(eDom.Automaton);
Assert.IsTrue(equivDom2);
int time0 = System.Environment.TickCount;
bool equiv0 = id.Eq1(ed);
time0 = System.Environment.TickCount - time0;
int time1 = System.Environment.TickCount;
bool equiv1 = id.Eq1(de);
time1 = System.Environment.TickCount - time1;
Assert.IsTrue(equiv1);
Assert.IsTrue(equiv0);
int time = System.Environment.TickCount;
bool equiv = id.Eq1(ed);
time = System.Environment.TickCount - time;
Console.WriteLine(time);
Assert.IsTrue(equiv);
}
private static int MintermBlowupTestHelperMoore(int K)
{
var z3p = new Z3Provider(BitWidth.BV32);
var x = z3p.CharVar;
var zero = z3p.MkNumeral(0, z3p.CharSort);
Func<int, Expr> gamma = k =>
{
int kth = 1 << k;
Expr mask = z3p.MkNumeral(kth, z3p.CharSort);
Expr cond = z3p.MkNot(z3p.MkEq(z3p.MkBvAnd(x, mask), zero));
return cond;
};
var moves = new List<Move<Expr>>();
for (int i = 0; i < K; i++)
moves.Add(Move<Expr>.Create(i, i + 1, gamma(i)));
for (int i = 0; i < K; i++)
moves.Add(Move<Expr>.Create(i == 0 ? 0 : K + i, K + i + 1, i ==0 ? z3p.MkNot(gamma(i)) : gamma(i)));
var aut = Automaton<Expr>.Create(z3p, 0, new int[] { K, 2 * K }, moves);
var sfa = new SFA<FuncDecl, Expr, Sort>(z3p, z3p.CharSort, aut);
sfa.Automaton.CheckDeterminism(true);
int t = System.Environment.TickCount;
var autmin = sfa.Automaton.MinimizeMoore();
t = System.Environment.TickCount - t;
return t;
}
internal override Automaton <Expr> getAutomata(Z3Provider z3p, List <string> variables, Expr universe, Expr var, Sort sort)
{
return(left.getAutomata(z3p, variables, universe, var, sort).Intersect(right.getAutomata(z3p, variables, universe, var, sort), z3p).Determinize(z3p).Minimize(z3p));
}
public void TestPositionConflict()
{
string bek1 = @"
program decode(input){
replace {
""&"" ==> ""&"";
""<"" ==> ""<"";
"">"" ==> "">"";
else ==> [#0];
}
}
";
string bek2 = @"
program decode(input){
replace {
""&"" ==> ""&"";
""<"" ==> ""<"";
"">"" ==> "")"";
else ==> [#0];
}
}
";
Z3Provider solver = new Z3Provider(BitWidth.BV16);
var test1 = BekConverter.BekToSTb(solver, bek1).ExploreBools();
//test1.ShowGraph();
var meth1 = test1.Compile();
var test2 = BekConverter.BekToSTb(solver, bek2).ExploreBools();
//test1.ShowGraph();
var meth2 = test2.Compile();
//just test on couple of samples
Assert.AreEqual<string>("<", meth1.Apply("<"));
Assert.AreEqual<string>(">", meth1.Apply(">"));
Assert.AreEqual<string>("&g>", meth1.Apply("&g>"));
Assert.AreEqual<string>("&g>", meth1.Apply("&g>"));
var d1 = test1.ToST().Explore();
var d2 = test2.ToST().Explore();
var witness = d1.Neq1(d2);
Assert.IsFalse(witness == null);
var inp = new String(Array.ConvertAll(witness.ToArray(), x => (char)solver.GetNumeralInt(x)));
var out1 = meth1.Apply(inp);
var out2 = meth2.Apply(inp);
Assert.AreNotEqual<string>(out1, out2);
}
internal abstract Automaton <Expr> getAutomata(Z3Provider z3p, List <string> variables, Expr universe, Expr var, Sort sort);
public void TestEq1()
{
string bek1 = @"
program decode(input) {
return iter(c in input)[pc := 0;]{
case (pc == 0) : //initial state
if (c == '&') { pc := 1; }
else { yield (c); }
case (pc == 1) : //memorized &
if (c == '&') { yield ('&'); }
else if (c == 'l') { pc := 2; }
else if (c == 'g') { pc := 3; }
else { yield ('&',c); pc := 0; }
case (pc == 2) : //memorized &l
if (c == 't') { pc := 4; }
else if (c == '&') { yield ('&','l'); pc := 1; }
else { yield ('&','l',c); pc := 0; }
case (pc == 3) : //memorized &g
if (c == 't') { pc := 5; }
else if (c == '&') { yield ('&','g'); pc := 1; }
else { yield ('&','g',c); pc := 0; }
case (pc == 4) : //memorized <
if (c == ';')
{ yield ('<'); pc := 0; } //finished <
else if (c == '&') { yield ('&','l','t'); pc := 1; }
else
{ yield ('&','l','t',c); pc := 0; }
case (true) : //memorized >
if (c == ';')
{ yield ('>'); pc := 0; } //finished >
else if (c == '&') { yield ('&','g','t'); pc := 1; }
else
{ yield ('&','g','t',c); pc := 0; }
} end {//final nonempty yields are unfinished patterns
case (pc == 0) : yield ();
case (pc == 1) : yield ('&');
case (pc == 2) : yield ('&','l');
case (pc == 3) : yield ('&','g');
case (pc == 4) : yield ('&','l','t');
case (true) : yield ('&','g','t');
};
}
";
string bek2 = @"
program decode(input){
replace {
""<"" ==> ""<"";
"">"" ==> "">"";
else ==> [#0];
}
}
";
Z3Provider solver = new Z3Provider(BitWidth.BV16);
//Func<IEnumerable<Expr>, string> GetString = w =>
//{
// return new String(Array.ConvertAll(new List<Expr>(w).ToArray(), x => (char)solver.GetNumeralInt(x)));
//};
var A = BekConverter.BekToSTb(solver, bek1).ExploreBools().ToST().Explore();
var B = BekConverter.BekToSTb(solver, bek2).ExploreBools().ToST().Explore();
var witness = A.Neq1(B);
Assert.IsTrue(witness == null);
}
public void TestHtmlDecode2()
{
string locals = @"
function dec2(x,y)=((10*(x-48))+(y-48));
function dec1(y)=(y-48);
";
string pgm = @"
program decode2(w) {
return iter(c in w) [ A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;]
{
case (D2 && (c == ';')) : //e.g. &
yield(dec2(d1,d2));
A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
case (D2 && (c == '&')) : //e.g. &&
yield('&','#', d1, d2);
A := true; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
case (D2) : //e.g. &a
yield('&','#',d1, d2, c);
A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
case (D1 && (c == ';')) : //e.g. 
yield(dec1(d1));
A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
case (D1 && (c == '&')) : //e.g. &
yield('&','#',d1);
A := true; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
case (D1 && (('0' <= c) && (c <= '9'))) : //e.g. A
A := true; H := false; D1 := false; D2 := true; d2 := c;
case (D1) : //e.g. e
yield('&','#',d1, c);
A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
case (H && (c == '&')) : // &#&
yield('&','#');
A := true; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
case (H && (('0' <= c) && (c <= '9'))) : //e.g. 
A := false; H := false; D1 := true; D2 := false; d1 := c; d2 := 0;
case (H) : //e.g. &#g
yield('&','#', c);
A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
case (A && (c == '#')) : // &#
A := false; H := true; D1 := false; D2 := false; d1 := 0; d2 := 0;
case (A && (c == '&')) : // &&
yield('&');
case (A) : // e.g. &3
yield('&',c);
A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
case (c == '&'): // &
A := true;
case (true) : //any other case
yield(c);
A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
} end
{ //characters to yield when input finished in the middle of a pattern
case (D2) :
yield('&','#',d1,d2);
case (D1) :
yield('&','#',d1);
case (H) :
yield('&','#');
case (A) :
yield('&');
case (true):
yield();
};
}
";
Z3Provider solver = new Z3Provider();
var D = BekConverter.BekToST(solver, locals + pgm);
D.Simplify();
var D1 = D.ExploreBools();
D1.Simplify();
var stb = BekConverter.BekToSTb(solver, pgm);
//avoid introduction of '0' into the intermediate result
var dom = new SFAModel(D1.Solver, D1.Solver.CharSort, D1.Solver.RegexConverter.Convert("0|�").Complement(D1.Solver));
var D1r = D1.RestrictDomain(dom);
var DD = D1r + D1r;
var w = D1r.Diff(DD);
Assert.IsNotNull(w);
string i_str = w.Input.GetStringValue(true);
string o1_str = w.Output1.GetStringValue(true);
string o2_str = w.Output2.GetStringValue(true);
Assert.IsFalse(o1_str.Equals(o2_str));
Assert.AreEqual(WebUtility.HtmlDecode(i_str), o1_str);
Assert.AreEqual(WebUtility.HtmlDecode(WebUtility.HtmlDecode(i_str)), o2_str);
}
/// <summary>
/// Creates a pretty printer of Z3 terms in the given z3 provider z3p.
/// Lists of concrete characters of the given numeric sort z3p.CharSort
/// are displayed as escaped strings encolsed in doublequotes.
/// Individual constants of sort z3p.CharSort are displayed as
/// escaped characters enclosed in single-quotes.
/// </summary>
/// <param name="z3p">given z3 provider</param>
public ExprPrettyPrinter(Z3Provider z3p)
{
if (z3p == null)
throw new ArgumentNullException("z3p");
this.charSort = z3p.CharSort;
this.z3p = z3p;
}
public void TestHtmlDecode()
{
string pgm = @"
function dec2(x,y) = ((10*(x-48)) + y - 48);
function dec1(x) = (x-48);
program decode(w) {
return iter(c in w) [ A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;]
{
//e.g. &
case (D2 && (c == ';')) :
yield(dec2(d1,d2));
A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
//e.g. &&
case (D2 && (c == '&')) :
yield('&','#', d1, d2);
A := true; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
//e.g. &a
case (D2) :
yield('&','#',d1, d2, c);
A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
//e.g. 
case (D1 && (c == ';')) :
yield(dec1(d1));
A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
//e.g. &
case (D1 && (c == '&')) :
yield('&','#',d1);
A := true; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
//e.g. A
case (D1 && (('0' <= c) && (c <= '9'))) :
D2 := true;
d2 := c;
//e.g. e
case (D1) :
yield('&','#',d1, c);
A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
// &#&
case (H && (c == '&')) :
yield('&','#');
A := true; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
//e.g. 
case (H && (('0' <= c) && (c <= '9'))) :
D1 := true;
d1 := c;
//e.g. &#g
case (H) :
yield('&','#', c);
A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
// &#
case (A && (c == '#')) :
H := true;
// &&
case (A && (c == '&')) :
yield('&');
// e.g. &3
case (A) :
yield('&',c);
A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
// &
case (c == '&'):
A := true;
//any other case
case (true) :
yield(c);
A := false; H := false; D1 := false; D2 := false; d1 := 0; d2 := 0;
//characters to yield when input finished in the middle of a pattern
end case (D2) :
yield('&','#',d1,d2);
end case (D1) :
yield('&','#',d1);
end case (H) :
yield('&','#');
end case (A) :
yield('&');
end case (true):
yield();
};
}
";
Z3Provider solver = new Z3Provider();
var D = BekConverter.BekToST(solver, pgm);
D.Simplify();
var D1 = D.ExploreBools();
D1.Simplify();
//var Dfst = D.Explore();
//Dfst.Simplify();
//D.ShowGraph(20);
//D1.ShowGraph(50);
//Dfst.ShowGraph(5);
//var D1r = D1.RestrictDomain(@"^.{5,}$");
var D1r = D1;
var DD = D1r + D1r;
//D1r.ShowGraph(10);
var w = D1r.Diff(DD);
Assert.IsNotNull(w);
string i_str = w.Input.GetStringValue(true);
string o1_str = w.Output1.GetStringValue(true);
string o2_str = w.Output2.GetStringValue(true);
Assert.IsFalse(o1_str.Equals(o2_str));
Assert.AreEqual(WebUtility.HtmlDecode(i_str), o1_str);
Assert.AreEqual(WebUtility.HtmlDecode(WebUtility.HtmlDecode(i_str)), o2_str);
//DD.Simplify();
//DD.ShowGraph(0);
//var st1st1f = st1st1.Explore();
//st1st1f.ShowGraph(5);
}
