Module InferModules.Prop

Compare propositions

Check the equality of two sigma's

Dump a substitution.

Pretty print a pi.

Dump a pi.

Dump a sigma.

Dump a pi and a sigma

Split sigma into stack and nonstack parts. The boolean indicates whether the stack should only include local variales.

Update the object substitution given the stack variables in the prop

Pretty print a proposition.

Create a predicate environment for a prop

Dump a proposition.

Apply substitution for pi

Apply subsitution for sigma

Apply subsitution to prop. Result is not normalized.

Apply the substitution to all the expressions in the prop.

Relaces all expressions in the hpred list using the first argument. Assume that the first parameter defines a partial function. No expressions inside hpara are replaced.

Turn an inequality expression into an atom

Return true if the atom is an inequality

If the atom is e<=n return e,n

If the atom is n<e return n,e

Normalize exp using the pure part of prop. Later, we should change this such that the normalization exposes offsets of exp as much as possible.

If destructive is true then normalize more aggressively, which may lose some useful structure or types.

Normalize the expression without abstracting complex subexpressions

Collapse consecutive indices that should be added. For instance, this function reduces x[1][1] to x[2]. The typ argument is used to ensure the soundness of this collapsing.

Normalize exp used for the address of a heap cell. This normalization does not combine two offsets inside exp.

normalize a prop

expose a prop, no-op used to instantiate the sub-type relation

Return a compact representation of the prop

Check if the sigma part of the proposition is emp

Construct a disequality.

Construct an equality.

Construct a positive pred.

Construct a negative pred.

create a strexp of the given type, populating the structures if expand_structs is true

Construct a pointsto.

Construct a points-to predicate for an expression using either the provided expression name as base for fresh identifiers.

Construct a points-to predicate for a single program variable. If expand_structs is true, initialize the fields of structs with fresh variables.

Construct a lseg predicate

Construct a dllseg predicate

Proposition true /\ emp.

Reset every inst in the prop using the given map

Conjoin a heap predicate by separating conjunction.

Conjoin a list of heap predicates by separating conjunction

Conjoin a pure atomic predicate by normal conjunction.

Conjoin exp1=exp2 with a symbolic heap prop.

Conjoin exp1!=exp2 with a symbolic heap prop.

Return the pure part of prop.

Canonicalize the names of primed variables.

Extract the footprint and return it as a prop

Extract the (footprint,current) pair

Expand PE listsegs if the flag is on.

Existentially quantify the ids in prop.

convert the footprint vars to primed vars.

convert the primed vars to normal vars.

Build an exposed prop from pi

Build an exposed prop from sigma

Set individual fields of the prop.

Iterator over the sigma part. Each iterator has a current hpred.

Create an iterator, return None if sigma part is empty.

Return the prop associated to the iterator.

Add an atom to the pi part of prop iter. The first parameter records whether it is done during footprint or during re - execution.

Remove the current element from the iterator, and return the prop associated to the resulting iterator.

Return the current hpred and state.

Return the next iterator.

Update the current element of the iterator.

Insert before the current element of the iterator.

Find the maximum stamp of a free variable of a certain kind.

Extract the sigma part of the footprint

Replace the sigma part of the footprint

Scan sigma to find an hpred satisfying the filter function.

Update the current element of the iterator by a nonempty list of elements.

Set the state of an iterator

Rename ident in iter by a fresh primed identifier

Collect garbage fields.