diff --git a/build.sbt b/build.sbt
index 4a6567e6ec23a273f612585422f12c40db971cb5..7922c95909b9950c16306f13e8edc6178345b482 100644
--- a/build.sbt
+++ b/build.sbt
@@ -28,6 +28,9 @@ if(osName.indexOf("win") != -1) {
(unmanagedJars in Compile) += baseDirectory.value / "unmanaged" / s"scalaz3-unix-$osArch.jar"
}
+unmanagedJars in Compile += baseDirectory.value / "unmanaged" / s"princess.jar"
+unmanagedJars in Compile += baseDirectory.value / "unmanaged" / s"scala-actors-2.11.0.jar"
+
unmanagedBase <<= baseDirectory { base => base / "unmanaged" / osArch }
resolvers ++= Seq(
diff --git a/src/main/scala/inox/solvers/SolverFactory.scala b/src/main/scala/inox/solvers/SolverFactory.scala
index 12a5891cba57f840688fb5a2a9b6f201062b8c46..2bdb55956615d24c102b535797cd737d5f825532 100644
--- a/src/main/scala/inox/solvers/SolverFactory.scala
+++ b/src/main/scala/inox/solvers/SolverFactory.scala
@@ -70,7 +70,8 @@ object SolverFactory {
"unrollz3" -> "Native Z3 with inox-templates for unrolling",
"smt-cvc4" -> "CVC4 through SMT-LIB",
"smt-z3" -> "Z3 through SMT-LIB",
- "enum" -> "Enumeration-based counter-example finder"
+ "enum" -> "Enumeration-based counter-example finder",
+ "princess" -> "Princess with inox unrolling"
)
def getFromName(name: String)
@@ -139,6 +140,22 @@ object SolverFactory {
}
})
+ case "princess" => create(p)(name, () => new {
+ val program: p.type = p
+ val options = opts
+ val encoder = enc
+ } with unrolling.UnrollingSolver with TimeoutSolver {
+ self =>
+ val evaluator = ev
+ import inox.solvers.theories._
+ object theories extends NoEncoder { val sourceProgram: self.encoder.targetProgram.type = self.encoder.targetProgram }
+
+ object underlying extends {
+ val program: targetProgram.type = targetProgram
+ val options = opts
+ } with PrincessSolver
+ })
+
case _ => throw FatalError("Unknown solver: " + name)
}
}
diff --git a/src/main/scala/inox/solvers/smtlib/PrincessSolver.scala b/src/main/scala/inox/solvers/smtlib/PrincessSolver.scala
new file mode 100644
index 0000000000000000000000000000000000000000..75ca954c18f4d51b104c2cb7b736620aac16aeb3
--- /dev/null
+++ b/src/main/scala/inox/solvers/smtlib/PrincessSolver.scala
@@ -0,0 +1,415 @@
+package inox
+package solvers
+//
+// Interface file between Inox and Princess
+// Currently work in progress. Only supports subset
+// of the features from Inox. Needs a special version
+// of Princess supporting ADT:s.
+//
+// Author: Peter Backeman, Uppsala University <peter.backeman@it.uu.se>
+//
+
+import ap._
+import ap.parser._
+import scala.collection.mutable.{Map => MMap}
+
+import SolverResponses._
+import inox.ast.Identifier
+
+trait PrincessSolver extends Solver {
+ import scala.language.postfixOps
+ import IExpression._
+
+ case class PrincessSolverException(msg : String)
+ extends Exception("handle PrincessSolver: " + msg)
+
+ import PrincessSolver.this.program.trees._
+
+ def name = "Princess"
+
+ val p = SimpleAPI.spawnWithAssertions
+
+ // Internal maps storing created Constant, Variables, ADT and Function symbols
+ val integerMap : MMap[Identifier, (ITerm, ValDef)] = MMap()
+ val booleanMap : MMap[Identifier, (IAtom, ValDef)] = MMap()
+ val functionMap : MMap[Identifier, IFunction] = MMap()
+ val adtMap : MMap[Identifier, ITerm] = MMap()
+
+ object inoxToPrincess {
+ def parseValDef(vdef : ValDef) = {
+ vdef.tpe match {
+ case IntegerType => integerMap(vdef.id)._1
+ case BooleanType => booleanMap(vdef.id)._1
+ case _ => throw new PrincessSolverException("ValDef TYPE")
+ }
+ }
+
+ def parseExpr(expressions : Trees) : IExpression = {
+ expressions match {
+ case variable @ Variable(id, tpe) => {
+ tpe match {
+ case BooleanType => {
+ if (!(booleanMap contains id))
+ booleanMap += (id -> ((p.createBooleanVariable(id.toString).asInstanceOf[IAtom], variable.toVal)))
+ booleanMap(id)._1
+ }
+
+ case IntegerType => {
+ if (!(integerMap contains id))
+ integerMap += (id -> ((p.createConstant(id.toString), variable.toVal)))
+ integerMap(id)._1
+ }
+
+ case ADTType(adtName, adtTps) => {
+ adtName.toString match {
+ case "Nat" => {
+ if (!(adtMap contains id))
+ adtMap += (id -> p.createConstant(adtName.toString))
+ adtMap(id)
+ }
+ case "Z" => p.zero()
+ case _ => throw new PrincessSolverException("ADT TYPE ||" + id + "||")
+ }
+ }
+
+ // TODO: Can we handle some of these types
+ case UnitType =>
+ throw new PrincessSolverException("UNIT TYPE")
+ case CharType =>
+ throw new PrincessSolverException("CHAR TYPE")
+ case RealType =>
+ throw new PrincessSolverException("REAL TYPE")
+ case StringType =>
+ throw new PrincessSolverException("STRING TYPE")
+ case BVType(size) =>
+ throw new PrincessSolverException("BV TYPE")
+ case TypeParameter(id) =>
+ throw new PrincessSolverException("TYPE PARAMETER")
+ case TupleType(bases) =>
+ throw new PrincessSolverException("TYPLE TYPE")
+ case SetType(base) =>
+ throw new PrincessSolverException("SET TYPE")
+ case BagType(base) =>
+ throw new PrincessSolverException("BAG TYPE")
+ case MapType(from, to) =>
+ throw new PrincessSolverException("MAP TYPE")
+ case FunctionType(from, to) =>
+ throw new PrincessSolverException("FUNCTION TYPE")
+ case _ =>
+ throw new Exception("Unhandled Variable type")
+ }
+ }
+
+ // LITERALS
+ case BooleanLiteral(value) => value
+ case IntegerLiteral(value) => value.toInt
+
+
+ // EQUALITY
+ case Equals(lhs, rhs) => {
+ val pLhs = parseExpr(lhs)
+ val pRhs = parseExpr(rhs)
+ (pLhs, pRhs) match {
+ case (t1 : ITerm, t2 : ITerm) => t1 === t2
+ case (a1 : IAtom, a2 : IAtom) => a1 <=> a2
+
+ case (a1 : IAtom, f2 : IFormula) => a1 <=> f2
+ case (f1 : IFormula, a2 : IAtom) => f1 <=> a2
+
+ case (a1 : IAtom, fun2 : IFunApp) => a1 <=> (fun2 === 1)
+ case (fun1 : IFunApp, a2 : IAtom) => a2 <=> (fun1 === 1)
+ case (_, _) => throw new PrincessSolverException("Equality between types not supported: " + pLhs.getClass + " === " + pRhs.getClass)
+ }
+ }
+
+ case FunctionInvocation(id, tps, args) => {
+ if (!(functionMap contains id)) {
+ val newFun = p.createFunction(id.toString, args.length)
+ functionMap += (id -> newFun)
+ }
+ val pArgs = for (a <- args) yield parseExpr(a)
+ IFunApp(functionMap(id), (pArgs.map(_.asInstanceOf[ITerm])))
+ }
+
+ // BOOLEAN CONNECTIVES
+ case Not(expr) => ! (parseExpr(expr).asInstanceOf[IFormula])
+ case And(exprs) => {
+ val subExprs =
+ for (e <- exprs) yield
+ parseExpr(e).asInstanceOf[IFormula]
+ (subExprs.head /: subExprs.tail)((p, q) => p & q)
+ }
+
+ case Or(exprs) => {
+ val subExprs =
+ for (e <- exprs) yield
+ parseExpr(e).asInstanceOf[IFormula]
+ (subExprs.head /: subExprs.tail)((p, q) => p | q)
+ }
+
+ case Implies(lhs, rhs) => {
+ val pLhs = parseExpr(lhs).asInstanceOf[IFormula]
+ val pRhs = parseExpr(rhs).asInstanceOf[IFormula]
+ pLhs ==> pRhs
+ }
+
+
+ // INTEGER COMPARISON
+ case LessThan(lhs, rhs) => {
+ val pLhs = parseExpr(lhs).asInstanceOf[ITerm]
+ val pRhs = parseExpr(rhs).asInstanceOf[ITerm]
+ pLhs < pRhs
+ }
+
+ case GreaterThan(lhs, rhs) => {
+ val pLhs = parseExpr(lhs).asInstanceOf[ITerm]
+ val pRhs = parseExpr(rhs).asInstanceOf[ITerm]
+ pLhs > pRhs
+ }
+
+ case LessEquals(lhs, rhs) => {
+ val pLhs = parseExpr(lhs).asInstanceOf[ITerm]
+ val pRhs = parseExpr(rhs).asInstanceOf[ITerm]
+ pLhs <= pRhs
+ }
+
+ case GreaterEquals(lhs, rhs) => {
+ val pLhs = parseExpr(lhs).asInstanceOf[ITerm]
+ val pRhs = parseExpr(rhs).asInstanceOf[ITerm]
+ pLhs >= pRhs
+ }
+
+ // INTEGER ARITHMETIC
+ case Plus(lhs, rhs) => {
+ val pLhs = parseExpr(lhs).asInstanceOf[ITerm]
+ val pRhs = parseExpr(rhs).asInstanceOf[ITerm]
+ pLhs + pRhs
+ }
+
+ case Minus(lhs, rhs) => {
+ val pLhs = parseExpr(lhs).asInstanceOf[ITerm]
+ val pRhs = parseExpr(rhs).asInstanceOf[ITerm]
+ pLhs - pRhs
+ }
+
+ case Times(lhs, rhs) => {
+ val pLhs = parseExpr(lhs).asInstanceOf[ITerm]
+ val pRhs = parseExpr(rhs).asInstanceOf[ITerm]
+ pLhs * pRhs
+ }
+
+ // TODO: We should support these
+ case Division(lhs, rhs) => {
+ val pLhs = parseExpr(lhs).asInstanceOf[ITerm]
+ val pRhs = parseExpr(rhs).asInstanceOf[ITerm]
+ throw new PrincessSolverException("DIVISION")
+ }
+
+ case Remainder(lhs, rhs) => {
+ val pLhs = parseExpr(lhs).asInstanceOf[ITerm]
+ val pRhs = parseExpr(rhs).asInstanceOf[ITerm]
+ throw new PrincessSolverException("REMAINDER")
+ }
+
+ case Modulo(lhs, rhs) => {
+ val pLhs = parseExpr(lhs).asInstanceOf[ITerm]
+ val pRhs = parseExpr(rhs).asInstanceOf[ITerm]
+ throw new PrincessSolverException("MODULO")
+ }
+
+
+ // ADT
+ // TODO: Extend ADT to general case
+ case ADT(adt, args) => {
+ adt.toString match {
+ case "S" => {
+ if (args.length > 1)
+ throw new Exception("Too many arguments to succ")
+ val pArg = parseExpr(args(0))
+ p.succ(pArg.asInstanceOf[ITerm])
+ }
+ case "Z" => p.zero()
+ case _ => throw new PrincessSolverException("ADT " + adt)
+ }
+ }
+
+ case ADTSelector(adt, selector) => {
+ if (selector.toString == "p") {
+ // Hardcoded Nat.pred
+ val pArg = parseExpr(adt)
+ p.pred(pArg.asInstanceOf[ITerm])
+ } else {
+ throw new PrincessSolverException("ADTSelector")
+ }
+ }
+
+ // I think we can ignore this since we do not type our variables
+ case AsInstanceOf(expr, tpe) => {
+ parseExpr(expr)
+ }
+
+ case IsInstanceOf(expr, tpe) => {
+ if (tpe.toString == "Z") {
+ // Hardcoded Nat.isZero
+ val pArg = parseExpr(expr)
+ p.isZero(pArg.asInstanceOf[ITerm])
+ } else {
+ throw new PrincessSolverException("AsInstanceOf")
+ }
+ }
+
+ // QUANTIFIERS
+ // TODO: This is currently not used by Inox
+ // Maybe we want to handle them by ourselves?
+ case Forall(args, body) => {
+ val pBody = parseExpr(body).asInstanceOf[IFormula]
+ val pArgs =
+ for (a <- args) yield {
+ parseValDef(a)
+ }
+ // Let's do one quantifier!
+ if (pArgs.length > 1)
+ throw new PrincessSolverException("FORALL >1 QUANTIFIER")
+ val a = pArgs.head
+ all(a => pBody)
+ }
+
+
+ // LAMBDA
+ case Lambda(args, body) => {
+ parseExpr(body)
+ throw new PrincessSolverException("LAMDA")
+ }
+
+ case exp => throw new Exception("Cannot handle type: " + exp.getClass)
+ }
+ }
+
+ // Tries to convert Inox Expression to Princess IFormula
+ // If fails, just return the true formula.
+ def apply(expressions : Trees) : IFormula = {
+ try {
+ // TODO: Hack! How do we convert IAtom to isTrue(IAtom)?
+ val pExp = parseExpr(expressions)
+ (if (pExp.isInstanceOf[IAtom])
+ pExp.asInstanceOf[IAtom] & pExp.asInstanceOf[IAtom]
+ else
+ pExp).asInstanceOf[IFormula]
+
+ } catch {
+ case e : PrincessSolverException => {
+ println("PrincessSolver: " + e)
+ // TODO: Change and don't catch this expression
+ // when we have a more stable
+ true
+ }
+ }
+ }
+ }
+
+
+ import scala.collection.mutable.ListBuffer
+
+ // These are only used for debugging purposes.
+ // Maybe we can ask Princess to print asserted
+ // constraints instead of keeping track of them.
+ var constraints : ListBuffer[IFormula] = ListBuffer()
+ var pushedConstraints : List[IFormula] = List()
+
+ override def assertCnstr(expressions : Trees) : Unit = {
+ val parsedExp = inoxToPrincess(expressions)
+ constraints += parsedExp
+ p !! parsedExp
+ }
+
+ private def internalCheck() : Option[Map[ValDef, Expr]] = {
+ import SimpleAPI.ProverStatus
+ // println("//======================\\\\")
+ // println("|| PrincessSolver.check ||")
+ // println("||----------------------//")
+ // for (c <- constraints)
+ // println("|| " + c)
+ // println("||----------------------\\\\")
+ if (constraints.map(_.toString) contains "true") {
+ // println("|| (Exception encountered) Let's say UNSAT")
+ None
+ } else {
+ val result = (p.???)
+ // println("|| " + result)
+ // TODO: What to we do with inconclusive results?
+ if (result == ProverStatus.Sat || result == ProverStatus.Inconclusive) {
+ val model = p.partialModel
+ // println("||----------------------||")
+
+ // Construct a Model for Inox
+ val inoxMap = MMap() : MMap[ValDef, Expr]
+
+ // Booleans
+ for ((id, (iterm, valdef)) <- booleanMap; v = model.eval(iterm); if v.isDefined) {
+ // println("|| " + iterm + "(" + id + ") = " + v)
+ inoxMap += (valdef -> BooleanLiteral(v.get))
+ }
+
+ // Integers
+ for ((id, (iterm, valdef)) <- integerMap; v = model.eval(iterm); if v.isDefined) {
+ println("|| " + iterm + "(" + id + ") = " + v)
+ inoxMap += (valdef -> IntegerLiteral(v.get.bigIntValue))
+ }
+
+ // Let's convert model to something useful!
+ // println("\\\\======================//\n\n")
+ Some(inoxMap.toMap)
+ } else if (result == ProverStatus.Unsat) {
+ // println("\\\\======================//\n\n")
+ None
+ } else {
+ // println("\\\\======================//\n\n")
+ throw new PrincessSolverException("Neither SAT nor UNSAT result...")
+ }
+ }
+ }
+
+ override def check(config: CheckConfiguration): config.Response[Model, Assumptions] = {
+ val result = internalCheck()
+ result match {
+ case Some(model) if config.withModel => config.cast(SatWithModel(Map() : Map[ValDef, Expr]))
+ case Some(_) => config.cast(Sat)
+ case None => config.cast(Unsat)
+ }
+ }
+
+ // We use push/pop to simulate checking with assumptions
+ override def checkAssumptions(config: Configuration)(assumptions: Set[Trees]): config.Response[Model, Assumptions] = {
+ p.push
+ pushedConstraints = constraints.toList
+
+ for (a <- assumptions) {
+ assertCnstr(a)
+ }
+ val result = internalCheck()
+ p.pop
+ constraints.clear()
+ constraints ++= pushedConstraints
+ result match {
+ case Some(model) if config.withModel => config.cast(SatWithModel(Map() : Map[ValDef, Expr]))
+ case Some(_) => config.cast(Sat)
+ case None => config.cast(Unsat)
+ }
+ }
+
+ override def free() = {
+ p.shutDown
+ }
+
+ // TODO: These should be implemented, some of the should be quite easy.
+ override def pop() =
+ throw new PrincessSolverException("POP not implemented")
+ override def push() =
+ throw new PrincessSolverException("PUSH not implemented")
+ override def reset() =
+ throw new PrincessSolverException("RESET not implemented")
+ override def interrupt() =
+ throw new PrincessSolverException("INTERRUPT not implemented")
+ def recoverInterrupt() =
+ throw new PrincessSolverException("RECOVERINTERRUPT not implemented")
+}
diff --git a/unmanaged/princess.jar b/unmanaged/princess.jar
new file mode 100644
index 0000000000000000000000000000000000000000..90bb5929c8261b87a0903a73d41c117ef7ba9f8d
Binary files /dev/null and b/unmanaged/princess.jar differ
diff --git a/unmanaged/scala-actors-2.11.0.jar b/unmanaged/scala-actors-2.11.0.jar
new file mode 100644
index 0000000000000000000000000000000000000000..805ede5ea4cb40142084ed18c5584476d03a3507
Binary files /dev/null and b/unmanaged/scala-actors-2.11.0.jar differ