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

Package-level declarations

Functions

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

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

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

body

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

Creates a new CompoundStatement 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.

breakStmt

fun LanguageFrontend.breakStmt(label: String? = null): BreakStatement

Creates a new BreakStatement in the Fluent Node DSL and invokes StatementHolder.addStatement of 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(caseExpr: Expression? = null): CaseStatement

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

condition

fun LanguageFrontend.condition(init: IfStatement.() -> BinaryOperator): BinaryOperator

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, thenExpr: Expression, elseExpr: Expression): ConditionalExpression

Creates a new ConditionalExpression with a = BinaryOperator.operatorCode in the Fluent Node DSL and invokes StatementHolder.addStatement of 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 invokes StatementHolder.addStatement of the nearest enclosing StatementHolder.

dec

operator fun Expression.dec(): UnaryOperator

Creates a new UnaryOperator with a -- UnaryOperator.operatorCode in the Fluent Node DSL and invokes StatementHolder.addStatement of 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.

default

fun LanguageFrontend.default(): DefaultStatement

Creates a new DefaultStatement in the Fluent Node DSL and invokes StatementHolder.addStatement of the nearest enclosing Holder, but only if it is an StatementHolder.

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: CompoundStatement.() -> Unit): CompoundStatement

Creates a new CompoundStatement 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 = newUnknownType(), init: FieldDeclaration.() -> Unit): 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.

function

fun LanguageFrontend.function(name: CharSequence, returnType: Type = newUnknownType(), 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.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.

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.

label

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

Creates a new LabelStatement in the Fluent Node DSL and invokes StatementHolder.addStatement of the nearest enclosing Holder, but only if it is an StatementHolder.

literal

fun <N> LanguageFrontend.literal(value: N, type: Type = newUnknownType()): 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: CompoundStatement.() -> Unit): CompoundStatement

Creates a new CompoundStatement in the Fluent Node DSL and sets it to the WhileStatement.statement of the nearest enclosing WhileStatement. 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.

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, member: Expression, isStatic: Boolean = false, init: CallExpression.() -> 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 = newUnknownType()): Expression

method

fun LanguageFrontend.method(name: CharSequence, returnType: Type = newUnknownType(), init: MethodDeclaration.() -> Unit): 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 = newUnknownType(), init: ParamVariableDeclaration.() -> Unit? = null): ParamVariableDeclaration

Creates a new ParamVariableDeclaration 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 invokes StatementHolder.addStatement of the nearest enclosing StatementHolder.

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 = newUnknownType(), init: DeclaredReferenceExpression.() -> Unit? = null): DeclaredReferenceExpression

Creates a new DeclaredReferenceExpression 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.

switchBody

fun LanguageFrontend.switchBody(init: CompoundStatement.() -> Unit): CompoundStatement

Creates a new CompoundStatement 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, init: Type.() -> Unit? = null): Type

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

thenStmt

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

Creates a new CompoundStatement 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.

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.

variable

fun LanguageFrontend.variable(name: String, type: Type = newUnknownType(), 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.

whileCondition

fun LanguageFrontend.whileCondition(init: WhileStatement.() -> BinaryOperator): BinaryOperator

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.