@cplieger/deadset-ts 8.0.0-dev.12 → 8.0.0-dev.14

package/src/vendor/unbash/arithmetic.ts

@@ -0,0 +1,641 @@
+// Code generated by scripts/vendor-unbash.ts from unbash 6.0.0 (968c14992a43dc06ce29c9f51858abd4a87851ea). DO NOT EDIT.
+// @ts-nocheck
+import type { ArithmeticExpression, ArithmeticWord } from "./internal-types.ts";
+import { ScriptExpansionImpl } from "./expansion.ts";
+import { MAX_SYNTAX_NESTING } from "./limits.ts";
+import {
+  CH_TAB,
+  CH_NL,
+  CH_SPACE,
+  CH_BANG,
+  CH_DOLLAR,
+  CH_PERCENT,
+  CH_AMP,
+  CH_LPAREN,
+  CH_RPAREN,
+  CH_STAR,
+  CH_PLUS,
+  CH_COMMA,
+  CH_DASH,
+  CH_SLASH,
+  CH_0,
+  CH_9,
+  CH_COLON,
+  CH_LT,
+  CH_EQ,
+  CH_GT,
+  CH_QUESTION,
+  CH_A,
+  CH_Z,
+  CH_LBRACKET,
+  CH_RBRACKET,
+  CH_CARET,
+  CH_UNDERSCORE,
+  CH_a,
+  CH_z,
+  CH_LBRACE,
+  CH_RBRACE,
+  CH_PIPE,
+  CH_TILDE,
+} from "./chars.ts";
+
+function opPrec(op: string): number {
+  switch (op) {
+    case ",":
+      return 1;
+    case "=":
+    case "+=":
+    case "-=":
+    case "*=":
+    case "/=":
+    case "%=":
+    case "<<=":
+    case ">>=":
+    case "&=":
+    case "|=":
+    case "^=":
+      return 2;
+    case "||":
+      return 4;
+    case "&&":
+      return 5;
+    case "|":
+      return 6;
+    case "^":
+      return 7;
+    case "&":
+      return 8;
+    case "==":
+    case "!=":
+      return 9;
+    case "<":
+    case "<=":
+    case ">":
+    case ">=":
+      return 10;
+    case "<<":
+    case ">>":
+      return 11;
+    case "+":
+    case "-":
+      return 12;
+    case "*":
+    case "/":
+    case "%":
+      return 13;
+    case "**":
+      return 14;
+    case "?":
+      return 3;
+    default:
+      return -1;
+  }
+}
+
+function trimEnd(src: string, start: number, end: number): number {
+  while (end > start) {
+    const c = src.charCodeAt(end - 1);
+    if (c !== CH_SPACE && c !== CH_TAB && c !== CH_NL) break;
+    end--;
+  }
+  return end;
+}
+
+function opRightAssoc(op: string): boolean {
+  switch (op) {
+    case "=":
+    case "+=":
+    case "-=":
+    case "*=":
+    case "/=":
+    case "%=":
+    case "<<=":
+    case ">>=":
+    case "&=":
+    case "|=":
+    case "^=":
+    case "**":
+      return true;
+    default:
+      return false;
+  }
+}
+
+export interface ArithmeticParseCollector {
+  embeddedWords: ArithmeticWord[];
+  // Builds a `$(…)` node whose script defers against the enclosing source and nesting budget.
+  commandExpansion: (pos: number, end: number, text: string) => ScriptExpansionImpl<"ArithmeticCommandExpansion">;
+  findClosingBracket?: (start: number, end: number) => number;
+  // Embedded `$(`, `${`, and `$((` require the lexer's shell-aware delimiter scanners;
+  // bodies parsed without a collector cannot contain them (see hasEmbeddedWordStructure).
+  findClosingBrace: (start: number, end: number) => number;
+  findClosingParenthesis: (start: number, end: number) => number;
+  findArithmeticExpansionEnd: (start: number, end: number) => number;
+  findArithmeticWordEnd?: (start: number, end: number) => number;
+}
+
+export function parseArithmeticExpression(
+  src: string,
+  offset: number = 0,
+  collector?: ArithmeticParseCollector,
+  nestingDepth = 0,
+): ArithmeticExpression | null {
+  let pos = 0;
+  const len = src.length;
+  const initialWordCount = collector?.embeddedWords.length ?? 0;
+
+  function makeWord(start: number, end: number, embedded = false): ArithmeticWord {
+    const node: ArithmeticWord = {
+      type: "ArithmeticWord",
+      pos: start + offset,
+      end: end + offset,
+      value: src.slice(start, end),
+      parts: undefined,
+    };
+    if (embedded) collector?.embeddedWords.push(node);
+    return node;
+  }
+
+  function skipWS(): void {
+    while (pos < len) {
+      const c = src.charCodeAt(pos);
+      if (c === CH_SPACE || c === CH_TAB || c === CH_NL) pos++;
+      else break;
+    }
+  }
+
+  function tryReadBinOp(): string | null {
+    if (pos >= len) return null;
+    const c = src.charCodeAt(pos);
+    const nc = pos + 1 < len ? src.charCodeAt(pos + 1) : 0;
+    const nnc = pos + 2 < len ? src.charCodeAt(pos + 2) : 0;
+
+    switch (c) {
+      case CH_COMMA:
+        pos++;
+        return ",";
+      case CH_EQ:
+        if (nc === CH_EQ) {
+          pos += 2;
+          return "==";
+        }
+        pos++;
+        return "=";
+      case CH_BANG:
+        if (nc === CH_EQ) {
+          pos += 2;
+          return "!=";
+        }
+        return null; // unary
+      case CH_LT:
+        if (nc === CH_LT) {
+          if (nnc === CH_EQ) {
+            pos += 3;
+            return "<<=";
+          }
+          pos += 2;
+          return "<<";
+        }
+        if (nc === CH_EQ) {
+          pos += 2;
+          return "<=";
+        }
+        pos++;
+        return "<";
+      case CH_GT:
+        if (nc === CH_GT) {
+          if (nnc === CH_EQ) {
+            pos += 3;
+            return ">>=";
+          }
+          pos += 2;
+          return ">>";
+        }
+        if (nc === CH_EQ) {
+          pos += 2;
+          return ">=";
+        }
+        pos++;
+        return ">";
+      case CH_PLUS:
+        if (nc === CH_EQ) {
+          pos += 2;
+          return "+=";
+        }
+        if (nc === CH_PLUS) return null; // postfix/prefix, not binary
+        pos++;
+        return "+";
+      case CH_DASH:
+        if (nc === CH_EQ) {
+          pos += 2;
+          return "-=";
+        }
+        if (nc === CH_DASH) return null; // postfix/prefix, not binary
+        pos++;
+        return "-";
+      case CH_STAR:
+        if (nc === CH_STAR) {
+          pos += 2;
+          return "**";
+        }
+        if (nc === CH_EQ) {
+          pos += 2;
+          return "*=";
+        }
+        pos++;
+        return "*";
+      case CH_SLASH:
+        if (nc === CH_EQ) {
+          pos += 2;
+          return "/=";
+        }
+        pos++;
+        return "/";
+      case CH_PERCENT:
+        if (nc === CH_EQ) {
+          pos += 2;
+          return "%=";
+        }
+        pos++;
+        return "%";
+      case CH_PIPE:
+        if (nc === CH_PIPE) {
+          pos += 2;
+          return "||";
+        }
+        if (nc === CH_EQ) {
+          pos += 2;
+          return "|=";
+        }
+        pos++;
+        return "|";
+      case CH_AMP:
+        if (nc === CH_AMP) {
+          pos += 2;
+          return "&&";
+        }
+        if (nc === CH_EQ) {
+          pos += 2;
+          return "&=";
+        }
+        pos++;
+        return "&";
+      case CH_CARET:
+        if (nc === CH_EQ) {
+          pos += 2;
+          return "^=";
+        }
+        pos++;
+        return "^";
+      case CH_QUESTION:
+        pos++;
+        return "?";
+      default:
+        return null;
+    }
+  }
+
+  function skipTruncatedUnary(): void {
+    skipWS();
+    while (pos < len) {
+      const c = src.charCodeAt(pos);
+      if (c !== CH_BANG && c !== CH_TILDE && c !== CH_PLUS && c !== CH_DASH) break;
+      if (src.charCodeAt(pos + 1) === CH_EQ) break;
+      pos++;
+      skipWS();
+    }
+    if (src.charCodeAt(pos) === CH_LPAREN) {
+      let groups = 1;
+      pos++;
+      while (pos < len && groups > 0) {
+        const wordEnd = collector?.findArithmeticWordEnd?.(pos + offset, offset + len) ?? pos + offset;
+        if (wordEnd > pos + offset) {
+          pos = wordEnd - offset;
+          continue;
+        }
+        const c = src.charCodeAt(pos++);
+        if (c === CH_LPAREN) groups++;
+        else if (c === CH_RPAREN) groups--;
+      }
+    } else if (pos < len && src.charCodeAt(pos) !== CH_RPAREN && src.charCodeAt(pos) !== CH_COLON) {
+      parseAtom(0);
+    }
+    skipWS();
+    const c = src.charCodeAt(pos);
+    if ((c === CH_PLUS || c === CH_DASH) && src.charCodeAt(pos + 1) === c) pos += 2;
+  }
+
+  function recoverExpression(minPrec: number): ArithmeticWord {
+    skipWS();
+    const start = pos;
+    if (start === len) return makeWord(start, start);
+    const wordCount = collector?.embeddedWords.length ?? 0;
+    let ternaries = 0;
+    for (;;) {
+      skipTruncatedUnary();
+      skipWS();
+      if (src.charCodeAt(pos) === CH_COLON && ternaries > 0) {
+        ternaries--;
+        pos++;
+        continue;
+      }
+      const saved = pos;
+      const op = tryReadBinOp();
+      if (op === null || (ternaries === 0 && opPrec(op) < minPrec)) {
+        pos = saved;
+        break;
+      }
+      if (op === "?") ternaries++;
+    }
+    if (collector) collector.embeddedWords.length = wordCount;
+    return makeWord(start, trimEnd(src, start, pos));
+  }
+
+  function parseBinExpr(minPrec: number, depth: number): ArithmeticExpression {
+    if (depth > MAX_SYNTAX_NESTING) return recoverExpression(minPrec);
+    let left = parseUnaryExpr(depth);
+
+    while (true) {
+      skipWS();
+      if (pos >= len) break;
+
+      const saved = pos;
+      const op = tryReadBinOp();
+      if (!op) break;
+
+      // Ternary
+      if (op === "?") {
+        if (opPrec(op) < minPrec) {
+          pos = saved;
+          break;
+        }
+        const consequent = parseBinExpr(1, depth + 1);
+        skipWS();
+        if (pos < len && src.charCodeAt(pos) === CH_COLON) pos++;
+        const alternate = parseBinExpr(3, depth + 1);
+        left = { type: "ArithmeticTernary", pos: left.pos, end: alternate.end, test: left, consequent, alternate };
+        continue;
+      }
+
+      const prec = opPrec(op);
+      if (prec < minPrec) {
+        pos = saved;
+        break;
+      }
+
+      const nextPrec = opRightAssoc(op) ? prec : prec + 1;
+      const right = parseBinExpr(nextPrec, depth + 1);
+      left = { type: "ArithmeticBinary", pos: left.pos, end: right.end, operator: op, left, right };
+    }
+
+    return left;
+  }
+
+  function parseUnaryExpr(depth: number): ArithmeticExpression {
+    skipWS();
+    if (depth > MAX_SYNTAX_NESTING) return recoverExpression(15);
+    if (pos >= len) return makeWord(pos, pos);
+
+    const start = pos;
+    const c = src.charCodeAt(pos);
+    const nc = pos + 1 < len ? src.charCodeAt(pos + 1) : 0;
+
+    // Prefix ++ --
+    if (c === CH_PLUS && nc === CH_PLUS) {
+      pos += 2;
+      const operand = parseUnaryExpr(depth + 1);
+      return { type: "ArithmeticUnary", pos: start + offset, end: operand.end, operator: "++", operand, prefix: true };
+    }
+    if (c === CH_DASH && nc === CH_DASH) {
+      pos += 2;
+      const operand = parseUnaryExpr(depth + 1);
+      return { type: "ArithmeticUnary", pos: start + offset, end: operand.end, operator: "--", operand, prefix: true };
+    }
+
+    // Unary ! ~ + -
+    if (c === CH_BANG) {
+      pos++;
+      const operand = parseUnaryExpr(depth + 1);
+      return { type: "ArithmeticUnary", pos: start + offset, end: operand.end, operator: "!", operand, prefix: true };
+    }
+    if (c === CH_TILDE) {
+      pos++;
+      const operand = parseUnaryExpr(depth + 1);
+      return { type: "ArithmeticUnary", pos: start + offset, end: operand.end, operator: "~", operand, prefix: true };
+    }
+    if (c === CH_PLUS && nc !== CH_PLUS && nc !== CH_EQ) {
+      pos++;
+      const operand = parseUnaryExpr(depth + 1);
+      return { type: "ArithmeticUnary", pos: start + offset, end: operand.end, operator: "+", operand, prefix: true };
+    }
+    if (c === CH_DASH && nc !== CH_DASH && nc !== CH_EQ) {
+      pos++;
+      const operand = parseUnaryExpr(depth + 1);
+      return { type: "ArithmeticUnary", pos: start + offset, end: operand.end, operator: "-", operand, prefix: true };
+    }
+
+    return parsePostfixExpr(depth);
+  }
+
+  function parsePostfixExpr(depth: number): ArithmeticExpression {
+    const operand = parseAtom(depth);
+    skipWS();
+    if (pos + 1 < len) {
+      const c = src.charCodeAt(pos);
+      const nc = src.charCodeAt(pos + 1);
+      if (c === CH_PLUS && nc === CH_PLUS) {
+        pos += 2;
+        return { type: "ArithmeticUnary", pos: operand.pos, end: pos + offset, operator: "++", operand, prefix: false };
+      }
+      if (c === CH_DASH && nc === CH_DASH) {
+        pos += 2;
+        return { type: "ArithmeticUnary", pos: operand.pos, end: pos + offset, operator: "--", operand, prefix: false };
+      }
+    }
+    return operand;
+  }
+
+  function parseAtom(depth: number): ArithmeticExpression {
+    skipWS();
+    if (pos >= len) return makeWord(pos, pos);
+
+    const c = src.charCodeAt(pos);
+
+    // Parenthesized expression
+    if (c === CH_LPAREN) {
+      const start = pos;
+      pos++;
+      const expr = parseBinExpr(0, depth + 1);
+      skipWS();
+      if (pos < len && src.charCodeAt(pos) === CH_RPAREN) pos++;
+      return { type: "ArithmeticGroup", pos: start + offset, end: pos + offset, expression: expr };
+    }
+
+    // Dollar expansion
+    if (c === CH_DOLLAR) {
+      const start = pos;
+      const wordCount = collector?.embeddedWords.length ?? 0;
+      const atom = readDollarAtom();
+      const wordEnd = collector?.findArithmeticWordEnd?.(start + offset, offset + len) ?? pos + offset;
+      if (wordEnd > pos + offset) {
+        if (collector) collector.embeddedWords.length = wordCount;
+        pos = wordEnd - offset;
+        return makeWord(start, pos, true);
+      }
+      return atom;
+    }
+
+    if (c === 0x60 /* ` */ || c === 0x22 /* " */ || c === 0x27 /* ' */) {
+      const start = pos;
+      pos = (collector?.findArithmeticWordEnd?.(start + offset, offset + len) ?? start + offset + 1) - offset;
+      return makeWord(start, pos, true);
+    }
+
+    // Number or variable name
+    const start = pos;
+    const wordCount = collector?.embeddedWords.length ?? 0;
+    const atom = readWordAtom();
+    const wordEnd = collector?.findArithmeticWordEnd?.(start + offset, offset + len) ?? pos + offset;
+    if (wordEnd > pos + offset) {
+      if (collector) collector.embeddedWords.length = wordCount;
+      pos = wordEnd - offset;
+      return makeWord(start, pos, true);
+    }
+    return atom;
+  }
+
+  function readDollarAtom(): ArithmeticExpression {
+    const start = pos;
+    pos++; // skip $
+    if (pos >= len) return makeWord(start, pos);
+
+    const c = src.charCodeAt(pos);
+
+    if (c === CH_LPAREN) {
+      if (pos + 1 < len && src.charCodeAt(pos + 1) === CH_LPAREN) {
+        // $(( nested arithmetic ))
+        const expansionEnd = collector?.findArithmeticExpansionEnd(start + offset, offset + len) ?? -1;
+        if (expansionEnd !== -1) {
+          pos = expansionEnd - offset;
+        } else {
+          pos += 2;
+          let depth = 1;
+          while (pos < len && depth > 0) {
+            if (src.charCodeAt(pos) === CH_LPAREN && src.charCodeAt(pos + 1) === CH_LPAREN) {
+              depth++;
+              pos += 2;
+            } else if (src.charCodeAt(pos) === CH_RPAREN && src.charCodeAt(pos + 1) === CH_RPAREN) {
+              depth--;
+              pos += 2;
+            } else {
+              pos++;
+            }
+          }
+        }
+      } else {
+        // $( command substitution )
+        pos++; // skip (
+        const close = collector?.findClosingParenthesis(pos + offset, offset + len) ?? -1;
+        if (close !== -1) {
+          pos = close - offset + 1;
+        } else {
+          let depth = 1;
+          while (pos < len && depth > 0) {
+            const ch = src.charCodeAt(pos++);
+            if (ch === CH_LPAREN) depth++;
+            else if (ch === CH_RPAREN) depth--;
+          }
+        }
+        const text = src.slice(start, pos);
+        return collector
+          ? collector.commandExpansion(start + offset, pos + offset, text)
+          : new ScriptExpansionImpl("ArithmeticCommandExpansion", start + offset, pos + offset, text);
+      }
+    } else if (c === CH_LBRACE) {
+      // ${ parameter expansion }
+      const close = collector?.findClosingBrace(pos + offset + 1, offset + len) ?? -1;
+      if (close !== -1) {
+        pos = close - offset + 1;
+      } else {
+        pos++;
+        let depth = 1;
+        while (pos < len && depth > 0) {
+          const ch = src.charCodeAt(pos++);
+          if (ch === CH_LBRACE) depth++;
+          else if (ch === CH_RBRACE) depth--;
+        }
+      }
+    } else {
+      // $var
+      while (pos < len) {
+        const ch = src.charCodeAt(pos);
+        if (
+          (ch >= CH_a && ch <= CH_z) ||
+          (ch >= CH_A && ch <= CH_Z) ||
+          (ch >= CH_0 && ch <= CH_9) ||
+          ch === CH_UNDERSCORE
+        )
+          pos++;
+        else break;
+      }
+    }
+
+    return makeWord(start, pos, c === CH_LPAREN || c === CH_LBRACE);
+  }
+
+  function readWordAtom(): ArithmeticExpression {
+    const start = pos;
+
+    while (pos < len) {
+      const c = src.charCodeAt(pos);
+      if (
+        (c >= CH_0 && c <= CH_9) ||
+        (c >= CH_A && c <= CH_Z) ||
+        (c >= CH_a && c <= CH_z) ||
+        c === CH_UNDERSCORE ||
+        c === 35 // # for base-N literals like 2#101
+      ) {
+        pos++;
+      } else break;
+    }
+
+    // Array subscript: var[expr]
+    if (pos > start && pos < len && src.charCodeAt(pos) === CH_LBRACKET) {
+      const close = collector?.findClosingBracket?.(pos + offset + 1, offset + len) ?? -1;
+      if (close !== -1) {
+        pos = close - offset + 1;
+      } else {
+        pos++;
+        let depth = 1;
+        while (pos < len && depth > 0) {
+          const c = src.charCodeAt(pos);
+          if (c === CH_LBRACKET) depth++;
+          else if (c === CH_RBRACKET) depth--;
+          pos++;
+        }
+      }
+      return makeWord(start, pos, true);
+    }
+
+    if (pos === start) {
+      // Unknown character — advance to prevent infinite loop
+      pos++;
+      return makeWord(start, pos);
+    }
+
+    return makeWord(start, pos);
+  }
+
+  skipWS();
+  if (pos >= len) return null;
+  const start = pos;
+  const result = parseBinExpr(0, nestingDepth);
+  skipWS();
+  if (pos < len) {
+    // Unparsed tokens remain: a partial tree would silently drop them, so keep the whole body
+    // as one word. With embedded structure its parts still expose nested substitutions.
+    if (collector) collector.embeddedWords.length = initialWordCount;
+    return makeWord(start, trimEnd(src, start, len), collector !== undefined);
+  }
+  return result;
+}