cpg-core/de.fraunhofer.aisec.cpg

Package-level declarations

Types

data class CallResolutionResult(val source: Expression, val arguments: List<Expression>, var candidateFunctions: Set<FunctionDeclaration>, var viableFunctions: Set<FunctionDeclaration>, var signatureResults: Map<FunctionDeclaration, SignatureResult>, var bestViable: Set<FunctionDeclaration>, var success: CallResolutionResult.SuccessKind, var actualStartScope: Scope?)

This is the result of SymbolResolver.resolveWithArguments. It holds all necessary intermediate results (such as candidateFunctions, viableFunctions) as well as the final result (see bestViable) of the call resolution.

ConfigurationException

class ConfigurationException : Exception

A generic exception that can be thrown while building the configuration. This exception indicates that the requested configuration is not possible.

IncompatibleSignature

data object IncompatibleSignature : SignatureResult

InferenceConfiguration

class InferenceConfiguration

This class holds configuration options for the inference of certain constructs and auto-guessing when executing language frontends.

PleaseBeCareful

annotation class PleaseBeCareful

Annotation used to mark functions that could potentially be dangerous, in a way that could modify or alter the CPG tree structure that one does not intent to.

PopulatedByPass

annotation class PopulatedByPass(val value: KClass<out Pass<*>>)

This annotation denotes that, this property is populates by a pass. Optionally, also specifying which Pass class is responsible.

ResolveInFrontend

@Target(allowedTargets = [AnnotationTarget.FUNCTION])

annotation class ResolveInFrontend(val method: String)

Functions marked with this annotation are using features of the ScopeManager to resolve symbols (or scopes) during frontend parsing. This is something which we discourage. However, in non-context free languages such as C++ this is unavoidable to some degree.

ScopeManager

class ScopeManager : ScopeProvider

The scope manager builds a multi-tree structure of nodes associated to a scope. These scopes capture the validity of certain (Variable-, Field-, Record-)declarations but are also used to identify outer scopes that should be the target of a jump (continue, break, throw).

SignatureMatches

data class SignatureMatches(val casts: List<CastResult>) : SignatureResult

SignatureResult

sealed class SignatureResult

SignatureResult will be the result of the function FunctionDeclaration.matchesSignature which calculates whether the provided CallExpression will match the signature of the current FunctionDeclaration.

TranslationConfiguration

class TranslationConfiguration

The configuration for the TranslationManager holds all information that is used during the translation.

TranslationContext

class TranslationContext(val config: TranslationConfiguration, val scopeManager: ScopeManager, val typeManager: TypeManager, var currentComponent: Component? = null)

The translation context holds all necessary managers and configurations needed during the translation process.

TranslationManager

class TranslationManager

Main entry point for all source code translation for all language front-ends.

TranslationResult

class TranslationResult(translationManager: TranslationManager, var finalCtx: TranslationContext) : Node, StatisticsHolder

The global (intermediate) result of the translation. A LanguageFrontend will initially populate it and a Pass can extend it.

TypeManager

class TypeManager

Properties

ancestors

val Type.ancestors: Set<Type.Ancestor>

commonType

val Collection<Type>.commonType: Type?

This computed property returns the common type in a Collection of Type objects. For example, if two types A and B both derive from the interface C`` then C` would be returned.

Functions

matchesSignature

fun FunctionDeclaration.matchesSignature(signature: List<Type>, arguments: List<Expression>? = null, useDefaultArguments: Boolean = false): SignatureResult

nameIsType

fun Reference.nameIsType(): Type?

A utility function that checks whether our Reference refers to a Type. This is used by many passes that replace certain Reference nodes with other nodes, e.g., the ResolveCallExpressionAmbiguityPass.

tryCast

fun Type.tryCast(targetType: Type, hint: HasType? = null, targetHint: HasType? = null): CastResult

This function checks, if this Type can be cast into targetType. Note, this also takes the TypeOperations of the type into account, which means that pointer types of derived types will not match with a non-pointer type of its base type. But, if both are pointer types, they will match.