SMTLIBSolver

Type Members

class ADTManager extends IncrementalStateWrapper

Definition Classes
ADTManagers
trait AbstractContext extends AnyRef

Attributes
protected
Definition Classes
SMTLIBParser
type Assumptions = Set[Trees]

Definition Classes
AbstractSolver
case class Constructor(sym: Identifier, tpe: ast.Trees.Type, fields: Seq[(Identifier, ast.Trees.Type)]) extends ast.Trees.Printable with Product with Serializable

Definition Classes
ADTManagers
class Context extends AbstractContext

Attributes
protected
Definition Classes
SMTLIBTarget
case class DataType(sym: Identifier, cases: Seq[Constructor]) extends ast.Trees.Printable with Product with Serializable

Definition Classes
ADTManagers
type Model = inox.Model { val program: SMTLIBSolver.this.program.type }

Definition Classes
Solver → AbstractSolver
case class SolverUnsupportedError(t: Tree, reason: Option[String] = None) extends Unsupported with Product with Serializable

Definition Classes
AbstractSolver
type Trees = ast.Trees.Expr

Definition Classes
Solver → AbstractSolver

Abstract Value Members

abstract val interpreter: Interpreter

Attributes
protected
Definition Classes
SMTLIBTarget
abstract def interpreterOpts: Seq[String]

Attributes
protected
Definition Classes
SMTLIBDebugger
abstract val options: Options

Definition Classes
AbstractSolver
abstract val program: Program

Definition Classes
SMTLIBTarget → ADTManagers
implicit abstract val semantics: Program.Semantics

Attributes
protected
Definition Classes
SMTLIBTarget
abstract def targetName: String

Definition Classes
SMTLIBSolver → SMTLIBTarget

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 Num

Attributes
protected
Definition Classes
SMTLIBTarget
object SimpleSymbol

Attributes
protected
Definition Classes
SMTLIBTarget
object SolverUnsupportedError extends Serializable

Definition Classes
AbstractSolver
val adtManager: ADTManager

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

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

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

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

Definition Classes
SMTLIBSolver → AbstractSolver
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def computeSort(t: ast.Trees.Type): Sort

Attributes
protected
Definition Classes
SMTLIBTarget
val constructors: IncrementalBijection[ast.Trees.Type, SSymbol]

Attributes
protected
Definition Classes
SMTLIBTarget
def dbg(msg: ⇒ Any): Unit

Definition Classes
SMTLIBSolver → AbstractSolver
lazy val debugOut: Option[FileWriter]

Attributes
protected
Definition Classes
SMTLIBDebugger
implicit val debugSection: DebugSectionSolver.type

Definition Classes
AbstractSolver
def declareDatatypes(datatypes: Seq[(ast.Trees.Type, DataType)]): Unit

Attributes
protected
Definition Classes
SMTLIBTarget
def declareFunction(tfd: ast.Trees.TypedFunDef): SSymbol

Attributes
protected
Definition Classes
SMTLIBTarget
def declareLambda(tpe: ast.Trees.FunctionType): SSymbol

Attributes
protected
Definition Classes
SMTLIBTarget
final def declareSort(t: ast.Trees.Type): Sort

Attributes
protected
Definition Classes
SMTLIBTarget
def declareStructuralSort(t: ast.Trees.Type): Sort

Attributes
protected
Definition Classes
SMTLIBTarget
def declareVariable(v: ast.Trees.Variable): SSymbol

Attributes
protected
Definition Classes
SMTLIBTarget
def emit(cmd: SExpr, rawOut: Boolean = false): SExpr

Definition Classes
SMTLIBDebugger → SMTLIBTarget
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def extractResponse(config: Configuration, res: SExpr): Response[Model, Assumptions]

Attributes
protected
def finalize(): Unit

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

Definition Classes
SMTLIBDebugger → SMTLIBTarget
def freshSym(name: String): SSymbol

Attributes
protected
Definition Classes
SMTLIBTarget
def freshSym(id: Identifier): SSymbol

Attributes
protected
Definition Classes
SMTLIBTarget
def fromSMT(t: Term, otpe: Option[ast.Trees.Type] = None)(implicit context: Context): ast.Trees.Expr

Attributes
protected
Definition Classes
SMTLIBTarget → SMTLIBParser
def fromSMT(sort: Sort)(implicit context: Context): ast.Trees.Type

Attributes
protected
Definition Classes
SMTLIBTarget → SMTLIBParser
final def fromSMT(pair: (Term, ast.Trees.Type))(implicit context: Context): ast.Trees.Expr

Attributes
protected
Definition Classes
SMTLIBParser
final def fromSMT(term: Term, tpe: ast.Trees.Type)(implicit context: Context): ast.Trees.Expr

Attributes
protected
Definition Classes
SMTLIBParser
def fromSMT(sv: SortedVar)(implicit context: Context): ast.Trees.ValDef

Attributes
protected
Definition Classes
SMTLIBParser
final def fromSMTUnifyType(t1: Term, t2: Term, otpe: Option[ast.Trees.Type])(recons: (ast.Trees.Expr, ast.Trees.Expr) ⇒ ast.Trees.Expr)(implicit context: Context): ast.Trees.Expr

Attributes
protected
Definition Classes
SMTLIBParser
val functions: IncrementalBijection[ast.Trees.TypedFunDef, SSymbol]

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

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

Definition Classes
Solver
def hashCode(): Int

Definition Classes
AnyRef → Any
def id2sym(id: Identifier): SSymbol

Attributes
protected
Definition Classes
SMTLIBTarget
def interrupt(): Unit

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

Definition Classes
Any
val lambdas: IncrementalBijection[ast.Trees.FunctionType, SSymbol]

Attributes
protected
Definition Classes
SMTLIBTarget
def name: String

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def parseSuccess(): Unit

Definition Classes
SMTLIBTarget
def pop(): Unit

Definition Classes
SMTLIBSolver → AbstractSolver
def push(): Unit

Definition Classes
SMTLIBSolver → AbstractSolver
def quantifiedTerm(quantifier: (SortedVar, Seq[SortedVar], Term) ⇒ Term, body: ast.Trees.Expr)(implicit bindings: Map[Identifier, Term]): Term

Attributes
protected
Definition Classes
SMTLIBTarget
def quantifiedTerm(quantifier: (SortedVar, Seq[SortedVar], Term) ⇒ Term, vars: Seq[ast.Trees.ValDef], body: ast.Trees.Expr)(implicit bindings: Map[Identifier, Term]): Term

Attributes
protected
Definition Classes
SMTLIBTarget
lazy val reporter: Reporter

Definition Classes
AbstractSolver
def reset(): Unit

Definition Classes
SMTLIBSolver → AbstractSolver
val selectors: IncrementalBijection[(ast.Trees.Type, Int), SSymbol]

Attributes
protected
Definition Classes
SMTLIBTarget
def sortToSMT(s: Sort): SExpr

Definition Classes
SMTLIBTarget
val sorts: IncrementalBijection[ast.Trees.Type, Sort]

Attributes
protected
Definition Classes
SMTLIBTarget
implicit def symbolToQualifiedId(s: SSymbol): QualifiedIdentifier

Attributes
protected
Definition Classes
SMTLIBTarget
lazy val symbols: Program.symbols.type

Definition Classes
SMTLIBTarget → SMTLIBParser
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
val testers: IncrementalBijection[ast.Trees.Type, SSymbol]

Attributes
protected
Definition Classes
SMTLIBTarget
def toSMT(e: ast.Trees.Expr)(implicit bindings: Map[Identifier, Term]): Term

Attributes
protected
Definition Classes
SMTLIBTarget
def toSMT(t: ast.Trees.Type): SExpr

Attributes
protected
Definition Classes
SMTLIBTarget
def toString(): String

Definition Classes
AnyRef → Any
lazy val trees: Program.trees.type

Definition Classes
SMTLIBTarget → SMTLIBParser
def unsupported(t: Tree, str: String): Nothing

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

Attributes
protected
Definition Classes
AbstractSolver
val variables: IncrementalBijection[ast.Trees.Variable, SSymbol]

Attributes
protected
Definition Classes
SMTLIBTarget
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 smtlib

trait SMTLIBSolver extends Solver with SMTLIBTarget with SMTLIBDebugger

Type Members

class ADTManager extends IncrementalStateWrapper

trait AbstractContext extends AnyRef

type Assumptions = Set[Trees]

case class Constructor(sym: Identifier, tpe: ast.Trees.Type, fields: Seq[(Identifier, ast.Trees.Type)]) extends ast.Trees.Printable with Product with Serializable

class Context extends AbstractContext

case class DataType(sym: Identifier, cases: Seq[Constructor]) extends ast.Trees.Printable with Product with Serializable

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

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

type Trees = ast.Trees.Expr

Abstract Value Members

abstract val interpreter: Interpreter

abstract def interpreterOpts: Seq[String]

abstract val options: Options

abstract val program: Program

implicit abstract val semantics: Program.Semantics

abstract def targetName: String

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Num

object SimpleSymbol

object SolverUnsupportedError extends Serializable

val adtManager: ADTManager

final def asInstanceOf[T0]: T0

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

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

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

def clone(): AnyRef

def computeSort(t: ast.Trees.Type): Sort

val constructors: IncrementalBijection[ast.Trees.Type, SSymbol]

def dbg(msg: ⇒ Any): Unit

lazy val debugOut: Option[FileWriter]

implicit val debugSection: DebugSectionSolver.type

def declareDatatypes(datatypes: Seq[(ast.Trees.Type, DataType)]): Unit

def declareFunction(tfd: ast.Trees.TypedFunDef): SSymbol

def declareLambda(tpe: ast.Trees.FunctionType): SSymbol

final def declareSort(t: ast.Trees.Type): Sort

def declareStructuralSort(t: ast.Trees.Type): Sort

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

def emit(cmd: SExpr, rawOut: Boolean = false): SExpr

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def extractResponse(config: Configuration, res: SExpr): Response[Model, Assumptions]

def finalize(): Unit

def free(): Unit

def freshSym(name: String): SSymbol

def freshSym(id: Identifier): SSymbol

def fromSMT(t: Term, otpe: Option[ast.Trees.Type] = None)(implicit context: Context): ast.Trees.Expr

def fromSMT(sort: Sort)(implicit context: Context): ast.Trees.Type

final def fromSMT(pair: (Term, ast.Trees.Type))(implicit context: Context): ast.Trees.Expr

final def fromSMT(term: Term, tpe: ast.Trees.Type)(implicit context: Context): ast.Trees.Expr

def fromSMT(sv: SortedVar)(implicit context: Context): ast.Trees.ValDef

final def fromSMTUnifyType(t1: Term, t2: Term, otpe: Option[ast.Trees.Type])(recons: (ast.Trees.Expr, ast.Trees.Expr) ⇒ ast.Trees.Expr)(implicit context: Context): ast.Trees.Expr

val functions: IncrementalBijection[ast.Trees.TypedFunDef, SSymbol]

final def getClass(): Class[_]

def getResultSolver: Option[Solver]

def hashCode(): Int

def id2sym(id: Identifier): SSymbol

def interrupt(): Unit

final def isInstanceOf[T0]: Boolean

val lambdas: IncrementalBijection[ast.Trees.FunctionType, SSymbol]

def name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def parseSuccess(): Unit

def pop(): Unit

def push(): Unit

def quantifiedTerm(quantifier: (SortedVar, Seq[SortedVar], Term) ⇒ Term, body: ast.Trees.Expr)(implicit bindings: Map[Identifier, Term]): Term

def quantifiedTerm(quantifier: (SortedVar, Seq[SortedVar], Term) ⇒ Term, vars: Seq[ast.Trees.ValDef], body: ast.Trees.Expr)(implicit bindings: Map[Identifier, Term]): Term

lazy val reporter: Reporter

def reset(): Unit

val selectors: IncrementalBijection[(ast.Trees.Type, Int), SSymbol]

def sortToSMT(s: Sort): SExpr

val sorts: IncrementalBijection[ast.Trees.Type, Sort]