Modifier and Type | Method and Description |
---|---|
Term |
SearchNode.getPatternTerm() |
Term |
ScriptApi.toTerm(java.lang.String term,
VariableAssignments assignments) |
Modifier and Type | Method and Description |
---|---|
abstract Term |
AbstractDomainElement.getDefiningAxiom(Term varOrConst,
Services services)
Return the defining axiom, instantiated for a given Term (skolem constant
or logical / program variable).
|
static Term |
AbstractDomainLattice.getSideConditionForAxiom(SymbolicExecutionState state,
Term term,
AbstractDomainElement elem,
Services services)
Returns a side condition which has to hold if elem is a correct
abstraction for term.
|
Modifier and Type | Method and Description |
---|---|
AbstractDomainElement |
AbstractDomainLattice.abstractFrom(SymbolicExecutionState state,
Term term,
Services services)
Abstracts from a given element of the concrete domain by returning a
suitable abstract element.
|
abstract Term |
AbstractDomainElement.getDefiningAxiom(Term varOrConst,
Services services)
Return the defining axiom, instantiated for a given Term (skolem constant
or logical / program variable).
|
static Term |
AbstractDomainLattice.getSideConditionForAxiom(SymbolicExecutionState state,
Term term,
AbstractDomainElement elem,
Services services)
Returns a side condition which has to hold if elem is a correct
abstraction for term.
|
Modifier and Type | Method and Description |
---|---|
Term |
Top.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
False.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
True.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
Bottom.getDefiningAxiom(Term varOrConst,
Services services) |
Modifier and Type | Method and Description |
---|---|
Term |
Top.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
False.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
True.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
Bottom.getDefiningAxiom(Term varOrConst,
Services services) |
Modifier and Type | Method and Description |
---|---|
abstract Term |
AbstractionPredicate.apply(Term t) |
protected Term |
DisjunctivePredicateAbstractionDomainElement.combinePredicates(Term preds,
Term newPred,
Services services) |
protected abstract Term |
AbstractPredicateAbstractionDomainElement.combinePredicates(Term preds,
Term newPred,
Services services)
Combines the given predicate terms (classically using AND or OR).
|
protected Term |
ConjunctivePredicateAbstractionDomainElement.combinePredicates(Term preds,
Term newPred,
Services services) |
protected Term |
SimplePredicateAbstractionDomainElement.combinePredicates(Term preds,
Term newPred,
Services services) |
Term |
AbstractPredicateAbstractionDomainElement.getDefiningAxiom(Term varOrConst,
Services services) |
Modifier and Type | Method and Description |
---|---|
Pair<LocationVariable,Term> |
AbstractionPredicate.getPredicateFormWithPlaceholder() |
Modifier and Type | Method and Description |
---|---|
abstract Term |
AbstractionPredicate.apply(Term t) |
protected Term |
DisjunctivePredicateAbstractionDomainElement.combinePredicates(Term preds,
Term newPred,
Services services) |
protected abstract Term |
AbstractPredicateAbstractionDomainElement.combinePredicates(Term preds,
Term newPred,
Services services)
Combines the given predicate terms (classically using AND or OR).
|
protected Term |
ConjunctivePredicateAbstractionDomainElement.combinePredicates(Term preds,
Term newPred,
Services services) |
protected Term |
SimplePredicateAbstractionDomainElement.combinePredicates(Term preds,
Term newPred,
Services services) |
static AbstractionPredicate |
AbstractionPredicate.create(Term predicate,
LocationVariable placeholder,
Services services)
Creates a new
AbstractionPredicate for the given predicate. |
Term |
AbstractPredicateAbstractionDomainElement.getDefiningAxiom(Term varOrConst,
Services services) |
Modifier and Type | Method and Description |
---|---|
static AbstractionPredicate |
AbstractionPredicate.create(Sort argSort,
java.util.function.Function<Term,Term> mapping,
Services services)
Creates a new
AbstractionPredicate with the given name and
mapping. |
static AbstractionPredicate |
AbstractionPredicate.create(Sort argSort,
java.util.function.Function<Term,Term> mapping,
Services services)
Creates a new
AbstractionPredicate with the given name and
mapping. |
Modifier and Type | Method and Description |
---|---|
Term |
Top.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
Geq.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
Neg.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
Zero.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
Pos.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
Bottom.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
Leq.getDefiningAxiom(Term varOrConst,
Services services) |
Modifier and Type | Method and Description |
---|---|
Term |
Top.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
Geq.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
Neg.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
Zero.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
Pos.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
Bottom.getDefiningAxiom(Term varOrConst,
Services services) |
Term |
Leq.getDefiningAxiom(Term varOrConst,
Services services) |
Modifier and Type | Method and Description |
---|---|
Term |
TacletAssumesModel.ifFma() |
Term |
TacletInstantiationModel.ifFma(int i) |
Term |
TacletAssumesModel.parseFormula(java.lang.String s)
parses and returns the term encoded as string 's'
|
Constructor and Description |
---|
TacletAssumesModel(Term ifFma,
ImmutableList<IfFormulaInstantiation> candidates,
TacletApp app,
Goal goal,
Services services,
NamespaceSet nss,
AbbrevMap scm) |
Modifier and Type | Field and Description |
---|---|
Term[] |
DependencyContractCompletion.TermStringWrapper.terms |
Modifier and Type | Method and Description |
---|---|
static Term |
InspectorForDecisionPredicates.translate(Services services,
java.lang.String toBeChecked) |
Modifier and Type | Method and Description |
---|---|
static PosInOccurrence |
DependencyContractCompletion.findCorrespondingStep(java.util.List<PosInOccurrence> steps,
Term[] resultHeaps) |
Constructor and Description |
---|
TermStringWrapper(Term[] terms,
java.lang.String string) |
Modifier and Type | Method and Description |
---|---|
Term |
MergePartnerSelectionDialog.getChosenDistinguishingFormula() |
Modifier and Type | Method and Description |
---|---|
static ProofDifference |
ProofDifference.create(Node left,
Node right,
java.util.function.Function<Term,java.lang.String> printer) |
Modifier and Type | Method and Description |
---|---|
static boolean |
SolverListener.containsModalityOrQuery(Term term)
Checks if the given
Term contains a modality, query, or update. |
void |
SolverListener.ContainsModalityOrQueryVisitor.visit(Term visited)
the entry method for the visitor pattern
|
Modifier and Type | Method and Description |
---|---|
static Term |
InspectorForFormulas.translate(Services services,
java.lang.String toBeChecked) |
Modifier and Type | Method and Description |
---|---|
protected Term |
LoopInvExecutionPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
InfFlowContractPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
BlockExecutionPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
SymbolicExecutionPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
LoopInvExecutionPO.generateMbyAtPreDef(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
InfFlowContractPO.generateMbyAtPreDef(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
BlockExecutionPO.generateMbyAtPreDef(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
SymbolicExecutionPO.generateMbyAtPreDef(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
LoopInvExecutionPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
protected Term |
InfFlowContractPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
protected Term |
BlockExecutionPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
protected Term |
SymbolicExecutionPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
LoopInvExecutionPO.getGuard() |
Term |
InfFlowContractPO.getMbyAtPre() |
Term |
SymbolicExecutionPO.getMbyAtPre() |
protected Term |
LoopInvExecutionPO.getPost(java.util.List<LocationVariable> modHeaps,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable exceptionVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Deprecated.
|
protected Term |
InfFlowContractPO.getPost(java.util.List<LocationVariable> modHeaps,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable exceptionVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Deprecated.
|
protected Term |
BlockExecutionPO.getPost(java.util.List<LocationVariable> modHeaps,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable exceptionVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Deprecated.
|
protected Term |
SymbolicExecutionPO.getPost(java.util.List<LocationVariable> modHeaps,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable exceptionVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Deprecated.
|
protected Term |
LoopInvExecutionPO.getPre(java.util.List<LocationVariable> modHeaps,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Deprecated.
|
protected Term |
InfFlowContractPO.getPre(java.util.List<LocationVariable> modHeaps,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Deprecated.
|
protected Term |
BlockExecutionPO.getPre(java.util.List<LocationVariable> modHeaps,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Deprecated.
|
protected Term |
SymbolicExecutionPO.getPre(java.util.List<LocationVariable> modHeaps,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
java.util.Map<Term,Term> |
IFProofObligationVars.getMapFor(ProofObligationVars vars) |
java.util.Map<Term,Term> |
IFProofObligationVars.getMapFor(ProofObligationVars vars) |
Modifier and Type | Method and Description |
---|---|
void |
InfFlowProofSymbols.add(Term t) |
void |
LoopInvExecutionPO.addIFSymbol(Term t) |
void |
InfFlowPO.addIFSymbol(Term t) |
void |
InfFlowContractPO.addIFSymbol(Term t) |
void |
BlockExecutionPO.addIFSymbol(Term t) |
void |
SymbolicExecutionPO.addIFSymbol(Term t) |
void |
InfFlowProofSymbols.addLabeled(Term t) |
void |
LoopInvExecutionPO.addLabeledIFSymbol(Term t) |
void |
InfFlowPO.addLabeledIFSymbol(Term t) |
void |
InfFlowContractPO.addLabeledIFSymbol(Term t) |
void |
BlockExecutionPO.addLabeledIFSymbol(Term t) |
void |
SymbolicExecutionPO.addLabeledIFSymbol(Term t) |
void |
InfFlowProofSymbols.addLabeledTotalTerm(Term t) |
void |
InfFlowProofSymbols.addTotalTerm(Term t) |
Proof |
AbstractInfFlowPO.createProof(java.lang.String proofName,
Term poTerm,
InitConfig proofConfig) |
InfFlowProof |
AbstractInfFlowPO.createProofObject(java.lang.String proofName,
java.lang.String proofHeader,
Term poTerm,
InitConfig proofConfig) |
protected Term |
LoopInvExecutionPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
protected Term |
InfFlowContractPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
protected Term |
BlockExecutionPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
protected Term |
SymbolicExecutionPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Modifier and Type | Method and Description |
---|---|
protected Term |
LoopInvExecutionPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
LoopInvExecutionPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
InfFlowContractPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
InfFlowContractPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
BlockExecutionPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
BlockExecutionPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
SymbolicExecutionPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
SymbolicExecutionPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
protected Term |
LoopInvExecutionPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
protected Term |
InfFlowContractPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
protected Term |
BlockExecutionPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
protected Term |
SymbolicExecutionPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Constructor and Description |
---|
LoopInvExecutionPO(InitConfig initConfig,
LoopSpecification loopInv,
ProofObligationVars symbExecVars,
Goal initiatingGoal,
ExecutionContext context,
Term guardTerm) |
LoopInvExecutionPO(InitConfig initConfig,
LoopSpecification loopInv,
ProofObligationVars symbExecVars,
Goal initiatingGoal,
ExecutionContext context,
Term guardTerm,
Services services)
To be used only for auxiliary proofs where the services object of
the actual proof has to be used instead of the initial services form
the InitConfig.
|
Modifier and Type | Method and Description |
---|---|
Term |
BasicPOSnippetFactory.create(BasicPOSnippetFactory.Snippet snippet) |
Term |
InfFlowPOSnippetFactory.create(InfFlowPOSnippetFactory.Snippet snippet) |
Term |
BasicLoopInvariantSnippet.produce(de.uka.ilkd.key.informationflow.po.snippet.BasicSnippetData d,
ProofObligationVars poVars) |
Term |
BasicFreeInvSnippet.produce(de.uka.ilkd.key.informationflow.po.snippet.BasicSnippetData d,
ProofObligationVars poVars) |
Term |
BasicLoopExecutionSnippet.produce(de.uka.ilkd.key.informationflow.po.snippet.BasicSnippetData d,
ProofObligationVars poVars) |
Term |
InfFlowLoopInvAppSnippet.produce(de.uka.ilkd.key.informationflow.po.snippet.BasicSnippetData d,
ProofObligationVars poVars1,
ProofObligationVars poVars2) |
Term |
SelfcomposedLoopSnippet.produce(de.uka.ilkd.key.informationflow.po.snippet.BasicSnippetData d,
ProofObligationVars poVars1,
ProofObligationVars poVars2) |
Modifier and Type | Method and Description |
---|---|
static BasicPOSnippetFactory |
POSnippetFactory.getBasicFactory(LoopSpecification invariant,
ProofObligationVars vars,
ExecutionContext context,
Term guardTerm,
Services services) |
static InfFlowPOSnippetFactory |
POSnippetFactory.getInfFlowFactory(LoopSpecification invariant,
ProofObligationVars vars1,
ProofObligationVars vars2,
ExecutionContext context,
Term guardTerm,
Services services) |
Modifier and Type | Method and Description |
---|---|
void |
InfFlowProof.addLabeledTotalTerm(Term p) |
void |
InfFlowProof.addTotalTerm(Term p) |
Constructor and Description |
---|
InfFlowProof(java.lang.String name,
Term problem,
java.lang.String header,
InitConfig initConfig) |
Modifier and Type | Field and Description |
---|---|
Term |
StateVars.exception |
Term |
StateVars.guard |
Term |
StateVars.heap |
Term |
StateVars.mbyAtPre |
Term |
StateVars.result |
Term |
StateVars.self |
Modifier and Type | Field and Description |
---|---|
ImmutableList<Term> |
StateVars.localVars |
ImmutableList<Term> |
StateVars.paddedTermList |
ImmutableList<Term> |
StateVars.termList |
Constructor and Description |
---|
StateVars(Term self,
ImmutableList<Term> localVars,
Term heap) |
StateVars(Term self,
ImmutableList<Term> localVars,
Term result,
Term exception,
Term heap) |
StateVars(Term self,
ImmutableList<Term> localVars,
Term result,
Term exception,
Term heap,
Term mbyAtPre) |
StateVars(Term self,
Term guard,
ImmutableList<Term> localVars,
Term heap) |
StateVars(Term self,
Term guard,
ImmutableList<Term> localVars,
Term result,
Term exception,
Term heap) |
StateVars(Term self,
Term guard,
ImmutableList<Term> localVars,
Term result,
Term exception,
Term heap,
Term mbyAtPre) |
Constructor and Description |
---|
StateVars(Term self,
ImmutableList<Term> localVars,
Term heap) |
StateVars(Term self,
ImmutableList<Term> localVars,
Term result,
Term exception,
Term heap) |
StateVars(Term self,
ImmutableList<Term> localVars,
Term result,
Term exception,
Term heap,
Term mbyAtPre) |
StateVars(Term self,
Term guard,
ImmutableList<Term> localVars,
Term heap) |
StateVars(Term self,
Term guard,
ImmutableList<Term> localVars,
Term result,
Term exception,
Term heap) |
StateVars(Term self,
Term guard,
ImmutableList<Term> localVars,
Term result,
Term exception,
Term heap,
Term mbyAtPre) |
Constructor and Description |
---|
InfFlowContractAppTaclet(Name name,
TacletApplPart applPart,
ImmutableList<TacletGoalTemplate> goalTemplates,
ImmutableList<RuleSet> ruleSets,
TacletAttributes attrs,
Term find,
ImmutableMap<SchemaVariable,TacletPrefix> prefixMap,
int p_applicationRestriction,
ImmutableSet<Choice> choices,
boolean surviveSymbExec,
ImmutableSet<TacletAnnotation> tacletAnnotations) |
InfFlowContractAppTaclet(Name name,
TacletApplPart applPart,
ImmutableList<TacletGoalTemplate> goalTemplates,
ImmutableList<RuleSet> ruleSets,
TacletAttributes attrs,
Term find,
ImmutableMap<SchemaVariable,TacletPrefix> prefixMap,
int p_applicationRestriction,
ImmutableSet<Choice> choices,
ImmutableSet<TacletAnnotation> tacletAnnotations) |
Modifier and Type | Field and Description |
---|---|
static Properties.Property<ImmutableList<Term>> |
InfFlowContractAppTacletExecutor.INF_FLOW_CONTRACT_APPL_PROPERTY
Strategy property which saves the list of formulas which where added
by information flow contract applications.
|
Modifier and Type | Method and Description |
---|---|
void |
LoopInfFlowUnfoldTacletBuilder.setGuard(Term guard) |
void |
InfFlowLoopInvariantTacletBuilder.setGuard(Term guard) |
Modifier and Type | Method and Description |
---|---|
Term |
TypeConverter.convertArrayReference(ArrayReference ar,
ExecutionContext ec) |
Term |
TypeConverter.convertMethodReference(MethodReference mr,
ExecutionContext ec) |
Term |
TypeConverter.convertToLogicElement(ProgramElement pe) |
Term |
TypeConverter.convertToLogicElement(ProgramElement pe,
ExecutionContext ec) |
Term |
TypeConverter.convertVariableReference(VariableReference fr,
ExecutionContext ec) |
Term |
TypeConverter.findThisForSort(Sort s,
ExecutionContext ec) |
Term |
TypeConverter.findThisForSort(Sort s,
Term self,
KeYJavaType context,
boolean exact) |
Term |
TypeConverter.findThisForSortExact(Sort s,
ExecutionContext ec) |
Term |
JavaInfo.getProgramMethodTerm(Term prefix,
java.lang.String methodName,
Term[] args,
java.lang.String className,
boolean traverseHierarchy) |
Term |
JavaInfo.getStaticProgramMethodTerm(java.lang.String methodName,
Term[] args,
java.lang.String className) |
Term |
JavaInfo.getTermFromProgramMethod(IProgramMethod pm,
java.lang.String methodName,
java.lang.String className,
Term[] args,
Term prefix) |
Modifier and Type | Method and Description |
---|---|
Expression |
TypeConverter.convertToProgramElement(Term term)
converts a logical term to an AST node if possible.
|
Term |
TypeConverter.findThisForSort(Sort s,
Term self,
KeYJavaType context,
boolean exact) |
KeYJavaType |
TypeConverter.getKeYJavaType(Term t) |
Term |
JavaInfo.getProgramMethodTerm(Term prefix,
java.lang.String methodName,
Term[] args,
java.lang.String className,
boolean traverseHierarchy) |
Term |
JavaInfo.getProgramMethodTerm(Term prefix,
java.lang.String methodName,
Term[] args,
java.lang.String className,
boolean traverseHierarchy) |
Term |
JavaInfo.getStaticProgramMethodTerm(java.lang.String methodName,
Term[] args,
java.lang.String className) |
Term |
JavaInfo.getTermFromProgramMethod(IProgramMethod pm,
java.lang.String methodName,
java.lang.String className,
Term[] args,
Term prefix) |
Term |
JavaInfo.getTermFromProgramMethod(IProgramMethod pm,
java.lang.String methodName,
java.lang.String className,
Term[] args,
Term prefix) |
Modifier and Type | Method and Description |
---|---|
Term |
DLEmbeddedExpression.makeTerm(LocationVariable heap,
Term[] subs,
Services services) |
Modifier and Type | Method and Description |
---|---|
Term |
DLEmbeddedExpression.makeTerm(LocationVariable heap,
Term[] subs,
Services services) |
Modifier and Type | Method and Description |
---|---|
Term |
BooleanLDT.getFalseTerm() |
Term |
BooleanLDT.getTrueTerm() |
Term |
IntegerLDT.one() |
Term |
DoubleLDT.translateLiteral(Literal lit,
Services services) |
Term |
CharListLDT.translateLiteral(Literal lit,
Services services) |
Term |
FreeLDT.translateLiteral(Literal lit,
Services services) |
Term |
MapLDT.translateLiteral(Literal lit,
Services services) |
Term |
RealLDT.translateLiteral(Literal lit,
Services services) |
Term |
BooleanLDT.translateLiteral(Literal lit,
Services services) |
Term |
PermissionLDT.translateLiteral(Literal lit,
Services services) |
Term |
LocSetLDT.translateLiteral(Literal lit,
Services services) |
Term |
IntegerLDT.translateLiteral(Literal lit,
Services services) |
Term |
HeapLDT.translateLiteral(Literal lit,
Services services) |
Term |
FloatLDT.translateLiteral(Literal lit,
Services services) |
Term |
SeqLDT.translateLiteral(Literal lit,
Services services) |
abstract Term |
LDT.translateLiteral(Literal lit,
Services services)
translates a given literal to its logic counterpart
|
Term |
IntegerLDT.zero() |
Modifier and Type | Method and Description |
---|---|
Type |
DoubleLDT.getType(Term t) |
Type |
CharListLDT.getType(Term t) |
Type |
FreeLDT.getType(Term t) |
Type |
MapLDT.getType(Term t) |
Type |
RealLDT.getType(Term t) |
Type |
BooleanLDT.getType(Term t) |
Type |
PermissionLDT.getType(Term t) |
Type |
LocSetLDT.getType(Term t) |
Type |
IntegerLDT.getType(Term t) |
Type |
HeapLDT.getType(Term t) |
Type |
FloatLDT.getType(Term t) |
Type |
SeqLDT.getType(Term t) |
abstract Type |
LDT.getType(Term t) |
boolean |
DoubleLDT.isResponsible(Operator op,
Term[] subs,
Services services,
ExecutionContext ec) |
boolean |
CharListLDT.isResponsible(Operator op,
Term[] subs,
Services services,
ExecutionContext ec) |
boolean |
FreeLDT.isResponsible(Operator op,
Term[] subs,
Services services,
ExecutionContext ec) |
boolean |
MapLDT.isResponsible(Operator op,
Term[] subs,
Services services,
ExecutionContext ec) |
boolean |
RealLDT.isResponsible(Operator op,
Term[] subs,
Services services,
ExecutionContext ec) |
boolean |
BooleanLDT.isResponsible(Operator op,
Term[] subs,
Services services,
ExecutionContext ec) |
boolean |
PermissionLDT.isResponsible(Operator op,
Term[] subs,
Services services,
ExecutionContext ec) |
boolean |
LocSetLDT.isResponsible(Operator op,
Term[] subs,
Services services,
ExecutionContext ec) |
boolean |
IntegerLDT.isResponsible(Operator op,
Term[] subs,
Services services,
ExecutionContext ec) |
boolean |
HeapLDT.isResponsible(Operator op,
Term[] subs,
Services services,
ExecutionContext ec) |
boolean |
FloatLDT.isResponsible(Operator op,
Term[] subs,
Services services,
ExecutionContext ec) |
boolean |
SeqLDT.isResponsible(Operator op,
Term[] subs,
Services services,
ExecutionContext ec) |
abstract boolean |
LDT.isResponsible(Operator op,
Term[] subs,
Services services,
ExecutionContext ec)
returns true if the LDT offers an operation for the given java
operator and the logic subterms
|
boolean |
DoubleLDT.isResponsible(Operator op,
Term sub,
TermServices services,
ExecutionContext ec) |
boolean |
CharListLDT.isResponsible(Operator op,
Term sub,
TermServices services,
ExecutionContext ec) |
boolean |
FreeLDT.isResponsible(Operator op,
Term sub,
TermServices services,
ExecutionContext ec) |
boolean |
MapLDT.isResponsible(Operator op,
Term sub,
TermServices services,
ExecutionContext ec) |
boolean |
RealLDT.isResponsible(Operator op,
Term sub,
TermServices services,
ExecutionContext ec) |
boolean |
BooleanLDT.isResponsible(Operator op,
Term sub,
TermServices services,
ExecutionContext ec) |
boolean |
PermissionLDT.isResponsible(Operator op,
Term sub,
TermServices services,
ExecutionContext ec) |
boolean |
LocSetLDT.isResponsible(Operator op,
Term sub,
TermServices services,
ExecutionContext ec) |
boolean |
IntegerLDT.isResponsible(Operator op,
Term sub,
TermServices services,
ExecutionContext ec) |
boolean |
HeapLDT.isResponsible(Operator op,
Term sub,
TermServices services,
ExecutionContext ec) |
boolean |
FloatLDT.isResponsible(Operator op,
Term sub,
TermServices services,
ExecutionContext ec) |
boolean |
SeqLDT.isResponsible(Operator op,
Term sub,
TermServices services,
ExecutionContext ec) |
abstract boolean |
LDT.isResponsible(Operator op,
Term sub,
TermServices services,
ExecutionContext ec)
returns true if the LDT offers an operation for the given
unary java operator and the logic subterms
|
boolean |
DoubleLDT.isResponsible(Operator op,
Term left,
Term right,
Services services,
ExecutionContext ec) |
boolean |
CharListLDT.isResponsible(Operator op,
Term left,
Term right,
Services services,
ExecutionContext ec) |
boolean |
FreeLDT.isResponsible(Operator op,
Term left,
Term right,
Services services,
ExecutionContext ec) |
boolean |
MapLDT.isResponsible(Operator op,
Term left,
Term right,
Services services,
ExecutionContext ec) |
boolean |
RealLDT.isResponsible(Operator op,
Term left,
Term right,
Services services,
ExecutionContext ec) |
boolean |
BooleanLDT.isResponsible(Operator op,
Term left,
Term right,
Services services,
ExecutionContext ec) |
boolean |
PermissionLDT.isResponsible(Operator op,
Term left,
Term right,
Services services,
ExecutionContext ec) |
boolean |
LocSetLDT.isResponsible(Operator op,
Term left,
Term right,
Services services,
ExecutionContext ec) |
boolean |
IntegerLDT.isResponsible(Operator op,
Term left,
Term right,
Services services,
ExecutionContext ec) |
boolean |
HeapLDT.isResponsible(Operator op,
Term left,
Term right,
Services services,
ExecutionContext ec) |
boolean |
FloatLDT.isResponsible(Operator op,
Term left,
Term right,
Services services,
ExecutionContext ec) |
boolean |
SeqLDT.isResponsible(Operator op,
Term left,
Term right,
Services services,
ExecutionContext ec) |
abstract boolean |
LDT.isResponsible(Operator op,
Term left,
Term right,
Services services,
ExecutionContext ec)
returns true if the LDT offers an operation for the given
binary java operator and the logic subterms
|
Expression |
DoubleLDT.translateTerm(Term t,
ExtList children,
Services services) |
Expression |
CharListLDT.translateTerm(Term t,
ExtList children,
Services services) |
Expression |
FreeLDT.translateTerm(Term t,
ExtList children,
Services services) |
Expression |
MapLDT.translateTerm(Term t,
ExtList children,
Services services) |
Expression |
RealLDT.translateTerm(Term t,
ExtList children,
Services services) |
Expression |
BooleanLDT.translateTerm(Term t,
ExtList children,
Services services) |
Expression |
PermissionLDT.translateTerm(Term t,
ExtList children,
Services services) |
Expression |
LocSetLDT.translateTerm(Term t,
ExtList children,
Services services) |
Expression |
IntegerLDT.translateTerm(Term t,
ExtList children,
Services services) |
Expression |
HeapLDT.translateTerm(Term t,
ExtList children,
Services services) |
Expression |
FloatLDT.translateTerm(Term t,
ExtList children,
Services services) |
Expression |
SeqLDT.translateTerm(Term t,
ExtList children,
Services services) |
abstract Expression |
LDT.translateTerm(Term t,
ExtList children,
Services services)
Is called whenever
hasLiteralFunction() returns true. |
Modifier and Type | Class and Description |
---|---|
class |
TermImpl
The currently only class implementing the Term interface.
|
Modifier and Type | Field and Description |
---|---|
protected Term |
ClashFreeSubst.s |
Modifier and Type | Method and Description |
---|---|
Term |
TermBuilder.acc(Term h,
Term s,
Term o1,
Term o2) |
Term |
TermBuilder.add(Term t1,
Term t2) |
Term |
TermBuilder.addLabel(Term term,
ImmutableArray<TermLabel> labels)
Adds labels to a term, removing any existing labels of the same type.
|
Term |
TermBuilder.addLabel(Term term,
TermLabel label)
Adds a label to a term, removing any existing labels of the same type.
|
Term |
TermBuilder.addLabelToAllSubs(Term term,
ImmutableArray<TermLabel> labels)
Applies the labels to the term and almost every (direct or indirect) sub-term recursively.
|
Term |
TermBuilder.addLabelToAllSubs(Term term,
TermLabel label)
Applies the label to the term and almost every (direct or indirect) sub-term recursively.
|
Term |
TermBuilder.all(java.lang.Iterable<QuantifiableVariable> qvs,
Term t) |
Term |
TermBuilder.all(QuantifiableVariable qv,
Term t) |
Term |
TermBuilder.allClose(Term t) |
Term |
TermBuilder.allFields(Term o) |
Term |
TermBuilder.allLocs() |
Term |
TermBuilder.allObjects(Term f) |
Term |
TermBuilder.and(java.lang.Iterable<Term> subTerms) |
Term |
TermBuilder.and(Term... subTerms) |
Term |
TermBuilder.and(Term t1,
Term t2) |
Term |
TermBuilder.andPreserveLabels(java.lang.Iterable<Term> subTerms)
Similar behavior as
TermBuilder.and(Iterable) but simplifications are not
performed if TermLabel s would be lost. |
Term |
TermBuilder.andPreserveLabels(Term t1,
Term t2)
Similar behavior as
TermBuilder.and(Term, Term) but simplifications are not
performed if TermLabel s would be lost. |
Term |
TermBuilder.andSC(java.lang.Iterable<Term> subTerms) |
Term |
TermBuilder.andSC(Term... subTerms) |
Term |
TermBuilder.andSC(Term t1,
Term t2) |
Term |
TermBuilder.anon(Term h1,
Term s,
Term h2) |
Term |
TermBuilder.anonUpd(LocationVariable heap,
Term mod,
Term anonHeap) |
Term |
ClashFreeSubst.apply(Term t)
substitute
s for v in t ,
avoiding collisions by replacing bound variables in
t if necessary. |
Term |
WaryClashFreeSubst.apply(Term t)
substitute
s for v in t ,
avoiding collisions by replacing bound variables in
t if necessary. |
Term |
TermBuilder.apply(Term update,
Term target) |
Term |
TermBuilder.apply(Term update,
Term target,
ImmutableArray<TermLabel> labels) |
protected Term |
ClashFreeSubst.apply1(Term t)
substitute
s for v in
t , avoiding collisions by replacing bound
variables in t if necessary. |
protected Term |
WaryClashFreeSubst.apply1(Term t)
substitute
s for v in
t , avoiding collisions by replacing bound
variables in t if necessary. |
Term |
TermBuilder.applyElementary(Term heap,
Term target) |
Term |
TermBuilder.applyElementary(Term loc,
Term value,
Term target) |
Term |
TermBuilder.applyParallel(ImmutableList<Term> updates,
Term target) |
Term |
TermBuilder.applyParallel(Term[] updates,
Term target) |
Term |
TermBuilder.applyParallel(Term[] lhss,
Term[] values,
Term target) |
Term |
TermBuilder.applySequential(ImmutableList<Term> updates,
Term target) |
Term |
TermBuilder.applySequential(Term[] updates,
Term target) |
Term |
TermBuilder.applyUpdatePairsSequential(ImmutableList<SVInstantiations.UpdateLabelPair> updates,
Term target) |
Term |
TermBuilder.arr(Term idx) |
Term |
TermBuilder.arrayRange(Term o,
Term lower,
Term upper) |
Term |
TermBuilder.arrayStore(Term o,
Term i,
Term v) |
Term |
TermBuilder.box(JavaBlock jb,
Term t) |
Term |
TermBuilder.bprod(QuantifiableVariable qv,
Term a,
Term b,
Term t,
Services services)
Constructs a bounded product comprehension expression.
|
Term |
TermBuilder.bsum(QuantifiableVariable qv,
Term a,
Term b,
Term t) |
Term |
TermBuilder.cast(Sort s,
Term t) |
Term |
TermImpl.checked()
Checks whether the Term is valid on the top level.
|
Term |
TermBuilder.classErroneous(Sort classSort) |
Term |
TermBuilder.classInitializationInProgress(Sort classSort) |
Term |
TermBuilder.classInitialized(Sort classSort) |
Term |
TermBuilder.classPrepared(Sort classSort) |
Term |
TermBuilder.convertToBoolean(Term a)
For a formula a, convert it to a boolean expression.
|
Term |
TermBuilder.convertToFormula(Term a)
If a is a boolean literal, the method returns the literal as a Formula.
|
Term |
TermBuilder.create(Term h,
Term o) |
Term |
TermBuilder.created(Term o) |
Term |
TermBuilder.created(Term h,
Term o) |
Term |
TermBuilder.createdInHeap(Term s,
Term h) |
Term |
TermBuilder.createdLocs() |
Term |
TermFactory.createTerm(Operator op,
ImmutableArray<Term> subs,
ImmutableArray<QuantifiableVariable> boundVars,
JavaBlock javaBlock) |
Term |
TermFactory.createTerm(Operator op,
ImmutableArray<Term> subs,
ImmutableArray<QuantifiableVariable> boundVars,
JavaBlock javaBlock,
ImmutableArray<TermLabel> labels)
Master method for term creation.
|
Term |
TermFactory.createTerm(Operator op,
ImmutableArray<TermLabel> labels) |
Term |
TermFactory.createTerm(Operator junctor,
java.util.List<Term> terms)
Reduce the given list of terms into a one term by using the operator.
|
Term |
TermFactory.createTerm(Operator op,
Term... subs) |
Term |
TermFactory.createTerm(Operator op,
Term[] subs,
ImmutableArray<QuantifiableVariable> boundVars,
JavaBlock javaBlock) |
Term |
TermFactory.createTerm(Operator op,
Term[] subs,
ImmutableArray<QuantifiableVariable> boundVars,
JavaBlock javaBlock,
ImmutableArray<TermLabel> labels) |
Term |
TermFactory.createTerm(Operator op,
Term[] subs,
ImmutableArray<QuantifiableVariable> boundVars,
JavaBlock javaBlock,
TermLabel label) |
Term |
TermFactory.createTerm(Operator op,
Term[] subs,
ImmutableArray<TermLabel> labels) |
Term |
TermFactory.createTerm(Operator op,
Term[] subs,
TermLabel label) |
Term |
TermFactory.createTerm(Operator op,
Term sub,
ImmutableArray<TermLabel> labels) |
Term |
TermFactory.createTerm(Operator op,
Term sub1,
Term sub2,
ImmutableArray<TermLabel> labels) |
Term |
TermBuilder.cTerm(java.lang.String numberString) |
Term |
TermBuilder.deepNonNull(Term o,
Term d)
The "deep non null" predicate arising from JML non_null types.
|
Term |
TermBuilder.dia(JavaBlock jb,
Term t) |
Term |
TermBuilder.disjoint(Term s1,
Term s2) |
Term |
TermBuilder.dot(Sort asSort,
Term o,
Function f) |
Term |
TermBuilder.dot(Sort asSort,
Term o,
LocationVariable field) |
Term |
TermBuilder.dot(Sort asSort,
Term o,
Term f) |
Term |
TermBuilder.dotArr(Term ref,
Term idx) |
Term |
TermBuilder.dotLength(Term a) |
Term |
TermBuilder.elementary(Term lhs,
Term rhs) |
Term |
TermBuilder.elementary(UpdateableOperator lhs,
Term rhs) |
Term |
TermBuilder.elementOf(Term o,
Term f,
Term s) |
Term |
TermBuilder.empty() |
Term |
TermBuilder.equals(Term t1,
Term t2)
Creates a term with the correct equality symbol for the sorts involved
|
Term |
TermBuilder.ex(java.lang.Iterable<QuantifiableVariable> qvs,
Term t) |
Term |
TermBuilder.ex(QuantifiableVariable qv,
Term t) |
Term |
TermBuilder.exactInstance(Sort s,
Term t) |
Term |
TermBuilder.FALSE() |
Term |
TermBuilder.ff() |
Term |
TermBuilder.fieldStore(TermServices services,
Term o,
Function f,
Term v) |
Term |
TermBuilder.forallHeaps(Services services,
Term t) |
Term |
SequentFormula.formula() |
Term |
TermBuilder.frame(Term heapTerm,
java.util.Map<Term,Term> normalToAtPre,
Term mod) |
Term |
TermBuilder.frameStrictlyEmpty(Term heapTerm,
java.util.Map<Term,Term> normalToAtPre)
Returns the framing condition that the resulting heap is identical (i.e.
|
Term |
TermBuilder.freshLocs(Term h) |
Term |
TermBuilder.func(Function f) |
Term |
TermBuilder.func(Function f,
Term... s) |
Term |
TermBuilder.func(Function f,
Term s) |
Term |
TermBuilder.func(Function f,
Term[] s,
ImmutableArray<QuantifiableVariable> boundVars) |
Term |
TermBuilder.func(Function f,
Term s1,
Term s2) |
Term |
TermBuilder.func(IObserverFunction f,
Term... s) |
Term |
TermBuilder.geq(Term t1,
Term t2) |
Term |
TermBuilder.getBaseHeap() |
protected Term |
ClashFreeSubst.getSubstitutedTerm() |
Term |
PIOPathIterator.getSubTerm() |
Term |
PosInTerm.getSubTerm(Term t)
navigate to the subterm described by this position and return it
if the described position does not exist in the term an
IndexOutOfBoundsException
is thrown |
static Term |
TermBuilder.goBelowUpdates(Term term)
Removes leading updates from the passed term.
|
Term |
TermBuilder.gt(Term t1,
Term t2) |
Term |
TermBuilder.ife(Term cond,
Term _then,
Term _else) |
Term |
TermBuilder.ifEx(ImmutableList<QuantifiableVariable> qvs,
Term cond,
Term _then,
Term _else)
Construct a term with the \ifEx operator.
|
Term |
TermBuilder.ifEx(QuantifiableVariable qv,
Term cond,
Term _then,
Term _else)
Construct a term with the \ifEx operator.
|
Term |
TermBuilder.imp(Term t1,
Term t2) |
Term |
TermBuilder.imp(Term t1,
Term t2,
ImmutableArray<TermLabel> labels) |
Term |
TermBuilder.impPreserveLabels(Term t1,
Term t2)
Similar behavior as
TermBuilder.imp(Term, Term) but simplifications are not
performed if TermLabel s would be lost. |
Term |
TermBuilder.inByte(Term var) |
Term |
TermBuilder.inChar(Term var) |
Term |
TermBuilder.index() |
Term |
TermBuilder.indexOf(Term s,
Term x)
Function representing the least index of an element x in a sequence s (or
underspecified)
|
Term |
TermBuilder.infiniteUnion(QuantifiableVariable[] qvs,
Term s) |
Term |
TermBuilder.infiniteUnion(QuantifiableVariable[] qvs,
Term guard,
Term s) |
Term |
TermBuilder.inInt(Term var) |
Term |
TermBuilder.initialized(Term o) |
Term |
TermBuilder.inLong(Term var) |
Term |
TermBuilder.inShort(Term var) |
Term |
TermBuilder.instance(Sort s,
Term t) |
Term |
TermBuilder.intersect(java.lang.Iterable<Term> subTerms) |
Term |
TermBuilder.intersect(Term... subTerms) |
Term |
TermBuilder.intersect(Term s1,
Term s2) |
Term |
TermBuilder.inv(Term o) |
Term |
TermBuilder.inv(Term[] h,
Term o) |
Term |
TermBuilder.label(Term term,
ImmutableArray<TermLabel> labels)
Applies labels to a term, removing any existing labels.
|
Term |
TermBuilder.label(Term term,
TermLabel label)
Applies a label to a term, removing any existing labels.
|
Term |
TermBuilder.leq(Term t1,
Term t2) |
Term |
TermBuilder.lt(Term t1,
Term t2) |
Term |
TermBuilder.max(ImmutableList<? extends QuantifiableVariable> qvs,
Term range,
Term t,
TermServices services)
minimum operator
|
Term |
TermBuilder.measuredBy(Term mby) |
Term |
TermBuilder.measuredByCheck(Term mby) |
Term |
TermBuilder.measuredByEmpty() |
Term |
TermBuilder.min(ImmutableList<? extends QuantifiableVariable> qvs,
Term range,
Term t,
TermServices services)
minimum operator
|
Term |
TermBuilder.not(Term t) |
Term |
TermBuilder.notPreserveLabels(Term t)
Similar behavior as
TermBuilder.not(Term) but simplifications are not
performed if TermLabel s would be lost. |
Term |
TermBuilder.NULL() |
Term |
TermBuilder.one() |
Term |
TermBuilder.open(Term formula)
Removes universal quantifiers from a formula.
|
Term |
TermBuilder.or(java.lang.Iterable<Term> subTerms) |
Term |
TermBuilder.or(Term... subTerms) |
Term |
TermBuilder.or(Term t1,
Term t2) |
Term |
TermBuilder.orPreserveLabels(java.lang.Iterable<Term> subTerms)
Similar behavior as
TermBuilder.or(Iterable) but simplifications are not
performed if TermLabel s would be lost. |
Term |
TermBuilder.orPreserveLabels(Term t1,
Term t2)
Similar behavior as
TermBuilder.or(Term, Term) but simplifications are not
performed if TermLabel s would be lost. |
Term |
TermBuilder.orSC(java.lang.Iterable<Term> subTerms) |
Term |
TermBuilder.orSC(Term... subTerms) |
Term |
TermBuilder.orSC(Term t1,
Term t2) |
Term |
TermBuilder.pair(Term first,
Term second) |
Term |
TermBuilder.parallel(ImmutableList<Term> updates) |
Term |
TermBuilder.parallel(java.lang.Iterable<Term> lhss,
java.lang.Iterable<Term> values) |
Term |
TermBuilder.parallel(Term... updates) |
Term |
TermBuilder.parallel(Term[] lhss,
Term[] values) |
Term |
TermBuilder.parallel(Term u1,
Term u2) |
Term |
TermBuilder.parseTerm(java.lang.String s)
Parses the given string that represents the term (or createTerm) using
the service's namespaces.
|
Term |
TermBuilder.parseTerm(java.lang.String s,
NamespaceSet namespaces)
Parses the given string that represents the term (or createTerm) using
the provided namespaces.
|
Term |
TermBuilder.permissionsFor(LocationVariable permHeap,
LocationVariable regularHeap) |
Term |
TermBuilder.permissionsFor(Term permHeap,
Term regularHeap) |
Term |
TermBuilder.prec(Term mby,
Term mbyAtPre) |
Term |
TermBuilder.prod(ImmutableList<QuantifiableVariable> qvs,
Term range,
Term t,
TermServices services)
General (unbounded) product
|
Term |
TermBuilder.prog(Modality mod,
JavaBlock jb,
Term t) |
Term |
TermBuilder.prog(Modality mod,
JavaBlock jb,
Term t,
ImmutableArray<TermLabel> labels) |
Term |
TermBuilder.reach(Term h,
Term s,
Term o1,
Term o2,
Term n) |
Term |
TermBuilder.reachableValue(ProgramVariable pv) |
Term |
TermBuilder.reachableValue(Term t,
KeYJavaType kjt) |
Term |
TermBuilder.reachableValue(Term h,
Term t,
KeYJavaType kjt) |
Term[] |
BoundVariableTools.renameVariables(Term[] originalTerms,
ImmutableArray<QuantifiableVariable> oldBoundVars,
ImmutableArray<QuantifiableVariable> newBoundVars,
TermServices services) |
Term |
BoundVariableTools.renameVariables(Term originalTerm,
ImmutableArray<QuantifiableVariable> oldBoundVars,
ImmutableArray<QuantifiableVariable> newBoundVars,
TermServices services)
Compare the arrays
oldBoundVars and
newBoundVars component-wise, and in case of differences
substitute variables from the former array with the ones of the latter
array (in originalTerm ) |
Term |
TermBuilder.replace(Term term,
PosInTerm pos,
Term replacement)
Replaces a child term by another one.
|
static Term |
GenericTermReplacer.replace(Term t,
java.util.function.Predicate<Term> filter,
java.util.function.Function<Term,Term> replacer,
Services services) |
Term |
TermBuilder.select(Sort asSort,
Term h,
Term o,
LocationVariable field)
Get the select expression for a location variabe representing the field.
|
Term |
TermBuilder.select(Sort asSort,
Term h,
Term o,
Term f) |
Term |
TermBuilder.seq(ImmutableList<Term> terms) |
Term |
TermBuilder.seq(Term... terms) |
Term |
TermBuilder.seqConcat(Term s,
Term s2) |
Term |
TermBuilder.seqDef(QuantifiableVariable qv,
Term a,
Term b,
Term t) |
Term |
TermBuilder.seqEmpty() |
Term |
TermBuilder.seqGet(Sort asSort,
Term s,
Term idx) |
Term |
TermBuilder.seqLen(Term s) |
Term |
TermBuilder.seqReverse(Term s) |
Term |
TermBuilder.seqSingleton(Term x) |
Term |
TermBuilder.seqSub(Term s,
Term from,
Term to) |
Term |
TermBuilder.sequential(ImmutableList<Term> updates) |
Term |
TermBuilder.sequential(Term[] updates) |
Term |
TermBuilder.sequential(Term u1,
Term u2) |
Term |
TermBuilder.setComprehension(QuantifiableVariable[] qvs,
Term o,
Term f) |
Term |
TermBuilder.setComprehension(QuantifiableVariable[] qvs,
Term guard,
Term o,
Term f) |
Term |
TermBuilder.setMinus(Term s1,
Term s2) |
Term |
TermBuilder.shortcut(Term term) |
Term |
TermBuilder.singleton(Term o,
Term f) |
Term |
TermBuilder.skip() |
Term |
TermBuilder.staticDot(Sort asSort,
Function f) |
Term |
TermBuilder.staticDot(Sort asSort,
Term f) |
Term |
TermBuilder.staticFieldStore(Function f,
Term v) |
Term |
TermBuilder.staticInv(KeYJavaType t) |
Term |
TermBuilder.staticInv(Term[] h,
KeYJavaType t) |
Term |
TermBuilder.store(Term h,
Term o,
Term f,
Term v) |
Term |
TermBuilder.strictlyNothing()
This value is only used as a marker for "\strictly_nothing" in JML.
|
Term |
TermImpl.sub(int nr) |
Term |
Term.sub(int n)
The
n -th direct subterm. |
Term |
TermBuilder.subset(Term s1,
Term s2) |
Term |
TermBuilder.subst(QuantifiableVariable substVar,
Term substTerm,
Term origTerm) |
Term |
TermBuilder.subst(SubstOp op,
QuantifiableVariable substVar,
Term substTerm,
Term origTerm)
Creates a substitution term
|
Term |
PosInOccurrence.subTerm()
returns the subterm this object points to
|
Term |
TermBuilder.sum(ImmutableList<QuantifiableVariable> qvs,
Term range,
Term t)
General (unbounded) sum
|
Term |
TermBuilder.TRUE() |
Term |
TermBuilder.tt() |
Term |
TermBuilder.union(java.lang.Iterable<Term> subTerms) |
Term |
TermBuilder.union(Term... subTerms) |
Term |
TermBuilder.union(Term s1,
Term s2) |
Term |
TermBuilder.unlabel(Term term) |
Term |
TermBuilder.unlabelRecursive(Term term) |
Term |
TermBuilder.values() |
Term |
TermBuilder.var(LogicVariable v) |
Term |
TermBuilder.var(ParsableVariable v) |
Term |
TermBuilder.var(ProgramVariable v) |
Term |
TermBuilder.var(SchemaVariable v) |
Term |
TermBuilder.wd(Term t) |
Term[] |
TermBuilder.wd(Term[] l) |
Term |
TermBuilder.wellFormed(LocationVariable heap) |
Term |
TermBuilder.wellFormed(Term heap) |
Term |
TermBuilder.zero() |
Term |
TermBuilder.zTerm(long number) |
Term |
TermBuilder.zTerm(java.lang.String numberString) |
Modifier and Type | Method and Description |
---|---|
ImmutableList<Term> |
TermBuilder.apply(Term update,
ImmutableList<Term> targets) |
ImmutableList<Term> |
TermBuilder.applyElementary(Term heap,
java.lang.Iterable<Term> targets) |
static Pair<ImmutableList<Term>,Term> |
TermBuilder.goBelowUpdates2(Term term)
Removes leading updates from the passed term.
|
static Pair<ImmutableList<Term>,Term> |
TermBuilder.goBelowUpdates2(Term term)
Removes leading updates from the passed term.
|
ImmutableArray<Term> |
TermImpl.subs() |
ImmutableArray<Term> |
Term.subs()
The subterms.
|
ImmutableSet<Term> |
TermBuilder.unionToSet(Term s) |
ImmutableList<Term> |
TermBuilder.var(java.lang.Iterable<ProgramVariable> vs) |
ImmutableList<Term> |
TermBuilder.var(ProgramVariable... vs) |
ImmutableList<Term> |
TermBuilder.wd(java.lang.Iterable<Term> l) |
Modifier and Type | Method and Description |
---|---|
Term |
TermBuilder.acc(Term h,
Term s,
Term o1,
Term o2) |
Term |
TermBuilder.add(Term t1,
Term t2) |
Term |
TermBuilder.addLabel(Term term,
ImmutableArray<TermLabel> labels)
Adds labels to a term, removing any existing labels of the same type.
|
Term |
TermBuilder.addLabel(Term term,
TermLabel label)
Adds a label to a term, removing any existing labels of the same type.
|
Term |
TermBuilder.addLabelToAllSubs(Term term,
ImmutableArray<TermLabel> labels)
Applies the labels to the term and almost every (direct or indirect) sub-term recursively.
|
Term |
TermBuilder.addLabelToAllSubs(Term term,
TermLabel label)
Applies the label to the term and almost every (direct or indirect) sub-term recursively.
|
Term |
TermBuilder.all(java.lang.Iterable<QuantifiableVariable> qvs,
Term t) |
Term |
TermBuilder.all(QuantifiableVariable qv,
Term t) |
Term |
TermBuilder.allClose(Term t) |
Term |
TermBuilder.allFields(Term o) |
Term |
TermBuilder.allObjects(Term f) |
Term |
TermBuilder.and(Term... subTerms) |
Term |
TermBuilder.and(Term t1,
Term t2) |
Term |
TermBuilder.andPreserveLabels(Term t1,
Term t2)
Similar behavior as
TermBuilder.and(Term, Term) but simplifications are not
performed if TermLabel s would be lost. |
Term |
TermBuilder.andSC(Term... subTerms) |
Term |
TermBuilder.andSC(Term t1,
Term t2) |
Term |
TermBuilder.anon(Term h1,
Term s,
Term h2) |
Term |
TermBuilder.anonUpd(LocationVariable heap,
Term mod,
Term anonHeap) |
Term |
ClashFreeSubst.apply(Term t)
substitute
s for v in t ,
avoiding collisions by replacing bound variables in
t if necessary. |
Term |
WaryClashFreeSubst.apply(Term t)
substitute
s for v in t ,
avoiding collisions by replacing bound variables in
t if necessary. |
ImmutableList<Term> |
TermBuilder.apply(Term update,
ImmutableList<Term> targets) |
Term |
TermBuilder.apply(Term update,
Term target) |
Term |
TermBuilder.apply(Term update,
Term target,
ImmutableArray<TermLabel> labels) |
protected Term |
ClashFreeSubst.apply1(Term t)
substitute
s for v in
t , avoiding collisions by replacing bound
variables in t if necessary. |
protected Term |
WaryClashFreeSubst.apply1(Term t)
substitute
s for v in
t , avoiding collisions by replacing bound
variables in t if necessary. |
ImmutableList<Term> |
TermBuilder.applyElementary(Term heap,
java.lang.Iterable<Term> targets) |
Term |
TermBuilder.applyElementary(Term heap,
Term target) |
Term |
TermBuilder.applyElementary(Term loc,
Term value,
Term target) |
protected void |
ClashFreeSubst.applyOnSubterm(Term completeTerm,
int subtermIndex,
Term[] newSubterms,
ImmutableArray<QuantifiableVariable>[] newBoundVars)
Apply the substitution of the subterm
subtermIndex of
term/formula completeTerm . |
protected void |
ClashFreeSubst.applyOnSubterm(Term completeTerm,
int subtermIndex,
Term[] newSubterms,
ImmutableArray<QuantifiableVariable>[] newBoundVars)
Apply the substitution of the subterm
subtermIndex of
term/formula completeTerm . |
Term |
TermBuilder.applyParallel(ImmutableList<Term> updates,
Term target) |
Term |
TermBuilder.applyParallel(Term[] updates,
Term target) |
Term |
TermBuilder.applyParallel(Term[] updates,
Term target) |
Term |
TermBuilder.applyParallel(Term[] lhss,
Term[] values,
Term target) |
Term |
TermBuilder.applyParallel(Term[] lhss,
Term[] values,
Term target) |
Term |
TermBuilder.applyParallel(Term[] lhss,
Term[] values,
Term target) |
Term |
TermBuilder.applySequential(ImmutableList<Term> updates,
Term target) |
Term |
TermBuilder.applySequential(Term[] updates,
Term target) |
Term |
TermBuilder.applySequential(Term[] updates,
Term target) |
Term |
TermBuilder.applyUpdatePairsSequential(ImmutableList<SVInstantiations.UpdateLabelPair> updates,
Term target) |
Term |
TermBuilder.arr(Term idx) |
Term |
TermBuilder.arrayRange(Term o,
Term lower,
Term upper) |
Term |
TermBuilder.arrayStore(Term o,
Term i,
Term v) |
Term |
TermBuilder.box(JavaBlock jb,
Term t) |
Term |
TermBuilder.bprod(QuantifiableVariable qv,
Term a,
Term b,
Term t,
Services services)
Constructs a bounded product comprehension expression.
|
Term |
TermBuilder.bsum(QuantifiableVariable qv,
Term a,
Term b,
Term t) |
Term |
TermBuilder.cast(Sort s,
Term t) |
int |
TermOrdering.compare(Term p_a,
Term p_b)
Compare the two given terms
|
int |
LexPathOrdering.compare(Term p_a,
Term p_b) |
Term |
TermBuilder.convertToBoolean(Term a)
For a formula a, convert it to a boolean expression.
|
Term |
TermBuilder.convertToFormula(Term a)
If a is a boolean literal, the method returns the literal as a Formula.
|
Expression |
ProgramInLogic.convertToProgram(Term t,
ExtList list) |
Term |
TermBuilder.create(Term h,
Term o) |
Term |
TermBuilder.created(Term o) |
Term |
TermBuilder.created(Term h,
Term o) |
Term |
TermBuilder.createdInHeap(Term s,
Term h) |
Term |
TermFactory.createTerm(Operator op,
Term... subs) |
Term |
TermFactory.createTerm(Operator op,
Term[] subs,
ImmutableArray<QuantifiableVariable> boundVars,
JavaBlock javaBlock) |
Term |
TermFactory.createTerm(Operator op,
Term[] subs,
ImmutableArray<QuantifiableVariable> boundVars,
JavaBlock javaBlock,
ImmutableArray<TermLabel> labels) |
Term |
TermFactory.createTerm(Operator op,
Term[] subs,
ImmutableArray<QuantifiableVariable> boundVars,
JavaBlock javaBlock,
TermLabel label) |
Term |
TermFactory.createTerm(Operator op,
Term[] subs,
ImmutableArray<TermLabel> labels) |
Term |
TermFactory.createTerm(Operator op,
Term[] subs,
TermLabel label) |
Term |
TermFactory.createTerm(Operator op,
Term sub,
ImmutableArray<TermLabel> labels) |
Term |
TermFactory.createTerm(Operator op,
Term sub1,
Term sub2,
ImmutableArray<TermLabel> labels) |
Term |
TermBuilder.deepNonNull(Term o,
Term d)
The "deep non null" predicate arising from JML non_null types.
|
Term |
TermBuilder.dia(JavaBlock jb,
Term t) |
Term |
TermBuilder.disjoint(Term s1,
Term s2) |
Term |
TermBuilder.dot(Sort asSort,
Term o,
Function f) |
Term |
TermBuilder.dot(Sort asSort,
Term o,
LocationVariable field) |
Term |
TermBuilder.dot(Sort asSort,
Term o,
Term f) |
Term |
TermBuilder.dotArr(Term ref,
Term idx) |
Term |
TermBuilder.dotLength(Term a) |
Term |
TermBuilder.elementary(Term lhs,
Term rhs) |
Term |
TermBuilder.elementary(UpdateableOperator lhs,
Term rhs) |
Term |
TermBuilder.elementOf(Term o,
Term f,
Term s) |
Term |
TermBuilder.equals(Term t1,
Term t2)
Creates a term with the correct equality symbol for the sorts involved
|
boolean |
BoundVariableTools.equalsModRenaming(ImmutableArray<QuantifiableVariable> vars0,
Term term0,
ImmutableArray<QuantifiableVariable> vars1,
Term term1,
TermServices services) |
boolean |
TermImpl.equalsModRenaming(Term o) |
boolean |
Term.equalsModRenaming(Term o)
Compares if two terms are equal modulo bound renaming
|
Term |
TermBuilder.ex(java.lang.Iterable<QuantifiableVariable> qvs,
Term t) |
Term |
TermBuilder.ex(QuantifiableVariable qv,
Term t) |
Term |
TermBuilder.exactInstance(Sort s,
Term t) |
Term |
TermBuilder.fieldStore(TermServices services,
Term o,
Function f,
Term v) |
Term |
TermBuilder.forallHeaps(Services services,
Term t) |
Term |
TermBuilder.frame(Term heapTerm,
java.util.Map<Term,Term> normalToAtPre,
Term mod) |
Term |
TermBuilder.frameStrictlyEmpty(Term heapTerm,
java.util.Map<Term,Term> normalToAtPre)
Returns the framing condition that the resulting heap is identical (i.e.
|
Term |
TermBuilder.freshLocs(Term h) |
Term |
TermBuilder.func(Function f,
Term... s) |
Term |
TermBuilder.func(Function f,
Term s) |
Term |
TermBuilder.func(Function f,
Term[] s,
ImmutableArray<QuantifiableVariable> boundVars) |
Term |
TermBuilder.func(Function f,
Term s1,
Term s2) |
Term |
TermBuilder.func(IObserverFunction f,
Term... s) |
Term |
TermBuilder.geq(Term t1,
Term t2) |
Term |
PosInTerm.getSubTerm(Term t)
navigate to the subterm described by this position and return it
if the described position does not exist in the term an
IndexOutOfBoundsException
is thrown |
static Term |
TermBuilder.goBelowUpdates(Term term)
Removes leading updates from the passed term.
|
static Pair<ImmutableList<Term>,Term> |
TermBuilder.goBelowUpdates2(Term term)
Removes leading updates from the passed term.
|
Term |
TermBuilder.gt(Term t1,
Term t2) |
Term |
TermBuilder.ife(Term cond,
Term _then,
Term _else) |
Term |
TermBuilder.ifEx(ImmutableList<QuantifiableVariable> qvs,
Term cond,
Term _then,
Term _else)
Construct a term with the \ifEx operator.
|
Term |
TermBuilder.ifEx(QuantifiableVariable qv,
Term cond,
Term _then,
Term _else)
Construct a term with the \ifEx operator.
|
Term |
TermBuilder.imp(Term t1,
Term t2) |
Term |
TermBuilder.imp(Term t1,
Term t2,
ImmutableArray<TermLabel> labels) |
Term |
TermBuilder.impPreserveLabels(Term t1,
Term t2)
Similar behavior as
TermBuilder.imp(Term, Term) but simplifications are not
performed if TermLabel s would be lost. |
Term |
TermBuilder.inByte(Term var) |
Term |
TermBuilder.inChar(Term var) |
Term |
TermBuilder.indexOf(Term s,
Term x)
Function representing the least index of an element x in a sequence s (or
underspecified)
|
Term |
TermBuilder.infiniteUnion(QuantifiableVariable[] qvs,
Term s) |
Term |
TermBuilder.infiniteUnion(QuantifiableVariable[] qvs,
Term guard,
Term s) |
Term |
TermBuilder.inInt(Term var) |
Term |
TermBuilder.initialized(Term o) |
Term |
TermBuilder.inLong(Term var) |
Term |
TermBuilder.inShort(Term var) |
Term |
TermBuilder.instance(Sort s,
Term t) |
Term |
TermBuilder.intersect(Term... subTerms) |
Term |
TermBuilder.intersect(Term s1,
Term s2) |
Term |
TermBuilder.inv(Term o) |
Term |
TermBuilder.inv(Term[] h,
Term o) |
Term |
TermBuilder.inv(Term[] h,
Term o) |
Term |
TermBuilder.label(Term term,
ImmutableArray<TermLabel> labels)
Applies labels to a term, removing any existing labels.
|
Term |
TermBuilder.label(Term term,
TermLabel label)
Applies a label to a term, removing any existing labels.
|
Term |
TermBuilder.leq(Term t1,
Term t2) |
Term |
TermBuilder.lt(Term t1,
Term t2) |
Term |
TermBuilder.max(ImmutableList<? extends QuantifiableVariable> qvs,
Term range,
Term t,
TermServices services)
minimum operator
|
Term |
TermBuilder.measuredBy(Term mby) |
Term |
TermBuilder.measuredByCheck(Term mby) |
Term |
TermBuilder.min(ImmutableList<? extends QuantifiableVariable> qvs,
Term range,
Term t,
TermServices services)
minimum operator
|
Term |
TermBuilder.not(Term t) |
Term |
TermBuilder.notPreserveLabels(Term t)
Similar behavior as
TermBuilder.not(Term) but simplifications are not
performed if TermLabel s would be lost. |
Term |
TermBuilder.open(Term formula)
Removes universal quantifiers from a formula.
|
Term |
TermBuilder.or(Term... subTerms) |
Term |
TermBuilder.or(Term t1,
Term t2) |
Term |
TermBuilder.orPreserveLabels(Term t1,
Term t2)
Similar behavior as
TermBuilder.or(Term, Term) but simplifications are not
performed if TermLabel s would be lost. |
Term |
TermBuilder.orSC(Term... subTerms) |
Term |
TermBuilder.orSC(Term t1,
Term t2) |
Term |
TermBuilder.pair(Term first,
Term second) |
Term |
TermBuilder.parallel(Term... updates) |
Term |
TermBuilder.parallel(Term[] lhss,
Term[] values) |
Term |
TermBuilder.parallel(Term[] lhss,
Term[] values) |
Term |
TermBuilder.parallel(Term u1,
Term u2) |
Term |
TermBuilder.permissionsFor(Term permHeap,
Term regularHeap) |
Term |
TermBuilder.prec(Term mby,
Term mbyAtPre) |
Term |
TermBuilder.prod(ImmutableList<QuantifiableVariable> qvs,
Term range,
Term t,
TermServices services)
General (unbounded) product
|
Term |
TermBuilder.prog(Modality mod,
JavaBlock jb,
Term t) |
Term |
TermBuilder.prog(Modality mod,
JavaBlock jb,
Term t,
ImmutableArray<TermLabel> labels) |
Term |
TermBuilder.reach(Term h,
Term s,
Term o1,
Term o2,
Term n) |
Term |
TermBuilder.reachableValue(Term t,
KeYJavaType kjt) |
Term |
TermBuilder.reachableValue(Term h,
Term t,
KeYJavaType kjt) |
Term[] |
BoundVariableTools.renameVariables(Term[] originalTerms,
ImmutableArray<QuantifiableVariable> oldBoundVars,
ImmutableArray<QuantifiableVariable> newBoundVars,
TermServices services) |
Term |
BoundVariableTools.renameVariables(Term originalTerm,
ImmutableArray<QuantifiableVariable> oldBoundVars,
ImmutableArray<QuantifiableVariable> newBoundVars,
TermServices services)
Compare the arrays
oldBoundVars and
newBoundVars component-wise, and in case of differences
substitute variables from the former array with the ones of the latter
array (in originalTerm ) |
Term |
TermBuilder.replace(Term term,
PosInTerm pos,
Term replacement)
Replaces a child term by another one.
|
static Term |
GenericTermReplacer.replace(Term t,
java.util.function.Predicate<Term> filter,
java.util.function.Function<Term,Term> replacer,
Services services) |
boolean |
BoundVariableTools.resolveCollisions(Term originalTerm,
ImmutableSet<QuantifiableVariable> criticalVars,
ImmutableArray<QuantifiableVariable>[] newBoundVars,
Term[] newSubs,
TermServices services)
Ensure that none of the variables
criticalVars is bound by
the top-level operator of t (by bound renaming). |
boolean |
BoundVariableTools.resolveCollisions(Term originalTerm,
ImmutableSet<QuantifiableVariable> criticalVars,
ImmutableArray<QuantifiableVariable>[] newBoundVars,
Term[] newSubs,
TermServices services)
Ensure that none of the variables
criticalVars is bound by
the top-level operator of t (by bound renaming). |
Term |
TermBuilder.select(Sort asSort,
Term h,
Term o,
LocationVariable field)
Get the select expression for a location variabe representing the field.
|
Term |
TermBuilder.select(Sort asSort,
Term h,
Term o,
Term f) |
Term |
TermBuilder.seq(Term... terms) |
Term |
TermBuilder.seqConcat(Term s,
Term s2) |
Term |
TermBuilder.seqDef(QuantifiableVariable qv,
Term a,
Term b,
Term t) |
Term |
TermBuilder.seqGet(Sort asSort,
Term s,
Term idx) |
Term |
TermBuilder.seqLen(Term s) |
Term |
TermBuilder.seqReverse(Term s) |
Term |
TermBuilder.seqSingleton(Term x) |
Term |
TermBuilder.seqSub(Term s,
Term from,
Term to) |
Term |
TermBuilder.sequential(Term[] updates) |
Term |
TermBuilder.sequential(Term u1,
Term u2) |
Term |
TermBuilder.setComprehension(QuantifiableVariable[] qvs,
Term o,
Term f) |
Term |
TermBuilder.setComprehension(QuantifiableVariable[] qvs,
Term guard,
Term o,
Term f) |
Term |
TermBuilder.setMinus(Term s1,
Term s2) |
Term |
TermBuilder.shortcut(Term term) |
Term |
TermBuilder.singleton(Term o,
Term f) |
Term |
TermBuilder.staticDot(Sort asSort,
Term f) |
Term |
TermBuilder.staticFieldStore(Function f,
Term v) |
Term |
TermBuilder.staticInv(Term[] h,
KeYJavaType t) |
Term |
TermBuilder.store(Term h,
Term o,
Term f,
Term v) |
Term |
TermBuilder.subset(Term s1,
Term s2) |
Term |
TermBuilder.subst(QuantifiableVariable substVar,
Term substTerm,
Term origTerm) |
Term |
TermBuilder.subst(SubstOp op,
QuantifiableVariable substVar,
Term substTerm,
Term origTerm)
Creates a substitution term
|
protected boolean |
ClashFreeSubst.subTermChanges(ImmutableArray<QuantifiableVariable> boundVars,
Term subTerm)
returns true if
subTerm bound by
boundVars would change under application of this
substitution. |
void |
Visitor.subtreeEntered(Term subtreeRoot)
this method is called in execPreOrder and execPostOrder in class Term
when entering the subtree rooted in the term subtreeRoot.
|
void |
DefaultVisitor.subtreeEntered(Term subtreeRoot) |
void |
Visitor.subtreeLeft(Term subtreeRoot)
this method is called in execPreOrder and execPostOrder in class Term
when leaving the subtree rooted in the term subtreeRoot.
|
void |
DefaultVisitor.subtreeLeft(Term subtreeRoot) |
Term |
TermBuilder.sum(ImmutableList<QuantifiableVariable> qvs,
Term range,
Term t)
General (unbounded) sum
|
ImmutableArray<QuantifiableVariable> |
BoundVariableTools.unifyBoundVariables(ImmutableArray<QuantifiableVariable>[] boundVarsPerSub,
Term[] subs,
int subtermsBegin,
int subtermsEnd,
TermServices services)
Ensure that for the subterms with indexes [
subtermsBegin ,
subtermsEnd ) the same variables are bound. |
Term |
TermBuilder.union(Term... subTerms) |
Term |
TermBuilder.union(Term s1,
Term s2) |
ImmutableSet<Term> |
TermBuilder.unionToSet(Term s) |
Term |
TermBuilder.unlabel(Term term) |
Term |
TermBuilder.unlabelRecursive(Term term) |
void |
Visitor.visit(Term visited)
the entry method for the visitor pattern
|
void |
OpCollector.visit(Term t) |
void |
BoundVarsVisitor.visit(Term visited)
only called by execPostOrder in Term.
|
void |
ClashFreeSubst.VariableCollectVisitor.visit(Term t) |
void |
SortCollector.visit(Term visited) |
boolean |
Visitor.visitSubtree(Term visited)
Checks if the subtree below the visited
Term should be traversed. |
boolean |
DefaultVisitor.visitSubtree(Term visited) |
Term |
TermBuilder.wd(Term t) |
Term[] |
TermBuilder.wd(Term[] l) |
Term |
TermBuilder.wellFormed(Term heap) |
Modifier and Type | Method and Description |
---|---|
Term |
TermBuilder.and(java.lang.Iterable<Term> subTerms) |
Term |
TermBuilder.andPreserveLabels(java.lang.Iterable<Term> subTerms)
Similar behavior as
TermBuilder.and(Iterable) but simplifications are not
performed if TermLabel s would be lost. |
Term |
TermBuilder.andSC(java.lang.Iterable<Term> subTerms) |
ImmutableList<Term> |
TermBuilder.apply(Term update,
ImmutableList<Term> targets) |
ImmutableList<Term> |
TermBuilder.applyElementary(Term heap,
java.lang.Iterable<Term> targets) |
Term |
TermBuilder.applyParallel(ImmutableList<Term> updates,
Term target) |
Term |
TermBuilder.applySequential(ImmutableList<Term> updates,
Term target) |
Term |
TermFactory.createTerm(Operator op,
ImmutableArray<Term> subs,
ImmutableArray<QuantifiableVariable> boundVars,
JavaBlock javaBlock) |
Term |
TermFactory.createTerm(Operator op,
ImmutableArray<Term> subs,
ImmutableArray<QuantifiableVariable> boundVars,
JavaBlock javaBlock,
ImmutableArray<TermLabel> labels)
Master method for term creation.
|
Term |
TermFactory.createTerm(Operator junctor,
java.util.List<Term> terms)
Reduce the given list of terms into a one term by using the operator.
|
Term |
TermBuilder.frame(Term heapTerm,
java.util.Map<Term,Term> normalToAtPre,
Term mod) |
Term |
TermBuilder.frame(Term heapTerm,
java.util.Map<Term,Term> normalToAtPre,
Term mod) |
Term |
TermBuilder.frameStrictlyEmpty(Term heapTerm,
java.util.Map<Term,Term> normalToAtPre)
Returns the framing condition that the resulting heap is identical (i.e.
|
Term |
TermBuilder.frameStrictlyEmpty(Term heapTerm,
java.util.Map<Term,Term> normalToAtPre)
Returns the framing condition that the resulting heap is identical (i.e.
|
ImmutableList<Sort> |
TermBuilder.getSorts(java.lang.Iterable<Term> terms)
|
Term |
TermBuilder.intersect(java.lang.Iterable<Term> subTerms) |
Term |
TermBuilder.or(java.lang.Iterable<Term> subTerms) |
Term |
TermBuilder.orPreserveLabels(java.lang.Iterable<Term> subTerms)
Similar behavior as
TermBuilder.or(Iterable) but simplifications are not
performed if TermLabel s would be lost. |
Term |
TermBuilder.orSC(java.lang.Iterable<Term> subTerms) |
Term |
TermBuilder.parallel(ImmutableList<Term> updates) |
Term |
TermBuilder.parallel(java.lang.Iterable<Term> lhss,
java.lang.Iterable<Term> values) |
Term |
TermBuilder.parallel(java.lang.Iterable<Term> lhss,
java.lang.Iterable<Term> values) |
static Term |
GenericTermReplacer.replace(Term t,
java.util.function.Predicate<Term> filter,
java.util.function.Function<Term,Term> replacer,
Services services) |
static Term |
GenericTermReplacer.replace(Term t,
java.util.function.Predicate<Term> filter,
java.util.function.Function<Term,Term> replacer,
Services services) |
static Term |
GenericTermReplacer.replace(Term t,
java.util.function.Predicate<Term> filter,
java.util.function.Function<Term,Term> replacer,
Services services) |
Term |
TermBuilder.seq(ImmutableList<Term> terms) |
Term |
TermBuilder.sequential(ImmutableList<Term> updates) |
Term |
TermBuilder.union(java.lang.Iterable<Term> subTerms) |
ImmutableList<Term> |
TermBuilder.wd(java.lang.Iterable<Term> l) |
Constructor and Description |
---|
ClashFreeSubst(QuantifiableVariable v,
Term s,
TermBuilder tb) |
SequentFormula(Term term)
creates a new SequentFormula
|
TermCreationException(Operator op,
Term failed) |
WaryClashFreeSubst(QuantifiableVariable v,
Term s,
TermBuilder tb) |
Constructor and Description |
---|
TermFactory(java.util.Map<Term,Term> cache) |
TermFactory(java.util.Map<Term,Term> cache) |
TermImpl(Operator op,
ImmutableArray<Term> subs,
ImmutableArray<QuantifiableVariable> boundVars,
JavaBlock javaBlock)
Constructs a term for the given operator, with the given sub terms,
bounded variables and (if applicable) the code block on this term.
|
Modifier and Type | Method and Description |
---|---|
static Term |
OriginTermLabel.collectSubtermOrigins(Term term,
Services services)
This method transforms a term in such a way that
every
OriginTermLabel contains all of the correct
OriginTermLabel.getSubtermOrigins() . |
static Term |
TermLabelManager.label(Services services,
TermLabelState state,
PosInOccurrence applicationPosInOccurrence,
Rule rule,
RuleApp ruleApp,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Term newTerm)
Computes the
TermLabel s for the new Term via
TermLabelManager.instantiateLabels(TermLabelState, Services, PosInOccurrence, Term, Rule, RuleApp,
Goal, Object, Term, Operator, ImmutableArray, ImmutableArray,
JavaBlock, ImmutableArray)
and refactors the labels below the new Term in addition via
TermLabelManager.refactorTerm(TermLabelState, Services, PosInOccurrence, Term, Goal, Object,
Rule, Term) . |
static Term |
TermLabelManager.label(Services services,
TermLabelState state,
Term applicationTerm,
PosInOccurrence applicationPosInOccurrence,
Rule rule,
RuleApp ruleApp,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Term newTerm)
Computes the
TermLabel s for the new Term via
TermLabelManager.instantiateLabels(TermLabelState, Services, PosInOccurrence, Term, Rule, RuleApp,
Goal, Object, Term, Operator, ImmutableArray, ImmutableArray,
JavaBlock, ImmutableArray)
and refactors the labels below the new Term in addition via
TermLabelManager.refactorTerm(TermLabelState, Services, PosInOccurrence, Term, Goal, Object,
Rule, Term) . |
Term |
TermLabelManager.label(TermLabelState state,
Services services,
Term applicationTerm,
PosInOccurrence applicationPosInOccurrence,
Rule rule,
RuleApp ruleApp,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Term newTerm)
Computes the
TermLabel s for the new Term via
TermLabelManager.instantiateLabels(TermLabelState, Services, PosInOccurrence, Term, Rule, RuleApp,
Goal, Object, Term, Operator, ImmutableArray, ImmutableArray,
JavaBlock, ImmutableArray)
and refactors the labels below the new Term in addition via
TermLabelManager.refactorTerm(TermLabelState, Services, PosInOccurrence, Term, Goal, Object,
Rule, Term) . |
protected Term |
TermLabelManager.refactorApplicationTerm(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
TermLabelManager.RefactoringsContainer refactorings,
TermFactory tf)
Refactors the labels of the application term.
|
protected Term |
TermLabelManager.refactorLabelsRecursive(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Term term,
ImmutableList<TermLabelRefactoring> activeRefactorings)
|
Term |
TermLabelManager.refactorSequentFormula(TermLabelState state,
Services services,
Term sequentFormula,
PosInOccurrence applicationPosInOccurrence,
Goal goal,
java.lang.Object hint,
Rule rule,
Term tacletTerm)
|
static Term |
TermLabelManager.refactorSequentFormula(TermLabelState state,
Services services,
Term sequentFormula,
PosInOccurrence applicationPosInOccurrence,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm)
|
Term |
TermLabelManager.refactorTerm(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Goal goal,
java.lang.Object hint,
Rule rule,
Term tacletTerm)
Refactors all labels in the given application
Term . |
static Term |
TermLabelManager.refactorTerm(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm)
Refactors all labels in the complete
Sequent . |
static Term |
TermLabel.removeIrrelevantLabels(Term term,
Services services)
Remove all irrelevant labels from a term.
|
static Term |
TermLabel.removeIrrelevantLabels(Term term,
TermFactory tf)
Remove all irrelevant labels from a term.
|
static Term |
OriginTermLabel.removeOriginLabels(Term term,
Services services)
Removes all
OriginTermLabel from the specified term and its sub-terms. |
protected Term |
TermLabelManager.replaceTerm(TermLabelState state,
PosInOccurrence pio,
Term newTerm,
TermFactory tf,
ImmutableList<TermLabelRefactoring> parentRefactorings,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm)
Replaces the
Term at the specified PosInOccurrence . |
Modifier and Type | Method and Description |
---|---|
static boolean |
OriginTermLabel.canAddLabel(Term term,
Services services)
Determines whether an
OriginTermLabel can be added to the specified term. |
static Term |
OriginTermLabel.collectSubtermOrigins(Term term,
Services services)
This method transforms a term in such a way that
every
OriginTermLabel contains all of the correct
OriginTermLabel.getSubtermOrigins() . |
protected java.util.Map<Name,ChildTermLabelPolicy> |
TermLabelManager.computeActiveChildPolicies(TermServices services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Map<Name,java.util.Map<Name,ChildTermLabelPolicy>> ruleSpecificPolicies,
java.util.Map<Name,ChildTermLabelPolicy> ruleIndependentPolicies)
Computes active
ChildTermLabelPolicy instances which have to be executed during the given rule application. |
protected TermLabelManager.RefactoringsContainer |
TermLabelManager.computeRefactorings(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm)
Computes the
TermLabelRefactoring to consider. |
static ImmutableArray<TermLabel> |
TermLabelManager.instantiateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Rule rule,
RuleApp ruleApp,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels)
|
ImmutableArray<TermLabel> |
TermLabelManager.instantiateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
RuleApp ruleApp,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels)
|
static ImmutableArray<TermLabel> |
TermLabelManager.instantiateLabels(TermLabelState state,
Services services,
Term applicationTerm,
PosInOccurrence applicationPosInOccurrence,
Rule rule,
RuleApp ruleApp,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels)
|
static Term |
TermLabelManager.label(Services services,
TermLabelState state,
PosInOccurrence applicationPosInOccurrence,
Rule rule,
RuleApp ruleApp,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Term newTerm)
Computes the
TermLabel s for the new Term via
TermLabelManager.instantiateLabels(TermLabelState, Services, PosInOccurrence, Term, Rule, RuleApp,
Goal, Object, Term, Operator, ImmutableArray, ImmutableArray,
JavaBlock, ImmutableArray)
and refactors the labels below the new Term in addition via
TermLabelManager.refactorTerm(TermLabelState, Services, PosInOccurrence, Term, Goal, Object,
Rule, Term) . |
static Term |
TermLabelManager.label(Services services,
TermLabelState state,
Term applicationTerm,
PosInOccurrence applicationPosInOccurrence,
Rule rule,
RuleApp ruleApp,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Term newTerm)
Computes the
TermLabel s for the new Term via
TermLabelManager.instantiateLabels(TermLabelState, Services, PosInOccurrence, Term, Rule, RuleApp,
Goal, Object, Term, Operator, ImmutableArray, ImmutableArray,
JavaBlock, ImmutableArray)
and refactors the labels below the new Term in addition via
TermLabelManager.refactorTerm(TermLabelState, Services, PosInOccurrence, Term, Goal, Object,
Rule, Term) . |
Term |
TermLabelManager.label(TermLabelState state,
Services services,
Term applicationTerm,
PosInOccurrence applicationPosInOccurrence,
Rule rule,
RuleApp ruleApp,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Term newTerm)
Computes the
TermLabel s for the new Term via
TermLabelManager.instantiateLabels(TermLabelState, Services, PosInOccurrence, Term, Rule, RuleApp,
Goal, Object, Term, Operator, ImmutableArray, ImmutableArray,
JavaBlock, ImmutableArray)
and refactors the labels below the new Term in addition via
TermLabelManager.refactorTerm(TermLabelState, Services, PosInOccurrence, Term, Goal, Object,
Rule, Term) . |
protected void |
TermLabelManager.performChildAndGrandchildPolicies(TermServices services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Map<Name,ChildTermLabelPolicy> policies,
java.util.Set<TermLabel> newLabels)
Performs the given child and grandchild
ChildTermLabelPolicy instances. |
protected void |
TermLabelManager.performDirectChildPolicies(TermServices services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Map<Name,ChildTermLabelPolicy> policies,
java.util.Set<TermLabel> newLabels)
Performs the given direct
ChildTermLabelPolicy instances. |
protected ImmutableArray<TermLabel> |
TermLabelManager.performRefactoring(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Term term,
ImmutableList<TermLabelRefactoring> activeRefactorings)
Computes the new labels as part of the refactoring for the given
Term . |
protected void |
TermLabelManager.performTacletTerm(Term tacletTerm,
java.util.Set<TermLabel> newLabels)
|
protected void |
TermLabelManager.performTermLabelPolicies(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels,
java.util.Map<Name,TermLabelPolicy> policies,
java.util.Set<TermLabel> newLabels)
Performs the given
TermLabelPolicy instances. |
protected void |
TermLabelManager.performTermLabelPolicies(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels,
java.util.Map<Name,TermLabelPolicy> policies,
java.util.Set<TermLabel> newLabels,
TermLabel label)
Performs the given
TermLabelPolicy instances. |
protected void |
TermLabelManager.performUpdater(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Term modalityTerm,
Rule rule,
RuleApp ruleApp,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableList<TermLabelUpdate> updater,
java.util.Set<TermLabel> newLabels)
Performs the given child and grandchild
TermLabelUpdate instances. |
protected Term |
TermLabelManager.refactorApplicationTerm(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
TermLabelManager.RefactoringsContainer refactorings,
TermFactory tf)
Refactors the labels of the application term.
|
static void |
TermLabelManager.refactorGoal(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm)
Refactors all labels in the complete
Sequent . |
void |
TermLabelManager.refactorGoal(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm)
Refactors all labels in the complete
Sequent . |
protected Term |
TermLabelManager.refactorLabelsRecursive(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Term term,
ImmutableList<TermLabelRefactoring> activeRefactorings)
|
protected void |
TermLabelManager.refactorSemisequent(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Semisequent semisequent,
boolean inAntec,
ImmutableList<TermLabelRefactoring> activeRefactorings)
Performs a
TermLabel refactoring on the given Semisequent . |
static void |
TermLabelManager.refactorSequent(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm)
Refactors all labels in the complete
Sequent . |
void |
TermLabelManager.refactorSequent(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm)
Refactors all labels in the complete
Sequent . |
Term |
TermLabelManager.refactorSequentFormula(TermLabelState state,
Services services,
Term sequentFormula,
PosInOccurrence applicationPosInOccurrence,
Goal goal,
java.lang.Object hint,
Rule rule,
Term tacletTerm)
|
static Term |
TermLabelManager.refactorSequentFormula(TermLabelState state,
Services services,
Term sequentFormula,
PosInOccurrence applicationPosInOccurrence,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm)
|
Term |
TermLabelManager.refactorTerm(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Goal goal,
java.lang.Object hint,
Rule rule,
Term tacletTerm)
Refactors all labels in the given application
Term . |
static Term |
TermLabelManager.refactorTerm(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm)
Refactors all labels in the complete
Sequent . |
static Term |
TermLabel.removeIrrelevantLabels(Term term,
Services services)
Remove all irrelevant labels from a term.
|
static Term |
TermLabel.removeIrrelevantLabels(Term term,
TermFactory tf)
Remove all irrelevant labels from a term.
|
static Term |
OriginTermLabel.removeOriginLabels(Term term,
Services services)
Removes all
OriginTermLabel from the specified term and its sub-terms. |
protected Term |
TermLabelManager.replaceTerm(TermLabelState state,
PosInOccurrence pio,
Term newTerm,
TermFactory tf,
ImmutableList<TermLabelRefactoring> parentRefactorings,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm)
Replaces the
Term at the specified PosInOccurrence . |
Modifier and Type | Method and Description |
---|---|
protected java.util.Map<Name,ChildTermLabelPolicy> |
TermLabelManager.computeActiveChildPolicies(TermServices services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Map<Name,java.util.Map<Name,ChildTermLabelPolicy>> ruleSpecificPolicies,
java.util.Map<Name,ChildTermLabelPolicy> ruleIndependentPolicies)
Computes active
ChildTermLabelPolicy instances which have to be executed during the given rule application. |
static ImmutableArray<TermLabel> |
TermLabelManager.instantiateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Rule rule,
RuleApp ruleApp,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels)
|
ImmutableArray<TermLabel> |
TermLabelManager.instantiateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
RuleApp ruleApp,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels)
|
static ImmutableArray<TermLabel> |
TermLabelManager.instantiateLabels(TermLabelState state,
Services services,
Term applicationTerm,
PosInOccurrence applicationPosInOccurrence,
Rule rule,
RuleApp ruleApp,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels)
|
protected void |
TermLabelManager.performChildAndGrandchildPolicies(TermServices services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Map<Name,ChildTermLabelPolicy> policies,
java.util.Set<TermLabel> newLabels)
Performs the given child and grandchild
ChildTermLabelPolicy instances. |
protected void |
TermLabelManager.performDirectChildPolicies(TermServices services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Map<Name,ChildTermLabelPolicy> policies,
java.util.Set<TermLabel> newLabels)
Performs the given direct
ChildTermLabelPolicy instances. |
protected void |
TermLabelManager.performTermLabelPolicies(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels,
java.util.Map<Name,TermLabelPolicy> policies,
java.util.Set<TermLabel> newLabels)
Performs the given
TermLabelPolicy instances. |
protected void |
TermLabelManager.performTermLabelPolicies(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels,
java.util.Map<Name,TermLabelPolicy> policies,
java.util.Set<TermLabel> newLabels,
TermLabel label)
Performs the given
TermLabelPolicy instances. |
protected void |
TermLabelManager.performUpdater(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Term modalityTerm,
Rule rule,
RuleApp ruleApp,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableList<TermLabelUpdate> updater,
java.util.Set<TermLabel> newLabels)
Performs the given child and grandchild
TermLabelUpdate instances. |
Modifier and Type | Method and Description |
---|---|
abstract Term |
SubstOp.apply(Term term,
TermBuilder tb)
Apply this substitution operator to
term , which
has this operator as top-level operator |
Term |
WarySubstOp.apply(Term term,
TermBuilder tb) |
static Term |
UpdateApplication.getTarget(Term t) |
static Term |
UpdateApplication.getUpdate(Term t) |
Term |
TermTransformer.transform(Term term,
SVInstantiations svInst,
Services services)
initiates term transformation of term.
|
Modifier and Type | Method and Description |
---|---|
protected void |
SubstOp.additionalValidTopLevel(Term term) |
protected void |
IfThenElse.additionalValidTopLevel(Term term) |
protected void |
AbstractSortedOperator.additionalValidTopLevel(Term term) |
void |
UpdateApplication.additionalValidTopLevel(Term term) |
protected void |
IfExThenElse.additionalValidTopLevel(Term term) |
abstract Term |
SubstOp.apply(Term term,
TermBuilder tb)
Apply this substitution operator to
term , which
has this operator as top-level operator |
Term |
WarySubstOp.apply(Term term,
TermBuilder tb) |
static java.lang.String |
AbstractTermTransformer.convertToDecimalString(Term term,
Services services) |
Expression |
ProgramVariable.convertToProgram(Term t,
ExtList l) |
Expression |
ProgramMethod.convertToProgram(Term t,
ExtList l) |
static Term |
UpdateApplication.getTarget(Term t) |
static Term |
UpdateApplication.getUpdate(Term t) |
Term |
TermTransformer.transform(Term term,
SVInstantiations svInst,
Services services)
initiates term transformation of term.
|
boolean |
TermLabelSV.validTopLevel(Term term) |
default boolean |
Operator.validTopLevel(Term term) |
void |
Operator.validTopLevelException(Term term)
Checks whether the top level structure of the given @link Term
is syntactically valid, given the assumption that the top level
operator of the term is the same as this Operator.
|
Modifier and Type | Method and Description |
---|---|
Sort |
SubstOp.sort(ImmutableArray<Term> terms) |
Sort |
IfThenElse.sort(ImmutableArray<Term> terms) |
Sort |
AbstractSortedOperator.sort(ImmutableArray<Term> terms) |
Sort |
UpdateApplication.sort(ImmutableArray<Term> terms) |
Sort |
Operator.sort(ImmutableArray<Term> terms)
Determines the sort of the
Term if it would be created using this
Operator as top level operator and the given terms as sub terms. |
Sort |
IfExThenElse.sort(ImmutableArray<Term> terms) |
Modifier and Type | Method and Description |
---|---|
boolean |
ProgramSVSort.canStandFor(Term t) |
Modifier and Type | Method and Description |
---|---|
static Sort |
TermHelper.getMaxSort(Term term,
int i,
TermServices services)
helper function to determine the maximal sort the term
tSub may have as i sub term
This method will become obsolete in the near future as all operators
will become a fixed signature.
|
Modifier and Type | Field and Description |
---|---|
Term |
RewriteCommand.Parameters.find
Term, which should be replaced
|
Term |
AssumeCommand.FormulaParameter.formula |
Term |
RuleCommand.Parameters.formula |
Term |
SelectCommand.Parameters.formula
A formula defining the goal to select
|
Term |
AxiomCommand.FormulaParameter.formula |
Term |
InstantiateCommand.Parameters.formula |
Term |
RewriteCommand.Parameters.formula
Formula, where to find
find . |
Term |
CutCommand.Parameters.formula |
Term |
RuleCommand.Parameters.on |
Term |
RewriteCommand.Parameters.replace
Substitutent
|
Term |
InstantiateCommand.Parameters.with |
Modifier and Type | Field and Description |
---|---|
java.util.Map<java.lang.String,Term> |
RuleCommand.Parameters.instantiations |
Modifier and Type | Method and Description |
---|---|
Term |
RewriteCommand.getTermAtPos(SequentFormula sf,
PosInOccurrence pio)
Calculates term at the PosInOccurrence pio
|
Term |
EngineState.toTerm(java.lang.String string,
Sort sort) |
Modifier and Type | Method and Description |
---|---|
void |
JavascriptCommand.JavascriptInterface.setVar(java.lang.String var,
Term term) |
Modifier and Type | Method and Description |
---|---|
Term |
KeyIO.Loader.getProblem() |
Term |
KeyIO.parseExpression(org.antlr.v4.runtime.CharStream stream)
Given an input stream, this function returns an term if parsable.
|
Term |
KeyIO.parseExpression(java.lang.String expr)
Given an input string, this function returns a term if parsable.
|
Modifier and Type | Method and Description |
---|---|
java.util.List<Term> |
ExpressionBuilder.visitArgument_list(KeYParser.Argument_listContext ctx) |
Modifier and Type | Method and Description |
---|---|
Term |
ExpressionBuilder.createAttributeTerm(Term prefix,
Operator attribute,
org.antlr.v4.runtime.ParserRuleContext ctx) |
protected Term |
ExpressionBuilder.heapSelectionSuffix(Term term,
Term heap,
org.antlr.v4.runtime.ParserRuleContext ctx)
Replace standard heap by another heap in an observer function.
|
protected boolean |
ExpressionBuilder.isHeapTerm(Term term) |
static Term |
ExpressionBuilder.updateOrigin(Term t,
org.antlr.v4.runtime.ParserRuleContext ctx) |
Modifier and Type | Method and Description |
---|---|
protected Term |
ExpressionBuilder.capsulateTf(org.antlr.v4.runtime.ParserRuleContext ctx,
java.util.function.Supplier<Term> termSupplier) |
Modifier and Type | Method and Description |
---|---|
Term |
DefaultTermParser.parse(java.io.Reader in,
Sort sort,
Services services,
Namespace<QuantifiableVariable> var_ns,
Namespace<Function> func_ns,
Namespace<Sort> sort_ns,
Namespace<IProgramVariable> progVar_ns,
AbbrevMap scm)
Deprecated.
The method reads the input and parses a term with the
specified namespaces.
|
Term |
DefaultTermParser.parse(java.io.Reader in,
Sort sort,
Services services,
NamespaceSet nss,
AbbrevMap scm)
Deprecated.
The method reads the input and parses a term with the
specified namespaces.
|
Modifier and Type | Method and Description |
---|---|
Term |
AbbrevMap.AbbrevWrapper.getTerm() |
Term |
AbbrevMap.getTerm(java.lang.String s)
Returns the term which is mapped to the abbreviation s, null if no term
is mapped to the abbreviation.
|
Modifier and Type | Method and Description |
---|---|
void |
AbbrevMap.changeAbbrev(java.lang.String abbreviation,
Term t,
boolean enabled)
Changes the abbreviation
abbreviation to t . |
void |
AbbrevMap.changeAbbrev(Term t,
java.lang.String abbreviation)
Changes the abbreviation of t to abbreviation.
|
boolean |
AbbrevMap.containsTerm(Term t)
Returns true if the map contains the term t.
|
java.lang.String |
AbbrevMap.getAbbrev(Term t)
Returns the abbreviation mapped to the term t.
|
protected ImmutableArray<TermLabel> |
LogicPrinter.getVisibleTermLabels(Term t)
Determine the Set of labels that will be printed out for a specific
Term . |
protected ImmutableArray<TermLabel> |
SequentViewLogicPrinter.getVisibleTermLabels(Term t) |
boolean |
AbbrevMap.isEnabled(Term t)
Returns true if the mapping is enabled, which means that the abbreviation
may be used.
|
protected void |
LogicPrinter.maybeParens(Term t,
int ass)
Prints a subterm, if needed with parentheses.
|
void |
CharListNotation.print(Term t,
LogicPrinter sp) |
abstract void |
Notation.print(Term t,
LogicPrinter sp)
Print a term to a
LogicPrinter . |
void |
Notation.Constant.print(Term t,
LogicPrinter sp) |
void |
Notation.Prefix.print(Term t,
LogicPrinter sp) |
void |
Notation.Infix.print(Term t,
LogicPrinter sp) |
void |
Notation.LabelNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.Quantifier.print(Term t,
LogicPrinter sp) |
void |
Notation.ModalityNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.ModalSVNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.UpdateApplicationNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.ElementaryUpdateNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.ParallelUpdateNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.Subst.print(Term t,
LogicPrinter sp) |
void |
Notation.FunctionNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.CastFunction.print(Term t,
LogicPrinter sp) |
void |
Notation.SelectNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.HeapConstructorNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.StoreNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.Postfix.print(Term t,
LogicPrinter sp) |
void |
Notation.SingletonNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.ElementOfNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.IfThenElse.print(Term t,
LogicPrinter sp) |
void |
Notation.VariableNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.SchemaVariableNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.SeqSingletonNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.SeqConcatNotation.print(Term t,
LogicPrinter sp) |
void |
Notation.SeqGetNotation.print(Term t,
LogicPrinter sp) |
void |
LogicPrinter.printCast(java.lang.String pre,
java.lang.String post,
Term t,
int ass) |
void |
LogicPrinter.printConstant(Term t,
java.lang.String s)
Print a constant.
|
void |
Notation.printContinuingBlock(Term t,
LogicPrinter sp)
Print a term without beginning a new block.
|
void |
Notation.Infix.printContinuingBlock(Term t,
LogicPrinter sp)
Print a term without beginning a new block.
|
void |
LogicPrinter.printElementaryUpdate(java.lang.String asgn,
Term t,
int ass2)
Print an elementary update.
|
void |
LogicPrinter.printElementOf(Term t) |
void |
LogicPrinter.printElementOf(Term t,
java.lang.String symbol) |
void |
Notation.HeapConstructorNotation.printEmbeddedHeap(Term t,
LogicPrinter sp) |
void |
Notation.StoreNotation.printEmbeddedHeap(Term t,
LogicPrinter sp) |
protected boolean |
LogicPrinter.printEmbeddedHeapConstructorTerm(Term t) |
protected void |
LogicPrinter.printEmbeddedObserver(Term heapTerm,
Term objectTerm) |
void |
LogicPrinter.printFunctionTerm(Term t)
Print a term in
f(t1,...tn) style. |
void |
LogicPrinter.printHeapConstructor(Term t,
boolean closingBrace) |
void |
LogicPrinter.printIfThenElseTerm(Term t,
java.lang.String keyword) |
void |
LogicPrinter.printInfixTerm(Term l,
int assLeft,
java.lang.String name,
Term t,
Term r,
int assRight)
Print a binary term in infix style.
|
void |
LogicPrinter.printInfixTermContinuingBlock(Term l,
int assLeft,
java.lang.String name,
Term t,
Term r,
int assRight)
Print a binary term in infix style, continuing a containing block.
|
boolean |
LogicPrinter.printInShortForm(java.lang.String attributeProgramName,
Term t)
returns true if an attribute term shall be printed in short form.
|
void |
LogicPrinter.printLabels(Term t) |
void |
LogicPrinter.printModalityTerm(java.lang.String left,
JavaBlock jb,
java.lang.String right,
Term phi,
int ass)
Print a DL modality formula.
|
void |
LogicPrinter.printObserver(Term t,
Term tacitHeap) |
void |
LogicPrinter.printParallelUpdate(java.lang.String separator,
Term t,
int ass) |
void |
LogicPrinter.printPostfix(Term t,
java.lang.String postfix) |
void |
LogicPrinter.printPostfixTerm(Term t,
int ass,
java.lang.String name)
Print a unary term in postfix style.
|
void |
LogicPrinter.printPrefixTerm(java.lang.String name,
Term t,
Term sub,
int ass)
Print a unary term in prefix style.
|
void |
LogicPrinter.printQuantifierTerm(java.lang.String name,
ImmutableArray<QuantifiableVariable> vars,
Term phi,
int ass)
Print a quantified term.
|
protected void |
LogicPrinter.printRewrite(Term t) |
void |
LogicPrinter.printSelect(Term t,
Term tacitHeap) |
void |
LogicPrinter.printSeqGet(Term t) |
void |
LogicPrinter.printSeqSingleton(Term t,
java.lang.String lDelimiter,
java.lang.String rDelimiter) |
void |
LogicPrinter.printSingleton(Term t) |
void |
LogicPrinter.printStore(Term t,
boolean closingBrace) |
void |
LogicPrinter.printSubstTerm(java.lang.String l,
QuantifiableVariable v,
Term t,
int ass2,
java.lang.String r,
Term phi,
int ass3)
Print a substitution term.
|
void |
LogicPrinter.printTerm(Term t)
Pretty-prints a term or formula.
|
void |
LogicPrinter.printTermContinuingBlock(Term t)
Pretty-prints a term or formula in the same block.
|
void |
LogicPrinter.printUpdateApplicationTerm(java.lang.String l,
java.lang.String r,
Term t,
int ass3)
Print a term with an update.
|
void |
Notation.SelectNotation.printWithHeap(Term t,
LogicPrinter sp,
Term heapTerm) |
void |
AbbrevMap.put(Term t,
java.lang.String abbreviation,
boolean enabled)
Associates a Term and its abbreviation in this map.
|
static java.lang.String |
LogicPrinter.quickPrintTerm(Term t,
Services services)
Converts a term to a string.
|
static java.lang.String |
LogicPrinter.quickPrintTerm(Term t,
Services services,
boolean usePrettyPrinting,
boolean useUnicodeSymbols)
Converts a term to a string.
|
void |
AbbrevMap.setEnabled(Term t,
boolean enabled)
Sets the mapping of the term t to its abbreviation enabled or disabled
|
Modifier and Type | Method and Description |
---|---|
void |
LogicPrinter.printTerm(ImmutableSet<Term> terms)
Pretty-prints a set of terms.
|
Constructor and Description |
---|
AbbrevWrapper(Term t) |
Modifier and Type | Field and Description |
---|---|
Term |
PrefixTermTacletAppIndexCacheImpl.CacheKey.analysedTerm |
Modifier and Type | Method and Description |
---|---|
static Term |
OpReplacer.replace(Operator toReplace,
Operator with,
Term in,
TermFactory tf)
Replace an operator.
|
static Term |
OpReplacer.replace(Operator toReplace,
Operator with,
Term in,
TermFactory tf,
Proof proof)
Replace an operator.
|
Term |
OpReplacer.replace(Term term)
Replaces in a term.
|
Term |
ProgVarReplacer.replace(Term t)
replaces in a term
|
static Term |
OpReplacer.replace(Term toReplace,
Term with,
Term in,
TermFactory tf)
Replace a sub-term.
|
static Term |
OpReplacer.replace(Term toReplace,
Term with,
Term in,
TermFactory tf,
Proof proof)
Replace a sub-term.
|
Modifier and Type | Method and Description |
---|---|
ImmutableList<Term> |
OpReplacer.replace(ImmutableList<Term> terms)
Replaces in a list of terms.
|
ImmutableSet<Term> |
OpReplacer.replace(ImmutableSet<Term> terms)
Replaces in a set of terms.
|
java.util.Map<Operator,Term> |
OpReplacer.replace(java.util.Map<Operator,Term> myMap)
Replaces in a map from Operator to Term.
|
static ImmutableList<Term> |
OpReplacer.replace(Term toReplace,
Term with,
ImmutableList<Term> in,
TermFactory tf)
Replace a sub-term.
|
static ImmutableList<Term> |
OpReplacer.replace(Term toReplace,
Term with,
ImmutableList<Term> in,
TermFactory tf,
Proof proof)
Replace a sub-term.
|
Modifier and Type | Method and Description |
---|---|
ITermTacletAppIndexCache |
ITermTacletAppIndexCache.descend(Term t,
int subtermIndex)
Determine the cache that is responsible for locations within the
subtermIndex 'th subterm of the term t
(assuming that this cache is responsible for the location
of the term t ). |
TermTacletAppIndex |
PrefixTermTacletAppIndexCacheImpl.getIndexForTerm(Term t) |
TermTacletAppIndex |
ITermTacletAppIndexCache.getIndexForTerm(Term t) |
void |
PrefixTermTacletAppIndexCacheImpl.putIndexForTerm(Term t,
TermTacletAppIndex index) |
void |
ITermTacletAppIndexCache.putIndexForTerm(Term t,
TermTacletAppIndex index)
Put the taclet app index
index for the term t
in the cache |
static Term |
OpReplacer.replace(Operator toReplace,
Operator with,
Term in,
TermFactory tf)
Replace an operator.
|
static Term |
OpReplacer.replace(Operator toReplace,
Operator with,
Term in,
TermFactory tf,
Proof proof)
Replace an operator.
|
Term |
OpReplacer.replace(Term term)
Replaces in a term.
|
Term |
ProgVarReplacer.replace(Term t)
replaces in a term
|
static ImmutableList<Term> |
OpReplacer.replace(Term toReplace,
Term with,
ImmutableList<Term> in,
TermFactory tf)
Replace a sub-term.
|
static ImmutableList<Term> |
OpReplacer.replace(Term toReplace,
Term with,
ImmutableList<Term> in,
TermFactory tf,
Proof proof)
Replace a sub-term.
|
static Term |
OpReplacer.replace(Term toReplace,
Term with,
Term in,
TermFactory tf)
Replace a sub-term.
|
static Term |
OpReplacer.replace(Term toReplace,
Term with,
Term in,
TermFactory tf,
Proof proof)
Replace a sub-term.
|
void |
TermProgramVariableCollector.visit(Term t)
is called by the execPostOrder-method of a term
|
void |
TermProgramVariableCollectorKeepUpdatesForBreakpointconditions.visit(Term t)
is called by the execPostOrder-method of a term
|
Modifier and Type | Method and Description |
---|---|
ImmutableList<Term> |
OpReplacer.replace(ImmutableList<Term> terms)
Replaces in a list of terms.
|
ImmutableSet<Term> |
OpReplacer.replace(ImmutableSet<Term> terms)
Replaces in a set of terms.
|
java.util.Map<Operator,Term> |
OpReplacer.replace(java.util.Map<Operator,Term> myMap)
Replaces in a map from Operator to Term.
|
static ImmutableList<Term> |
OpReplacer.replace(Term toReplace,
Term with,
ImmutableList<Term> in,
TermFactory tf)
Replace a sub-term.
|
static ImmutableList<Term> |
OpReplacer.replace(Term toReplace,
Term with,
ImmutableList<Term> in,
TermFactory tf,
Proof proof)
Replace a sub-term.
|
Constructor and Description |
---|
CacheKey(PrefixTermTacletAppIndexCacheImpl parent,
Term analysedTerm) |
Proof(java.lang.String name,
Term problem,
java.lang.String header,
InitConfig initConfig) |
Modifier and Type | Method and Description |
---|---|
Term |
DelayedCut.getFormula() |
Modifier and Type | Method and Description |
---|---|
java.lang.String |
ApplicationCheck.check(Node cutNode,
Term cutFormula) |
java.lang.String |
ApplicationCheck.NoNewSymbolsCheck.check(Node cutNode,
Term cutFormula) |
Constructor and Description |
---|
DelayedCut(Proof proof,
Node node,
Term formula,
ImmutableList<Node> subtrees,
int sideOfDecisionPredicate,
RuleApp firstAppliedRuleApp) |
DelayedCutProcessor(Proof proof,
Node node,
Term descisionPredicate,
int mode) |
Modifier and Type | Field and Description |
---|---|
Term |
WellDefinednessPO.Variables.anonHeap |
Term |
ProofObligationVars.exceptionParameter
Exception Variable for the try-catch statement.
|
protected Term |
FunctionalOperationContractPO.mbyAtPre |
protected Term[] |
AbstractPO.poTerms |
Modifier and Type | Field and Description |
---|---|
ImmutableList<Term> |
ProofObligationVars.formalParams
The formal parameters of a method.
|
Modifier and Type | Method and Description |
---|---|
static Term |
AbstractOperationPO.addAdditionalUninterpretedPredicateIfRequired(Services services,
Term term,
ImmutableList<LocationVariable> variablesToProtect,
Term exceptionVar)
This method adds the uninterpreted predicate to the given
Term
if the used ProofOblInput is an instance of AbstractOperationPO
and AbstractOperationPO.isAddUninterpretedPredicate() is true . |
static Term |
AbstractOperationPO.addUninterpretedPredicateIfRequired(Services services,
Term term)
This method adds the uninterpreted predicate to the given
Term
if the used ProofOblInput is an instance of AbstractOperationPO
and AbstractOperationPO.isAddUninterpretedPredicate() is true . |
protected abstract Term |
AbstractOperationPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Builds the frame clause including the modifies clause.
|
protected Term |
FunctionalOperationContractPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Builds the frame clause including the modifies clause.
|
protected Term |
AbstractOperationPO.buildFreePre(ProgramVariable selfVar,
KeYJavaType selfKJT,
ImmutableList<ProgramVariable> paramVars,
java.util.List<LocationVariable> heaps,
Services services)
Builds the "general assumption".
|
protected Term |
AbstractOperationPO.buildProgramTerm(ImmutableList<ProgramVariable> paramVars,
ImmutableList<LocationVariable> formalParamVars,
ProgramVariable selfVar,
ProgramVariable resultVar,
ProgramVariable exceptionVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Term postTerm,
ImmutableList<StatementBlock> sb,
Services services)
Creates the
Term which contains the modality including
the complete program to execute. |
protected Term |
AbstractOperationPO.buildUpdate(ImmutableList<ProgramVariable> paramVars,
ImmutableList<LocationVariable> formalParamVars,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Builds the initial updates.
|
protected Term |
FunctionalOperationContractPO.buildUpdate(ImmutableList<ProgramVariable> paramVars,
ImmutableList<LocationVariable> formalParamVars,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Builds the initial updates.
|
protected Term |
AbstractOperationPO.createUninterpretedPredicate(ImmutableList<LocationVariable> formalParamVars,
Term exceptionVar,
java.lang.String name,
Services services)
|
protected Term |
AbstractOperationPO.ensureUninterpretedPredicateExists(ImmutableList<ProgramVariable> paramVars,
ImmutableList<LocationVariable> formalParamVars,
ProgramVariable exceptionVar,
java.lang.String name,
Services services)
|
protected abstract Term |
AbstractOperationPO.generateMbyAtPreDef(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services) |
protected Term |
FunctionalOperationContractPO.generateMbyAtPreDef(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services) |
protected Term |
AbstractOperationPO.generateParamsOK(ImmutableList<ProgramVariable> paramVars)
Generates the general assumption that all parameter arguments are valid.
|
protected Term |
AbstractOperationPO.generateParamsOK2(ImmutableList<Term> paramVars)
Generates the general assumption that all parameter arguments are valid.
|
protected Term |
AbstractPO.generateSelfCreated(java.util.List<LocationVariable> heaps,
IProgramMethod pm,
ProgramVariable selfVar,
Services services)
Generates the general assumption that self is created.
|
protected Term |
AbstractPO.generateSelfExactType(IProgramMethod pm,
ProgramVariable selfVar,
KeYJavaType selfKJT)
Generates the general assumption which defines the type of self.
|
protected Term |
AbstractPO.generateSelfExactType(IProgramMethod pm,
Term selfVar,
KeYJavaType selfKJT)
Generates the general assumption which defines the type of self.
|
protected Term |
AbstractPO.generateSelfNotNull(IProgramMethod pm,
ProgramVariable selfVar)
Generates the general assumption that self is not null.
|
protected abstract Term |
AbstractOperationPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
protected Term |
FunctionalOperationContractPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
DependencyContractPO.getMbyAtPre() |
Term |
FunctionalBlockContractPO.getMbyAtPre() |
Term |
WellDefinednessPO.getMbyAtPre() |
Term |
ContractPO.getMbyAtPre() |
Term |
FunctionalLoopContractPO.getMbyAtPre() |
Term |
FunctionalOperationContractPO.getMbyAtPre() |
protected abstract Term |
AbstractOperationPO.getPost(java.util.List<LocationVariable> modHeaps,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable exceptionVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Creates the postcondition.
|
protected Term |
FunctionalOperationContractPO.getPost(java.util.List<LocationVariable> modHeaps,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable exceptionVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Creates the postcondition.
|
protected abstract Term |
AbstractOperationPO.getPre(java.util.List<LocationVariable> modHeaps,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Creates the precondition.
|
protected Term |
FunctionalOperationContractPO.getPre(java.util.List<LocationVariable> modHeaps,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Creates the precondition.
|
Term |
AbstractOperationPO.getUninterpretedPredicate()
Returns the used uninterpreted predicate.
|
static Term |
AbstractOperationPO.getUninterpretedPredicate(Proof proof)
Returns the uninterpreted predicate used in the given
Proof if available. |
Term |
POExtension.modifyPostTerm(InitConfig proofConfig,
Services services,
Term postTerm)
Modifies the post condition.
|
protected Term |
AbstractOperationPO.modifyPostTerm(Services proofServices,
Term post)
Modifies the post condition with help of
POExtension.modifyPostTerm(InitConfig, Services, Term) . |
protected Term |
AbstractOperationPO.newAdditionalUninterpretedPredicate(ImmutableList<LocationVariable> formalParamVars,
Term exceptionVar,
java.lang.String name,
Services services)
Creates a new uninterpreted predicate which is added to
AbstractOperationPO.additionalUninterpretedPredicates . |
Modifier and Type | Method and Description |
---|---|
java.util.Set<Term> |
AbstractOperationPO.getAdditionalUninterpretedPredicates()
Returns the available additional uninterpreted predicates.
|
static java.util.Set<Term> |
AbstractOperationPO.getAdditionalUninterpretedPredicates(Proof proof)
Returns the uninterpreted predicate used in the given
Proof if available. |
Modifier and Type | Method and Description |
---|---|
static Term |
AbstractOperationPO.addAdditionalUninterpretedPredicateIfRequired(Services services,
Term term,
ImmutableList<LocationVariable> variablesToProtect,
Term exceptionVar)
This method adds the uninterpreted predicate to the given
Term
if the used ProofOblInput is an instance of AbstractOperationPO
and AbstractOperationPO.isAddUninterpretedPredicate() is true . |
static Term |
AbstractOperationPO.addUninterpretedPredicateIfRequired(Services services,
Term term)
This method adds the uninterpreted predicate to the given
Term
if the used ProofOblInput is an instance of AbstractOperationPO
and AbstractOperationPO.isAddUninterpretedPredicate() is true . |
protected void |
AbstractPO.assignPOTerms(Term... poTerms) |
protected Term |
AbstractOperationPO.buildProgramTerm(ImmutableList<ProgramVariable> paramVars,
ImmutableList<LocationVariable> formalParamVars,
ProgramVariable selfVar,
ProgramVariable resultVar,
ProgramVariable exceptionVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Term postTerm,
ImmutableList<StatementBlock> sb,
Services services)
Creates the
Term which contains the modality including
the complete program to execute. |
protected Proof |
AbstractPO.createProof(java.lang.String proofName,
Term poTerm,
InitConfig proofConfig)
Creates a Proof (helper for getPO()).
|
protected Proof |
AbstractPO.createProofObject(java.lang.String proofName,
java.lang.String proofHeader,
Term poTerm,
InitConfig proofConfig) |
protected Term |
AbstractOperationPO.createUninterpretedPredicate(ImmutableList<LocationVariable> formalParamVars,
Term exceptionVar,
java.lang.String name,
Services services)
|
protected Term |
AbstractPO.generateSelfExactType(IProgramMethod pm,
Term selfVar,
KeYJavaType selfKJT)
Generates the general assumption which defines the type of self.
|
protected abstract Term |
AbstractOperationPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
protected Term |
FunctionalOperationContractPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
POExtension.modifyPostTerm(InitConfig proofConfig,
Services services,
Term postTerm)
Modifies the post condition.
|
protected Term |
AbstractOperationPO.modifyPostTerm(Services proofServices,
Term post)
Modifies the post condition with help of
POExtension.modifyPostTerm(InitConfig, Services, Term) . |
protected Term |
AbstractOperationPO.newAdditionalUninterpretedPredicate(ImmutableList<LocationVariable> formalParamVars,
Term exceptionVar,
java.lang.String name,
Services services)
Creates a new uninterpreted predicate which is added to
AbstractOperationPO.additionalUninterpretedPredicates . |
Modifier and Type | Method and Description |
---|---|
protected abstract Term |
AbstractOperationPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Builds the frame clause including the modifies clause.
|
protected abstract Term |
AbstractOperationPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Builds the frame clause including the modifies clause.
|
protected Term |
FunctionalOperationContractPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Builds the frame clause including the modifies clause.
|
protected Term |
FunctionalOperationContractPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Builds the frame clause including the modifies clause.
|
protected Term |
AbstractOperationPO.generateParamsOK2(ImmutableList<Term> paramVars)
Generates the general assumption that all parameter arguments are valid.
|
protected abstract Term |
AbstractOperationPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
protected Term |
FunctionalOperationContractPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Constructor and Description |
---|
ProofObligationVars(StateVars pre,
StateVars post,
Term exceptionParameter,
ImmutableList<Term> formalParams,
Services services) |
ProofObligationVars(StateVars pre,
StateVars post,
Term exceptionParameter,
ImmutableList<Term> formalParams,
TermBuilder tb) |
Variables(ProgramVariable self,
ProgramVariable result,
ProgramVariable exception,
java.util.Map<LocationVariable,ProgramVariable> atPres,
ImmutableList<ProgramVariable> params,
LocationVariable heap,
Term anonHeap) |
Constructor and Description |
---|
ProofObligationVars(StateVars pre,
StateVars post,
Term exceptionParameter,
ImmutableList<Term> formalParams,
Services services) |
ProofObligationVars(StateVars pre,
StateVars post,
Term exceptionParameter,
ImmutableList<Term> formalParams,
TermBuilder tb) |
Modifier and Type | Method and Description |
---|---|
static Term |
IntermediateProofReplayer.parseTerm(java.lang.String value,
Proof proof)
Parses a given term in String representation.
|
static Term |
IntermediateProofReplayer.parseTerm(java.lang.String value,
Proof proof,
Namespace<QuantifiableVariable> varNS,
Namespace<IProgramVariable> progVarNS,
Namespace<Function> functNS)
Parses a given term in String representation.
|
Modifier and Type | Method and Description |
---|---|
static java.lang.StringBuffer |
OutputStreamProofSaver.printTerm(Term t,
Services serv) |
static java.lang.StringBuffer |
OutputStreamProofSaver.printTerm(Term t,
Services serv,
boolean shortAttrNotation) |
Modifier and Type | Method and Description |
---|---|
Term |
ProspectivePartner.getCommonFormula() |
Term |
ProspectivePartner.getCommonPredicate() |
Term |
PredicateEstimator.Result.getPredicate() |
Term |
ProspectivePartner.getUpdate(int index) |
Modifier and Type | Method and Description |
---|---|
void |
ProspectivePartner.setCommonPredicate(Term commonPredicate) |
Constructor and Description |
---|
ProspectivePartner(Term commonFormula,
Node node1,
SequentFormula formula1,
Term update1,
Node node2,
SequentFormula formula2,
Term update2)
Constructs a new prospective partner object, i.e.
|
Modifier and Type | Method and Description |
---|---|
void |
SpecificationRepository.map(java.util.function.UnaryOperator<Term> op,
Services services)
Applies the specified operator to every contract in this repository.
|
Modifier and Type | Field and Description |
---|---|
Term |
UseOperationContractRule.Instantiation.actualSelf
The actual self term.
|
Term |
AbstractLoopInvariantRule.AnonUpdateData.anonHeap |
Term |
AbstractLoopInvariantRule.AdditionalHeapTerms.anonUpdate |
Term |
AbstractLoopInvariantRule.AnonUpdateData.anonUpdate |
Term |
AbstractLoopInvariantRule.LoopInvariantInformation.anonUpdate
The anonymized update
Term . |
protected Term |
FindTaclet.find
contains the find term
|
Term |
AbstractAuxiliaryContractRule.Instantiation.formula
The update target.
|
Term |
AbstractLoopInvariantRule.AdditionalHeapTerms.frameCondition |
Term |
AbstractLoopInvariantRule.LoopInvariantInformation.frameCondition
The frame condition.
|
Term |
AbstractLoopInvariantRule.LoopInvariantInformation.invTerm
The loop invariant formula.
|
Term |
AbstractLoopInvariantRule.AnonUpdateData.loopHeap |
Term |
AbstractLoopInvariantRule.AnonUpdateData.loopHeapAtPre |
Term |
UseOperationContractRule.Instantiation.progPost
The program post condition term.
|
Term |
AbstractLoopInvariantRule.Instantiation.progPost |
Term |
AbstractLoopInvariantRule.AdditionalHeapTerms.reachableState |
Term |
AbstractLoopInvariantRule.LoopInvariantInformation.reachableState
The reachable state formula.
|
Term |
AbstractAuxiliaryContractRule.Instantiation.self
The self variable.
|
Term |
AbstractLoopInvariantRule.Instantiation.selfTerm |
Term |
UseOperationContractRule.Instantiation.u
The enclosing update term.
|
Term |
AbstractLoopInvariantRule.Instantiation.u |
Term |
AbstractLoopInvariantRule.LoopInvariantInformation.uAnonInv
A formula containing the anonymized update and the loop invariant.
|
Term[] |
AbstractLoopInvariantRule.LoopInvariantInformation.uBeforeLoopDefAnonVariant
An array containing the original update, the "before the loop" update
for reasoning about the variant, the anonymized update, and the
variant update.
|
Term |
AbstractAuxiliaryContractRule.Instantiation.update
The context update.
|
Term |
AbstractLoopInvariantRule.LoopInvariantInformation.variantPO
The proof obligation for the variant.
|
Term |
AbstractLoopInvariantRule.AdditionalHeapTerms.wellFormedAnon |
Term |
AbstractLoopInvariantRule.LoopInvariantInformation.wellFormedAnon
The wellformed formula.
|
Modifier and Type | Field and Description |
---|---|
ImmutableList<Term> |
UseOperationContractRule.Instantiation.actualParams
The actual parameter terms.
|
Modifier and Type | Method and Description |
---|---|
protected static Term |
AbstractLoopInvariantRule.and(TermBuilder tb,
Term t1,
Term t2)
Creates a conjunction of t1 and t2 if both are not null, and returns t2
only if t1 is null.
|
protected static Term |
AbstractBlockContractRule.buildAfterVar(Term varTerm,
java.lang.String suffix,
Services services) |
Term |
AuxiliaryContractBuilders.UpdatesBuilder.buildAnonInUpdate(java.util.Map<LocationVariable,Function> anonymisationHeaps) |
Term |
AuxiliaryContractBuilders.UpdatesBuilder.buildAnonOutUpdate(java.util.Map<LocationVariable,Function> anonymisationHeaps,
java.util.Map<LocationVariable,Term> modifiesClauses) |
Term |
AuxiliaryContractBuilders.UpdatesBuilder.buildAnonOutUpdate(ProgramElement el,
java.util.Map<LocationVariable,Function> anonymisationHeaps,
java.util.Map<LocationVariable,Term> modifiesClauses) |
Term |
AuxiliaryContractBuilders.UpdatesBuilder.buildAnonOutUpdate(ProgramElement el,
java.util.Map<LocationVariable,Function> anonymisationHeaps,
java.util.Map<LocationVariable,Term> modifiesClauses,
java.lang.String prefix) |
Term |
AuxiliaryContractBuilders.UpdatesBuilder.buildAnonOutUpdate(java.util.Set<LocationVariable> vars,
java.util.Map<LocationVariable,Function> anonymisationHeaps,
java.util.Map<LocationVariable,Term> modifiesClauses,
java.lang.String prefix) |
Term |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildAtMostOneFlagSetCondition() |
Term |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildDecreasesCheck() |
Term |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildFrameCondition(java.util.Map<LocationVariable,Term> modifiesClauses) |
Term |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildFreePostcondition() |
Term |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildFreePrecondition() |
protected static Term |
AbstractBlockContractRule.buildInfFlowPostAssumption(ProofObligationVars instVars,
ImmutableList<Term> localOuts,
ImmutableList<Term> localOutsAtPost,
Term baseHeap,
Term applPredTerm,
TermBuilder tb) |
protected static Term |
AbstractBlockContractRule.buildInfFlowPreAssumption(ProofObligationVars instVars,
ImmutableList<Term> localOuts,
ImmutableList<Term> localOutsAtPre,
Term baseHeap,
TermBuilder tb) |
Term |
AuxiliaryContractBuilders.UpdatesBuilder.buildOuterRemembranceUpdate() |
Term |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildPostcondition() |
Term |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildPrecondition() |
Term |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildReachableCondition(ImmutableSet<ProgramVariable> variables) |
Term |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildReachableInCondition(ImmutableSet<ProgramVariable> localInVariables) |
Term |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildReachableOutCondition(ImmutableSet<ProgramVariable> localOutVariables) |
Term |
AuxiliaryContractBuilders.UpdatesBuilder.buildRemembranceUpdate(java.util.List<LocationVariable> heaps) |
Term |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildSelfConditions(java.util.List<LocationVariable> heaps,
IProgramMethod pm,
KeYJavaType selfKJT,
Term self,
Services services)
Builds the assumptions for the
self variable
(self != null & self.created == true & exactInstance(self) ) |
Term |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildWellFormedAnonymisationHeapsCondition(java.util.Map<LocationVariable,Function> anonymisationHeaps) |
Term |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildWellFormedHeapsCondition() |
static Term |
UseOperationContractRule.computeSelf(Term baseHeapTerm,
java.util.Map<LocationVariable,Term> atPres,
LocationVariable baseHeap,
UseOperationContractRule.Instantiation inst,
Term resultTerm,
TermFactory tf)
Returns the correct self term.
|
protected static Term |
AbstractLoopInvariantRule.conjunctFreeInv(Services services,
AbstractLoopInvariantRule.Instantiation inst,
java.util.Map<LocationVariable,Term> atPres,
java.util.List<LocationVariable> heapContext)
Creates a conjunction of all free invariant formulas for the
LocationVariable s in heapContext. |
protected static Term |
AbstractLoopInvariantRule.conjunctInv(Services services,
AbstractLoopInvariantRule.Instantiation inst,
java.util.Map<LocationVariable,Term> atPres,
java.util.List<LocationVariable> heapContext)
Creates a conjunction of all invariant formulas for the
LocationVariable s in heapContext. |
protected static Term |
AbstractLoopInvariantRule.createBeforeLoopUpdate(Services services,
java.util.List<LocationVariable> heapContext,
ImmutableSet<ProgramVariable> localOuts,
java.util.Map<LocationVariable,java.util.Map<Term,Term>> heapToBeforeLoop)
Creates the "...Before_LOOP" update needed for the variant.
|
protected static Term |
AbstractAuxiliaryContractRule.createLocalAnonUpdate(ImmutableSet<ProgramVariable> localOuts,
Services services) |
protected static Term |
AbstractLoopInvariantRule.createLocalAnonUpdate(ImmutableSet<ProgramVariable> localOuts,
Services services)
Creates an update for the anonymization of all
ProgramVariable s
in localOuts. |
Term |
QueryExpand.evaluateQueries(Services services,
Term term,
boolean positiveContext,
boolean allowExpandBelowInstQuantifier)
Apply "evaluate query" to the queries that occur in
term . |
Term |
FindTaclet.find()
returns the find term of the taclet to be matched
|
Term |
LoopInvariantBuiltInRuleApp.getGuard() |
Term |
BlockContractExternalRule.getLastFocusTerm() |
Term |
BlockContractInternalRule.getLastFocusTerm() |
Term |
LoopContractExternalRule.getLastFocusTerm() |
abstract Term |
AbstractAuxiliaryContractRule.getLastFocusTerm() |
Term |
LoopContractInternalRule.getLastFocusTerm() |
Term |
Taclet.TacletLabelHint.getTerm()
Returns the optional replace
Term of the taclet. |
Term |
LightweightSyntacticalReplaceVisitor.getTerm()
delivers the new built term
|
Term |
SyntacticalReplaceVisitor.getTerm()
delivers the new built term
|
Term |
Trigger.getTerm() |
protected static <T> Term |
AbstractLoopInvariantRule.mapAndConjunct(Services services,
java.util.function.Function<T,Term> fct,
java.util.List<T> listOfT)
Creates a conjunction of
Term s that are produced by fct from the
elements in listOfT. |
Term |
LoopInvariantBuiltInRuleApp.programTerm() |
Term |
ContractRuleApp.programTerm() |
protected Term |
QueryExpand.replace(Term term,
Term with,
java.util.Iterator<java.lang.Integer> it,
TermServices services)
Replaces in a term.
|
Term |
AuxiliaryContractBuilders.GoalsConfigurator.setUpLoopValidityGoal(Goal goal,
LoopContract contract,
Term context,
Term remember,
Term rememberNext,
java.util.Map<LocationVariable,Function> anonOutHeaps,
java.util.Map<LocationVariable,Term> modifiesClauses,
Term[] assumptions,
Term decreasesCheck,
Term[] postconditions,
Term[] postconditionsNext,
ProgramVariable exceptionParameter,
AuxiliaryContract.Terms terms,
AuxiliaryContract.Variables nextVars) |
Term |
AuxiliaryContractBuilders.GoalsConfigurator.setUpValidityGoal(Goal goal,
Term[] updates,
Term[] assumptions,
Term[] postconditions,
ProgramVariable exceptionParameter,
AuxiliaryContract.Terms terms) |
Term |
AuxiliaryContractBuilders.GoalsConfigurator.setUpWdGoal(Goal goal,
BlockContract contract,
Term update,
Term anonUpdate,
LocationVariable heap,
Function anonHeap,
ImmutableSet<ProgramVariable> localIns) |
protected Term |
LightweightSyntacticalReplaceVisitor.toTerm(Term o)
the method is only still invoked to allow the
ConstraintAwareSyntacticalReplaceVisitor to recursively replace
meta variables |
protected Term |
SyntacticalReplaceVisitor.toTerm(Term o)
the method is only still invoked to allow the
ConstraintAwareSyntacticalReplaceVisitor
to recursively replace meta variables |
Modifier and Type | Method and Description |
---|---|
protected static ImmutableList<Term> |
AbstractBlockContractRule.buildLocalOutsAtPost(ImmutableList<Term> varTerms,
Services services) |
protected static ImmutableList<Term> |
AbstractBlockContractRule.buildLocalOutsAtPre(ImmutableList<Term> varTerms,
Services services) |
java.util.Map<LocationVariable,Term> |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildModifiesClauses() |
static ImmutableList<Term> |
UseOperationContractRule.computeParams(Term baseHeapTerm,
java.util.Map<LocationVariable,Term> atPres,
LocationVariable baseHeap,
UseOperationContractRule.Instantiation inst,
TermFactory tf)
Returns the correct parameter terms.
|
ImmutableList<Term> |
Trigger.getAvoidConditions() |
java.util.Deque<Term> |
Taclet.TacletLabelHint.getTacletTermStack()
Returns the stack maintained during application of a taclet
Term . |
protected static Pair<Term,Term> |
AbstractLoopInvariantRule.prepareVariant(AbstractLoopInvariantRule.Instantiation inst,
Term variant,
TermServices services)
Creates the variant proof obligation and update.
|
protected static Pair<Term,Term> |
AbstractLoopInvariantRule.prepareVariant(AbstractLoopInvariantRule.Instantiation inst,
Term variant,
TermServices services)
Creates the variant proof obligation and update.
|
Pair<Term,Term> |
QueryExpand.queryEvalTerm(Services services,
Term query,
LogicVariable[] instVars)
Creates an invocation of a query in a modal operator and stores the value in a
new symbol.
|
Pair<Term,Term> |
QueryExpand.queryEvalTerm(Services services,
Term query,
LogicVariable[] instVars)
Creates an invocation of a query in a modal operator and stores the value in a
new symbol.
|
protected static Pair<Term,Term> |
AbstractLoopInvariantRule.splitUpdates(Term focusTerm,
TermServices services)
Splits a term into the update and formula part.
|
protected static Pair<Term,Term> |
AbstractLoopInvariantRule.splitUpdates(Term focusTerm,
TermServices services)
Splits a term into the update and formula part.
|
Modifier and Type | Method and Description |
---|---|
TacletApp |
TacletApp.addCheckedInstantiation(SchemaVariable sv,
Term term,
Services services,
boolean interesting)
creates a new Tacletapp where the SchemaVariable sv is instantiated with
the the given Term term.
|
TacletApp |
NoPosTacletApp.addInstantiation(SchemaVariable sv,
Term term,
boolean interesting,
Services services)
adds a new instantiation to this TacletApp
|
TacletApp |
PosTacletApp.addInstantiation(SchemaVariable sv,
Term term,
boolean interesting,
Services services)
adds a new instantiation to this TacletApp
|
abstract TacletApp |
TacletApp.addInstantiation(SchemaVariable sv,
Term term,
boolean interesting,
Services services)
adds a new instantiation to this TacletApp
|
void |
BoundUniquenessChecker.addTerm(Term term)
adds term to the list of terms to include in
the uniqueness check
|
protected static Term |
AbstractLoopInvariantRule.and(TermBuilder tb,
Term t1,
Term t2)
Creates a conjunction of t1 and t2 if both are not null, and returns t2
only if t1 is null.
|
protected static Term |
AbstractBlockContractRule.buildAfterVar(Term varTerm,
java.lang.String suffix,
Services services) |
protected static Term |
AbstractBlockContractRule.buildInfFlowPostAssumption(ProofObligationVars instVars,
ImmutableList<Term> localOuts,
ImmutableList<Term> localOutsAtPost,
Term baseHeap,
Term applPredTerm,
TermBuilder tb) |
protected static Term |
AbstractBlockContractRule.buildInfFlowPreAssumption(ProofObligationVars instVars,
ImmutableList<Term> localOuts,
ImmutableList<Term> localOutsAtPre,
Term baseHeap,
TermBuilder tb) |
Term |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildSelfConditions(java.util.List<LocationVariable> heaps,
IProgramMethod pm,
KeYJavaType selfKJT,
Term self,
Services services)
Builds the assumptions for the
self variable
(self != null & self.created == true & exactInstance(self) ) |
static UseOperationContractRule.Instantiation |
UseOperationContractRule.computeInstantiation(Term focusTerm,
Services services)
Computes instantiation for contract rule on passed focus term.
|
static ImmutableList<Term> |
UseOperationContractRule.computeParams(Term baseHeapTerm,
java.util.Map<LocationVariable,Term> atPres,
LocationVariable baseHeap,
UseOperationContractRule.Instantiation inst,
TermFactory tf)
Returns the correct parameter terms.
|
static Term |
UseOperationContractRule.computeSelf(Term baseHeapTerm,
java.util.Map<LocationVariable,Term> atPres,
LocationVariable baseHeap,
UseOperationContractRule.Instantiation inst,
Term resultTerm,
TermFactory tf)
Returns the correct self term.
|
AuxiliaryContract.Variables |
AuxiliaryContractBuilders.VariablesCreatorAndRegistrar.createAndRegister(Term self,
boolean existingPO) |
AuxiliaryContract.Variables |
AuxiliaryContractBuilders.VariablesCreatorAndRegistrar.createAndRegister(Term self,
boolean existingPO,
ProgramElement pe) |
protected static AbstractLoopInvariantRule.AnonUpdateData |
AbstractLoopInvariantRule.createAnonUpdate(LocationVariable heap,
Term mod,
LoopSpecification inv,
Services services)
Computes the anonymizing update, the loop heap, the base heap, and the
anonymized heap.
|
Term |
QueryExpand.evaluateQueries(Services services,
Term term,
boolean positiveContext,
boolean allowExpandBelowInstQuantifier)
Apply "evaluate query" to the queries that occur in
term . |
java.lang.Long |
QueryExpand.getTimeOfQuery(Term t) |
AbstractAuxiliaryContractRule.Instantiation |
AbstractBlockContractRule.instantiate(Term formula,
Goal goal,
Services services) |
AbstractAuxiliaryContractRule.Instantiation |
AbstractLoopContractRule.instantiate(Term formula,
Goal goal,
Services services) |
static boolean |
UseDependencyContractRule.isBaseOcc(Term focus,
Term candidate) |
protected static boolean |
AbstractLoopInvariantRule.isModalityTerm(Term progPost)
Checks whether progPost contains a Java program.
|
NoPosTacletApp |
NoPosTacletApp.matchFind(PosInOccurrence pos,
Services services,
Term t) |
MatchConditions |
TacletMatcher.matchFind(Term term,
MatchConditions matchCond,
Services services)
matches the given term against the taclet's find term
if the taclet has no find term or the match is unsuccessful
null
is returned |
IfMatchResult |
TacletMatcher.matchIf(ImmutableList<IfFormulaInstantiation> p_toMatch,
Term p_template,
MatchConditions p_matchCond,
Services p_services)
Match the given template (which is probably a formula of the if
sequence) against a list of constraint formulas (probably the
formulas of the antecedent or the succedent), starting with the
given instantiations and constraint p_matchCond.
|
MatchConditions |
TacletMatcher.matchSV(SchemaVariable sv,
Term term,
MatchConditions matchCond,
Services services)
|
protected static Pair<Term,Term> |
AbstractLoopInvariantRule.prepareVariant(AbstractLoopInvariantRule.Instantiation inst,
Term variant,
TermServices services)
Creates the variant proof obligation and update.
|
Pair<Term,Term> |
QueryExpand.queryEvalTerm(Services services,
Term query,
LogicVariable[] instVars)
Creates an invocation of a query in a modal operator and stores the value in a
new symbol.
|
protected Term |
QueryExpand.replace(Term term,
Term with,
java.util.Iterator<java.lang.Integer> it,
TermServices services)
Replaces in a term.
|
void |
LoopInvariantBuiltInRuleApp.setGuard(Term guard) |
protected void |
BlockContractExternalRule.setLastFocusTerm(Term lastFocusTerm) |
protected void |
BlockContractInternalRule.setLastFocusTerm(Term lastFocusTerm) |
protected void |
LoopContractExternalRule.setLastFocusTerm(Term lastFocusTerm) |
protected abstract void |
AbstractAuxiliaryContractRule.setLastFocusTerm(Term formula) |
protected void |
LoopContractInternalRule.setLastFocusTerm(Term lastFocusTerm) |
protected void |
AbstractBlockContractRule.setUpInfFlowPartOfUsageGoal(Goal usageGoal,
AbstractBlockContractRule.InfFlowValidityData infFlowValitidyData,
Term contextUpdate,
Term remembranceUpdate,
Term anonymisationUpdate,
TermBuilder tb) |
Term |
AuxiliaryContractBuilders.GoalsConfigurator.setUpLoopValidityGoal(Goal goal,
LoopContract contract,
Term context,
Term remember,
Term rememberNext,
java.util.Map<LocationVariable,Function> anonOutHeaps,
java.util.Map<LocationVariable,Term> modifiesClauses,
Term[] assumptions,
Term decreasesCheck,
Term[] postconditions,
Term[] postconditionsNext,
ProgramVariable exceptionParameter,
AuxiliaryContract.Terms terms,
AuxiliaryContract.Variables nextVars) |
Term |
AuxiliaryContractBuilders.GoalsConfigurator.setUpLoopValidityGoal(Goal goal,
LoopContract contract,
Term context,
Term remember,
Term rememberNext,
java.util.Map<LocationVariable,Function> anonOutHeaps,
java.util.Map<LocationVariable,Term> modifiesClauses,
Term[] assumptions,
Term decreasesCheck,
Term[] postconditions,
Term[] postconditionsNext,
ProgramVariable exceptionParameter,
AuxiliaryContract.Terms terms,
AuxiliaryContract.Variables nextVars) |
Term |
AuxiliaryContractBuilders.GoalsConfigurator.setUpLoopValidityGoal(Goal goal,
LoopContract contract,
Term context,
Term remember,
Term rememberNext,
java.util.Map<LocationVariable,Function> anonOutHeaps,
java.util.Map<LocationVariable,Term> modifiesClauses,
Term[] assumptions,
Term decreasesCheck,
Term[] postconditions,
Term[] postconditionsNext,
ProgramVariable exceptionParameter,
AuxiliaryContract.Terms terms,
AuxiliaryContract.Variables nextVars) |
Term |
AuxiliaryContractBuilders.GoalsConfigurator.setUpLoopValidityGoal(Goal goal,
LoopContract contract,
Term context,
Term remember,
Term rememberNext,
java.util.Map<LocationVariable,Function> anonOutHeaps,
java.util.Map<LocationVariable,Term> modifiesClauses,
Term[] assumptions,
Term decreasesCheck,
Term[] postconditions,
Term[] postconditionsNext,
ProgramVariable exceptionParameter,
AuxiliaryContract.Terms terms,
AuxiliaryContract.Variables nextVars) |
void |
AuxiliaryContractBuilders.GoalsConfigurator.setUpPreconditionGoal(Goal goal,
Term update,
Term[] preconditions)
Sets up the precondition goal.
|
void |
AuxiliaryContractBuilders.GoalsConfigurator.setUpPreconditionGoal(Goal goal,
Term update,
Term[] preconditions)
Sets up the precondition goal.
|
void |
AuxiliaryContractBuilders.GoalsConfigurator.setUpUsageGoal(Goal goal,
Term[] updates,
Term[] assumptions)
Sets up the usage goal.
|
void |
AuxiliaryContractBuilders.GoalsConfigurator.setUpUsageGoal(Goal goal,
Term[] updates,
Term[] assumptions)
Sets up the usage goal.
|
Term |
AuxiliaryContractBuilders.GoalsConfigurator.setUpValidityGoal(Goal goal,
Term[] updates,
Term[] assumptions,
Term[] postconditions,
ProgramVariable exceptionParameter,
AuxiliaryContract.Terms terms) |
Term |
AuxiliaryContractBuilders.GoalsConfigurator.setUpValidityGoal(Goal goal,
Term[] updates,
Term[] assumptions,
Term[] postconditions,
ProgramVariable exceptionParameter,
AuxiliaryContract.Terms terms) |
Term |
AuxiliaryContractBuilders.GoalsConfigurator.setUpValidityGoal(Goal goal,
Term[] updates,
Term[] assumptions,
Term[] postconditions,
ProgramVariable exceptionParameter,
AuxiliaryContract.Terms terms) |
Term |
AuxiliaryContractBuilders.GoalsConfigurator.setUpWdGoal(Goal goal,
BlockContract contract,
Term update,
Term anonUpdate,
LocationVariable heap,
Function anonHeap,
ImmutableSet<ProgramVariable> localIns) |
protected static Pair<Term,Term> |
AbstractLoopInvariantRule.splitUpdates(Term focusTerm,
TermServices services)
Splits a term into the update and formula part.
|
void |
LightweightSyntacticalReplaceVisitor.subtreeEntered(Term subtreeRoot)
this method is called in execPreOrder and execPostOrder in class Term
when entering the subtree rooted in the term subtreeRoot.
|
void |
SyntacticalReplaceVisitor.subtreeEntered(Term subtreeRoot)
this method is called in execPreOrder and execPostOrder in class Term
when entering the subtree rooted in the term subtreeRoot.
|
void |
LightweightSyntacticalReplaceVisitor.subtreeLeft(Term subtreeRoot)
this method is called in execPreOrder and execPostOrder in class Term
when leaving the subtree rooted in the term subtreeRoot.
|
void |
SyntacticalReplaceVisitor.subtreeLeft(Term subtreeRoot)
this method is called in execPreOrder and execPostOrder in class Term
when leaving the subtree rooted in the term subtreeRoot.
|
protected Term |
LightweightSyntacticalReplaceVisitor.toTerm(Term o)
the method is only still invoked to allow the
ConstraintAwareSyntacticalReplaceVisitor to recursively replace
meta variables |
protected Term |
SyntacticalReplaceVisitor.toTerm(Term o)
the method is only still invoked to allow the
ConstraintAwareSyntacticalReplaceVisitor
to recursively replace meta variables |
void |
TacletVariableSVCollector.visit(Term t)
visits term t in post order
(
execPostOrder(de.uka.ilkd.key.logic.Visitor) )
and collects all bound schema variables |
void |
TacletSchemaVariableCollector.visit(Term t)
visits the Term in post order
execPostOrder(Visitor) and
collects all found schema variables |
void |
LightweightSyntacticalReplaceVisitor.visit(Term visited)
performs the syntactic replacement of schemavariables with their
instantiations
|
void |
SyntacticalReplaceVisitor.visit(Term visited)
performs the syntactic replacement of schemavariables with their
instantiations
|
void |
SVNameCorrespondenceCollector.visit(Term t)
is called by the execPostOrder-method of a term
|
Modifier and Type | Method and Description |
---|---|
Term |
AuxiliaryContractBuilders.UpdatesBuilder.buildAnonOutUpdate(java.util.Map<LocationVariable,Function> anonymisationHeaps,
java.util.Map<LocationVariable,Term> modifiesClauses) |
Term |
AuxiliaryContractBuilders.UpdatesBuilder.buildAnonOutUpdate(ProgramElement el,
java.util.Map<LocationVariable,Function> anonymisationHeaps,
java.util.Map<LocationVariable,Term> modifiesClauses) |
Term |
AuxiliaryContractBuilders.UpdatesBuilder.buildAnonOutUpdate(ProgramElement el,
java.util.Map<LocationVariable,Function> anonymisationHeaps,
java.util.Map<LocationVariable,Term> modifiesClauses,
java.lang.String prefix) |
Term |
AuxiliaryContractBuilders.UpdatesBuilder.buildAnonOutUpdate(java.util.Set<LocationVariable> vars,
java.util.Map<LocationVariable,Function> anonymisationHeaps,
java.util.Map<LocationVariable,Term> modifiesClauses,
java.lang.String prefix) |
Term |
AuxiliaryContractBuilders.ConditionsAndClausesBuilder.buildFrameCondition(java.util.Map<LocationVariable,Term> modifiesClauses) |
protected static Term |
AbstractBlockContractRule.buildInfFlowPostAssumption(ProofObligationVars instVars,
ImmutableList<Term> localOuts,
ImmutableList<Term> localOutsAtPost,
Term baseHeap,
Term applPredTerm,
TermBuilder tb) |
protected static Term |
AbstractBlockContractRule.buildInfFlowPostAssumption(ProofObligationVars instVars,
ImmutableList<Term> localOuts,
ImmutableList<Term> localOutsAtPost,
Term baseHeap,
Term applPredTerm,
TermBuilder tb) |
protected static Term |
AbstractBlockContractRule.buildInfFlowPreAssumption(ProofObligationVars instVars,
ImmutableList<Term> localOuts,
ImmutableList<Term> localOutsAtPre,
Term baseHeap,
TermBuilder tb) |
protected static Term |
AbstractBlockContractRule.buildInfFlowPreAssumption(ProofObligationVars instVars,
ImmutableList<Term> localOuts,
ImmutableList<Term> localOutsAtPre,
Term baseHeap,
TermBuilder tb) |
protected static ImmutableList<Term> |
AbstractBlockContractRule.buildLocalOutsAtPost(ImmutableList<Term> varTerms,
Services services) |
protected static ImmutableList<Term> |
AbstractBlockContractRule.buildLocalOutsAtPre(ImmutableList<Term> varTerms,
Services services) |
static ImmutableList<Term> |
UseOperationContractRule.computeParams(Term baseHeapTerm,
java.util.Map<LocationVariable,Term> atPres,
LocationVariable baseHeap,
UseOperationContractRule.Instantiation inst,
TermFactory tf)
Returns the correct parameter terms.
|
static Term |
UseOperationContractRule.computeSelf(Term baseHeapTerm,
java.util.Map<LocationVariable,Term> atPres,
LocationVariable baseHeap,
UseOperationContractRule.Instantiation inst,
Term resultTerm,
TermFactory tf)
Returns the correct self term.
|
protected static Term |
AbstractLoopInvariantRule.conjunctFreeInv(Services services,
AbstractLoopInvariantRule.Instantiation inst,
java.util.Map<LocationVariable,Term> atPres,
java.util.List<LocationVariable> heapContext)
Creates a conjunction of all free invariant formulas for the
LocationVariable s in heapContext. |
protected static Term |
AbstractLoopInvariantRule.conjunctInv(Services services,
AbstractLoopInvariantRule.Instantiation inst,
java.util.Map<LocationVariable,Term> atPres,
java.util.List<LocationVariable> heapContext)
Creates a conjunction of all invariant formulas for the
LocationVariable s in heapContext. |
protected static AbstractLoopInvariantRule.AdditionalHeapTerms |
AbstractLoopInvariantRule.createAdditionalHeapTerms(Services services,
AbstractLoopInvariantRule.Instantiation inst,
java.util.List<LocationVariable> heapContext,
ImmutableSet<ProgramVariable> localOuts,
java.util.Map<LocationVariable,java.util.Map<Term,Term>> heapToBeforeLoop,
java.util.Map<LocationVariable,Term> atPres)
Prepare anon update, wellformed formula, frame condition and reachable
state formula.
|
protected static AbstractLoopInvariantRule.AdditionalHeapTerms |
AbstractLoopInvariantRule.createAdditionalHeapTerms(Services services,
AbstractLoopInvariantRule.Instantiation inst,
java.util.List<LocationVariable> heapContext,
ImmutableSet<ProgramVariable> localOuts,
java.util.Map<LocationVariable,java.util.Map<Term,Term>> heapToBeforeLoop,
java.util.Map<LocationVariable,Term> atPres)
Prepare anon update, wellformed formula, frame condition and reachable
state formula.
|
protected static AbstractLoopInvariantRule.AdditionalHeapTerms |
AbstractLoopInvariantRule.createAdditionalHeapTerms(Services services,
AbstractLoopInvariantRule.Instantiation inst,
java.util.List<LocationVariable> heapContext,
ImmutableSet<ProgramVariable> localOuts,
java.util.Map<LocationVariable,java.util.Map<Term,Term>> heapToBeforeLoop,
java.util.Map<LocationVariable,Term> atPres)
Prepare anon update, wellformed formula, frame condition and reachable
state formula.
|
protected static Term |
AbstractLoopInvariantRule.createBeforeLoopUpdate(Services services,
java.util.List<LocationVariable> heapContext,
ImmutableSet<ProgramVariable> localOuts,
java.util.Map<LocationVariable,java.util.Map<Term,Term>> heapToBeforeLoop)
Creates the "...Before_LOOP" update needed for the variant.
|
protected static Term |
AbstractLoopInvariantRule.createBeforeLoopUpdate(Services services,
java.util.List<LocationVariable> heapContext,
ImmutableSet<ProgramVariable> localOuts,
java.util.Map<LocationVariable,java.util.Map<Term,Term>> heapToBeforeLoop)
Creates the "...Before_LOOP" update needed for the variant.
|
protected static <T> Term |
AbstractLoopInvariantRule.mapAndConjunct(Services services,
java.util.function.Function<T,Term> fct,
java.util.List<T> listOfT)
Creates a conjunction of
Term s that are produced by fct from the
elements in listOfT. |
void |
Taclet.TacletLabelHint.setTacletTermStack(java.util.Deque<Term> tacletTermStack)
Sets the stack maintained during application of a taclet
Term . |
Term |
AuxiliaryContractBuilders.GoalsConfigurator.setUpLoopValidityGoal(Goal goal,
LoopContract contract,
Term context,
Term remember,
Term rememberNext,
java.util.Map<LocationVariable,Function> anonOutHeaps,
java.util.Map<LocationVariable,Term> modifiesClauses,
Term[] assumptions,
Term decreasesCheck,
Term[] postconditions,
Term[] postconditionsNext,
ProgramVariable exceptionParameter,
AuxiliaryContract.Terms terms,
AuxiliaryContract.Variables nextVars) |
Constructor and Description |
---|
AdditionalHeapTerms(Term anonUpdate,
Term wellFormedAnon,
Term frameCondition,
Term reachableState,
ImmutableList<AbstractLoopInvariantRule.AnonUpdateData> anonUpdateData) |
AnonUpdateData(Term anonUpdate,
Term loopHeap,
Term loopHeapAtPre,
Term anonHeap) |
AntecTaclet(Name name,
TacletApplPart applPart,
ImmutableList<TacletGoalTemplate> goalTemplates,
ImmutableList<RuleSet> heuristics,
TacletAttributes attrs,
Term find,
boolean ignoreTopLevelUpdates,
ImmutableMap<SchemaVariable,TacletPrefix> prefixMap,
ImmutableSet<Choice> choices,
ImmutableSet<TacletAnnotation> tacletAnnotations)
creates a Schematic Theory Specific Rule (Taclet) with the given
parameters.
|
BoundUniquenessChecker(Term t,
Sequent seq) |
ConditionsAndClausesBuilder(AuxiliaryContract contract,
java.util.List<LocationVariable> heaps,
AuxiliaryContract.Variables variables,
Term self,
Services services) |
FindTaclet(Name name,
TacletApplPart applPart,
ImmutableList<TacletGoalTemplate> goalTemplates,
ImmutableList<RuleSet> ruleSets,
TacletAttributes attrs,
Term find,
ImmutableMap<SchemaVariable,TacletPrefix> prefixMap,
ImmutableSet<Choice> choices,
boolean surviveSymbExec,
ImmutableSet<TacletAnnotation> tacletAnnotations)
creates a FindTaclet
|
FindTaclet(Name name,
TacletApplPart applPart,
ImmutableList<TacletGoalTemplate> goalTemplates,
ImmutableList<RuleSet> ruleSets,
TacletAttributes attrs,
Term find,
ImmutableMap<SchemaVariable,TacletPrefix> prefixMap,
ImmutableSet<Choice> choices,
ImmutableSet<TacletAnnotation> tacletAnnotations)
creates a FindTaclet
|
InfFlowValidityData(Term preAssumption,
Term postAssumption,
Taclet taclet) |
Instantiation(Term u,
Term progPost,
Modality mod,
Expression actualResult,
Term actualSelf,
KeYJavaType staticType,
MethodOrConstructorReference mr,
IProgramMethod pm,
ImmutableList<Term> actualParams,
boolean transaction)
Creates a new instantiation for the contract rule and the given variables.
|
Instantiation(Term update,
Term formula,
Modality modality,
Term self,
JavaStatement statement,
ExecutionContext context) |
Instantiation(Term u,
Term progPost,
While loop,
LoopSpecification inv,
Term selfTerm,
ExecutionContext innermostExecutionContext) |
Instantiator(Term formula,
Goal goal,
Services services) |
Instantiator(Term formula,
Goal goal,
Services services) |
Instantiator(Term formula,
Goal goal,
Services services) |
LoopInvariantInformation(Goal goal,
Services services,
AbstractLoopInvariantRule.Instantiation inst,
LoopInvariantBuiltInRuleApp ruleApp,
ImmutableList<Goal> goals,
TermLabelState termLabelState,
Term invTerm,
Term variantPO,
Term reachableState,
Term anonUpdate,
Term wellFormedAnon,
Term uAnonInv,
Term frameCondition,
Term[] uBeforeLoopDefAnonVariant,
ImmutableList<AbstractLoopInvariantRule.AnonUpdateData> anonUpdateData)
Creates a new
AbstractLoopInvariantRule.LoopInvariantInformation object. |
LoopInvariantInformation(Goal goal,
Services services,
AbstractLoopInvariantRule.Instantiation inst,
LoopInvariantBuiltInRuleApp ruleApp,
ImmutableList<Goal> goals,
TermLabelState termLabelState,
Term invTerm,
Term variantPO,
Term reachableState,
Term anonUpdate,
Term wellFormedAnon,
Term uAnonInv,
Term frameCondition,
Term[] uBeforeLoopDefAnonVariant,
ImmutableList<AbstractLoopInvariantRule.AnonUpdateData> anonUpdateData)
Creates a new
AbstractLoopInvariantRule.LoopInvariantInformation object. |
RewriteTaclet(Name name,
TacletApplPart applPart,
ImmutableList<TacletGoalTemplate> goalTemplates,
ImmutableList<RuleSet> ruleSets,
TacletAttributes attrs,
Term find,
ImmutableMap<SchemaVariable,TacletPrefix> prefixMap,
int p_applicationRestriction,
ImmutableSet<Choice> choices,
boolean surviveSymbExec,
ImmutableSet<TacletAnnotation> tacletAnnotations) |
RewriteTaclet(Name name,
TacletApplPart applPart,
ImmutableList<TacletGoalTemplate> goalTemplates,
ImmutableList<RuleSet> ruleSets,
TacletAttributes attrs,
Term find,
ImmutableMap<SchemaVariable,TacletPrefix> prefixMap,
int p_applicationRestriction,
ImmutableSet<Choice> choices,
ImmutableSet<TacletAnnotation> tacletAnnotations)
creates a Schematic Theory Specific Rule (Taclet) with the given
parameters that represents a rewrite rule.
|
SuccTaclet(Name name,
TacletApplPart applPart,
ImmutableList<TacletGoalTemplate> goalTemplates,
ImmutableList<RuleSet> heuristics,
TacletAttributes attrs,
Term find,
boolean ignoreTopLevelUpdates,
ImmutableMap<SchemaVariable,TacletPrefix> prefixMap,
ImmutableSet<Choice> choices,
ImmutableSet<TacletAnnotation> tacletAnnotations)
creates a Schematic Theory Specific Rule (Taclet) with the given
parameters that works on the succedent.
|
TacletLabelHint(Term term)
Constructor.
|
Trigger(SchemaVariable triggerVar,
Term trigger,
ImmutableList<Term> avoidConditions) |
Constructor and Description |
---|
Instantiation(Term u,
Term progPost,
Modality mod,
Expression actualResult,
Term actualSelf,
KeYJavaType staticType,
MethodOrConstructorReference mr,
IProgramMethod pm,
ImmutableList<Term> actualParams,
boolean transaction)
Creates a new instantiation for the contract rule and the given variables.
|
Trigger(SchemaVariable triggerVar,
Term trigger,
ImmutableList<Term> avoidConditions) |
Constructor and Description |
---|
StoreStmtInCondition(ProgramSV resultVarSV,
Term term) |
StoreTermInCondition(SchemaVariable resultVarSV,
Term term) |
Modifier and Type | Method and Description |
---|---|
protected Term |
TacletExecutor.syntacticalReplace(Term term,
TermLabelState termLabelState,
Taclet.TacletLabelHint labelHint,
PosInOccurrence applicationPosInOccurrence,
MatchConditions mc,
Goal goal,
RuleApp ruleApp,
Services services)
a new term is created by replacing variables of term whose replacement is
found in the given SVInstantiations
|
Modifier and Type | Method and Description |
---|---|
protected Term |
TacletExecutor.syntacticalReplace(Term term,
TermLabelState termLabelState,
Taclet.TacletLabelHint labelHint,
PosInOccurrence applicationPosInOccurrence,
MatchConditions mc,
Goal goal,
RuleApp ruleApp,
Services services)
a new term is created by replacing variables of term whose replacement is
found in the given SVInstantiations
|
Modifier and Type | Method and Description |
---|---|
Term |
SVInstantiations.getTermInstantiation(SchemaVariable sv,
ExecutionContext ec,
Services services)
returns the instantiation of the given SchemaVariable as Term.
|
Term |
SVInstantiations.UpdateLabelPair.getUpdate() |
Modifier and Type | Method and Description |
---|---|
ImmutableMap<SchemaVariable,Term> |
TacletInstantiations.instantiations() |
Modifier and Type | Method and Description |
---|---|
SVInstantiations |
SVInstantiations.add(SchemaVariable sv,
Term subst,
Services services)
adds the given pair to the instantiations.
|
SVInstantiations |
SVInstantiations.addInteresting(SchemaVariable sv,
Term subst,
Services services) |
SVInstantiations |
SVInstantiations.addUpdate(Term update,
ImmutableArray<TermLabel> updateApplicationlabels)
adds an update to the update context
|
SVInstantiations |
SVInstantiations.replace(SchemaVariable sv,
Term term,
Services services)
replaces the given pair in the instantiations.
|
Constructor and Description |
---|
UpdateLabelPair(Term update,
ImmutableArray<TermLabel> updateApplicationlabels) |
Constructor and Description |
---|
TacletInstantiations(Taclet rule,
ImmutableMap<SchemaVariable,Term> instantiations) |
Modifier and Type | Method and Description |
---|---|
boolean |
ChildTermLabelPolicy.addLabel(TermServices services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
Term childTerm,
TermLabel label)
|
TermLabelRefactoring.RefactoringScope |
TermLabelRefactoring.defineRefactoringScope(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm)
Defines if a refactoring is required and if so in which
TermLabelRefactoring.RefactoringScope . |
TermLabelRefactoring.RefactoringScope |
OriginTermLabelRefactoring.defineRefactoringScope(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm) |
TermLabelRefactoring.RefactoringScope |
FormulaTermLabelRefactoring.defineRefactoringScope(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm)
Defines if a refactoring is required and if so in which
TermLabelRefactoring.RefactoringScope . |
TermLabelRefactoring.RefactoringScope |
RemoveInCheckBranchesTermLabelRefactoring.defineRefactoringScope(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm)
Defines if a refactoring is required and if so in which
TermLabelRefactoring.RefactoringScope . |
boolean |
ChildTermLabelPolicy.isRuleApplicationSupported(TermServices services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock)
Decides if the currently active
Rule application is supported or not. |
protected boolean |
StayOnFormulaTermLabelPolicy.isTopLevel(Taclet.TacletLabelHint tacletHint,
Term tacletTerm)
Checks if the given taclet
Term is top level. |
TermLabel |
OriginTermLabelPolicy.keepLabel(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels,
TermLabel label) |
TermLabel |
TermLabelPolicy.keepLabel(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels,
TermLabel label)
|
TermLabel |
PerpetualTermLabelPolicy.keepLabel(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels,
TermLabel label) |
TermLabel |
StayOnOperatorTermLabelPolicy.keepLabel(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels,
TermLabel label)
|
TermLabel |
StayOnFormulaTermLabelPolicy.keepLabel(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels,
TermLabel label)
|
boolean |
TermLabelMerger.mergeLabels(SequentFormula existingSF,
Term existingTerm,
TermLabel existingLabel,
SequentFormula rejectedSF,
Term rejectedTerm,
TermLabel rejectedLabel,
java.util.List<TermLabel> mergedLabels)
Merges the existing and the rejected
TermLabel by updating the merged List . |
boolean |
FormulaTermLabelMerger.mergeLabels(SequentFormula existingSF,
Term existingTerm,
TermLabel existingLabel,
SequentFormula rejectedSF,
Term rejectedTerm,
TermLabel rejectedLabel,
java.util.List<TermLabel> mergedLabels)
Merges the existing and the rejected
TermLabel by updating the merged List . |
protected void |
FormulaTermLabelRefactoring.refactorBewlowUpdates(PosInOccurrence applicationPosInOccurrence,
Term term,
java.util.List<TermLabel> labels)
Refactors the
Term below its update. |
protected void |
FormulaTermLabelRefactoring.refactorInCaseOfNewIdRequired(TermLabelState state,
Goal goal,
Term term,
Services services,
java.util.List<TermLabel> labels)
Refactors in case that the inner most label needs a new ID.
|
void |
TermLabelRefactoring.refactorLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Term term,
java.util.List<TermLabel> labels)
This method is used to refactor the labels of the given
Term . |
void |
OriginTermLabelRefactoring.refactorLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Term term,
java.util.List<TermLabel> labels) |
void |
FormulaTermLabelRefactoring.refactorLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Term term,
java.util.List<TermLabel> labels)
This method is used to refactor the labels of the given
Term . |
void |
RemoveInCheckBranchesTermLabelRefactoring.refactorLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Term term,
java.util.List<TermLabel> labels)
This method is used to refactor the labels of the given
Term . |
protected void |
FormulaTermLabelRefactoring.refactorSequentFormulas(TermLabelState state,
Services services,
Term term,
java.util.List<TermLabel> labels)
Refactors the specified
SequentFormula s. |
protected void |
FormulaTermLabelRefactoring.refactorSpecificationApplication(Term term,
Goal goal,
Services services,
java.util.List<TermLabel> labels,
java.lang.Object hint)
Refactors a specification application.
|
protected void |
FormulaTermLabelRefactoring.refactorSubstitution(Term term,
Term tacletTerm,
java.util.List<TermLabel> labels)
Refactors the given
Term after a substitiution. |
void |
TermLabelUpdate.updateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Term modalityTerm,
Rule rule,
RuleApp ruleApp,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Set<TermLabel> labels)
|
void |
FormulaTermLabelUpdate.updateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Term modalityTerm,
Rule rule,
RuleApp ruleApp,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Set<TermLabel> labels)
|
void |
LoopBodyTermLabelUpdate.updateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Term modalityTerm,
Rule rule,
RuleApp ruleApp,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Set<TermLabel> labels)
|
void |
BlockContractValidityTermLabelUpdate.updateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Term modalityTerm,
Rule rule,
RuleApp ruleApp,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Set<TermLabel> labels)
|
void |
SymbolicExecutionTermLabelUpdate.updateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Term modalityTerm,
Rule rule,
RuleApp ruleApp,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Set<TermLabel> labels)
|
void |
LoopInvariantNormalBehaviorTermLabelUpdate.updateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Term modalityTerm,
Rule rule,
RuleApp ruleApp,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Set<TermLabel> labels)
|
Modifier and Type | Method and Description |
---|---|
boolean |
ChildTermLabelPolicy.addLabel(TermServices services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
Term childTerm,
TermLabel label)
|
protected boolean |
StayOnFormulaTermLabelPolicy.isBelowIfThenElse(java.util.Deque<Term> visitStack)
Checks if the currently treated taclet
Term is a child
of an if-then-else operation. |
boolean |
ChildTermLabelPolicy.isRuleApplicationSupported(TermServices services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock)
Decides if the currently active
Rule application is supported or not. |
TermLabel |
OriginTermLabelPolicy.keepLabel(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels,
TermLabel label) |
TermLabel |
TermLabelPolicy.keepLabel(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels,
TermLabel label)
|
TermLabel |
PerpetualTermLabelPolicy.keepLabel(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels,
TermLabel label) |
TermLabel |
StayOnOperatorTermLabelPolicy.keepLabel(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels,
TermLabel label)
|
TermLabel |
StayOnFormulaTermLabelPolicy.keepLabel(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Rule rule,
Goal goal,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
ImmutableArray<TermLabel> newTermOriginalLabels,
TermLabel label)
|
void |
TermLabelUpdate.updateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Term modalityTerm,
Rule rule,
RuleApp ruleApp,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Set<TermLabel> labels)
|
void |
FormulaTermLabelUpdate.updateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Term modalityTerm,
Rule rule,
RuleApp ruleApp,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Set<TermLabel> labels)
|
void |
LoopBodyTermLabelUpdate.updateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Term modalityTerm,
Rule rule,
RuleApp ruleApp,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Set<TermLabel> labels)
|
void |
BlockContractValidityTermLabelUpdate.updateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Term modalityTerm,
Rule rule,
RuleApp ruleApp,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Set<TermLabel> labels)
|
void |
SymbolicExecutionTermLabelUpdate.updateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Term modalityTerm,
Rule rule,
RuleApp ruleApp,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Set<TermLabel> labels)
|
void |
LoopInvariantNormalBehaviorTermLabelUpdate.updateLabels(TermLabelState state,
Services services,
PosInOccurrence applicationPosInOccurrence,
Term applicationTerm,
Term modalityTerm,
Rule rule,
RuleApp ruleApp,
java.lang.Object hint,
Term tacletTerm,
Operator newTermOp,
ImmutableArray<Term> newTermSubs,
ImmutableArray<QuantifiableVariable> newTermBoundVars,
JavaBlock newTermJavaBlock,
java.util.Set<TermLabel> labels)
|
Modifier and Type | Method and Description |
---|---|
MatchConditions |
LegacyTacletMatcher.matchFind(Term term,
MatchConditions matchCond,
Services services)
matches the given term against the taclet's find term
if the taclet has no find term or the match is unsuccessful
null
is returned |
IfMatchResult |
LegacyTacletMatcher.matchIf(ImmutableList<IfFormulaInstantiation> p_toMatch,
Term p_template,
MatchConditions p_matchCond,
Services p_services)
(non-Javadoc)
|
protected MatchConditions |
LegacyTacletMatcher.matchJavaBlock(Term term,
Term template,
MatchConditions matchCond,
Services services)
returns the matchconditions that are required if the java block of the
given term matches the schema given by the template term or null if no
match is possible
(marked as final to help the compiler inlining methods)
|
MatchConditions |
LegacyTacletMatcher.matchSV(SchemaVariable sv,
Term term,
MatchConditions matchCond,
Services services)
|
Modifier and Type | Method and Description |
---|---|
Term |
TermNavigator.getCurrentSubterm() |
Modifier and Type | Method and Description |
---|---|
static TacletMatchProgram |
TacletMatchProgram.createProgram(Term pattern)
creates a matcher for the given pattern
|
static TermNavigator |
TermNavigator.get(Term term)
returns a pooled
TermNavigator or a new one if the TERM_NAVIGATOR_POOL is currently empty
The used TermNavigator have to be explicitly released by the user via TermNavigator.release() |
MatchConditions |
TacletMatchProgram.match(Term p_toMatch,
MatchConditions p_matchCond,
Services services)
executes the program and tries to match the provided term; additional restrictions are provided via match conditions.
|
MatchConditions |
VMTacletMatcher.matchFind(Term term,
MatchConditions matchCond,
Services services)
matches the given term against the taclet's find term
if the taclet has no find term or the match is unsuccessful
null
is returned |
IfMatchResult |
VMTacletMatcher.matchIf(ImmutableList<IfFormulaInstantiation> p_toMatch,
Term p_template,
MatchConditions p_matchCond,
Services p_services)
(non-Javadoc)
|
MatchConditions |
VMTacletMatcher.matchSV(SchemaVariable sv,
Term term,
MatchConditions matchCond,
Services services)
|
Modifier and Type | Method and Description |
---|---|
protected MatchConditions |
MatchSchemaVariableInstruction.addInstantiation(Term term,
MatchConditions matchCond,
Services services)
Tries to add the pair (this,term) to the match conditions.
|
MatchConditions |
MatchUpdateSVInstruction.match(Term subst,
MatchConditions mc,
Services services)
tries to match the schema variable of this instruction with the specified
Term instantiationCandidate
w.r.t. |
MatchConditions |
MatchProgramSVInstruction.match(Term instantiationCandidate,
MatchConditions matchCond,
Services services)
tries to match the schema variable of this instruction with the specified
Term instantiationCandidate
w.r.t. |
MatchConditions |
MatchFormulaSVInstruction.match(Term subst,
MatchConditions mc,
Services services)
tries to match the schema variable of this instruction with the specified
Term instantiationCandidate
w.r.t. |
MatchConditions |
MatchElementaryUpdateInstruction.match(Term instantiationCandidate,
MatchConditions matchCond,
Services services) |
MatchConditions |
MatchModalOperatorSVInstruction.match(Term subst,
MatchConditions mc,
Services services) |
abstract MatchConditions |
Instruction.match(Term instantiationCandidate,
MatchConditions matchCond,
Services services)
tries to match the schema variable of this instruction with the specified
Term instantiationCandidate
w.r.t. |
MatchConditions |
MatchOpIdentityInstruction.match(Term instantiationCandidate,
MatchConditions matchConditions,
Services services)
tries to match the schema variable of this instruction with the specified
Term instantiationCandidate
w.r.t. |
MatchConditions |
MatchTermSVInstruction.match(Term subst,
MatchConditions mc,
Services services)
tries to match the schema variable of this instruction with the specified
Term instantiationCandidate
w.r.t. |
MatchConditions |
MatchVariableSVInstruction.match(Term subst,
MatchConditions mc,
Services services)
tries to match the schema variable of this instruction with the specified
Term instantiationCandidate
w.r.t. |
MatchConditions |
MatchSortDependingFunctionInstruction.match(Term instantiationCandidate,
MatchConditions matchConditions,
Services services)
Tries to match the top level operator of the given term with this instruction's sort depending function symbol.
|
Modifier and Type | Method and Description |
---|---|
Term |
MergeRuleBuiltInRuleApp.getDistinguishingFormula() |
Term |
MergeProcedure.ValuesMergeResult.getMergeVal() |
Term |
CloseAfterMergeRuleBuiltInRuleApp.getPc() |
Modifier and Type | Method and Description |
---|---|
ImmutableSet<Term> |
MergeProcedure.ValuesMergeResult.getNewConstraints() |
java.util.LinkedHashSet<Term> |
MergeProcedure.ValuesMergeResult.getSideConditions() |
protected Triple<SymbolicExecutionState,java.util.LinkedHashSet<Name>,java.util.LinkedHashSet<Term>> |
MergeRule.mergeStates(MergeProcedure mergeRule,
SymbolicExecutionState state1,
SymbolicExecutionState state2,
Term programCounter,
Term distinguishingFormula,
Services services)
Merges two SE states (U1,C1,p) and (U2,C2,p) according to the method
MergeRule#mergeValuesInStates(LocationVariable, SymbolicExecutionState, Term, SymbolicExecutionState, Term, Services)
. |
Modifier and Type | Method and Description |
---|---|
CloseAfterMergeRuleBuiltInRuleApp |
CloseAfterMerge.createApp(PosInOccurrence pio,
Node thePartnerNode,
Node correspondingMergeNode,
SymbolicExecutionState mergeNodeState,
SymbolicExecutionState partnerState,
Term pc,
java.util.Set<Name> newNames)
Creates a complete CloseAfterMergeBuiltInRuleApp.
|
protected MergeProcedure.ValuesMergeResult |
MergeRule.mergeHeaps(MergeProcedure mergeRule,
LocationVariable heapVar,
Term heap1,
Term heap2,
SymbolicExecutionState state1,
SymbolicExecutionState state2,
Term distinguishingFormula,
Services services)
Merges two heaps in a zip-like procedure.
|
protected Triple<SymbolicExecutionState,java.util.LinkedHashSet<Name>,java.util.LinkedHashSet<Term>> |
MergeRule.mergeStates(MergeProcedure mergeRule,
SymbolicExecutionState state1,
SymbolicExecutionState state2,
Term programCounter,
Term distinguishingFormula,
Services services)
Merges two SE states (U1,C1,p) and (U2,C2,p) according to the method
MergeRule#mergeValuesInStates(LocationVariable, SymbolicExecutionState, Term, SymbolicExecutionState, Term, Services)
. |
abstract MergeProcedure.ValuesMergeResult |
MergeProcedure.mergeValuesInStates(Term v,
SymbolicExecutionState state1,
Term valueInState1,
SymbolicExecutionState state2,
Term valueInState2,
Term distinguishingFormula,
Services services)
Merges two values valueInState1 and valueInState2 of corresponding SE
states state1 and state2 to a new value of a merge state.
|
void |
MergeRuleBuiltInRuleApp.setDistinguishingFormula(Term distForm) |
void |
CloseAfterMergeRuleBuiltInRuleApp.setPc(Term pc) |
Constructor and Description |
---|
CloseAfterMergeRuleBuiltInRuleApp(BuiltInRule builtInRule,
PosInOccurrence pio,
Node thePartnerNode,
Node correspondingMergeNode,
SymbolicExecutionState mergeNodeState,
SymbolicExecutionState partnerState,
Term pc,
java.util.Set<Name> newNames) |
MergeRuleBuiltInRuleApp(BuiltInRule rule,
PosInOccurrence pio,
ImmutableList<PosInOccurrence> ifInsts,
Node mergeNode,
ImmutableList<MergePartner> mergePartners,
MergeProcedure concreteRule,
SymbolicExecutionStateWithProgCnt thisSEState,
ImmutableList<SymbolicExecutionState> mergePartnerStates,
Term distForm,
java.util.ArrayList<MergeRule.MergeRuleProgressListener> progressListeners) |
ValuesMergeResult(ImmutableSet<Term> newConstraints,
Term mergeVal,
java.util.LinkedHashSet<Name> newNames,
java.util.LinkedHashSet<Term> sideConditions) |
Constructor and Description |
---|
ValuesMergeResult(ImmutableSet<Term> newConstraints,
Term mergeVal,
java.util.LinkedHashSet<Name> newNames,
java.util.LinkedHashSet<Term> sideConditions) |
ValuesMergeResult(ImmutableSet<Term> newConstraints,
Term mergeVal,
java.util.LinkedHashSet<Name> newNames,
java.util.LinkedHashSet<Term> sideConditions) |
Modifier and Type | Method and Description |
---|---|
static Term |
MergeByIfThenElse.createIfThenElseTerm(SymbolicExecutionState state1,
SymbolicExecutionState state2,
Term ifTerm,
Term elseTerm,
Term distinguishingFormula,
Services services)
Creates an if-then-else term for the variable v.
|
Modifier and Type | Method and Description |
---|---|
static Term |
MergeByIfThenElse.createIfThenElseTerm(SymbolicExecutionState state1,
SymbolicExecutionState state2,
Term ifTerm,
Term elseTerm,
Term distinguishingFormula,
Services services)
Creates an if-then-else term for the variable v.
|
MergeProcedure.ValuesMergeResult |
MergeWithLatticeAbstraction.mergeValuesInStates(Term v,
SymbolicExecutionState state1,
Term valueInState1,
SymbolicExecutionState state2,
Term valueInState2,
Term distinguishingFormula,
Services services) |
MergeProcedure.ValuesMergeResult |
MergeWithPredicateAbstractionFactory.mergeValuesInStates(Term v,
SymbolicExecutionState state1,
Term valueInState1,
SymbolicExecutionState state2,
Term valueInState2,
Term distinguishingFormula,
Services services) |
MergeProcedure.ValuesMergeResult |
MergeIfThenElseAntecedent.mergeValuesInStates(Term v,
SymbolicExecutionState state1,
Term valueInState1,
SymbolicExecutionState state2,
Term valueInState2,
Term distinguishingFormula,
Services services) |
MergeProcedure.ValuesMergeResult |
MergeTotalWeakening.mergeValuesInStates(Term v,
SymbolicExecutionState state1,
Term valueInState1,
SymbolicExecutionState state2,
Term valueInState2,
Term distinguishingFormula,
Services services) |
MergeProcedure.ValuesMergeResult |
MergeByIfThenElse.mergeValuesInStates(Term v,
SymbolicExecutionState state1,
Term valueInState1,
SymbolicExecutionState state2,
Term valueInState2,
Term distinguishingFormula,
Services services) |
Modifier and Type | Method and Description |
---|---|
Term |
WhileInvariantTransformer.transform(TermLabelState termLabelState,
Rule rule,
RuleApp ruleApp,
Goal goal,
Sequent applicationSequent,
PosInOccurrence applicationPos,
Term initialPost,
Term invariantFramingTermination,
SVInstantiations svInst,
Services services)
calculates the resulting term.
|
Term |
AddCast.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
CreateBeforeLoopUpdate.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
CreateLocalAnonUpdate.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
ConstantValue.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
CreateFrameCond.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
ExpandQueriesMetaConstruct.transform(Term term,
SVInstantiations svInst,
Services services)
term.sub(0) is the term that possibly contains queries.
|
Term |
MemberPVToField.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
CreateWellformedCond.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
EnumConstantValue.transform(Term term,
SVInstantiations svInst,
Services services)
calculates the resulting term.
|
Term |
ArrayBaseInstanceOf.transform(Term term,
SVInstantiations svInst,
Services services)
returns an G::instance(term.sub(1)) term for the element sort of
the given array .
|
Term |
CreateHeapAnonUpdate.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
IntroAtPreDefsOp.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
ObserverEqualityMetaConstruct.transform(Term term,
SVInstantiations svInst,
Services services)
Given two terms termExt and termBase, produce a formula which implies
equality of the two terms.
|
Modifier and Type | Method and Description |
---|---|
Term |
WhileInvariantTransformer.transform(TermLabelState termLabelState,
Rule rule,
RuleApp ruleApp,
Goal goal,
Sequent applicationSequent,
PosInOccurrence applicationPos,
Term initialPost,
Term invariantFramingTermination,
SVInstantiations svInst,
Services services)
calculates the resulting term.
|
Term |
AddCast.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
CreateBeforeLoopUpdate.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
CreateLocalAnonUpdate.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
ConstantValue.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
CreateFrameCond.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
ExpandQueriesMetaConstruct.transform(Term term,
SVInstantiations svInst,
Services services)
term.sub(0) is the term that possibly contains queries.
|
Term |
MemberPVToField.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
CreateWellformedCond.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
EnumConstantValue.transform(Term term,
SVInstantiations svInst,
Services services)
calculates the resulting term.
|
Term |
ArrayBaseInstanceOf.transform(Term term,
SVInstantiations svInst,
Services services)
returns an G::instance(term.sub(1)) term for the element sort of
the given array .
|
Term |
CreateHeapAnonUpdate.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
IntroAtPreDefsOp.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
ObserverEqualityMetaConstruct.transform(Term term,
SVInstantiations svInst,
Services services)
Given two terms termExt and termBase, produce a formula which implies
equality of the two terms.
|
Modifier and Type | Method and Description |
---|---|
Term |
Polynomial.toTerm(Services services)
Creates a term from this polynomial expression.
|
Term |
Monomial.toTerm(Services services) |
Term |
MetaGreater.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
MetaEqual.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
MetaArithBitMaskOp.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
DivideMonomials.transform(Term term,
SVInstantiations svInst,
Services services)
calculates the resulting term.
|
Term |
MetaLeq.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
MetaSub.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
DivideLCRMonomials.transform(Term term,
SVInstantiations svInst,
Services services)
calculates the resulting term.
|
Term |
MetaShift.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
MetaPow.transform(Term term,
SVInstantiations svInst,
Services services)
calculates the resulting term.
|
Term |
MetaDiv.transform(Term term,
SVInstantiations svInst,
Services services)
calculates the resulting term.
|
Term |
MetaLess.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
MetaGeq.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
MetaAdd.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
MetaMul.transform(Term term,
SVInstantiations svInst,
Services services) |
Modifier and Type | Method and Description |
---|---|
ImmutableList<Term> |
Monomial.getParts() |
Modifier and Type | Method and Description |
---|---|
static Polynomial |
Polynomial.create(Term polyTerm,
Services services) |
static Monomial |
Monomial.create(Term monoTerm,
Services services) |
Term |
MetaGreater.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
MetaEqual.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
MetaArithBitMaskOp.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
DivideMonomials.transform(Term term,
SVInstantiations svInst,
Services services)
calculates the resulting term.
|
Term |
MetaLeq.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
MetaSub.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
DivideLCRMonomials.transform(Term term,
SVInstantiations svInst,
Services services)
calculates the resulting term.
|
Term |
MetaShift.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
MetaPow.transform(Term term,
SVInstantiations svInst,
Services services)
calculates the resulting term.
|
Term |
MetaDiv.transform(Term term,
SVInstantiations svInst,
Services services)
calculates the resulting term.
|
Term |
MetaLess.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
MetaGeq.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
MetaAdd.transform(Term term,
SVInstantiations svInst,
Services services) |
Term |
MetaMul.transform(Term term,
SVInstantiations svInst,
Services services) |
Modifier and Type | Field and Description |
---|---|
protected Term |
FindTacletBuilder.find |
Modifier and Type | Method and Description |
---|---|
Term |
FindTacletBuilder.getFind() |
Term |
RewriteTacletGoalTemplate.replaceWith()
a Taclet may replace a Term by another.
|
Modifier and Type | Method and Description |
---|---|
void |
RewriteTacletBuilder.addGoalTerm(Term goalTerm) |
Taclet |
TacletGenerator.generateAxiomTaclet(Name tacletName,
Term originalAxiom,
ImmutableList<ProgramVariable> programVars,
KeYJavaType kjt,
RuleSet ruleSet,
TermServices services)
Returns a no-find taclet to the passed axiom.
|
ImmutableSet<Taclet> |
TacletGenerator.generateContractAxiomTaclets(Name name,
Term originalPre,
Term originalPost,
Term originalMby,
KeYJavaType kjt,
IObserverFunction target,
java.util.List<? extends ProgramVariable> heaps,
ProgramVariable originalSelfVar,
ProgramVariable originalResultVar,
java.util.Map<LocationVariable,ProgramVariable> atPreVars,
ImmutableList<ProgramVariable> originalParamVars,
ImmutableSet<Pair<Sort,IObserverFunction>> toLimit,
boolean satisfiabilityGuard,
TermServices services) |
ImmutableSet<Taclet> |
TacletGenerator.generateFunctionalRepresentsTaclets(Name name,
Term originalPreTerm,
Term originalRepresentsTerm,
KeYJavaType kjt,
IObserverFunction target,
java.util.List<? extends ProgramVariable> heaps,
ProgramVariable self,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,ProgramVariable> atPreVars,
ImmutableSet<Pair<Sort,IObserverFunction>> toLimit,
boolean satisfiability,
Services services) |
ImmutableSet<Taclet> |
TacletGenerator.generatePartialInvTaclet(Name name,
java.util.List<SchemaVariable> heapSVs,
SchemaVariable selfSV,
SchemaVariable eqSV,
Term term,
KeYJavaType kjt,
ImmutableSet<Pair<Sort,IObserverFunction>> toLimit,
boolean isStatic,
boolean eqVersion,
Services services) |
Taclet |
TacletGenerator.generateRelationalRepresentsTaclet(Name tacletName,
Term originalAxiom,
KeYJavaType kjt,
IObserverFunction target,
java.util.List<? extends ProgramVariable> heaps,
ProgramVariable self,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,ProgramVariable> atPreVars,
boolean satisfiabilityGuard,
TermServices services) |
Taclet |
TacletGenerator.generateRewriteTaclet(Name tacletName,
Term originalFind,
Term originalAxiom,
ImmutableList<ProgramVariable> programVars,
RuleSet ruleSet,
TermServices services) |
AntecTacletBuilder |
AntecTacletBuilder.setFind(Term findTerm)
sets the find of the Taclet that is to build to the given
term, if the sort of the given term is of Sort.FORMULA otherwise
nothing happens.
|
SuccTacletBuilder |
SuccTacletBuilder.setFind(Term findTerm)
sets the find of the Taclet that is to build to the given
term, if the sort of the given term is of Sort.FORMULA otherwise
nothing happens.
|
RewriteTacletBuilder<T> |
RewriteTacletBuilder.setFind(Term findTerm)
sets the find of the Taclet that is to build to the given
term.
|
Constructor and Description |
---|
RewriteTacletGoalTemplate(Sequent addedSeq,
ImmutableList<Taclet> addedRules,
Term replacewith) |
RewriteTacletGoalTemplate(Sequent addedSeq,
ImmutableList<Taclet> addedRules,
Term replacewith,
ImmutableSet<SchemaVariable> pvs)
creates new Goaldescription
|
RewriteTacletGoalTemplate(Term replacewith) |
Modifier and Type | Method and Description |
---|---|
Term |
SMTProblem.getTerm()
Returns the term that is related to this problem.
|
static Term |
SMTProblem.sequentToTerm(Sequent s,
Services services) |
Modifier and Type | Method and Description |
---|---|
void |
SMTObjTranslator.ConstantCounter.countConstants(Term t) |
static java.math.BigInteger |
NumberTranslation.translate(Term term)
This methods translates a term with sort "numbers" into a
BigInteger representing the number.
|
protected java.lang.StringBuffer |
AbstractSMTTranslator.translateBprodFunction(Term bprodterm,
java.util.ArrayList<java.lang.StringBuffer> sub)
translate a bprod function.
|
protected java.lang.StringBuffer |
AbstractSMTTranslator.translateBsumFunction(Term bsumterm,
java.util.ArrayList<java.lang.StringBuffer> sub)
translate a bsum function.
|
SMTFile |
SMTObjTranslator.translateProblem(Term problem)
Translates a KeY problem into a SMTFile.
|
SMTTerm |
SMTObjTranslator.translateTerm(Term term)
Translates a KeY term to an SMT term.
|
protected java.lang.StringBuffer |
AbstractSMTTranslator.translateTerm(Term term,
java.util.Vector<QuantifiableVariable> quantifiedVars,
Services services)
Translates the given term into input syntax and adds the resulting
string to the StringBuffer sb.
|
protected java.lang.StringBuffer |
AbstractSMTTranslator.translateUnknown(Term term,
java.util.Vector<QuantifiableVariable> quantifiedVars,
Services services)
Takes care of sequent tree parts that were not matched in
translate(term, skolemization).
|
Constructor and Description |
---|
SMTProblem(Term t) |
Modifier and Type | Method and Description |
---|---|
Term |
SMTTacletTranslator.translate(Taclet taclet) |
Modifier and Type | Method and Description |
---|---|
java.util.Map<Term,SExpr> |
MasterHandler.getUnknownValues() |
Modifier and Type | Method and Description |
---|---|
default SMTHandler.Capability |
SMTHandler.canHandle(Term term)
Query if this handler can translate a term.
|
SMTHandler.Capability |
IntegerOpHandler.canHandle(Term term) |
SExpr |
DefinedSymbolsHandler.handle(MasterHandler trans,
Term term) |
SExpr |
SeqDefHandler.handle(MasterHandler trans,
Term term) |
SExpr |
CastingFunctionsHandler.handle(MasterHandler trans,
Term term) |
SExpr |
QuantifierHandler.handle(MasterHandler trans,
Term term) |
SExpr |
LogicalVariableHandler.handle(MasterHandler trans,
Term term) |
SExpr |
SMTHandler.handle(MasterHandler trans,
Term term)
Translate the given term into an SMT SExpression.
|
SExpr |
BooleanConnectiveHandler.handle(MasterHandler trans,
Term term) |
SExpr |
UninterpretedSymbolsHandler.handle(MasterHandler trans,
Term term) |
SExpr |
PolymorphicHandler.handle(MasterHandler trans,
Term term) |
SExpr |
InstanceOfHandler.handle(MasterHandler trans,
Term term) |
SExpr |
IntegerOpHandler.handle(MasterHandler trans,
Term term) |
SExpr |
FieldConstantHandler.handle(MasterHandler trans,
Term term) |
SExpr |
UpdateHandler.handle(MasterHandler trans,
Term term) |
SExpr |
SumProdHandler.handle(MasterHandler trans,
Term term) |
SExpr |
NumberConstantsHandler.handle(MasterHandler trans,
Term term) |
SExpr |
CastHandler.handle(MasterHandler trans,
Term term) |
SExpr |
MasterHandler.translate(Term problem)
Translate a single term to an SMTLib S-Expression.
|
SExpr |
MasterHandler.translate(Term problem,
SExpr.Type type)
Translate a single term to an SMTLib S-Expression.
|
Modifier and Type | Method and Description |
---|---|
java.util.List<SExpr> |
MasterHandler.translate(java.lang.Iterable<Term> terms)
Translate a list of terms into a list of SExprs without coercion.
|
java.util.List<SExpr> |
MasterHandler.translate(java.lang.Iterable<Term> terms,
SExpr.Type type)
Translate a list of terms into a list of SExprs.
|
Modifier and Type | Field and Description |
---|---|
Term |
AuxiliaryContract.Terms.exception |
protected Term |
AbstractAuxiliaryContractImpl.instantiationSelf |
protected Term |
AbstractAuxiliaryContractImpl.measuredBy |
Term |
WellDefinednessCheck.POTerms.mod |
Term |
AuxiliaryContract.Terms.result |
Term |
AuxiliaryContract.Terms.returnFlag |
Term |
AuxiliaryContract.Terms.self |
Term |
WellDefinednessCheck.TermAndFunc.term |
Modifier and Type | Field and Description |
---|---|
java.util.Map<Label,Term> |
AuxiliaryContract.Terms.breakFlags |
java.util.Map<Label,Term> |
AuxiliaryContract.Terms.continueFlags |
protected java.util.Map<LocationVariable,Term> |
AbstractAuxiliaryContractImpl.freePostconditions |
protected java.util.Map<LocationVariable,Term> |
AbstractAuxiliaryContractImpl.Combinator.freePostconditions |
protected java.util.Map<LocationVariable,Term> |
AbstractAuxiliaryContractImpl.freePreconditions |
protected java.util.Map<LocationVariable,Term> |
AbstractAuxiliaryContractImpl.Combinator.freePreconditions |
protected java.util.Map<LocationVariable,Term> |
AbstractAuxiliaryContractImpl.modifiesClauses |
protected java.util.Map<LocationVariable,Term> |
AbstractAuxiliaryContractImpl.Combinator.modifiesClauses |
java.util.Map<LocationVariable,Term> |
AuxiliaryContract.Terms.outerRemembranceHeaps |
java.util.Map<LocationVariable,Term> |
AuxiliaryContract.Terms.outerRemembranceVariables |
protected java.util.Map<LocationVariable,Term> |
AbstractAuxiliaryContractImpl.postconditions |
protected java.util.Map<LocationVariable,Term> |
AbstractAuxiliaryContractImpl.Combinator.postconditions |
protected java.util.Map<LocationVariable,Term> |
AbstractAuxiliaryContractImpl.preconditions |
protected java.util.Map<LocationVariable,Term> |
AbstractAuxiliaryContractImpl.Combinator.preconditions |
java.util.Map<LocationVariable,Term> |
AuxiliaryContract.Terms.remembranceHeaps |
java.util.Map<LocationVariable,Term> |
AuxiliaryContract.Terms.remembranceLocalVariables |
ImmutableList<Term> |
WellDefinednessCheck.POTerms.rest |
Modifier and Type | Method and Description |
---|---|
Term |
WellDefinednessCheck.getAccessible() |
Term |
FunctionalAuxiliaryContract.getAccessible(ProgramVariable heap) |
Term |
FunctionalOperationContractImpl.getAccessible(ProgramVariable heap) |
Term |
InformationFlowContractImpl.getAccessible(ProgramVariable heap) |
Term |
DependencyContractImpl.getAccessible(ProgramVariable heap) |
Term |
WellDefinednessCheck.getAccessible(ProgramVariable heap) |
Term |
Contract.getAccessible(ProgramVariable heap) |
Term |
FunctionalOperationContractImpl.getAnyMod(Term mod,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services) |
Term |
WellDefinednessCheck.getAssignable() |
Term |
AbstractAuxiliaryContractImpl.getAssignable(LocationVariable heap) |
Term |
FunctionalAuxiliaryContract.getAssignable(LocationVariable heap) |
Term |
FunctionalOperationContractImpl.getAssignable(LocationVariable heap) |
Term |
InformationFlowContractImpl.getAssignable(LocationVariable heap) |
Term |
DependencyContractImpl.getAssignable(LocationVariable heap) |
Term |
WellDefinednessCheck.getAssignable(LocationVariable heap) |
Term |
Contract.getAssignable(LocationVariable heap) |
Term |
AuxiliaryContract.getAssignable(LocationVariable heap) |
Term |
InformationFlowContractImpl.getAtPre() |
Term |
InformationFlowContract.getAtPre() |
Term |
MethodWellDefinedness.getAxiom() |
Term |
ClassWellDefinedness.getAxiom() |
abstract Term |
WellDefinednessCheck.getAxiom()
Only for contracts with model_behaviour, the result is different from null.
|
Term |
StatementWellDefinedness.getAxiom() |
Term |
RepresentsAxiom.getAxiom(ParsableVariable heapVar,
ParsableVariable selfVar,
Services services) |
Term |
InitiallyClauseImpl.getClause(ParsableVariable selfVar,
TermServices services) |
Term |
InitiallyClause.getClause(ParsableVariable selfVar,
TermServices services)
Returns the formula without implicit all-quantification over
the receiver object.
|
Term |
LoopContract.getDecreases() |
Term |
LoopContractImpl.getDecreases() |
Term |
LoopContract.getDecreases(AuxiliaryContract.Variables variables,
Services services) |
Term |
LoopContractImpl.getDecreases(AuxiliaryContract.Variables variables,
Services services) |
Term |
LoopContract.getDecreases(Term heap,
Term self,
Services services) |
Term |
LoopContractImpl.getDecreases(Term heap,
Term self,
Services services) |
Term |
InformationFlowContractImpl.getDep() |
Term |
InformationFlowContract.getDep()
Returns the dependency set of the contract.
|
Term |
FunctionalAuxiliaryContract.getDep(LocationVariable heap,
boolean atPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
FunctionalOperationContractImpl.getDep(LocationVariable heap,
boolean atPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
InformationFlowContractImpl.getDep(LocationVariable heap,
boolean atPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
DependencyContractImpl.getDep(LocationVariable heap,
boolean atPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
WellDefinednessCheck.getDep(LocationVariable heap,
boolean atPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services)
Deprecated.
|
Term |
Contract.getDep(LocationVariable heap,
boolean atPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services)
Returns the dependency set of the contract.
|
Term |
FunctionalAuxiliaryContract.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
InformationFlowContractImpl.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
DependencyContractImpl.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
WellDefinednessCheck.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
Contract.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the dependency set of the contract.
|
Term |
AbstractAuxiliaryContractImpl.getEnsures(LocationVariable heap) |
Term |
FunctionalOperationContractImpl.getEnsures(LocationVariable heap) |
Term |
FunctionalOperationContract.getEnsures(LocationVariable heap) |
Term |
WellDefinednessCheck.getEnsures(LocationVariable heap) |
Term |
AuxiliaryContract.getEnsures(LocationVariable heap) |
Term |
AbstractAuxiliaryContractImpl.getEnsuresFree(LocationVariable heap) |
Term |
AuxiliaryContract.getEnsuresFree(LocationVariable heap) |
Term |
FunctionalOperationContractImpl.getExc() |
Term |
InformationFlowContractImpl.getExc() |
Term |
InformationFlowContract.getExc()
Get the exception-variable which is used in this contract.
|
Term |
FunctionalOperationContract.getExc() |
Term |
LoopSpecification.getFreeInvariant(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the free invariant formula.
|
Term |
LoopSpecImpl.getFreeInvariant(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
LoopSpecification.getFreeInvariant(Services services) |
Term |
LoopSpecImpl.getFreeInvariant(Services services) |
Term |
FunctionalOperationContractImpl.getFreePost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getFreePost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getFreePost(LocationVariable heap,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
FunctionalOperationContract.getFreePost(LocationVariable heap,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
FunctionalOperationContractImpl.getFreePost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getFreePost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getFreePost(Services services) |
Term |
AuxiliaryContract.getFreePost(Services services) |
Term |
AbstractAuxiliaryContractImpl.getFreePostcondition(LocationVariable heap,
AuxiliaryContract.Variables variables,
Services services) |
Term |
AuxiliaryContract.getFreePostcondition(LocationVariable heap,
AuxiliaryContract.Variables variables,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getFreePostcondition(LocationVariable heap,
Services services) |
Term |
AuxiliaryContract.getFreePostcondition(LocationVariable heap,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getFreePostcondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
AuxiliaryContract.getFreePostcondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
InformationFlowContractImpl.getFreePre() |
Term |
InformationFlowContract.getFreePre()
Returns the original free precondition of the contract.
|
Term |
FunctionalOperationContractImpl.getFreePre(java.util.List<LocationVariable> heapContext,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
OperationContract.getFreePre(java.util.List<LocationVariable> heapContext,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
FunctionalOperationContractImpl.getFreePre(LocationVariable heap,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
OperationContract.getFreePre(LocationVariable heap,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
FunctionalOperationContractImpl.getFreePre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
OperationContract.getFreePre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getFreePre(Services services) |
Term |
AuxiliaryContract.getFreePre(Services services) |
Term |
AbstractAuxiliaryContractImpl.getFreePrecondition(LocationVariable heap,
AuxiliaryContract.Variables variables,
Services services) |
Term |
AuxiliaryContract.getFreePrecondition(LocationVariable heap,
AuxiliaryContract.Variables variables,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getFreePrecondition(LocationVariable heap,
ProgramVariable self,
java.util.Map<LocationVariable,LocationVariable> atPres,
Services services) |
Term |
AuxiliaryContract.getFreePrecondition(LocationVariable heap,
ProgramVariable self,
java.util.Map<LocationVariable,LocationVariable> atPres,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getFreePrecondition(LocationVariable heap,
Services services) |
Term |
AuxiliaryContract.getFreePrecondition(LocationVariable heap,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getFreePrecondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
AuxiliaryContract.getFreePrecondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getFreePrecondition(LocationVariable heapVariable,
Term heap,
Term self,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AuxiliaryContract.getFreePrecondition(LocationVariable heapVariable,
Term heap,
Term self,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
MethodWellDefinedness.getGlobalDefs() |
Term |
FunctionalAuxiliaryContract.getGlobalDefs() |
Term |
FunctionalOperationContractImpl.getGlobalDefs() |
Term |
ClassWellDefinedness.getGlobalDefs() |
Term |
InformationFlowContractImpl.getGlobalDefs() |
Term |
DependencyContractImpl.getGlobalDefs() |
Term |
Contract.getGlobalDefs() |
Term |
StatementWellDefinedness.getGlobalDefs() |
Term |
FunctionalAuxiliaryContract.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
FunctionalOperationContractImpl.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
InformationFlowContractImpl.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
DependencyContractImpl.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
WellDefinednessCheck.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services)
Deprecated.
|
Term |
Contract.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getInstantiationSelfTerm() |
Term |
AuxiliaryContract.getInstantiationSelfTerm() |
Term |
AbstractAuxiliaryContractImpl.getInstantiationSelfTerm(TermServices services) |
Term |
AuxiliaryContract.getInstantiationSelfTerm(TermServices services) |
Term |
LoopSpecification.getInternalSelfTerm()
Returns the term internally used for self.
|
Term |
LoopSpecImpl.getInternalSelfTerm() |
Term |
LoopSpecification.getInternalVariant()
Returns the term internally used for the variant.
|
Term |
LoopSpecImpl.getInternalVariant() |
Term |
ClassInvariantImpl.getInv(ParsableVariable selfVar,
TermServices services) |
Term |
ClassInvariant.getInv(ParsableVariable selfVar,
TermServices services)
Returns the invariant formula without implicit all-quantification over
the receiver object.
|
Term |
LoopSpecification.getInvariant(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the invariant formula.
|
Term |
LoopSpecImpl.getInvariant(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
LoopSpecification.getInvariant(Services services) |
Term |
LoopSpecImpl.getInvariant(Services services) |
Term |
AbstractAuxiliaryContractImpl.getMby() |
Term |
FunctionalAuxiliaryContract.getMby() |
Term |
FunctionalOperationContractImpl.getMby() |
Term |
InformationFlowContractImpl.getMby() |
Term |
InformationFlowContract.getMby()
Returns the original measured_by clause of the contract.
|
Term |
FunctionalOperationContract.getMby() |
Term |
DependencyContractImpl.getMby() |
Term |
WellDefinednessCheck.getMby() |
Term |
Contract.getMby() |
Term |
AuxiliaryContract.getMby() |
Term |
AbstractAuxiliaryContractImpl.getMby(AuxiliaryContract.Variables variables,
Services services) |
Term |
AuxiliaryContract.getMby(AuxiliaryContract.Variables variables,
Services services) |
Term |
FunctionalAuxiliaryContract.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
InformationFlowContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
DependencyContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
WellDefinednessCheck.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
Contract.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the measured_by clause of the contract.
|
Term |
AbstractAuxiliaryContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AuxiliaryContract.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalAuxiliaryContract.getMby(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services) |
Term |
FunctionalOperationContractImpl.getMby(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services) |
Term |
InformationFlowContractImpl.getMby(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
Term |
DependencyContractImpl.getMby(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services) |
Term |
WellDefinednessCheck.getMby(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Deprecated.
|
Term |
Contract.getMby(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Returns the measured_by clause of the contract.
|
Term |
AbstractAuxiliaryContractImpl.getMby(ProgramVariable selfVar,
Services services) |
Term |
AuxiliaryContract.getMby(ProgramVariable selfVar,
Services services) |
Term |
FunctionalOperationContractImpl.getMod() |
Term |
InformationFlowContractImpl.getMod() |
Term |
InformationFlowContract.getMod()
Returns the original modifies clause of the contract.
|
Term |
FunctionalOperationContract.getMod() |
Term |
FunctionalOperationContractImpl.getMod(LocationVariable heap,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services) |
Term |
OperationContract.getMod(LocationVariable heapVar,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Returns the modifies clause of the contract.
|
Term |
FunctionalOperationContractImpl.getMod(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
OperationContract.getMod(LocationVariable heapVar,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services)
Returns the modifies clause of the contract.
|
Term |
AbstractAuxiliaryContractImpl.getMod(Services services) |
Term |
AuxiliaryContract.getMod(Services services) |
Term |
LoopSpecification.getModifies() |
Term |
LoopSpecImpl.getModifies() |
Term |
LoopSpecification.getModifies(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the modifies clause.
|
Term |
LoopSpecImpl.getModifies(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
LoopSpecification.getModifies(Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the modifies clause.
|
Term |
LoopSpecImpl.getModifies(Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getModifiesClause(LocationVariable heap,
AuxiliaryContract.Variables variables,
Services services) |
Term |
AuxiliaryContract.getModifiesClause(LocationVariable heap,
AuxiliaryContract.Variables variables,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getModifiesClause(LocationVariable heap,
ProgramVariable self,
Services services) |
Term |
AuxiliaryContract.getModifiesClause(LocationVariable heap,
ProgramVariable self,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getModifiesClause(LocationVariable heap,
Services services) |
Term |
AuxiliaryContract.getModifiesClause(LocationVariable heap,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getModifiesClause(LocationVariable heapVariable,
Term heap,
Term self,
Services services) |
Term |
AuxiliaryContract.getModifiesClause(LocationVariable heapVariable,
Term heap,
Term self,
Services services) |
Term |
ClassInvariantImpl.getOriginalInv() |
Term |
ClassInvariant.getOriginalInv()
Returns the invariant formula without implicit all-quantification over
the receiver object.
|
Term |
FunctionalOperationContractImpl.getPost() |
Term |
FunctionalOperationContract.getPost() |
Term |
FunctionalOperationContractImpl.getPost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getPost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPost(java.util.List<LocationVariable> heapContext,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
FunctionalOperationContract.getPost(java.util.List<LocationVariable> heapContext,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
FunctionalOperationContractImpl.getPost(LocationVariable heap,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
FunctionalOperationContract.getPost(LocationVariable heap,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services)
Returns the postcondition of the contract.
|
Term |
FunctionalOperationContractImpl.getPost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getPost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the postcondition of the contract.
|
Term |
AbstractAuxiliaryContractImpl.getPost(Services services) |
Term |
AuxiliaryContract.getPost(Services services) |
Term |
WellDefinednessCheck.getPost(de.uka.ilkd.key.speclang.WellDefinednessCheck.Condition post,
ParsableVariable result,
TermServices services)
Gets the full valid post-condition
|
Term |
AbstractAuxiliaryContractImpl.getPostcondition(LocationVariable heap,
AuxiliaryContract.Variables variables,
Services services) |
Term |
AuxiliaryContract.getPostcondition(LocationVariable heap,
AuxiliaryContract.Variables variables,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getPostcondition(LocationVariable heap,
Services services) |
Term |
AuxiliaryContract.getPostcondition(LocationVariable heap,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getPostcondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
AuxiliaryContract.getPostcondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
FunctionalOperationContractImpl.getPre() |
Term |
InformationFlowContractImpl.getPre() |
Term |
InformationFlowContract.getPre()
Returns the original precondition of the contract.
|
Term |
FunctionalOperationContract.getPre() |
Term |
FunctionalAuxiliaryContract.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
InformationFlowContractImpl.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
DependencyContractImpl.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
WellDefinednessCheck.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
Contract.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the precondition of the contract.
|
Term |
FunctionalAuxiliaryContract.getPre(java.util.List<LocationVariable> heapContext,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
FunctionalOperationContractImpl.getPre(java.util.List<LocationVariable> heapContext,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
InformationFlowContractImpl.getPre(java.util.List<LocationVariable> heapContext,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services)
Deprecated.
|
Term |
DependencyContractImpl.getPre(java.util.List<LocationVariable> heapContext,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
WellDefinednessCheck.getPre(java.util.List<LocationVariable> heapContext,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services)
Deprecated.
|
Term |
Contract.getPre(java.util.List<LocationVariable> heapContext,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services)
Returns the precondition of the contract.
|
Term |
FunctionalAuxiliaryContract.getPre(LocationVariable heap,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
FunctionalOperationContractImpl.getPre(LocationVariable heap,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
InformationFlowContractImpl.getPre(LocationVariable heap,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services)
Deprecated.
|
Term |
DependencyContractImpl.getPre(LocationVariable heap,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
WellDefinednessCheck.getPre(LocationVariable heap,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services)
Deprecated.
|
Term |
Contract.getPre(LocationVariable heap,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services)
Returns the precondition of the contract.
|
Term |
FunctionalAuxiliaryContract.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
InformationFlowContractImpl.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
DependencyContractImpl.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
WellDefinednessCheck.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
Contract.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the precondition of the contract.
|
Term |
AbstractAuxiliaryContractImpl.getPre(Services services) |
Term |
AuxiliaryContract.getPre(Services services) |
Term |
AbstractAuxiliaryContractImpl.getPrecondition(LocationVariable heap,
AuxiliaryContract.Variables variables,
Services services) |
Term |
AuxiliaryContract.getPrecondition(LocationVariable heap,
AuxiliaryContract.Variables variables,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getPrecondition(LocationVariable heap,
ProgramVariable self,
java.util.Map<LocationVariable,LocationVariable> atPres,
Services services) |
Term |
AuxiliaryContract.getPrecondition(LocationVariable heap,
ProgramVariable self,
java.util.Map<LocationVariable,LocationVariable> atPres,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getPrecondition(LocationVariable heap,
Services services) |
Term |
AuxiliaryContract.getPrecondition(LocationVariable heap,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getPrecondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
AuxiliaryContract.getPrecondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getPrecondition(LocationVariable heapVariable,
Term heap,
Term self,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AuxiliaryContract.getPrecondition(LocationVariable heapVariable,
Term heap,
Term self,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
WellDefinednessCheck.getRepresents() |
Term |
FunctionalOperationContractImpl.getRepresentsAxiom(LocationVariable heap,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services) |
Term |
FunctionalOperationContract.getRepresentsAxiom(LocationVariable heap,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Services services)
Returns the model method definition for model method contracts
|
Term |
FunctionalOperationContractImpl.getRepresentsAxiom(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getRepresentsAxiom(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getRequires(LocationVariable heap) |
Term |
FunctionalAuxiliaryContract.getRequires(LocationVariable heap) |
Term |
FunctionalOperationContractImpl.getRequires(LocationVariable heap) |
Term |
InformationFlowContractImpl.getRequires(LocationVariable heap) |
Term |
DependencyContractImpl.getRequires(LocationVariable heap) |
Term |
WellDefinednessCheck.getRequires(LocationVariable heap) |
Term |
Contract.getRequires(LocationVariable heap) |
Term |
AuxiliaryContract.getRequires(LocationVariable heap) |
Term |
AbstractAuxiliaryContractImpl.getRequiresFree(LocationVariable heap) |
Term |
AuxiliaryContract.getRequiresFree(LocationVariable heap) |
Term |
FunctionalOperationContractImpl.getResult() |
Term |
InformationFlowContractImpl.getResult() |
Term |
InformationFlowContract.getResult()
Get the result-variable which is used in this contract.
|
Term |
FunctionalOperationContract.getResult() |
Term |
FunctionalOperationContractImpl.getSelf() |
Term |
InformationFlowContractImpl.getSelf() |
Term |
InformationFlowContract.getSelf()
Get the self-variable which is used in this contract.
|
Term |
FunctionalOperationContract.getSelf() |
Term |
AbstractAuxiliaryContractImpl.getTerm(Term term,
AuxiliaryContract.Variables variables,
Services services)
Replaces variables in a map of terms
|
Term |
AbstractAuxiliaryContractImpl.getTerm(Term term,
Term heap,
AuxiliaryContract.Terms terms,
Services services)
Replaces variables in a map of terms
|
Term |
WellDefinednessCheck.getUpdates(Term mod,
LocationVariable heap,
ProgramVariable heapAtPre,
Term anonHeap,
TermServices services)
Gets the necessary updates applicable to the post-condition
|
Term |
LoopSpecification.getVariant(Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the variant term.
|
Term |
LoopSpecImpl.getVariant(Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
WellDefinednessCheck.replace(Term t,
WellDefinednessPO.Variables vars) |
Modifier and Type | Method and Description |
---|---|
protected java.util.Map<LocationVariable,Term> |
AbstractAuxiliaryContractImpl.Creator.buildFreePostconditions() |
protected java.util.Map<LocationVariable,Term> |
AbstractAuxiliaryContractImpl.Creator.buildFreePreconditions() |
protected java.util.Map<LocationVariable,Term> |
AbstractAuxiliaryContractImpl.Creator.buildPostconditions() |
protected java.util.Map<LocationVariable,Term> |
AbstractAuxiliaryContractImpl.Creator.buildPreconditions() |
protected java.util.Map<LocationVariable,Term> |
LoopContractImpl.Creator.buildPreconditions() |
protected java.util.Map<Term,Term> |
AbstractAuxiliaryContractImpl.createReplacementMap(Term newHeap,
AuxiliaryContract.Terms newTerms,
Services services) |
protected java.util.Map<Term,Term> |
AbstractAuxiliaryContractImpl.createReplacementMap(Term newHeap,
AuxiliaryContract.Terms newTerms,
Services services) |
java.util.Map<LocationVariable,Term> |
PredicateAbstractionMergeContract.getAtPres() |
static java.util.Map<LocationVariable,Term> |
HeapContext.getAtPres(java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services) |
java.util.Map<LocationVariable,Term> |
LoopSpecification.getInternalAtPres()
Returns operators internally used for the pre-heap.
|
java.util.Map<LocationVariable,Term> |
LoopSpecImpl.getInternalAtPres() |
java.util.Map<LocationVariable,Term> |
LoopSpecification.getInternalFreeInvariants()
Returns the term internally used for the "free" invariant.
|
java.util.Map<LocationVariable,Term> |
LoopSpecImpl.getInternalFreeInvariants() |
java.util.Map<LocationVariable,Term> |
LoopSpecification.getInternalInvariants()
Returns the term internally used for the invariant.
|
java.util.Map<LocationVariable,Term> |
LoopSpecImpl.getInternalInvariants() |
java.util.Map<LocationVariable,Term> |
LoopSpecification.getInternalModifies()
Returns the term internally used for the modifies clause.
|
java.util.Map<LocationVariable,Term> |
LoopSpecImpl.getInternalModifies() |
ImmutableList<Term> |
FunctionalOperationContractImpl.getParams() |
ImmutableList<Term> |
InformationFlowContractImpl.getParams() |
ImmutableList<Term> |
InformationFlowContract.getParams()
Get the parameter-variables which is used in this contract.
|
ImmutableList<Term> |
FunctionalOperationContract.getParams() |
protected java.util.Map<Term,Term> |
FunctionalOperationContractImpl.getReplaceMap(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services)
Deprecated.
|
protected java.util.Map<Term,Term> |
FunctionalOperationContractImpl.getReplaceMap(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services)
Deprecated.
|
protected java.util.Map<Term,Term> |
FunctionalOperationContractImpl.getReplaceMap(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
Term atPre,
Services services)
Deprecated.
|
protected java.util.Map<Term,Term> |
FunctionalOperationContractImpl.getReplaceMap(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
Term atPre,
Services services)
Deprecated.
|
protected java.util.Map<Term,Term> |
FunctionalOperationContractImpl.getReplaceMap(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Get the according replace map for the given variable terms.
|
protected java.util.Map<Term,Term> |
FunctionalOperationContractImpl.getReplaceMap(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Get the according replace map for the given variable terms.
|
Modifier and Type | Method and Description |
---|---|
FunctionalOperationContract |
ContractFactory.addGlobalDefs(FunctionalOperationContract opc,
Term globalDefs)
Add global variable definitions (aka.
|
void |
ClassWellDefinedness.addInv(Term inv) |
FunctionalOperationContract |
ContractFactory.addPost(FunctionalOperationContract old,
Term addedPost,
ProgramVariable selfVar,
ProgramVariable resultVar,
ProgramVariable excVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,LocationVariable> atPreVars)
Returns another contract like this one, except that the passed term has been added as a
postcondition (regardless of termination case).
|
FunctionalOperationContract |
ContractFactory.addPre(FunctionalOperationContract old,
Term addedPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,LocationVariable> atPreVars)
Returns another contract like this one, except that the passed term has been added as a
precondition.
|
WellDefinednessCheck |
WellDefinednessCheck.addRepresents(Term rep) |
protected abstract T |
AbstractAuxiliaryContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected BlockContract |
BlockContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected LoopContract |
LoopContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
LoopSpecification |
LoopSpecification.configurate(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant)
Configure the existing loop specification element with new elements,
i.e., loop invariant clauses, a loop variant, modifies clauses,
information flow specification elements, and a loop variant,
possibly together with (if any) "free" loop invariant clauses.
|
LoopSpecification |
LoopSpecImpl.configurate(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant) |
LoopSpecification |
LoopSpecification.create(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Create and return a new loop specification element from the existing one
where the arguments given are replaced.
|
LoopSpecification |
LoopSpecImpl.create(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres) |
LoopSpecification |
LoopSpecification.create(LoopStatement loop,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Create and return a new loop specification element from the existing one
where the arguments given are replaced.
|
LoopSpecification |
LoopSpecImpl.create(LoopStatement loop,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres) |
InformationFlowContract |
ContractFactory.createInformationFlowContract(KeYJavaType forClass,
IProgramMethod pm,
KeYJavaType specifiedIn,
Modality modality,
Term requires,
Term requiresFree,
Term measuredBy,
Term modifies,
boolean hasMod,
ProgramVariableCollection progVars,
Term accessible,
ImmutableList<InfFlowSpec> infFlowSpecs,
boolean toBeSaved) |
protected java.util.Map<Term,Term> |
AbstractAuxiliaryContractImpl.createReplacementMap(Term newHeap,
AuxiliaryContract.Terms newTerms,
Services services) |
DependencyContract |
ContractFactory.dep(KeYJavaType containerType,
IObserverFunction pm,
KeYJavaType specifiedIn,
java.util.Map<LocationVariable,Term> requires,
Term measuredBy,
java.util.Map<ProgramVariable,Term> accessibles,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Term globalDefs) |
DependencyContract |
ContractFactory.dep(java.lang.String string,
KeYJavaType containerType,
IObserverFunction pm,
KeYJavaType specifiedIn,
java.util.Map<LocationVariable,Term> requires,
Term measuredBy,
java.util.Map<ProgramVariable,Term> accessibles,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Term globalDefs) |
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
boolean terminates,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection pv)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection progVars,
boolean toBeSaved,
boolean transaction)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
KeYJavaType kjt,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accs,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
boolean toBeSaved)
Creates a new functional operation contract.
|
SequentFormula |
StatementWellDefinedness.generateSequent(ProgramVariable self,
LocationVariable heap,
Term anonHeap,
ImmutableSet<ProgramVariable> ps,
Term leadingUpdate,
Term localAnonUpdate,
Services services)
This is where the proof sequent is built, however with a smaller set of variables,
due to the nature of the jml statement.
|
SequentFormula |
StatementWellDefinedness.generateSequent(ProgramVariable self,
ProgramVariable exception,
ProgramVariable result,
LocationVariable heap,
ProgramVariable heapAtPre,
Term anonHeap,
ImmutableSet<ProgramVariable> ps,
Term leadingUpdate,
Term localAnonUpdate,
Services services)
This is where the proof sequent is built.
|
Term |
FunctionalOperationContractImpl.getAnyMod(Term mod,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services) |
Term |
LoopContract.getDecreases(Term heap,
Term self,
Services services) |
Term |
LoopContractImpl.getDecreases(Term heap,
Term self,
Services services) |
Term |
FunctionalAuxiliaryContract.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
InformationFlowContractImpl.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
DependencyContractImpl.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
WellDefinednessCheck.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
Contract.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the dependency set of the contract.
|
Term |
LoopSpecification.getFreeInvariant(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the free invariant formula.
|
Term |
LoopSpecImpl.getFreeInvariant(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getFreePost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getFreePost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getFreePost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getFreePost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getFreePostcondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
AuxiliaryContract.getFreePostcondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
FunctionalOperationContractImpl.getFreePre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
OperationContract.getFreePre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getFreePrecondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
AuxiliaryContract.getFreePrecondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getFreePrecondition(LocationVariable heapVariable,
Term heap,
Term self,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AuxiliaryContract.getFreePrecondition(LocationVariable heapVariable,
Term heap,
Term self,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalAuxiliaryContract.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
FunctionalOperationContractImpl.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
InformationFlowContractImpl.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
DependencyContractImpl.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
WellDefinednessCheck.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services)
Deprecated.
|
Term |
Contract.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
protected java.lang.String |
InformationFlowContractImpl.getHTMLFor(Term originalTerm,
java.lang.String htmlName,
Services services) |
ImmutableList<InfFlowSpec> |
LoopSpecification.getInfFlowSpecs(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
ImmutableList<InfFlowSpec> |
LoopSpecImpl.getInfFlowSpecs(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
LoopSpecification.getInvariant(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the invariant formula.
|
Term |
LoopSpecImpl.getInvariant(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalAuxiliaryContract.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
InformationFlowContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
DependencyContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
WellDefinednessCheck.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
Contract.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the measured_by clause of the contract.
|
Term |
AbstractAuxiliaryContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AuxiliaryContract.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getMod(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
OperationContract.getMod(LocationVariable heapVar,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services)
Returns the modifies clause of the contract.
|
Term |
LoopSpecification.getModifies(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the modifies clause.
|
Term |
LoopSpecImpl.getModifies(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
LoopSpecification.getModifies(Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the modifies clause.
|
Term |
LoopSpecImpl.getModifies(Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getModifiesClause(LocationVariable heapVariable,
Term heap,
Term self,
Services services) |
Term |
AuxiliaryContract.getModifiesClause(LocationVariable heapVariable,
Term heap,
Term self,
Services services) |
Term |
FunctionalOperationContractImpl.getPost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getPost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getPost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the postcondition of the contract.
|
Term |
AbstractAuxiliaryContractImpl.getPostcondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
AuxiliaryContract.getPostcondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
FunctionalAuxiliaryContract.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
InformationFlowContractImpl.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
DependencyContractImpl.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
WellDefinednessCheck.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
Contract.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the precondition of the contract.
|
Term |
FunctionalAuxiliaryContract.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
InformationFlowContractImpl.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
DependencyContractImpl.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
WellDefinednessCheck.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
Contract.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the precondition of the contract.
|
Term |
AbstractAuxiliaryContractImpl.getPrecondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
AuxiliaryContract.getPrecondition(LocationVariable heapVariable,
Term heap,
AuxiliaryContract.Terms terms,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getPrecondition(LocationVariable heapVariable,
Term heap,
Term self,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AuxiliaryContract.getPrecondition(LocationVariable heapVariable,
Term heap,
Term self,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
protected java.util.Map<Term,Term> |
FunctionalOperationContractImpl.getReplaceMap(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services)
Deprecated.
|
protected java.util.Map<Term,Term> |
FunctionalOperationContractImpl.getReplaceMap(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
Term atPre,
Services services)
Deprecated.
|
protected java.util.Map<Term,Term> |
FunctionalOperationContractImpl.getReplaceMap(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Get the according replace map for the given variable terms.
|
Term |
FunctionalOperationContractImpl.getRepresentsAxiom(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getRepresentsAxiom(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getTerm(Term term,
AuxiliaryContract.Variables variables,
Services services)
Replaces variables in a map of terms
|
Term |
AbstractAuxiliaryContractImpl.getTerm(Term term,
Term heap,
AuxiliaryContract.Terms terms,
Services services)
Replaces variables in a map of terms
|
static java.lang.String |
FunctionalOperationContractImpl.getText(FunctionalOperationContract contract,
ImmutableList<Term> contractParams,
Term resultTerm,
Term contractSelf,
Term excTerm,
LocationVariable baseHeap,
Term baseHeapTerm,
java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> atPres,
boolean includeHtmlMarkup,
Services services,
boolean usePrettyPrinting,
boolean useUnicodeSymbols) |
Term |
WellDefinednessCheck.getUpdates(Term mod,
LocationVariable heap,
ProgramVariable heapAtPre,
Term anonHeap,
TermServices services)
Gets the necessary updates applicable to the post-condition
|
Term |
LoopSpecification.getVariant(Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the variant term.
|
Term |
LoopSpecImpl.getVariant(Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
LoopSpecification |
LoopSpecification.instantiate(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
Term variant)
Instantiate a (raw) loop specification with loop invariant clauses and
a loop variant, possibly together with (if any) "free" loop invariant
clauses.
|
LoopSpecification |
LoopSpecImpl.instantiate(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
Term variant) |
Term |
WellDefinednessCheck.replace(Term t,
WellDefinednessPO.Variables vars) |
void |
AbstractAuxiliaryContractImpl.setInstantiationSelf(Term selfInstantiation) |
void |
AuxiliaryContract.setInstantiationSelf(Term selfInstantiation) |
LoopSpecification |
LoopSpecification.setInvariant(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns a new loop invariant where the invariant formula has been
replaced with the passed one.
|
LoopSpecification |
LoopSpecImpl.setInvariant(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
InformationFlowContract |
InformationFlowContractImpl.setModifies(Term modifies) |
InformationFlowContract |
InformationFlowContract.setModifies(Term modifies) |
AuxiliaryContract.Terms |
AuxiliaryContract.Variables.termify(Term self) |
LoopContract |
LoopContract.update(LoopStatement newLoop,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContractImpl.update(LoopStatement newLoop,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
BlockContract |
BlockContractImpl.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy) |
BlockContract |
BlockContract.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newInfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy) |
LoopContract |
LoopContract.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContractImpl.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
Modifier and Type | Method and Description |
---|---|
protected abstract T |
AbstractAuxiliaryContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected abstract T |
AbstractAuxiliaryContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected abstract T |
AbstractAuxiliaryContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected abstract T |
AbstractAuxiliaryContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected abstract T |
AbstractAuxiliaryContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected BlockContract |
BlockContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected BlockContract |
BlockContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected BlockContract |
BlockContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected BlockContract |
BlockContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected BlockContract |
BlockContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected LoopContract |
LoopContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected LoopContract |
LoopContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected LoopContract |
LoopContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected LoopContract |
LoopContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
protected LoopContract |
LoopContractImpl.Creator.build(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod) |
LoopSpecification |
LoopSpecification.configurate(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant)
Configure the existing loop specification element with new elements,
i.e., loop invariant clauses, a loop variant, modifies clauses,
information flow specification elements, and a loop variant,
possibly together with (if any) "free" loop invariant clauses.
|
LoopSpecification |
LoopSpecification.configurate(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant)
Configure the existing loop specification element with new elements,
i.e., loop invariant clauses, a loop variant, modifies clauses,
information flow specification elements, and a loop variant,
possibly together with (if any) "free" loop invariant clauses.
|
LoopSpecification |
LoopSpecification.configurate(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant)
Configure the existing loop specification element with new elements,
i.e., loop invariant clauses, a loop variant, modifies clauses,
information flow specification elements, and a loop variant,
possibly together with (if any) "free" loop invariant clauses.
|
LoopSpecification |
LoopSpecImpl.configurate(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant) |
LoopSpecification |
LoopSpecImpl.configurate(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant) |
LoopSpecification |
LoopSpecImpl.configurate(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant) |
LoopSpecification |
LoopSpecification.create(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Create and return a new loop specification element from the existing one
where the arguments given are replaced.
|
LoopSpecification |
LoopSpecification.create(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Create and return a new loop specification element from the existing one
where the arguments given are replaced.
|
LoopSpecification |
LoopSpecification.create(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Create and return a new loop specification element from the existing one
where the arguments given are replaced.
|
LoopSpecification |
LoopSpecification.create(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Create and return a new loop specification element from the existing one
where the arguments given are replaced.
|
LoopSpecification |
LoopSpecification.create(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Create and return a new loop specification element from the existing one
where the arguments given are replaced.
|
LoopSpecification |
LoopSpecification.create(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Create and return a new loop specification element from the existing one
where the arguments given are replaced.
|
LoopSpecification |
LoopSpecImpl.create(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres) |
LoopSpecification |
LoopSpecImpl.create(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres) |
LoopSpecification |
LoopSpecImpl.create(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres) |
LoopSpecification |
LoopSpecImpl.create(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres) |
LoopSpecification |
LoopSpecImpl.create(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres) |
LoopSpecification |
LoopSpecImpl.create(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres) |
LoopSpecification |
LoopSpecification.create(LoopStatement loop,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Create and return a new loop specification element from the existing one
where the arguments given are replaced.
|
LoopSpecification |
LoopSpecification.create(LoopStatement loop,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Create and return a new loop specification element from the existing one
where the arguments given are replaced.
|
LoopSpecification |
LoopSpecification.create(LoopStatement loop,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Create and return a new loop specification element from the existing one
where the arguments given are replaced.
|
LoopSpecification |
LoopSpecification.create(LoopStatement loop,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Create and return a new loop specification element from the existing one
where the arguments given are replaced.
|
LoopSpecification |
LoopSpecification.create(LoopStatement loop,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Create and return a new loop specification element from the existing one
where the arguments given are replaced.
|
LoopSpecification |
LoopSpecification.create(LoopStatement loop,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Create and return a new loop specification element from the existing one
where the arguments given are replaced.
|
LoopSpecification |
LoopSpecImpl.create(LoopStatement loop,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres) |
LoopSpecification |
LoopSpecImpl.create(LoopStatement loop,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres) |
LoopSpecification |
LoopSpecImpl.create(LoopStatement loop,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres) |
LoopSpecification |
LoopSpecImpl.create(LoopStatement loop,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres) |
LoopSpecification |
LoopSpecImpl.create(LoopStatement loop,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres) |
LoopSpecification |
LoopSpecImpl.create(LoopStatement loop,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres) |
DependencyContract |
ContractFactory.dep(KeYJavaType containerType,
IObserverFunction pm,
KeYJavaType specifiedIn,
java.util.Map<LocationVariable,Term> requires,
Term measuredBy,
java.util.Map<ProgramVariable,Term> accessibles,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Term globalDefs) |
DependencyContract |
ContractFactory.dep(KeYJavaType containerType,
IObserverFunction pm,
KeYJavaType specifiedIn,
java.util.Map<LocationVariable,Term> requires,
Term measuredBy,
java.util.Map<ProgramVariable,Term> accessibles,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Term globalDefs) |
DependencyContract |
ContractFactory.dep(KeYJavaType kjt,
LocationVariable targetHeap,
Triple<IObserverFunction,Term,Term> dep,
ProgramVariable selfVar) |
DependencyContract |
ContractFactory.dep(KeYJavaType kjt,
LocationVariable targetHeap,
Triple<IObserverFunction,Term,Term> dep,
ProgramVariable selfVar) |
DependencyContract |
ContractFactory.dep(java.lang.String string,
KeYJavaType containerType,
IObserverFunction pm,
KeYJavaType specifiedIn,
java.util.Map<LocationVariable,Term> requires,
Term measuredBy,
java.util.Map<ProgramVariable,Term> accessibles,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Term globalDefs) |
DependencyContract |
ContractFactory.dep(java.lang.String string,
KeYJavaType containerType,
IObserverFunction pm,
KeYJavaType specifiedIn,
java.util.Map<LocationVariable,Term> requires,
Term measuredBy,
java.util.Map<ProgramVariable,Term> accessibles,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,? extends ProgramVariable> atPreVars,
Term globalDefs) |
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
boolean terminates,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection pv)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
boolean terminates,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection pv)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
boolean terminates,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection pv)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
boolean terminates,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection pv)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
boolean terminates,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection pv)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
boolean terminates,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection pv)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
boolean terminates,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection pv)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection progVars,
boolean toBeSaved,
boolean transaction)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection progVars,
boolean toBeSaved,
boolean transaction)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection progVars,
boolean toBeSaved,
boolean transaction)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection progVars,
boolean toBeSaved,
boolean transaction)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection progVars,
boolean toBeSaved,
boolean transaction)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection progVars,
boolean toBeSaved,
boolean transaction)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accessibles,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariableCollection progVars,
boolean toBeSaved,
boolean transaction)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
KeYJavaType kjt,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accs,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
boolean toBeSaved)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
KeYJavaType kjt,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accs,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
boolean toBeSaved)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
KeYJavaType kjt,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accs,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
boolean toBeSaved)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
KeYJavaType kjt,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accs,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
boolean toBeSaved)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
KeYJavaType kjt,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accs,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
boolean toBeSaved)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
KeYJavaType kjt,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accs,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
boolean toBeSaved)
Creates a new functional operation contract.
|
FunctionalOperationContract |
ContractFactory.func(java.lang.String baseName,
KeYJavaType kjt,
IProgramMethod pm,
Modality modality,
java.util.Map<LocationVariable,Term> pres,
java.util.Map<LocationVariable,Term> freePres,
Term mby,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> freePosts,
java.util.Map<LocationVariable,Term> axioms,
java.util.Map<LocationVariable,Term> mods,
java.util.Map<ProgramVariable,Term> accs,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
boolean toBeSaved)
Creates a new functional operation contract.
|
java.util.ArrayList<AbstractionPredicate> |
PredicateAbstractionMergeContract.getAbstractionPredicates(java.util.Map<LocationVariable,Term> atPres,
Services services)
TODO
|
Term |
FunctionalAuxiliaryContract.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalAuxiliaryContract.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
InformationFlowContractImpl.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
InformationFlowContractImpl.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
DependencyContractImpl.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
DependencyContractImpl.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
WellDefinednessCheck.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
WellDefinednessCheck.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
Contract.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the dependency set of the contract.
|
Term |
Contract.getDep(LocationVariable heap,
boolean atPre,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the dependency set of the contract.
|
Term |
LoopSpecification.getFreeInvariant(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the free invariant formula.
|
Term |
LoopSpecImpl.getFreeInvariant(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getFreePost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getFreePost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getFreePost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getFreePost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getFreePost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getFreePost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getFreePost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getFreePost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getFreePost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getFreePost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getFreePre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getFreePre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
OperationContract.getFreePre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
OperationContract.getFreePre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getFreePrecondition(LocationVariable heapVariable,
Term heap,
Term self,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AuxiliaryContract.getFreePrecondition(LocationVariable heapVariable,
Term heap,
Term self,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalAuxiliaryContract.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
FunctionalOperationContractImpl.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
InformationFlowContractImpl.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
DependencyContractImpl.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
WellDefinednessCheck.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services)
Deprecated.
|
Term |
Contract.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
ImmutableList<InfFlowSpec> |
LoopSpecification.getInfFlowSpecs(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
ImmutableList<InfFlowSpec> |
LoopSpecImpl.getInfFlowSpecs(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
LoopSpecification.getInvariant(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the invariant formula.
|
Term |
LoopSpecImpl.getInvariant(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalAuxiliaryContract.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalAuxiliaryContract.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalAuxiliaryContract.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
InformationFlowContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
InformationFlowContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
InformationFlowContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
DependencyContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
DependencyContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
DependencyContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
WellDefinednessCheck.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
WellDefinednessCheck.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
WellDefinednessCheck.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
Contract.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the measured_by clause of the contract.
|
Term |
Contract.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the measured_by clause of the contract.
|
Term |
Contract.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the measured_by clause of the contract.
|
Term |
AbstractAuxiliaryContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AbstractAuxiliaryContractImpl.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AuxiliaryContract.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AuxiliaryContract.getMby(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getMod(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Term |
OperationContract.getMod(LocationVariable heapVar,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services)
Returns the modifies clause of the contract.
|
Term |
LoopSpecification.getModifies(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the modifies clause.
|
Term |
LoopSpecImpl.getModifies(LocationVariable heap,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
LoopSpecification.getModifies(Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the modifies clause.
|
Term |
LoopSpecImpl.getModifies(Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getPost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getPost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getPost(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getPost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the postcondition of the contract.
|
Term |
FunctionalOperationContract.getPost(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the postcondition of the contract.
|
Term |
FunctionalAuxiliaryContract.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalAuxiliaryContract.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalAuxiliaryContract.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
InformationFlowContractImpl.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
InformationFlowContractImpl.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
InformationFlowContractImpl.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
DependencyContractImpl.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
DependencyContractImpl.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
DependencyContractImpl.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
WellDefinednessCheck.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
WellDefinednessCheck.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
WellDefinednessCheck.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
Contract.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the precondition of the contract.
|
Term |
Contract.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the precondition of the contract.
|
Term |
Contract.getPre(java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the precondition of the contract.
|
Term |
FunctionalAuxiliaryContract.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalAuxiliaryContract.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
InformationFlowContractImpl.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
InformationFlowContractImpl.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
DependencyContractImpl.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
DependencyContractImpl.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
WellDefinednessCheck.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
WellDefinednessCheck.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Deprecated.
|
Term |
Contract.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the precondition of the contract.
|
Term |
Contract.getPre(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the precondition of the contract.
|
Term |
AbstractAuxiliaryContractImpl.getPrecondition(LocationVariable heapVariable,
Term heap,
Term self,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
AuxiliaryContract.getPrecondition(LocationVariable heapVariable,
Term heap,
Term self,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
protected java.util.Map<Term,Term> |
FunctionalOperationContractImpl.getReplaceMap(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services)
Deprecated.
|
protected java.util.Map<Term,Term> |
FunctionalOperationContractImpl.getReplaceMap(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
Term atPre,
Services services)
Deprecated.
|
protected java.util.Map<Term,Term> |
FunctionalOperationContractImpl.getReplaceMap(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Get the according replace map for the given variable terms.
|
protected java.util.Map<Term,Term> |
FunctionalOperationContractImpl.getReplaceMap(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Get the according replace map for the given variable terms.
|
protected java.util.Map<Term,Term> |
FunctionalOperationContractImpl.getReplaceMap(java.util.Map<LocationVariable,Term> heapTerms,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Get the according replace map for the given variable terms.
|
Term |
FunctionalOperationContractImpl.getRepresentsAxiom(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContractImpl.getRepresentsAxiom(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getRepresentsAxiom(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
Term |
FunctionalOperationContract.getRepresentsAxiom(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Term resultTerm,
Term excTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
static java.lang.String |
FunctionalOperationContractImpl.getText(FunctionalOperationContract contract,
ImmutableList<Term> contractParams,
Term resultTerm,
Term contractSelf,
Term excTerm,
LocationVariable baseHeap,
Term baseHeapTerm,
java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> atPres,
boolean includeHtmlMarkup,
Services services,
boolean usePrettyPrinting,
boolean useUnicodeSymbols) |
static java.lang.String |
FunctionalOperationContractImpl.getText(FunctionalOperationContract contract,
ImmutableList<Term> contractParams,
Term resultTerm,
Term contractSelf,
Term excTerm,
LocationVariable baseHeap,
Term baseHeapTerm,
java.util.List<LocationVariable> heapContext,
java.util.Map<LocationVariable,Term> atPres,
boolean includeHtmlMarkup,
Services services,
boolean usePrettyPrinting,
boolean useUnicodeSymbols) |
Term |
LoopSpecification.getVariant(Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns the variant term.
|
Term |
LoopSpecImpl.getVariant(Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
LoopSpecification |
LoopSpecification.instantiate(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
Term variant)
Instantiate a (raw) loop specification with loop invariant clauses and
a loop variant, possibly together with (if any) "free" loop invariant
clauses.
|
LoopSpecification |
LoopSpecification.instantiate(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
Term variant)
Instantiate a (raw) loop specification with loop invariant clauses and
a loop variant, possibly together with (if any) "free" loop invariant
clauses.
|
LoopSpecification |
LoopSpecImpl.instantiate(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
Term variant) |
LoopSpecification |
LoopSpecImpl.instantiate(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
Term variant) |
PredicateAbstractionMergeContract |
PredicateAbstractionMergeContract.map(java.util.function.UnaryOperator<Term> op,
Services services) |
MethodWellDefinedness |
MethodWellDefinedness.map(java.util.function.UnaryOperator<Term> op,
Services services) |
ClassAxiomImpl |
ClassAxiomImpl.map(java.util.function.UnaryOperator<Term> op,
Services services) |
FunctionalOperationContract |
FunctionalOperationContractImpl.map(java.util.function.UnaryOperator<Term> op,
Services services) |
ClassWellDefinedness |
ClassWellDefinedness.map(java.util.function.UnaryOperator<Term> op,
Services services) |
ClassInvariant |
ClassInvariantImpl.map(java.util.function.UnaryOperator<Term> op,
Services services) |
LoopContract |
LoopContract.map(java.util.function.UnaryOperator<Term> op,
Services services) |
InformationFlowContract |
InformationFlowContractImpl.map(java.util.function.UnaryOperator<Term> op,
Services services) |
InitiallyClause |
InitiallyClauseImpl.map(java.util.function.UnaryOperator<Term> op,
Services services) |
FunctionalBlockContract |
FunctionalBlockContract.map(java.util.function.UnaryOperator<Term> op,
Services services) |
QueryAxiom |
QueryAxiom.map(java.util.function.UnaryOperator<Term> op,
Services services) |
InformationFlowContract |
InformationFlowContract.map(java.util.function.UnaryOperator<Term> op,
Services services) |
ClassInvariant |
ClassInvariant.map(java.util.function.UnaryOperator<Term> op,
Services services) |
UnparameterizedMergeContract |
UnparameterizedMergeContract.map(java.util.function.UnaryOperator<Term> op,
Services services) |
FunctionalOperationContract |
FunctionalOperationContract.map(java.util.function.UnaryOperator<Term> op,
Services services) |
SpecificationElement |
PartialInvAxiom.map(java.util.function.UnaryOperator<Term> op,
Services services) |
ContractAxiom |
ContractAxiom.map(java.util.function.UnaryOperator<Term> op,
Services services) |
LoopSpecification |
LoopSpecification.map(java.util.function.UnaryOperator<Term> op,
Services services) |
InitiallyClause |
InitiallyClause.map(java.util.function.UnaryOperator<Term> op,
Services services) |
DependencyContract |
DependencyContractImpl.map(java.util.function.UnaryOperator<Term> op,
Services services) |
OperationContract |
OperationContract.map(java.util.function.UnaryOperator<Term> op,
Services services) |
abstract WellDefinednessCheck |
WellDefinednessCheck.map(java.util.function.UnaryOperator<Term> op,
Services services) |
BlockContract |
BlockContractImpl.map(java.util.function.UnaryOperator<Term> op,
Services services) |
SpecificationElement |
RepresentsAxiom.map(java.util.function.UnaryOperator<Term> op,
Services services) |
Contract |
Contract.map(java.util.function.UnaryOperator<Term> op,
Services services) |
MergeContract |
MergeContract.map(java.util.function.UnaryOperator<Term> op,
Services services) |
LoopWellDefinedness |
LoopWellDefinedness.map(java.util.function.UnaryOperator<Term> op,
Services services) |
BlockContract |
BlockContract.map(java.util.function.UnaryOperator<Term> op,
Services services) |
DependencyContract |
DependencyContract.map(java.util.function.UnaryOperator<Term> op,
Services services) |
LoopContract |
LoopContractImpl.map(java.util.function.UnaryOperator<Term> op,
Services services) |
BlockWellDefinedness |
BlockWellDefinedness.map(java.util.function.UnaryOperator<Term> op,
Services services) |
SpecificationElement |
SpecificationElement.map(java.util.function.UnaryOperator<Term> op,
Services services)
Applies a unary operator to every term in this specification element.
|
FunctionalLoopContract |
FunctionalLoopContract.map(java.util.function.UnaryOperator<Term> op,
Services services) |
ModelMethodExecution |
ModelMethodExecution.map(java.util.function.UnaryOperator<Term> op,
Services services) |
AuxiliaryContract |
AuxiliaryContract.map(java.util.function.UnaryOperator<Term> op,
Services services) |
abstract StatementWellDefinedness |
StatementWellDefinedness.map(java.util.function.UnaryOperator<Term> op,
Services services) |
LoopSpecification |
LoopSpecImpl.map(java.util.function.UnaryOperator<Term> op,
Services services) |
LoopSpecification |
LoopSpecification.setInvariant(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns a new loop invariant where the invariant formula has been
replaced with the passed one.
|
LoopSpecification |
LoopSpecification.setInvariant(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns a new loop invariant where the invariant formula has been
replaced with the passed one.
|
LoopSpecification |
LoopSpecification.setInvariant(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services)
Returns a new loop invariant where the invariant formula has been
replaced with the passed one.
|
LoopSpecification |
LoopSpecImpl.setInvariant(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
LoopSpecification |
LoopSpecImpl.setInvariant(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
LoopSpecification |
LoopSpecImpl.setInvariant(java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres,
Services services) |
LoopContract |
LoopContract.update(LoopStatement newLoop,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContract.update(LoopStatement newLoop,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContract.update(LoopStatement newLoop,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContract.update(LoopStatement newLoop,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContract.update(LoopStatement newLoop,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContractImpl.update(LoopStatement newLoop,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContractImpl.update(LoopStatement newLoop,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContractImpl.update(LoopStatement newLoop,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContractImpl.update(LoopStatement newLoop,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContractImpl.update(LoopStatement newLoop,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
BlockContract |
BlockContractImpl.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy) |
BlockContract |
BlockContractImpl.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy) |
BlockContract |
BlockContractImpl.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy) |
BlockContract |
BlockContractImpl.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy) |
BlockContract |
BlockContractImpl.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy) |
BlockContract |
BlockContract.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newInfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy) |
BlockContract |
BlockContract.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newInfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy) |
BlockContract |
BlockContract.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newInfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy) |
BlockContract |
BlockContract.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newInfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy) |
BlockContract |
BlockContract.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newInfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy) |
LoopContract |
LoopContract.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContract.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContract.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContract.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContract.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContractImpl.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContractImpl.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContractImpl.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContractImpl.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
LoopContract |
LoopContractImpl.update(StatementBlock newBlock,
java.util.Map<LocationVariable,Term> newPreconditions,
java.util.Map<LocationVariable,Term> newFreePreconditions,
java.util.Map<LocationVariable,Term> newPostconditions,
java.util.Map<LocationVariable,Term> newFreePostconditions,
java.util.Map<LocationVariable,Term> newModifiesClauses,
ImmutableList<InfFlowSpec> newinfFlowSpecs,
AuxiliaryContract.Variables newVariables,
Term newMeasuredBy,
Term newDecreases) |
Constructor and Description |
---|
AbstractAuxiliaryContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts) |
BlockContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts) |
ClassAxiomImpl(java.lang.String name,
KeYJavaType kjt,
VisibilityModifier visibility,
Term rep,
ProgramVariable selfVar) |
ClassAxiomImpl(java.lang.String name,
java.lang.String displayName,
KeYJavaType kjt,
VisibilityModifier visibility,
Term rep,
ProgramVariable selfVar) |
ClassInvariantImpl(java.lang.String name,
java.lang.String displayName,
KeYJavaType kjt,
VisibilityModifier visibility,
Term inv,
ParsableVariable selfVar)
Creates a class invariant.
|
ClassWellDefinedness(ClassInvariant inv,
IObserverFunction target,
Term accessible,
Term mby,
Services services) |
ContractAxiom(java.lang.String name,
IObserverFunction target,
KeYJavaType kjt,
VisibilityModifier visibility,
Term pre,
Term post,
Term mby,
java.util.Map<LocationVariable,ProgramVariable> atPreVars,
ProgramVariable selfVar,
ProgramVariable resultVar,
ImmutableList<ProgramVariable> paramVars) |
ContractAxiom(java.lang.String name,
java.lang.String displayName,
IObserverFunction target,
KeYJavaType kjt,
VisibilityModifier visibility,
Term originalPre,
Term originalPost,
Term originalMby,
java.util.Map<LocationVariable,ProgramVariable> atPreVars,
ProgramVariable selfVar,
ProgramVariable resultVar,
ImmutableList<ProgramVariable> paramVars) |
Creator(java.lang.String baseName,
LoopStatement loop,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a loop.
|
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a block that starts with a loop.
|
InformationFlowContractImpl(java.lang.String baseName,
KeYJavaType forClass,
IProgramMethod pm,
KeYJavaType specifiedIn,
Modality modality,
Term pre,
Term freePre,
Term mby,
Term mod,
boolean hasRealMod,
Term self,
ImmutableList<Term> params,
Term result,
Term exc,
Term heapAtPre,
Term dep,
ImmutableList<InfFlowSpec> infFlowSpecs,
boolean toBeSaved) |
InformationFlowContractImpl(java.lang.String baseName,
java.lang.String name,
KeYJavaType forClass,
IProgramMethod pm,
KeYJavaType specifiedIn,
Modality modality,
Term pre,
Term freePre,
Term mby,
Term mod,
boolean hasRealMod,
Term self,
ImmutableList<Term> params,
Term result,
Term exc,
Term heapAtPre,
Term dep,
ImmutableList<InfFlowSpec> infFlowSpecs,
boolean toBeSaved,
int id) |
InitiallyClauseImpl(java.lang.String name,
java.lang.String displayName,
KeYJavaType kjt,
VisibilityModifier visibility,
Term inv,
ParsableVariable selfVar,
LabeledParserRuleContext originalSpec)
Creates a class invariant.
|
LoopContractImpl(java.lang.String baseName,
LoopStatement loop,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts,
Services services)
Construct a loop contract for a loop.
|
LoopContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts,
Services services)
Construct a loop contract for a block that starts with a loop.
|
LoopSpecImpl(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Creates a loop invariant.
|
LoopSpecImpl(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres)
Creates an empty, default loop invariant for the passed loop.
|
RepresentsAxiom(java.lang.String name,
IObserverFunction target,
KeYJavaType kjt,
VisibilityModifier visibility,
Term pre,
Term rep,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,ProgramVariable> atPreVars) |
RepresentsAxiom(java.lang.String name,
java.lang.String displayName,
IObserverFunction target,
KeYJavaType kjt,
VisibilityModifier visibility,
Term pre,
Term rep,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,ProgramVariable> atPreVars) |
Terms(Term self,
java.util.Map<Label,Term> breakFlags,
java.util.Map<Label,Term> continueFlags,
Term returnFlag,
Term result,
Term exception,
java.util.Map<LocationVariable,Term> remembranceHeaps,
java.util.Map<LocationVariable,Term> remembranceLocalVariables,
java.util.Map<LocationVariable,Term> outerRemembranceHeaps,
java.util.Map<LocationVariable,Term> outerRemembranceVariables)
Creates a new instance.
|
Constructor and Description |
---|
AbstractAuxiliaryContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts) |
AbstractAuxiliaryContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts) |
AbstractAuxiliaryContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts) |
AbstractAuxiliaryContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts) |
AbstractAuxiliaryContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts) |
BlockContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts) |
BlockContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts) |
BlockContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts) |
BlockContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts) |
BlockContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts) |
Creator(java.lang.String baseName,
LoopStatement loop,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a loop.
|
Creator(java.lang.String baseName,
LoopStatement loop,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a loop.
|
Creator(java.lang.String baseName,
LoopStatement loop,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a loop.
|
Creator(java.lang.String baseName,
LoopStatement loop,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a loop.
|
Creator(java.lang.String baseName,
LoopStatement loop,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a loop.
|
Creator(java.lang.String baseName,
LoopStatement loop,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a loop.
|
Creator(java.lang.String baseName,
LoopStatement loop,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a loop.
|
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Services services) |
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a block that starts with a loop.
|
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a block that starts with a loop.
|
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a block that starts with a loop.
|
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a block that starts with a loop.
|
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a block that starts with a loop.
|
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a block that starts with a loop.
|
Creator(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Behavior behavior,
AuxiliaryContract.Variables variables,
java.util.Map<LocationVariable,Term> requires,
java.util.Map<LocationVariable,Term> requiresFree,
Term measuredBy,
java.util.Map<LocationVariable,Term> ensures,
java.util.Map<LocationVariable,Term> ensuresFree,
ImmutableList<InfFlowSpec> infFlowSpecs,
java.util.Map<Label,Term> breaks,
java.util.Map<Label,Term> continues,
Term returns,
Term signals,
Term signalsOnly,
Term diverges,
java.util.Map<LocationVariable,Term> assignables,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
Services services)
Creates loop contract for a block that starts with a loop.
|
InformationFlowContractImpl(java.lang.String baseName,
KeYJavaType forClass,
IProgramMethod pm,
KeYJavaType specifiedIn,
Modality modality,
Term pre,
Term freePre,
Term mby,
Term mod,
boolean hasRealMod,
Term self,
ImmutableList<Term> params,
Term result,
Term exc,
Term heapAtPre,
Term dep,
ImmutableList<InfFlowSpec> infFlowSpecs,
boolean toBeSaved) |
InformationFlowContractImpl(java.lang.String baseName,
java.lang.String name,
KeYJavaType forClass,
IProgramMethod pm,
KeYJavaType specifiedIn,
Modality modality,
Term pre,
Term freePre,
Term mby,
Term mod,
boolean hasRealMod,
Term self,
ImmutableList<Term> params,
Term result,
Term exc,
Term heapAtPre,
Term dep,
ImmutableList<InfFlowSpec> infFlowSpecs,
boolean toBeSaved,
int id) |
LoopContractImpl(java.lang.String baseName,
LoopStatement loop,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts,
Services services)
Construct a loop contract for a loop.
|
LoopContractImpl(java.lang.String baseName,
LoopStatement loop,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts,
Services services)
Construct a loop contract for a loop.
|
LoopContractImpl(java.lang.String baseName,
LoopStatement loop,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts,
Services services)
Construct a loop contract for a loop.
|
LoopContractImpl(java.lang.String baseName,
LoopStatement loop,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts,
Services services)
Construct a loop contract for a loop.
|
LoopContractImpl(java.lang.String baseName,
LoopStatement loop,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts,
Services services)
Construct a loop contract for a loop.
|
LoopContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts,
Services services)
Construct a loop contract for a block that starts with a loop.
|
LoopContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts,
Services services)
Construct a loop contract for a block that starts with a loop.
|
LoopContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts,
Services services)
Construct a loop contract for a block that starts with a loop.
|
LoopContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts,
Services services)
Construct a loop contract for a block that starts with a loop.
|
LoopContractImpl(java.lang.String baseName,
StatementBlock block,
java.util.List<Label> labels,
IProgramMethod method,
Modality modality,
java.util.Map<LocationVariable,Term> preconditions,
java.util.Map<LocationVariable,Term> freePreconditions,
Term measuredBy,
java.util.Map<LocationVariable,Term> postconditions,
java.util.Map<LocationVariable,Term> freePostconditions,
java.util.Map<LocationVariable,Term> modifiesClauses,
ImmutableList<InfFlowSpec> infFlowSpecs,
AuxiliaryContract.Variables variables,
boolean transactionApplicable,
java.util.Map<LocationVariable,java.lang.Boolean> hasMod,
Term decreases,
ImmutableSet<FunctionalAuxiliaryContract<?>> functionalContracts,
Services services)
Construct a loop contract for a block that starts with a loop.
|
LoopSpecImpl(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Creates a loop invariant.
|
LoopSpecImpl(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Creates a loop invariant.
|
LoopSpecImpl(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Creates a loop invariant.
|
LoopSpecImpl(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Creates a loop invariant.
|
LoopSpecImpl(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Creates a loop invariant.
|
LoopSpecImpl(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
java.util.Map<LocationVariable,Term> invariants,
java.util.Map<LocationVariable,Term> freeInvariants,
java.util.Map<LocationVariable,Term> modifies,
java.util.Map<LocationVariable,ImmutableList<InfFlowSpec>> infFlowSpecs,
Term variant,
Term selfTerm,
ImmutableList<Term> localIns,
ImmutableList<Term> localOuts,
java.util.Map<LocationVariable,Term> atPres)
Creates a loop invariant.
|
LoopSpecImpl(LoopStatement loop,
IProgramMethod pm,
KeYJavaType kjt,
Term selfTerm,
java.util.Map<LocationVariable,Term> atPres)
Creates an empty, default loop invariant for the passed loop.
|
PredicateAbstractionMergeContract(MergePointStatement mps,
java.util.Map<LocationVariable,Term> atPres,
KeYJavaType kjt,
java.lang.String latticeType,
java.util.List<AbstractionPredicate> abstractionPredicates) |
Terms(Term self,
java.util.Map<Label,Term> breakFlags,
java.util.Map<Label,Term> continueFlags,
Term returnFlag,
Term result,
Term exception,
java.util.Map<LocationVariable,Term> remembranceHeaps,
java.util.Map<LocationVariable,Term> remembranceLocalVariables,
java.util.Map<LocationVariable,Term> outerRemembranceHeaps,
java.util.Map<LocationVariable,Term> outerRemembranceVariables)
Creates a new instance.
|
Terms(Term self,
java.util.Map<Label,Term> breakFlags,
java.util.Map<Label,Term> continueFlags,
Term returnFlag,
Term result,
Term exception,
java.util.Map<LocationVariable,Term> remembranceHeaps,
java.util.Map<LocationVariable,Term> remembranceLocalVariables,
java.util.Map<LocationVariable,Term> outerRemembranceHeaps,
java.util.Map<LocationVariable,Term> outerRemembranceVariables)
Creates a new instance.
|
Terms(Term self,
java.util.Map<Label,Term> breakFlags,
java.util.Map<Label,Term> continueFlags,
Term returnFlag,
Term result,
Term exception,
java.util.Map<LocationVariable,Term> remembranceHeaps,
java.util.Map<LocationVariable,Term> remembranceLocalVariables,
java.util.Map<LocationVariable,Term> outerRemembranceHeaps,
java.util.Map<LocationVariable,Term> outerRemembranceVariables)
Creates a new instance.
|
Terms(Term self,
java.util.Map<Label,Term> breakFlags,
java.util.Map<Label,Term> continueFlags,
Term returnFlag,
Term result,
Term exception,
java.util.Map<LocationVariable,Term> remembranceHeaps,
java.util.Map<LocationVariable,Term> remembranceLocalVariables,
java.util.Map<LocationVariable,Term> outerRemembranceHeaps,
java.util.Map<LocationVariable,Term> outerRemembranceVariables)
Creates a new instance.
|
Terms(Term self,
java.util.Map<Label,Term> breakFlags,
java.util.Map<Label,Term> continueFlags,
Term returnFlag,
Term result,
Term exception,
java.util.Map<LocationVariable,Term> remembranceHeaps,
java.util.Map<LocationVariable,Term> remembranceLocalVariables,
java.util.Map<LocationVariable,Term> outerRemembranceHeaps,
java.util.Map<LocationVariable,Term> outerRemembranceVariables)
Creates a new instance.
|
Terms(Term self,
java.util.Map<Label,Term> breakFlags,
java.util.Map<Label,Term> continueFlags,
Term returnFlag,
Term result,
Term exception,
java.util.Map<LocationVariable,Term> remembranceHeaps,
java.util.Map<LocationVariable,Term> remembranceLocalVariables,
java.util.Map<LocationVariable,Term> outerRemembranceHeaps,
java.util.Map<LocationVariable,Term> outerRemembranceVariables)
Creates a new instance.
|
Modifier and Type | Method and Description |
---|---|
ClassInvariant |
DLSpecFactory.createDLClassInvariant(java.lang.String name,
java.lang.String displayName,
ParsableVariable selfVar,
Term inv)
Creates a class invariant from a formula and a designated "self".
|
FunctionalOperationContract |
DLSpecFactory.createDLOperationContract(java.lang.String name,
Term fma,
Term modifies)
Creates an operation contract from an implication formula of the form
"pre -> {heapAtPre := heap}
[#catchAll(java.lang.Throwable exc){m();}]post",
(where the update and/or the #catchAll may be omitted) and a modifies
clause.
|
Modifier and Type | Field and Description |
---|---|
Term |
JMLSpecFactory.ContractClauses.decreases |
Term |
JMLSpecFactory.ContractClauses.diverges |
Term |
JMLSpecFactory.ContractClauses.measuredBy |
Term |
JMLSpecFactory.ContractClauses.returns |
Term |
JMLSpecFactory.ContractClauses.signals |
Term |
JMLSpecFactory.ContractClauses.signalsOnly |
Modifier and Type | Field and Description |
---|---|
ImmutableList<Term> |
JMLSpecFactory.ContractClauses.abbreviations |
java.util.Map<ProgramVariable,Term> |
JMLSpecFactory.ContractClauses.accessibles |
java.util.Map<LocationVariable,Term> |
JMLSpecFactory.ContractClauses.assignables |
java.util.Map<LocationVariable,Term> |
ProgramVariableCollection.atBefores
A map from every variable
var to \before(var) (if applicable). |
java.util.Map<LocationVariable,Term> |
ProgramVariableCollection.atPres
A map from every variable
var to \old(var) . |
java.util.Map<LocationVariable,Term> |
JMLSpecFactory.ContractClauses.axioms |
java.util.Map<Label,Term> |
JMLSpecFactory.ContractClauses.breaks |
java.util.Map<Label,Term> |
JMLSpecFactory.ContractClauses.continues |
java.util.Map<LocationVariable,Term> |
JMLSpecFactory.ContractClauses.ensures |
java.util.Map<LocationVariable,Term> |
JMLSpecFactory.ContractClauses.ensuresFree |
java.util.Map<LocationVariable,Term> |
JMLSpecFactory.ContractClauses.requires |
java.util.Map<LocationVariable,Term> |
JMLSpecFactory.ContractClauses.requiresFree |
Modifier and Type | Method and Description |
---|---|
ImmutableSet<Contract> |
JMLSpecFactory.createFunctionalOperationContracts(java.lang.String name,
IProgramMethod pm,
ProgramVariableCollection progVars,
JMLSpecFactory.ContractClauses clauses,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> axioms)
Generate functional operation contracts.
|
ImmutableSet<Contract> |
JMLSpecFactory.createFunctionalOperationContracts(java.lang.String name,
IProgramMethod pm,
ProgramVariableCollection progVars,
JMLSpecFactory.ContractClauses clauses,
java.util.Map<LocationVariable,Term> posts,
java.util.Map<LocationVariable,Term> axioms)
Generate functional operation contracts.
|
Constructor and Description |
---|
ProgramVariableCollection(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
java.util.Map<LocationVariable,Term> atPres)
Create a collection containing the specified variables.
|
ProgramVariableCollection(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
java.util.Map<LocationVariable,Term> atPres,
java.util.Map<LocationVariable,LocationVariable> atBeforeVars,
java.util.Map<LocationVariable,Term> atBefores)
Create a collection containing the specified variables.
|
ProgramVariableCollection(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
java.util.Map<LocationVariable,Term> atPres,
java.util.Map<LocationVariable,LocationVariable> atBeforeVars,
java.util.Map<LocationVariable,Term> atBefores)
Create a collection containing the specified variables.
|
Modifier and Type | Method and Description |
---|---|
Term |
JmlTermFactory.accessible(Term ensuresTerm) |
Term |
JmlTermFactory.assignable(Term term) |
Term |
JmlTermFactory.createLocSet(ImmutableList<SLExpression> exprList) |
Term |
JmlTermFactory.createReturns(Term term) |
Term |
JmlTermFactory.createStoreRef(SLExpression expr) |
Term |
JmlTermFactory.notModified(Term term,
SLExpression t) |
Term |
JmlIO.parseExpression(PositionedString p)
Parse and interpret the given string as an JML expression in the current context.
|
Term |
JmlIO.parseExpression(java.lang.String input)
Parses and interpret the given input as an JML expression in the current context.
|
Term |
JmlTermFactory.signals(Term result,
LogicVariable eVar,
ProgramVariable excVar,
KeYJavaType excType) |
Term |
JmlTermFactory.signalsOnly(ImmutableList<KeYJavaType> signalsonly,
ProgramVariable excVar) |
Term |
JmlIO.translateTerm(LabeledParserRuleContext expr)
Interpret the given parse tree as an JML expression in the current context.
|
Term |
JmlIO.translateTerm(LabeledParserRuleContext expr,
OriginTermLabel.SpecType type)
Interpret the given parse tree as an JML expression in the current context.
|
Term |
JmlIO.translateTerm(org.antlr.v4.runtime.ParserRuleContext expr)
Interpret the given parse tree as an JML expression in the current context.
|
Term |
JmlIO.translateTerm(org.antlr.v4.runtime.ParserRuleContext expr,
OriginTermLabel.SpecType type)
Interpret the given parse tree as an JML expression in the current context.
|
protected Term |
JmlTermFactory.typerestrict(KeYJavaType kjt,
boolean nullable,
java.lang.Iterable<? extends QuantifiableVariable> qvs)
Provide restriction terms for the declared KeYJavaType
Note that these restrictions only apply to the JML to DL translation.
|
Term |
JmlTermFactory.upperBound(Term a,
LogicVariable lv)
Extracts upper bound from
a if it matches the pattern. |
Modifier and Type | Method and Description |
---|---|
Pair<Label,Term> |
JmlTermFactory.createBreaks(Term term,
java.lang.String label) |
Pair<Label,Term> |
JmlTermFactory.createContinues(Term term,
java.lang.String label) |
Triple<IObserverFunction,Term,Term> |
JmlTermFactory.depends(SLExpression lhs,
Term rhs,
SLExpression mby) |
Triple<IObserverFunction,Term,Term> |
JmlTermFactory.depends(SLExpression lhs,
Term rhs,
SLExpression mby) |
ImmutableList<Term> |
JmlTermFactory.infflowspeclist(ImmutableList<Term> result) |
Pair<IObserverFunction,Term> |
JmlTermFactory.represents(SLExpression lhs,
Term t) |
Triple<IObserverFunction,Term,Term> |
JmlIO.translateDependencyContract(LabeledParserRuleContext ctx)
Translates a dependency contract.
|
Triple<IObserverFunction,Term,Term> |
JmlIO.translateDependencyContract(LabeledParserRuleContext ctx)
Translates a dependency contract.
|
Triple<IObserverFunction,Term,Term> |
JmlIO.translateDependencyContract(org.antlr.v4.runtime.ParserRuleContext ctx)
Translates the given context into a dependency contract, aka, accessible-clause or depends-clause.
|
Triple<IObserverFunction,Term,Term> |
JmlIO.translateDependencyContract(org.antlr.v4.runtime.ParserRuleContext ctx)
Translates the given context into a dependency contract, aka, accessible-clause or depends-clause.
|
Pair<Label,Term> |
JmlIO.translateLabeledClause(LabeledParserRuleContext parserRuleContext,
OriginTermLabel.SpecType type)
Interpret a labeled term (breaks clauses, continue clauses).
|
Pair<IObserverFunction,Term> |
JmlIO.translateRepresents(LabeledParserRuleContext clause)
Interpret a given represents clause.
|
Pair<IObserverFunction,Term> |
JmlIO.translateRepresents(org.antlr.v4.runtime.ParserRuleContext clause)
Interpret the given parse tree as a represents clause
|
Modifier and Type | Method and Description |
---|---|
Term |
JmlTermFactory.accessible(Term ensuresTerm) |
Term |
JmlTermFactory.assignable(Term term) |
SLExpression |
JmlTermFactory.commentary(java.lang.String desc,
ProgramVariable selfVar,
ProgramVariable resultVar,
ImmutableList<ProgramVariable> paramVars,
Term heapAtPre) |
Pair<Label,Term> |
JmlTermFactory.createBreaks(Term term,
java.lang.String label) |
Pair<Label,Term> |
JmlTermFactory.createContinues(Term term,
java.lang.String label) |
SLExpression |
JmlTermFactory.createIndexOf(Term seq,
Term elem) |
SLExpression |
JmlTermFactory.createIntersect(Term t,
JavaInfo javaInfo) |
SLExpression |
JmlTermFactory.createInv(Term selfVar,
KeYJavaType targetType)
Need to handle this one differently from INV_FOR
since here also static invariants may occur.
|
Term |
JmlTermFactory.createReturns(Term term) |
SLExpression |
JmlTermFactory.createUnion(JavaInfo javaInfo,
Term t) |
SLExpression |
JmlTermFactory.createUnionF(boolean nullable,
Pair<KeYJavaType,ImmutableList<LogicVariable>> declVars,
Term expr,
Term guard) |
Triple<IObserverFunction,Term,Term> |
JmlTermFactory.depends(SLExpression lhs,
Term rhs,
SLExpression mby) |
SLExpression |
JmlTermFactory.exists(Term preTerm,
Term bodyTerm,
KeYJavaType declsType,
ImmutableList<LogicVariable> declVars,
boolean nullable,
KeYJavaType resultType) |
SLExpression |
JmlTermFactory.forall(Term preTerm,
Term bodyTerm,
KeYJavaType declsType,
ImmutableList<LogicVariable> declVars,
boolean nullable,
KeYJavaType resultType) |
Term |
JmlTermFactory.notModified(Term term,
SLExpression t) |
SLExpression |
JmlTermFactory.quantifiedMax(Term _guard,
Term body,
KeYJavaType declsType,
boolean nullable,
ImmutableList<LogicVariable> qvs) |
SLExpression |
JmlTermFactory.quantifiedMin(Term _guard,
Term body,
KeYJavaType declsType,
boolean nullable,
ImmutableList<LogicVariable> qvs) |
SLExpression |
JmlTermFactory.quantifiedNumOf(Term t1,
Term t2,
KeYJavaType declsType,
boolean nullable,
java.lang.Iterable<LogicVariable> qvs,
KeYJavaType resultType) |
SLExpression |
JmlTermFactory.quantifiedProduct(KeYJavaType declsType,
boolean nullable,
java.lang.Iterable<LogicVariable> qvs,
Term t1,
Term t2,
KeYJavaType resultType) |
SLExpression |
JmlTermFactory.quantifiedSum(KeYJavaType javaType,
boolean nullable,
java.lang.Iterable<LogicVariable> qvs,
Term t1,
Term t2,
KeYJavaType resultType) |
SLExpression |
JmlTermFactory.reach(Term t,
SLExpression e1,
SLExpression e2,
SLExpression e3) |
SLExpression |
JmlTermFactory.reachLocs(Term t,
SLExpression e1,
SLExpression e2,
SLExpression e3) |
Pair<IObserverFunction,Term> |
JmlTermFactory.represents(SLExpression lhs,
Term t) |
SLExpression |
JmlTermFactory.seqConcat(Term seq1,
Term seq2) |
SLExpression |
JmlTermFactory.seqGet(Term seq,
Term idx) |
Term |
JmlTermFactory.signals(Term result,
LogicVariable eVar,
ProgramVariable excVar,
KeYJavaType excType) |
Term |
JmlTermFactory.upperBound(Term a,
LogicVariable lv)
Extracts upper bound from
a if it matches the pattern. |
Modifier and Type | Method and Description |
---|---|
JmlIO |
JmlIO.atBefore(java.util.Map<LocationVariable,Term> atBefores) |
JmlIO |
JmlIO.atPres(java.util.Map<LocationVariable,Term> atPres) |
SLExpression |
JmlTermFactory.createPairwiseDisjoint(ImmutableList<Term> list) |
SLExpression |
JmlTermFactory.fresh(ImmutableList<SLExpression> list,
java.util.Map<LocationVariable,Term> atPres) |
ImmutableList<Term> |
JmlTermFactory.infflowspeclist(ImmutableList<Term> result) |
Constructor and Description |
---|
JmlIO(Services services,
KeYJavaType specInClass,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,Term> atPres,
java.util.Map<LocationVariable,Term> atBefores)
Full constructor of this class.
|
JmlIO(Services services,
KeYJavaType specInClass,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable excVar,
java.util.Map<LocationVariable,Term> atPres,
java.util.Map<LocationVariable,Term> atBefores)
Full constructor of this class.
|
Modifier and Type | Method and Description |
---|---|
Term |
SLExpression.getTerm() |
Constructor and Description |
---|
SLExpression(Term term)
USE WITH CARE! Term-SLExpressions should have a type!
|
SLExpression(Term term,
KeYJavaType type) |
SLExpression(Term term,
KeYJavaType type,
boolean isTerm) |
Modifier and Type | Method and Description |
---|---|
protected Term |
IsInRangeProvable.createConsequence(PosInOccurrence pos,
Services services)
creates the term to be proven to follow from a (possibly empty) set of axioms
|
Modifier and Type | Method and Description |
---|---|
protected Sequent |
IsInRangeProvable.toSequent(ImmutableSet<Term> axioms,
Term toProve)
creates the sequent
axioms ==> toProve |
Modifier and Type | Method and Description |
---|---|
protected Sequent |
IsInRangeProvable.toSequent(ImmutableSet<Term> axioms,
Term toProve)
creates the sequent
axioms ==> toProve |
Modifier and Type | Method and Description |
---|---|
protected ImmutableList<Term> |
AbstractMonomialSmallerThanFeature.collectAtoms(Term t) |
ImmutableList<Term> |
SmallerThanFeature.Collector.getResult() |
Modifier and Type | Method and Description |
---|---|
protected void |
SmallerThanFeature.Collector.addTerm(Term mon) |
static boolean |
AbstractBetaFeature.alwaysReplace(Term p_t) |
protected ImmutableList<Term> |
AbstractMonomialSmallerThanFeature.collectAtoms(Term t) |
protected int |
SmallerThanFeature.compare(Term t1,
Term t2) |
protected static boolean |
AbstractBetaFeature.containsNegAtom(Term p_t,
boolean p_positive,
ServiceCaches caches) |
protected static boolean |
AbstractBetaFeature.containsQuantifier(Term p_t,
ServiceCaches caches) |
protected RuleAppCost |
ContainsQuantifierFeature.doComputation(PosInOccurrence pos,
Term findTerm,
ServiceCaches caches) |
protected RuleAppCost |
PurePosDPathFeature.doComputation(PosInOccurrence pos,
Term findTerm,
ServiceCaches caches) |
protected RuleAppCost |
CountMaxDPathFeature.doComputation(PosInOccurrence pos,
Term findTerm,
ServiceCaches caches) |
protected RuleAppCost |
LeftmostNegAtomFeature.doComputation(PosInOccurrence pos,
Term findTerm,
ServiceCaches caches) |
protected RuleAppCost |
SimplifyBetaCandidateFeature.doComputation(PosInOccurrence pos,
Term findTerm,
ServiceCaches caches) |
protected RuleAppCost |
CountPosDPathFeature.doComputation(PosInOccurrence pos,
Term findTerm,
ServiceCaches caches) |
protected abstract RuleAppCost |
AbstractBetaFeature.doComputation(PosInOccurrence pos,
Term findTerm,
ServiceCaches caches) |
protected boolean |
ThrownExceptionFeature.filter(Term term,
Services services,
ExecutionContext ec) |
protected static boolean |
AbstractBetaFeature.hasPurePosPath(Term p_t,
boolean p_positive,
ServiceCaches caches)
p_t contains a d-path consisting only of positive literals (as a formula
of the antecedent)
|
protected static boolean |
AbstractBetaFeature.isBetaCandidate(Term p_t,
boolean p_inAntec,
ServiceCaches caches) |
protected boolean |
MonomialsSmallerThanFeature.lessThan(Term t1,
Term t2,
PosInOccurrence focus,
Goal goal)
this overwrites the method of
SmallerThanFeature |
protected boolean |
SmallerThanFeature.lessThan(Term t1,
Term t2,
PosInOccurrence focus,
Goal currentGoal) |
protected boolean |
AtomsSmallerThanFeature.lessThan(Term t1,
Term t2,
PosInOccurrence focus,
Goal goal)
this overwrites the method of
SmallerThanFeature |
protected static int |
AbstractBetaFeature.maxDPath(Term p_t,
boolean p_positive,
ServiceCaches caches)
The length (number of literals) of the maximum d-path of the given
formula as a formula of the antecedent
|
protected static int |
AbstractBetaFeature.maxPosPath(Term p_t,
boolean p_positive,
ServiceCaches caches)
The maximal number of positive literals occurring within a
d-path of "p_t" as a formula of the antecedent
|
protected boolean |
SetsSmallerThanFeature.origLessThan(Term leftTerm,
Term rightTerm,
PosInOccurrence pos,
Goal goal) |
Modifier and Type | Method and Description |
---|---|
protected boolean |
SmallerThanFeature.lessThan(ImmutableList<Term> list1,
ImmutableList<Term> list2,
PosInOccurrence focus,
Goal currentGoal) |
protected boolean |
SmallerThanFeature.lessThan(ImmutableList<Term> list1,
ImmutableList<Term> list2,
PosInOccurrence focus,
Goal currentGoal) |
Modifier and Type | Method and Description |
---|---|
Term |
Substitution.apply(Term t,
TermServices services) |
Term |
Substitution.applyWithoutCasts(Term t,
TermServices services)
Try to apply the substitution to a term, introducing casts if
necessary (may never be the case any more, XXX)
|
Term |
EqualityConstraint.getDirectInstantiation(Metavariable p_mv)
Deprecated.
|
Term |
Constraint.getInstantiation(Metavariable p_mv,
Services services)
Deprecated.
Find a term the given metavariable can be instantiated with which
is consistent with every instantiation that satisfies this
constraint (that means, the term such an instantiation
substitutes the metavariable with can always be unified with the
returned term).
|
Term |
Constraint.Top.getInstantiation(Metavariable p_mv,
Services services)
Deprecated.
as this constraint is unsatisfiable it just returns the metavariable given as argument
|
Term |
EqualityConstraint.getInstantiation(Metavariable p_mv,
Services services)
Deprecated.
Find a term the given metavariable can be instantiated with which
is consistent with every instantiation that satisfies this
constraint (that means, the term such an instantiation
substitutes the metavariable with can always be unified with the
returned term).
|
Term |
TriggersSet.getQuantifiedFormula() |
Term |
Substitution.getSubstitutedTerm(QuantifiableVariable var) |
Term |
Trigger.getTriggerTerm() |
static Term |
HandleArith.provedByArith(Term problem,
Services services)
try to prove atom by using polynomial
|
static Term |
HandleArith.provedByArith(Term problem,
Term axiom,
Services services)
Try to prove problem by know that axiom is true.
|
protected Term |
ConstraintAwareSyntacticalReplaceVisitor.toTerm(Term t) |
Modifier and Type | Method and Description |
---|---|
java.util.Iterator<Term> |
HeuristicInstantiation.generate(RuleApp app,
PosInOccurrence pos,
Goal goal) |
ImmutableMap<QuantifiableVariable,Term> |
Substitution.getVarMap() |
Modifier and Type | Method and Description |
---|---|
Term |
Substitution.apply(Term t,
TermServices services) |
Term |
Substitution.applyWithoutCasts(Term t,
TermServices services)
Try to apply the substitution to a term, introducing casts if
necessary (may never be the case any more, XXX)
|
protected boolean |
LiteralsSmallerThanFeature.compareTerms(Term leftTerm,
Term rightTerm,
PosInOccurrence pos,
Goal goal) |
static long |
PredictCostProver.computerInstanceCost(Substitution sub,
Term matrix,
ImmutableSet<Term> assertList,
Services services) |
int |
QuanEliminationAnalyser.eliminableDefinition(Term definition,
PosInOccurrence envPIO) |
protected boolean |
RecAndExistentiallyConnectedClausesFeature.filter(Term term,
Services services) |
protected boolean |
EliminableQuantifierTF.filter(Term term,
Services services) |
boolean |
QuanEliminationAnalyser.isEliminableVariableAllPaths(QuantifiableVariable var,
Term matrix,
boolean ex)
The variable
var is eliminable on all
conjunctive/disjunctive paths through matrix (depending on
whether ex is true/false) |
boolean |
QuanEliminationAnalyser.isEliminableVariableSomePaths(QuantifiableVariable var,
Term matrix,
boolean ex)
The variable
var is either eliminable or does not occur on
all conjunctive/disjunctive paths through matrix
(depending on whether ex is true/false) |
protected boolean |
LiteralsSmallerThanFeature.lessThan(Term t1,
Term t2,
PosInOccurrence focus,
Goal goal)
this overwrites the method of
SmallerThanFeature |
protected boolean |
ClausesSmallerThanFeature.lessThan(Term t1,
Term t2,
PosInOccurrence focus,
Goal goal)
this overwrites the method of
SmallerThanFeature |
static ImmutableSet<Metavariable> |
EqualityConstraint.metaVars(Term t)
Deprecated.
|
static Term |
HandleArith.provedByArith(Term problem,
Services services)
try to prove atom by using polynomial
|
static Term |
HandleArith.provedByArith(Term problem,
Term axiom,
Services services)
Try to prove problem by know that axiom is true.
|
boolean |
Substitution.termContainsValue(Term term) |
protected Term |
ConstraintAwareSyntacticalReplaceVisitor.toTerm(Term t) |
Constraint |
Constraint.unify(Term t1,
Term t2,
TermServices services)
Deprecated.
tries to unify the terms t1 and t2
|
Constraint |
Constraint.Top.unify(Term t1,
Term t2,
TermServices services)
Deprecated.
adding new constraints to an unsatisfiable constraint results in an
unsatisfiable constraint so this one is returned
|
Constraint |
EqualityConstraint.unify(Term t1,
Term t2,
TermServices services)
Deprecated.
unifies terms t1 and t2
|
Constraint |
Constraint.unify(Term t1,
Term t2,
TermServices services,
BooleanContainer unchanged)
Deprecated.
tries to unify terms t1 and t2.
|
Constraint |
Constraint.Top.unify(Term t1,
Term t2,
TermServices services,
BooleanContainer unchanged)
Deprecated.
|
Constraint |
EqualityConstraint.unify(Term t1,
Term t2,
TermServices services,
BooleanContainer unchanged)
Deprecated.
executes unification for terms t1 and t2.
|
void |
ConstraintAwareSyntacticalReplaceVisitor.visited(Term visited) |
Modifier and Type | Method and Description |
---|---|
static long |
PredictCostProver.computerInstanceCost(Substitution sub,
Term matrix,
ImmutableSet<Term> assertList,
Services services) |
ImmutableSet<Substitution> |
Trigger.getSubstitutionsFromTerms(ImmutableSet<Term> targetTerm,
Services services) |
Constructor and Description |
---|
Substitution(ImmutableMap<QuantifiableVariable,Term> map) |
Modifier and Type | Method and Description |
---|---|
RuleAppCost |
SubTermFeature.compute(Term term,
Services services) |
RuleAppCost |
BinarySumTermFeature.compute(Term term,
Services services) |
RuleAppCost |
RecSubTermFeature.compute(Term term,
Services services) |
RuleAppCost |
ConstTermFeature.compute(Term term,
Services services) |
RuleAppCost |
ShannonTermFeature.compute(Term term,
Services services) |
RuleAppCost |
BinaryTermFeature.compute(Term term,
Services services) |
RuleAppCost |
PrintTermFeature.compute(Term term,
Services services) |
RuleAppCost |
TermFeature.compute(Term term,
Services services) |
protected boolean |
OperatorTF.filter(Term term,
Services services) |
protected boolean |
AtomTermFeature.filter(Term term,
Services services) |
protected boolean |
IsPostConditionTermFeature.filter(Term t,
Services services) |
protected boolean |
TermLabelTermFeature.filter(Term term,
Services services) |
protected boolean |
EqTermFeature.filter(Term term,
Services services) |
protected boolean |
AnonHeapTermFeature.filter(Term t,
Services services) |
protected boolean |
IsInductionVariable.filter(Term term,
Services services) |
protected boolean |
PrimitiveHeapTermFeature.filter(Term t,
Services services) |
protected boolean |
IsNonRigidTermFeature.filter(Term term,
Services services) |
protected boolean |
SimplifiedSelectTermFeature.filter(Term t,
Services services) |
protected boolean |
SortExtendsTransTermFeature.filter(Term term,
Services services) |
protected boolean |
OperatorClassTF.filter(Term term,
Services services) |
protected boolean |
ClosedExpressionTermFeature.filter(Term term,
Services services) |
protected boolean |
IsSelectSkolemConstantTermFeature.filter(Term t,
Services services) |
protected abstract boolean |
BinaryTermFeature.filter(Term term,
Services services) |
protected boolean |
IsHeapFunctionTermFeature.filter(Term t,
Services services) |
protected boolean |
ContainsExecutableCodeTermFeature.filter(Term t,
Services services) |
protected boolean |
ConstantTermFeature.filter(Term term,
Services services) |
Modifier and Type | Method and Description |
---|---|
protected Term |
SuperTermGenerator.generateOneTerm(Term superterm,
int child) |
protected Term |
SubtermGenerator.getTermInst(RuleApp app,
PosInOccurrence pos,
Goal goal) |
Modifier and Type | Method and Description |
---|---|
protected abstract java.util.Iterator<Term> |
SuperTermGenerator.createIterator(PosInOccurrence focus) |
java.util.Iterator<Term> |
HeapGenerator.generate(RuleApp app,
PosInOccurrence pos,
Goal goal) |
java.util.Iterator<Term> |
TriggeredInstantiations.generate(RuleApp app,
PosInOccurrence pos,
Goal goal) |
java.util.Iterator<Term> |
MultiplesModEquationsGenerator.generate(RuleApp app,
PosInOccurrence pos,
Goal goal) |
java.util.Iterator<Term> |
TermGenerator.generate(RuleApp app,
PosInOccurrence pos,
Goal goal) |
java.util.Iterator<Term> |
AllowedCutPositionsGenerator.generate(RuleApp app,
PosInOccurrence pos,
Goal goal) |
java.util.Iterator<Term> |
SequentFormulasGenerator.generate(RuleApp app,
PosInOccurrence pos,
Goal goal) |
java.util.Iterator<Term> |
RootsGenerator.generate(RuleApp app,
PosInOccurrence pos,
Goal goal) |
java.util.Iterator<Term> |
SuperTermGenerator.generate(RuleApp app,
PosInOccurrence pos,
Goal goal) |
Modifier and Type | Method and Description |
---|---|
protected Term |
SuperTermGenerator.generateOneTerm(Term superterm,
int child) |
Modifier and Type | Method and Description |
---|---|
protected Term |
MonomialColumnOp.divide(Monomial numerator,
java.math.BigInteger denominator,
Services services) |
protected abstract Term |
AbstractDividePolynomialsProjection.divide(Monomial numerator,
java.math.BigInteger denominator,
Services services) |
Term |
TermBuffer.getContent() |
Term |
TermBuffer.toTerm(RuleApp app,
PosInOccurrence pos,
Goal goal) |
Term |
AssumptionProjection.toTerm(RuleApp app,
PosInOccurrence pos,
Goal goal) |
Term |
ProjectionToTerm.toTerm(RuleApp app,
PosInOccurrence pos,
Goal goal) |
Term |
TermConstructionProjection.toTerm(RuleApp app,
PosInOccurrence pos,
Goal goal) |
Term |
SVInstantiationProjection.toTerm(RuleApp app,
PosInOccurrence pos,
Goal goal) |
Term |
CoeffGcdProjection.toTerm(RuleApp app,
PosInOccurrence pos,
Goal goal) |
Term |
SubtermProjection.toTerm(RuleApp app,
PosInOccurrence pos,
Goal goal) |
Term |
TriggerVariableInstantiationProjection.toTerm(RuleApp app,
PosInOccurrence pos,
Goal goal) |
Term |
AbstractDividePolynomialsProjection.toTerm(RuleApp app,
PosInOccurrence pos,
Goal goal) |
Term |
ReduceMonomialsProjection.toTerm(RuleApp app,
PosInOccurrence pos,
Goal goal) |
Term |
FocusProjection.toTerm(RuleApp app,
PosInOccurrence pos,
Goal goal) |
Term |
FocusFormulaProjection.toTerm(RuleApp app,
PosInOccurrence pos,
Goal goal) |
Modifier and Type | Method and Description |
---|---|
void |
TermBuffer.setContent(Term t) |
Modifier and Type | Method and Description |
---|---|
protected static Term |
TruthValueTracingUtil.checkForNewMinorIds(Node childNode,
FormulaTermLabel label,
boolean antecedentRuleApplication,
TermBuilder tb)
Checks if new minor IDs are available.
|
protected static Term |
TruthValueTracingUtil.checkForNewMinorIdsOSS(SequentFormula onlyChangedChildSF,
FormulaTermLabel label,
boolean antecedentRuleApplication,
TermBuilder tb)
Checks if new minor IDs are available in case of
OneStepSimplifier usage. |
protected Term |
AbstractUpdateExtractor.computeBranchCondition(Node node,
java.util.Map<Node,Term> branchConditionCache,
boolean simplifyConditions)
Computes the branch condition if not already present in the cache
and stores it in the cache.
|
protected static Term |
TruthValueTracingUtil.computeInstructionTerm(java.util.List<Term> antecedentReplacements,
java.util.List<Term> succedentReplacements,
boolean antecedentRuleApplication,
TermBuilder tb)
Computes the
Term with the instruction how to compute the truth
value based on the found replacements. |
protected Term |
AbstractUpdateExtractor.createLocationPredicateAndTerm(java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> valueSelectParameter)
Creates a predicate and a
Term which can be used to compute the
values defined by the given AbstractUpdateExtractor.ExtractLocationParameter s. |
Term |
AbstractUpdateExtractor.ExtractLocationParameter.createPreParentTerm()
Creates the
Term to compute the parent object with help of the pre update. |
Term |
AbstractUpdateExtractor.ExtractLocationParameter.createPreUpdate()
Creates the pre update to make sure that the parent object defined
by the expression is evaluated on the initial state because it might
be changed in the current state due to updates.
|
Term |
AbstractUpdateExtractor.ExtractLocationParameter.createPreValueTerm()
Computes the
Term to compute the value with help of the pre update. |
Term |
ExecutionNodeReader.KeYlessVariable.createSelectTerm()
Creates recursive a term which can be used to determine the value
of
IExecutionVariable.getProgramVariable() . |
Term |
ExecutionVariableExtractor.ExtractedExecutionVariable.createSelectTerm()
Creates recursive a term which can be used to determine the value
of
IExecutionVariable.getProgramVariable() . |
Term |
ExecutionNodeReader.KeYlessVariable.getAdditionalCondition()
Returns the optional additional condition considered during value computation.
|
Term |
ExecutionVariableExtractor.ExtractedExecutionVariable.getArrayEndIndex()
Returns the array end index.
|
Term |
AbstractUpdateExtractor.ExtractLocationParameter.getArrayEndIndex()
Returns the array end index.
|
Term |
AbstractUpdateExtractor.ExecutionVariableValuePair.getArrayEndIndex()
Returns the array end index.
|
Term |
SymbolicLayoutReader.KeYlessValue.getArrayIndex()
Returns the represented array index or
null if a program variable is represented.. |
Term |
SymbolicLayoutReader.KeYlessAssociation.getArrayIndex()
Returns the represented array index or
null if a program variable is represented.. |
Term |
ExecutionNodeReader.KeYlessVariable.getArrayIndex()
Returns the index in the parent array if an array cell value is represented.
|
Term |
AbstractUpdateExtractor.ExtractLocationParameter.getArrayIndex()
Returns the array index.
|
Term |
AbstractUpdateExtractor.ExecutionVariableValuePair.getArrayIndex()
Returns the array index.
|
Term |
AbstractUpdateExtractor.ExtractLocationParameter.getArrayRangeConstant()
Returns the constant used to query an array range.
|
Term |
ExecutionVariableExtractor.ExtractedExecutionVariable.getArrayStartIndex()
Returns the array start index.
|
Term |
AbstractUpdateExtractor.ExtractLocationParameter.getArrayStartIndex()
Returns the array start index.
|
Term |
AbstractUpdateExtractor.ExecutionVariableValuePair.getArrayStartIndex()
Returns the array start index.
|
Term |
ExecutionNodeReader.AbstractKeYlessExecutionNode.getBlockCompletionCondition(IExecutionBlockStartNode<?> completedNode)
Returns the condition under which this node completes the code block of the given
IExecutionBlockStartNode . |
Term |
ExecutionNodeReader.KeYlessBranchCondition.getBranchCondition()
Returns the branch condition as
Term . |
Term |
TruthValueTracingUtil.BranchResult.getCondition()
|
Term |
SymbolicLayoutReader.KeYlessValue.getCondition()
Returns the optional condition under which this value is valid.
|
Term |
SymbolicLayoutReader.KeYlessAssociation.getCondition()
Returns the optional condition under which this association is valid.
|
Term |
ExecutionNodeReader.KeYlessMethodReturnValue.getCondition()
Returns the optional condition under which the return value is valid.
|
Term |
ExecutionNodeReader.KeYlessValue.getCondition()
Returns the condition under which the variable (
IExecutionValue.getVariable() )
has this value. |
Term |
AbstractUpdateExtractor.ExecutionVariableValuePair.getCondition()
Returns the optional condition under which the value is valid.
|
Term |
ExecutionNodeReader.KeYlessOperationContract.getExceptionTerm()
|
Term |
TruthValueTracingUtil.MultiEvaluationResult.getInstructionTerm()
Returns the instruction
Term . |
Term[] |
ExecutionNodeReader.KeYlessBranchCondition.getMergedBranchCondtions()
Returns the branch condition
Term s. |
Term |
ExecutionNodeReader.AbstractKeYlessBaseExecutionNode.getMethodReturnCondition()
Returns the condition under which this method return is reached from
the calling
IExecutionMethodCall . |
Term |
SymbolicLayoutReader.KeYlessObject.getName()
Returns the name of this object.
|
Term |
AbstractUpdateExtractor.ExtractLocationParameter.getNotAValue()
Returns the constant representing the fact that no value is available.
|
Term |
AbstractUpdateExtractor.ExecutionVariableValuePair.getParent()
Returns the optional parent object or
null if it is a value/association of the state. |
Term |
AbstractUpdateExtractor.ExtractLocationParameter.getParentTerm()
Returns the optional parent object represented as
Term . |
Term |
ExecutionNodeReader.AbstractKeYlessExecutionNode.getPathCondition()
Returns the path condition to reach this node as
Term . |
Term |
AbstractUpdateExtractor.ExtractLocationParameter.getPreUpdateTarget()
Returns the right side of the update created by
AbstractUpdateExtractor.ExtractLocationParameter.createPreUpdate() . |
Term |
SymbolicLayoutReader.KeYlessEquivalenceClass.getRepresentative()
Returns the most representative term.
|
Term |
ExecutionNodeReader.KeYlessOperationContract.getResultTerm()
|
Term |
ExecutionNodeReader.KeYlessMethodReturnValue.getReturnValue()
Returns the return value.
|
Term |
ExecutionNodeReader.KeYlessOperationContract.getSelfTerm()
|
Term |
ExecutionNodeReader.KeYlessConstraint.getTerm()
Returns the
Term representing the constraint. |
Term |
SymbolicLayoutReader.KeYlessValue.getValue()
Returns the value of the represented variable.
|
Term |
ExecutionNodeReader.KeYlessValue.getValue()
Returns the value of the variable.
|
Term |
AbstractUpdateExtractor.ExecutionVariableValuePair.getValue()
Returns the value or association target.
|
protected Term |
AbstractUpdateExtractor.removeImplicitSubTermsFromPathCondition(Term pathCondition)
Removes all conditions from the given path condition which contains
implicit
IProgramVariable s. |
Modifier and Type | Method and Description |
---|---|
protected java.util.List<Term> |
AbstractUpdateExtractor.collectAdditionalUpdates()
Collects additional updates.
|
protected java.util.Set<Term> |
SymbolicLayoutExtractor.collectObjectsFromSequent(Sequent sequent,
java.util.Set<Term> objectsToIgnore)
Collects all objects which are used in the conditions of the
Sequent . |
protected java.util.Set<Term> |
SymbolicLayoutExtractor.collectSymbolicObjectsFromTerm(Term term,
java.util.Set<Term> objectsToIgnore)
Collects all objects which are used in the given
Term . |
protected java.util.Set<Term> |
AbstractUpdateExtractor.computeInitialObjectsToIgnore(boolean ignoreExceptionVariable,
boolean ignoreOldStateVariables)
Computes objects which should be ignored in the state because
they are part of the proof obligation and not of the source code.
|
protected ImmutableList<Term> |
AbstractUpdateExtractor.computeOriginalUpdates(PosInOccurrence pio,
boolean currentLayout)
Computes the original updates.
|
protected java.util.Map<Goal,Term> |
AbstractUpdateExtractor.computeValueConditions(java.util.Set<Goal> valueGoals,
java.util.Map<Node,Term> branchConditionCache,
boolean simplifyConditions)
This method computes for all given
Goal s representing the same
value their path conditions. |
protected java.util.List<ImmutableSet<Term>> |
SymbolicLayoutExtractor.extractAppliedCutsFromGoals(Proof proof)
Extracts the possible memory layouts from the given side proof.
|
protected ImmutableSet<Term> |
SymbolicLayoutExtractor.extractAppliedCutsSet(Node goalnode,
Node root)
Extracts the applied cut rules in the given
Node . |
protected ImmutableList<Term> |
SymbolicLayoutExtractor.extractInitialUpdates()
Computes the initial updates to consider.
|
protected java.util.Set<Term> |
SymbolicLayoutExtractor.filterOutObjectsToIgnore(java.util.Set<Term> objectsToFilter,
java.util.Set<Term> objectsToIgnore)
Filters out the objects from the second
Set in the first Set . |
ImmutableList<Term> |
ExecutionNodeReader.KeYlessOperationContract.getContractParams()
Returns the parameters of the called method for which a
Contract is applied. |
ImmutableList<Term> |
SymbolicLayoutReader.KeYlessEquivalenceClass.getTerms()
Returns the terms which represents the same
ISymbolicObject . |
protected java.util.Set<Term> |
SymbolicLayoutExtractor.sortTerms(java.util.Set<Term> terms)
Sorts the given
Term s alphabetically. |
protected Pair<java.lang.Boolean,ImmutableList<Term>> |
ExecutionVariableExtractor.updateAlreadyVisitedObjects(ImmutableList<Term> alreadyVisitedObjects,
Term value)
Updates the already visited objects list if required.
|
Modifier and Type | Method and Description |
---|---|
protected void |
SymbolicLayoutExtractor.applyCut(ProofStarter starter,
Term term,
int maxProofSteps)
Applies one single cut rule for the given
Term . |
protected static void |
TruthValueTracingUtil.checkForNewMinorIds(Node childNode,
Term term,
Name termLabelName,
PosInOccurrence parentPio,
TermBuilder tb,
java.util.Map<java.lang.String,TruthValueTracingUtil.MultiEvaluationResult> results)
Checks if new minor IDs are available.
|
protected static void |
TruthValueTracingUtil.checkForNewMinorIdsOSS(SequentFormula onlyChangedChildSF,
Term term,
Name termLabelName,
PosInOccurrence parentPio,
TermBuilder tb,
java.util.Map<java.lang.String,TruthValueTracingUtil.MultiEvaluationResult> results)
Checks if new minor IDs are available in case of
OneStepSimplifier usage. |
protected void |
AbstractUpdateExtractor.collectLocationsFromHeapTerms(Term selectTerm,
Term variableTerm,
HeapLDT heapLDT,
java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> toFill,
java.util.Set<Term> objectsToIgnore)
Collects the
AbstractUpdateExtractor.ExtractLocationParameter location from the heap Term s. |
protected void |
AbstractUpdateExtractor.collectLocationsFromHeapUpdate(Term term,
java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> locationsToFill,
java.util.Set<Term> updateCreatedObjectsToFill,
java.util.Set<Term> updateValueObjectsToFill)
|
protected void |
AbstractUpdateExtractor.collectLocationsFromTerm(java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> toFill,
Term term,
java.util.Set<Term> objectsToIgnore)
Utility method of
AbstractUpdateExtractor.extractLocationsFromTerm(Term, Set) which
recursively extracts the locations. |
protected void |
AbstractUpdateExtractor.collectLocationsFromTerm(Term updateTerm,
java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> locationsToFill,
java.util.Set<Term> updateCreatedObjectsToFill,
java.util.Set<Term> updateValueObjectsToFill,
java.util.Set<Term> objectsToIgnore)
|
protected java.util.Set<Term> |
SymbolicLayoutExtractor.collectSymbolicObjectsFromTerm(Term term,
java.util.Set<Term> objectsToIgnore)
Collects all objects which are used in the given
Term . |
protected java.util.Set<AbstractUpdateExtractor.ExecutionVariableValuePair> |
AbstractUpdateExtractor.computeVariableValuePairs(Term layoutCondition,
Term layoutTerm,
java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> locations,
boolean currentLayout,
boolean simplifyConditions)
The method starts a side proof with the given arguments to compute
the values and objects of the requested memory layout.
|
protected boolean |
AbstractUpdateExtractor.containsImplicitProgramVariable(Term term)
Checks if the given
Term contains an implicit IProgramVariable . |
boolean |
SymbolicLayoutReader.KeYlessEquivalenceClass.containsTerm(Term term)
Checks if a
Term is contained. |
protected void |
SymbolicLayoutExtractor.createObjectForTerm(java.util.Map<Term,SymbolicObject> objects,
ImmutableList<ISymbolicEquivalenceClass> equivalentClasses,
SymbolicLayout result,
Term objectTerm)
Creates for the object defined by the given
Term an SymbolicObject instance if not already available. |
protected java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> |
AbstractUpdateExtractor.extractLocationsFromTerm(Term term,
java.util.Set<Term> objectsToIgnore)
|
protected void |
AbstractUpdateExtractor.fillInitialObjectsToIgnoreRecursively(Term term,
java.util.Set<Term> toFill)
Utility method of
#computeInitialObjectsToIgnore() which
computes the objects to ignore recursively. |
protected ISymbolicEquivalenceClass |
SymbolicLayoutExtractor.findEquivalentClass(ImmutableList<ISymbolicEquivalenceClass> equivalentClasses,
Term term)
Searches the
ISymbolicEquivalenceClass from the given one
which contains the given Term . |
ISymbolicAssociation |
SymbolicLayoutReader.KeYlessState.getAssociation(IProgramVariable programVariable,
boolean isArrayIndex,
Term arrayIndex,
Term condition)
Returns the
ISymbolicAssociation with the given IProgramVariable . |
ISymbolicAssociation |
SymbolicLayoutReader.KeYlessObject.getAssociation(IProgramVariable programVariable,
boolean isArrayIndex,
Term arrayIndex,
Term condition)
Returns the
ISymbolicAssociation with the given IProgramVariable . |
FormulaTermLabel |
TruthValueTracingUtil.BranchResult.getPredicateLabel(Term term)
|
ISymbolicValue |
SymbolicLayoutReader.KeYlessState.getValue(IProgramVariable programVariable,
boolean isArrayIndex,
Term arrayIndex,
Term condition)
Returns the
ISymbolicValue with the given IProgramVariable . |
ISymbolicValue |
SymbolicLayoutReader.KeYlessObject.getValue(IProgramVariable programVariable,
boolean isArrayIndex,
Term arrayIndex,
Term condition)
Returns the
ISymbolicValue with the given IProgramVariable . |
IExecutionVariable[] |
ExecutionNodeReader.AbstractKeYlessExecutionNode.getVariables(Term condition)
Returns the variable value pairs of the current state under the given condition.
|
protected boolean |
AbstractUpdateExtractor.hasFreeVariables(Term term)
Checks if the given
Term has free variables. |
boolean |
TruthValueTracingUtil.BranchResult.hasPredicateLabel(Term term)
|
static boolean |
TruthValueTracingUtil.isIfThenElseFormula(Term term)
Checks if the given
Term is an if-then-else formula. |
static boolean |
TruthValueTracingUtil.isLogicOperator(Term term)
Checks if the given
Term is a logical operator |
static boolean |
TruthValueTracingUtil.isPredicate(Term term)
Checks if the given
Term is a predicate. |
TruthValueTracingUtil.MultiEvaluationResult |
TruthValueTracingUtil.MultiEvaluationResult.newInstructionTerm(Term newInstructionTerm)
Creates a new
TruthValueTracingUtil.MultiEvaluationResult based on the current once
but with an update instruction term. |
protected Term |
AbstractUpdateExtractor.removeImplicitSubTermsFromPathCondition(Term pathCondition)
Removes all conditions from the given path condition which contains
implicit
IProgramVariable s. |
protected Pair<java.lang.Boolean,ImmutableList<Term>> |
ExecutionVariableExtractor.updateAlreadyVisitedObjects(ImmutableList<Term> alreadyVisitedObjects,
Term value)
Updates the already visited objects list if required.
|
protected static void |
TruthValueTracingUtil.updatePredicateResult(FormulaTermLabel label,
Term instructionTerm,
java.util.Map<java.lang.String,TruthValueTracingUtil.MultiEvaluationResult> results)
|
Modifier and Type | Method and Description |
---|---|
protected void |
SymbolicLayoutExtractor.applyCutRules(ProofStarter starter,
java.util.Set<Term> symbolicObjects,
ImmutableList<Term> updates)
Applies cut rules to the given side proofs to compute equivalence classes.
|
protected void |
SymbolicLayoutExtractor.applyCutRules(ProofStarter starter,
java.util.Set<Term> symbolicObjects,
ImmutableList<Term> updates)
Applies cut rules to the given side proofs to compute equivalence classes.
|
protected void |
AbstractUpdateExtractor.collectLocationsFromHeapTerms(Term selectTerm,
Term variableTerm,
HeapLDT heapLDT,
java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> toFill,
java.util.Set<Term> objectsToIgnore)
Collects the
AbstractUpdateExtractor.ExtractLocationParameter location from the heap Term s. |
protected void |
AbstractUpdateExtractor.collectLocationsFromHeapUpdate(Term term,
java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> locationsToFill,
java.util.Set<Term> updateCreatedObjectsToFill,
java.util.Set<Term> updateValueObjectsToFill)
|
protected void |
AbstractUpdateExtractor.collectLocationsFromHeapUpdate(Term term,
java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> locationsToFill,
java.util.Set<Term> updateCreatedObjectsToFill,
java.util.Set<Term> updateValueObjectsToFill)
|
protected void |
AbstractUpdateExtractor.collectLocationsFromTerm(java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> toFill,
Term term,
java.util.Set<Term> objectsToIgnore)
Utility method of
AbstractUpdateExtractor.extractLocationsFromTerm(Term, Set) which
recursively extracts the locations. |
protected void |
AbstractUpdateExtractor.collectLocationsFromTerm(Term updateTerm,
java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> locationsToFill,
java.util.Set<Term> updateCreatedObjectsToFill,
java.util.Set<Term> updateValueObjectsToFill,
java.util.Set<Term> objectsToIgnore)
|
protected void |
AbstractUpdateExtractor.collectLocationsFromTerm(Term updateTerm,
java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> locationsToFill,
java.util.Set<Term> updateCreatedObjectsToFill,
java.util.Set<Term> updateValueObjectsToFill,
java.util.Set<Term> objectsToIgnore)
|
protected void |
AbstractUpdateExtractor.collectLocationsFromTerm(Term updateTerm,
java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> locationsToFill,
java.util.Set<Term> updateCreatedObjectsToFill,
java.util.Set<Term> updateValueObjectsToFill,
java.util.Set<Term> objectsToIgnore)
|
protected void |
AbstractUpdateExtractor.collectLocationsFromUpdates(Sequent sequent,
java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> locationsToFill,
java.util.Set<Term> updateCreatedObjectsToFill,
java.util.Set<Term> updateValueObjectsToFill,
java.util.Set<Term> objectsToIgnore)
|
protected void |
AbstractUpdateExtractor.collectLocationsFromUpdates(Sequent sequent,
java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> locationsToFill,
java.util.Set<Term> updateCreatedObjectsToFill,
java.util.Set<Term> updateValueObjectsToFill,
java.util.Set<Term> objectsToIgnore)
|
protected void |
AbstractUpdateExtractor.collectLocationsFromUpdates(Sequent sequent,
java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> locationsToFill,
java.util.Set<Term> updateCreatedObjectsToFill,
java.util.Set<Term> updateValueObjectsToFill,
java.util.Set<Term> objectsToIgnore)
|
protected java.util.Set<Term> |
SymbolicLayoutExtractor.collectObjectsFromSequent(Sequent sequent,
java.util.Set<Term> objectsToIgnore)
Collects all objects which are used in the conditions of the
Sequent . |
protected java.util.Set<Term> |
SymbolicLayoutExtractor.collectSymbolicObjectsFromTerm(Term term,
java.util.Set<Term> objectsToIgnore)
Collects all objects which are used in the given
Term . |
protected Term |
AbstractUpdateExtractor.computeBranchCondition(Node node,
java.util.Map<Node,Term> branchConditionCache,
boolean simplifyConditions)
Computes the branch condition if not already present in the cache
and stores it in the cache.
|
protected static Term |
TruthValueTracingUtil.computeInstructionTerm(java.util.List<Term> antecedentReplacements,
java.util.List<Term> succedentReplacements,
boolean antecedentRuleApplication,
TermBuilder tb)
Computes the
Term with the instruction how to compute the truth
value based on the found replacements. |
protected static Term |
TruthValueTracingUtil.computeInstructionTerm(java.util.List<Term> antecedentReplacements,
java.util.List<Term> succedentReplacements,
boolean antecedentRuleApplication,
TermBuilder tb)
Computes the
Term with the instruction how to compute the truth
value based on the found replacements. |
protected java.util.Map<Goal,Term> |
AbstractUpdateExtractor.computeValueConditions(java.util.Set<Goal> valueGoals,
java.util.Map<Node,Term> branchConditionCache,
boolean simplifyConditions)
This method computes for all given
Goal s representing the same
value their path conditions. |
protected void |
SymbolicLayoutExtractor.createObjectForTerm(java.util.Map<Term,SymbolicObject> objects,
ImmutableList<ISymbolicEquivalenceClass> equivalentClasses,
SymbolicLayout result,
Term objectTerm)
Creates for the object defined by the given
Term an SymbolicObject instance if not already available. |
protected void |
ExecutionVariableExtractor.createValues(IExecutionVariable variable,
java.util.List<AbstractUpdateExtractor.ExecutionVariableValuePair> pairs,
AbstractUpdateExtractor.ExecutionVariableValuePair firstPair,
java.util.Map<de.uka.ilkd.key.symbolic_execution.ExecutionVariableExtractor.ParentDefinition,java.util.Map<de.uka.ilkd.key.symbolic_execution.ExecutionVariableExtractor.LocationDefinition,java.util.List<AbstractUpdateExtractor.ExecutionVariableValuePair>>> contentMap,
java.util.List<IExecutionValue> valueListToFill,
ImmutableList<Term> alreadyVisitedObjects)
Creates the
IExecutionValue s of the given IExecutionVariable . |
protected IExecutionVariable |
ExecutionVariableExtractor.createVariablesValueStructure(java.util.List<AbstractUpdateExtractor.ExecutionVariableValuePair> pairs,
java.util.Map<de.uka.ilkd.key.symbolic_execution.ExecutionVariableExtractor.ParentDefinition,java.util.Map<de.uka.ilkd.key.symbolic_execution.ExecutionVariableExtractor.LocationDefinition,java.util.List<AbstractUpdateExtractor.ExecutionVariableValuePair>>> contentMap,
ExecutionVariableExtractor.ExtractedExecutionValue parentValue,
ImmutableList<Term> alreadyVisitedObjects)
Creates an
IExecutionVariable for the given ExecutionVariableValuePair s. |
protected java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> |
AbstractUpdateExtractor.extractLocationsFromSequent(Sequent sequent,
java.util.Set<Term> objectsToIgnore)
|
protected java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> |
AbstractUpdateExtractor.extractLocationsFromTerm(Term term,
java.util.Set<Term> objectsToIgnore)
|
protected void |
AbstractUpdateExtractor.fillInitialObjectsToIgnoreRecursively(Term term,
java.util.Set<Term> toFill)
Utility method of
#computeInitialObjectsToIgnore() which
computes the objects to ignore recursively. |
protected java.util.Set<Term> |
SymbolicLayoutExtractor.filterOutObjectsToIgnore(java.util.Set<Term> objectsToFilter,
java.util.Set<Term> objectsToIgnore)
Filters out the objects from the second
Set in the first Set . |
protected java.util.Set<Term> |
SymbolicLayoutExtractor.filterOutObjectsToIgnore(java.util.Set<Term> objectsToFilter,
java.util.Set<Term> objectsToIgnore)
Filters out the objects from the second
Set in the first Set . |
static boolean |
TruthValueTracingUtil.isIfThenElseFormula(Operator operator,
ImmutableArray<Term> subs)
|
static boolean |
TruthValueTracingUtil.isLogicOperator(Operator operator,
ImmutableArray<Term> subs)
|
protected ImmutableList<ISymbolicEquivalenceClass> |
SymbolicLayoutExtractor.lazyComputeEquivalenceClasses(ImmutableSet<Term> appliedCuts)
Computes the equivalence classes from the given applied cut rules
lazily when
SymbolicLayoutExtractor.getEquivalenceClasses(int) is called the first time. |
protected ISymbolicLayout |
SymbolicLayoutExtractor.lazyComputeLayout(ImmutableSet<Term> layout,
java.util.Set<AbstractUpdateExtractor.ExtractLocationParameter> locations,
ImmutableList<ISymbolicEquivalenceClass> equivalentClasses,
java.lang.String stateName,
boolean currentLayout)
Computes a memory layout lazily when it is first time requested via
#getLayout(Map, int, Term, Set, String, boolean) . |
protected static void |
TruthValueTracingUtil.listLabelReplacements(SequentFormula sf,
Name labelName,
java.lang.String labelId,
java.util.List<Term> resultToFill)
Lists all label replacements in the given
SequentFormula . |
protected java.util.Set<Term> |
SymbolicLayoutExtractor.sortTerms(java.util.Set<Term> terms)
Sorts the given
Term s alphabetically. |
protected Pair<java.lang.Boolean,ImmutableList<Term>> |
ExecutionVariableExtractor.updateAlreadyVisitedObjects(ImmutableList<Term> alreadyVisitedObjects,
Term value)
Updates the already visited objects list if required.
|
Constructor and Description |
---|
BranchResult(Node leafNode,
java.util.Map<java.lang.String,TruthValueTracingUtil.MultiEvaluationResult> results,
Term condition,
java.lang.String conditionString,
Name termLabelName)
Constructor.
|
ExecutionVariableExtractor(Node node,
PosInOccurrence modalityPio,
IExecutionNode<?> executionNode,
Term condition,
boolean simplifyConditions)
Constructor.
|
ExecutionVariableValuePair(ProgramVariable programVariable,
Term parent,
Term value,
Term condition,
boolean stateMember,
Node goalNode)
Constructor.
|
ExecutionVariableValuePair(Term arrayIndex,
Term parent,
Term value,
Term condition,
boolean stateMember,
Node goalNode)
Constructor.
|
ExecutionVariableValuePair(Term arrayStartIndex,
Term arrayEndIndex,
Term arrayRangeConstant,
Term parent,
Term value,
Term condition,
boolean stateMember,
Node goalNode)
Constructor.
|
ExtractedExecutionValue(IExecutionNode<?> parentNode,
Node proofNode,
IExecutionVariable variable,
Term condition,
Term value)
Constructor.
|
ExtractedExecutionVariable(IExecutionNode<?> parentNode,
Node proofNode,
PosInOccurrence modalityPIO,
IProgramVariable programVariable,
Term arrayIndex,
Term arrayStartIndex,
Term arrayEndIndex,
Term additionalCondition,
ExecutionVariableExtractor.ExtractedExecutionValue parentValue)
Constructor.
|
ExtractLocationParameter(AbstractUpdateExtractor.ExtractLocationParameter original,
Term newParent)
Constructor for cloning purpose.
|
ExtractLocationParameter(ProgramVariable programVariable,
Term parentTerm)
Constructor.
|
ExtractLocationParameter(ProgramVariable programVariable,
Term parentTerm,
boolean stateMember)
Constructor.
|
ExtractLocationParameter(Term arrayIndex,
Term parentTerm)
Constructor.
|
ExtractLocationParameter(Term arrayStartIndex,
Term arrayEndIndex,
Term parentTerm)
Constructor.
|
MultiEvaluationResult(boolean evaluatesToTrue,
boolean evaluatesToFalse,
Term instructionTerm)
Constructor.
|
MultiEvaluationResult(Term instructionTerm)
Constructor.
|
Modifier and Type | Method and Description |
---|---|
Term |
IExecutionVariable.createSelectTerm()
Creates recursive a term which can be used to determine the value
of
IExecutionVariable.getProgramVariable() . |
Term |
IExecutionVariable.getAdditionalCondition()
Returns the optional additional condition considered during value computation.
|
Term |
IExecutionVariable.getArrayIndex()
Returns the index in the parent array if an array cell value is represented.
|
Term |
IExecutionNode.getBlockCompletionCondition(IExecutionBlockStartNode<?> completedNode)
Returns the condition under which this node completes the code block of the given
IExecutionBlockStartNode . |
Term |
IExecutionBranchCondition.getBranchCondition()
Returns the branch condition as
Term . |
Term |
IExecutionValue.getCondition()
Returns the condition under which the variable (
IExecutionValue.getVariable() )
has this value. |
Term |
IExecutionMethodReturnValue.getCondition()
Returns the optional condition under which the return value is valid.
|
Term |
IExecutionOperationContract.getExceptionTerm()
|
Term[] |
IExecutionBranchCondition.getMergedBranchCondtions()
Returns the branch condition
Term s. |
Term |
IExecutionBaseMethodReturn.getMethodReturnCondition()
Returns the condition under which this method return is reached from
the calling
IExecutionMethodCall . |
Term |
IExecutionNode.getPathCondition()
Returns the path condition to reach this node as
Term . |
Term |
IExecutionOperationContract.getResultTerm()
|
Term |
IExecutionMethodReturnValue.getReturnValue()
Returns the return value.
|
Term |
IExecutionOperationContract.getSelfTerm()
|
Term |
IExecutionConstraint.getTerm()
Returns the
Term representing the constraint. |
Term |
IExecutionValue.getValue()
Returns the value of the variable.
|
Modifier and Type | Method and Description |
---|---|
ImmutableList<Term> |
IExecutionOperationContract.getContractParams()
Returns the parameters of the called method for which a
Contract is applied. |
Modifier and Type | Method and Description |
---|---|
IExecutionVariable[] |
IExecutionNode.getVariables(Term condition)
Returns the variable value pairs of the current state under the given condition.
|
Modifier and Type | Method and Description |
---|---|
protected Term |
ExecutionVariable.computeValueCondition(TermBuilder tb,
java.util.List<Goal> valueGoals,
InitConfig initConfig)
|
Term |
ExecutionAllArrayIndicesVariable.createArrayTerm()
Creates a
Term to access the array. |
Term |
ExecutionAllArrayIndicesVariable.createSelectTerm()
Creates recursive a term which can be used to determine the value
of
IExecutionVariable.getProgramVariable() . |
Term |
ExecutionVariable.createSelectTerm()
Creates recursive a term which can be used to determine the value
of
IExecutionVariable.getProgramVariable() . |
protected Term |
ExecutionAuxiliaryContract.declaredVariableAsTerm(StatementBlock sb,
int statementIndex)
Returns the variable declared by the statement at the given index as
Term . |
Term |
AbstractExecutionVariable.getAdditionalCondition()
Returns the optional additional condition considered during value computation.
|
Term |
AbstractExecutionVariable.getArrayIndex()
Returns the index in the parent array if an array cell value is represented.
|
Term |
AbstractExecutionNode.getBlockCompletionCondition(IExecutionBlockStartNode<?> completedNode)
Returns the condition under which this node completes the code block of the given
IExecutionBlockStartNode . |
Term |
ExecutionBranchCondition.getBranchCondition()
Returns the branch condition as
Term . |
Term |
ExecutionMethodReturnValue.getCondition()
Returns the optional condition under which the return value is valid.
|
Term |
AbstractExecutionValue.getCondition()
Returns the condition under which the variable (
IExecutionValue.getVariable() )
has this value. |
Term |
ExecutionAllArrayIndicesVariable.getConstant()
Returns the constant representing an arbitrary array index.
|
Term |
ExecutionOperationContract.getExceptionTerm()
|
Term[] |
ExecutionBranchCondition.getMergedBranchCondtions()
Returns the branch condition
Term s. |
Term |
AbstractExecutionMethodReturn.getMethodReturnCondition()
Returns the condition under which this method return is reached from
the calling
IExecutionMethodCall . |
Term |
ExecutionAllArrayIndicesVariable.getNotAValue()
Returns the constant representing the fact that no value is available.
|
Term |
ExecutionBranchCondition.getPathCondition()
Returns the path condition to reach this node as
Term . |
Term |
AbstractExecutionNode.getPathCondition()
Returns the path condition to reach this node as
Term . |
Term |
ExecutionOperationContract.getResultTerm()
|
Term |
ExecutionMethodReturnValue.getReturnValue()
Returns the return value.
|
Term |
ExecutionOperationContract.getSelfTerm()
|
Term |
ExecutionConstraint.getTerm()
Returns the
Term representing the constraint. |
Term |
AbstractExecutionValue.getValue()
Returns the value of the variable.
|
protected Term[] |
ExecutionBranchCondition.lazyComputeMergedBranchCondtions()
Computes the branch condition lazily when
ExecutionBranchCondition.getMergedBranchCondtions()
is called the first time. |
protected Term |
ExecutionOperationContract.searchConstructorSelfDefinition(Term term,
KeYJavaType staticType,
Services services)
Tries to find the self
Term of the given KeYJavaType . |
protected Term |
ExecutionOperationContract.searchResultTerm(FunctionalOperationContract contract,
UseOperationContractRule.Instantiation inst,
Services services)
Searches the result
Term . |
Modifier and Type | Method and Description |
---|---|
protected java.util.Set<Term> |
AbstractExecutionValue.collectRelevantTerms(Services services,
Term term)
Collects all
Term s contained in relevant constraints. |
ImmutableList<Term> |
ExecutionOperationContract.getContractParams()
Returns the parameters of the called method for which a
Contract is applied. |
Modifier and Type | Method and Description |
---|---|
protected java.util.Set<Term> |
AbstractExecutionValue.collectRelevantTerms(Services services,
Term term)
Collects all
Term s contained in relevant constraints. |
protected void |
ExecutionAuxiliaryContract.collectRemembranceVariables(Term term,
java.util.Map<LocationVariable,Term> remembranceHeaps,
java.util.Map<LocationVariable,Term> remembranceLocalVariables)
Collects recursive all remembrance variables.
|
protected boolean |
AbstractExecutionValue.containsTerm(Term term,
java.util.Set<Term> toSearch)
Checks if the given
Term contains at least one of the given once. |
protected void |
AbstractExecutionValue.fillRelevantTerms(Services services,
Term term,
java.util.Set<Term> toFill)
Utility method used by
AbstractExecutionValue.collectRelevantTerms(Services, Term) . |
protected java.lang.String |
AbstractExecutionElement.formatTerm(Term term,
Services services)
|
IExecutionVariable[] |
AbstractExecutionNode.getVariables(Term condition)
Returns the variable value pairs of the current state under the given condition.
|
protected void |
ExecutionVariable.groupGoalsByValue(ImmutableList<Goal> goals,
Operator operator,
Term siteProofSelectTerm,
Term siteProofCondition,
java.util.Map<Term,java.util.List<Goal>> valueMap,
java.util.List<Goal> unknownValues,
Services services)
Groups all
Goal s which provides the same value. |
protected ExecutionValue[] |
ExecutionVariable.instantiateValuesFromSideProof(InitConfig initConfig,
Services services,
TermBuilder tb,
ApplyStrategyInfo info,
Operator resultOperator,
Term siteProofSelectTerm,
Term siteProofCondition)
Analyzes the side proof defined by the
ApplyStrategyInfo
and creates ExecutionValue s from it. |
protected boolean |
ExecutionAllArrayIndicesVariable.isValidValue(Term value)
Checks if the given
Term represents a valid value. |
protected boolean |
ExecutionVariable.isValidValue(Term value)
Checks if the given
Term represents a valid value. |
protected IExecutionVariable[] |
AbstractExecutionNode.lazyComputeVariables(Term condition)
Computes the variables lazily when
AbstractExecutionNode.getVariables(Term) is
called the first time. |
protected Term |
ExecutionOperationContract.searchConstructorSelfDefinition(Term term,
KeYJavaType staticType,
Services services)
Tries to find the self
Term of the given KeYJavaType . |
Modifier and Type | Method and Description |
---|---|
protected void |
ExecutionAuxiliaryContract.collectRemembranceVariables(Term term,
java.util.Map<LocationVariable,Term> remembranceHeaps,
java.util.Map<LocationVariable,Term> remembranceLocalVariables)
Collects recursive all remembrance variables.
|
protected void |
ExecutionAuxiliaryContract.collectRemembranceVariables(Term term,
java.util.Map<LocationVariable,Term> remembranceHeaps,
java.util.Map<LocationVariable,Term> remembranceLocalVariables)
Collects recursive all remembrance variables.
|
protected boolean |
AbstractExecutionValue.containsTerm(Term term,
java.util.Set<Term> toSearch)
Checks if the given
Term contains at least one of the given once. |
protected void |
AbstractExecutionValue.fillRelevantTerms(Services services,
Term term,
java.util.Set<Term> toFill)
Utility method used by
AbstractExecutionValue.collectRelevantTerms(Services, Term) . |
protected void |
ExecutionVariable.groupGoalsByValue(ImmutableList<Goal> goals,
Operator operator,
Term siteProofSelectTerm,
Term siteProofCondition,
java.util.Map<Term,java.util.List<Goal>> valueMap,
java.util.List<Goal> unknownValues,
Services services)
Groups all
Goal s which provides the same value. |
Constructor and Description |
---|
AbstractExecutionValue(ITreeSettings settings,
Node proofNode,
IExecutionVariable variable,
Term condition,
Term value)
Constructor.
|
AbstractExecutionVariable(ITreeSettings settings,
Node proofNode,
IProgramVariable programVariable,
IExecutionValue parentValue,
Term arrayIndex,
Term additionalCondition,
PosInOccurrence modalityPIO)
Constructor.
|
ExecutionAllArrayIndicesVariable(IExecutionNode<?> parentNode,
Node proofNode,
PosInOccurrence modalityPIO,
ExecutionValue parentValue,
IProgramVariable arrayProgramVariable,
Term additionalCondition)
Constructor.
|
ExecutionConstraint(ITreeSettings settings,
Node proofNode,
PosInOccurrence modalityPIO,
Term term)
Constructor.
|
ExecutionMethodReturnValue(ITreeSettings settings,
Node proofNode,
PosInOccurrence modalityPIO,
Term returnValue,
Term condition)
Constructor.
|
ExecutionValue(Node proofNode,
ExecutionVariable variable,
boolean valueUnknown,
Term value,
java.lang.String valueString,
java.lang.String typeString,
Term condition,
java.lang.String conditionString)
Constructor.
|
ExecutionVariable(IExecutionNode<?> parentNode,
Node proofNode,
PosInOccurrence modalityPIO,
ExecutionValue parentValue,
IProgramVariable programVariable,
Term additionalCondition)
Constructor for a "normal" child value.
|
ExecutionVariable(IExecutionNode<?> parentNode,
Node proofNode,
PosInOccurrence modalityPIO,
ExecutionValue parentValue,
Term arrayIndex,
ExecutionValue lengthValue,
Term additionalCondition)
Constructor for an array cell value.
|
ExecutionVariable(IExecutionNode<?> parentNode,
Node proofNode,
PosInOccurrence modalityPIO,
IProgramVariable programVariable,
Term additionalCondition)
Constructor for a "normal" value.
|
Modifier and Type | Method and Description |
---|---|
Term |
ISymbolicValue.getArrayIndex()
Returns the represented array index or
null if a program variable is represented.. |
Term |
ISymbolicAssociation.getArrayIndex()
Returns the represented array index or
null if a program variable is represented.. |
Term |
ISymbolicValue.getCondition()
Returns the optional condition under which this value is valid.
|
Term |
ISymbolicAssociation.getCondition()
Returns the optional condition under which this association is valid.
|
Term |
ISymbolicObject.getName()
Returns the name of this object.
|
Term |
ISymbolicEquivalenceClass.getRepresentative()
Returns the most representative term.
|
Term |
ISymbolicValue.getValue()
Returns the value of the represented variable.
|
Modifier and Type | Method and Description |
---|---|
ImmutableList<Term> |
ISymbolicEquivalenceClass.getTerms()
Returns the terms which represents the same
ISymbolicObject . |
Modifier and Type | Method and Description |
---|---|
boolean |
ISymbolicEquivalenceClass.containsTerm(Term term)
Checks if a
Term is contained. |
ISymbolicAssociation |
ISymbolicAssociationValueContainer.getAssociation(IProgramVariable programVariable,
boolean isArrayIndex,
Term arrayIndex,
Term condition)
Returns the
ISymbolicAssociation with the given IProgramVariable . |
ISymbolicValue |
ISymbolicAssociationValueContainer.getValue(IProgramVariable programVariable,
boolean isArrayIndex,
Term arrayIndex,
Term condition)
Returns the
ISymbolicValue with the given IProgramVariable . |
Modifier and Type | Method and Description |
---|---|
Term |
SymbolicAssociation.getArrayEndIndex()
Returns the array end index.
|
Term |
SymbolicValue.getArrayEndIndex()
Returns the array end index.
|
Term |
SymbolicAssociation.getArrayIndex()
Returns the represented array index or
null if a program variable is represented.. |
Term |
SymbolicValue.getArrayIndex()
Returns the represented array index or
null if a program variable is represented.. |
Term |
SymbolicAssociation.getArrayStartIndex()
Returns the array start index.
|
Term |
SymbolicValue.getArrayStartIndex()
Returns the array start index.
|
Term |
SymbolicAssociation.getCondition()
Returns the optional condition under which this association is valid.
|
Term |
SymbolicValue.getCondition()
Returns the optional condition under which this value is valid.
|
Term |
SymbolicObject.getName()
Returns the name of this object.
|
Term |
SymbolicEquivalenceClass.getRepresentative()
Returns the most representative term.
|
Term |
SymbolicValue.getValue()
Returns the value of the represented variable.
|
Modifier and Type | Method and Description |
---|---|
ImmutableList<Term> |
SymbolicEquivalenceClass.getTerms()
Returns the terms which represents the same
ISymbolicObject . |
Modifier and Type | Method and Description |
---|---|
void |
SymbolicEquivalenceClass.addTerm(Term term)
Adds a new
Term . |
boolean |
SymbolicEquivalenceClass.containsTerm(Term term)
Checks if a
Term is contained. |
protected java.lang.String |
AbstractElement.formatTerm(Term term,
Services services)
|
ISymbolicAssociation |
AbstractSymbolicAssociationValueContainer.getAssociation(IProgramVariable programVariable,
boolean isArrayIndex,
Term arrayIndex,
Term condition)
Returns the
ISymbolicAssociation with the given IProgramVariable . |
ISymbolicValue |
AbstractSymbolicAssociationValueContainer.getValue(IProgramVariable programVariable,
boolean isArrayIndex,
Term arrayIndex,
Term condition)
Returns the
ISymbolicValue with the given IProgramVariable . |
Constructor and Description |
---|
SymbolicAssociation(Services services,
IProgramVariable programVariable,
ISymbolicObject target,
Term condition,
IModelSettings settings)
Constructor.
|
SymbolicAssociation(Services services,
Term arrayIndex,
ISymbolicObject target,
Term condition,
IModelSettings settings)
Constructor.
|
SymbolicAssociation(Services services,
Term arrayIndex,
Term arrayStartIndex,
Term arrayEndIndex,
ISymbolicObject target,
Term condition,
IModelSettings settings)
Constructor.
|
SymbolicObject(Services services,
Term name,
IModelSettings settings)
Constructor.
|
SymbolicValue(Services services,
IProgramVariable programVariable,
Term value,
Term condition,
IModelSettings settings)
Constructor.
|
SymbolicValue(Services services,
Term arrayIndex,
Term value,
Term condition,
IModelSettings settings)
Constructor.
|
SymbolicValue(Services services,
Term arrayIndex,
Term arrayStartIndex,
Term arrayEndIndex,
Term value,
Term condition,
IModelSettings settings)
Constructor.
|
Constructor and Description |
---|
SymbolicEquivalenceClass(Services services,
ImmutableList<Term> terms,
IModelSettings settings)
Constructor.
|
Modifier and Type | Method and Description |
---|---|
protected Term |
ProgramMethodPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Builds the frame clause including the modifies clause.
|
protected Term |
ProgramMethodSubsetPO.buildFreePre(ProgramVariable selfVar,
KeYJavaType selfKJT,
ImmutableList<ProgramVariable> paramVars,
java.util.List<LocationVariable> heaps,
Services proofServices)
Builds the "general assumption".
|
protected Term |
ProgramMethodSubsetPO.ensureUninterpretedPredicateExists(ImmutableList<ProgramVariable> paramVars,
ImmutableList<LocationVariable> formalParamVars,
ProgramVariable exceptionVar,
java.lang.String name,
Services proofServices)
|
protected Term |
ProgramMethodPO.generateMbyAtPreDef(ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services) |
protected Term |
ProgramMethodPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
protected Term |
ProgramMethodPO.getPost(java.util.List<LocationVariable> modHeaps,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
ProgramVariable resultVar,
ProgramVariable exceptionVar,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Creates the postcondition.
|
protected Term |
ProgramMethodPO.getPre(java.util.List<LocationVariable> modHeaps,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Creates the precondition.
|
protected Term |
ProgramMethodSubsetPO.getPre(java.util.List<LocationVariable> modHeaps,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
java.util.Map<LocationVariable,LocationVariable> atPreVars,
Services services)
Creates the precondition.
|
protected Term |
TruthValuePOExtension.labelPostTerm(Services services,
Term term)
Labels all predicates in the given
Term and its children with
a FormulaTermLabel . |
Term |
TruthValuePOExtension.modifyPostTerm(InitConfig proofConfig,
Services services,
Term postTerm)
Modifies the post condition.
|
Modifier and Type | Method and Description |
---|---|
protected Term |
ProgramMethodPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
protected Term |
TruthValuePOExtension.labelPostTerm(Services services,
Term term)
Labels all predicates in the given
Term and its children with
a FormulaTermLabel . |
Term |
TruthValuePOExtension.modifyPostTerm(InitConfig proofConfig,
Services services,
Term postTerm)
Modifies the post condition.
|
Modifier and Type | Method and Description |
---|---|
protected Term |
ProgramMethodPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Builds the frame clause including the modifies clause.
|
protected Term |
ProgramMethodPO.buildFrameClause(java.util.List<LocationVariable> modHeaps,
java.util.Map<Term,Term> heapToAtPre,
ProgramVariable selfVar,
ImmutableList<ProgramVariable> paramVars,
Services services)
Builds the frame clause including the modifies clause.
|
protected Term |
ProgramMethodPO.getGlobalDefs(LocationVariable heap,
Term heapTerm,
Term selfTerm,
ImmutableList<Term> paramTerms,
Services services) |
Modifier and Type | Method and Description |
---|---|
protected java.util.List<Triple<Term,java.util.Set<Term>,Node>> |
AbstractSideProofRule.computeResultsAndConditions(Services services,
Goal goal,
ProofEnvironment sideProofEnvironment,
Sequent sequentToProve,
Function newPredicate)
Starts the side proof and extracts the result
Term and conditions. |
protected java.util.List<Triple<Term,java.util.Set<Term>,Node>> |
AbstractSideProofRule.computeResultsAndConditions(Services services,
Goal goal,
ProofEnvironment sideProofEnvironment,
Sequent sequentToProve,
Function newPredicate)
Starts the side proof and extracts the result
Term and conditions. |
Modifier and Type | Method and Description |
---|---|
protected boolean |
QuerySideProofRule.isApplicableQuery(Goal goal,
Term pmTerm,
PosInOccurrence pio)
Checks if the query term is supported.
|
protected static SequentFormula |
AbstractSideProofRule.replace(PosInOccurrence pio,
Term newTerm,
Services services)
|
Modifier and Type | Method and Description |
---|---|
Term |
Location.toTerm(Services services)
|
static Term |
AbstractSlicer.toTerm(Services services,
Expression expression,
ExecutionContext ec)
Converts the given
Expression into a Term . |
Modifier and Type | Method and Description |
---|---|
ImmutableArray<Term> |
Access.getDimensionExpressions()
Returns the accessed array index or
null if it is not an array access. |
java.util.Map<ProgramVariable,Term> |
AbstractSlicer.SequentInfo.getLocalValues()
Returns the local values.
|
static ImmutableArray<Term> |
AbstractSlicer.toTerm(Services services,
ImmutableArray<Expression> expressions,
ExecutionContext ec)
Converts the given
Expression s into Term s. |
Modifier and Type | Method and Description |
---|---|
protected void |
AbstractSlicer.analyzeEquality(Services services,
Term equality,
java.util.Map<Location,java.util.SortedSet<Location>> aliases,
ReferencePrefix thisReference)
Analyzes the given equality
Term for aliased locations. |
protected void |
AbstractSlicer.analyzeHeapUpdate(Term term,
Services services,
HeapLDT heapLDT,
java.util.Map<Location,java.util.SortedSet<Location>> aliases,
ReferencePrefix thisReference)
Recursive utility method used by
#analyzeUpdate(Term, Services, HeapLDT, Map) to analyze a given update. |
protected void |
AbstractSlicer.analyzeUpdate(Term term,
Services services,
HeapLDT heapLDT,
java.util.Map<Location,java.util.SortedSet<Location>> aliases,
java.util.Map<ProgramVariable,Term> localValues,
ExecutionContext ec,
ReferencePrefix thisReference)
Recursive utility method used by
#analyzeUpdates(ImmutableList, Services, HeapLDT, Map) to analyze a given update. |
protected void |
AbstractSlicer.listModifiedHeapLocations(Term term,
Services services,
HeapLDT heapLDT,
java.util.List<Location> listToFill,
ReferencePrefix thisReference,
java.util.Set<Location> relevantLocations,
Node node)
Recursive utility method used by
#listModifiedLocations(Term, Services, HeapLDT, List, ReferencePrefix) to analyze a given update. |
protected void |
AbstractSlicer.listModifiedLocations(Term term,
Services services,
HeapLDT heapLDT,
java.util.List<Location> listToFill,
ExecutionContext ec,
ReferencePrefix thisReference,
java.util.Set<Location> relevantLocations,
Node node)
|
ImmutableArray<Node> |
AbstractSlicer.slice(Node seedNode,
Term term,
ImmutableList<ISymbolicEquivalenceClass> sec)
Computes the slice.
|
static Location |
AbstractSlicer.toLocation(Services services,
Term term)
|
Modifier and Type | Method and Description |
---|---|
protected void |
AbstractSlicer.analyzeUpdate(Term term,
Services services,
HeapLDT heapLDT,
java.util.Map<Location,java.util.SortedSet<Location>> aliases,
java.util.Map<ProgramVariable,Term> localValues,
ExecutionContext ec,
ReferencePrefix thisReference)
Recursive utility method used by
#analyzeUpdates(ImmutableList, Services, HeapLDT, Map) to analyze a given update. |
protected void |
AbstractSlicer.analyzeUpdates(ImmutableList<Term> updates,
Services services,
HeapLDT heapLDT,
java.util.Map<Location,java.util.SortedSet<Location>> aliases,
java.util.Map<ProgramVariable,Term> localValues,
ExecutionContext ec,
ReferencePrefix thisReference)
Utility method used by
#analyzeSequent(Node) to analyze the given updates. |
protected void |
AbstractSlicer.analyzeUpdates(ImmutableList<Term> updates,
Services services,
HeapLDT heapLDT,
java.util.Map<Location,java.util.SortedSet<Location>> aliases,
java.util.Map<ProgramVariable,Term> localValues,
ExecutionContext ec,
ReferencePrefix thisReference)
Utility method used by
#analyzeSequent(Node) to analyze the given updates. |
Constructor and Description |
---|
Access(Term... dimensionExpressions)
Constructor.
|
Constructor and Description |
---|
Access(ImmutableArray<Term> dimensionExpressions)
Constructor.
|
SequentInfo(java.util.Map<Location,java.util.SortedSet<Location>> aliases,
java.util.Map<ProgramVariable,Term> localValues,
ExecutionContext executionContext,
ReferencePrefix thisReference)
Constructor.
|
Modifier and Type | Method and Description |
---|---|
java.util.Iterator<Term> |
CutHeapObjectsTermGenerator.generate(RuleApp app,
PosInOccurrence pos,
Goal goal) |
Modifier and Type | Method and Description |
---|---|
protected void |
CutHeapObjectsTermGenerator.collectStoreLocations(Term term,
java.util.Set<Term> storeLocations,
HeapLDT heapLDT)
Collects recursive all possible targets of store operations on a heap.
|
Modifier and Type | Method and Description |
---|---|
protected void |
CutHeapObjectsTermGenerator.collectEqualityTerms(SequentFormula sf,
java.util.Set<Term> equalityTerms,
java.util.Set<Term> topTerms,
HeapLDT heapLDT,
Services services)
Computes all possible equality terms between objects in the given
SequentFormula . |
protected void |
CutHeapObjectsTermGenerator.collectEqualityTerms(SequentFormula sf,
java.util.Set<Term> equalityTerms,
java.util.Set<Term> topTerms,
HeapLDT heapLDT,
Services services)
Computes all possible equality terms between objects in the given
SequentFormula . |
protected void |
CutHeapObjectsTermGenerator.collectStoreLocations(Term term,
java.util.Set<Term> storeLocations,
HeapLDT heapLDT)
Collects recursive all possible targets of store operations on a heap.
|
Modifier and Type | Method and Description |
---|---|
Term |
AbstractConditionalBreakpoint.getCondition()
Returns the condition of the associated Breakpoint.
|
Modifier and Type | Method and Description |
---|---|
static Term |
SymbolicExecutionUtil.computeBranchCondition(Node node,
boolean simplify,
boolean improveReadability)
Computes the branch condition of the given
Node . |
static Term |
SymbolicExecutionUtil.computePathCondition(Node node,
boolean simplify,
boolean improveReadability)
Computes the path condition of the given
Node . |
static Term |
SymbolicExecutionUtil.computePathCondition(Node parentNode,
Node childNode,
boolean simplify,
boolean improveReadability)
Computes the path condition between the given
Node s. |
static Term |
SymbolicExecutionUtil.createSelectTerm(IExecutionVariable variable)
Creates recursive a term which can be used to determine the value
of
#getProgramVariable() . |
static Term |
SymbolicExecutionSideProofUtil.extractOperatorTerm(ApplyStrategyInfo info,
Operator operator)
Extracts the operator term for the formula with the given
Operator
from the site proof result (ApplyStrategyInfo ). |
static Term |
SymbolicExecutionSideProofUtil.extractOperatorTerm(Goal goal,
Operator operator)
|
static Term |
SymbolicExecutionSideProofUtil.extractOperatorTerm(Node node,
Operator operator)
|
static Term |
SymbolicExecutionSideProofUtil.extractOperatorValue(Goal goal,
Operator operator)
|
static Term |
SymbolicExecutionSideProofUtil.extractOperatorValue(Node node,
Operator operator)
|
static Term |
SymbolicExecutionUtil.followPosInOccurrence(PosInOccurrence posInOccurrence,
Term term)
Returns the sub
Term at the given PosInOccurrence
but on the given Term instead of the one contained in the PosInOccurrence . |
static Term |
SymbolicExecutionUtil.getArrayIndex(Services services,
HeapLDT heapLDT,
Term arrayIndexTerm)
Returns the array index defined by the given
Term . |
Term |
SymbolicExecutionUtil.ContractPostOrExcPostExceptionVariableResult.getExceptionDefinition()
Returns the exception definition.
|
Term |
SymbolicExecutionUtil.ContractPostOrExcPostExceptionVariableResult.getExceptionEquality()
Returns the equality which contains the equality.
|
Term |
SymbolicExecutionUtil.ContractPostOrExcPostExceptionVariableResult.getWorkingTerm()
Returns the working
Term . |
static Term |
SymbolicExecutionUtil.improveReadability(Term term,
Services services)
Improves the
Term to increase its readability. |
static Term |
SymbolicExecutionUtil.instantiateTerm(Node node,
Term term,
TacletApp tacletApp,
Services services)
|
static Term |
SymbolicExecutionUtil.posInOccurrenceInOtherNode(Node original,
PosInOccurrence pio,
Node toApplyOn)
Returns the
Term described by the given PosInOccurrence of the original Node
in the Node to apply on. |
static Term |
SymbolicExecutionUtil.posInOccurrenceInOtherNode(Sequent original,
PosInOccurrence pio,
Sequent toApplyOn)
Returns the
Term described by the given PosInOccurrence of the original Sequent
in the Sequent to apply on. |
static Term |
SymbolicExecutionUtil.removeLabelRecursive(TermFactory tf,
Term term,
TermLabel label)
|
static Term |
SymbolicExecutionUtil.replaceSkolemConstants(Sequent sequent,
Term term,
Services services)
Replaces all skolem constants in the given
Term . |
static Term |
SymbolicExecutionUtil.sequentToImplication(Sequent sequent,
Services services)
Converts the given
Sequent into an implication. |
static Term |
SymbolicExecutionUtil.simplify(InitConfig initConfig,
Proof parentProof,
Term term)
Simplifies the given
Term in a side proof. |
static Term |
SymbolicExecutionUtil.simplify(InitConfig initConfig,
Term term)
Simplifies the given
Term in a side proof. |
static Term |
SymbolicExecutionUtil.simplify(Proof parentProof,
Term term)
Simplifies the given
Term in a side proof. |
Modifier and Type | Method and Description |
---|---|
static ImmutableList<Term> |
SymbolicExecutionUtil.collectElementaryUpdates(Term term)
Collects the
ElementaryUpdate s in the given Term . |
static java.util.List<Pair<Term,Node>> |
SymbolicExecutionSideProofUtil.computeResults(Services services,
Proof proof,
ProofEnvironment sideProofEnvironment,
Sequent sequentToProve,
TermLabel label,
java.lang.String description,
java.lang.String methodTreatment,
java.lang.String loopTreatment,
java.lang.String queryTreatment,
java.lang.String splittingOption,
boolean addNamesToServices)
Starts the side proof and extracts the result
Term . |
static java.util.List<Triple<Term,java.util.Set<Term>,Node>> |
SymbolicExecutionSideProofUtil.computeResultsAndConditions(Services services,
Proof proof,
ProofEnvironment sideProofEnvironment,
Sequent sequentToProve,
Operator operator,
java.lang.String description,
java.lang.String methodTreatment,
java.lang.String loopTreatment,
java.lang.String queryTreatment,
java.lang.String splittingOption,
boolean addNamesToServices)
Starts the side proof and extracts the result
Term and conditions. |
static java.util.List<Triple<Term,java.util.Set<Term>,Node>> |
SymbolicExecutionSideProofUtil.computeResultsAndConditions(Services services,
Proof proof,
ProofEnvironment sideProofEnvironment,
Sequent sequentToProve,
Operator operator,
java.lang.String description,
java.lang.String methodTreatment,
java.lang.String loopTreatment,
java.lang.String queryTreatment,
java.lang.String splittingOption,
boolean addNamesToServices)
Starts the side proof and extracts the result
Term and conditions. |
static ImmutableList<Term> |
SymbolicExecutionUtil.computeRootElementaryUpdates(Node root)
Computes the initial
ElementaryUpdate s on the given root Node . |
protected static ImmutableArray<Term> |
SymbolicExecutionUtil.extractValueFromUpdate(Term term,
IProgramVariable variable)
Utility method to extract the value of the
IProgramVariable
from the given update term. |
Pair<ImmutableList<Term>,Term> |
SymbolicExecutionUtil.ContractPostOrExcPostExceptionVariableResult.getUpdatesAndTerm()
Returns the updates.
|
Pair<ImmutableList<Term>,Term> |
SymbolicExecutionUtil.ContractPostOrExcPostExceptionVariableResult.getUpdatesAndTerm()
Returns the updates.
|
static ImmutableList<Term> |
SymbolicExecutionUtil.listSemisequentTerms(Semisequent semisequent)
Lists the
Term s contained in the given Semisequent . |
Modifier and Type | Method and Description |
---|---|
static void |
SymbolicExecutionSideProofUtil.addNewNamesToNamespace(Services services,
Term term)
|
static int |
SymbolicExecutionUtil.checkSkolemEquality(Term term)
Checks if the given
Term is a skolem equality. |
static ImmutableList<Term> |
SymbolicExecutionUtil.collectElementaryUpdates(Term term)
Collects the
ElementaryUpdate s in the given Term . |
static boolean |
SymbolicExecutionSideProofUtil.containsModalityOrQuery(Term term)
Checks if the given
Term contains a modality or query. |
static boolean |
SymbolicExecutionUtil.containsSymbolicExecutionLabel(Term term)
Checks if the
Term or one of its sub terms contains
a symbolic execution label. |
static IExecutionVariable[] |
SymbolicExecutionUtil.createAllExecutionVariables(IExecutionNode<?> node,
Node proofNode,
PosInOccurrence modalityPIO,
Term condition)
Creates for the given
IExecutionNode the contained
root IExecutionVariable s. |
static IExecutionVariable[] |
SymbolicExecutionUtil.createExecutionVariables(IExecutionNode<?> node,
Node proofNode,
PosInOccurrence modalityPIO,
Term condition)
Creates for the given
IExecutionNode the contained
root IExecutionVariable s. |
static IExecutionVariable[] |
SymbolicExecutionUtil.createExecutionVariables(IExecutionNode<?> node,
Term condition)
Creates for the given
IExecutionNode the contained
root IExecutionVariable s. |
static SymbolicExecutionUtil.SiteProofVariableValueInput |
SymbolicExecutionUtil.createExtractTermSequent(Services sideProofServices,
Node node,
PosInOccurrence pio,
Term additionalConditions,
Term term,
boolean keepUpdates)
Creates a
Sequent which can be used in site proofs to
extract the value of the given IProgramVariable from the
sequent of the given Node . |
static SymbolicExecutionUtil.SiteProofVariableValueInput |
SymbolicExecutionUtil.createExtractVariableValueSequent(Services services,
Node node,
PosInOccurrence pio,
Term additionalConditions,
IProgramVariable variable)
Creates a
Sequent which can be used in site proofs to
extract the value of the given IProgramVariable from the
sequent of the given Node . |
static Sequent |
SymbolicExecutionUtil.createSequentToProveWithNewSuccedent(Node node,
PosInOccurrence pio,
Term newSuccedent)
|
static Sequent |
SymbolicExecutionUtil.createSequentToProveWithNewSuccedent(Node node,
PosInOccurrence pio,
Term additionalAntecedent,
Term newSuccedent,
boolean addResultLabel)
|
static Sequent |
SymbolicExecutionUtil.createSequentToProveWithNewSuccedent(Node node,
PosInOccurrence pio,
Term additionalAntecedent,
Term newSuccedent,
ImmutableList<Term> updates,
boolean addResultLabel)
|
static Sequent |
SymbolicExecutionUtil.createSequentToProveWithNewSuccedent(Node node,
Term additionalAntecedent,
Term newSuccedent,
boolean addResultLabel)
|
static Sequent |
SymbolicExecutionUtil.createSequentToProveWithNewSuccedent(Node node,
Term additionalAntecedent,
Term newSuccedent,
ImmutableList<Term> updates,
boolean addResultLabel)
|
protected static ImmutableArray<Term> |
SymbolicExecutionUtil.extractValueFromUpdate(Term term,
IProgramVariable variable)
Utility method to extract the value of the
IProgramVariable
from the given update term. |
static PosInTerm |
SymbolicExecutionUtil.findModalityWithMaxSymbolicExecutionLabelId(Term term)
Searches the modality
PosInTerm with the maximal SymbolicExecutionTermLabel ID
SymbolicExecutionTermLabel.getId() in the given Term . |
static PosInTerm |
SymbolicExecutionUtil.findModalityWithMinSymbolicExecutionLabelId(Term term)
Searches the modality
PosInTerm with the minimal SymbolicExecutionTermLabel ID
SymbolicExecutionTermLabel.getId() in the given Term . |
static Term |
SymbolicExecutionUtil.followPosInOccurrence(PosInOccurrence posInOccurrence,
Term term)
Returns the sub
Term at the given PosInOccurrence
but on the given Term instead of the one contained in the PosInOccurrence . |
static java.lang.String |
SymbolicExecutionUtil.formatTerm(Term term,
Services services,
boolean useUnicode,
boolean usePrettyPrinting)
|
static Term |
SymbolicExecutionUtil.getArrayIndex(Services services,
HeapLDT heapLDT,
Term arrayIndexTerm)
Returns the array index defined by the given
Term . |
static ProgramVariable |
SymbolicExecutionUtil.getProgramVariable(Services services,
HeapLDT heapLDT,
Term locationTerm)
Returns the
ProgramVariable defined by the given Term . |
static SymbolicExecutionTermLabel |
SymbolicExecutionUtil.getSymbolicExecutionLabel(Term term)
Returns the contained
SymbolicExecutionTermLabel if available. |
static boolean |
SymbolicExecutionUtil.hasReferenceSort(Services services,
Term term)
|
static boolean |
SymbolicExecutionUtil.hasSymbolicExecutionLabel(Term term)
Checks if the given
Term contains a SymbolicExecutionTermLabel . |
static Term |
SymbolicExecutionUtil.improveReadability(Term term,
Services services)
Improves the
Term to increase its readability. |
static Term |
SymbolicExecutionUtil.instantiateTerm(Node node,
Term term,
TacletApp tacletApp,
Services services)
|
static boolean |
SymbolicExecutionUtil.isHeapUpdate(Services services,
Term term)
Checks if the given
Term represents a heap update,
in particular a store or create operation on a heap. |
static boolean |
SymbolicExecutionUtil.isNotNull(Node node,
Term additionalAntecedent,
Term newSuccedent)
|
static boolean |
SymbolicExecutionUtil.isNull(Node node,
Term additionalAntecedent,
Term newSuccedent)
|
protected static boolean |
SymbolicExecutionSideProofUtil.isRelevantThing(Services services,
Term term)
Checks if the given
Term describes a relevant thing. |
static boolean |
SymbolicExecutionUtil.isSelect(Services services,
Term term)
Checks if the given
Term is a select on a heap. |
static boolean |
SymbolicExecutionUtil.isSkolemConstant(Term term)
|
static Term |
SymbolicExecutionUtil.removeLabelRecursive(TermFactory tf,
Term term,
TermLabel label)
|
static Term |
SymbolicExecutionUtil.replaceSkolemConstants(Sequent sequent,
Term term,
Services services)
Replaces all skolem constants in the given
Term . |
static Term |
SymbolicExecutionUtil.simplify(InitConfig initConfig,
Proof parentProof,
Term term)
Simplifies the given
Term in a side proof. |
static Term |
SymbolicExecutionUtil.simplify(InitConfig initConfig,
Term term)
Simplifies the given
Term in a side proof. |
static Term |
SymbolicExecutionUtil.simplify(Proof parentProof,
Term term)
Simplifies the given
Term in a side proof. |
void |
SymbolicExecutionSideProofUtil.ContainsModalityOrQueryVisitor.visit(Term visited)
the entry method for the visitor pattern
|
void |
SymbolicExecutionSideProofUtil.ContainsIrrelevantThingsVisitor.visit(Term visited)
the entry method for the visitor pattern
|
Modifier and Type | Method and Description |
---|---|
static Sequent |
SymbolicExecutionUtil.createSequentToProveWithNewSuccedent(Node node,
PosInOccurrence pio,
Term additionalAntecedent,
Term newSuccedent,
ImmutableList<Term> updates,
boolean addResultLabel)
|
static Sequent |
SymbolicExecutionUtil.createSequentToProveWithNewSuccedent(Node node,
Term additionalAntecedent,
Term newSuccedent,
ImmutableList<Term> updates,
boolean addResultLabel)
|
protected static Sequent |
SymbolicExecutionUtil.labelSkolemConstants(Sequent sequent,
java.util.Set<Term> constantsToLabel,
TermFactory factory)
Labels all specified skolem equalities with the
SymbolicExecutionUtil.RESULT_LABEL . |
Constructor and Description |
---|
ContractPostOrExcPostExceptionVariableResult(Term workingTerm,
Pair<ImmutableList<Term>,Term> updatesAndTerm,
Term exceptionDefinition,
Term exceptionEquality)
Constructor.
|
Constructor and Description |
---|
ContractPostOrExcPostExceptionVariableResult(Term workingTerm,
Pair<ImmutableList<Term>,Term> updatesAndTerm,
Term exceptionDefinition,
Term exceptionEquality)
Constructor.
|
ContractPostOrExcPostExceptionVariableResult(Term workingTerm,
Pair<ImmutableList<Term>,Term> updatesAndTerm,
Term exceptionDefinition,
Term exceptionEquality)
Constructor.
|
Modifier and Type | Method and Description |
---|---|
protected Term |
DefaultTacletTranslator.getFindFromTaclet(FindTaclet findTaclet)
Retrieve the "find" Term from a FindTaclet.
|
Term |
TacletFormula.getFormula(TermServices services) |
Term |
SkeletonGenerator.translate(Taclet t,
TermServices services)
Override this method to introduce a translating mechanism for taclets.
|
Term |
DefaultTacletTranslator.translate(Taclet taclet,
TermServices services)
Translates a RewriteTaclet to a formula.
|
Modifier and Type | Method and Description |
---|---|
java.util.Collection<Term> |
TacletFormula.getInstantiations()
It can be that a taclet is translated into several formulas, i.e.
|
Modifier and Type | Method and Description |
---|---|
protected Term |
AssumptionGenerator.changeTerm(Term term)
Override this method if you want to change the term, i.e.
|
Term |
AssumptionFormula.getFormula(TermServices services) |
protected static Term |
AssumptionGenerator.quantifyTerm(Term term,
TermServices services)
Quantifies a term, i.d.
|
Modifier and Type | Method and Description |
---|---|
java.util.Collection<Term> |
AssumptionFormula.getInstantiations() |
Modifier and Type | Method and Description |
---|---|
protected Term |
AssumptionGenerator.changeTerm(Term term)
Override this method if you want to change the term, i.e.
|
static java.util.HashSet<GenericSort> |
AssumptionGenerator.collectGenerics(Term term) |
boolean |
DefaultTacletSetTranslation.eventInstantiationFailure(GenericSort dest,
Sort sort,
Taclet t,
Term term) |
boolean |
TranslationListener.eventInstantiationFailure(GenericSort dest,
Sort sort,
Taclet t,
Term term)
Called when the translator can not instantiate a generic sort
with a particular sort in the given term.
|
protected static Term |
AssumptionGenerator.quantifyTerm(Term term,
TermServices services)
Quantifies a term, i.d.
|
Constructor and Description |
---|
AssumptionFormula(Taclet taclet,
java.util.Collection<Term> formula,
java.lang.String status) |
AssumptionFormula(Taclet taclet,
java.util.Collection<Term> formula,
java.lang.String status,
de.uka.ilkd.key.taclettranslation.assumptions.TacletConditions conditions) |
Modifier and Type | Method and Description |
---|---|
Term |
ProofInfo.getAssignable() |
Term |
ProofInfo.getPO() |
Term |
ProofInfo.getPostCondition() |
Term |
ProofInfo.getPostCondition2() |
Term |
ProofInfo.getPreConTerm() |
Term |
ModelGenerator.sequentToTerm(Sequent s) |
Modifier and Type | Method and Description |
---|---|
JavaBlock |
ProofInfo.getJavaBlock(Term t) |
void |
ProofInfo.getProgramVariables(Term t,
java.util.Set<Term> vars) |
java.lang.String |
ProofInfo.getUpdate(Term t) |
Modifier and Type | Method and Description |
---|---|
void |
ProofInfo.getProgramVariables(Term t,
java.util.Set<Term> vars) |
Modifier and Type | Method and Description |
---|---|
Term |
OracleInvariantTranslator.getInvariantTerm(Sort s) |
Modifier and Type | Method and Description |
---|---|
java.util.Set<Term> |
OracleGenerator.getConstants() |
Modifier and Type | Method and Description |
---|---|
OracleTerm |
OracleGenerator.generateOracle(Term term,
boolean initialSelect) |
OracleMethod |
OracleGenerator.generateOracleMethod(Term term) |
OracleLocationSet |
OracleGenerator.getOracleLocationSet(Term modifierset) |
boolean |
ModifiesSetTranslator.isAllFields(Term t) |
boolean |
ModifiesSetTranslator.isAllLocs(Term t) |
boolean |
ModifiesSetTranslator.isEmpty(Term t) |
boolean |
ModifiesSetTranslator.isIntersection(Term t) |
boolean |
ModifiesSetTranslator.isSingleTon(Term t) |
boolean |
ModifiesSetTranslator.isUnion(Term t) |
OracleLocationSet |
ModifiesSetTranslator.translate(Term t) |
Modifier and Type | Field and Description |
---|---|
ImmutableList<Term> |
InfFlowSpec.newObjects |
ImmutableList<Term> |
InfFlowSpec.postExpressions |
ImmutableList<Term> |
InfFlowSpec.preExpressions |
Modifier and Type | Method and Description |
---|---|
Term |
HelperClassForTests.extractProblemTerm(Proof p) |
static Term |
MiscTools.getSelfTerm(MethodFrame mf,
Services services)
Returns the receiver term of the passed method frame, or null if the frame belongs to a
static method.
|
Term[] |
InfFlowProgVarRenamer.renameVariablesAndSkolemConstants() |
Modifier and Type | Method and Description |
---|---|
static ImmutableList<Term> |
MiscTools.filterOutDuplicates(ImmutableList<Term> localIns,
ImmutableList<Term> localOuts) |
static ImmutableList<Term> |
MiscTools.toTermList(java.lang.Iterable<ProgramVariable> list,
TermBuilder tb) |
Modifier and Type | Method and Description |
---|---|
static ImmutableSet<Pair<Sort,IObserverFunction>> |
MiscTools.collectObservers(Term t)
Recursively collect all observers for this term including all of its sub terms.
|
static java.util.Optional<LoopSpecification> |
MiscTools.getSpecForTermWithLoopStmt(Term loopTerm,
Services services)
Returns the
LoopSpecification for the program in the given term,
the active statement of which has to be a loop statement. |
void |
ProofStarter.init(Term formulaToProve,
ProofEnvironment env)
creates a new proof object for formulaToProve and registers it in the given environment
|
Modifier and Type | Method and Description |
---|---|
static ImmutableList<Term> |
MiscTools.filterOutDuplicates(ImmutableList<Term> localIns,
ImmutableList<Term> localOuts) |
static ImmutableList<Term> |
MiscTools.filterOutDuplicates(ImmutableList<Term> localIns,
ImmutableList<Term> localOuts) |
InfFlowSpec |
InfFlowSpec.map(java.util.function.UnaryOperator<Term> op)
Applies a unary operator to every list of terms in this InfFlow specification element.
|
Constructor and Description |
---|
InfFlowProgVarRenamer(Term[] terms,
java.util.Map<Term,Term> preInitialisedReplaceMap,
java.lang.String postfix,
Goal goalForVariableRegistration,
Services services) |
InfFlowProgVarRenamer(Term[] terms,
java.lang.String postfix,
Goal goalForVariableRegistration,
Services services) |
UserProvidedInput(Term formula,
ProofEnvironment env) |
Constructor and Description |
---|
InfFlowProgVarRenamer(Term[] terms,
java.util.Map<Term,Term> preInitialisedReplaceMap,
java.lang.String postfix,
Goal goalForVariableRegistration,
Services services) |
InfFlowProgVarRenamer(Term[] terms,
java.util.Map<Term,Term> preInitialisedReplaceMap,
java.lang.String postfix,
Goal goalForVariableRegistration,
Services services) |
InfFlowSpec(ImmutableList<Term> preExpressions,
ImmutableList<Term> postExpressions,
ImmutableList<Term> newObjects) |
InfFlowSpec(ImmutableList<Term> preExpressions,
ImmutableList<Term> postExpressions,
ImmutableList<Term> newObjects) |
InfFlowSpec(ImmutableList<Term> preExpressions,
ImmutableList<Term> postExpressions,
ImmutableList<Term> newObjects) |
Modifier and Type | Method and Description |
---|---|
static Term |
MergeRuleUtils.allClosure(Term term,
Services services)
Universally closes all logical and location variables in the given term.
|
static Term |
MergeRuleUtils.createSimplifiedDisjunctivePathCondition(Term cond1,
Term cond2,
Services services,
int simplificationTimeout)
Creates a path condition that is equivalent to the disjunction of the two
supplied formulae, but possibly simpler.
|
static Term |
MergeRuleUtils.exClosure(Term term,
Services services)
Existentially closes all logical and location variables in the given
term.
|
Term |
SymbolicExecutionStateWithProgCnt.getPathCondition() |
Term |
SymbolicExecutionState.getPathCondition() |
Term |
SymbolicExecutionStateWithProgCnt.getProgramCounter() |
Term |
SymbolicExecutionStateWithProgCnt.getSymbolicState() |
Term |
SymbolicExecutionState.getSymbolicState() |
static Term |
MergeRuleUtils.getUpdateRightSideFor(Term update,
LocationVariable leftSide)
Returns the right side for a given location variable in an update (in
normal form).
|
static Term |
MergeRuleUtils.substConstantsByFreshVars(Term term,
java.util.HashMap<Function,LogicVariable> replMap,
Services services)
Substitutes all constants in the given term by fresh variables.
|
static Term |
MergeRuleUtils.substConstantsByFreshVars(Term term,
java.util.HashSet<Function> restrictTo,
java.util.HashMap<Function,LogicVariable> replMap,
Services services)
Substitutes all constants in the given term that are contained in the set
restrictTo by fresh variables.
|
static Term |
MergeRuleUtils.translateToFormula(Services services,
java.lang.String toTranslate)
Translates a String into a formula or to null if not applicable.
|
static Term |
MergeRuleUtils.trySimplify(Proof parentProof,
Term term,
boolean countDisjunctions,
int timeout)
Tries to simplifies the given
Term in a side proof with splits. |
Modifier and Type | Method and Description |
---|---|
static java.util.ArrayList<Term> |
MergeRuleUtils.getConjunctiveElementsFor(Term term)
Dissects a conjunction into its conjunctive elements.
|
static MergeRuleUtils.Option<Pair<Term,Term>> |
MergeRuleUtils.getDistinguishingFormula(java.util.ArrayList<Term> conjElemsPathCond1,
java.util.ArrayList<Term> conjElemsPathCond2,
Services services) |
static MergeRuleUtils.Option<Pair<Term,Term>> |
MergeRuleUtils.getDistinguishingFormula(java.util.ArrayList<Term> conjElemsPathCond1,
java.util.ArrayList<Term> conjElemsPathCond2,
Services services) |
static MergeRuleUtils.Option<Pair<Term,Term>> |
MergeRuleUtils.getDistinguishingFormula(Term pathCondition1,
Term pathCondition2,
Services services)
Computes a formula that implies pathCondition1 and, if pathCondition1 and
pathCondition2 are contradicting, does not imply pathCondition2.
|
static MergeRuleUtils.Option<Pair<Term,Term>> |
MergeRuleUtils.getDistinguishingFormula(Term pathCondition1,
Term pathCondition2,
Services services)
Computes a formula that implies pathCondition1 and, if pathCondition1 and
pathCondition2 are contradicting, does not imply pathCondition2.
|
static java.util.LinkedList<Term> |
MergeRuleUtils.getElementaryUpdates(Term u)
Returns all elementary updates of a parallel update.
|
ImmutableList<Term> |
MergeParamsSpec.getPredicates() |
static MergeRuleUtils.Option<Term> |
MergeRuleUtils.getUpdateRightSideForSafe(Term update,
LocationVariable leftSide)
Returns the right side for a given location variable in an update (in
normal form).
|
Modifier and Type | Method and Description |
---|---|
static Term |
MergeRuleUtils.allClosure(Term term,
Services services)
Universally closes all logical and location variables in the given term.
|
static void |
MergeRuleUtils.assertEquivalent(Term term1,
Term term2,
Services services,
int timeout)
Tries to prove the equivalence of term1 and term2 and throws a
RuntimeException if the proof fails. |
static void |
MergeRuleUtils.closeMergePartnerGoal(Node mergeNodeParent,
Goal mergePartner,
PosInOccurrence pio,
SymbolicExecutionState mergeState,
SymbolicExecutionState mergePartnerState,
Term pc,
java.util.Set<Name> newNames)
Closes the given partner goal, using the
CloseAfterMerge rule. |
static int |
MergeRuleUtils.countAtoms(Term term)
Counts the atoms in a formula.
|
static int |
MergeRuleUtils.countDisjunctions(Term term,
boolean negated)
Counts the disjunctions in a formula.
|
static Term |
MergeRuleUtils.createSimplifiedDisjunctivePathCondition(Term cond1,
Term cond2,
Services services,
int simplificationTimeout)
Creates a path condition that is equivalent to the disjunction of the two
supplied formulae, but possibly simpler.
|
static Term |
MergeRuleUtils.exClosure(Term term,
Services services)
Existentially closes all logical and location variables in the given
term.
|
static java.util.ArrayList<Term> |
MergeRuleUtils.getConjunctiveElementsFor(Term term)
Dissects a conjunction into its conjunctive elements.
|
static MergeRuleUtils.Option<Pair<Term,Term>> |
MergeRuleUtils.getDistinguishingFormula(Term pathCondition1,
Term pathCondition2,
Services services)
Computes a formula that implies pathCondition1 and, if pathCondition1 and
pathCondition2 are contradicting, does not imply pathCondition2.
|
static java.util.LinkedList<Term> |
MergeRuleUtils.getElementaryUpdates(Term u)
Returns all elementary updates of a parallel update.
|
static JavaBlock |
MergeRuleUtils.getJavaBlockRecursive(Term term)
Returns the first Java block in the given term that can be found by
recursive search, or the empty block if there is no non-empty Java block
in the term.
|
static ImmutableSet<LocationVariable> |
MergeRuleUtils.getLocationVariables(Term term,
Services services)
Returns all program variables in the given term.
|
static java.util.HashSet<LocationVariable> |
MergeRuleUtils.getLocationVariablesHashSet(Term term,
Services services)
Returns all program variables in the given term.
|
static java.util.HashSet<Function> |
MergeRuleUtils.getSkolemConstants(Term term)
Returns all Skolem constants in the given term.
|
static ImmutableSet<LocationVariable> |
MergeRuleUtils.getUpdateLeftSideLocations(Term u) |
static Term |
MergeRuleUtils.getUpdateRightSideFor(Term update,
LocationVariable leftSide)
Returns the right side for a given location variable in an update (in
normal form).
|
static MergeRuleUtils.Option<Term> |
MergeRuleUtils.getUpdateRightSideForSafe(Term update,
LocationVariable leftSide)
Returns the right side for a given location variable in an update (in
normal form).
|
static boolean |
MergeRuleUtils.isProvable(Term toProve,
Services services,
int timeout)
Tries to prove the given formula without splitting and returns whether
the prove could be closed.
|
static boolean |
MergeRuleUtils.isProvableWithSplitting(Term toProve,
Services services,
int timeout)
Tries to prove the given formula with splitting and returns whether the
prove could be closed.
|
static boolean |
MergeRuleUtils.isUpdateNormalForm(Term u)
Checks if an update is of the form { x := v || ...
|
static boolean |
MergeRuleUtils.pathConditionsAreDistinguishable(Term pathCondition1,
Term pathCondition2,
Services services)
Checks if two given path conditions are distinguishable.
|
static Term |
MergeRuleUtils.substConstantsByFreshVars(Term term,
java.util.HashMap<Function,LogicVariable> replMap,
Services services)
Substitutes all constants in the given term by fresh variables.
|
static Term |
MergeRuleUtils.substConstantsByFreshVars(Term term,
java.util.HashSet<Function> restrictTo,
java.util.HashMap<Function,LogicVariable> replMap,
Services services)
Substitutes all constants in the given term that are contained in the set
restrictTo by fresh variables.
|
static Term |
MergeRuleUtils.trySimplify(Proof parentProof,
Term term,
boolean countDisjunctions,
int timeout)
Tries to simplifies the given
Term in a side proof with splits. |
Modifier and Type | Method and Description |
---|---|
static MergeRuleUtils.Option<Pair<Term,Term>> |
MergeRuleUtils.getDistinguishingFormula(java.util.ArrayList<Term> conjElemsPathCond1,
java.util.ArrayList<Term> conjElemsPathCond2,
Services services) |
static MergeRuleUtils.Option<Pair<Term,Term>> |
MergeRuleUtils.getDistinguishingFormula(java.util.ArrayList<Term> conjElemsPathCond1,
java.util.ArrayList<Term> conjElemsPathCond2,
Services services) |
Constructor and Description |
---|
SymbolicExecutionState(Term symbolicState,
Term pathCondition) |
SymbolicExecutionState(Term symbolicState,
Term pathCondition,
Node correspondingNode) |
SymbolicExecutionStateWithProgCnt(Term symbolicState,
Term pathCondition,
Term programCounter) |
SymbolicExecutionStateWithProgCnt(Term symbolicState,
Term pathCondition,
Term programCounter,
Node correspondingNode) |
Constructor and Description |
---|
MergeParamsSpec(java.lang.String latticeType,
LocationVariable placeholder,
ImmutableList<Term> predicates) |
Modifier and Type | Method and Description |
---|---|
Node |
ProofExplorationService.applyChangeFormula(Goal g,
PosInOccurrence pio,
Term term,
Term newTerm) |
Node |
ProofExplorationService.soundAddition(Goal g,
Term t,
boolean antecedent)
Create a new Tacletapp that add a formula to the sequent using the cut rule and disabeling one of the branches
|
void |
ProofExplorationService.soundHide(Goal g,
PosInOccurrence pio,
Term term) |
Copyright © 2003-2019 The KeY-Project.