cpg-core/de.fraunhofer.aisec.cpg.graph.builder

Package-level declarations

Functions

infix fun Expression.assign(rhs: Expression): AssignExpression

Creates a new AssignExpression with a = AssignExpression.operatorCode in the Fluent Node DSL and adds it to the nearest enclosing StatementHolder.

infix fun Expression.assign(init: AssignExpression.() -> Expression): AssignExpression

Creates a new BinaryOperator with a = BinaryOperator.operatorCode in the Fluent Node DSL and adds it to the nearest enclosing StatementHolder.

assignAsExpr

infix fun Expression.assignAsExpr(rhs: Expression): AssignExpression

infix fun Expression.assignAsExpr(rhs: AssignExpression.() -> Unit): AssignExpression

Creates a new AssignExpression with a = AssignExpression.operatorCode in the Fluent Node DSL and adds it to the nearest enclosing StatementHolder.

assignPlus

infix fun Expression.assignPlus(rhs: Expression): AssignExpression

Creates a new AssignExpression with a += AssignExpression.operatorCode in the Fluent Node DSL and adds it to the nearest enclosing StatementHolder.

block

fun LanguageFrontend<*, *>.block(needsScope: Boolean = true, init: Block.() -> Unit): Block

Creates a new Block in the Fluent Node DSL and sets it to the FunctionDeclaration.body of the nearest enclosing FunctionDeclaration. The init block can be used to create further sub-nodes as well as configuring the created node itself.

body

fun LanguageFrontend<*, *>.body(needsScope: Boolean = true, init: Block.() -> Unit): Block

breakStmt

fun LanguageFrontend<*, *>.breakStmt(label: String? = null): BreakStatement

Creates a new BreakStatement in the Fluent Node DSL and adds it to the nearest enclosing Holder, but only if it is an StatementHolder.

call

fun LanguageFrontend<*, *>.call(name: CharSequence, isStatic: Boolean = false, init: CallExpression.() -> Unit? = null): CallExpression

Creates a new CallExpression (or MemberCallExpression) in the Fluent Node DSL with the given name and adds it to the nearest enclosing Holder. Depending on whether it is a StatementHolder it is added to the list of StatementHolder.statements or in case of an ArgumentHolder, the function ArgumentHolder.addArgument is invoked.

case

fun LanguageFrontend<*, *>.case(caseExpression: Expression? = null): CaseStatement

Creates a new CaseStatement in the Fluent Node DSL and adds it to the nearest enclosing Holder, but only if it is an StatementHolder.

cast

fun LanguageFrontend<*, *>.cast(castType: Type, init: CastExpression.() -> Unit? = null): CastExpression

compExpr

fun LanguageFrontend<*, *>.compExpr(init: ComprehensionExpression.() -> Unit? = null): ComprehensionExpression

condition

fun LanguageFrontend<*, *>.condition(init: IfStatement.() -> Expression): Expression

Configures the IfStatement.condition in the Fluent Node DSL of the nearest enclosing IfStatement. The init block can be used to create further sub-nodes as well as configuring the created node itself.

conditional

fun Expression.conditional(condition: Expression, thenExpression: Expression, elseExpression: Expression): ConditionalExpression

Creates a new ConditionalExpression with a = BinaryOperator.operatorCode in the Fluent Node DSL and adds it to the nearest enclosing StatementHolder.

construct

fun LanguageFrontend<*, *>.construct(name: CharSequence, init: ConstructExpression.() -> Unit? = null): ConstructExpression

Creates a new ConstructExpression in the Fluent Node DSL for the translation record/type with the given name and adds it to the nearest enclosing Holder. Depending on whether it is a StatementHolder it is added to the list of StatementHolder.statements or in case of an ArgumentHolder, the function ArgumentHolder.addArgument is invoked. The init block can be used to create further sub-nodes as well as configuring the created node itself.

constructor

fun LanguageFrontend<*, *>.constructor(init: ConstructorDeclaration.() -> Unit): ConstructorDeclaration

Creates a new ConstructorDeclaration in the Fluent Node DSL for the enclosing RecordDeclaration. The init block can be used to create further sub-nodes as well as configuring the created node itself.

continueStmt

fun LanguageFrontend<*, *>.continueStmt(label: String? = null): ContinueStatement

Creates a new ContinueStatement in the Fluent Node DSL and adds it to the nearest enclosing StatementHolder.

dec

operator fun Expression.dec(): UnaryOperator

Creates a new UnaryOperator with a -- UnaryOperator.operatorCode in the Fluent Node DSL and adds it to the nearest enclosing StatementHolder.

declare

fun LanguageFrontend<*, *>.declare(init: DeclarationStatement.() -> Unit): DeclarationStatement

Creates a new DeclarationStatement in the Fluent Node DSL and adds it to the StatementHolder.statements of the nearest enclosing StatementHolder. The init block can be used to create further sub-nodes as well as configuring the created node itself.

declareVar

fun LanguageFrontend<*, *>.declareVar(name: String, type: Type, init: VariableDeclaration.() -> Unit? = null): DeclarationStatement

Creates a new DeclarationStatement in the Fluent Node DSL. The init block can be used to create further sub-nodes as well as configuring the created node itself.

default

fun LanguageFrontend<*, *>.default(): DefaultStatement

Creates a new DefaultStatement in the Fluent Node DSL and adds it to the nearest enclosing StatementHolder.

div

operator fun Expression.div(rhs: Expression): BinaryOperator

Creates a new BinaryOperator with a / BinaryOperator.operatorCode in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing ArgumentHolder.

doCondition

fun LanguageFrontend<*, *>.doCondition(init: DoStatement.() -> Expression): Expression

Configures the DoStatement.condition in the Fluent Node DSL of the nearest enclosing DoStatement. The init block can be used to create further sub-nodes as well as configuring the created node itself.

doStmt

fun LanguageFrontend<*, *>.doStmt(needsScope: Boolean = true, init: DoStatement.() -> Unit): DoStatement

Creates a new DoStatement in the Fluent Node DSL and adds it to the StatementHolder.statements of the nearest enclosing StatementHolder. The init block can be used to create further sub-nodes as well as configuring the created node itself.

elseIf

fun LanguageFrontend<*, *>.elseIf(init: IfStatement.() -> Unit): IfStatement

Creates a new IfStatement in the Fluent Node DSL and sets it to the IfStatement.elseStatement of the nearest enclosing IfStatement. This simulates an else-if scenario. The init block can be used to create further sub-nodes as well as configuring the created node itself.

elseStmt

fun LanguageFrontend<*, *>.elseStmt(needsScope: Boolean = true, init: Block.() -> Unit): Block

Creates a new Block in the Fluent Node DSL and sets it to the IfStatement.elseStatement of the nearest enclosing IfStatement. The init block can be used to create further sub-nodes as well as configuring the created node itself.

infix fun Expression.eq(rhs: Expression): BinaryOperator

Creates a new BinaryOperator with a == BinaryOperator.operatorCode in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing ArgumentHolder.

field

fun LanguageFrontend<*, *>.field(name: CharSequence, type: Type = unknownType(), init: FieldDeclaration.() -> Unit? = null): FieldDeclaration

Creates a new FieldDeclaration in the Fluent Node DSL with the given name and optional type. The init block can be used to create further sub-nodes as well as configuring the created node itself.

forEachStmt

fun LanguageFrontend<*, *>.forEachStmt(init: ForEachStatement.() -> Unit): ForEachStatement

Creates a new ForEachStatement in the Fluent Node DSL and adds it to the StatementHolder.statements of the nearest enclosing StatementHolder. The init block can be used to create further sub-nodes as well as configuring the created node itself.

forStmt

fun LanguageFrontend<*, *>.forStmt(initializer: DeclarationStatement, condition: Expression, iteration: Statement, elseStmt: Statement? = null, init: Block.() -> Unit): ForStatement

Creates a new ForStatement in the Fluent Node DSL and adds it to the StatementHolder.statements of the nearest enclosing StatementHolder. The init block can be used to create further sub-nodes as well as configuring the created node itself.

function

fun LanguageFrontend<*, *>.function(name: CharSequence, returnType: Type = unknownType(), returnTypes: List<Type>? = null, init: FunctionDeclaration.() -> Unit? = null): FunctionDeclaration

Creates a new FunctionDeclaration in the Fluent Node DSL with the given name and optional returnType. The init block can be used to create further sub-nodes as well as configuring the created node itself.

infix fun Expression.ge(rhs: Expression): BinaryOperator

Creates a new BinaryOperator with a >= BinaryOperator.operatorCode in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing ArgumentHolder.

infix fun Expression.gt(rhs: Expression): BinaryOperator

Creates a new BinaryOperator with a > BinaryOperator.operatorCode in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing ArgumentHolder.

ifStmt

fun LanguageFrontend<*, *>.ifStmt(init: IfStatement.() -> Unit): IfStatement

Creates a new IfStatement in the Fluent Node DSL and adds it to the StatementHolder.statements of the nearest enclosing StatementHolder. The init block can be used to create further sub-nodes as well as configuring the created node itself.

ile

fun LanguageFrontend<*, *>.ile(targetType: Type = unknownType(), init: InitializerListExpression.() -> Unit? = null): InitializerListExpression

Creates a new InitializerListExpression in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing Holder, but only if it is an ArgumentHolder.

import

fun LanguageFrontend<*, *>.import(name: CharSequence): IncludeDeclaration

Creates a new IncludeDeclaration and adds it to the surrounding TranslationUnitDeclaration.

inc

operator fun Expression.inc(): UnaryOperator

Creates a new UnaryOperator with a ++ UnaryOperator.operatorCode in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing ArgumentHolder.

incNoContext

fun Expression.incNoContext(): UnaryOperator

Creates a new UnaryOperator with a ++ UnaryOperator.operatorCode in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing ArgumentHolder.

initializer

fun LanguageFrontend<*, *>.initializer(init: ForStatement.() -> Expression): Expression

Configures the ForStatement.initializerStatement in the Fluent Node DSL of the nearest enclosing ForStatement. The init block can be used to create further sub-nodes as well as configuring the created node itself.

iterable

fun LanguageFrontend<*, *>.iterable(init: ForEachStatement.() -> Statement): Statement

Configures the ForEachStatement.iterable in the Fluent Node DSL of the nearest enclosing ForEachStatement. The init block can be used to create further sub-nodes as well as configuring the created node itself.

label

fun LanguageFrontend<*, *>.label(label: String, init: LabelStatement.() -> Statement? = null): LabelStatement

Creates a new LabelStatement in the Fluent Node DSL and adds it to the nearest enclosing StatementHolder.

infix fun Expression.le(rhs: Expression): BinaryOperator

Creates a new BinaryOperator with a <= BinaryOperator.operatorCode in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing ArgumentHolder.

infix fun Expression.le(rhs: Expression): BinaryOperator

line

fun Expression.line(i: Int): Expression

This utility function tries to create a fake PhysicalLocation in order to somewhat differentiate the different nodes. This is primarily needed for the mermaid graph printer, which relies on Node.hashCode, which in turn relies on Node.location.

listComp

fun LanguageFrontend<*, *>.listComp(init: CollectionComprehension.() -> Unit? = null): CollectionComprehension

literal

fun <N> LanguageFrontend<*, *>.literal(value: N, type: Type = unknownType()): Literal<N>

Creates a new Literal in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing Holder, but only if it is an ArgumentHolder.

loopBody

fun LanguageFrontend<*, *>.loopBody(init: Block.() -> Unit): Block

Creates a new Block in the Fluent Node DSL and sets it to the LoopStatement.statement of the nearest enclosing LoopStatement. The init block can be used to create further sub-nodes as well as configuring the created node itself.

loopElseStmt

fun LanguageFrontend<*, *>.loopElseStmt(needsScope: Boolean = true, init: Block.() -> Unit): Block

Creates a new Block in the Fluent Node DSL and sets it to the LoopStatement.elseStatement of the nearest enclosing LoopStatement. The init block can be used to create further sub-nodes as well as configuring the created node itself.

infix fun Expression.lt(rhs: Expression): BinaryOperator

Creates a new BinaryOperator with a < BinaryOperator.operatorCode in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing ArgumentHolder.

infix fun Expression.lt(rhs: Expression): BinaryOperator

member

fun LanguageFrontend<*, *>.member(name: CharSequence, base: Expression? = null, operatorCode: String = "."): MemberExpression

Creates a new MemberExpression in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing Holder, but only if it is an ArgumentHolder. If the name doesn't already contain a fqn, we add an implicit "this" as base.

memberCall

fun LanguageFrontend<*, *>.memberCall(localName: CharSequence, base: Expression, isStatic: Boolean = false, init: MemberCallExpression.() -> Unit? = null): MemberCallExpression

Creates a new CallExpression (or MemberCallExpression) in the Fluent Node DSL with the given localName and adds it to the nearest enclosing Holder. Depending on whether it is a StatementHolder it is added to the list of StatementHolder.statements or in case of an ArgumentHolder, the function ArgumentHolder.addArgument is invoked.

memberOrRef

fun LanguageFrontend<*, *>.memberOrRef(name: Name, type: Type = unknownType()): Expression

method

fun LanguageFrontend<*, *>.method(name: CharSequence, returnType: Type = unknownType(), init: MethodDeclaration.() -> Unit? = null): MethodDeclaration

Creates a new MethodDeclaration in the Fluent Node DSL with the given name and optional returnType. The init block can be used to create further sub-nodes as well as configuring the created node itself.

minus

operator fun Expression.minus(rhs: Expression): BinaryOperator

Creates a new BinaryOperator with a - BinaryOperator.operatorCode in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing ArgumentHolder.

namespace

fun LanguageFrontend<*, *>.namespace(name: CharSequence, init: NamespaceDeclaration.() -> Unit): NamespaceDeclaration

Creates a new NamespaceDeclaration in the Fluent Node DSL with the given name. The declaration will be set to the ScopeManager.globalScope. The init block can be used to create further sub-nodes as well as configuring the created node itself.

new

fun LanguageFrontend<*, *>.new(init: NewExpression.() -> Unit? = null): NewExpression

param

fun LanguageFrontend<*, *>.param(name: CharSequence, type: Type = unknownType(), init: ParameterDeclaration.() -> Unit? = null): ParameterDeclaration

Creates a new ParameterDeclaration in the Fluent Node DSL and adds it to the FunctionDeclaration.parameters of the nearest enclosing FunctionDeclaration. The init block can be used to create further sub-nodes as well as configuring the created node itself.

plus

operator fun Expression.plus(rhs: Expression): BinaryOperator

Creates a new BinaryOperator with a + BinaryOperator.operatorCode in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing ArgumentHolder.

plusAssign

operator fun Expression.plusAssign(rhs: Expression)

Creates a new BinaryOperator with a + BinaryOperator.operatorCode in the Fluent Node DSL and adds it to the nearest enclosing StatementHolder.

problemDecl

fun LanguageFrontend<*, *>.problemDecl(description: String, type: ProblemNode.ProblemType = ProblemNode.ProblemType.TRANSLATION, init: ProblemDeclaration.() -> Unit? = null): ProblemDeclaration

Creates a new ProblemDeclaration in the Fluent Node DSL and adds it to the DeclarationStatement.declarations of the nearest enclosing DeclarationStatement. The init block can be used to create further sub-nodes as well as configuring the created node itself.

receiver

fun LanguageFrontend<*, *>.receiver(name: String, type: Type): VariableDeclaration

record

fun LanguageFrontend<*, *>.record(name: CharSequence, kind: String = "class", init: RecordDeclaration.() -> Unit): RecordDeclaration

Creates a new RecordDeclaration in the Fluent Node DSL with the given name. The declaration will be set to the ScopeManager.currentRecord. The init block can be used to create further sub-nodes as well as configuring the created node itself.

ref

fun LanguageFrontend<*, *>.ref(name: CharSequence, type: Type = unknownType(), makeMagic: Boolean = true, init: Reference.() -> Unit? = null): Reference

Creates a new Reference in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing Holder, but only if it is an ArgumentHolder.

reference

fun reference(input: Expression): UnaryOperator

Creates a new UnaryOperator with a & UnaryOperator.operatorCode in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing ArgumentHolder.

rem

operator fun Expression.rem(rhs: Expression): BinaryOperator

Creates a new BinaryOperator with a + BinaryOperator.operatorCode in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing ArgumentHolder.

returnStmt

fun LanguageFrontend<*, *>.returnStmt(init: ReturnStatement.() -> Unit): ReturnStatement

Creates a new ReturnStatement in the Fluent Node DSL and adds it to the StatementHolder.statements of the nearest enclosing StatementHolder. The init block can be used to create further sub-nodes as well as configuring the created node itself.

subscriptExpr

fun LanguageFrontend<*, *>.subscriptExpr(init: SubscriptExpression.() -> Unit? = null): SubscriptExpression

switchBody

fun LanguageFrontend<*, *>.switchBody(init: Block.() -> Unit): Block

Creates a new Block in the Fluent Node DSL and sets it to the SwitchStatement.statement of the nearest enclosing SwitchStatement. The init block can be used to create further sub-nodes as well as configuring the created node itself.

switchStmt

fun LanguageFrontend<*, *>.switchStmt(selector: Expression, needsScope: Boolean = true, init: SwitchStatement.() -> Unit): SwitchStatement

Creates a new SwitchStatement in the Fluent Node DSL and adds it to the StatementHolder.statements of the nearest enclosing StatementHolder. The init block can be used to create further sub-nodes as well as configuring the created node itself.

fun LanguageFrontend<*, *>.t(name: CharSequence, generics: List<Type> = listOf()): Type

Creates a new Type with the given name in the Fluent Node DSL.

thenStmt

fun LanguageFrontend<*, *>.thenStmt(needsScope: Boolean = true, init: Block.() -> Unit): Block

Creates a new Block in the Fluent Node DSL and sets it to the IfStatement.thenStatement of the nearest enclosing IfStatement. The init block can be used to create further sub-nodes as well as configuring the created node itself.

throw

infix fun Expression.throw(init: ThrowExpression.() -> Unit?): ThrowExpression

Creates a new ThrowExpression in the Fluent Node DSL and adds it to the nearest enclosing StatementHolder.

times

operator fun Expression.times(rhs: Expression): BinaryOperator

Creates a new BinaryOperator with a * BinaryOperator.operatorCode in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing ArgumentHolder.

translationResult

fun LanguageFrontend<*, *>.translationResult(init: TranslationResult.() -> Unit): TranslationResult

translationUnit

fun LanguageFrontend<*, *>.translationUnit(name: CharSequence = Node.EMPTY_NAME, init: TranslationUnitDeclaration.() -> Unit): TranslationUnitDeclaration

Creates a new TranslationUnitDeclaration in the Fluent Node DSL with the given name. The declaration will be set to the ScopeManager.globalScope. The init block can be used to create further sub-nodes as well as configuring the created node itself.

unaryMinus

operator fun Expression.unaryMinus(): UnaryOperator

Creates a new UnaryOperator with a - UnaryOperator.operatorCode in the Fluent Node DSL and invokes ArgumentHolder.addArgument of the nearest enclosing ArgumentHolder.

variable

fun LanguageFrontend<*, *>.variable(init: ForEachStatement.() -> Statement): Statement

Configures the ForEachStatement.variable in the Fluent Node DSL of the nearest enclosing ForEachStatement. The init block can be used to create further sub-nodes as well as configuring the created node itself.

fun LanguageFrontend<*, *>.variable(name: String, type: Type = unknownType(), init: VariableDeclaration.() -> Unit? = null): VariableDeclaration

Creates a new VariableDeclaration in the Fluent Node DSL and adds it to the DeclarationStatement.declarations of the nearest enclosing DeclarationStatement. The init block can be used to create further sub-nodes as well as configuring the created node itself.

void

fun LanguageFrontend<*, *>.void(): Type

Creates a new IncompleteType in the Fluent Node DSL.

whileCondition

fun LanguageFrontend<*, *>.whileCondition(init: WhileStatement.() -> Expression): Expression

Configures the WhileStatement.condition in the Fluent Node DSL of the nearest enclosing WhileStatement. The init block can be used to create further sub-nodes as well as configuring the created node itself.

whileStmt

fun LanguageFrontend<*, *>.whileStmt(needsScope: Boolean = true, init: WhileStatement.() -> Unit): WhileStatement

Creates a new WhileStatement in the Fluent Node DSL and adds it to the StatementHolder.statements of the nearest enclosing StatementHolder. The init block can be used to create further sub-nodes as well as configuring the created node itself.