simc-ast-builder/dist/parser/visitors/ast/ContextHandlers/Basic/ComparisonExprHandler.js

Parser and AST generator for SimulationCraft files

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.handleLessThanExpr = exports.handleLessThanEqualExpr = exports.handleInequalityExpr = exports.handleGreaterThanExpr = exports.handleGreaterThanEqualExpr = exports.handleEqualityExpr = exports.handleComparisonExpr = void 0;
/**
 * Handler for equality expressions (=, ==)
 */
const handleEqualityExpr = (ctx, visitor) => {
    // Only handle if this is an equality comparison
    if (!ctx.OP_EQ() && !ctx.OP_EQEQ()) {
        throw new Error("Not an equality expression");
    }
    return {
        expressionType: "boolean",
        kind: "expression",
        left: visitor.visit(ctx.expression(0)),
        nodeType: "comparison",
        operator: "eq",
        right: visitor.visit(ctx.expression(1)),
    };
};
exports.handleEqualityExpr = handleEqualityExpr;
/**
 * Handler for inequality expressions (!=)
 */
const handleInequalityExpr = (ctx, visitor) => {
    // Only handle if this is an inequality comparison
    if (!ctx.OP_NE()) {
        throw new Error("Not an inequality expression");
    }
    return {
        expressionType: "boolean",
        kind: "expression",
        left: visitor.visit(ctx.expression(0)),
        nodeType: "comparison",
        operator: "ne",
        right: visitor.visit(ctx.expression(1)),
    };
};
exports.handleInequalityExpr = handleInequalityExpr;
/**
 * Handler for less than expressions (<)
 */
const handleLessThanExpr = (ctx, visitor) => {
    // Only handle if this is a less than comparison
    if (!ctx.OP_LT()) {
        throw new Error("Not a less than expression");
    }
    return {
        expressionType: "boolean",
        kind: "expression",
        left: visitor.visit(ctx.expression(0)),
        nodeType: "comparison",
        operator: "lt",
        right: visitor.visit(ctx.expression(1)),
    };
};
exports.handleLessThanExpr = handleLessThanExpr;
/**
 * Handler for less than or equal expressions (<=)
 */
const handleLessThanEqualExpr = (ctx, visitor) => {
    // Only handle if this is a less than or equal comparison
    if (!ctx.OP_LE()) {
        throw new Error("Not a less than or equal expression");
    }
    return {
        expressionType: "boolean",
        kind: "expression",
        left: visitor.visit(ctx.expression(0)),
        nodeType: "comparison",
        operator: "le",
        right: visitor.visit(ctx.expression(1)),
    };
};
exports.handleLessThanEqualExpr = handleLessThanEqualExpr;
/**
 * Handler for greater than expressions (>)
 */
const handleGreaterThanExpr = (ctx, visitor) => {
    // Only handle if this is a greater than comparison
    if (!ctx.OP_GT()) {
        throw new Error("Not a greater than expression");
    }
    return {
        expressionType: "boolean",
        kind: "expression",
        left: visitor.visit(ctx.expression(0)),
        nodeType: "comparison",
        operator: "gt",
        right: visitor.visit(ctx.expression(1)),
    };
};
exports.handleGreaterThanExpr = handleGreaterThanExpr;
/**
 * Handler for greater than or equal expressions (>=)
 */
const handleGreaterThanEqualExpr = (ctx, visitor) => {
    // Only handle if this is a greater than or equal comparison
    if (!ctx.OP_GE()) {
        throw new Error("Not a greater than or equal expression");
    }
    return {
        expressionType: "boolean",
        kind: "expression",
        left: visitor.visit(ctx.expression(0)),
        nodeType: "comparison",
        operator: "ge",
        right: visitor.visit(ctx.expression(1)),
    };
};
exports.handleGreaterThanEqualExpr = handleGreaterThanEqualExpr;
/**
 * Generic handler for all comparison expressions (= != < <= > >=)
 */
const handleComparisonExpr = (ctx, visitor) => {
    if (ctx.OP_EQ() || ctx.OP_EQEQ()) {
        return handleEqualityExpr(ctx, visitor);
    }
    else if (ctx.OP_NE()) {
        return handleInequalityExpr(ctx, visitor);
    }
    else if (ctx.OP_LT()) {
        return handleLessThanExpr(ctx, visitor);
    }
    else if (ctx.OP_LE()) {
        return handleLessThanEqualExpr(ctx, visitor);
    }
    else if (ctx.OP_GT()) {
        return handleGreaterThanExpr(ctx, visitor);
    }
    else if (ctx.OP_GE()) {
        return handleGreaterThanEqualExpr(ctx, visitor);
    }
    else {
        throw new Error("Unknown comparison operator");
    }
};
exports.handleComparisonExpr = handleComparisonExpr;
//# sourceMappingURL=ComparisonExprHandler.js.map