NativeZ3Solver

Type Members

type Assumptions = Set[Trees]

Definition Classes
AbstractSolver
type Encoded = Z3AST

Definition Classes
Z3Unrolling → AbstractUnrollingSolver
type Model = inox.Model { val program: NativeZ3Solver.this.program.type }

Definition Classes
Solver → AbstractSolver
trait ModelWrapper extends AnyRef

Definition Classes
AbstractUnrollingSolver
case class SolverUnsupportedError(t: Tree, reason: Option[String] = None) extends UnsupportedTree with Product with Serializable

Definition Classes
AbstractSolver
type Trees = ast.Trees.Expr

Definition Classes
Solver → AbstractSolver

Abstract Value Members

abstract val chooses: ChooseEncoder { ... /* 2 definitions in type refinement */ }

Attributes
protected
Definition Classes
AbstractUnrollingSolver
abstract val context: Context

Definition Classes
AbstractSolver
abstract val encoder: ProgramTransformer { val sourceProgram: NativeZ3Solver.this.program.type }

Attributes
protected
Definition Classes
AbstractUnrollingSolver
abstract val program: Program

Definition Classes
AbstractSolver
implicit abstract val semantics: Program.Semantics

Attributes
protected
Definition Classes
AbstractUnrollingSolver
implicit abstract val targetSemantics: (targetProgram)#Semantics

Attributes
protected
Definition Classes
AbstractUnrollingSolver

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object SolverUnsupportedError extends Serializable

Definition Classes
AbstractSolver
var abort: Boolean

Attributes
protected
Definition Classes
AbstractUnrollingSolver
final def asInstanceOf[T0]: T0

Definition Classes
Any
def assertCnstr(expression: ast.Trees.Expr): Unit

Definition Classes
AbstractUnrollingSolver → AbstractSolver
def check(config: CheckConfiguration): Response[Model, Assumptions]

Definition Classes
AbstractUnrollingSolver → AbstractSolver
def checkAssumptions(config: Configuration)(assumptions: Set[ast.Trees.Expr]): Response[Model, Assumptions]

Definition Classes
AbstractUnrollingSolver → AbstractSolver
lazy val checkModels: Boolean

Definition Classes
AbstractUnrollingSolver
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def dbg(msg: ⇒ Any): Unit

Definition Classes
AbstractSolver
implicit val debugSection: DebugSection

Definition Classes
AbstractSolver
def declare(vd: ast.Trees.ValDef): Unit

Definition Classes
AbstractUnrollingSolver → Solver
def declareVariable(v: ast.Trees.Variable): Z3AST

Attributes
protected
Definition Classes
Z3Unrolling → AbstractUnrollingSolver
final def decode(tpe: ast.Trees.Type): ast.Trees.Type

Attributes
protected
Definition Classes
AbstractUnrollingSolver
final def decode(e: ast.Trees.Expr): ast.Trees.Expr

Attributes
protected
Definition Classes
AbstractUnrollingSolver
final def decode(v: ast.Trees.Variable): ast.Trees.Variable

Attributes
protected
Definition Classes
AbstractUnrollingSolver
final def decode(vd: ast.Trees.ValDef): ast.Trees.ValDef

Attributes
protected
Definition Classes
AbstractUnrollingSolver
final def encode(tpe: ast.Trees.Type): ast.Trees.Type

Attributes
protected
Definition Classes
AbstractUnrollingSolver
final def encode(e: ast.Trees.Expr): ast.Trees.Expr

Attributes
protected
Definition Classes
AbstractUnrollingSolver
final def encode(v: ast.Trees.Variable): ast.Trees.Variable

Attributes
protected
Definition Classes
AbstractUnrollingSolver
final def encode(vd: ast.Trees.ValDef): ast.Trees.ValDef

Attributes
protected
Definition Classes
AbstractUnrollingSolver
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
var failures: ListBuffer[Throwable]

Attributes
protected
Definition Classes
AbstractUnrollingSolver
lazy val feelingLucky: Boolean

Definition Classes
AbstractUnrollingSolver
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def free(): Unit

Definition Classes
NativeZ3Solver → Z3Unrolling → AbstractUnrollingSolver → AbstractSolver
val freeVars: IncrementalMap[ast.Trees.Variable, Encoded]

Attributes
protected
Definition Classes
AbstractUnrollingSolver
lazy val fullEncoder: ProgramTransformer { ... /* 2 definitions in type refinement */ }

Attributes
protected
Definition Classes
AbstractUnrollingSolver
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getResultSolver: Option[Solver]

Definition Classes
Solver
def hashCode(): Int

Definition Classes
AnyRef → Any
def interrupt(): Unit

Definition Classes
Z3Unrolling → AbstractUnrollingSolver → Interruptible
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
lazy val modelFinding: Boolean

Definition Classes
AbstractUnrollingSolver
val name: String

Definition Classes
NativeZ3Solver → AbstractSolver
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
var pause: Boolean

Attributes
protected
Definition Classes
AbstractUnrollingSolver
def pop(): Unit

Definition Classes
Z3Unrolling → AbstractUnrollingSolver → AbstractSolver
lazy val programEncoder: ProgramTransformer { ... /* 2 definitions in type refinement */ }

Attributes
protected
Definition Classes
AbstractUnrollingSolver
def push(): Unit

Definition Classes
Z3Unrolling → AbstractUnrollingSolver → AbstractSolver
def reset(): Unit

Definition Classes
Z3Unrolling → AbstractUnrollingSolver → AbstractSolver
lazy val s: Program.trees.type

Attributes
protected
Definition Classes
AbstractUnrollingSolver
lazy val silentErrors: Boolean

Definition Classes
AbstractUnrollingSolver
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
lazy val t: ((programEncoder)#targetProgram)#trees.type

Attributes
protected
Definition Classes
AbstractUnrollingSolver
lazy val targetProgram: (programEncoder)#targetProgram

Attributes
protected
Definition Classes
AbstractUnrollingSolver
object templates extends Templates

Definition Classes
Z3Unrolling → AbstractUnrollingSolver
lazy val theories: ProgramTransformer { ... /* 2 definitions in type refinement */ }

Attributes
protected
Definition Classes
Z3Unrolling → AbstractUnrollingSolver
def toString(): String

Definition Classes
AbstractSolver → AnyRef → Any
val underlying: AbstractZ3Solver { val program: inox.solvers.theories.<refinement>.<refinement>.type }

Attributes
protected
Definition Classes
NativeZ3Solver → Z3Unrolling → AbstractUnrollingSolver
lazy val unrollAssumptions: Boolean

Definition Classes
AbstractUnrollingSolver
lazy val unrollBound: Int

Definition Classes
AbstractUnrollingSolver
lazy val unrollFactor: Int

Definition Classes
AbstractUnrollingSolver
def unsupported(t: Tree, str: String): Nothing

Attributes
protected
Definition Classes
AbstractSolver
def unsupported(t: Tree): Nothing

Attributes
protected
Definition Classes
AbstractSolver
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def wrapModel(model: Z3Model): ModelWrapper

Attributes
protected
Definition Classes
Z3Unrolling → AbstractUnrollingSolver
lazy val z3: Z3Context

Attributes
protected
Definition Classes
Z3Unrolling

Related Docs: object NativeZ3Solver | package z3

trait NativeZ3Solver extends Z3Unrolling

Type Members

type Assumptions = Set[Trees]

type Encoded = Z3AST

type Model = inox.Model { val program: NativeZ3Solver.this.program.type }

trait ModelWrapper extends AnyRef

case class SolverUnsupportedError(t: Tree, reason: Option[String] = None) extends UnsupportedTree with Product with Serializable

type Trees = ast.Trees.Expr

Abstract Value Members

abstract val chooses: ChooseEncoder { ... /* 2 definitions in type refinement */ }

abstract val context: Context

abstract val encoder: ProgramTransformer { val sourceProgram: NativeZ3Solver.this.program.type }

abstract val program: Program

implicit abstract val semantics: Program.Semantics

implicit abstract val targetSemantics: (targetProgram)#Semantics

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object SolverUnsupportedError extends Serializable

var abort: Boolean

final def asInstanceOf[T0]: T0

def assertCnstr(expression: ast.Trees.Expr): Unit

def check(config: CheckConfiguration): Response[Model, Assumptions]

def checkAssumptions(config: Configuration)(assumptions: Set[ast.Trees.Expr]): Response[Model, Assumptions]

lazy val checkModels: Boolean

def clone(): AnyRef

def dbg(msg: ⇒ Any): Unit

implicit val debugSection: DebugSection

def declare(vd: ast.Trees.ValDef): Unit

def declareVariable(v: ast.Trees.Variable): Z3AST

final def decode(tpe: ast.Trees.Type): ast.Trees.Type

final def decode(e: ast.Trees.Expr): ast.Trees.Expr

final def decode(v: ast.Trees.Variable): ast.Trees.Variable

final def decode(vd: ast.Trees.ValDef): ast.Trees.ValDef

final def encode(tpe: ast.Trees.Type): ast.Trees.Type

final def encode(e: ast.Trees.Expr): ast.Trees.Expr

final def encode(v: ast.Trees.Variable): ast.Trees.Variable

final def encode(vd: ast.Trees.ValDef): ast.Trees.ValDef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

var failures: ListBuffer[Throwable]

lazy val feelingLucky: Boolean

def finalize(): Unit

def free(): Unit

val freeVars: IncrementalMap[ast.Trees.Variable, Encoded]

lazy val fullEncoder: ProgramTransformer { ... /* 2 definitions in type refinement */ }

final def getClass(): Class[_]

def getResultSolver: Option[Solver]

def hashCode(): Int

def interrupt(): Unit

final def isInstanceOf[T0]: Boolean

lazy val modelFinding: Boolean

val name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

var pause: Boolean

def pop(): Unit

lazy val programEncoder: ProgramTransformer { ... /* 2 definitions in type refinement */ }

def push(): Unit

def reset(): Unit

lazy val s: Program.trees.type

lazy val silentErrors: Boolean

final def synchronized[T0](arg0: ⇒ T0): T0

lazy val t: ((programEncoder)#targetProgram)#trees.type

lazy val targetProgram: (programEncoder)#targetProgram

object templates extends Templates

lazy val theories: ProgramTransformer { ... /* 2 definitions in type refinement */ }

def toString(): String

val underlying: AbstractZ3Solver { val program: inox.solvers.theories.<refinement>.<refinement>.type }

lazy val unrollAssumptions: Boolean

lazy val unrollBound: Int

lazy val unrollFactor: Int

def unsupported(t: Tree, str: String): Nothing

def unsupported(t: Tree): Nothing

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit