private IEnumerable<Expression> ReplaceConstants(ExpressionTree expression, List<Expression> constants, List<IVariable> vars) { if (expression == null) yield break; if (expression.Root == null) expression.SetRoot(); if (expression.IsLeaf()) { if (HasConstant(expression.Data, constants)) { foreach (var var in vars) { if (!ValidateType(var, expression.Parent.TreeToExpression() as BinaryExpr)) continue; var newVal = ExpressionTree.ExpressionToTree(VariableToExpression(var)); var copy = expression.Root.Copy(); var newTree = ExpressionTree.FindAndReplaceNode(copy, newVal, expression.Copy()); yield return newTree.Root.TreeToExpression(); foreach (var item in ReplaceConstants(newTree.Root, constants, vars)) yield return item; } } } else { foreach (var item in ReplaceConstants(expression.LChild, constants, vars)) yield return item; foreach (var item in ReplaceConstants(expression.RChild, constants, vars)) yield return item; } }
public static IEnumerable <object> EvaluateLeaf(ExpressionTree expt, ProofState state) { Contract.Requires(expt != null && expt.IsLeaf()); foreach (var item in Interpreter.EvalTacnyExpression(state, expt.Data)) { yield return(item); } }
/// <summary> /// Resolve all variables in expression to either literal values /// or to orignal declared nameSegments /// </summary> /// <param name="guard"></param> /// <param name="state"></param> /// <returns></returns> public static IEnumerable <ExpressionTree> ResolveExpression(ExpressionTree guard, ProofState state) { Contract.Requires <ArgumentNullException>(guard != null, "guard"); Contract.Requires <ArgumentNullException>(state != null, "state"); if (guard.IsLeaf()) { if (!(guard.Data is NameSegment)) { yield return(guard.Copy()); } var newGuard = guard.Copy(); var result = EvaluateLeaf(newGuard, state); foreach (var item in result) { Contract.Assert(result != null); Expression newNs = null; // potential encapsulation problems if (item is MemberDecl) { var md = item as MemberDecl; newNs = new StringLiteralExpr(new Token(), md.Name, true); } else if (item is Formal) { var tmp = item as Formal; newNs = new NameSegment(tmp.tok, tmp.Name, null); } else if (item is NameSegment) { newNs = item as NameSegment; } else { newNs = item as Expression; // Dafny.LiteralExpr; } newGuard.Data = newNs; yield return(newGuard); } } else { foreach (var lChild in ResolveExpression(guard.LChild, state)) { if (guard.RChild != null) { foreach (var rChild in ResolveExpression(guard.RChild, state)) { yield return(new ExpressionTree(guard.Data, null, lChild, rChild)); } } else { yield return(new ExpressionTree(guard.Data, null, lChild, null)); } } } }
/// <summary> /// Evalutate an expression tree /// </summary> /// <param name="expt"></param> /// <returns></returns> protected bool EvaluateGuardTree(ExpressionTree expt) { Contract.Requires(expt != null); // if the node is leaf, cast it to bool and return if (expt.IsLeaf()) { var lit = EvaluateLeaf(expt) as LiteralExpr; return lit?.Value is bool && (bool)lit.Value; } // left branch only if (expt.LChild != null && expt.RChild == null) return EvaluateGuardTree(expt.LChild); // if there is no more nesting resolve the expression if (expt.LChild.IsLeaf() && expt.RChild.IsLeaf()) { LiteralExpr lhs = null; LiteralExpr rhs = null; lhs = EvaluateLeaf(expt.LChild) as LiteralExpr; rhs = EvaluateLeaf(expt.RChild) as LiteralExpr; if (lhs.GetType() == rhs.GetType()) return false; var bexp = tcce.NonNull(expt.Data as BinaryExpr); int res = -1; if (lhs.Value is BigInteger) { var l = (BigInteger)lhs.Value; var r = (BigInteger)rhs.Value; res = l.CompareTo(r); } else if (lhs.Value is string) { var l = (string) lhs.Value; var r = rhs.Value as string; res = String.Compare(l, r, StringComparison.Ordinal); } else if (lhs.Value is bool) { res = ((bool)lhs.Value).CompareTo((bool)rhs.Value); } switch (bexp.Op) { case BinaryExpr.Opcode.Eq: return res == 0; case BinaryExpr.Opcode.Neq: return res != 0; case BinaryExpr.Opcode.Ge: return res >= 0; case BinaryExpr.Opcode.Gt: return res > 0; case BinaryExpr.Opcode.Le: return res <= 0; case BinaryExpr.Opcode.Lt: return res < 0; } } else // evaluate a nested expression { BinaryExpr bexp = tcce.NonNull(expt.Data as BinaryExpr); if (bexp.Op == BinaryExpr.Opcode.And) return EvaluateGuardTree(expt.LChild) && EvaluateGuardTree(expt.RChild); if (bexp.Op == BinaryExpr.Opcode.Or) return EvaluateGuardTree(expt.LChild) || EvaluateGuardTree(expt.RChild); } return false; }
protected Expression EvaluateExpression(ExpressionTree expt, ProofState state) { Contract.Requires(expt != null); if (expt.IsLeaf()) { return(EvaluateLeaf(expt, state) as LiteralExpr); } var bexp = (BinaryExpr)expt.Data; if (BinaryExpr.IsEqualityOp(bexp.Op)) { bool boolVal = EvaluateEqualityExpression(expt, state); return(new LiteralExpr(new Token(), boolVal)); } var lhs = EvaluateExpression(expt.LChild, state) as LiteralExpr; var rhs = EvaluateExpression(expt.RChild, state) as LiteralExpr; // for now asume lhs and rhs are integers var l = (BigInteger)lhs?.Value; var r = (BigInteger)rhs?.Value; BigInteger res = 0; switch (bexp.Op) { case BinaryExpr.Opcode.Sub: res = BigInteger.Subtract(l, r); break; case BinaryExpr.Opcode.Add: res = BigInteger.Add(l, r); break; case BinaryExpr.Opcode.Mul: res = BigInteger.Multiply(l, r); break; case BinaryExpr.Opcode.Div: res = BigInteger.Divide(l, r); break; } return(new LiteralExpr(lhs.tok, res)); }
public static IEnumerable<object> EvaluateLeaf(ExpressionTree expt, ProofState state) { Contract.Requires(expt != null && expt.IsLeaf()); foreach (var item in Interpreter.EvaluateTacnyExpression(state, expt.Data)) yield return item; }
public static bool EvaluateEqualityExpression(ExpressionTree expt, ProofState state) { Contract.Requires(expt != null); // if the node is leaf, cast it to bool and return if (expt.IsLeaf()) { var lit = EvaluateLeaf(expt, state) as LiteralExpr; return lit?.Value is bool && (bool)lit.Value; } // left branch only if (expt.LChild != null && expt.RChild == null) return EvaluateEqualityExpression(expt.LChild, state); // if there is no more nesting resolve the expression if (expt.LChild.IsLeaf() && expt.RChild.IsLeaf()) { LiteralExpr lhs = null; LiteralExpr rhs = null; lhs = (LiteralExpr) EvaluateLeaf(expt.LChild, state).FirstOrDefault(); rhs = EvaluateLeaf(expt.RChild, state).FirstOrDefault() as LiteralExpr; if (lhs?.GetType() == rhs?.GetType()) return false; var bexp = expt.Data as BinaryExpr; int res = -1; if (lhs?.Value is BigInteger) { var l = (BigInteger)lhs.Value; var r = (BigInteger)rhs?.Value; res = l.CompareTo(r); } else if (lhs?.Value is string) { var l = (string)lhs.Value; var r = rhs?.Value as string; res = string.Compare(l, r, StringComparison.Ordinal); } else if (lhs?.Value is bool) { res = ((bool)lhs.Value).CompareTo(rhs?.Value != null && (bool)rhs?.Value); } switch (bexp.Op) { case BinaryExpr.Opcode.Eq: return res == 0; case BinaryExpr.Opcode.Neq: return res != 0; case BinaryExpr.Opcode.Ge: return res >= 0; case BinaryExpr.Opcode.Gt: return res > 0; case BinaryExpr.Opcode.Le: return res <= 0; case BinaryExpr.Opcode.Lt: return res < 0; } } else { // evaluate a nested expression var bexp = expt.Data as BinaryExpr; switch (bexp.Op) { case BinaryExpr.Opcode.And: return EvaluateEqualityExpression(expt.LChild, state) && EvaluateEqualityExpression(expt.RChild, state); case BinaryExpr.Opcode.Or: return EvaluateEqualityExpression(expt.LChild, state) || EvaluateEqualityExpression(expt.RChild, state); } } return false; }
protected Expression EvaluateExpression(ExpressionTree expt, ProofState state) { Contract.Requires(expt != null); if (expt.IsLeaf()) { return EvaluateLeaf(expt, state) as LiteralExpr; } var bexp = (BinaryExpr) expt.Data; if (BinaryExpr.IsEqualityOp(bexp.Op)) { bool boolVal = EvaluateEqualityExpression(expt, state); return new LiteralExpr(new Token(), boolVal); } var lhs = EvaluateExpression(expt.LChild,state) as LiteralExpr; var rhs = EvaluateExpression(expt.RChild, state) as LiteralExpr; // for now asume lhs and rhs are integers var l = (BigInteger)lhs?.Value; var r = (BigInteger)rhs?.Value; BigInteger res = 0; switch (bexp.Op) { case BinaryExpr.Opcode.Sub: res = BigInteger.Subtract(l, r); break; case BinaryExpr.Opcode.Add: res = BigInteger.Add(l, r); break; case BinaryExpr.Opcode.Mul: res = BigInteger.Multiply(l, r); break; case BinaryExpr.Opcode.Div: res = BigInteger.Divide(l, r); break; } return new LiteralExpr(lhs.tok, res); }
public static bool EvaluateEqualityExpression(ExpressionTree expt, ProofState state) { Contract.Requires(expt != null); // if the node is leaf, cast it to bool and return if (expt.IsLeaf()) { var lit = EvaluateLeaf(expt, state) as LiteralExpr; return(lit?.Value is bool && (bool)lit.Value); } // left branch only if (expt.LChild != null && expt.RChild == null) { return(EvaluateEqualityExpression(expt.LChild, state)); } // if there is no more nesting resolve the expression if (expt.LChild.IsLeaf() && expt.RChild.IsLeaf()) { LiteralExpr lhs = null; LiteralExpr rhs = null; lhs = EvaluateLeaf(expt.LChild, state).FirstOrDefault() as LiteralExpr; rhs = EvaluateLeaf(expt.RChild, state).FirstOrDefault() as LiteralExpr; Contract.Assert(lhs != null && rhs != null); var bexp = expt.Data as BinaryExpr; int res = -1; if (lhs?.Value is BigInteger) { var l = (BigInteger)lhs.Value; var r = (BigInteger)rhs?.Value; res = l.CompareTo(r); } else if (lhs?.Value is string) { var l = (string)lhs.Value; var r = rhs?.Value as string; res = string.Compare(l, r, StringComparison.Ordinal); } else if (lhs?.Value is bool) { res = ((bool)lhs.Value).CompareTo(rhs?.Value != null && (bool)rhs?.Value); } switch (bexp.Op) { case BinaryExpr.Opcode.Eq: return(res == 0); case BinaryExpr.Opcode.Neq: return(res != 0); case BinaryExpr.Opcode.Ge: return(res >= 0); case BinaryExpr.Opcode.Gt: return(res > 0); case BinaryExpr.Opcode.Le: return(res <= 0); case BinaryExpr.Opcode.Lt: return(res < 0); } } else { // evaluate a nested expression var bexp = expt.Data as BinaryExpr; switch (bexp.Op) { case BinaryExpr.Opcode.And: return(EvaluateEqualityExpression(expt.LChild, state) && EvaluateEqualityExpression(expt.RChild, state)); case BinaryExpr.Opcode.Or: return(EvaluateEqualityExpression(expt.LChild, state) || EvaluateEqualityExpression(expt.RChild, state)); } } return(false); }
private IEnumerable<Expression> ReplaceVar(Dictionary<Expression, List<Expression>> vars, ExpressionTree expression) { if (expression == null) yield break; if (expression.Root == null) expression.SetRoot(); if (expression.IsLeaf()) { foreach (var kvp in vars) { if (SingletonEquality(expression.Data, kvp.Key)) { foreach (var var in kvp.Value) { // safeguard against infinite loop if (SingletonEquality(kvp.Key, var)) continue; ExpressionTree newVal = RewriteExpression(expression, kvp.Key, var); if (newVal == null) break; var copy = expression.Root.Copy(); var newTree = ExpressionTree.FindAndReplaceNode(copy, newVal, expression.Copy()); yield return newTree.Root.TreeToExpression(); foreach (var item in ReplaceVar(vars, newTree.Root)) yield return item; } } } } else { foreach (var item in ReplaceVar(vars, expression.LChild)) yield return item; foreach (var item in ReplaceVar(vars, expression.RChild)) yield return item; } }
protected IEnumerable<Expression> ReplaceOp(Dictionary<BinaryExpr.Opcode, BinaryExpr.Opcode> opCodeMap, ExpressionTree formula) { if (formula == null || formula.IsLeaf()) yield break; var expressionTree = formula; var binaryExpr = formula.Data as BinaryExpr; if (binaryExpr != null) { var bexp = binaryExpr; if (opCodeMap.ContainsKey(bexp.Op)) { expressionTree = expressionTree.Copy(); expressionTree.Data = new BinaryExpr(binaryExpr.tok, opCodeMap[bexp.Op], bexp.E0, bexp.E1); expressionTree = expressionTree.Root; yield return expressionTree.Root.TreeToExpression(); } } foreach (var item in ReplaceOp(opCodeMap, expressionTree.LChild)) yield return item; foreach (var item in ReplaceOp(opCodeMap, expressionTree.RChild)) yield return item; }
/// <summary> /// Resolve all variables in expression to either literal values /// or to orignal declared nameSegments /// </summary> /// <param name="guard"></param> /// <param name="state"></param> /// <returns></returns> public static IEnumerable<ExpressionTree> ResolveExpression(ExpressionTree guard, ProofState state) { Contract.Requires<ArgumentNullException>(guard != null, "guard"); Contract.Requires<ArgumentNullException>(state != null, "state"); if (guard.IsLeaf()) { if (!(guard.Data is NameSegment)) { yield return guard.Copy(); } var newGuard = guard.Copy(); var result = EvaluateLeaf(newGuard, state); foreach (var item in result) { Contract.Assert(result != null); Expression newNs = null; // potential encapsulation problems if (item is MemberDecl) { var md = item as MemberDecl; newNs = new StringLiteralExpr(new Token(), md.Name, true); } else if (item is Formal) { var tmp = item as Formal; newNs = new NameSegment(tmp.tok, tmp.Name, null); } else if (item is NameSegment) { newNs = item as NameSegment; } else { newNs = item as Expression; // Dafny.LiteralExpr; } newGuard.Data = newNs; yield return newGuard; } } else { foreach (var lChild in ResolveExpression(guard.LChild, state)) { if (guard.RChild != null) { foreach (var rChild in ResolveExpression(guard.RChild, state)) { yield return new ExpressionTree(guard.Data, null, lChild, rChild); } } else { yield return new ExpressionTree(guard.Data, null, lChild, null); } } } }