All Classes

Class	Description
AbstractClassUnit	A compilation unit of the program to analyze.
AbstractCodeMember	A signature control flow graph, that has no graph implementation but just its signature. Note that this class does not implement Object.equals(Object) nor Object.hashCode() since all cfgs are unique.
AbstractState<A extends AbstractState<A>>	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.
AdditionOperator	An operation that performs an addition between its operands.
AdjacencyMatrix<G extends BaseGraph<G,N,E>,N extends Node<G,N,E>,E extends Edge<G,N,E>>	An adjacency matrix for a graph that has Nodes as nodes and Edges as edges.
AdjacencyMatrix.NodeEdges<G extends BaseGraph<G,N,E>,N extends Node<G,N,E>,E extends Edge<G,N,E>>	Utility class for representing the edges tied to a node, split into two sets: ingoing and outgoing.
Aliases	A SetLattice of Symbols to be used as aliases.
AnalysisException	A generic RuntimeException that indicates that something has gone wrong during the analysis.
AnalysisExecutionException	A generic AnalysisException 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>>	The abstract analysis state at a given program point.
AnalyzedCFG<A extends AbstractState<A>>	A control flow graph, that has Statements as nodes and Edges as edges.
Annotation	A single annotation.
AnnotationMatcher	Interface for an annotation matcher.
AnnotationMember	A member of an annotation.
Annotations	A collection of annotations.
AnnotationValue	An annotation value.
Application	An complete application, collecting several Programs that need to be analyzed together.
ArithmeticOperator	A numerical operation on operand(s) of type NumericType.
ArrayAnnotationValue	An array annotation value.
ArrayType	Array type interface.
AscendingFixpoint<A extends AbstractState<A>>	A CFGFixpoint that traverses ascending chains using lubs and widenings.
Assignment	A statement assigning the result of an expression to an assignable expression.
Atom	A RegularExpression representing a single string.
AutomataFactory<A extends Automaton<A,T>,T extends TransitionSymbol<T>>	A factory for creating instances of Automaton.
Automaton<A extends Automaton<A,T>,T extends TransitionSymbol<T>>	A class that describes a generic automaton(dfa, nfa, epsilon nfa).
BackwardAnalyzedCFG<A extends AbstractState<A>>	A control flow graph, that has Statements as nodes and Edges as edges.
BackwardAscendingFixpoint<A extends AbstractState<A>>	A CFGFixpoint that traverses ascending chains using lubs and widenings.
BackwardCFGFixpoint<A extends AbstractState<A>>	A Fixpoint.FixpointImplementation for CFGs.
BackwardDescendingGLBFixpoint<A extends AbstractState<A>>	A CFGFixpoint that traverses descending chains using glbs up to threshold.
BackwardDescendingNarrowingFixpoint<A extends AbstractState<A>>	A CFGFixpoint that traverses descending chains using narrowings.
BackwardFixpoint<G extends Graph<G,N,E>,N extends Node<G,N,E>,E extends Edge<G,N,E>,T>	A backward fixpoint algorithm for a Graph, parametric to the Fixpoint.FixpointImplementation that one wants to use to compute the results.
BackwardOptimizedAnalyzedCFG<A extends AbstractState<A>>	A BackwardAnalyzedCFG that has been built using an OptimizedBackwardFixpoint.
BaseCallGraph	An instance of CallGraph that provides the basic mechanism to resolve UnresolvedCalls. The graph underlying this call graph is built lazily through each call to resolve: querying for information about the graph before the completion of the analysis might lead to wrong results.
BaseConfiguration	A holder for the configuration of a LiSA analysis.
BaseGraph<G extends BaseGraph<G,N,E>,N extends Node<G,N,E>,E extends Edge<G,N,E>>	A generic Graph, backed by an AdjacencyMatrix. Note that this class does not define Object.equals(Object) nor Object.hashCode(), since we leave the decision to be unique instances to implementers.
BaseHeapDomain<H extends BaseHeapDomain<H>>	A base implementation of the HeapDomain interface, handling base cases of BaseHeapDomain.smallStepSemantics(SymbolicExpression, ProgramPoint, SemanticOracle).
BaseHeapDomain.Rewriter	An ExpressionVisitor that rewrites SymbolicExpressions to ValueExpressions.
BaseInferredValue<T extends BaseInferredValue<T>>	Base implementation for InferredValues.
BaseInferredValue.EvaluationVisitor<T extends BaseInferredValue<T>>	A ExpressionVisitor for BaseInferredValue instances.
BaseLattice<L extends BaseLattice<L>>	A base implementation of the Lattice interface, handling base cases of the methods exposed by that interface.
BaseNonRelationalTypeDomain<T extends BaseNonRelationalTypeDomain<T>>	Base implementation for NonRelationalTypeDomains.
BaseNonRelationalTypeDomain.EvaluationVisitor<T extends BaseNonRelationalTypeDomain<T>>	A ExpressionVisitor for BaseNonRelationalTypeDomain instances.
BaseNonRelationalValueDomain<T extends BaseNonRelationalValueDomain<T>>	Base implementation for NonRelationalValueDomains.
BaseNonRelationalValueDomain.EvaluationVisitor<T extends BaseNonRelationalValueDomain<T>>	A ExpressionVisitor for BaseNonRelationalValueDomain instances.
BaseValidationLogic	A simple implementation of ProgramValidationLogic, providing the minimum reasoning for considering a Program valid for LiSA.
BasicAnnotationMatcher	An annotation matcher based on the annotation name.
BasicAnnotationValue	Abstract class representing a basic annotation value, namely annotation values that can be inside an ArrayAnnotationValue.
BinaryExpression	An NaryExpression with exactly two sub-expressions.
BinaryExpression	A bynary expression that applies a BinaryOperator to two SymbolicExpressions.
BinaryOperator	A binary Operator that can be applied to a pair of SymbolicExpression.
BinaryStatement	An NaryStatement with exactly two sub-expressions.
BitExternalSet<T>	An ExternalSet where the indexes of the elements included in the set are stored through bit vectors, enabling better memory efficiency.
BitwiseAnd	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the AND operation (i.e., setting each bit to 1 only if the corresponding bits of both operands are 1) on the arguments. First argument expression type: any NumericType Second argument expression type: any NumericType Computed expression type: NumericType
BitwiseNegation	Given an expression that evaluates to a numeric value, a UnaryExpression using this operator computes the bitwise negation (i.e., flipping every single bit independently) of that value. Argument expression type: NumericType Computed expression type: NumericType (same as argument)
BitwiseOperator	An operation that treats its operand(s) as bit vectors, operating on each bit individually.
BitwiseOr	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the OR operation (i.e., setting each bit to 1 only if at least one of the corresponding bits of the operands are 1) on the arguments. First argument expression type: any NumericType Second argument expression type: any NumericType Computed expression type: NumericType
BitwiseShiftLeft	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes a new number built with the bits of the first argument's value shifted to the left by an amount specified by the second argument's value.
BitwiseShiftRight	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes a new number built with the bits of the first argument's value shifted to the right by an amount specified by the second argument's value.
BitwiseUnsignedShiftRight	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes a new number built with the bits of the first argument's value shifted to the right by an amount specified by the second argument's value.
BitwiseXor	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the XOR operation (i.e., setting each bit to 1 only the corresponding bits of the operands are different) on the arguments. First argument expression type: any NumericType Second argument expression type: any NumericType Computed expression type: NumericType
BoolAnnotationValue	A Boolean annotation value.
BooleanType	Boolean type interface.
ByteAnnotationValue	A byte annotation value.
Call	A call to another cfg.
Call.CallType	Possible types of a call, identifying the type of targets (instance or static) it can have.
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.
CallGraphEdge	An edge between two CallGraphNodes in a BaseCallGraph.
CallGraphNode	A node of a BaseCallGraph, representing a single CodeMember.
CallResolutionException	An exception that occurred while resolving an UnresolvedCall.
CallWithResult	A call that evaluate its result directly.
CanRemoveReceiver	Marker for Calls whose first parameter can be removed.
CastIterable<E,T extends E>	An iterable that wraps another one, and whose iterator delegates to the wrapped one's, but returns its elements casted to another type.
CFG	A control flow graph with an implementation, that has Statements as nodes and Edges as edges. Note that this class does not implement Object.equals(Object) nor Object.hashCode() since all cfgs are unique.
CFGCall	A call to one or more of the CFGs under analysis.
CFGDescriptorWarning	A warning reported by LiSA on the descriptor of one of the CFGs under analysis.
CFGFixpoint<A extends AbstractState<A>>	A Fixpoint.FixpointImplementation for CFGs.
CFGFixpoint.CompoundState<A extends AbstractState<A>>	A compound state for a Statement, holding the post-state of the whole statement as well as the ones of the inner expressions.
CFGResults<A extends AbstractState<A>>	A FunctionalLattice from ScopeIds to AnalyzedCFGs.
CFGWarning	A warning reported by LiSA on one of the CFGs under analysis.
CharAnnotationValue	A char annotation value.
Check<T>	A check that inspects the syntactic structure of the program to report warnings.
ChecksExecutor	Utility class that handles the execution of Checks.
CheckTool	An auxiliary tool that can be used by checks during their execution.
CheckToolWithAnalysisResults<A extends AbstractState<A>>	An extension of CheckTool that also contains the results of the fixpoint computation.
ClassUnit	A CompilationUnit representing a concrete class that can be instantiated.
CodeEdge<G extends CodeGraph<G,N,E>,N extends CodeNode<G,N,E>,E extends CodeEdge<G,N,E>>	An Edge that can be used with a CodeGraph.
CodeElement	Interface for code elements that have to provide information about the location where they appear.
CodeGraph<G extends CodeGraph<G,N,E>,N extends CodeNode<G,N,E>,E extends CodeEdge<G,N,E>>	A Graph that contains a list of nodes, backed by a NodeList.
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.
CodeMemberDescriptor	A descriptor of a CodeMember, containing the debug informations (source file, line, column) as well as metadata.
CodeNode<G extends CodeGraph<G,N,E>,N extends CodeNode<G,N,E>,E extends CodeEdge<G,N,E>>	A Node that can be used with a CodeGraph.
CodeUnit	A file-based unit of the program to analyze, that logically groups code in files or modules.
CollectionsDiffBuilder<T>	An utility class that can compute the difference between two collections containing the same object types.
CollectionUtilities	Utility methods for operations on Collections.
CollectionUtilities.SortedSetCollector<E>	A Collector that yields a SortedSet.
CollectionUtilities.StringCollector<E>	A Collector that yields a String built by concatenating the values returned by Object.toString() when invoked on the elements of the stream.
Comp	A RegularExpression representing the sequential composition of two regular expressions.
ComparisonEq	Given two expressions, a BinaryExpression using this operator checks if the values those expressions compute to are different.
ComparisonGe	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator checks if the value of the first argument is greater or equal than the value of the right-hand side. First argument expression type: NumericType Second argument expression type: NumericType Computed expression type: BooleanType
ComparisonGt	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator checks if the value of the first argument is greater than the value of the second argument. First argument expression type: NumericType Second argument expression type: NumericType Computed expression type: BooleanType
ComparisonLe	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator checks if the value of the first argument is less or equal than the value of the right-hand side. First argument expression type: NumericType Second argument expression type: NumericType Computed expression type: BooleanType
ComparisonLt	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator checks if the value of the first argument is less than the value of the second argument. First argument expression type: NumericType Second argument expression type: NumericType Computed expression type: BooleanType
ComparisonNe	Given two expressions, a BinaryExpression using this operator checks if the values those expressions compute to are different.
ComparisonOperator	A logical operation on operand(s) of type BooleanType.
CompilationUnit	An unit of the program to analyze that is part of a hierarchical structure.
CompilationUnitAnnotationValue	A compilation unit annotation value.
ConcurrentFIFOWorkingSet<E>	A first-in, first-out working set.
ConcurrentLIFOWorkingSet<E>	A last-in, first-out working set.
Constant	A constant value.
ConstantGlobal	A global variable, scoped by its container, that is fixed to a statically constant (and immutable) value.
ControlFlowExtractor	An extractor of ControlFlowStructures from CFGs.
ControlFlowStructure	A control flow structure of a CFG.
Counter	A counter that logs to a given logger while progressing during the count.
CyclicAutomatonException	Exception thrown if an automaton is cyclic while computing accepted language.
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 contains a collection of Identifiers in its definition.
DefaultParamInitialization	An Expression that can be used on the right-hand side of an assignment to initialize a variable or parameter of a given type to a statically unknown value.
DefiniteDataflowDomain<E extends DataflowElement<DefiniteDataflowDomain<E>,E>>	A DataflowDomain for definite dataflow analysis.
DescendingGLBFixpoint<A extends AbstractState<A>>	A CFGFixpoint that traverses descending chains using glbs up to threshold.
DescendingNarrowingFixpoint<A extends AbstractState<A>>	A CFGFixpoint that traverses descending chains using narrowings.
DivisionOperator	An operation that performs a division between its operands.
Dominators<G extends Graph<G,N,E>,N extends Node<G,N,E>,E extends Edge<G,N,E>>	An algorithms that evaluates the dominators of each node in a graph.
DotGraph	A graph that can be dumped into Dot format.
DoubleAnnotationValue	A double annotation value.
DuplicateFreeFIFOWorkingSet<E>	A LIFO working set that guarantees that, at any time, the same element cannot appear more than once in it.
DuplicateFreeLIFOWorkingSet<E>	A LIFO working set that guarantees that, at any time, the same element cannot appear more than once in it.
Edge	An edge of a control flow graph, connecting two statements.
Edge<G extends Graph<G,N,E>,N extends Node<G,N,E>,E extends Edge<G,N,E>>	An edge of a Graph.
EmptySet	A RegularExpression representing the empty set of strings.
EnumAnnotationValue	An enum annotation value.
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.
EvaluationOrder	The order of evaluation of the sub-expressions of an NaryExpression.
Expression	An expression that is part of a statement of the program.
ExpressionInverseSet	An inverse set lattice containing a set of symbolic expressions.
ExpressionSet	A set lattice containing a set of symbolic expressions.
ExpressionVisitor<T>	A visitor for SymbolicExpressions, to be used as parameter to SymbolicExpression.accept(ExpressionVisitor, Object...).
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.
FIFOWorkingSet<E>	A first-in, first-out working set.
FileManager	A file manager that provides standard functionalities for communicating with the file system.
FileManager.WriteAction	A functional interface for a write operation that can throw IOExceptions.
FixedOrderMatchingStrategy	A resolution strategy that does not permit by-name (e.g.
Fixpoint<G extends Graph<G,N,E>,N extends Node<G,N,E>,E extends Edge<G,N,E>,T>	A fixpoint algorithm for a Graph, parametric to the Fixpoint.FixpointImplementation that one wants to use to compute the results.
Fixpoint.FixpointImplementation<N,E,T>	Concrete implementation of the general methods used by a fixpoint algorithm to perform.
FixpointConfiguration	An immutable configuration holding fixpoint-specific parameters.
FixpointException	An exception raised during the fixpoint computation.
FixpointInfo	A generic mapping from string keys to Lattice instances that can store custom user-defined information inside the AnalysisState.
FixpointResults<A extends AbstractState<A>>	A FunctionalLattice from CFGs to CFGResultss.
FloatAnnotationValue	A float annotation value.
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.
FunctionalLattice.FunctionalLift<V extends Lattice<V>>	Interface for the lift of lattice elements.
FunctionalLattice.KeyFunctionalLift<K>	Interface for the left of key sets.
GenericInverseSetLattice<E>	A generic ready-to-use InverseSetLattice with no additional fields, that relies on an underlying boolean value for distinguishing top and bottom values.
GenericMapLattice<K,V extends Lattice<V>>	A generic ready-to-use FunctionalLattice with no additional fields, that relies on the underlying lattice instance for distinguishing top and bottom values.
GenericSetLattice<E>	A generic ready-to-use SetLattice with no additional fields, that relies on an underlying boolean value for distinguishing top and bottom values.
Global	A global variable, scoped by its container.
GlobalWarning	A warning reported by LiSA on one of the Globals under analysis.
Graph<G extends Graph<G,N,E>,N extends Node<G,N,E>,E extends Edge<G,N,E>>	Interface of a generic graph structure.
GraphmlGraph	A graph that can be dumped into compound GraphML format.
GraphStreamWrapper	A graph instance that decorates a graphstream Graph, offering custom/improved dumping.
GraphVisitor<G extends Graph<G,N,E>,N extends Node<G,N,E>,E extends Edge<G,N,E>,V>	A visitor of a Graph.
HeapDereference	A heap dereference expression.
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.
HeapReference	A reference to a memory location, identified by its name.
HeapSemanticOperation	A semantic operation on the heap state of the program, that provides a substitution of the available identifiers.
HeapSemanticOperation.HeapReplacement	A replacement between Identifiers caused by a change in the heap abstraction.
HierarcyTraversalStrategy	A strategy for traversing hierarchies of CompilationUnit to search for implementations of call targets or global implementations.
HtmlGraph	A graph that can be dumped as an html page using javascript to visualize the graphs.
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).
IfThenElse	A ControlFlowStructure representing a if-then-else.
InferenceSystem<T extends InferredValue<T>>	An inference system that model standard derivation systems.
InferredValue<T extends InferredValue<T>>	A NonRelationalElement that can be inferred by InferenceSystems.
InferredValue.InferredPair<T extends InferredValue<T>>	A pair of instances of InferredValue, representing the result of an evaluation in the form of <inferred value, new execution state>.
InfiniteIterationException	An exception throw when someone tries to iterate over a non-finite IntInterval.
InMemoryType	A type that can only live in-memory, without being used for local variables.
IntAnnotationValue	An integer annotation value.
InterfaceUnit	A interface unit of the program to analyze.
InterproceduralAnalysis<A extends AbstractState<A>>	The definition of interprocedural analyses.
InterproceduralAnalysisException	An exception that occurred while performing an interprocedural analysis.
IntInterval	An interval with integer bounds.
IntIntervalIterator	The IntInterval iterator.
InverseSetLattice<S extends InverseSetLattice<S,E>,E>	A generic inverse set lattice containing a set of elements.
IterableArray<E>	An iterable over an array of elements.
IterationLogger	An utility class that allows automatic logging while iterating over elements of a collection, stream or array.
JavaLikeMatchingStrategy	A strategy where the first parameter is tested using RuntimeTypesMatchingStrategy if it represents the receiver of an instance call, otherwise it is tested with StaticTypesMatchingStrategy.
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.BaseDiffAlgorithm	A JsonReportComparer.DiffAlgorithm that dumps the differences using this class' logger, will compare all fields of the report, and will not fail fast.
JsonReportComparer.DiffAlgorithm	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.
LanguageFeatures	Logical grouping of all language-specific features, such as strategies for matching call parameters or traversing type hierarchies.
Lattice<L extends Lattice<L>>	An interface for elements that follow a lattice structure.
LeftToRightEvaluation	A left-to-right EvaluationOrder, evaluating expressions in the given order.
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.
LiSAConfiguration.DescendingPhaseType	The type of descending fixpoint phase algorithms that can be used.
LiSAConfiguration.GraphType	The type of graphs that can be dumped by LiSA.
LiSAReport	A structured report containing the information about an analysis that has successfully completed.
LiSARunInfo	A collector of the information about a competed analysis.
LiSARunner<A extends AbstractState<A>>	An auxiliary analysis runner for executing LiSA analysis.
ListRepresentation	A StructuredRepresentation in the form of a list of values.
Literal<E>	A literal, representing a constant value.
LogicalAnd	Given two expressions that both evaluate to Boolean values, a BinaryExpression using this operator computes the logical conjunction of those values, without short-circuiting. First argument expression type: BooleanType Second argument expression type: BooleanType Computed expression type: BooleanType
LogicalNegation	Given an expression that evaluates to a Boolean value, a UnaryExpression using this operator computes the logical negation of the expression: if it evaluates to true, it is transformed to false, and vice versa. Argument expression type: BooleanType Computed expression type: BooleanType
LogicalOperation	A common implementation for classes implementing BinaryOperator and LogicalOperator, providing a LogicalOperation.typeInference(TypeSystem, Set, Set) implementation that returns an empty set if no BooleanType can be found in one of the arguments, and a singleton set containing TypeSystem.getBooleanType() otherwise.
LogicalOperator	A logical operation on operand(s) of type BooleanType.
LogicalOr	Given two expressions that both evaluate to Boolean values, a BinaryExpression using this operator computes the logical disjunction of those values, without short-circuiting. First argument expression type: BooleanType Second argument expression type: BooleanType Computed expression type: BooleanType
LongAnnotationValue	A long annotation value.
Loop	A ControlFlowStructure representing a loop.
MapRepresentation	A StructuredRepresentation in the form of a key-value mapping.
MathNumber	A wrapper around BigDecimal to represent the mathematical concept of a number, that can be also plus or minus infinity, in a convenient way.
MathNumberConversionException	An exception thrown when a MathNumber fails to be converted to a specific Java numerical type.
MemoryAllocation	An allocation of a memory location.
MemoryOracle	An oracle that can be queried for information about the static and dynamic memory of the program.
MemoryPointer	A memory pointer to a heap location.
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.
ModuloOperator	An operation that performs a modulo (Euclidean modulo between the two operands and taking the sign of the divisor) between its operands.
MultiCall	A call to one or more CodeMembers under analysis, implemented through a sequence of calls.
MultiplicationOperator	An operation that performs a multiplication between its operands.
NamedParameterExpression	An expression that can be used to for by-name parameter passing to Calls.
NameSymbol	A Symbol that represents a name (e.g.
NaryExpression	A generic expression with n sub-expressions.
NaryStatement	A generic statement with n sub-expressions.
NativeCall	A call to one or more NativeCFGs under analysis.
NativeCFG	A native cfg, representing a cfg that is usually provided by the runtime of the programming language.
NegatableOperator	A logical operation on operand(s) of type BooleanType.
Node<G extends Graph<G,N,E>,N extends Node<G,N,E>,E extends Edge<G,N,E>>	A node of a Graph.
NodeList<G extends CodeGraph<G,N,E>,N extends CodeNode<G,N,E>,E extends CodeEdge<G,N,E>>	A list of nodes of a CodeGraph, together with the edges connecting them.
NodeList.NodeEdges<G extends CodeGraph<G,N,E>,N extends CodeNode<G,N,E>,E extends CodeEdge<G,N,E>>	Utility class for representing the edges tied to a node, split into two sets: ingoing and outgoing.
NoEntryPointException	A FixpointException signaling that no entry points have been found.
NonRelationalDomain<T extends NonRelationalDomain<T,E,F>,E extends SymbolicExpression,F extends Environment<F,E,T>>	A NonRelationalElement that models the standard concept of non-relational abstract domain, and that is able to compute the value of a SymbolicExpressions of type E by knowing the values of all program variables.
NonRelationalElement<T extends NonRelationalElement<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.
NonRelationalTypeDomain<T extends NonRelationalTypeDomain<T>>	A non-relational type domain, that is able to compute the types of a ValueExpression by knowing the types 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.
NullType	The Null type, that is the type of {#link NullLiteral}.
Numeric16BitAdd	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic addition of those values.
Numeric16BitDiv	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic division of those values.
Numeric16BitMod	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic modulo (Euclidean modulo between the two operands and taking the sign of the divisor) of those values.
Numeric16BitMul	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic multiplication of those values.
Numeric16BitRem	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic remainder (the remainder of the division between the two operands and taking the sign of the dividend) of those values.
Numeric16BitSub	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic subtraction of those values.
Numeric32BitAdd	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic addition of those values.
Numeric32BitDiv	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic division of those values.
Numeric32BitMod	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic modulo (Euclidean modulo between the two operands and taking the sign of the divisor) of those values.
Numeric32BitMul	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic multiplication of those values.
Numeric32BitRem	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic remainder (the remainder of the division between the two operands and taking the sign of the dividend) of those values.
Numeric32BitSub	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic subtraction of those values.
Numeric64BitAdd	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic addition of those values.
Numeric64BitDiv	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic division of those values.
Numeric64BitMod	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic modulo (Euclidean modulo between the two operands and taking the sign of the divisor) of those values.
Numeric64BitMul	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic multiplication of those values.
Numeric64BitRem	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic remainder (the remainder of the division between the two operands and taking the sign of the dividend) of those values.
Numeric64BitSub	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic subtraction of those values.
Numeric8BitAdd	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic addition of those values.
Numeric8BitDiv	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic division of those values.
Numeric8BitMod	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic modulo (Euclidean modulo between the two operands and taking the sign of the divisor) of those values.
Numeric8BitMul	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic multiplication of those values.
Numeric8BitRem	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic remainder (the remainder of the division between the two operands and taking the sign of the dividend) of those values.
Numeric8BitSub	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic subtraction of those values.
NumericComparison	A common implementation for classes implementing BinaryOperator and ComparisonOperator, providing a NumericComparison.typeInference(TypeSystem, Set, Set) implementation that returns an empty set if no NumericType can be found in one of the arguments or if NumericType.commonNumericalType(Set, Set) returns an empty set, and a singleton set containing TypeSystem.getBooleanType() otherwise.
NumericNegation	Given an expression that evaluates to a numeric value, a UnaryExpression using this operator computes the arithmetic negation (i.e., multiplication by -1) of that value. Argument expression type: NumericType Computed expression type: NumericType (same of the argument, but signed)
NumericNonOverflowingAdd	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic addition of those values.
NumericNonOverflowingDiv	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic division of those values.
NumericNonOverflowingMod	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic modulo (Euclidean modulo between the two operands and taking the sign of the divisor) of those values.
NumericNonOverflowingMul	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic multiplication of those values.
NumericNonOverflowingRem	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic remainder (the remainder of the division between the two operands and taking the sign of the dividend) of those values.
NumericNonOverflowingSub	Given two expressions that both evaluate to numeric values, a BinaryExpression using this operator computes the arithmetic subtraction of those values.
NumericOperation	A common implementation for classes implementing BinaryOperator, providing a NumericOperation.typeInference(TypeSystem, Set, Set) implementation that returns an empty set if no NumericType, and the result of NumericType.commonNumericalType(Set, Set) otherwise.
NumericType	Numeric type interface.
ObjectRepresentation	A StructuredRepresentation in the form of a complex object with fields.
OpenCall	A call to a CFG that is not under analysis.
OpenCallPolicy	Policy that determines what happens to the AnalysisState when an OpenCall is encountered during the fixpoint.
Operator	An operator that causes a transformation of one or more SymbolicExpressions.
OptimizedAnalyzedCFG<A extends AbstractState<A>>	An AnalyzedCFG that has been built using an OptimizedFixpoint.
OptimizedBackwardFixpoint<A extends AbstractState<A>>	A fixpoint algorithm for a Graph, parametric to the Fixpoint.FixpointImplementation that one wants to use to compute the results.
OptimizedFixpoint<A extends AbstractState<A>>	A fixpoint algorithm for a Graph, parametric to the Fixpoint.FixpointImplementation that one wants to use to compute the results.
Or	A RegularExpression representing an or between two other regular expressions.
OrderPreservingAssigningStrategy	A strategy that passes the parameters in the same order as they are specified.
OutOfScopeIdentifier	An identifier outside the current scope of the call, that is, in a method that is in the call stack but not the last one.
OutputDumpingException	An exception thrown when creating or dumping one of the outputs of the analysis.
OverflowingOperator	An operation that might overflow or underflow.
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.
ParameterAssigningStrategy	A strategy for assigning parameters at call sites.
ParameterMatchingStrategy	A strategy for matching call signatures.
PluggableStatement	A Statement that can be dynamically plugged into a CFG in place of another statement.
PointerType	Pointer type interface.
PossibleDataflowDomain<E extends DataflowElement<PossibleDataflowDomain<E>,E>>	A DataflowDomain for 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.
ProgramUnit	A unit that is part of a LiSA Program.
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.
ProgramValidationLogic	A logic for validating Programs.
PushAny	An expression that pushes any possible value on the stack.
PushInv	An expression that pushes an invalid value on the stack.
PythonLikeAssigningStrategy	A Python-like assigning strategy.
PythonLikeMatchingStrategy	A Python-like matching strategy.
QualifiedNameSymbol	A Symbol that represents a fully qualified name, composed of both a name and a qualifier.
QualifierSymbol	A Symbol that represents a qualifier (i.e.
ReferenceType	A type for references to memory regions.
RegularExpression	A regular expression that can be recognized by an Automaton, or that can be used to represent the language recognized by an automaton.
RegularExpression.PartialSubstring	A class that represents an intermediate result of the computation of RegularExpression.substring(int, int).
RemainderOperator	An operation that performs a remainder (the remainder of the division between the two operands and taking the sign of the dividend) between its operands.
ResolvedCall	Marker for Calls that have already been resolved, and that thus know what are their targets.
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.
ReturnTopPolicy	An OpenCallPolicy, where the post state is exactly the entry state, with the only difference of having a the call's meta variable assigned to top only if the call returns a value.
RightToLeftEvaluation	A right-to-left EvaluationOrder, evaluating expressions in reversed order.
RuntimeTypesMatchingStrategy	A strategy where the runtime types of the parameters of the call are evaluated against the signature of a cfg: for each parameter, if at least one of the runtime types of the actual parameter can be assigned to the type of the formal parameter, then FixedOrderMatchingStrategy.matches(Call, Parameter[], Expression[], Set[]) returns true.
Satisfiability	A lattice representing sets of possible Boolean values: (true), (false), (true, false) or unknown, () or bottom.
SCCs<G extends Graph<G,N,E>,N extends Node<G,N,E>,E extends Edge<G,N,E>>	An algorithms that evaluates the strongly connected components a graph.
ScopedObject<T>	An object that can react to the introduction or removal of scopes, modifying the variables currently in view.
ScopeId	An identifier for an InterproceduralAnalysis to distinguish different results for the same CFG based on their calling contexts.
ScopeToken	A token that can be used for pushing and popping scopes on local variables through ScopedObject.pushScope(ScopeToken) and ScopedObject.popScope(ScopeToken).
SemanticCheck<A extends AbstractState<A>>	A Check that is able to exploit both the syntactic structure of the program and the semantic information produced with the fixpoint iteration.
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.
SemanticEvaluator	An entity that can perform semantic evaluations that is not a SemanticDomain.
SemanticException	An exception that occurred during semantic computation.
SemanticExceptionWrapper	A runtime exception that wraps a SemanticException, so that it can be thrown within lambdas.
SemanticOracle	An oracle that can be queried for semantic information the program under analysis.
SequentialEdge	A sequential edge connecting two statement.
SerializableArray	An array of serializable values, represented through a list.
SerializableCFG	Utility class to build SerializableGraphs from CFGs.
SerializableEdge	An edge of a SerializableGraph.
SerializableGraph	A graph that can be serialized.
SerializableNode	A node of a SerializableGraph, represented by a numeric id.
SerializableNodeDescription	A description for a SerializableNode, pairing it with a SerializableValue.
SerializableObject	A complex serializable object, represented through a set of named serializable fields.
SerializableString	A single serializable value, represented in its textual form.
SerializableValue	A value that can be serialized, as part of a SerializableNodeDescription.
SetLattice<S extends SetLattice<S,E>,E>	A generic set lattice containing a set of elements.
SetRepresentation	A StructuredRepresentation in the form of a set of values.
ShortAnnotationValue	A short annotation value.
SingleInheritanceTraversalStrategy	A HierarcyTraversalStrategy that assumes a single super unit per each unit (Java-like).
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.
Star	A RegularExpression representing a loop, repeated an arbitrary number of times, over an inner regular expression.
State	A class that describes an Automaton state.
Statement	A statement of the program to analyze.
StatementStore<A extends AbstractState<A>>	A functional lattice that stores instances of AnalysisState computed on statements.
StatementWarning	A warning reported by LiSA on a statement.
StaticTypesMatchingStrategy	A strategy where the static types of the parameters of the call are evaluated against the signature of a cfg: for each parameter, if the static type of the actual parameter can be assigned to the type of the formal parameter, then FixedOrderMatchingStrategy.matches(Call, Parameter[], Expression[], Set[]) return true.
StringAnnotationValue	A string annotation value.
StringConcat	Given two expressions that both evaluate to string values, a BinaryExpression using this operator computes the concatenation of the string from the first argument with the one of the second argument. First argument expression type: StringType Second argument expression type: StringType Computed expression type: StringType
StringContains	Given two expressions that both evaluate to string values, a BinaryExpression using this operator checks if the string from the first argument contains the one of the second argument. First argument expression type: StringType Second argument expression type: StringType Computed expression type: BooleanType
StringEndsWith	Given two expressions that both evaluate to string values, a BinaryExpression using this operator checks if the string from the first argument is suffixed by the one of the second argument. First argument expression type: StringType Second argument expression type: StringType Computed expression type: BooleanType
StringEquals	Given two expressions that both evaluate to string values, a BinaryExpression using this operator checks if the string from the first argument is equal (in terms of contents, that is different from ComparisonEq) to the one of the second argument. First argument expression type: StringType Second argument expression type: StringType Computed expression type: BooleanType
StringIndexOf	Given two expressions that both evaluate to string values, a BinaryExpression using this operator computes the starting index of the first occurrence of the string from the second argument inside the one of the first argument, producing -1 if no occurrence can be found. First argument expression type: StringType Second argument expression type: StringType Computed expression type: NumericType (integral)
StringLength	Given an expression that evaluates to a string value, a UnaryExpression using this operator computes an integral value, from 0 upwards, representing the length of that value. Argument expression type: StringType Computed expression type: NumericType (integral)
StringOperation	A common implementation for classes implementing BinaryOperator and StringOperator, providing a StringOperation.typeInference(TypeSystem, Set, Set) implementation that returns an empty set if no StringType can be found in one of the arguments, and a singleton set containing their result type otherwise.
StringOperator	An operation manipulating one or more values of type StringType.
StringReplace	Given three expressions that all evaluate to string values, a TernaryExpression using this operator computes a new string corresponding to the first argument's string where all occurrences of the second argument's string have been replaced with the third argument's string. Note that: if the first argument's string is empty, the empty string is returned if the second argument's string is empty, the third argument's string is added in any position of the first argument's string if the third argument's string is empty, occurrences of the second argument's string are simply removed from the first argument's string First argument expression type: StringType Second argument expression type: StringType Third argument expression type: StringType Computed expression type: StringType
StringRepresentation	A StructuredRepresentation in the form of a single string element.
StringStartsWith	Given two expressions that both evaluate to string values, a BinaryExpression using this operator checks if the string from the first argument is prefixed by the one of the second argument. First argument expression type: StringType Second argument expression type: StringType Computed expression type: BooleanType
StringSubstring	Given three expressions, with the first one evaluating to a string value and the second and third one evaluating to integral numerical values, a TernaryExpression using this operator computes a new string corresponding to the portion of first argument's string starting at the second argument's number position (inclusive) and ending at the third argument's number position (exclusive). Note that: both second and third argument's numbers must be non-negative and less than the length of the first argument's string, with the second one's less or equal than the third one's if the second and third argument's numbers are equal, the empty string is returned First argument expression type: StringType Second argument expression type: NumericType Third argument expression type: NumericType Computed expression type: StringType
StringType	String type interface.
StringUtilities	Utility methods for building and manipulating strings.
StructuredObject	An object that whose contents can be converted to a domain-independent StructuredRepresentation for later use.
StructuredRepresentation	A structured representation of the information present in a single instance of an object.
SubtractionOperator	An operation that performs a subtraction between its operands.
Symbol	A symbol that can be aliased or used as an alias.
SymbolAliasing	A FunctionalLattice mapping Symbols to Aliases, that is, sets of symbols.
SymbolicChar	An symbolic character, that is, an object representing a single and possibly unknown character.
SymbolicExpression	A symbolic expression that can be evaluated by SemanticDomains.
SymbolicString	An extended string, that is, a string composed of an array of SymbolicChar.
SyntacticCheck	A Check that is able to exploit only the syntactic structure of the program.
SyntheticLocation	A synthetic code location.
TernaryExpression	An NaryExpression with exactly three sub-expressions.
TernaryExpression	A bynary expression that applies a TernaryExpression to three SymbolicExpressions.
TernaryOperator	A ternary Operator that can be applied to three SymbolicExpression.
TernaryStatement	An NaryStatement with exactly three sub-expressions.
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.LoggableSupplier<R>	A Supplier producing one element.
TopAtom	A RegularExpression representing a sequence of unknown characters of arbitrary length.
Transition<T extends TransitionSymbol<T>>	A class that describes an Automaton transition.
TransitionSymbol<T>	A symbol that can be read by Transitions of an Automaton.
TrueEdge	An edge connecting two statements, that is traversed when the condition expressed in the source state holds.
TruncatedParamsCall	A call that wraps another one that has been created through CanRemoveReceiver.removeFirstParameter().
Type	Type interface.
TypeCast	Given two expressions, with the second one evaluating to a type token, a BinaryExpression using this operator casts the type of the first argument to the type of the second argument.
TypeCheck	Given two expressions, with the second one evaluating to a type token, a BinaryExpression using this operator checks if the runtime types of the value the first argument evaluates to are subtypes of the ones contained in the token. First argument expression type: any Type Second argument expression type: TypeTokenType Computed expression type: BooleanType
TypeConv	Given two expressions, with the second one evaluating to a type token, a BinaryExpression using this operator converts the type of the first argument to the type of the second argument.
TypeDomain<T extends TypeDomain<T>>	An domain that is able to determine the runtime types of an expression given the runtime types of its operands.
TypeEnvironment<T extends NonRelationalTypeDomain<T>>	An environment for a NonRelationalTypeDomain, that maps Identifiers to instances of such domain.
TypeOf	Given any expression, a UnaryExpression using this operator computes the type(s) of that expression. Argument expression type: any Type Computed expression type: TypeTokenType containing all types of argument
TypeOperator	An operation manipulating the types of concrete values.
TypeOracle	An oracle that can be queried for runtime type information.
TypeSystem	A type system, knowing about the types that can appear in a Program.
TypeTokenType	The type of type tokens, used as reference to types in code.
UnaryExpression	An NaryExpression with a single sub-expression.
UnaryExpression	A unary expression that applies a UnaryOperator to a SymbolicExpression.
UnaryOperator	A unary Operator that can be applied to a single SymbolicExpression.
UnaryStatement	An NaryStatement with a single sub-expression.
UniqueScope	A ScopeId for analyses that do not make distinction between different calling contexts.
Unit	A unit of the program to analyze.
UnitType	Interface for types that are introduced by a ClassUnit.
UnitWarning	A warning reported by LiSA on one of the Units under analysis.
UniversalExternalSet<T>	An ExternalSet that always stays up-to-date with the contents of the underlying factory, but that cannot be modified.
UnknownSymbolicChar	An SymbolicChar representing an unknown character.
UnresolvedCall	A call that happens inside the program to analyze.
Untyped	The untyped type, corresponding to an unknown/untyped type.
ValueDeserializer	Custom Jackson deserializer for SerializableValues, built to read back what is serialized by ValueSerializer.
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.
ValueOracle	An oracle that can be queried for information about values being computed during program execution.
ValueSerializer	Custom Jackson serializer for SerializableValues that tries to reduce the size of the generated json files.
Variable	An identifier of a real program variable.
VariableLift<M extends VariableLift<M,E,T>,E extends SymbolicExpression,T extends NonRelationalElement<T,E,M>>	A SemanticDomain implemented as a lift for a NonRelationalElements, that maps Identifiers to instances of such domain.
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.
VersionInfo	Compiler-generated class that holds information about versioning and other build metadata.
VisitOnceFIFOWorkingSet<E>	A FIFO working set that guarantees that each element will be added to this working set no more than once.
VisitOnceLIFOWorkingSet<E>	A LIFO working set that guarantees that each element will be added to this working set no more than once.
VisitOnceWorkingSet<E>	A working set, containing items to be processed.
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.
WorstCasePolicy	A worst-case OpenCallPolicy, where the whole analysis state becomes top and all information is lost.