All Classes

Class	Description
AbstractState<A extends AbstractState<A,H,V>,H extends HeapDomain<H>,V extends ValueDomain<V>>	An abstract state of the analysis, composed by a heap state modeling the memory layout and a value state modeling values of program variables and memory locations.
AccessChild	An expression that accesses a memory location that is a child of another one, that is, the former is reachable from the latter.
AccessGlobal	An access to a Global of a Unit.
AccessUnitGlobal	An access to an instance Global of a CompilationUnit.
AdjacencyMatrix<N extends Node<N,E,G>,E extends Edge<N,E,G>,G extends Graph<G,N,E>>	An adjacency matrix for a graph that has Nodes as nodes and Edges as edges.
AllocationSite	A heap identifier that track also the source location where it has been allocated and a field (optional).
AllocationSites	A heap domain tracking sets of AllocationSite.
AnalysisException	A generic Exception that indicates that something has gone wrong during the analysis.
AnalysisExecutionException	A generic RuntimeException that indicates that something has gone wrong during the analysis.
AnalysisSetupException	An AnalysisException that happens during the setup of the analysis.
AnalysisState<A extends AbstractState<A,H,V>,H extends HeapDomain<H>,V extends ValueDomain<V>>	The abstract analysis state at a given program point.
ArrayType	Array type interface.
Assignment	A statement assigning the result of an expression to an assignable expression.
AvailableExpressions	An implementation of the available expressions dataflow analysis, that focuses only on the expressions that are stored into some variable.
BaseHeapDomain<H extends BaseHeapDomain<H>>	A base implementation of the HeapDomain interface, handling base cases of BaseHeapDomain.smallStepSemantics(SymbolicExpression, ProgramPoint).
BaseInferredValue<T extends BaseInferredValue<T>>	Base implementation for InferredValues.
BaseLattice<L extends BaseLattice<L>>	A base implementation of the Lattice interface, handling base cases of the methods exposed by that interface.
BaseNonRelationalValueDomain<T extends BaseNonRelationalValueDomain<T>>	Base implementation for NonRelationalValueDomains.
BinaryExpression	A binary expression.
BinaryExpression	A bynary expression that applies a BinaryOperator to two SymbolicExpressions.
BinaryNativeCall	A NativeCall with a exactly two arguments.
BinaryOperator	A binary operator that can be applied to a pair of SymbolicExpressions.
BitExternalSet<T>	An ExternalSet where the indexes of the elements included in the set are stored through bit vectors, enabling better memory efficiency.
BooleanType	Boolean type interface.
BoolType	An internal implementation of the BooleanType interface that can be used by domains that need a concrete instance of that interface.
Caches	A holder of ExternalSetCaches, to ensure that all ExternalSets built to hold a given element type will share the same unique cache.
Call	A call to another procedure.
CallGraph	A callgraph of the program to analyze, that knows how to resolve dynamic targets of UnresolvedCalls.
CallGraphConstructionException	An exception that occurred while building the callgraph.
CallResolutionException	An exception that occurred while resolving an UnresolvedCall.
CartesianProduct<T1 extends SemanticDomain<T1,E,I>,T2 extends SemanticDomain<T2,E,I>,E extends SymbolicExpression,I extends Identifier>	A generic Cartesian product abstract domain between two non-communicating SemanticDomains (i.e., no exchange of information between the abstract domains), assigning the same Identifiers and handling instances of the same SymbolicExpressions.
CFG	A control flow graph, that has Statements as nodes and Edges as edges.
CFGCall	A call to one or more of the CFGs under analysis.
CFGDescriptor	A descriptor of a CFG, containing the debug informations (source file, line, column) as well as metadata.
CFGDescriptorWarning	A warning reported by LiSA on the descriptor of one of the CFGs under analysis.
CFGWarning	A warning reported by LiSA on one of the CFGs under analysis.
CFGWithAnalysisResults<A extends AbstractState<A,H,V>,H extends HeapDomain<H>,V extends ValueDomain<V>>	A control flow graph, that has Statements as nodes and Edges as edges.
CheckTool	An auxiliary tool that can be used by checks during their execution.
CodeElement	Interface for code elements that have to provide information about the location where they appear.
CodeLocation	A generic interface for representing the location of an element in the source code (e.g., source/line/column, source/offset, ...).
CodeMember	A program member that has code within it.
CollectionsDiffBuilder<T>	An utility class that can compute the difference between two collections containing the same object types.
CompilationUnit	A compilation unit of the program to analyze.
ConcurrentFIFOWorkingSet<E>	A first-in, first-out working set.
ConcurrentLIFOWorkingSet<E>	A last-in, first-out working set.
Constant	A constant value.
ConstantPropagation	An implementation of the constant propagation dataflow analysis, that focuses only on integers.
Counter	A counter that logs to a given logger while progressing during the count.
DataflowDomain<D extends DataflowDomain<D,E>,E extends DataflowElement<D,E>>	A dataflow domain that collects instances of DataflowElement.
DataflowElement<D extends DataflowDomain<D,E>,E extends DataflowElement<D,E>>	An element of the dataflow domain, that is associated to an Identifier through DataflowElement.getIdentifier().
DefaultImplementation	An annotation defining the default implementation for an analysis component.
DefaultParameters	An annotation defining the default parameters to use when automatically creating an instance of the annotated type.
DefiniteForwardDataflowDomain<E extends DataflowElement<DefiniteForwardDataflowDomain<E>,E>>	A DataflowDomain for forward and definite dataflow analysis.
DotCFG	An DotGraph built from a CFG.
DotGraph<N extends Node<N,E,G>,E extends Edge<N,E,G>,G extends Graph<G,N,E>>	An auxiliary graph built from a Graph that can be dumped in dot format, together with a legend.
Edge	An edge of a control flow graph, connecting two statements.
Edge<N extends Node<N,E,G>,E extends Edge<N,E,G>,G extends Graph<G,N,E>>	An edge of a Graph.
Environment<M extends Environment<M,E,T>,E extends SymbolicExpression,T extends NonRelationalDomain<T,E,M>>	An environment for a NonRelationalDomain, that maps Identifiers to instances of such domain.
Expression	An expression that is part of a statement of the program.
ExpressionWarning	A warning reported by LiSA on an expression.
ExternalSet<T>	A set of elements that are stored externally from this set.
ExternalSetCache<T>	A cache for creating ExternalSets of the elements contained in this cache.
FalseEdge	An edge connecting two statements, that is traversed when the condition expressed in the source state does not hold.
FieldSensitivePointBasedHeap	A field-sensitive point-based heap implementation that abstracts heap locations depending on their allocation sites, namely the position of the code where heap locations are generated.
FIFOWorkingSet<E>	A first-in, first-out working set.
FileManager	A file manager that provides standard functionalities for communicating with the file system.
FixpointException	An exception raised during the fixpoint computation.
FixpointGraph<G extends FixpointGraph<G,N,E>,N extends Node<N,E,G>,E extends SemanticEdge<N,E,G>>	A generic graph, backed by an AdjacencyMatrix, over which a fixpoint can be computed.
FixpointGraph.SemanticFunction<N extends Node<N,E,G>,E extends SemanticEdge<N,E,G>,G extends FixpointGraph<G,N,E>,A extends AbstractState<A,H,V>,H extends HeapDomain<H>,V extends ValueDomain<V>,F extends FunctionalLattice<F,N,AnalysisState<A,H,V>>>	A functional interface that can be used for compute the semantics of Nodes, producing AnalysisStates.
FunctionalLattice<F extends FunctionalLattice<F,K,V>,K,V extends Lattice<V>>	A generic functional abstract domain that performs the functional lifting of the lattice on the elements of the co-domain.
Global	A global variable, scoped by its container.
Graph<G extends Graph<G,N,E>,N extends Node<N,E,G>,E extends Edge<N,E,G>>	A generic graph, backed by an AdjacencyMatrix.
GraphVisitor<G extends Graph<G,N,E>,N extends Node<N,E,G>,E extends Edge<N,E,G>,V>	A visitor of a Graph.
HeapAllocation	An allocation of a memory location.
HeapDomain<D extends HeapDomain<D>>	A semantic domain that can evaluate the semantic of statements that operate on heap locations, and not on concrete values.
HeapEnvironment<T extends NonRelationalHeapDomain<T>>	An environment for a NonRelationalHeapDomain, that maps Identifiers to instances of such domain.
HeapExpression	A symbolic expression that identifies a location in the program's heap.
HeapLocation	An identifier of a synthetic program variable that represents a resolved memory location.
HeapSemanticOperation	A semantic operation on the heap state of the program, that rewrites expressions and provides a substitution of the available identifiers.
HeapSemanticOperation.HeapReplacement	A replacement between Identifiers caused by a change in the heap abstraction.
Identifier	An identifier of a program variable, representing either a program variable (as an instance of Variable), or a resolved memory location (as an instance of HeapLocation).
InferenceSystem<T extends InferredValue<T>>	An inference system that model standard derivation systems (e.g., types systems, small step semantics, big step semantics, ...).
InferredTypes	An InferredValue holding a set of Types, representing the inferred runtime types of an Expression.
InferredValue<T extends InferredValue<T>>	A value that can be inferred by InferenceSystems.
IntegerConstantPropagation	The basic integer constant propagation abstract domain, tracking if a certain integer value has constant value or not, implemented as a BaseNonRelationalValueDomain, handling top and bottom values for the expression evaluation and bottom values for the expression satisfiability.
Interval	The interval abstract domain, approximating integer values as the minimum integer interval containing them.
IntraproceduralCallGraph	An instance of CallGraph that does not handle interprocedurality.
IntType	An internal implementation of the NumericType interface that can be used by domains that need a concrete instance for integer values.
InverseSetLattice<S extends InverseSetLattice<S,E>,E>	A generic inverse set lattice containing a set of elements.
IterationLogger	An utility class that allows automatic logging while iterating over elements of a collection, stream or array.
JsonReport	A report of an executed analysis that can be dumped in json format, and that can be read from a json file.
JsonReport.JsonWarning	A warning that is ready to dump into a JsonReport.
JsonReportComparer	A class providing capabilities for finding differences between two JsonReports.
JsonReportComparer.DiffReporter	An object that provides callbacks for reporting differences when comparing JsonReports.
JsonReportComparer.REPORT_TYPE	An enumeration defining the different type of reports that can be issued.
JsonReportComparer.REPORTED_COMPONENT	An enumeration defining the different components of a JsonReport, in order to distinguish which one of them caused a difference being reported.
Lattice<L extends Lattice<L>>	An interface for elements that follow a lattice structure.
LIFOWorkingSet<E>	A last-in, first-out working set.
LiSA	This is the central class of the LiSA library.
LiSAConfiguration	A holder for the configuration of a LiSA analysis.
LiSAFactory	An utility class for instantiating analysis components, that is, modular pieces of the analysis that have several implementations.
LiSAFactory.ConfigurableComponent<T>	An analysis component that can be configured, that is, it has more than one implementation that can be modularly integrated into the analysis.
Literal	A literal, representing a constant value.
MetaVariableCreator	Objects implementing this interface will produce a meta-variable to represent the value that they produce on the stack during the computation of their semantic.
MonolithicHeap	A monolithic heap implementation that abstracts all heap locations to a unique identifier.
NativeCall	A native call, modeling the usage of one of the native constructs of the language.
NativeCFG	A native cfg, representing a cfg that is usually provided by the runtime of the programming language.
Node<N extends Node<N,E,G>,E extends Edge<N,E,G>,G extends Graph<G,N,E>>	A node of a Graph.
NonRelationalDomain<T extends NonRelationalDomain<T,E,F>,E extends SymbolicExpression,F extends FunctionalLattice<F,Identifier,T>>	A non-relational domain, that is able to compute the value of a SymbolicExpressions of type E by knowing the values of all program variables.
NonRelationalHeapDomain<T extends NonRelationalHeapDomain<T>>	A non-relational heap domain, that is able to compute the value of a SymbolicExpression by knowing the values of all program variables.
NonRelationalValueDomain<T extends NonRelationalValueDomain<T>>	A non-relational value domain, that is able to compute the value of a ValueExpression by knowing the values of all program variables.
NoOp	A statement that does nothing.
NullConstant	A Constant that represent the null value.
NullLiteral	A literal representing the null constant.
NullType	The Null type, that is the type of {#link NullLiteral}.
NumericType	Numeric type interface.
OpenCall	A call to a CFG that is not under analysis.
Operator	An operator that causes a transformation of one or more SymbolicExpressions.
Parameter	A CFG parameter identified by its name and its type, containing the information about the source file, line and column where the parameter is defined.
Parity	The Parity abstract domain, tracking if a numeric value is even or odd, implemented as a BaseNonRelationalValueDomain, handling top and bottom values for the expression evaluation and bottom values for the expression satisfiability.
PluggableStatement	A Statement that can be dynamically plugged into a CFG in place of another statement.
PointBasedHeap	A field-insensitive point-based heap implementation that abstracts heap locations depending on their allocation sites, namely the position of the code where heap locations are generated.
PointerType	Pointer type interface.
PossibleForwardDataflowDomain<E extends DataflowElement<PossibleForwardDataflowDomain<E>,E>>	A DataflowDomain for forward and possible dataflow analysis.
Program	A program that LiSA can analyze.
ProgramPoint	A program point, representing an instruction that is happening in one of the CFG under analysis.
ProgramValidationException	A generic Exception that indicates that something has gone wrong while validating a Program's structure or when computing unit's hierarchies and cfgs' overridings.
PushAny	An expression converting that push any possible value on the stack.
ReachingDefinitions	An implementation of the reaching definition dataflow analysis.
Ret	Terminates the execution of the CFG where this statement lies, without returning anything to the caller.
Return	Returns an expression to the caller CFG, terminating the execution of the CFG where this statement lies.
SemanticDomain<D extends SemanticDomain<D,E,I>,E extends SymbolicExpression,I extends Identifier>	A domain able to determine how abstract information evolves thanks to the semantics of statements and expressions.
SemanticDomain.Satisfiability	The satisfiability of an expression.
SemanticEdge<N extends Node<N,E,G>,E extends SemanticEdge<N,E,G>,G extends Graph<G,N,E>>	An extension of Edge that can modify abstract information when being traversed.
SemanticEvaluator	An entity that can perform semantic evaluations that is not a SemanticDomain.
SemanticException	An exception that occurred during semantic computation.
SequentialEdge	A sequential edge connecting two statement.
SetLattice<S extends SetLattice<S,E>,E>	A generic set lattice containing a set of elements.
Sign	The basic Sign abstract domain, tracking zero, strictly positive and strictly negative integer values, implemented as a BaseNonRelationalValueDomain, handling top and bottom values for the expression evaluation and bottom values for the expression satisfiability.
SimpleAbstractState<H extends HeapDomain<H>,V extends ValueDomain<V>>	An abstract state of the analysis, composed by a heap state modeling the memory layout and a value state modeling values of program variables and memory locations.
Skip	An expression that does nothing.
SourceCodeLocation	A location of an element in the source code represented by the path to the source code, the line and the column where the element appears.
Statement	A statement of the program to analyze.
StatementStore<A extends AbstractState<A,H,V>,H extends HeapDomain<H>,V extends ValueDomain<V>>	A functional lattice that stores instances of AnalysisState computed on statements.
StatementWarning	A warning reported by LiSA on a statement.
StringType	An internal implementation of the StringType interface that can be used by domains that need a concrete instance of that interface.
StringType	String type interface.
SymbolicExpression	A symbolic expression that can be evaluated by SemanticDomains.
SyntacticCheck	A check that inspects the syntactic structure of the program to report warnings about its structure.
SyntacticChecksExecutor	Utility class that handles the execution of SyntacticChecks.
TernaryExpression	A bynary expression that applies a TernaryExpression to three SymbolicExpressions.
TernaryNativeCall	A NativeCall with a exactly three arguments.
TernaryOperator	A ternary operator that can be applied to a triple of SymbolicExpressions.
Throw	A statement that raises an error, stopping the execution of the current CFG and propagating the error to among the call chain.
TimeFormat	Time formatting utility.
TimerLogger	An utility class that allows automatic logging of the execution time of a method.
TimerLogger.LoggableAction	A Runnable executing a function with no arguments a no return value.
TimerLogger.LoggableBiConsumer<T0,T1>	A Consumer consuming two arguments.
TimerLogger.LoggableBiFunction<R,T0,T1>	A Function consuming two arguments and producing one value.
TimerLogger.LoggableConsumer<T0>	A Consumer consuming one argument.
TimerLogger.LoggableFunction<R,T0>	A Function consuming one argument and producing one value.
TimerLogger.LoggableMultiConsumer	A Consumer consuming multiple arguments.
TimerLogger.LoggableMultiFunction<R>	A Function consuming multiple arguments and producing one value.
TimerLogger.LoggablePentaConsumer<T0,T1,T2,T3,T4>	A Consumer consuming five arguments.
TimerLogger.LoggablePentaFunction<R,T0,T1,T2,T3,T4>	A Function consuming five arguments and producing one value.
TimerLogger.LoggableQuadConsumer<T0,T1,T2,T3>	A Consumer consuming four arguments.
TimerLogger.LoggableQuadFunction<R,T0,T1,T2,T3>	A Function consuming four arguments and producing one value.
TimerLogger.LoggableSupplier<R>	A Supplier producing one element.
TimerLogger.LoggableTriConsumer<T0,T1,T2>	A Consumer consuming three arguments.
TimerLogger.LoggableTriFunction<R,T0,T1,T2>	A Function consuming three arguments and producing one value.
TrueEdge	An edge connecting two statements, that is traversed when the condition expressed in the source state holds.
Type	Type interface.
TypeBasedHeap	A type-based heap implementation that abstracts heap locations depending on their types, i.e., all the heap locations with the same type are abstracted into a single unique identifier.
TypeTokenType	The type of type tokens, used as reference to types in code.
UnaryExpression	A unary expression that applies a UnaryOperator to a SymbolicExpression.
UnaryNativeCall	A NativeCall with a single argument.
UnaryOperator	A unary operator that can be applied to a single SymbolicExpression.
UnaryStatement	A unary statement.
Unit	A unit of the program to analyze.
UnitType	Interface for types that are introduced by a CompilationUnit.
UniversalExternalSet<T>	An ExternalSet that always stays up-to-date with the contents of the underlying factory, but that cannot be modified.
UnresolvedCall	A call that happens inside the program to analyze.
UnresolvedCall.ResolutionStrategy	An enum defining the different types of resolution strategies for call signatures.
Untyped	The untyped type, corresponding to an unknown/untyped type.
Utils	Utility methods for operations on Collections.
ValueCartesianProduct<T1 extends ValueDomain<T1>,T2 extends ValueDomain<T2>>	A Cartesian product between two non-communicating ValueDomains (i.e., no exchange of information between the abstract domains) assigning Identifiers and handling ValueExpressions.
ValueDomain<D extends ValueDomain<D>>	A semantic domain that can evaluate the semantic of statements that operate on values, and not on memory locations.
ValueEnvironment<T extends NonRelationalValueDomain<T>>	An environment for a NonRelationalValueDomain, that maps Identifiers to instances of such domain.
ValueExpression	A symbolic expression that represents an operation on the program's state.
Variable	An identifier of a real program variable.
VariableRef	A reference to a variable of the current CFG, identified by its name.
VariableTableEntry	An entry in the variable table representing a CFG variable identified by its index, containing the information about the source file, line and column where the variable is defined.
VoidType	The void type.
Warning	A warning reported by LiSA on the program under analysis.
WarningWithLocation	A warning reported by LiSA on the program under analysis.
WorkingSet<E>	A working set, containing items to be processed.