@fincity/kirun-js 1.0.0

package/src/engine/runtime/expression/ExpressionEvaluator.ts

@@ -0,0 +1,305 @@
+import { ExecutionException } from '../../exception/ExecutionException';
+import { LinkedList } from '../../util/LinkedList';
+import { StringBuilder } from '../../util/string/StringBuilder';
+import { StringFormatter } from '../../util/string/StringFormatter';
+import { FunctionExecutionParameters } from '../FunctionExecutionParameters';
+import { ExpressionEvaluationException } from './exception/ExpressionEvaluationException';
+import { Expression } from './Expression';
+import { ExpressionToken } from './ExpressionToken';
+import { ExpressionTokenValue } from './ExpressionTokenValue';
+import { Operation } from './Operation';
+import { ArithmeticAdditionOperator } from './operators/binary/ArithmeticAdditionOperator';
+import { ArithmeticDivisionOperator } from './operators/binary/ArithmeticDivisionOperator';
+import { ArithmeticIntegerDivisionOperator } from './operators/binary/ArithmeticInetgerDivisionOperator';
+import { ArithmeticModulusOperator } from './operators/binary/ArithmeticModulusOperator';
+import { ArithmeticMultiplicationOperator } from './operators/binary/ArithmeticMultiplicationOperator';
+import { ArithmeticSubtractionOperator } from './operators/binary/ArithmeticSubtractionOperator';
+import { ArrayOperator } from './operators/binary/ArrayOperator';
+import { BinaryOperator } from './operators/binary/BinaryOperator';
+import { BitwiseAndOperator } from './operators/binary/BitwiseAndOperator';
+import { BitwiseLeftShiftOperator } from './operators/binary/BitwiseLeftShiftOperator';
+import { BitwiseOrOperator } from './operators/binary/BitwiseOrOperator';
+import { BitwiseRightShiftOperator } from './operators/binary/BitwiseRightShiftOperator';
+import { BitwiseUnsignedRightShiftOperator } from './operators/binary/BitwiseUnsignedRightShiftOperator';
+import { BitwiseXorOperator } from './operators/binary/BitwiseXorOperator';
+import { LogicalAndOperator } from './operators/binary/LogicalAndOperator';
+import { LogicalEqualOperator } from './operators/binary/LogicalEqualOperator';
+import { LogicalGreaterThanEqualOperator } from './operators/binary/LogicalGreaterThanEqualOperator';
+import { LogicalGreaterThanOperator } from './operators/binary/LogicalGreaterThanOperator';
+import { LogicalLessThanEqualOperator } from './operators/binary/LogicalLessThanEqualOperator';
+import { LogicalLessThanOperator } from './operators/binary/LogicalLessThanOperator';
+import { LogicalNotEqualOperator } from './operators/binary/LogicalNotEqualOperator';
+import { LogicalOrOperator } from './operators/binary/LogicalOrOperator';
+import { ObjectOperator } from './operators/binary/ObjectOperator';
+import { ArithmeticUnaryMinusOperator } from './operators/unary/ArithmeticUnaryMinusOperator';
+import { ArithmeticUnaryPlusOperator } from './operators/unary/ArithmeticUnaryPlusOperator';
+import { BitwiseComplementOperator } from './operators/unary/BitwiseComplementOperator';
+import { LogicalNotOperator } from './operators/unary/LogicalNotOperator';
+import { UnaryOperator } from './operators/unary/UnaryOperator';
+import { LiteralTokenValueExtractor } from './tokenextractor/LiteralTokenValueExtractor';
+import { TokenValueExtractor } from './tokenextractor/TokenValueExtractor';
+
+export class ExpressionEvaluator {
+    private static readonly UNARY_OPERATORS_MAP: Map<Operation, UnaryOperator> = new Map([
+        [Operation.UNARY_BITWISE_COMPLEMENT, new BitwiseComplementOperator()],
+        [Operation.UNARY_LOGICAL_NOT, new LogicalNotOperator()],
+        [Operation.UNARY_MINUS, new ArithmeticUnaryMinusOperator()],
+        [Operation.UNARY_PLUS, new ArithmeticUnaryPlusOperator()],
+    ]);
+
+    private static readonly BINARY_OPERATORS_MAP: Map<Operation, BinaryOperator> = new Map([
+        [Operation.ADDITION, new ArithmeticAdditionOperator()],
+        [Operation.DIVISION, new ArithmeticDivisionOperator()],
+        [Operation.INTEGER_DIVISION, new ArithmeticIntegerDivisionOperator()],
+        [Operation.MOD, new ArithmeticModulusOperator()],
+        [Operation.MULTIPLICATION, new ArithmeticMultiplicationOperator()],
+        [Operation.SUBTRACTION, new ArithmeticSubtractionOperator()],
+
+        [Operation.BITWISE_AND, new BitwiseAndOperator()],
+        [Operation.BITWISE_LEFT_SHIFT, new BitwiseLeftShiftOperator()],
+        [Operation.BITWISE_OR, new BitwiseOrOperator()],
+        [Operation.BITWISE_RIGHT_SHIFT, new BitwiseRightShiftOperator()],
+        [Operation.BITWISE_UNSIGNED_RIGHT_SHIFT, new BitwiseUnsignedRightShiftOperator()],
+        [Operation.BITWISE_XOR, new BitwiseXorOperator()],
+
+        [Operation.AND, new LogicalAndOperator()],
+        [Operation.EQUAL, new LogicalEqualOperator()],
+        [Operation.GREATER_THAN, new LogicalGreaterThanOperator()],
+        [Operation.GREATER_THAN_EQUAL, new LogicalGreaterThanEqualOperator()],
+        [Operation.LESS_THAN, new LogicalLessThanOperator()],
+        [Operation.LESS_THAN_EQUAL, new LogicalLessThanEqualOperator()],
+        [Operation.OR, new LogicalOrOperator()],
+        [Operation.NOT_EQUAL, new LogicalNotEqualOperator()],
+
+        [Operation.ARRAY_OPERATOR, new ArrayOperator()],
+        [Operation.OBJECT_OPERATOR, new ObjectOperator()],
+    ]);
+
+    private static readonly UNARY_OPERATORS_MAP_KEY_SET: Set<Operation> = new Set(
+        ExpressionEvaluator.UNARY_OPERATORS_MAP.keys(),
+    );
+
+    private expression: string;
+    private exp?: Expression;
+
+    public constructor(exp: Expression | string) {
+        if (exp instanceof Expression) {
+            this.exp = exp as Expression;
+            this.expression = this.exp.getExpression();
+        } else {
+            this.expression = exp;
+        }
+    }
+
+    public evaluate(valuesMap: Map<string, TokenValueExtractor>): any {
+        if (!this.exp) this.exp = new Expression(this.expression);
+        return this.evaluateExpression(this.exp, valuesMap);
+    }
+
+    public getExpression(): Expression {
+        if (!this.exp) this.exp = new Expression(this.expression);
+
+        return this.exp;
+    }
+
+    public getExpressionString(): string {
+        return this.expression;
+    }
+
+    private evaluateExpression(exp: Expression, valuesMap: Map<string, TokenValueExtractor>): any {
+        let ops: LinkedList<Operation> = exp.getOperations();
+        let tokens: LinkedList<ExpressionToken> = exp.getTokens();
+
+        while (!ops.isEmpty()) {
+            let operator: Operation = ops.pop();
+            let token: ExpressionToken = tokens.pop();
+
+            if (ExpressionEvaluator.UNARY_OPERATORS_MAP_KEY_SET.has(operator)) {
+                tokens.push(
+                    this.applyUnaryOperation(operator, this.getValueFromToken(valuesMap, token)),
+                );
+            } else if (
+                operator == Operation.OBJECT_OPERATOR ||
+                operator == Operation.ARRAY_OPERATOR
+            ) {
+                this.processObjectOrArrayOperator(valuesMap, ops, tokens, operator, token);
+            } else {
+                const token2: ExpressionToken = tokens.pop();
+                var v1 = this.getValueFromToken(valuesMap, token2);
+                var v2 = this.getValueFromToken(valuesMap, token);
+                tokens.push(this.applyBinaryOperation(operator, v1, v2));
+            }
+        }
+
+        if (tokens.isEmpty())
+            throw new ExecutionException(
+                StringFormatter.format('Expression : $ evaluated to null', exp),
+            );
+
+        if (tokens.size() != 1)
+            throw new ExecutionException(
+                StringFormatter.format('Expression : $ evaluated multiple values $', exp, tokens),
+            );
+
+        const token: ExpressionToken = tokens.get(0);
+        if (token instanceof ExpressionTokenValue)
+            return (token as ExpressionTokenValue).getElement();
+        else if (!(token instanceof Expression)) return this.getValueFromToken(valuesMap, token);
+
+        throw new ExecutionException(
+            StringFormatter.format('Expression : $ evaluated to $', exp, tokens.get(0)),
+        );
+    }
+
+    private processObjectOrArrayOperator(
+        valuesMap: Map<string, TokenValueExtractor>,
+        ops: LinkedList<Operation>,
+        tokens: LinkedList<ExpressionToken>,
+        operator?: Operation,
+        token?: ExpressionToken,
+    ): void {
+        const objTokens: LinkedList<ExpressionToken> = new LinkedList();
+        const objOperations: LinkedList<Operation> = new LinkedList();
+
+        if (!operator || !token)
+            return;
+
+        do {
+            objOperations.push(operator);
+            if (token instanceof Expression)
+                objTokens.push(
+                    new ExpressionTokenValue(
+                        token.toString(),
+                        this.evaluateExpression(token as Expression, valuesMap),
+                    ),
+                );
+            else if (token)
+                objTokens.push(token);
+            token = tokens.isEmpty() ? undefined : tokens.pop();
+            operator = ops.isEmpty() ? undefined : ops.pop();
+        } while (operator == Operation.OBJECT_OPERATOR || operator == Operation.ARRAY_OPERATOR);
+
+        if (token) {
+            if (token instanceof Expression)
+                objTokens.push(
+                    new ExpressionTokenValue(
+                        token.toString(),
+                        this.evaluateExpression(token as Expression, valuesMap),
+                    ),
+                );
+            else objTokens.push(token);
+        }
+
+        if (operator) ops.push(operator);
+
+        let objToken: ExpressionToken = objTokens.pop();
+        let sb: StringBuilder = new StringBuilder(
+            objToken instanceof ExpressionTokenValue
+                ? (objToken as ExpressionTokenValue).getTokenValue()
+                : objToken.toString(),
+        );
+
+        while (!objTokens.isEmpty()) {
+            objToken = objTokens.pop();
+            operator = objOperations.pop();
+            sb.append(operator.getOperator()).append(
+                objToken instanceof ExpressionTokenValue
+                    ? (objToken as ExpressionTokenValue).getTokenValue()
+                    : objToken.toString(),
+            );
+            if (operator == Operation.ARRAY_OPERATOR) sb.append(']');
+        }
+
+        let str: string = sb.toString();
+        let key: string = str.substring(0, str.indexOf('.') + 1);
+        if (key.length > 2 && valuesMap.has(key))
+            tokens.push(new ExpressionTokenValue(str, this.getValue(str, valuesMap)));
+        else {
+            let v: any = undefined;
+            try {
+                v = LiteralTokenValueExtractor.INSTANCE.getValue(str);
+            } catch (err) {
+                v = str;
+            }
+            tokens.push(new ExpressionTokenValue(str, v));
+        }
+    }
+
+    private applyBinaryOperation(operator: Operation, v1: any, v2: any): ExpressionToken {
+        let typv1: string = typeof v1;
+        let typv2: string = typeof v2;
+
+        if (typv1 === 'object' || typv2 === 'object' || Array.isArray(v1) || Array.isArray(v2))
+            throw new ExpressionEvaluationException(
+                this.expression,
+                StringFormatter.format(
+                    'Cannot evaluate expression $ $ $',
+                    v1,
+                    operator.getOperator(),
+                    v2,
+                ),
+            );
+
+        let op: BinaryOperator | undefined = ExpressionEvaluator.BINARY_OPERATORS_MAP.get(operator);
+
+        if (!op)
+            throw new ExpressionEvaluationException(
+                this.expression,
+                StringFormatter.format(
+                    'No operator found to evaluate $ $ $',
+                    v1,
+                    operator.getOperator(),
+                    v2,
+                ),
+            );
+
+        return new ExpressionTokenValue(operator.toString(), op.apply(v1, v2));
+    }
+
+    private applyUnaryOperation(operator: Operation, value: any): ExpressionToken {
+        let typv: string = typeof value;
+
+        if (typv === 'object' || Array.isArray(value))
+            throw new ExpressionEvaluationException(
+                this.expression,
+                StringFormatter.format(
+                    'The operator $ cannot be applied to $',
+                    operator.getOperator(),
+                    value,
+                ),
+            );
+
+        let op: UnaryOperator | undefined = ExpressionEvaluator.UNARY_OPERATORS_MAP.get(operator);
+
+        if (!op)
+            throw new ExpressionEvaluationException(
+                this.expression,
+                StringFormatter.format(
+                    'No Unary operator $ is found to apply on $',
+                    operator.getOperator(),
+                    value,
+                ),
+            );
+
+        return new ExpressionTokenValue(operator.toString(), op.apply(value));
+    }
+
+    private getValueFromToken(
+        valuesMap: Map<string, TokenValueExtractor>,
+        token: ExpressionToken,
+    ): any {
+        if (token instanceof Expression) {
+            return this.evaluateExpression(token as Expression, valuesMap);
+        } else if (token instanceof ExpressionTokenValue) {
+            return (token as ExpressionTokenValue).getElement();
+        }
+        return this.getValue(token.getExpression(), valuesMap);
+    }
+
+    private getValue(path: string, valuesMap: Map<string, TokenValueExtractor>): any {
+        if (path.length <= 5) return LiteralTokenValueExtractor.INSTANCE.getValue(path);
+
+        const pathPrefix: string = path.substring(0, path.indexOf('.') + 1);
+        return (valuesMap.get(pathPrefix) ?? LiteralTokenValueExtractor.INSTANCE).getValue(path);
+    }
+}

package/src/engine/runtime/expression/ExpressionToken.ts

@@ -0,0 +1,15 @@
+export class ExpressionToken {
+    expression: string;
+
+    public constructor(expression: string) {
+        this.expression = expression;
+    }
+
+    public getExpression(): string {
+        return this.expression;
+    }
+
+    public toString(): string {
+        return this.expression;
+    }
+}

package/src/engine/runtime/expression/ExpressionTokenValue.ts

@@ -0,0 +1,23 @@
+import { StringFormatter } from '../../util/string/StringFormatter';
+import { ExpressionToken } from './ExpressionToken';
+
+export class ExpressionTokenValue extends ExpressionToken {
+    private element: any;
+
+    public constructor(expression: string, element: any) {
+        super(expression);
+        this.element = element;
+    }
+
+    public getTokenValue(): any {
+        return this.element;
+    }
+
+    public getElement(): any {
+        return this.element;
+    }
+
+    public toString(): string {
+        return StringFormatter.format('$: $', this.expression, this.element);
+    }
+}

package/src/engine/runtime/expression/Operation.ts

@@ -0,0 +1,190 @@
+export class Operation {
+    public static readonly MULTIPLICATION: Operation = new Operation('*');
+    public static readonly DIVISION: Operation = new Operation('/');
+    public static readonly INTEGER_DIVISION: Operation = new Operation('//');
+    public static readonly MOD: Operation = new Operation('%');
+    public static readonly ADDITION: Operation = new Operation('+');
+    public static readonly SUBTRACTION: Operation = new Operation('-');
+
+    public static readonly NOT: Operation = new Operation('not');
+    public static readonly AND: Operation = new Operation('and');
+    public static readonly OR: Operation = new Operation('or');
+    public static readonly LESS_THAN: Operation = new Operation('<');
+    public static readonly LESS_THAN_EQUAL: Operation = new Operation('<=');
+    public static readonly GREATER_THAN: Operation = new Operation('>');
+    public static readonly GREATER_THAN_EQUAL: Operation = new Operation('>=');
+    public static readonly EQUAL: Operation = new Operation('=');
+    public static readonly NOT_EQUAL: Operation = new Operation('!=');
+
+    public static readonly BITWISE_AND: Operation = new Operation('&');
+    public static readonly BITWISE_OR: Operation = new Operation('|');
+    public static readonly BITWISE_XOR: Operation = new Operation('^');
+    public static readonly BITWISE_COMPLEMENT: Operation = new Operation('~');
+    public static readonly BITWISE_LEFT_SHIFT: Operation = new Operation('<<');
+    public static readonly BITWISE_RIGHT_SHIFT: Operation = new Operation('>>');
+    public static readonly BITWISE_UNSIGNED_RIGHT_SHIFT: Operation = new Operation('>>>');
+
+    public static readonly UNARY_PLUS: Operation = new Operation('UN: +', '+');
+    public static readonly UNARY_MINUS: Operation = new Operation('UN: -', '-');
+    public static readonly UNARY_LOGICAL_NOT: Operation = new Operation('UN: not', 'not');
+    public static readonly UNARY_BITWISE_COMPLEMENT: Operation = new Operation('UN: ~', '~');
+
+    public static readonly ARRAY_OPERATOR: Operation = new Operation('[');
+    public static readonly OBJECT_OPERATOR: Operation = new Operation('.');
+
+    private static readonly VALUE_OF: Map<string, Operation> = new Map([
+        ['MULTIPLICATION', Operation.MULTIPLICATION],
+        ['DIVISION', Operation.DIVISION],
+        ['INTEGER_DIVISON', Operation.INTEGER_DIVISION],
+        ['MOD', Operation.MOD],
+        ['ADDITION', Operation.ADDITION],
+        ['SUBTRACTION', Operation.SUBTRACTION],
+        ['NOT', Operation.NOT],
+        ['AND', Operation.AND],
+        ['OR', Operation.OR],
+        ['LESS_THAN', Operation.LESS_THAN],
+        ['LESS_THAN_EQUAL', Operation.LESS_THAN_EQUAL],
+        ['GREATER_THAN', Operation.GREATER_THAN],
+        ['GREATER_THAN_EQUAL', Operation.GREATER_THAN_EQUAL],
+        ['EQUAL', Operation.EQUAL],
+        ['NOT_EQUAL', Operation.NOT_EQUAL],
+        ['BITWISE_AND', Operation.BITWISE_AND],
+        ['BITWISE_OR', Operation.BITWISE_OR],
+        ['BITWISE_XOR', Operation.BITWISE_XOR],
+        ['BITWISE_COMPLEMENT', Operation.BITWISE_COMPLEMENT],
+        ['BITWISE_LEFT_SHIFT', Operation.BITWISE_LEFT_SHIFT],
+        ['BITWISE_RIGHT_SHIFT', Operation.BITWISE_RIGHT_SHIFT],
+        ['BITWISE_UNSIGNED_RIGHT_SHIFT', Operation.BITWISE_UNSIGNED_RIGHT_SHIFT],
+        ['UNARY_PLUS', Operation.UNARY_PLUS],
+        ['UNARY_MINUS', Operation.UNARY_MINUS],
+        ['UNARY_LOGICAL_NOT', Operation.UNARY_LOGICAL_NOT],
+        ['UNARY_BITWISE_COMPLEMENT', Operation.UNARY_BITWISE_COMPLEMENT],
+        ['ARRAY_OPERATOR', Operation.ARRAY_OPERATOR],
+        ['OBJECT_OPERATOR', Operation.OBJECT_OPERATOR],
+    ]);
+
+    public static readonly UNARY_OPERATORS: Set<Operation> = new Set([
+        Operation.ADDITION,
+        Operation.SUBTRACTION,
+        Operation.NOT,
+        Operation.BITWISE_COMPLEMENT,
+        Operation.UNARY_PLUS,
+        Operation.UNARY_MINUS,
+        Operation.UNARY_LOGICAL_NOT,
+        Operation.UNARY_BITWISE_COMPLEMENT,
+    ]);
+
+    public static readonly ARITHMETIC_OPERATORS: Set<Operation> = new Set([
+        Operation.MULTIPLICATION,
+        Operation.DIVISION,
+        Operation.INTEGER_DIVISION,
+        Operation.MOD,
+        Operation.ADDITION,
+        Operation.SUBTRACTION,
+    ]);
+
+    public static readonly LOGICAL_OPERATORS: Set<Operation> = new Set([
+        Operation.NOT,
+        Operation.AND,
+        Operation.OR,
+        Operation.LESS_THAN,
+        Operation.LESS_THAN_EQUAL,
+        Operation.GREATER_THAN,
+        Operation.GREATER_THAN_EQUAL,
+        Operation.EQUAL,
+        Operation.NOT_EQUAL,
+    ]);
+
+    public static readonly BITWISE_OPERATORS: Set<Operation> = new Set([
+        Operation.BITWISE_AND,
+        Operation.BITWISE_COMPLEMENT,
+        Operation.BITWISE_LEFT_SHIFT,
+        Operation.BITWISE_OR,
+        Operation.BITWISE_RIGHT_SHIFT,
+        Operation.BITWISE_UNSIGNED_RIGHT_SHIFT,
+        Operation.BITWISE_XOR,
+    ]);
+
+    public static readonly OPERATOR_PRIORITY: Map<Operation, number> = new Map([
+        [Operation.UNARY_PLUS, 1],
+        [Operation.UNARY_MINUS, 1],
+        [Operation.UNARY_LOGICAL_NOT, 1],
+        [Operation.UNARY_BITWISE_COMPLEMENT, 1],
+        [Operation.ARRAY_OPERATOR, 1],
+        [Operation.OBJECT_OPERATOR, 1],
+        [Operation.MULTIPLICATION, 2],
+        [Operation.DIVISION, 2],
+        [Operation.INTEGER_DIVISION, 2],
+        [Operation.MOD, 2],
+        [Operation.ADDITION, 3],
+        [Operation.SUBTRACTION, 3],
+        [Operation.BITWISE_LEFT_SHIFT, 4],
+        [Operation.BITWISE_RIGHT_SHIFT, 4],
+        [Operation.BITWISE_UNSIGNED_RIGHT_SHIFT, 4],
+        [Operation.LESS_THAN, 5],
+        [Operation.LESS_THAN_EQUAL, 5],
+        [Operation.GREATER_THAN, 5],
+        [Operation.GREATER_THAN_EQUAL, 5],
+        [Operation.EQUAL, 6],
+        [Operation.NOT_EQUAL, 6],
+        [Operation.BITWISE_AND, 7],
+        [Operation.BITWISE_XOR, 8],
+        [Operation.BITWISE_OR, 9],
+        [Operation.AND, 10],
+        [Operation.OR, 11],
+    ]);
+
+    public static readonly OPERATORS: Set<string> = new Set(
+        [
+            ...Array.from(Operation.ARITHMETIC_OPERATORS),
+            ...Array.from(Operation.LOGICAL_OPERATORS),
+            ...Array.from(Operation.BITWISE_OPERATORS),
+            Operation.ARRAY_OPERATOR,
+            Operation.OBJECT_OPERATOR,
+        ].map((e) => e.getOperator()),
+    );
+
+    public static readonly OPERATION_VALUE_OF: Map<string, Operation> = new Map(
+        Array.from(Operation.VALUE_OF.entries()).map(([_, o]) => [o.getOperator(), o]),
+    );
+
+    public static readonly UNARY_MAP: Map<Operation, Operation> = new Map([
+        [Operation.ADDITION, Operation.UNARY_PLUS],
+        [Operation.SUBTRACTION, Operation.UNARY_MINUS],
+        [Operation.NOT, Operation.UNARY_LOGICAL_NOT],
+        [Operation.BITWISE_COMPLEMENT, Operation.UNARY_BITWISE_COMPLEMENT],
+        [Operation.UNARY_PLUS, Operation.UNARY_PLUS],
+        [Operation.UNARY_MINUS, Operation.UNARY_MINUS],
+        [Operation.UNARY_LOGICAL_NOT, Operation.UNARY_LOGICAL_NOT],
+        [Operation.UNARY_BITWISE_COMPLEMENT, Operation.UNARY_BITWISE_COMPLEMENT],
+    ]);
+
+    public static readonly BIGGEST_OPERATOR_SIZE: number = Array.from(Operation.VALUE_OF.values())
+        .map((e) => e.getOperator())
+        .filter((e) => !e.startsWith('UN: '))
+        .map((e) => e.length)
+        .reduce((a, c) => (a > c ? a : c), 0);
+
+    private operator: string;
+    private operatorName: string;
+    public constructor(operator: string, operatorName?: string) {
+        this.operator = operator;
+        this.operatorName = operatorName ?? operator;
+    }
+
+    public getOperator(): string {
+        return this.operator;
+    }
+
+    public getOperatorName(): string {
+        return this.operatorName;
+    }
+
+    public valueOf(str: string): Operation | undefined {
+        return Operation.VALUE_OF.get(str);
+    }
+
+    public toString(): string {
+        return this.operator;
+    }
+}

package/src/engine/runtime/expression/exception/ExpressionEvaluationException.ts

@@ -0,0 +1,15 @@
+import { StringFormatter } from '../../../util/string/StringFormatter';
+
+export class ExpressionEvaluationException extends Error {
+    private cause?: Error;
+
+    constructor(expression: string, message: string, err?: Error) {
+        super(StringFormatter.format('$ : $', expression, message));
+
+        this.cause = err;
+    }
+
+    public getCause(): Error | undefined {
+        return this.cause;
+    }
+}

package/src/engine/runtime/expression/operators/binary/ArithmeticAdditionOperator.ts

@@ -0,0 +1,9 @@
+import { Operation } from '../../Operation';
+import { BinaryOperator } from './BinaryOperator';
+
+export class ArithmeticAdditionOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        this.nullCheck(t, u, Operation.ADDITION);
+        return t + u;
+    }
+}

package/src/engine/runtime/expression/operators/binary/ArithmeticDivisionOperator.ts

@@ -0,0 +1,9 @@
+import { Operation } from '../../Operation';
+import { BinaryOperator } from './BinaryOperator';
+
+export class ArithmeticDivisionOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        this.nullCheck(t, u, Operation.DIVISION);
+        return t / u;
+    }
+}

package/src/engine/runtime/expression/operators/binary/ArithmeticInetgerDivisionOperator.ts

@@ -0,0 +1,9 @@
+import { Operation } from '../../Operation';
+import { BinaryOperator } from './BinaryOperator';
+
+export class ArithmeticIntegerDivisionOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        this.nullCheck(t, u, Operation.DIVISION);
+        return Math.floor(t / u);
+    }
+}

package/src/engine/runtime/expression/operators/binary/ArithmeticModulusOperator.ts

@@ -0,0 +1,9 @@
+import { Operation } from '../../Operation';
+import { BinaryOperator } from './BinaryOperator';
+
+export class ArithmeticModulusOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        this.nullCheck(t, u, Operation.MOD);
+        return t % u;
+    }
+}

package/src/engine/runtime/expression/operators/binary/ArithmeticMultiplicationOperator.ts

@@ -0,0 +1,9 @@
+import { Operation } from '../../Operation';
+import { BinaryOperator } from './BinaryOperator';
+
+export class ArithmeticMultiplicationOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        this.nullCheck(t, u, Operation.MULTIPLICATION);
+        return t * u;
+    }
+}

package/src/engine/runtime/expression/operators/binary/ArithmeticSubtractionOperator.ts

@@ -0,0 +1,9 @@
+import { Operation } from '../../Operation';
+import { BinaryOperator } from './BinaryOperator';
+
+export class ArithmeticSubtractionOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        this.nullCheck(t, u, Operation.SUBTRACTION);
+        return t - u;
+    }
+}

package/src/engine/runtime/expression/operators/binary/ArrayOperator.ts

@@ -0,0 +1,31 @@
+import { ExecutionException } from '../../../../exception/ExecutionException';
+import { StringFormatter } from '../../../../util/string/StringFormatter';
+import { BinaryOperator } from './BinaryOperator';
+
+export class ArrayOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        if (!t) {
+            throw new ExecutionException('Cannot apply array operator on a null value');
+        }
+
+        if (!u) {
+            throw new ExecutionException('Cannot retrive null index value');
+        }
+
+        if (!Array.isArray(t) && typeof t != 'string') {
+            throw new ExecutionException(
+                StringFormatter.format('Cannot retrieve value from a primitive value $', t),
+            );
+        }
+        if (u >= t.length)
+            throw new ExecutionException(
+                StringFormatter.format(
+                    'Cannot retrieve index $ from the array of length $',
+                    u,
+                    t.length,
+                ),
+            );
+
+        return t[u];
+    }
+}

package/src/engine/runtime/expression/operators/binary/BinaryOperator.ts

@@ -0,0 +1,15 @@
+import { ExecutionException } from '../../../../exception/ExecutionException';
+import { isNullValue } from '../../../../util/NullCheck';
+import { StringFormatter } from '../../../../util/string/StringFormatter';
+import { Operation } from '../../Operation';
+
+export abstract class BinaryOperator {
+    public abstract apply(t: any, u: any): any;
+
+    public nullCheck(e1: any, e2: any, op: Operation): void {
+        if (isNullValue(e1) || isNullValue(e2))
+            throw new ExecutionException(
+                StringFormatter.format('$ cannot be applied to a null value', op.getOperatorName()),
+            );
+    }
+}

package/src/engine/runtime/expression/operators/binary/BitwiseAndOperator.ts

@@ -0,0 +1,9 @@
+import { Operation } from '../../Operation';
+import { BinaryOperator } from './BinaryOperator';
+
+export class BitwiseAndOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        this.nullCheck(t, u, Operation.BITWISE_AND);
+        return t & u;
+    }
+}