Namespace: compiler

Classes

Interfaces

Type Aliases

Variables

Functions

Type Aliases

ASTArithmeticExpressionKind

Ƭ ASTArithmeticExpressionKind: typeof RULE_additiveExpression | typeof RULE_multiplicativeExpression

Union type of all possible kind values for a constructable ArithmeticExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/arithmetic/arithmetic-expression.ts:18

ASTBitwiseExpressionKind

Ƭ ASTBitwiseExpressionKind: typeof RULE_bitwiseAndExpression | typeof RULE_bitwiseOrExpression | typeof RULE_bitwiseXorExpression | typeof RULE_bitwiseShiftExpression

Union type of all possible kind values for a constructable BitwiseExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/bitwise-expression/bitwise-expression.ts:15

ASTComparativeExpressionKind

Ƭ ASTComparativeExpressionKind: typeof RULE_equalityExpression | typeof RULE_relationalExpression

Union type of all possible kind values for a constructable ComparativeExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/comparative-expression/comparative-expression.ts:16

ASTDeclarationKind

Ƭ ASTDeclarationKind: typeof RULE_functionDeclaration | typeof RULE_parameterDeclaration | typeof RULE_variableDeclaration

Union type of all possible kind values that have a constructable Declaration AST node.

Note that not all ParseRuleKindMapping rule context classes have a corresponding AST node class. For example, the ParseRuleKindMapping.declaration rule context has no corresponding AST node class because it is a union of all possible declaration types.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:126

ASTDeclarationRuleName

Ƭ ASTDeclarationRuleName: typeof KindParseRuleMapping[typeof RULE_functionDeclaration] | typeof KindParseRuleMapping[typeof RULE_parameterDeclaration] | typeof KindParseRuleMapping[typeof RULE_variableDeclaration]

Union type of all possible ruleName values that have a constructable Declaration AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:202

ASTExpressionKind

Union type of all possible kind values that have a constructable Expression AST node.

Note that not all ParseRuleKindMapping rule context classes have a corresponding AST node class. For example, the ParseRuleKindMapping.primaryExpression rule context has no corresponding AST node class because it is a union of all possible primary expression types.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:154

ASTExpressionRuleName

Union type of all possible ruleName values that have a constructable Expression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:228

ASTKind

Ƭ ASTKind: typeof ParseRuleKindMapping[keyof typeof ParseRuleKindMapping]

Union type of every possible AST kind number mapped to a KipperParser rule.

Not every number contained here is mapped to a constructable AST node. Some may be only used for internal purposes inside the parser. For completion’s sake, all numbers are listed here regardless.

Since

0.10.0

Defined in

kipper/core/src/compiler/lexer-parser/parse-rule-kind-mapping.ts:117

ASTLogicalExpressionKind

Ƭ ASTLogicalExpressionKind: typeof RULE_logicalAndExpression | typeof RULE_logicalOrExpression

Union type of all possible kind values for a constructable LogicalExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/logical-expression/logical-expression.ts:17

ASTNodeParserContext

Ƭ ASTNodeParserContext: ParserExpressionContext | ParserStatementContext | ParserDeclarationContext

Union type of all rule context classes implemented by the ParseRuleKindMapping that have a corresponding AST node class.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:116

ASTPostfixExpressionKind

Ƭ ASTPostfixExpressionKind: typeof RULE_incrementOrDecrementPostfixExpression

Union type of all possible kind values for a constructable PostfixExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/postfix-expression/postfix-expression.ts:17

ASTPrimaryExpressionKind

Ƭ ASTPrimaryExpressionKind: typeof RULE_objectProperty | typeof RULE_numberPrimaryExpression | typeof RULE_stringPrimaryExpression | typeof RULE_boolPrimaryExpression | typeof RULE_voidOrNullOrUndefinedPrimaryExpression | typeof RULE_arrayPrimaryExpression | typeof RULE_objectPrimaryExpression | typeof RULE_fStringPrimaryExpression | typeof RULE_identifierPrimaryExpression | typeof RULE_tangledPrimaryExpression

Union type of all possible kind values for a constructable PrimaryExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/primary-expression/primary-expression.ts:17

ASTStatementKind

Union type of all possible kind values for a Statement AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:135

ASTStatementRuleName

Union type of all possible ruleName values that have a constructable Statement AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:212

ASTTypeSpecifierExpressionKind

Ƭ ASTTypeSpecifierExpressionKind: typeof RULE_identifierTypeSpecifierExpression | typeof RULE_genericTypeSpecifierExpression | typeof RULE_typeofTypeSpecifierExpression

Union type of all possible kind values for a constructable TypeSpecifierExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/type-specifier-expression/type-specifier-expression.ts:16

ASTUnaryExpressionKind

Ƭ ASTUnaryExpressionKind: typeof RULE_incrementOrDecrementUnaryExpression | typeof RULE_operatorModifiedUnaryExpression

Union type of all possible kind values for a constructable UnaryExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/unary-expression/unary-expression.ts:18

AnalysableNodeChild

Ƭ AnalysableNodeChild: AnalysableASTNode

An eligible parent for an analysable AST node.

Defined in

kipper/core/src/compiler/ast/analysable-ast-node.ts:27

AnalysableNodeParent

Ƭ AnalysableNodeParent: AnalysableASTNode | RootASTNode

An eligible parent for an analysable AST node.

Defined in

kipper/core/src/compiler/ast/analysable-ast-node.ts:22

CompilableNodeChild

Ƭ CompilableNodeChild: CompilableASTNode

An eligible child for a compilable AST node.

Since

0.8.0

Defined in

kipper/core/src/compiler/ast/compilable-ast-node.ts:32

CompilableNodeParent

Ƭ CompilableNodeParent: CompilableASTNode | RootASTNode

An eligible parent for a compilable AST node.

Since

0.8.0

Defined in

kipper/core/src/compiler/ast/compilable-ast-node.ts:26

ConstructableASTDeclaration

Ƭ ConstructableASTDeclaration: InstanceType<ConstructableASTDeclarationClass>

A union of all construable Declaration AST nodes. Uses ConstructableASTDeclarationClass to infer the type.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/declaration-ast-factory.ts:66

ConstructableASTDeclarationClass

Ƭ ConstructableASTDeclarationClass: typeof ruleMapping[ASTDeclarationKind]

A union of all construable Declaration AST node classes.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/declaration-ast-factory.ts:60

ConstructableASTExpression

Ƭ ConstructableASTExpression: InstanceType<ConstructableASTExpressionClass>

A union of all construable Expression AST nodes. Uses ConstructableASTExpressionClass to infer the type.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/expression-ast-factory.ts:66

ConstructableASTExpressionClass

Ƭ ConstructableASTExpressionClass: typeof ruleMapping[ASTExpressionKind]

A union of all construable Expression AST node classes.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/expression-ast-factory.ts:60

ConstructableASTKind

Ƭ ConstructableASTKind: ASTDeclarationKind | ASTStatementKind | ASTExpressionKind

Union type of all possible kind values that have a constructable CompilableASTNode.

This unlike ASTKind only contains the syntax kinds that have a corresponding constructable CompilableASTNode implementation and as such can be created using an ASTNodeFactory.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:195

ConstructableASTNode

Ƭ ConstructableASTNode: InstanceType<ConstructableASTNodeClass>

A union of all construable AST nodes. Uses ConstructableASTNodeClass to infer the type.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/index.ts:27

ConstructableASTNodeClass

Ƭ ConstructableASTNodeClass: ConstructableASTStatementClass | ConstructableASTExpressionClass | ConstructableASTDeclarationClass

A union of all construable AST node classes.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/index.ts:18

ConstructableASTRuleName

Ƭ ConstructableASTRuleName: ASTDeclarationRuleName | ASTStatementRuleName | ASTExpressionRuleName

Union type of all possible ruleName values that have a constructable CompilableASTNode.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:266

ConstructableASTStatement

Ƭ ConstructableASTStatement: InstanceType<ConstructableASTStatementClass>

A union of all construable Statement AST nodes. Uses ConstructableASTStatementClass to infer the type.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/statement-ast-factory.ts:64

ConstructableASTStatementClass

Ƭ ConstructableASTStatementClass: typeof ruleMapping[ASTStatementKind]

A union of all construable Statement AST node classes.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/statement-ast-factory.ts:58

JmpStatementType

Ƭ JmpStatementType: "continue" | "break"

Represents all possible jump statements inside Kipper.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:672

KipperAdditiveOperator

Ƭ KipperAdditiveOperator: KipperMinusOperator | KipperPlusOperator

All available additive operations inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:447

KipperArg

Ƭ KipperArg: KipperParam

Represents a Kipper argument inside a custom user-defined ScopeFunctionDeclaration.

Alias

KipperParam

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:660

KipperArithmeticAssignOperator

Ƭ KipperArithmeticAssignOperator: "+=" | "-=" | "*=" | "/=" | "%="

All available arithmetic assignment operations inside Kipper.

Since

0.3.0

Defined in

kipper/core/src/compiler/const.ts:575

KipperArithmeticOperator

Ƭ KipperArithmeticOperator: KipperAdditiveOperator | KipperMultiplicativeOperator

All available arithmetic operations inside Kipper.

Since

0.3.0

Defined in

kipper/core/src/compiler/const.ts:560

KipperAssignOperator

Ƭ KipperAssignOperator: KipperEqualAssignOperator | KipperArithmeticAssignOperator

All available assignment operators inside Kipper, which can be used to assign a value to a variable/reference.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:599

KipperBitwiseAndOperator

Ƭ KipperBitwiseAndOperator: "&"

The bitwise-and operator, which can be used to combine two numbers bitwise.

Example

EXP & EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:300

KipperBitwiseNotOperator

Ƭ KipperBitwiseNotOperator: "~"

The bitwise-not operator, which can be used to negate a number bitwise.

Example

~EXP;

Since

0.11.0

Defined in

kipper/core/src/compiler/const.ts:360

KipperBitwiseOperator

Ƭ KipperBitwiseOperator: KipperBitwiseAndOperator | KipperBitwiseOrOperator | KipperBitwiseXorOperator | KipperBitwiseShiftOperator

All available bitwise operators inside Kipper, which can be used to combine two numbers bitwise.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:374

KipperBitwiseOrOperator

Ƭ KipperBitwiseOrOperator: "|"

The bitwise-or operator, which can be used to combine two numbers bitwise.

Example

EXP | EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:316

KipperBitwiseShiftOperator

Ƭ KipperBitwiseShiftOperator: "<<" | ">>" | ">>>"

All available bitwise operators inside Kipper, which can be used to combine two numbers bitwise.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:330

KipperBitwiseXorOperator

Ƭ KipperBitwiseXorOperator: "^"

The bitwise-xor operator, which can be used to combine two numbers bitwise.

Example

EXP ^ EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:344

KipperBoolType

Ƭ KipperBoolType: "bool"

Boolean type in Kipper.

Since

0.5.0

Example

bool

Defined in

kipper/core/src/compiler/const.ts:128

KipperBoolTypeLiterals

Ƭ KipperBoolTypeLiterals: "true" | "false"

Literal names for a Kipper boolean.

Since

0.8.0

Example

var x: bool = true;

Defined in

kipper/core/src/compiler/const.ts:136

KipperComparativeOperator

Ƭ KipperComparativeOperator: KipperEqualityOperator | KipperRelationalOperator

All available comparative operators inside Kipper, which can be used to compare two expressions against each other.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:408

KipperCompilableType

Ƭ KipperCompilableType: KipperMetaType | KipperPrimitiveType | KipperFuncType | KipperListType<any>

All compilable and valid base types inside Kipper.

This is mainly different from the standard KipperType that it excludes KipperErrorType, which is only used for error handling/recovery and skips type checking altogether.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:197

KipperEqualAssignOperator

Ƭ KipperEqualAssignOperator: "="

Default assignment operator for assigning a value to a variable/reference.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:587

KipperEqualityOperator

Ƭ KipperEqualityOperator: "==" | "!="

All available equality operators inside Kipper, which can be used to compare two expressions against each other.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:384

KipperErrorType

Ƭ KipperErrorType: UndefinedCustomType

All error types inside Kipper, which indicate an invalid type that can not be used for type checking.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:213

KipperFuncType

Ƭ KipperFuncType: "func"

Function type in Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:66

KipperFunction

Ƭ KipperFunction: InternalFunction | KipperReferenceableFunction

Represents a Kipper function that can be either declared or defined.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:640

KipperIncrementOrDecrementOperator

Ƭ KipperIncrementOrDecrementOperator: "++" | "--"

All available increment and decrement operators, which can be used to modify the value of an expression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:489

KipperListType

Ƭ KipperListType<T>: "list"

List type in Kipper. T represents the type of the list content and only serves as a type checking generic type, it will not change the type itself.

Since

0.5.0

Example

list<T>

Type parameters

Name	Type
`T`	extends `KipperType`

Defined in

kipper/core/src/compiler/const.ts:154

KipperLogicalAndOperator

Ƭ KipperLogicalAndOperator: "&&"

The logical-and operator, which can be used to combine multiple conditions and return true if all conditions are true.

Example

EXP && EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:254

KipperLogicalOperator

Ƭ KipperLogicalOperator: KipperLogicalAndOperator | KipperLogicalOrOperator

All available logical operators inside Kipper, which can be used to compare or combine two expressions.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:286

KipperLogicalOrOperator

Ƭ KipperLogicalOrOperator: "||"

The logical-or operator, which can be used to combine multiple conditions and return true if at least one condition is true.

Example

EXP || EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:271

KipperMetaType

Ƭ KipperMetaType: "type"

Represents the meta type in Kipper, which itself is used represents a type e.g. this is the type of a type.

Since

0.8.0

Defined in

kipper/core/src/compiler/const.ts:29

KipperMinusOperator

Ƭ KipperMinusOperator: "-"

The minus operator.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:435

KipperMultiplicativeOperator

Ƭ KipperMultiplicativeOperator: "*" | "**" | "/" | "%"

All available multiplicative operators inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:539

KipperNegateOperator

Ƭ KipperNegateOperator: "!"

Negate operator, which can be used to negate a boolean expression. It evaluates to the opposite boolean representation of the original expression.

Example

!true; // false
!false; // true
!1; // false
!0; // true

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:471

KipperNullType

Ƭ KipperNullType: "null"

Null type in Kipper.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:42

KipperNumType

Ƭ KipperNumType: "num"

Numeric type in Kipper.

Since

0.5.0

Example

num

Defined in

kipper/core/src/compiler/const.ts:96

KipperParam

Ƭ KipperParam: ScopeParameterDeclaration

Represents a Kipper parameter inside a custom user-defined ScopeFunctionDeclaration.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:652

KipperPlusOperator

Ƭ KipperPlusOperator: "+"

The plus operator.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:423

KipperPrimitiveType

All primitive types inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:169

KipperReferenceable

Ƭ KipperReferenceable: KipperReferenceableFunction | KipperVariable | KipperParam | ScopeDeclaration

Represents a runtime variable or function that can be referenced.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:666

KipperReferenceableFunction

Ƭ KipperReferenceableFunction: BuiltInFunction | ScopeFunctionDeclaration

Represents all referencable functions that a user can use inside Kipper. This does not include internal functions.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:634

KipperRelationalOperator

Ƭ KipperRelationalOperator: "<" | ">" | "<=" | ">="

All available relational operators inside Kipper, which can be used to compare two expressions against each other.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:396

KipperSignOperator

Ƭ KipperSignOperator: "+" | "-"

All available sign operators inside Kipper, which can be used to modify the value of a numeric expression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:453

KipperStorageType

Ƭ KipperStorageType: "var" | "const"

All available storage types inside Kipper, which define how a variable is stored/can be accessed.

Defined in

kipper/core/src/compiler/const.ts:240

KipperStrType

Ƭ KipperStrType: "str"

String type in Kipper.

Since

0.5.0

Example

str

Defined in

kipper/core/src/compiler/const.ts:112

KipperType

Ƭ KipperType: KipperCompilableType | KipperErrorType

All available variable types inside Kipper.

Defined in

kipper/core/src/compiler/const.ts:218

KipperUnaryModifierOperator

Ƭ KipperUnaryModifierOperator: KipperNegateOperator | KipperSignOperator | KipperBitwiseNotOperator

Modifier Unary operators, which can be used to modify the value of an expression.

This type specifically exists for the OperatorModifiedUnaryExpression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:503

KipperUnaryOperator

Ƭ KipperUnaryOperator: KipperUnaryModifierOperator | KipperIncrementOrDecrementOperator | KipperBitwiseNotOperator

All available unary operators in Kipper, which can be used to modify the value of an expression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:521

KipperUndefinedType

Ƭ KipperUndefinedType: "undefined"

Undefined type in Kipper.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:54

KipperVariable

Ƭ KipperVariable: BuiltInVariable | ScopeVariableDeclaration

Represents a Kipper variable that can be either declared or defined.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:646

KipperVoidType

Ƭ KipperVoidType: "void"

Void type in Kipper.

Since

0.5.0

Example

void

Defined in

kipper/core/src/compiler/const.ts:80

MemberAccessExpressionContext

Ƭ MemberAccessExpressionContext: DotNotationMemberAccessExpressionContext | BracketNotationMemberAccessExpressionContext | SliceNotationMemberAccessExpressionContext

A union of all possible KipperParserRuleContext rule contexts that MemberAccessExpression implements.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/member-access-expression/member-access-expression.ts:24

ParserArithmeticExpressionContext

Ƭ ParserArithmeticExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTArithmeticExpressionKind]\>

Union type of all possible ParserASTNode context classes for a constructable ArithmeticExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/arithmetic/arithmetic-expression.ts:26

ParserArithmeticExpressionRuleName

Ƭ ParserArithmeticExpressionRuleName: typeof KindParseRuleMapping[ASTArithmeticExpressionKind]

Union type of all possible ruleName values for a constructable ArithmeticExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/arithmetic/arithmetic-expression.ts:35

ParserBitwiseExpressionContext

Ƭ ParserBitwiseExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTBitwiseExpressionKind]\>

Union type of all possible kind context classes for a constructable BitwiseExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/bitwise-expression/bitwise-expression.ts:26

ParserBitwiseExpressionRuleName

Ƭ ParserBitwiseExpressionRuleName: typeof KindParseRuleMapping[ASTBitwiseExpressionKind]

Union type of all possible ruleName values for a constructable BitwiseExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/bitwise-expression/bitwise-expression.ts:35

ParserComparativeExpressionContext

Ƭ ParserComparativeExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTComparativeExpressionKind]\>

Union type of all possible ParserASTNode context classes for a constructable ComparativeExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/comparative-expression/comparative-expression.ts:24

ParserComparativeExpressionRuleName

Ƭ ParserComparativeExpressionRuleName: typeof KindParseRuleMapping[ASTComparativeExpressionKind]

Union type of all possible ruleName values for a constructable ComparativeExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/comparative-expression/comparative-expression.ts:33

ParserDeclarationContext

Ƭ ParserDeclarationContext: FunctionDeclarationContext | ParameterDeclarationContext | VariableDeclarationContext

Union type of all usable definition/declaration rule context classes implemented by the ParseRuleKindMapping for a Declaration.

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:107

ParserExpressionContext

Union type of all usable expression rule context classes implemented by the ParseRuleKindMapping for an Expression.

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:56

ParserIterationStatementContext

Ƭ ParserIterationStatementContext: InstanceTypestatementKindToRuleContextMap[ParserIterationStatementKind]\>

Union type of all possible ParserASTNode context classes for a constructable MemberAccessExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/statements/iteration-statement/iteration-statement.ts:27

ParserIterationStatementKind

Ƭ ParserIterationStatementKind: typeof RULE_forLoopIterationStatement | typeof RULE_whileLoopIterationStatement | typeof RULE_doWhileLoopIterationStatement

Union type of all possible kind values for a constructable MemberAccessExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/statements/iteration-statement/iteration-statement.ts:17

ParserIterationStatementRuleName

Ƭ ParserIterationStatementRuleName: typeof KindParseRuleMapping[ParserIterationStatementKind]

Union type of all possible ruleName values for a constructable MemberAccessExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/statements/iteration-statement/iteration-statement.ts:36

ParserLogicalExpressionContext

Ƭ ParserLogicalExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTLogicalExpressionKind]\>

Union type of all possible kind context classes for a constructable LogicalExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/logical-expression/logical-expression.ts:26

ParserLogicalExpressionRuleName

Ƭ ParserLogicalExpressionRuleName: typeof KindParseRuleMapping[ASTLogicalExpressionKind]

Union type of all possible ruleName values for a constructable LogicalExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/logical-expression/logical-expression.ts:35

ParserPostfixExpressionContext

Ƭ ParserPostfixExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTPostfixExpressionKind]\>

Union type of all possible kind context classes for a constructable PostfixExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/postfix-expression/postfix-expression.ts:24

ParserPostfixExpressionRuleName

Ƭ ParserPostfixExpressionRuleName: typeof KindParseRuleMapping[ASTPostfixExpressionKind]

Union type of all possible ruleName values for a constructable PostfixExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/postfix-expression/postfix-expression.ts:33

ParserPrimaryExpressionContext

Ƭ ParserPrimaryExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTPrimaryExpressionKind]\>

Union type of all possible kind context classes for a constructable PrimaryExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/primary-expression/primary-expression.ts:34

ParserPrimaryExpressionRuleName

Ƭ ParserPrimaryExpressionRuleName: typeof KindParseRuleMapping[ASTPrimaryExpressionKind]

Union type of all possible ruleName values for a constructable PrimaryExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/primary-expression/primary-expression.ts:43

ParserStatementContext

Union type of all usable statement rule context classes implemented by the ParseRuleKindMapping for a Statement.

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:92

ParserTypeSpecifierExpressionContext

Ƭ ParserTypeSpecifierExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTTypeSpecifierExpressionKind]\>

Union type of all possible ParserASTNode context classes for a constructable TypeSpecifierExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/type-specifier-expression/type-specifier-expression.ts:26

ParserTypeSpecifierExpressionRuleName

Ƭ ParserTypeSpecifierExpressionRuleName: typeof KindParseRuleMapping[ASTTypeSpecifierExpressionKind]

Union type of all possible ruleName values for a constructable TypeSpecifierExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/type-specifier-expression/type-specifier-expression.ts:35

ParserUnaryExpressionContext

Ƭ ParserUnaryExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTUnaryExpressionKind]\>

Union type of all possible ParserASTNode context classes for a constructable UnaryExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/unary-expression/unary-expression.ts:26

ParserUnaryExpressionRuleName

Ƭ ParserUnaryExpressionRuleName: typeof KindParseRuleMapping[ASTUnaryExpressionKind]

Union type of all possible ruleName values for a constructable UnaryExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/unary-expression/unary-expression.ts:35

SemanticData

Ƭ SemanticData: Record<string, any>

Semantics type which defines the blueprint for semanticData inside a CompilableASTNode.

Since

0.3.0

Defined in

kipper/core/src/compiler/ast/ast-node.ts:18

TargetASTNodeCodeGenerator

Ƭ TargetASTNodeCodeGenerator<T, R>: Function & (node: T) => Promise<R>

Represents a function that translates a Kipper token code into a specific language.

The return may only be of type TranslatedExpression, TranslatedCodeLine or Array.

Since

0.10.0

Type parameters

Name	Type
`T`	extends `CompilableASTNode`
`R`	extends `TranslatedExpression` \| `TranslatedCodeLine` \| `TranslatedCodeLine`[]

Defined in

kipper/core/src/compiler/target-presets/translation/code-generator.ts:64

TargetASTNodeSemanticAnalyser

Ƭ TargetASTNodeSemanticAnalyser<T>: (node: T) => Promise<void>

Type parameters

Name	Type
`T`	extends `AnalysableASTNode`<`SemanticData`, `TypeData`>

Type declaration

▸ (node): Promise<void>

Represents a function that checks the semantics for a AnalysableASTNode.

This function does not interpret but only check the logical integrity of the AST node.

Since

0.10.0

Parameters

Name	Type
`node`	`T`

Returns

Promise<void>

Defined in

kipper/core/src/compiler/target-presets/semantic-analyser.ts:60

TargetSetUpCodeGenerator

Ƭ TargetSetUpCodeGenerator: (programCtx: KipperProgramContext) => Promise<TranslatedCodeLine[]>

Type declaration

▸ (programCtx): Promise<TranslatedCodeLine[]>

Represents a function that generates setup code for a Kipper file.

This is not intended as a replacement to KipperTargetBuiltInGenerator.

Since

0.10.0

Parameters

Name	Type
`programCtx`	`KipperProgramContext`

Returns

Promise<TranslatedCodeLine[]>

Defined in

kipper/core/src/compiler/target-presets/translation/code-generator.ts:75

TargetWrapUpCodeGenerator

Ƭ TargetWrapUpCodeGenerator: (programCtx: KipperProgramContext) => Promise<TranslatedCodeLine[]>

Type declaration

▸ (programCtx): Promise<TranslatedCodeLine[]>

Represents a function that generates wrap up code for a Kipper file.

This is not intended as a replacement to KipperTargetBuiltInGenerator.

Since

0.10.0

Parameters

Name	Type
`programCtx`	`KipperProgramContext`

Returns

Promise<TranslatedCodeLine[]>

Defined in

kipper/core/src/compiler/target-presets/translation/code-generator.ts:83

TranslatedCodeLine

Ƭ TranslatedCodeLine: TranslatedCodeToken[]

Represents a single line of translated Kipper code.

Since

0.5.0

Defined in

kipper/core/src/compiler/const.ts:628

TranslatedCodeToken

Ƭ TranslatedCodeToken: string

Represents a single token of translated Kipper code. This is usually used without a TranslatedCodeLine, which represents a whole translated line of code.

Since

0.5.0

Defined in

kipper/core/src/compiler/const.ts:615

TranslatedExpression

Ƭ TranslatedExpression: TranslatedCodeToken[]

Represents a single translated Kipper expression. This is usually used to represent multiple expression inside a single TranslatedCodeLine.

Since

0.5.0

Defined in

kipper/core/src/compiler/const.ts:622

TypeData

Ƭ TypeData: Record<string, any>

Type semantics for an expression class that must be evaluated during Type Checking.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/ast-node.ts:24

Variables

COMMENT

• Const COMMENT: 2

The comment channels where all comments are stored.

Since

0.11.0

Defined in

kipper/core/src/compiler/lexer-parser/lexer-channels.ts:19

DEFAULT_TOKEN_CHANNEL

• Const DEFAULT_TOKEN_CHANNEL: 0

The default channel ID which all parser-relevant tokens are stored.

Since

0.11.0

Defined in

kipper/core/src/compiler/lexer-parser/lexer-channels.ts:7

HIDDEN

• Const HIDDEN: 1

The hidden channel where all whitespaces and newlines are stored.

Since

0.11.0

Defined in

kipper/core/src/compiler/lexer-parser/lexer-channels.ts:13

KindParseRuleMapping

• Const KindParseRuleMapping: InverseMap<{ RULE_additiveExpression: 58 = KipperParser.RULE_additiveExpression; RULE_argumentExpressionList: 45 = KipperParser.RULE_argumentExpressionList; RULE_arrayPrimaryExpression: 40 = KipperParser.RULE_arrayPrimaryExpression; RULE_assignmentExpression: 69 = KipperParser.RULE_assignmentExpression; RULE_assignmentOperator: 70 = KipperParser.RULE_assignmentOperator; RULE_bitwiseAndExpression: 63 = KipperParser.RULE_bitwiseAndExpression; RULE_bitwiseOrExpression: 65 = KipperParser.RULE_bitwiseOrExpression; RULE_bitwiseShiftExpression: 59 = KipperParser.RULE_bitwiseShiftExpression; RULE_bitwiseShiftOperators: 60 = KipperParser.RULE_bitwiseShiftOperators; RULE_bitwiseXorExpression: 64 = KipperParser.RULE_bitwiseXorExpression; RULE_blockItem: 4 = KipperParser.RULE_blockItem; RULE_blockItemList: 3 = KipperParser.RULE_blockItemList; RULE_boolPrimaryExpression: 31 = KipperParser.RULE_boolPrimaryExpression; RULE_bracketNotation: 47 = KipperParser.RULE_bracketNotation; RULE_castOrConvertExpression: 56 = KipperParser.RULE_castOrConvertExpression; RULE_compilationUnit: 0 = KipperParser.RULE_compilationUnit; RULE_compoundStatement: 16 = KipperParser.RULE_compoundStatement; RULE_computedPrimaryExpression: 44 = KipperParser.RULE_computedPrimaryExpression; RULE_conditionalExpression: 68 = KipperParser.RULE_conditionalExpression; RULE_declaration: 5 = KipperParser.RULE_declaration; RULE_declarator: 9 = KipperParser.RULE_declarator; RULE_directDeclarator: 10 = KipperParser.RULE_directDeclarator; RULE_doWhileLoopIterationStatement: 25 = KipperParser.RULE_doWhileLoopIterationStatement; RULE_dotNotation: 46 = KipperParser.RULE_dotNotation; RULE_equalityExpression: 62 = KipperParser.RULE_equalityExpression; RULE_expression: 71 = KipperParser.RULE_expression; RULE_expressionStatement: 17 = KipperParser.RULE_expressionStatement; RULE_externalItem: 2 = KipperParser.RULE_externalItem; RULE_fStringDoubleQuoteAtom: 38 = KipperParser.RULE_fStringDoubleQuoteAtom; RULE_fStringPrimaryExpression: 36 = KipperParser.RULE_fStringPrimaryExpression; RULE_fStringSingleQuoteAtom: 37 = KipperParser.RULE_fStringSingleQuoteAtom; RULE_forLoopIterationStatement: 23 = KipperParser.RULE_forLoopIterationStatement; RULE_functionCallExpression: 1002 = 1002; RULE_functionDeclaration: 6 = KipperParser.RULE_functionDeclaration; RULE_genericTypeSpecifierExpression: 74 = KipperParser.RULE_genericTypeSpecifierExpression; RULE_identifier: 33 = KipperParser.RULE_identifier; RULE_identifierOrStringPrimaryExpression: 34 = KipperParser.RULE_identifierOrStringPrimaryExpression; RULE_identifierPrimaryExpression: 32 = KipperParser.RULE_identifierPrimaryExpression; RULE_identifierTypeSpecifierExpression: 73 = KipperParser.RULE_identifierTypeSpecifierExpression; RULE_ifStatement: 19 = KipperParser.RULE_ifStatement; RULE_incrementOrDecrementOperator: 54 = KipperParser.RULE_incrementOrDecrementOperator; RULE_incrementOrDecrementPostfixExpression: 50 = KipperParser.RULE_incrementOrDecrementPostfixExpression; RULE_incrementOrDecrementUnaryExpression: 52 = KipperParser.RULE_incrementOrDecrementUnaryExpression; RULE_initDeclarator: 11 = KipperParser.RULE_initDeclarator; RULE_initializer: 14 = KipperParser.RULE_initializer; RULE_iterationStatement: 22 = KipperParser.RULE_iterationStatement; RULE_jumpStatement: 26 = KipperParser.RULE_jumpStatement; RULE_lambdaExpression: 29 = KipperParser.RULE_lambdaExpression; RULE_logicalAndExpression: 66 = KipperParser.RULE_logicalAndExpression; RULE_logicalOrExpression: 67 = KipperParser.RULE_logicalOrExpression; RULE_memberAccessExpression: 1001 = 1001; RULE_multiplicativeExpression: 57 = KipperParser.RULE_multiplicativeExpression; RULE_numberPrimaryExpression: 39 = KipperParser.RULE_numberPrimaryExpression; RULE_objectPrimaryExpression: 41 = KipperParser.RULE_objectPrimaryExpression; RULE_objectProperty: 42 = KipperParser.RULE_objectProperty; RULE_operatorModifiedUnaryExpression: 53 = KipperParser.RULE_operatorModifiedUnaryExpression; RULE_parameterDeclaration: 13 = KipperParser.RULE_parameterDeclaration; RULE_parameterList: 12 = KipperParser.RULE_parameterList; RULE_postfixExpression: 49 = KipperParser.RULE_postfixExpression; RULE_primaryExpression: 28 = KipperParser.RULE_primaryExpression; RULE_relationalExpression: 61 = KipperParser.RULE_relationalExpression; RULE_returnStatement: 27 = KipperParser.RULE_returnStatement; RULE_selectionStatement: 18 = KipperParser.RULE_selectionStatement; RULE_sliceNotation: 48 = KipperParser.RULE_sliceNotation; RULE_statement: 15 = KipperParser.RULE_statement; RULE_storageTypeSpecifier: 8 = KipperParser.RULE_storageTypeSpecifier; RULE_stringPrimaryExpression: 35 = KipperParser.RULE_stringPrimaryExpression; RULE_switchLabeledStatement: 21 = KipperParser.RULE_switchLabeledStatement; RULE_switchStatement: 20 = KipperParser.RULE_switchStatement; RULE_tangledPrimaryExpression: 30 = KipperParser.RULE_tangledPrimaryExpression; RULE_translationUnit: 1 = KipperParser.RULE_translationUnit; RULE_typeSpecifierExpression: 72 = KipperParser.RULE_typeSpecifierExpression; RULE_typeSpecifierIdentifier: 76 = KipperParser.RULE_typeSpecifierIdentifier; RULE_typeofTypeSpecifierExpression: 75 = KipperParser.RULE_typeofTypeSpecifierExpression; RULE_unaryExpression: 51 = KipperParser.RULE_unaryExpression; RULE_unaryOperator: 55 = KipperParser.RULE_unaryOperator; RULE_variableDeclaration: 7 = KipperParser.RULE_variableDeclaration; RULE_voidOrNullOrUndefinedPrimaryExpression: 43 = KipperParser.RULE_voidOrNullOrUndefinedPrimaryExpression; RULE_whileLoopIterationStatement: 24 = KipperParser.RULE_whileLoopIterationStatement }>

Inverse mapping of ParseRuleKindMapping which maps the AST syntax kind number to the KipperParser rule.

Since

0.11.0

Defined in

kipper/core/src/compiler/lexer-parser/parse-rule-kind-mapping.ts:108

PRAGMA

• Const PRAGMA: 3

The pragma channel where all pragma instructions are stored which modify the compiler behaviour.

Since

0.11.0

Defined in

kipper/core/src/compiler/lexer-parser/lexer-channels.ts:25

ParseRuleKindMapping

• Const ParseRuleKindMapping: Object

A mapping object which maps the KipperParser rules to an AST syntax kind number and in extension with the ASTNodeFactory factories to an AST node class implementation.

This mapping is required, since even if the KipperParser implements numbers for each rule, labelled rules are ignored and the parent rule index is used instead. This means that the rule index is not unique and cannot be used for identifying the AST node class for a labelled rule. As such we need a new mapping for the AST generation.

Not every number contained here is mapped to a constructable AST node. Some may be only used for internal purposes inside the parser. For completion’s sake, all numbers are listed here regardless.

Since

0.10.0

Type declaration

Name	Type
`RULE_additiveExpression`	`58`
`RULE_argumentExpressionList`	`45`
`RULE_arrayPrimaryExpression`	`40`
`RULE_assignmentExpression`	`69`
`RULE_assignmentOperator`	`70`
`RULE_bitwiseAndExpression`	`63`
`RULE_bitwiseOrExpression`	`65`
`RULE_bitwiseShiftExpression`	`59`
`RULE_bitwiseShiftOperators`	`60`
`RULE_bitwiseXorExpression`	`64`
`RULE_blockItem`	`4`
`RULE_blockItemList`	`3`
`RULE_boolPrimaryExpression`	`31`
`RULE_bracketNotation`	`47`
`RULE_castOrConvertExpression`	`56`
`RULE_compilationUnit`	`0`
`RULE_compoundStatement`	`16`
`RULE_computedPrimaryExpression`	`44`
`RULE_conditionalExpression`	`68`
`RULE_declaration`	`5`
`RULE_declarator`	`9`
`RULE_directDeclarator`	`10`
`RULE_doWhileLoopIterationStatement`	`25`
`RULE_dotNotation`	`46`
`RULE_equalityExpression`	`62`
`RULE_expression`	`71`
`RULE_expressionStatement`	`17`
`RULE_externalItem`	`2`
`RULE_fStringDoubleQuoteAtom`	`38`
`RULE_fStringPrimaryExpression`	`36`
`RULE_fStringSingleQuoteAtom`	`37`
`RULE_forLoopIterationStatement`	`23`
`RULE_functionCallExpression`	`1002`
`RULE_functionDeclaration`	`6`
`RULE_genericTypeSpecifierExpression`	`74`
`RULE_identifier`	`33`
`RULE_identifierOrStringPrimaryExpression`	`34`
`RULE_identifierPrimaryExpression`	`32`
`RULE_identifierTypeSpecifierExpression`	`73`
`RULE_ifStatement`	`19`
`RULE_incrementOrDecrementOperator`	`54`
`RULE_incrementOrDecrementPostfixExpression`	`50`
`RULE_incrementOrDecrementUnaryExpression`	`52`
`RULE_initDeclarator`	`11`
`RULE_initializer`	`14`
`RULE_iterationStatement`	`22`
`RULE_jumpStatement`	`26`
`RULE_lambdaExpression`	`29`
`RULE_logicalAndExpression`	`66`
`RULE_logicalOrExpression`	`67`
`RULE_memberAccessExpression`	`1001`
`RULE_multiplicativeExpression`	`57`
`RULE_numberPrimaryExpression`	`39`
`RULE_objectPrimaryExpression`	`41`
`RULE_objectProperty`	`42`
`RULE_operatorModifiedUnaryExpression`	`53`
`RULE_parameterDeclaration`	`13`
`RULE_parameterList`	`12`
`RULE_postfixExpression`	`49`
`RULE_primaryExpression`	`28`
`RULE_relationalExpression`	`61`
`RULE_returnStatement`	`27`
`RULE_selectionStatement`	`18`
`RULE_sliceNotation`	`48`
`RULE_statement`	`15`
`RULE_storageTypeSpecifier`	`8`
`RULE_stringPrimaryExpression`	`35`
`RULE_switchLabeledStatement`	`21`
`RULE_switchStatement`	`20`
`RULE_tangledPrimaryExpression`	`30`
`RULE_translationUnit`	`1`
`RULE_typeSpecifierExpression`	`72`
`RULE_typeSpecifierIdentifier`	`76`
`RULE_typeofTypeSpecifierExpression`	`75`
`RULE_unaryExpression`	`51`
`RULE_unaryOperator`	`55`
`RULE_variableDeclaration`	`7`
`RULE_voidOrNullOrUndefinedPrimaryExpression`	`43`
`RULE_whileLoopIterationStatement`	`24`

Defined in

kipper/core/src/compiler/lexer-parser/parse-rule-kind-mapping.ts:21

defaultOptimisationOptions

• Const defaultOptimisationOptions: OptimisationOptions

The default configuration for OptimisationOptions.

Since

0.8.0

Defined in

kipper/core/src/compiler/optimiser/optimiser.ts:32

isBrowser

• Const isBrowser: boolean

If this variable is true, then this environment is assumed to be inside a browser and special browser support should be applied.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:22

kipperAdditiveOperators

• Const kipperAdditiveOperators: (KipperMinusOperator | KipperPlusOperator)[]

All available additive operations inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:551

kipperArithmeticAssignOperators

• Const kipperArithmeticAssignOperators: KipperArithmeticAssignOperator[]

All available arithmetic assignment operations inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:581

kipperArithmeticOperators

• Const kipperArithmeticOperators: KipperArithmeticOperator[]

All available arithmetic operations inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:566

kipperAssignOperators

• Const kipperAssignOperators: KipperAssignOperator[]

All available assignment operators inside Kipper, which can be used to assign a value to a variable/reference.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:605

kipperBitwiseAndOperator

• Const kipperBitwiseAndOperator: KipperBitwiseAndOperator = "&"

The bitwise-and operator, which can be used to combine two numbers bitwise.

Example

EXP & EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:308

kipperBitwiseNotOperator

• Const kipperBitwiseNotOperator: KipperBitwiseNotOperator = "~"

The bitwise-not operator, which can be used to negate a number bitwise.

Example

~EXP;

Since

0.11.0

Defined in

kipper/core/src/compiler/const.ts:368

kipperBitwiseOrOperator

• Const kipperBitwiseOrOperator: KipperBitwiseOrOperator = "|"

The bitwise-or operator, which can be used to combine two numbers bitwise.

Example

EXP | EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:324

kipperBitwiseShiftOperators

• Const kipperBitwiseShiftOperators: KipperBitwiseShiftOperator[]

All available bitwise operators inside Kipper, which can be used to combine two numbers bitwise.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:336

kipperBitwiseXorOperator

• Const kipperBitwiseXorOperator: KipperBitwiseXorOperator = "^"

The bitwise-xor operator, which can be used to combine two numbers bitwise.

Example

EXP ^ EXP;

Since

0.11.0

Defined in

kipper/core/src/compiler/const.ts:352

kipperBoolType

• Const kipperBoolType: KipperBoolType = "bool"

Boolean type in Kipper.

Since

0.5.0

Example

bool

Defined in

kipper/core/src/compiler/const.ts:144

kipperComparativeOperators

• Const kipperComparativeOperators: KipperComparativeOperator[]

All available comparative operators inside Kipper, which can be used to compare two expressions against each other.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:414

kipperCompilableTypes

• Const kipperCompilableTypes: KipperCompilableType[]

All compilable and valid base types inside Kipper.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:203

kipperEqualAssignOperator

• Const kipperEqualAssignOperator: KipperEqualAssignOperator = "="

Default assignment operator for assigning a value to a variable/reference.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:593

kipperEqualityOperators

• Const kipperEqualityOperators: KipperEqualityOperator[]

All available equality operators inside Kipper, which can be used to compare two expressions against each other.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:390

kipperFuncType

• Const kipperFuncType: KipperFuncType = "func"

Function type in Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:72

kipperIncrementOrDecrementOperators

• Const kipperIncrementOrDecrementOperators: KipperIncrementOrDecrementOperator[]

Increment and decrement operators, which can be used to modify the value of an expression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:495

kipperInternalBuiltInFunctions

• Const kipperInternalBuiltInFunctions: Object

Contains all the internal built-in functions, which are used by Kipper to provide internal functionality. These internal built-ins are commonly used to provide the functionality for keywords and other internal logic.

This contains every builtin that also must be implemented by every target in the KipperTargetBuiltInGenerator.

Since

0.8.0

Type declaration

Name	Type
`boolToNum`	{ `identifier`: `string` = "boolToNum"; `params`: { `identifier`: `string` = "value"; `valueType`: `"bool"` = "bool" }[] ; `returnType`: `"num"` = "num" }
`boolToNum.identifier`	`string`
`boolToNum.params`	{ `identifier`: `string` = "value"; `valueType`: `"bool"` = "bool" }[]
`boolToNum.returnType`	`"num"`
`boolToStr`	{ `identifier`: `string` = "boolToStr"; `params`: { `identifier`: `string` = "value"; `valueType`: `"bool"` = "bool" }[] ; `returnType`: `"str"` = "str" }
`boolToStr.identifier`	`string`
`boolToStr.params`	{ `identifier`: `string` = "value"; `valueType`: `"bool"` = "bool" }[]
`boolToStr.returnType`	`"str"`
`index`	{ `identifier`: `string` = "index"; `params`: ({ `identifier`: `string` = "arrayLike"; `valueType`: `"str"` = "str" } \| { `identifier`: `string` = "indexOrKey"; `valueType`: `"num"` = "num" })[] ; `returnType`: `"str"` = "str" }
`index.identifier`	`string`
`index.params`	({ `identifier`: `string` = "arrayLike"; `valueType`: `"str"` = "str" } \| { `identifier`: `string` = "indexOrKey"; `valueType`: `"num"` = "num" })[]
`index.returnType`	`"str"`
`nullToStr`	{ `identifier`: `string` = "nullToStr"; `params`: { `identifier`: `string` = "value"; `valueType`: `"null"` = "null" }[] ; `returnType`: `"str"` = "str" }
`nullToStr.identifier`	`string`
`nullToStr.params`	{ `identifier`: `string` = "value"; `valueType`: `"null"` = "null" }[]
`nullToStr.returnType`	`"str"`
`numToStr`	{ `identifier`: `string` = "numToStr"; `params`: { `identifier`: `string` = "value"; `valueType`: `"num"` = "num" }[] ; `returnType`: `"str"` = "str" }
`numToStr.identifier`	`string`
`numToStr.params`	{ `identifier`: `string` = "value"; `valueType`: `"num"` = "num" }[]
`numToStr.returnType`	`"str"`
`repeatString`	{ `identifier`: `string` = "repeatString"; `params`: ({ `identifier`: `string` = "toRepeat"; `valueType`: `"str"` = "str" } \| { `identifier`: `string` = "times"; `valueType`: `"num"` = "num" })[] ; `returnType`: `"str"` = "str" }
`repeatString.identifier`	`string`
`repeatString.params`	({ `identifier`: `string` = "toRepeat"; `valueType`: `"str"` = "str" } \| { `identifier`: `string` = "times"; `valueType`: `"num"` = "num" })[]
`repeatString.returnType`	`"str"`
`slice`	{ `identifier`: `string` = "slice"; `params`: ({ `identifier`: `string` = "objLike"; `valueType`: `"str"` = "str" } \| { `identifier`: `string` = "start"; `valueType`: (`"undefined"` \| `"num"`)[] })[] ; `returnType`: `"str"` = "str" }
`slice.identifier`	`string`
`slice.params`	({ `identifier`: `string` = "objLike"; `valueType`: `"str"` = "str" } \| { `identifier`: `string` = "start"; `valueType`: (`"undefined"` \| `"num"`)[] })[]
`slice.returnType`	`"str"`
`strToNum`	{ `identifier`: `string` = "strToNum"; `params`: { `identifier`: `string` = "value"; `valueType`: `"str"` = "str" }[] ; `returnType`: `"num"` = "num" }
`strToNum.identifier`	`string`
`strToNum.params`	{ `identifier`: `string` = "value"; `valueType`: `"str"` = "str" }[]
`strToNum.returnType`	`"num"`
`undefinedToStr`	{ `identifier`: `string` = "undefinedToStr"; `params`: { `identifier`: `string` = "value"; `valueType`: `"undefined"` = "undefined" }[] ; `returnType`: `"str"` = "str" }
`undefinedToStr.identifier`	`string`
`undefinedToStr.params`	{ `identifier`: `string` = "value"; `valueType`: `"undefined"` = "undefined" }[]
`undefinedToStr.returnType`	`"str"`
`voidToStr`	{ `identifier`: `string` = "voidToStr"; `params`: { `identifier`: `string` = "value"; `valueType`: `"void"` = "void" }[] ; `returnType`: `"str"` = "str" }
`voidToStr.identifier`	`string`
`voidToStr.params`	{ `identifier`: `string` = "value"; `valueType`: `"void"` = "void" }[]
`voidToStr.returnType`	`"str"`

Defined in

kipper/core/src/compiler/runtime-built-ins.ts:184

kipperListType

• Const kipperListType: KipperListType<any> = "list"

List type in Kipper. ValueType represents the type of the list content and only serves as a type checking generic type, it will not change the type itself.

Since

0.5.0

Example

list<T>

Defined in

kipper/core/src/compiler/const.ts:163

kipperLogicalAndOperator

• Const kipperLogicalAndOperator: KipperLogicalAndOperator = "&&"

The logical-and operator, which can be used to combine multiple conditions and return true if all conditions are true.

Example

EXP && EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:262

kipperLogicalOperator

• Const kipperLogicalOperator: KipperLogicalOperator[]

All available logical operators inside Kipper, which can be used to compare two expressions against each other.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:292

kipperLogicalOrOperator

• Const kipperLogicalOrOperator: KipperLogicalOrOperator = "||"

The logical-or operator, which can be used to combine multiple conditions and return true if at least one condition is true.

Example

EXP || EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:280

kipperMetaType

• Const kipperMetaType: KipperMetaType = "type"

Represents the meta type in Kipper, which itself is used represents a type e.g. this is the type of a type.

Since

0.8.0

Defined in

kipper/core/src/compiler/const.ts:36

kipperMinusOperator

• Const kipperMinusOperator: KipperMinusOperator = "-"

The minus operator.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:441

kipperMultiplicativeOperators

• Const kipperMultiplicativeOperators: KipperMultiplicativeOperator[]

All available multiplicative operators inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:545

kipperNegateOperator

• Const kipperNegateOperator: KipperNegateOperator = "!"

Negate operator, which can be used to negate a boolean expression. It evaluates to the opposite boolean representation of the original expression.

Example

!true; // false
!false; // true
!1; // false
!0; // true

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:483

kipperNullType

• Const kipperNullType: KipperNullType = "null"

Null type in Kipper.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:48

kipperNumType

• Const kipperNumType: KipperNumType = "num"

Numeric type in Kipper.

Since

0.5.0

Example

num

Defined in

kipper/core/src/compiler/const.ts:104

kipperPlusOperator

• Const kipperPlusOperator: KipperPlusOperator = "+"

The plus operator.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:429

kipperPrimitiveTypes

• Const kipperPrimitiveTypes: KipperPrimitiveType[]

All primitive types inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:181

kipperRelationalOperators

• Const kipperRelationalOperators: KipperRelationalOperator[]

All available relational operators inside Kipper, which can be used to compare two expressions against each other.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:402

kipperRuntimeBuiltInFunctions

• Const kipperRuntimeBuiltInFunctions: Record<string, BuiltInFunction>

Contains all the built-in functions in Kipper that are available per default in every program.

This contains every builtin that also must be implemented by every target in the KipperTargetBuiltInGenerator.

Since

0.7.0

Defined in

kipper/core/src/compiler/runtime-built-ins.ts:154

kipperRuntimeBuiltInVariables

• Const kipperRuntimeBuiltInVariables: Record<string, BuiltInVariable>

Contains all the built-in variables in Kipper that are available per default in every program.

Since

0.10.0

Defined in

kipper/core/src/compiler/runtime-built-ins.ts:307

kipperSignOperators

• Const kipperSignOperators: KipperSignOperator[]

All available sign operators inside Kipper, which can be used to modify the value of a numeric expression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:459

kipperStorageTypes

• Const kipperStorageTypes: KipperStorageType[]

All available storage types inside Kipper, which define how a variable is stored/can be accessed.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:246

kipperStrType

• Const kipperStrType: KipperStrType = "str"

String type in Kipper.

Since

0.5.0

Example

str

Defined in

kipper/core/src/compiler/const.ts:120

kipperSupportedConversions

• Const kipperSupportedConversions: [KipperType, KipperType][]

List of all supported variable type conversions that can be performed in a Kipper program.

For each translation, there will have to be a corresponding generator function, which generates for each conversion the translator function in the specific target.

Since

0.8.0

Defined in

kipper/core/src/compiler/const.ts:227

kipperUnaryModifierOperators

• Const kipperUnaryModifierOperators: KipperUnaryModifierOperator[]

Modifier Unary operators, which are used to modify the value of an expression.

This type specifically exists for the OperatorModifiedUnaryExpression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:511

kipperUnaryOperators

• Const kipperUnaryOperators: KipperUnaryOperator[]

All available unary operators in Kipper, which can be used to modify the value of an expression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:530

kipperUndefinedType

• Const kipperUndefinedType: KipperUndefinedType = "undefined"

Undefined type in Kipper.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:60

kipperVoidType

• Const kipperVoidType: KipperVoidType = "void"

Void type in Kipper.

Since

0.5.0

Example

void

Defined in

kipper/core/src/compiler/const.ts:88

Functions

handleSemanticError

▸ handleSemanticError(node, error): void

Handles the specified error that occurred during the semantic analysis of a node in a standardised way.

Since

0.10.0

Parameters

Name	Type	Description
`node`	`RootASTNode` \| `AnalysableASTNode`<`SemanticData`, `TypeData`>	The node that is currently being processed.
`error`	`KipperError` \| `Error`	The error to handle.

Returns

void

Defined in

kipper/core/src/compiler/analysis/handle-error.ts:25

shouldRecoverFromError

▸ shouldRecoverFromError(node, error): boolean

Checks whether the given error should be recovered from or not.

Since

0.10.0

Parameters

Name	Type	Description
`node`	`RootASTNode` \| `AnalysableASTNode`<`SemanticData`, `TypeData`>	The node that is currently being processed.
`error`	`KipperError` \| `Error`	The error to check.

Returns

boolean

Defined in

kipper/core/src/compiler/analysis/handle-error.ts:14

Namespace: compiler

Table of contents

Classes

Interfaces

Type Aliases

Variables

Functions

Type Aliases

ASTArithmeticExpressionKind

Defined in

ASTBitwiseExpressionKind

Defined in

ASTComparativeExpressionKind

Defined in

ASTDeclarationKind

Defined in

ASTDeclarationRuleName

Defined in

ASTExpressionKind

Defined in

ASTExpressionRuleName

Defined in

ASTKind

Defined in

ASTLogicalExpressionKind

Defined in

ASTNodeParserContext

Defined in

ASTPostfixExpressionKind

Defined in

ASTPrimaryExpressionKind

Defined in

ASTStatementKind

Defined in

ASTStatementRuleName

Defined in

ASTTypeSpecifierExpressionKind

Defined in

ASTUnaryExpressionKind

Defined in

AnalysableNodeChild

Defined in

AnalysableNodeParent

Defined in

CompilableNodeChild

Defined in

CompilableNodeParent

Defined in

ConstructableASTDeclaration

Defined in

ConstructableASTDeclarationClass

Defined in

ConstructableASTExpression

Defined in

ConstructableASTExpressionClass

Defined in

ConstructableASTKind

Defined in

ConstructableASTNode

Defined in

ConstructableASTNodeClass

Defined in

ConstructableASTRuleName

Defined in

ConstructableASTStatement

Defined in

ConstructableASTStatementClass

Defined in

JmpStatementType

Defined in

KipperAdditiveOperator

Defined in

KipperArg

Defined in

KipperArithmeticAssignOperator

Defined in

KipperArithmeticOperator

Defined in

KipperAssignOperator

Defined in