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);
}
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);
}
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();
}
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);
//}
}
STb <FuncDecl, Expr, Sort> Generate()
{
var name = DeclarationType.ContainingNamespace.Name + "." +
(DeclarationType.ContainingType == null ? "" : DeclarationType.ContainingType.Name + ".") + DeclarationType.Name;
Console.WriteLine("XPath " + name);
var parser = new XPathParser <IXPathNode>();
IXPathNode root;
try
{
root = parser.Parse(_xpath, new XPathNodeBuilder());
Console.WriteLine(root);
}
catch (XPathParserException e)
{
throw new TransducerCompilationException("XPath parsing failed", e);
}
var resultSort = _ctx.MkBitVecSort(32);
var levelCounterSort = _ctx.MkBitVecSort(32);
var regSort = _ctx.MkTupleSort(resultSort, levelCounterSort);
var initReg = _ctx.MkTuple(_ctx.MkNumeral(0, resultSort), _ctx.MkNumeral(0, levelCounterSort));
var stb = new STb <FuncDecl, Expr, Sort>(_ctx, "stb", _ctx.CharSort, _ctx.MkBitVecSort(32), regSort, initReg, 0);
int freeState = 1;
Func <int> nextState = () => freeState++;
var resultProj = _ctx.MkProj(0, stb.RegVar);
var levelCounterProj = _ctx.MkProj(1, stb.RegVar);
Func <int, IgnorerInfo> CreateIgnorer = (exitState) =>
{
IgnorerInfo info = new IgnorerInfo();
int outsideTagState = nextState();
int freshTagState = nextState();
int openingTagState = nextState();
int standaloneTagState = nextState();
int closingTagState = nextState();
stb.AssignRule(outsideTagState,
new IteRule <Expr>(EqualsChar(stb.InputVar, '<'),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, freshTagState),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, outsideTagState)));
stb.AssignRule(freshTagState,
new IteRule <Expr>(EqualsChar(stb.InputVar, '/'),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, closingTagState),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, openingTagState)));
var counterOne = _ctx.MkNumeral(1, levelCounterSort);
var levelCounterInc = _ctx.MkTuple(resultProj, _ctx.MkBvAdd(levelCounterProj, counterOne));
stb.AssignRule(openingTagState,
new IteRule <Expr>(EqualsChar(stb.InputVar, '>'),
new BaseRule <Expr>(Sequence <Expr> .Empty, levelCounterInc, outsideTagState),
new IteRule <Expr>(EqualsChar(stb.InputVar, '/'),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, standaloneTagState),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, openingTagState))));
var counterZero = _ctx.MkNumeral(0, levelCounterSort);
var levelCounterZeroed = _ctx.MkTuple(resultProj, counterZero);
stb.AssignRule(standaloneTagState,
new IteRule <Expr>(EqualsChar(stb.InputVar, '>'),
new IteRule <Expr>(_ctx.MkEq(levelCounterProj, counterZero),
new BaseRule <Expr>(Sequence <Expr> .Empty, levelCounterZeroed, exitState),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, outsideTagState)),
new IteRule <Expr>(EqualsChar(stb.InputVar, '/'),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, standaloneTagState),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, openingTagState))));
var levelCounterDec = _ctx.MkTuple(resultProj, _ctx.MkBvSub(levelCounterProj, counterOne));
stb.AssignRule(closingTagState,
new IteRule <Expr>(EqualsChar(stb.InputVar, '>'),
new IteRule <Expr>(_ctx.MkEq(levelCounterProj, counterOne),
new BaseRule <Expr>(Sequence <Expr> .Empty, levelCounterZeroed, exitState),
new BaseRule <Expr>(Sequence <Expr> .Empty, levelCounterDec, outsideTagState)),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, closingTagState)));
info.MoveToTagOpening = new BaseRule <Expr>(Sequence <Expr> .Empty, levelCounterZeroed, openingTagState);
info.MoveToTagOpeningOrStandalone = new IteRule <Expr>(EqualsChar(stb.InputVar, '/'),
new BaseRule <Expr>(Sequence <Expr> .Empty, levelCounterZeroed, standaloneTagState),
info.MoveToTagOpening);
var levelCounterSet = _ctx.MkTuple(resultProj, counterOne);
info.MoveToOutsideTag = new BaseRule <Expr>(Sequence <Expr> .Empty, levelCounterSet, outsideTagState);
return(info);
};
var next = root;
int?parentState = null;
int startState = stb.InitialState;
int childState = nextState();
var zeroResult = _ctx.MkTuple(_ctx.MkNumeral(0, resultSort), levelCounterProj);
while (next != null)
{
XPathAxisNode current;
var step = next as XPathStepNode;
if (step != null)
{
current = step.Left as XPathAxisNode;
next = step.Right;
}
else
{
current = next as XPathAxisNode;
next = null;
}
if (current.Axis == XPathAxis.Root)
{
continue;
}
if (current == null)
{
throw new TransducerCompilationException("Unsupported XPath node type: " + next.GetType());
}
if (current.Axis != XPathAxis.Child)
{
throw new TransducerCompilationException("Unsupported axis: " + current.Axis);
}
if (current.Type != System.Xml.XPath.XPathNodeType.Element)
{
throw new TransducerCompilationException("Unsupported node type: " + current.Type);
}
int freshTagState = nextState();
int closingTagState = nextState();
int standaloneMatchState = nextState();
int matchedOpeningTagState = nextState();
int matchedStandaloneTagState = nextState();
var ignorer = CreateIgnorer(startState);
stb.AssignRule(startState,
new IteRule <Expr>(EqualsChar(stb.InputVar, '<'),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, freshTagState),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, startState)));
int matchState = freshTagState;
int nextMatchState = nextState();
bool first = true;
foreach (char c in current.Label)
{
STbRule <Expr> matchRule;
if (first)
{
matchRule = new IteRule <Expr>(EqualsChar(stb.InputVar, '/'),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, closingTagState),
new IteRule <Expr>(EqualsChar(stb.InputVar, c),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, nextMatchState),
new IteRule <Expr>(EqualsChar(stb.InputVar, '>'),
ignorer.MoveToOutsideTag,
ignorer.MoveToTagOpening)));
first = false;
}
else
{
matchRule = new IteRule <Expr>(EqualsChar(stb.InputVar, c),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, nextMatchState),
new IteRule <Expr>(EqualsChar(stb.InputVar, '>'),
ignorer.MoveToOutsideTag,
ignorer.MoveToTagOpeningOrStandalone));
}
stb.AssignRule(matchState, matchRule);
matchState = nextMatchState;
nextMatchState = nextState();
}
stb.AssignRule(closingTagState,
new IteRule <Expr>(EqualsChar(stb.InputVar, '>'),
parentState != null ? (STbRule <Expr>) new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, parentState.Value) : new UndefRule <Expr>(),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, closingTagState)));
stb.AssignRule(matchState,
new IteRule <Expr>(EqualsChar(stb.InputVar, '>'),
new BaseRule <Expr>(Sequence <Expr> .Empty, zeroResult, childState),
new IteRule <Expr>(EqualsChar(stb.InputVar, ' '),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, matchedOpeningTagState),
new IteRule <Expr>(EqualsChar(stb.InputVar, '/'),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, standaloneMatchState),
ignorer.MoveToTagOpening))));
stb.AssignRule(standaloneMatchState,
new IteRule <Expr>(EqualsChar(stb.InputVar, '>'),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, startState),
new UndefRule <Expr>()));
stb.AssignRule(matchedOpeningTagState,
new IteRule <Expr>(EqualsChar(stb.InputVar, '>'),
new BaseRule <Expr>(Sequence <Expr> .Empty, zeroResult, childState),
new IteRule <Expr>(EqualsChar(stb.InputVar, '/'),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, matchedStandaloneTagState),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, matchedOpeningTagState))));
stb.AssignRule(matchedStandaloneTagState,
new IteRule <Expr>(EqualsChar(stb.InputVar, '>'),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, startState),
new IteRule <Expr>(EqualsChar(stb.InputVar, '/'),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, matchedStandaloneTagState),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, matchedOpeningTagState))));
parentState = startState;
startState = childState;
childState = nextState();
}
Func <Expr, Expr> AddZeros = (c) =>
{
uint k = (uint)(32 - (int)_ctx.CharSetProvider.Encoding);
if (k == 0)
{
return(c);
}
else
{
return(_ctx.MkZeroExt(k, c));
}
};
var toIntUpdate = _ctx.MkTuple(
_ctx.MkBvAdd(_ctx.MkBvMul(_ctx.MkNumeral(10, resultSort), resultProj), _ctx.MkBvSub(AddZeros(stb.InputVar), _ctx.MkNumeral((int)'0', resultSort))),
levelCounterProj);
var expectSlashState = nextState();
var scanTagState = nextState();
stb.AssignRule(startState,
new IteRule <Expr>(EqualsChar(stb.InputVar, '<'),
new BaseRule <Expr>(new Sequence <Expr>(resultProj), zeroResult, expectSlashState),
new BaseRule <Expr>(Sequence <Expr> .Empty, toIntUpdate, startState)));
stb.AssignRule(expectSlashState,
new IteRule <Expr>(EqualsChar(stb.InputVar, '/'),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, scanTagState),
new UndefRule <Expr>()));
stb.AssignRule(scanTagState,
new IteRule <Expr>(EqualsChar(stb.InputVar, '>'),
parentState != null ? (STbRule <Expr>) new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, parentState.Value) : new UndefRule <Expr>(),
new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, scanTagState)));
Console.WriteLine(stb.StateCount);
foreach (var state in stb.States)
{
stb.AssignFinalRule(state, new BaseRule <Expr>(Sequence <Expr> .Empty, stb.RegVar, state));
}
if (ShowGraphStages.Count > 0)
{
stb.ToST().ShowGraph();
}
return(stb);
}
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();
}
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);
//}
}
