mcalc/modules/parser.js

90 lines
2.0 KiB
JavaScript

function isLeftAssociative(op) {
return op === "+" || op === "-" || op === "*" || op === "/";
}
function popOps(opstack, queue, op, powInStack) {
const prec = {"+": 1, "-": 1, "*": 2, "/": 2, "^": 3}
while (opstack.length > 0) {
const op2 = opstack.at(-1);
if (op2 === "(") {
break;
}
if ((prec[op2] > prec[op]) || (prec[op2] === prec[op] && isLeftAssociative(op))) {
opstack.pop();
queue.push(op2);
if (op2 === "^") {
powInStack = false;
}
} else {
break;
}
}
// practically, we want 2^(3+4) mod 7 to evaluate to 2^7 mod 7 = 2
// however, since our operators are all modular, this would instead
// evaluate as 2^0 mod 7 = 1
// rather than complicate things by evaluating exponent expressions
// normally instead of modularly (and consequently needing to deal with
// fractions) we simply require exponents to be integers
if (powInStack) {
throw new Error("exponent must be an integer, not an expression");
}
}
function popBetweenParens(opstack, queue, powInStack) {
while (opstack.at(-1) !== "(") {
if (opstack.length === 0) {
throw new Error("mismatched parentheses");
}
const op = opstack.pop();
if (op === "^") {
powInStack = false;
}
queue.push(op);
}
opstack.pop();
return powInStack;
}
function empty(opstack, queue) {
while (opstack.length !== 0) {
const op = opstack.pop();
if (op === "(") {
throw new Error("mismatched parentheses");
}
queue.push(op);
}
}
function shunt(tokens) {
const queue = [];
const opstack = [];
let powInStack = false;
for (const token of tokens) {
if (typeof token === "bigint") {
queue.push(token);
} else if (/[-+*/^]/.test(token)) {
popOps(opstack, queue, token, powInStack);
powInStack = false;
opstack.push(token);
if (token === "^") {
powInStack = true;
}
} else if (token === "(") {
opstack.push(token);
} else if (token === ")") {
powInStack = popBetweenParens(opstack, queue, powInStack);
}
}
empty(opstack, queue);
return queue;
}
export { shunt };