The OPAL Framework5.0.0 < Back

Packages

package root
Definition Classes
root
package org
Definition Classes
root
package opalj
OPAL is a Scala-based framework for the static analysis, manipulation and creation of Java bytecode.
OPAL is a Scala-based framework for the static analysis, manipulation and creation of Java bytecode. OPAL is designed with performance, scalability and adaptability in mind.
Its main components are:
- a library (Common) which provides generally useful data-structures and algorithms for static analyses.
- a framework for implementing lattice based static analyses (Static Analysis Infrastructure)
- a framework for parsing Java bytecode (Bytecode Infrastructure) that can be used to create arbitrary representations.
- a library to create a one-to-one in-memory representation of Java bytecode (Bytecode Disassembler).
- a library to create a representation of Java bytecode that facilitates writing simple static analyses (Bytecode Representation - org.opalj.br).
- a scalable, easily customizable framework for the abstract interpretation of Java bytecode (Abstract Interpretation Framework - org.opalj.ai).
- a library to extract dependencies between code elements and to facilitate checking architecture definitions.
- a library for the lightweight manipulation and creation of Java bytecode (Bytecode Assembler).
General Design Decisions
Thread Safety
Unless explicitly noted, OPAL is thread safe. I.e., the classes defined by OPAL can be considered to be thread safe unless otherwise stated. (For example, it is possible to read and process class files concurrently without explicit synchronization on the client side.)
No null Values
Unless explicitly noted, OPAL does not null values I.e., fields that are accessible will never contain null values and methods will never return null. If a method accepts null as a value for a parameter or returns a null value it is always explicitly documented. In general, the behavior of methods that are passed null values is undefined unless explicitly documented.
No Typecasts for Collections
For efficiency reasons, OPAL sometimes uses mutable data-structures internally. After construction time, these data-structures are generally represented using their generic interfaces (e.g., scala.collection.{Set,Map}). However, a downcast (e.g., to add/remove elements) is always forbidden as it would effectively prevent thread-safety.
Assertions
OPAL makes heavy use of Scala's Assertion Facility to facilitate writing correct code. Hence, for production builds (after thorough testing(!)) it is highly recommend to build OPAL again using -Xdisable-assertions.
Definition Classes
org
package fpcf
The fixpoint computations framework (fpcf) is a general framework to perform fixpoint computations of properties ordered by a lattice.
The fixpoint computations framework (fpcf) is a general framework to perform fixpoint computations of properties ordered by a lattice. The framework in particular supports the development of static analyses.
In this case, the fixpoint computations/static analyses are generally operating on the code and need to be executed until the computations have reached their (implicit) fixpoint. The fixpoint framework explicitly supports resolving cyclic dependencies/computations. A prime use case of the fixpoint framework are all those analyses that may interact with the results of other analyses.
For example, an analysis that analyzes all field write accesses to determine if we can refine a field's type (for the purpose of the analysis) can (reuse) the information about the return types of methods, which however may depend on the refined field types.
The framework is generic enough to facilitate the implementation of anytime algorithms.
Definition Classes
opalj
Note
This framework assumes that all data-structures (e.g., dependee lists and properties) that are passed to the framework are effectively immutable! (Effectively immutable means that a data structure is never updated after it was passed to the framework.)
,
The dependency relation is as follows: “A depends on B” === “A is the depender, B is the dependee”. === “B is depended on by A”
,
The very core of the framework is described in: Lattice Based Modularization of Static Analyses
package par
Definition Classes
fpcf
package seq
Definition Classes
fpcf
AnalysisScenario
ComputationSpecification
ComputationType
ContextNotAvailableException
ELBP
ELBPS
ELUBP
ELUBPS
EOptionP
EOptionPSet
EPK
EPS
EUBP
EUBPS
EagerComputation
ExplicitlyNamedProperty
FallbackReason
FinalE
FinalEP
FinalP
FinalProperties
FinalPropertyComputationResult
IncrementalResult
InterimE
InterimELBP
InterimELUBP
InterimEP
InterimEUB
InterimEUBP
InterimLBP
InterimLUBP
InterimPartialResult
InterimResult
InterimUBP
LBP
LBPS
LBProperties
LUBP
LUBPS
LUBProperties
LazyComputation
MultiResult
NoLBP
NoResult
NoUBP
OrderedProperty
PartialResult
PhaseConfiguration
ProperPropertyComputationResult
PropertiesBoundType
Property
PropertyBounds
PropertyComputationResult
PropertyIsNotComputedByAnyAnalysis
PropertyIsNotDerivedByPreviouslyExecutedAnalysis
PropertyKey
PropertyKind
PropertyKindsConfiguration
PropertyMetaInformation
PropertyStore
PropertyStoreContext
PropertyStoreFactory
Result
Results
Schedule
SimpleComputationSpecification
SinglePropertiesBoundType
SomeEPS
SomeFinalEP
SpecificationViolation
Transformer
TriggeredComputation
UBP
UBPS
UBProperties

org.opalj.fpcf

EOptionP

Companion object EOptionP

sealed trait EOptionP[+E <: Entity, +P <: Property] extends AnyRef

An entity associated with the current extension of a property or None if no (preliminary) property is already computed.

Source: EOptionP.scala

Linear Supertypes

AnyRef, Any

Known Subclasses

EPK, EPS, FinalEP, InterimELBP, InterimELUBP, InterimEP, InterimEUBP

Ordering

Alphabetic
By Inheritance

Inherited

EOptionP
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

Abstract Value Members

abstract def asEPK: EPK[E, P]
abstract def asEPS: EPS[E, P]
This EOptionP as an EPS object; defined iff at least a preliminary property exists.
abstract def asFinal: FinalEP[E, P]
abstract def asInterim: InterimEP[E, P]
abstract val e: E
The entity.
The entity. E.g., a class, method or field. In general, it is recommended to use entities that stand for specific elements in the code, but which are not the concrete source code entities themselves. This greatly facilitates associating properties with entities where the respective code is not available. For example, by using an object which acts as a representative for a concrete method it is possible to associate (predetermined) properties with (selected) library methods even if those methods are not part of the analysis.
Note
Entities have to implement equals/hashCode methods which are very efficient, because entity based comparisons happen very frequently!
abstract def hasLBP: Boolean
returns
true if the entity is associated with a (preliminary) property which represents a lower bound. Always true in case of a FinalP.
abstract def hasUBP: Boolean
returns
true if the entity is associated with a (preliminary) property which represents an upper bound. Always true in case of a FinalP.
abstract def isEPK: Boolean
abstract def isEPS: Boolean
abstract def isFinal: Boolean
Returns true if and only if we have a property and the property was stored in the store using (Multi)Result.
abstract def lb: P
Returns the lower bound of the property if it is available, otherwise an UnsupportedOperationException is thrown.
Returns the lower bound of the property if it is available, otherwise an UnsupportedOperationException is thrown. For details regarding the precise semantics see the discussion for ub.
Annotations
@throws("if no property is available")
Note
If the property is final, lb (and ub) will return the final property p.
abstract def pk: PropertyKey[P]
The property key of the optionally available property.
abstract def toEPK: EPK[E, P]
This EOptionP as a pair of an entity and a property key.
abstract def toEPS: Option[EPS[E, P]]
abstract def ub: P
Returns the upper bound of the property if it is available – hasUBP has to be true – otherwise an UnsupportedOperationException is thrown.
Returns the upper bound of the property if it is available – hasUBP has to be true – otherwise an UnsupportedOperationException is thrown.
The upper bound always models the best/most precise result w.r.t. the underlying lattice. Here, "best" means that the set of potentially reachable states/instructions that the analyzed program can ever assume is potentially smaller when compared to a worse property.
The upper bound models the sound and precise result under the assumption that the properties of all explicitly and implicitly relevant entities is as last queried or implicitly assumed. I.e., unless a dependee is updated the upper bound represents the correct and most precise result.
The lower bound models the worst case property that a specific entity can have under the assumption that all other relevant properties will get their worst properties. This can – but does not have to be – the underlying lattice's bottom value. The lower bound is generally helpful for client analyses to determine final results quicker. For example, imagine the following code:
```
def f(a : AnyRef) : Unit = a match {
  case a : List[_] => if (a.exists( _ == null)) throw  new IllegalArgumentException
  case _ => throw new UnknownError
}
def m(){
  try {
    f(List(1,2,3))
  } catch {
    case nfe:  NumberFormatException => ...
  }
}
```
In that case – assuming we do not perform context sensitive analyses – if the lower bound for f for the set of thrown exceptions is determined to be Set(IllegalArgumentException,UnkownError), then the catch of the NumberFormatException can be ruled out and a final result for m can be computed.
Annotations
@throws("if no property is available")
Note
If the property is final, lb (and ub) will return the final property p.

Concrete Value Members

final def !=(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def ##: Int
Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0
Definition Classes
Any
def clone(): AnyRef
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @native() @IntrinsicCandidate()
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native() @IntrinsicCandidate()
final def hasNoLBP: Boolean
final def hasNoUBP: Boolean
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native() @IntrinsicCandidate()
def is(p: AnyRef): Boolean
Combines the test if we have a final property and – if we have one – if it is equal (by means of an equality check) to the given one.
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
final def isRefinable: Boolean
final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native() @IntrinsicCandidate()
final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native() @IntrinsicCandidate()
final def synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
def toString(): String
Definition Classes
AnyRef → Any
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])

Deprecated Value Members

def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable]) @Deprecated
Deprecated

Packages

General Design Decisions

Thread Safety

No `null` Values

No Typecasts for Collections

Assertions

EOptionP

Companion object EOptionP

sealed trait EOptionP[+E <: Entity, +P <: Property] extends AnyRef

Abstract Value Members

Concrete Value Members

Deprecated Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

General Design Decisions

Thread Safety

No null Values

No Typecasts for Collections

Assertions

EOptionP

Companion object EOptionP

sealed trait EOptionP[+E <: Entity, +P <: Property] extends AnyRef

Abstract Value Members

Concrete Value Members

Deprecated Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

No `null` Values

EOptionP