depyo 1.0.0

package/lib/code_reader.js

@@ -0,0 +1,146 @@
+class CodeReader {
+    constructor(code, endian) {
+        this.endian = endian || 'B';
+        this._reader = Buffer.from(code);
+        this._pc = 0;
+    }
+
+    get pc() {
+        return this._pc;
+    }
+
+    set pc(pos) {
+        if (pos > this.length || pos < 0) {
+            pos = this.length;
+        }
+        this._pc = pos;
+    }
+
+    get length() {
+        return this._reader.length
+    }
+
+    get EOF() {
+        return this._pc >= this._reader.length;
+    }
+
+    readByte() {
+        try {
+            let value = this._reader.readUInt8(this.pc, true);
+            this.pc++;
+            return value;
+        } catch {
+            debugger;
+        }
+    }
+    
+    readUShort() {
+        try {
+            let value = this._reader[`readUInt16${this.endian}E`](this.pc, true);
+            this.pc += 2;
+            return value;
+        } catch {
+            debugger;
+        }
+    }
+
+    readShort() {
+        try {
+            let value = this._reader[`readInt16${this.endian}E`](this.pc, true);
+            this.pc += 2;
+            return value;
+        } catch {
+            debugger;
+        }
+    }
+
+    readInt() {
+        try {
+            let value = this._reader[`readInt32${this.endian}E`](this.pc, true);
+            this.pc += 4;
+            return value;
+        } catch {
+            debugger;
+        }
+    }
+
+    readUInt() {
+        try {
+            let value = this._reader[`readUInt32${this.endian}E`](this.pc, true);
+            this.pc += 4;
+            return value;
+        } catch (ex) {
+            debugger;
+        }
+    }
+    
+    readLong() {
+        try {
+            let high = this.readInt()
+            let low = this.readInt()
+            return {low, high};
+        } catch {
+            debugger;
+        }
+    }
+    
+    readULong() {
+        try {
+            let high = this.readUInt()
+            let low = this.readUInt()
+            return {low, high};
+        } catch {
+            debugger;
+        }
+    }
+
+    readFloat() {
+        try {
+            let value = this._reader[`readFloat${this.endian}E`](this.pc, true);
+            this.pc += 4;
+            return value;
+        } catch {
+            debugger;
+        }
+    }
+    
+    readDouble() {
+        try {
+            let value = this._reader[`readDouble${this.endian}E`](this.pc, true);
+            this.pc += 8;
+            return value;
+        } catch {
+            debugger;
+        }
+    }
+    
+    readBytes(length) {
+        try {
+            let value = this._reader.slice(this.pc, this.pc + length);
+            this.pc += length;
+            return value;
+        } catch {
+            debugger;
+        }
+    }
+
+    readString(length) {
+        try {
+            let value = this._reader.slice(this.pc, this.pc + length).toString('utf8');
+            this.pc += length;
+            return value;
+        } catch {
+            debugger;
+        }
+    }
+
+    peekByte() {
+        try {
+            return this._reader.readUInt8(this.pc, true);
+        } catch {
+            debugger;
+        }
+    }
+}
+
+module.exports = CodeReader;

package/lib/handlers/binary_ops.js

@@ -0,0 +1,174 @@
+const AST = require('../ast/ast_node');
+
+function handleBinaryOpA()
+{
+    let rVal = this.dataStack.pop();
+    let lVal = this.dataStack.pop();
+    let op = AST.ASTBinary.from_binary_op(this.code.Current.Argument);
+    if (op == AST.ASTBinary.BinOp.InvalidOp) {
+        // TODO: Throw and handle proper exeception.
+        throw new SyntaxError("Invalid op");
+    }
+    let node = new AST.ASTBinary(lVal, rVal,op);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+}
+
+function handleBinaryAdd() {
+    processBinaryOp.call(this);
+}
+
+function handleBinaryAnd() {
+    processBinaryOp.call(this);
+}
+
+function handleBinaryDivide(){
+    processBinaryOp.call(this);
+}
+
+function handleBinaryFloorDivide() {
+    processBinaryOp.call(this);
+}
+
+function handleBinaryLshift(){
+    processBinaryOp.call(this);
+}
+
+function handleBinaryModulo() {
+    processBinaryOp.call(this);
+}
+
+function handleBinaryMultiply() {
+    processBinaryOp.call(this);
+}
+
+function handleBinaryOr() {
+    processBinaryOp.call(this);
+}
+
+function handleBinaryPower() {
+    processBinaryOp.call(this);
+}
+
+function handleBinaryRshift() {
+    processBinaryOp.call(this);
+}
+
+function handleBinarySubtract() {
+    processBinaryOp.call(this);
+}
+
+function handleBinaryTrueDivide() {
+    processBinaryOp.call(this);
+}
+
+function handleBinaryXor() {
+    processBinaryOp.call(this);
+}
+
+function handleBinaryMatrixMultiply() {
+    processBinaryOp.call(this);
+}
+
+function handleInplaceAdd() {
+    processBinaryOp.call(this);
+}
+
+function handleInplaceAnd() {
+    processBinaryOp.call(this);
+}
+
+function handleInplaceDivide() {
+    processBinaryOp.call(this);
+}
+
+function handleInplaceFloorDivide() {
+    processBinaryOp.call(this);
+}
+
+function handleInplaceLShift() {
+    processBinaryOp.call(this);
+}
+
+function handleInplaceModulo() {
+    processBinaryOp.call(this);
+}
+
+function handleInplaceMultiply() {
+    processBinaryOp.call(this);
+}
+
+function handleInplaceOr() {
+    processBinaryOp.call(this);
+}
+
+function handleInplacePower() {
+    processBinaryOp.call(this);
+}
+
+function handleInplaceRshift() {
+    processBinaryOp.call(this);
+}
+
+function handleInplaceSubtract() {
+    processBinaryOp.call(this);
+}
+
+function handleInplaceTrueDivide() {
+    processBinaryOp.call(this);
+}
+
+function handleInplaceXor() {
+    processBinaryOp.call(this);
+}
+
+function handleInplaceMatrixMultiply() {
+    processBinaryOp.call(this);
+}
+
+function processBinaryOp()
+{
+    let rVal = this.dataStack.pop();
+    let lVal = this.dataStack.pop();
+    let op = AST.ASTBinary.from_opcode(this.code.Current.OpCodeID);
+    if (op == AST.ASTBinary.BinOp.InvalidOp) {
+        // TODO: Throw and handle proper exeception.
+        throw new SyntaxError("Invalid op");
+    }
+    let node = new AST.ASTBinary(lVal, rVal,op);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+}
+
+module.exports = {
+    handleBinaryOr,
+    handleBinaryAdd,
+    handleBinaryAnd,
+    handleBinaryDivide,
+    handleBinaryFloorDivide,
+    handleBinaryLshift,
+    handleBinaryModulo,
+    handleBinaryMultiply,
+    handleBinaryOr,
+    handleBinaryPower,
+    handleBinaryRshift,
+    handleBinarySubtract,
+    handleBinaryTrueDivide,
+    handleBinaryXor,
+    handleBinaryMatrixMultiply,
+    handleInplaceAdd,
+    handleInplaceAnd,
+    handleInplaceDivide,
+    handleInplaceFloorDivide,
+    handleInplaceLShift,
+    handleInplaceModulo,
+    handleInplaceMultiply,
+    handleInplaceOr,
+    handleInplacePower,
+    handleInplaceRshift,
+    handleInplaceSubtract,
+    handleInplaceTrueDivide,
+    handleInplaceXor,
+    handleInplaceMatrixMultiply,
+    handleBinaryOpA
+};

package/lib/handlers/collections_update.js

@@ -0,0 +1,239 @@
+const AST = require('../ast/ast_node');
+
+function handleSetAdd() {
+    handleSetAddA.call(this);
+}
+
+function handleSetAddA() {
+    let value = this.dataStack.pop();
+
+    // Check if this is a set comprehension first
+    if (this.curBlock.blockType == AST.ASTBlock.BlockType.For && this.curBlock.comprehension) {
+        this.dataStack.pop(); // Pop the empty set
+        let node = new AST.ASTComprehension(value);
+        node.line = this.code.Current.LineNo;
+        node.kind = AST.ASTComprehension.SET;
+        this.dataStack.push(node);
+        return;
+    }
+
+    // Normal set add
+    let setOffset = this.code.Current.OpCodeID == this.OpCodes.SET_ADD_A ? this.code.Current.Argument - 1 : 0;
+    let setNode = this.dataStack.top(setOffset);
+    if (!setNode || typeof setNode.add !== 'function') {
+        if (global.g_cliArgs?.debug) {
+            console.error(`SET_ADD target missing or invalid at offset ${this.code.Current.Offset}`);
+        }
+        return;
+    }
+    setNode.add(value);
+}
+
+function handleListAppend() {
+    processListAppend.call(this);
+}
+
+function handleListAppendA() {
+    processListAppend.call(this);
+}
+
+function processListAppend() {
+    let value = this.dataStack.pop();
+    let list = this.dataStack.top();
+
+    if (this.curBlock.blockType == AST.ASTBlock.BlockType.For && this.curBlock.comprehension) {
+        this.dataStack.pop();
+        let node = new AST.ASTComprehension (value);
+        node.line = this.code.Current.LineNo;
+        this.dataStack.push(node);
+    } else {
+        let node = new AST.ASTSubscr (list, value);
+        node.line = this.code.Current.LineNo;
+        this.dataStack.push(node);
+    }
+}
+
+function handleSetUpdateA() {
+    const rhs = this.dataStack.pop();
+    const lhs = this.dataStack.pop();
+
+    const targetValues = lhs instanceof AST.ASTSet ? [...(lhs.values || [])] : [];
+    const rhsValues = collectIterableValues(rhs);
+
+    if (!rhsValues) {
+        if (global.g_cliArgs?.debug) {
+            console.error("Unsupported argument found for SET_UPDATE");
+        }
+        this.dataStack.push(lhs);
+        return;
+    }
+
+    let node = new AST.ASTSet([...targetValues, ...rhsValues]);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+}
+
+function handleListExtendA() {
+    const rhs = this.dataStack.pop();
+    const lhs = this.dataStack.pop();
+
+    if (!(lhs instanceof AST.ASTList)) {
+        if (global.g_cliArgs?.debug) {
+            console.error("LIST_EXTEND target is not a list literal");
+        }
+        this.dataStack.push(lhs);
+        return;
+    }
+
+    const appendValues = collectIterableValues(rhs);
+
+    if (!appendValues || appendValues.length === 0) {
+        if (global.g_cliArgs?.debug) {
+            console.error("Unsupported argument found for LIST_EXTEND");
+        }
+        this.dataStack.push(lhs);
+        return;
+    }
+
+    lhs.values.push(...appendValues);
+
+    this.dataStack.push(lhs);
+}
+
+function handleDictMergeA() {
+    const dictToMerge = this.dataStack.pop();
+    const targetDict = this.dataStack.top();
+    const entries = collectMapEntries(dictToMerge);
+
+    if (!(targetDict instanceof AST.ASTMap) || !entries) {
+        if (global.g_cliArgs?.debug) {
+            console.error("Expected ASTMap for DICT_MERGE_A");
+        }
+        return;
+    }
+
+    for (const entry of entries) {
+        targetDict.add(entry.key, entry.value);
+    }
+}
+
+function handleDictUpdateA() {
+    const updateSource = this.dataStack.pop();
+    const targetDict = this.dataStack.top();
+
+    if (!(targetDict instanceof AST.ASTMap)) {
+        if (global.g_cliArgs?.debug) {
+            console.error("Expected ASTMap for DICT_UPDATE_A target");
+        }
+        return;
+    }
+
+    if (updateSource instanceof AST.ASTCall && updateSource.func instanceof AST.ASTName && updateSource.func.name == 'zip') {
+        // Handle case where updateSource is a zip of keys and values
+        if (updateSource.pparams.length === 2) {
+            let keys = updateSource.pparams[0];
+            let values = updateSource.pparams[1];
+            if (keys instanceof AST.ASTList && values instanceof AST.ASTList && keys.values.length === values.values.length) {
+                for (let i = 0; i < keys.values.length; i++) {
+                    targetDict.add(keys.values[i], values.values[i]);
+                }
+                return;
+            } else if (keys instanceof AST.ASTTuple && values instanceof AST.ASTTuple && keys.values.length === values.values.length) {
+                for (let i = 0; i < keys.values.length; i++) {
+                    targetDict.add(keys.values[i], values.values[i]);
+                }
+                return;
+            } else if (global.g_cliArgs?.debug) {
+                console.error("Expected lists or tuples of equal length for zip in DICT_UPDATE_A");
+            }
+        }
+    }
+
+    const entries = collectMapEntries(updateSource);
+    if (!entries) {
+        if (global.g_cliArgs?.debug) {
+            console.error("Expected ASTMap or iterable for DICT_UPDATE_A");
+        }
+        return;
+    }
+
+    for (const entry of entries) {
+        targetDict.add(entry.key, entry.value);
+    }
+}
+
+function collectIterableValues(node) {
+    if (node instanceof AST.ASTList || node instanceof AST.ASTTuple || node instanceof AST.ASTSet) {
+        return node.values || [];
+    }
+
+    if (node instanceof AST.ASTObject) {
+        const obj = node.object;
+        if (["Py_List", "Py_Tuple", "Py_SmallTuple", "Py_Set", "Py_FrozenSet"].includes(obj?.ClassName)) {
+            return (obj.Value || []).map(value => new AST.ASTObject(value));
+        }
+    }
+
+    return null;
+}
+
+function collectMapEntries(node) {
+    if (node instanceof AST.ASTMap || node instanceof AST.ASTKwNamesMap) {
+        return node.values || [];
+    }
+
+    if (node instanceof AST.ASTConstMap) {
+        let keysArray = [];
+        if (node.keys instanceof AST.ASTObject) {
+            const obj = node.keys.object;
+            if (obj?.ClassName === 'Py_Tuple' || obj?.ClassName === 'Py_SmallTuple') {
+                keysArray = (obj.Value || []).map(v => new AST.ASTObject(v));
+            }
+        } else if (Array.isArray(node.keys)) {
+            keysArray = node.keys;
+        }
+
+        const valuesArray = Array.isArray(node.values) ? [...node.values].reverse() : [];
+        const count = Math.min(keysArray.length, valuesArray.length);
+        const entries = [];
+        for (let i = 0; i < count; i++) {
+            entries.push({key: keysArray[i], value: valuesArray[i]});
+        }
+        return entries.length ? entries : null;
+    }
+
+    if (node instanceof AST.ASTList || node instanceof AST.ASTTuple) {
+        const entries = [];
+        for (const pair of node.values || []) {
+            if (pair instanceof AST.ASTTuple && pair.values?.length === 2) {
+                entries.push({key: pair.values[0], value: pair.values[1]});
+            }
+        }
+        if (entries.length) {
+            return entries;
+        }
+    }
+
+    if (node instanceof AST.ASTObject) {
+        const obj = node.object;
+        if (obj?.ClassName === "Py_Dict") {
+            return (obj.Value || []).map(({key, value}) => ({
+                key: new AST.ASTObject(key),
+                value: new AST.ASTObject(value)
+            }));
+        }
+    }
+
+    return null;
+}
+
+module.exports = {
+    handleSetAdd,
+    handleSetAddA,
+    handleListAppend,
+    handleListAppendA,
+    handleSetUpdateA,
+    handleListExtendA,
+    handleDictMergeA,
+    handleDictUpdateA
+};

package/lib/handlers/comparisons.js

@@ -0,0 +1,95 @@
+const AST = require('../ast/ast_node');
+
+function handleCompareOpA() {
+    // Literal-only match patterns in 3.13+: COPY 1 + LOAD_CONST + COMPARE_OP
+    // No MATCH_* opcodes appear, so initialize match tracking here.
+    // Match patterns only exist in Python 3.10+
+    if (!this.currentMatch && this.potentialMatchSubject && !this.inMatchPattern &&
+        this.object.Reader.versionCompare(3, 10) >= 0) {
+        this.matchSubject = this.potentialMatchSubject;
+        this.currentMatch = new AST.ASTMatch(this.matchSubject);
+        this.currentMatch.line = this.code.Current.LineNo;
+        this.matchParentBlock = this.curBlock;
+        this.patternOps = [];
+        if (!this.matchPreNodesStart && this.matchParentBlock) {
+            this.matchPreNodesStart = this.matchParentBlock.nodes.length;
+        }
+    }
+    if (this.currentMatch && !this.inMatchPattern) {
+        this.inMatchPattern = true;
+        this.patternOps = [];
+    }
+    const jumpOps = [
+        this.OpCodes.POP_JUMP_IF_FALSE_A,
+        this.OpCodes.POP_JUMP_FORWARD_IF_FALSE_A,
+        this.OpCodes.POP_JUMP_IF_TRUE_A,
+        this.OpCodes.POP_JUMP_FORWARD_IF_TRUE_A
+    ];
+    if (this.currentMatch && this.patternOps?.length && jumpOps.includes(this.code.Prev?.OpCodeID)) {
+        this.patternOps = [];
+    }
+
+    let right = this.dataStack.pop();
+    let left = this.dataStack.pop();
+    let arg = this.code.Current.Argument;
+    if (this.object.Reader.versionCompare(3, 13) >= 0) {
+        // Python 3.13 encodes the comparison in packed form; map observed
+        // specializations back to standard compare ops.
+        const mapped = {
+            18: AST.ASTCompare.CompareOp.Less,         // guards: n < 0
+            72: AST.ASTCompare.CompareOp.Equal,        // len == N
+            88: AST.ASTCompare.CompareOp.Equal,        // literal == value
+            148: AST.ASTCompare.CompareOp.Greater      // guards: n > 0
+        };
+        arg = mapped[arg] ?? (arg & 0x0F);
+    } else if (this.object.Reader.versionCompare(3, 12) >= 0) {
+        // 3.12 quickened form stores compare op in high nibble
+        arg >>= 4;
+    }
+
+    // Record pattern operation if in pattern matching
+    if (this.inMatchPattern) {
+        this.patternOps.push({
+            type: 'COMPARE',
+            op: arg,
+            left: left,
+            right: right
+        });
+    }
+
+    // Debug: exception match (arg=10)
+    if (arg == 10 && global.g_cliArgs?.debug) {
+        console.log(`[COMPARE_OP] EXCEPTION MATCH at offset ${this.code.Current.Offset}`);
+        console.log(`  left=${left?.constructor.name} ${left?.codeFragment?.() || left}`);
+        console.log(`  right=${right?.constructor.name} ${right?.codeFragment?.() || right}`);
+        console.log(`  Stack depth: ${this.dataStack.length}`);
+    }
+
+    let node = new AST.ASTCompare (left, right, arg);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+}
+
+function handleContainsOpA() {
+    let right = this.dataStack.pop();
+    let left = this.dataStack.pop();
+    // The this.code.Current.Argument will be 0 for 'in' and 1 for 'not in'.
+    let node = new AST.ASTCompare (left, right, this.code.Current.Argument ? AST.ASTCompare.CompareOp.NotIn : AST.ASTCompare.CompareOp.In);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+}
+
+function handleIsOpA() {
+    let right = this.dataStack.pop();
+    let left = this.dataStack.pop();
+    // The this.code.Current.Argument will be 0 for 'is' and 1 for 'is not'.
+    let node = new AST.ASTCompare (left, right, this.code.Current.Argument ? AST.ASTCompare.CompareOp.IsNot : AST.ASTCompare.CompareOp.Is);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+}
+
+module.exports = {
+    handleCompareOpA,
+    handleContainsOpA,
+    handleIsOpA
+};