Package sync.pds.solver

Class SyncPDSSolver<Stmt extends Location,Fact,Field extends Location,W extends Weight>

java.lang.Object

sync.pds.solver.SyncPDSSolver<Stmt,Fact,Field,W>

public abstract class SyncPDSSolver<Stmt extends Location,Fact,Field extends Location,W extends Weight>
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static interface	SyncPDSSolver.OnAddedSummaryListener<Stmt,Fact>
static class	SyncPDSSolver.PDSSystem

Field Summary

Fields

Modifier and Type	Field	Description
protected WeightedPAutomaton<Stmt,INode<Fact>,W>	callAutomaton
protected WeightedPushdownSystem<Stmt,INode<Fact>,W>	callingPDS
protected WeightedPAutomaton<Field,INode<Node<Stmt,Fact>>,W>	fieldAutomaton
protected WeightedPushdownSystem<Field,INode<Node<Stmt,Fact>>,W>	fieldPDS
protected Map<Map.Entry<INode<Fact>,Stmt>,INode<Fact>>	generatedCallState

Constructor Summary

Constructors

Constructor	Description
SyncPDSSolver(boolean useCallSummaries, NestedWeightedPAutomatons<Stmt,INode<Fact>,W> callSummaries, boolean useFieldSummaries, NestedWeightedPAutomatons<Field,INode<Node<Stmt,Fact>>,W> fieldSummaries, int maxCallDepth, int maxFieldDepth, int maxUnbalancedCallDepth)

Method Summary

Modifier and Type	Method	Description
void	addApplySummaryListener(SyncPDSSolver.OnAddedSummaryListener l)
void	addCallRule(Rule<Stmt,INode<Fact>,W> rule)
void	addFieldRule(Rule<Field,INode<Node<Stmt,Fact>>,W> rule)
void	addGeneratedFieldState(GeneratedState<Node<Stmt,Fact>,Field> state)
void	addNormalCallFlow(Node<Stmt,Fact> curr, Node<Stmt,Fact> succ)
void	addNormalFieldFlow(Node<Stmt,Fact> curr, Node<Stmt,Fact> succ)
abstract void	applyCallSummary(Stmt callSite, Fact factInCallee, Stmt spInCallee, Stmt exitStmt, Fact returnedFact)
INode<Node<Stmt,Fact>>	asFieldFact(Node<Stmt,Fact> node)
abstract void	computeSuccessor(Node<Stmt,Fact> node)
void	debugOutput()
abstract Field	emptyField()
abstract Field	epsilonField()
abstract Stmt	epsilonStmt()
abstract Field	exclusionFieldWildCard(Field exclusion)
abstract Field	fieldWildCard()
INode<Fact>	generateCallState(INode<Fact> d, Stmt loc)
INode<Node<Stmt,Fact>>	generateFieldState(INode<Node<Stmt,Fact>> d, Field loc)
abstract WeightFunctions<Stmt,Fact,Stmt,W>	getCallWeights()
abstract WeightFunctions<Stmt,Fact,Field,W>	getFieldWeights()
Set<Node<Stmt,Fact>>	getReachedStates()
protected boolean	preventCallTransitionAdd(Transition<Stmt,INode<Fact>> trans, W weight)
protected boolean	preventFieldTransitionAdd(Transition<Field,INode<Node<Stmt,Fact>>> trans, W weight)
void	processNode(Node<Stmt,Fact> curr)
void	processNormal(Node<Stmt,Fact> curr, Node<Stmt,Fact> succ)
void	processPop(Node<Stmt,Fact> curr, PopNode popNode)
void	processPush(Node<Stmt,Fact> curr, Location location, PushNode<Stmt,Fact,?> succ, SyncPDSSolver.PDSSystem system)
void	propagate(Node<Stmt,Fact> curr, State s)
void	registerListener(SyncPDSUpdateListener<Stmt,Fact> listener)
void	registerListener(SyncStatePDSUpdateListener<Stmt,Fact> listener)
void	solve(Node<Stmt,Fact> curr, Field field, INode<Node<Stmt,Fact>> fieldTarget, Stmt stmt, INode<Fact> callTarget)
void	solve(Node<Stmt,Fact> curr, Field field, INode<Node<Stmt,Fact>> fieldTarget, Stmt stmt, INode<Fact> callTarget, W weight)
protected INode<Fact>	wrap(Fact variable)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

callingPDS

protected final WeightedPushdownSystem<Stmt extends Location,INode<Fact>,W extends Weight> callingPDS

fieldPDS

protected final WeightedPushdownSystem<Field extends Location,INode<Node<Stmt extends Location,Fact>>,W extends Weight> fieldPDS

fieldAutomaton

protected final WeightedPAutomaton<Field extends Location,INode<Node<Stmt extends Location,Fact>>,W extends Weight> fieldAutomaton

callAutomaton

protected final WeightedPAutomaton<Stmt extends Location,INode<Fact>,W extends Weight> callAutomaton

generatedCallState

protected Map<Map.Entry<INode<Fact>,Stmt extends Location>,INode<Fact>> generatedCallState

Constructor Detail

SyncPDSSolver

public SyncPDSSolver(boolean useCallSummaries,
                     NestedWeightedPAutomatons<Stmt,INode<Fact>,W> callSummaries,
                     boolean useFieldSummaries,
                     NestedWeightedPAutomatons<Field,INode<Node<Stmt,Fact>>,W> fieldSummaries,
                     int maxCallDepth,
                     int maxFieldDepth,
                     int maxUnbalancedCallDepth)

Method Detail

preventFieldTransitionAdd

protected boolean preventFieldTransitionAdd(Transition<Field,INode<Node<Stmt,Fact>>> trans,
                                            W weight)

preventCallTransitionAdd

protected boolean preventCallTransitionAdd(Transition<Stmt,INode<Fact>> trans,
                                           W weight)

solve

public void solve(Node<Stmt,Fact> curr,
                  Field field,
                  INode<Node<Stmt,Fact>> fieldTarget,
                  Stmt stmt,
                  INode<Fact> callTarget,
                  W weight)

solve

public void solve(Node<Stmt,Fact> curr,
                  Field field,
                  INode<Node<Stmt,Fact>> fieldTarget,
                  Stmt stmt,
                  INode<Fact> callTarget)

processNode

public void processNode(Node<Stmt,Fact> curr)

propagate

public void propagate(Node<Stmt,Fact> curr,
                      State s)

processNormal

public void processNormal(Node<Stmt,Fact> curr,
                          Node<Stmt,Fact> succ)

addNormalCallFlow

public void addNormalCallFlow(Node<Stmt,Fact> curr,
                              Node<Stmt,Fact> succ)

addNormalFieldFlow

public void addNormalFieldFlow(Node<Stmt,Fact> curr,
                               Node<Stmt,Fact> succ)

asFieldFact

public INode<Node<Stmt,Fact>> asFieldFact(Node<Stmt,Fact> node)

processPop

public void processPop(Node<Stmt,Fact> curr,
                       PopNode popNode)

addApplySummaryListener

public void addApplySummaryListener(SyncPDSSolver.OnAddedSummaryListener l)

applyCallSummary

public abstract void applyCallSummary(Stmt callSite,
                                      Fact factInCallee,
                                      Stmt spInCallee,
                                      Stmt exitStmt,
                                      Fact returnedFact)

processPush

public void processPush(Node<Stmt,Fact> curr,
                        Location location,
                        PushNode<Stmt,Fact,?> succ,
                        SyncPDSSolver.PDSSystem system)

addCallRule

public void addCallRule(Rule<Stmt,INode<Fact>,W> rule)

addFieldRule

public void addFieldRule(Rule<Field,INode<Node<Stmt,Fact>>,W> rule)

getFieldWeights

public abstract WeightFunctions<Stmt,Fact,Field,W> getFieldWeights()

getCallWeights

public abstract WeightFunctions<Stmt,Fact,Stmt,W> getCallWeights()

registerListener

public void registerListener(SyncPDSUpdateListener<Stmt,Fact> listener)

registerListener

public void registerListener(SyncStatePDSUpdateListener<Stmt,Fact> listener)

wrap

protected INode<Fact> wrap(Fact variable)

generateCallState

public INode<Fact> generateCallState(INode<Fact> d,
                                     Stmt loc)

generateFieldState

public INode<Node<Stmt,Fact>> generateFieldState(INode<Node<Stmt,Fact>> d,
                                                       Field loc)

addGeneratedFieldState

public void addGeneratedFieldState(GeneratedState<Node<Stmt,Fact>,Field> state)

computeSuccessor

public abstract void computeSuccessor(Node<Stmt,Fact> node)

epsilonField

public abstract Field epsilonField()

emptyField

public abstract Field emptyField()

epsilonStmt

public abstract Stmt epsilonStmt()

exclusionFieldWildCard

public abstract Field exclusionFieldWildCard(Field exclusion)

fieldWildCard

public abstract Field fieldWildCard()

getReachedStates

public Set<Node<Stmt,Fact>> getReachedStates()

debugOutput

public void debugOutput()