AbstractUnrollingSolver

Type Members

type Assumptions = Set[Trees]

Definition Classes
AbstractSolver
abstract type Encoded

Attributes
protected
type Model = inox.Model { val program: AbstractUnrollingSolver.this.program.type }

Definition Classes
Solver → AbstractSolver
trait ModelWrapper extends AnyRef
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
abstract val context: Context

Definition Classes
AbstractSolver
abstract def declareVariable(v: ast.Trees.Variable): Encoded

Attributes
protected
abstract val encoder: ProgramTransformer { val sourceProgram: AbstractUnrollingSolver.this.program.type }

Attributes
protected
abstract def name: String

Definition Classes
AbstractSolver
abstract val program: Program

Definition Classes
AbstractSolver
implicit abstract val semantics: Program.Semantics

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

Attributes
protected
abstract val templates: Templates { ... /* 2 definitions in type refinement */ }

Attributes
protected
abstract val theories: ProgramTransformer { ... /* 2 definitions in type refinement */ }

Attributes
protected
abstract val underlying: AbstractSolver { ... /* 2 definitions in type refinement */ }

Attributes
protected
abstract def wrapModel(model: (underlying)#Model): ModelWrapper

Attributes
protected

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
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
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
final def decode(tpe: ast.Trees.Type): ast.Trees.Type

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

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

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

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

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

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

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

Attributes
protected
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
lazy val feelingLucky: Boolean
def finalize(): Unit

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

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

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

Attributes
protected
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
AbstractUnrollingSolver → Interruptible
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
lazy val modelFinding: Boolean
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
def pop(): Unit

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

Attributes
protected
def push(): Unit

Definition Classes
AbstractUnrollingSolver → AbstractSolver
def reset(): Unit

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

Attributes
protected
lazy val silentErrors: Boolean
final def synchronized[T0](arg0: ⇒ T0): T0

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

Attributes
protected
lazy val targetProgram: (programEncoder)#targetProgram

Attributes
protected
def toString(): String

Definition Classes
AnyRef → Any
lazy val unrollAssumptions: Boolean
lazy val unrollFactor: Int
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( ... )

Related Doc: package unrolling

trait AbstractUnrollingSolver extends Solver

Type Members

type Assumptions = Set[Trees]

abstract type Encoded

type Model = inox.Model { val program: AbstractUnrollingSolver.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 def declareVariable(v: ast.Trees.Variable): Encoded

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

abstract def name: String

abstract val program: Program

implicit abstract val semantics: Program.Semantics

implicit abstract val targetSemantics: (targetProgram)#Semantics

abstract val templates: Templates { ... /* 2 definitions in type refinement */ }

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

abstract val underlying: AbstractSolver { ... /* 2 definitions in type refinement */ }

abstract def wrapModel(model: (underlying)#Model): ModelWrapper

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

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

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

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

def toString(): String

lazy val unrollAssumptions: Boolean

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

final def wait(arg0: Long): Unit