depyo 1.0.0

package/lib/handlers/pattern_matching.js

@@ -0,0 +1,226 @@
+const AST = require('../ast/ast_node');
+const { flushCurrentCaseBody } = require('./misc_other');
+
+/**
+ * Pattern matching opcodes for match/case statements (Python 3.10+)
+ */
+
+function ensureMatchInitialized(subjectCandidate, options = {}) {
+    const skipStackLookup = options.skipStackLookup || false;
+    if (this.currentMatch) {
+        return;
+    }
+
+    // Prefer subject from stack (TOS-1), fallback to provided candidate or saved potential
+    const stackLen = this.dataStack ? this.dataStack.length : 0;
+    let tosMinusOne = (!skipStackLookup && stackLen >= 2) ? this.dataStack[stackLen - 2] : null;
+    this.matchSubject = subjectCandidate || tosMinusOne;
+
+    if (!this.matchSubject && !skipStackLookup && this.dataStack && this.dataStack.length > 0) {
+        this.matchSubject = this.dataStack.top();
+    }
+
+    if (!this.matchSubject && this.potentialMatchSubject) {
+        this.matchSubject = this.potentialMatchSubject;
+    }
+
+    if (!this.matchSubject) {
+        if (global.g_cliArgs?.debug) {
+            console.log(`[MATCH] Unable to initialize match at offset ${this.code.Current.Offset}: no subject available (stackLen=${this.dataStack?.length || 0})`);
+        }
+        return;
+    }
+
+    this.currentMatch = new AST.ASTMatch(this.matchSubject);
+    this.currentMatch.line = this.code.Current.LineNo;
+    this.matchParentBlock = this.curBlock;
+    this.inMatchPattern = true;
+    this.patternOps = [];
+    if (!this.matchPreNodesStart && this.matchParentBlock) {
+        this.matchPreNodesStart = this.matchParentBlock.nodes.length;
+    }
+
+    if (global.g_cliArgs?.debug) {
+        console.log(`[MATCH] Initialized new ASTMatch at offset ${this.code.Current.Offset} subject=${this.matchSubject?.constructor?.name}`);
+    }
+}
+
+function handleMatchSequence() {
+    // MATCH_SEQUENCE opcode (Python 3.10+)
+    // Tests if TOS is a sequence (tuple, list, etc.) but not str/bytes/bytearray
+    // Stack: TOS = value (copy from COPY 1), TOS1 = subject
+    // IMPORTANT: TOS is NOT popped! Result is pushed on top.
+
+    // If we have an open case and starting a new pattern, flush the previous case first
+    if (this.currentMatch && this.currentCase && !this.inMatchPattern) {
+        if (global.g_cliArgs?.debug) {
+            console.log(`[MATCH_SEQUENCE] Flushing previous case before new pattern at offset ${this.code.Current.Offset}`);
+        }
+        flushCurrentCaseBody.call(this);
+    }
+
+    if (!this.inMatchPattern && this.currentMatch) {
+        this.inMatchPattern = true;
+        this.patternOps = [];
+    }
+
+    let value = this.dataStack.top();  // Peek at the copy (don't pop!)
+
+    if (global.g_cliArgs?.debug) {
+        console.log(`[MATCH_SEQUENCE] at offset ${this.code.Current.Offset}`);
+        console.log(`  currentMatch=${this.currentMatch ? 'active' : 'null'}`);
+        console.log(`  Stack depth=${this.dataStack.length}`);
+    }
+
+    const subjectCandidate = this.dataStack && this.dataStack.length >= 2 ? this.dataStack[this.dataStack.length - 2] : null;
+    ensureMatchInitialized.call(this, subjectCandidate);
+
+    // Mark that we're in pattern checking phase
+    this.inMatchPattern = true;
+    this.patternOps = [];  // Clear pattern operations for new case
+
+    // Record pattern operation
+    this.patternOps.push({type: 'MATCH_SEQUENCE'});
+
+    // Push True to indicate sequence check passed
+    // (In reality, should check type, but for decompilation we assume it passes)
+    let node = new AST.ASTObject(new (require('../PythonObject').PythonObject)("Py_Bool", true));
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+}
+
+function handleGetLen() {
+    // GET_LEN opcode (Python 3.10+)
+    // Pushes len(TOS) onto stack (TOS is not popped)
+    // Used in sequence pattern matching to check length
+
+    let value = this.dataStack.top();
+
+    // Record pattern operation if in pattern matching
+    if (this.inMatchPattern) {
+        this.patternOps.push({type: 'GET_LEN'});
+    }
+
+    // Create len(value) call node
+    // This will be compared with expected length in subsequent COMPARE_OP
+    let lenNode = new AST.ASTCall(
+        new AST.ASTName('len'),
+        [value],
+        []
+    );
+    lenNode.line = this.code.Current.LineNo;
+    this.dataStack.push(lenNode);
+
+    if (global.g_cliArgs?.debug) {
+        console.log(`[GET_LEN] at offset ${this.code.Current.Offset}, value=${value?.constructor.name}`);
+    }
+}
+
+function handleMatchMapping() {
+    // MATCH_MAPPING opcode (Python 3.10+)
+    // Similar to MATCH_SEQUENCE but for mappings (dicts)
+
+    ensureMatchInitialized.call(this, null, {skipStackLookup: true});
+
+    let value = this.dataStack.pop();
+    if (this.inMatchPattern) {
+        this.patternOps.push({type: 'MATCH_MAPPING'});
+    }
+    let node = new AST.ASTObject(new (require('../PythonObject').PythonObject)("Py_Bool", true));
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+
+    if (global.g_cliArgs?.debug) {
+        console.log(`[MATCH_MAPPING] Stub implementation at offset ${this.code.Current.Offset}`);
+    }
+}
+
+function handleMatchClassA() {
+    // MATCH_CLASS_A opcode (Python 3.10+)
+    // Matches object against a class pattern
+
+    let count = this.code.Current.Argument;
+
+    ensureMatchInitialized.call(this, null, {skipStackLookup: true});
+
+    if (!this.inMatchPattern && this.currentMatch) {
+        this.inMatchPattern = true;
+        this.patternOps = [];
+    }
+
+    let attrNames = [];
+    const prevInstr = this.code.Prev;
+    if (prevInstr?.ConstantObject?.ClassName == "Py_Tuple" && prevInstr.ConstantObject.Value) {
+        attrNames = prevInstr.ConstantObject.Value.map(obj => obj?.toString());
+    }
+    let classExpr = this.dataStack?.[this.dataStack.length - 2] || null;
+
+    // Pop class object and subject
+    for (let i = 0; i < count + 1; i++) {
+        this.dataStack.pop();
+    }
+
+    if (this.inMatchPattern) {
+        this.patternOps.push({type: 'MATCH_CLASS', count, attrNames, classExpr});
+    }
+
+    // Push success placeholder
+    let node = new AST.ASTObject(new (require('../PythonObject').PythonObject)("Py_Bool", true));
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+
+    if (global.g_cliArgs?.debug) {
+        console.log(`[MATCH_CLASS] Stub implementation at offset ${this.code.Current.Offset}, count=${count}, inMatch=${this.inMatchPattern}`);
+    }
+}
+
+function handleMatchKeys() {
+    // MATCH_KEYS opcode (Python 3.10+)
+    // Used in mapping patterns
+
+    ensureMatchInitialized.call(this, null, {skipStackLookup: true});
+
+    const keysNode = this.dataStack.pop(); // keys tuple
+    let subject = this.dataStack.top();
+
+    const keys = extractMatchKeys(keysNode);
+    if (this.inMatchPattern) {
+        this.patternOps.push({type: 'MATCH_KEYS', keys});
+    }
+
+    // Push (values_tuple, True) or None
+    let node = new AST.ASTTuple([]);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+
+    if (global.g_cliArgs?.debug) {
+        console.log(`[MATCH_KEYS] Stub implementation at offset ${this.code.Current.Offset}`);
+        if (keys?.length) {
+            console.log(`  keys=${keys.map(k => k.codeFragment().toString()).join(', ')}`);
+        }
+    }
+}
+
+function extractMatchKeys(keysNode) {
+    if (!keysNode) {
+        return [];
+    }
+    if (keysNode instanceof AST.ASTTuple || keysNode instanceof AST.ASTList) {
+        return keysNode.values || [];
+    }
+    if (keysNode instanceof AST.ASTObject) {
+        const obj = keysNode.object;
+        if (["Py_Tuple", "Py_SmallTuple", "Py_List"].includes(obj?.ClassName)) {
+            return (obj.Value || []).map(value => new AST.ASTObject(value));
+        }
+    }
+    return [];
+}
+
+module.exports = {
+    handleMatchSequence,
+    handleGetLen,
+    handleMatchMapping,
+    handleMatchClassA,
+    handleMatchKeys
+};

package/lib/handlers/stack_ops.js

@@ -0,0 +1,280 @@
+const AST = require('../ast/ast_node');
+
+function handleDupTop() {
+    // Track COPY pattern for match detection
+    let prevOpCode = this.code.Prev?.OpCodeID;
+    let prevOffset = this.code.Prev?.Offset;
+
+    // Check if this is COPY after LOAD (potential match start)
+    if (prevOpCode == this.OpCodes.LOAD_FAST_A ||
+        prevOpCode == this.OpCodes.LOAD_NAME_A ||
+        prevOpCode == this.OpCodes.LOAD_GLOBAL_A) {
+
+        // Save subject for later use
+        this.potentialMatchSubject = this.dataStack.top();
+
+        // First COPY after LOAD → potential match candidate
+        if (this.matchCandidateStart === -1) {
+            this.matchCandidateStart = this.code.Current.Offset;
+            this.lastLoadOffset = prevOffset;
+            this.matchParentBlock = this.curBlock;
+            if (!this.matchPreNodesStart) {
+                this.matchPreNodesStart = this.matchParentBlock.nodes.length;
+            }
+
+            if (global.g_cliArgs?.debug) {
+                console.log(`[DUP_TOP] Match candidate at offset ${this.matchCandidateStart}`);
+            }
+
+            // Look ahead to confirm match pattern immediately
+            if (!this.currentMatch && this.lookAheadForMatchPattern()) {
+                this.currentMatch = new AST.ASTMatch(this.potentialMatchSubject);
+                this.currentMatch.line = this.code.Current.LineNo;
+                this.matchParentBlock = this.curBlock;
+                this.inMatchPattern = true;  // Start tracking pattern operations
+                this.patternOps = [];  // Clear for first case
+            }
+        }
+    }
+    // Second COPY without intermediate LOAD → confirm match or start new case!
+    else if (this.matchCandidateStart > 0 &&
+             prevOffset > this.lastLoadOffset &&
+             prevOpCode == this.OpCodes.POP_TOP) {
+
+        // This COPY has no LOAD before it → reusing same subject
+        // Match patterns only exist in Python 3.10+
+        if (!this.currentMatch && this.potentialMatchSubject &&
+            this.object.Reader.versionCompare(3, 10) >= 0) {
+            // First time - create match (fallback if look-ahead didn't work)
+            this.currentMatch = new AST.ASTMatch(this.potentialMatchSubject);
+            this.currentMatch.line = this.code.Current.LineNo;
+            this.matchParentBlock = this.curBlock;
+            this.inMatchPattern = true;
+            this.patternOps = [];
+            if (!this.matchPreNodesStart) {
+                this.matchPreNodesStart = this.matchParentBlock.nodes.length;
+            }
+
+            this.debug(`[DUP_TOP] MATCH CONFIRMED at offset ${this.code.Current.Offset}! Subject: ${this.potentialMatchSubject?.constructor.name}`);
+        } else if (this.currentMatch) {
+            // Subsequent case in same match - reset pattern tracking
+            this.debug(`[DUP_TOP] Starting new case at offset ${this.code.Current.Offset}`);
+            this.inMatchPattern = true;
+            this.patternOps = [];
+        }
+    }
+
+    if (this.dataStack.top() == null) {
+        this.dataStack.push(null);
+    } else if (this.code.Next?.OpCodeID == this.OpCodes.ROT_THREE) {
+        // double compare case
+        this.skipNextJump = true;
+        this.code.GoNext();
+    } else if (this.dataStack.top() instanceof AST.ASTChainStore) {
+        let chainstore = this.dataStack.pop();
+        this.dataStack.push(this.dataStack.top());
+        this.dataStack.push(chainstore);
+    } else if (this.code.Next?.OpCodeID == this.OpCodes.LOAD_ATTR_A) {
+        // Augmented assign on attribute (a.value += 1)
+        // Don't create ChainStore - just duplicate the value
+        this.dataStack.push(this.dataStack.top());
+    } else {
+        // Check if this is a walrus operator pattern:
+        // DUP_TOP → STORE_* → <not another STORE>
+        let nextOpCode = this.code.Next?.OpCodeID;
+        let isStoreOp = (nextOpCode == this.OpCodes.STORE_NAME_A ||
+                         nextOpCode == this.OpCodes.STORE_FAST_A ||
+                         nextOpCode == this.OpCodes.STORE_GLOBAL_A);
+
+        if (isStoreOp && this.code.Next?.Next) {
+            let afterStoreOpCode = this.code.Next.Next.OpCodeID;
+            let isAnotherStore = (afterStoreOpCode == this.OpCodes.STORE_NAME_A ||
+                                  afterStoreOpCode == this.OpCodes.STORE_FAST_A ||
+                                  afterStoreOpCode == this.OpCodes.STORE_GLOBAL_A ||
+                                  afterStoreOpCode == this.OpCodes.STORE_ATTR_A ||
+                                  afterStoreOpCode == this.OpCodes.STORE_DEREF_A);
+
+            if (!isAnotherStore) {
+                // This is a walrus operator (named expression)
+                // Don't duplicate - just set flag. The value will be wrapped in ASTNamedExpr.
+                this.isWalrusOperator = true;
+                return;
+            }
+        }
+
+        // If next opcode is NOT a store operation, this is just a temporary copy
+        // (e.g., for match/case pattern matching) - don't create ChainStore
+        if (!isStoreOp) {
+            this.dataStack.push(this.dataStack.top());
+            return;
+        }
+
+        // Regular chained assignment (a = b = 10)
+        this.dataStack.push(this.dataStack.top());
+        let node = new AST.ASTChainStore ([], this.dataStack.top());
+        this.dataStack.push(node);
+    }
+}
+
+function handleCopyA() {
+    // COPY opcode (Python 3.11+): copies the i-th item to the top of the stack
+    // Argument specifies which item: 1 = top, 2 = second, etc.
+    let depth = this.code.Current.Argument;
+
+    // Save potential match subject for COPY 1 (like DUP_TOP)
+    if (depth == 1) {
+        let prevOpCode = this.code.Prev?.OpCodeID;
+        if (prevOpCode == this.OpCodes.LOAD_FAST_A ||
+            prevOpCode == this.OpCodes.LOAD_NAME_A ||
+            prevOpCode == this.OpCodes.LOAD_GLOBAL_A) {
+            this.potentialMatchSubject = this.dataStack.top();
+            if (global.g_cliArgs?.debug) {
+                console.log(`[COPY] Saved potential match subject: ${this.potentialMatchSubject?.constructor.name}`);
+            }
+        }
+
+        // COPY 1 is equivalent to DUP_TOP - same walrus detection logic
+        handleDupTop.call(this);
+    } else {
+        // For other depths, just copy the item
+        let index = this.dataStack.length - depth;
+        if (index >= 0 && index < this.dataStack.length) {
+            this.dataStack.push(this.dataStack[index]);
+        }
+    }
+}
+
+function handleDupTopTwo() {
+    let first = this.dataStack.pop();
+    let second = this.dataStack.top();
+
+    this.dataStack.push(first);
+    this.dataStack.push(second);
+    this.dataStack.push(first);
+}
+
+function handleDupTopxA() {
+    let first = [];
+    let second = [];
+
+    for (let idx = 0; idx < this.code.Current.Argument; idx++) {
+        let node = this.dataStack.pop();
+        first.push(node);
+        second.push(node);
+    }
+
+    while (first.length) {
+        this.dataStack.push(first.pop());
+    }
+
+    while (second.length) {
+        this.dataStack.push(second.pop());
+    }
+}
+
+function handleSwapA() {
+    // Python 3.11+ SWAP opcode: swaps i-th item with TOS
+    // Argument specifies depth: 2 = swap top 2, 3 = swap TOS with 3rd, etc.
+    let depth = this.code.Current.Argument;
+
+    // Record pattern operation if in pattern matching
+    if (this.inMatchPattern) {
+        this.patternOps.push({
+            type: 'SWAP',
+            depth: depth
+        });
+    }
+
+    if (depth == 2) {
+        // SWAP 2: swap top two items
+        handleRotTwo.call(this);
+    } else if (depth == 3) {
+        // SWAP 3: swap TOS with third item
+        let one = this.dataStack.pop();
+        let two = this.dataStack.pop();
+        let three = this.dataStack.pop();
+
+        this.dataStack.push(one);
+        this.dataStack.push(two);
+        this.dataStack.push(three);
+    } else {
+        // General case: swap TOS with i-th item
+        let tos = this.dataStack.pop();
+        let index = this.dataStack.length - (depth - 1);
+        if (index >= 0) {
+            let temp = this.dataStack[index];
+            this.dataStack[index] = tos;
+            this.dataStack.push(temp);
+        }
+    }
+}
+
+function handleRotTwo() {
+    let one = this.dataStack.pop();
+    if (this.dataStack.top() instanceof AST.ASTChainStore) {
+        this.dataStack.pop();
+    }
+    let two = this.dataStack.pop();
+
+    this.dataStack.push(one);
+    this.dataStack.push(two);
+}
+
+function handleRotThree() {
+        let one = this.dataStack.pop();
+        let two = this.dataStack.pop();
+        if (this.dataStack.top() instanceof AST.ASTChainStore) {
+            this.dataStack.pop();
+        }
+        let three = this.dataStack.pop();
+        this.dataStack.push(one);
+        this.dataStack.push(three);
+        this.dataStack.push(two);
+    }
+
+function handleRotFour() {
+    let one = this.dataStack.pop();
+    let two = this.dataStack.pop();
+    let three = this.dataStack.pop();
+    if (this.dataStack.top() instanceof AST.ASTChainStore) {
+        this.dataStack.pop();
+    }
+    let four = this.dataStack.pop();
+    this.dataStack.push(one);
+    this.dataStack.push(four);
+    this.dataStack.push(three);
+    this.dataStack.push(two);
+}
+
+function handlePushNull() {
+    this.dataStack.push(null);
+}
+
+function handleCache() {
+    /* These "fake" opcodes are used as placeholders for optimizing
+       certain opcodes in Python 3.11+.  Since we have no need for
+       that during disassembly/decompilation, we can just treat these
+       as no-ops. */
+}
+
+function handleNop() {}
+
+function handleStopCode() {
+    // Early Python STOP_CODE opcode: terminate processing of instruction stream.
+    this.code.CurrentInstructionIndex = this.code.Instructions.length;
+}
+
+module.exports = {
+    handleDupTop,
+    handleCopyA,
+    handleDupTopTwo,
+    handleDupTopxA,
+    handleSwapA,
+    handleRotTwo,
+    handleRotThree,
+    handleRotFour,
+    handlePushNull,
+    handleCache,
+    handleNop,
+    handleStopCode
+};