consys/dsl/Expression.js

consys is a flexible tool to evaluate models using generic and readable constraints.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Expression = void 0;
/**
 * Utility class to print an ast.
 */
class ASTPrinter {
    /**
     * Returns the string representation of a given ast.
     * @param ast ast to be printed
     */
    print(ast) {
        var _a;
        return ((_a = ast.root) === null || _a === void 0 ? void 0 : _a.accept(this)) || ``;
    }
    visitBinaryExpression(expression) {
        return this.parenthesize(expression.operator.lexeme, expression.left, expression.right);
    }
    visitGroupingExpression(expression) {
        return this.parenthesize(`group`, expression.expression);
    }
    visitLiteralExpression(expression) {
        return expression.value.toString();
    }
    visitLogicalExpression(expression) {
        return this.parenthesize(expression.operator.lexeme, expression.left, expression.right);
    }
    visitUnaryExpression(expression) {
        return this.parenthesize(expression.operator.lexeme, expression.right);
    }
    parenthesize(name, ...expressions) {
        return `(${name} ${expressions.map(e => e.accept(this)).join(` `)})`;
    }
    visitConstraintExpression(rule) {
        return `(activation ${rule.activation.accept(this)} assertion ${rule.assertion.accept(this)})`;
    }
    visitFunctionExpression(rule) {
        return this.parenthesize(rule.name.lexeme, ...rule.args);
    }
    visitVariableExpression(rule) {
        return `${rule.prefix.lexeme} ${rule.name.map(e => e.lexeme).join(`.`)}`;
    }
}
var Expression;
(function (Expression) {
    /**
     * Represents the root node of an abstract syntax tree that was created from a given source.
     */
    class AST {
        constructor(root, source, statistics) {
            this.root = root;
            this.source = source;
            this.statistics = statistics;
        }
        toString() {
            return new ASTPrinter().print(this);
        }
    }
    Expression.AST = AST;
    class Binary {
        constructor(left, operator, right) {
            this.left = left;
            this.operator = operator;
            this.right = right;
        }
        accept(visitor) {
            return visitor.visitBinaryExpression(this);
        }
    }
    Expression.Binary = Binary;
    class Constraint {
        constructor(activation, assertion) {
            this.activation = activation;
            this.assertion = assertion;
        }
        accept(visitor) {
            return visitor.visitConstraintExpression(this);
        }
    }
    Expression.Constraint = Constraint;
    class Function {
        constructor(name, args) {
            this.name = name;
            this.args = args;
        }
        accept(visitor) {
            return visitor.visitFunctionExpression(this);
        }
    }
    Expression.Function = Function;
    class Grouping {
        constructor(expression) {
            this.expression = expression;
        }
        accept(visitor) {
            return visitor.visitGroupingExpression(this);
        }
    }
    Expression.Grouping = Grouping;
    class Literal {
        constructor(value) {
            this.value = value;
        }
        accept(visitor) {
            return visitor.visitLiteralExpression(this);
        }
    }
    Expression.Literal = Literal;
    class Logical {
        constructor(left, operator, right) {
            this.left = left;
            this.operator = operator;
            this.right = right;
        }
        accept(visitor) {
            return visitor.visitLogicalExpression(this);
        }
    }
    Expression.Logical = Logical;
    class Unary {
        constructor(operator, right) {
            this.operator = operator;
            this.right = right;
        }
        accept(visitor) {
            return visitor.visitUnaryExpression(this);
        }
    }
    Expression.Unary = Unary;
    class Variable {
        constructor(prefix, name) {
            this.prefix = prefix;
            this.name = name;
        }
        accept(visitor) {
            return visitor.visitVariableExpression(this);
        }
    }
    Expression.Variable = Variable;
})(Expression = exports.Expression || (exports.Expression = {}));