depyo 1.0.0

package/lib/handlers/subscript_slice.js

@@ -0,0 +1,394 @@
+const AST = require('../ast/ast_node');
+
+function handleBinarySubscr()
+{
+    let subscr = this.dataStack.pop();
+    let src = this.dataStack.pop();
+    let node = new AST.ASTSubscr(src, subscr);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+}
+
+function handleMapAddA() {
+    // MAP_ADD: add key/value pair to dict under construction
+    // Stack (TOS at right): ... , map, key, value
+    let value = this.dataStack.pop();
+    let key = this.dataStack.pop();
+
+    // Check if this is a dict comprehension
+    if (this.curBlock.blockType == AST.ASTBlock.BlockType.For && this.curBlock.comprehension) {
+        this.dataStack.pop(); // Pop the empty map
+        let node = new AST.ASTComprehension(value, key);
+        node.line = this.code.Current.LineNo;
+        node.kind = AST.ASTComprehension.DICT;
+        this.dataStack.push(node);
+        return;
+    }
+
+    let mapNode = this.dataStack.pop();
+
+    if (!(mapNode instanceof AST.ASTMap)) {
+        // Initialize a map literal if we didn't have one
+        mapNode = new AST.ASTMap([]);
+    }
+
+    mapNode.add(key, value);
+    mapNode.line = this.code.Current.LineNo;
+    this.dataStack.push(mapNode);
+}
+
+function handleStoreMap() {
+    handleBuildSliceA.call(this);
+}
+
+function handleBuildSliceA() {
+    if (this.code.Current.Argument == 2) {
+        let end = this.dataStack.pop();
+        let start = this.dataStack.pop();
+
+        if (start instanceof AST.ASTObject && (start.object == null || start.object.ClassName == 'Py_None')) {
+            start = null;
+        }
+
+        if (end instanceof AST.ASTObject && (end.object == null || end.object.ClassName == 'Py_None')) {
+            end = null;
+        }
+
+        let sliceOp = null;
+        if (!start && !end) {
+            sliceOp = AST.ASTSlice.SliceOp.Slice0;
+        } else if (!start) {
+            sliceOp = AST.ASTSlice.SliceOp.Slice2;
+        } else if (!end) {
+            sliceOp = AST.ASTSlice.SliceOp.Slice1;
+        } else {
+            sliceOp = AST.ASTSlice.SliceOp.Slice3;
+        }
+
+        let mapNode = new AST.ASTSlice(sliceOp, start || new AST.ASTNone(), end || new AST.ASTNone());
+        mapNode.line = this.code.Current.LineNo;
+        this.dataStack.push(mapNode);
+    } else if (this.code.Current.Argument == 3) {
+        let step = this.dataStack.pop();
+        let end = this.dataStack.pop();
+        let start = this.dataStack.pop();
+
+        if (start instanceof AST.ASTObject && (start.object == null || start.object.ClassName == 'Py_None')) {
+            start = null;
+        }
+
+        if (end instanceof AST.ASTObject && (end.object == null || end.object.ClassName == 'Py_None')) {
+            end = null;
+        }
+
+        if (step instanceof AST.ASTObject && (step.object == null || step.object.ClassName == 'Py_None')) {
+            step = null;
+        }
+
+        let sliceOp = null;
+        if (!start && !end) {
+            sliceOp = AST.ASTSlice.SliceOp.Slice0;
+        } else if (!start) {
+            sliceOp = AST.ASTSlice.SliceOp.Slice2;
+        } else if (!end) {
+            sliceOp = AST.ASTSlice.SliceOp.Slice1;
+        } else {
+            sliceOp = AST.ASTSlice.SliceOp.Slice3;
+        }
+
+        let lhs = new AST.ASTSlice(sliceOp, start || new AST.ASTNone(), end || new AST.ASTNone());
+        lhs.line = this.code.Current.LineNo;
+
+        if (!step) {
+            sliceOp = AST.ASTSlice.SliceOp.Slice1;
+        } else {
+            sliceOp = AST.ASTSlice.SliceOp.Slice3;
+        }
+
+        let sliceNode = new AST.ASTSlice(sliceOp, start || new AST.ASTNone(), end || new AST.ASTNone());
+        sliceNode.line = this.code.Current.LineNo;
+        this.dataStack.push(sliceNode);
+    }
+}
+
+function handleDeleteSlice0() {
+    if (this.code.Current?.InstructionName === 'NOT_TAKEN') {
+        if (global.g_cliArgs?.debug) {
+            console.log(`[NOT_TAKEN] skipping instrumentation hint at offset ${this.code.Current.Offset}`);
+        }
+        return;
+    }
+    let name = this.dataStack.pop();
+    let node = new AST.ASTDelete(new AST.ASTSubscr(name, new AST.ASTSlice(AST.ASTSlice.SliceOp.Slice0)));
+    node.line = this.code.Current.LineNo;
+    this.curBlock.nodes.push(node);
+}
+
+function handleDeleteSlice1() {
+    let upper = this.dataStack.pop();
+    let name = this.dataStack.pop();
+
+    let node = new AST.ASTDelete(new AST.ASTSubscr(name, new AST.ASTSlice(AST.ASTSlice.SliceOp.Slice1, upper)));
+    node.line = this.code.Current.LineNo;
+    this.curBlock.nodes.push(node);
+}
+
+function handleDeleteSlice2() {
+    let lower = this.dataStack.pop();
+    let name = this.dataStack.pop();
+
+    let node = new AST.ASTDelete(new AST.ASTSubscr(name, new AST.ASTSlice(AST.ASTSlice.SliceOp.Slice2, lower)));
+    node.line = this.code.Current.LineNo;
+    this.curBlock.nodes.push(node);
+}
+
+function handleDeleteSlice3() {
+    let lower = this.dataStack.pop();
+    let upper = this.dataStack.pop();
+    let name = this.dataStack.pop();
+
+    let node = new AST.ASTDelete(new AST.ASTSubscr(name, new AST.ASTSlice(AST.ASTSlice.SliceOp.Slice3, upper, lower)));
+    node.line = this.code.Current.LineNo;
+    this.curBlock.nodes.push(node);
+}
+
+function handleDeleteSubscr() {
+    let key = this.dataStack.pop();
+    let name = this.dataStack.pop();
+
+    let node = new AST.ASTDelete(new AST.ASTSubscr(name, key));
+    node.line = this.code.Current.LineNo;
+    this.curBlock.nodes.push(node);
+}
+
+function handleSlice0() {
+    let name = this.dataStack.pop();
+    if (name instanceof AST.ASTChainStore) {
+        name = name.source;
+    }
+
+    let sliceNode = new AST.ASTSlice (AST.ASTSlice.SliceOp.Slice0);
+    let node = new AST.ASTSubscr (name, sliceNode);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+}
+
+function handleSlice1() {
+    let lower = this.dataStack.pop();
+    let name = this.dataStack.pop();
+
+    let sliceNode = new AST.ASTSlice(AST.ASTSlice.SliceOp.Slice1, lower);
+    let node = new AST.ASTSubscr(name, sliceNode);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+}
+
+function handleSlice2() {
+    let upper = this.dataStack.pop();
+    let name = this.dataStack.pop();
+
+    let sliceNode = new AST.ASTSlice(AST.ASTSlice.SliceOp.Slice2, null, upper);
+    let node = new AST.ASTSubscr(name, sliceNode);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);    
+}
+
+function handleSlice3() {
+    let upper = this.dataStack.pop();
+    let lower = this.dataStack.pop();
+    let name = this.dataStack.pop();
+
+    let sliceNode = new AST.ASTSlice(AST.ASTSlice.SliceOp.Slice3, lower, upper);
+    let node = new AST.ASTSubscr(name, sliceNode);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);    
+}
+
+function handleStoreSlice0() {
+    let destNode = this.dataStack.pop();
+    let valueNode = this.dataStack.pop();
+    let node = new AST.ASTStore(valueNode,
+                    new AST.ASTSubscr(destNode,
+                        new AST.ASTSlice(AST.ASTSlice.SliceOp.Slice0)
+                    )
+                );
+    node.line = this.code.Current.LineNo;
+    this.curBlock.append(node);
+}
+
+function handleStoreSlice1() {
+    let upper = this.dataStack.pop();
+    let dest = this.dataStack.pop();
+    let value = this.dataStack.pop();
+    let node = new AST.ASTStore(value,
+        new AST.ASTSubscr(dest,
+            new AST.ASTSlice(AST.ASTSlice.SliceOp.Slice1, upper)
+        )
+    );
+    node.line = this.code.Current.LineNo;
+    this.curBlock.append(node);
+}
+
+function handleStoreSlice2() {
+    let lowerNode = this.dataStack.pop();
+    let destNode = this.dataStack.pop();
+    let valueNode = this.dataStack.pop();
+    let node = new AST.ASTStore(valueNode,
+        new AST.ASTSubscr(destNode,
+            new AST.ASTSlice(AST.ASTSlice.SliceOp.Slice2, null, lowerNode)));
+    node.line = this.code.Current.LineNo;
+    this.curBlock.append(node);
+}
+
+function handleStoreSlice3() {
+    let lowerNode = this.dataStack.pop();
+    let upperNode = this.dataStack.pop();
+    let destNode = this.dataStack.pop();
+    let valueNode = this.dataStack.pop();
+    let node = new AST.ASTStore(valueNode,
+        new AST.ASTSubscr(destNode,
+            new AST.ASTSlice(AST.ASTSlice.SliceOp.Slice3, upperNode, lowerNode)));
+    node.line = this.code.Current.LineNo;
+    this.curBlock.append(node);
+}
+
+function getAnnotationTargetName(node) {
+    if (!node) {
+        return null;
+    }
+    if (node instanceof AST.ASTName) {
+        return node.name;
+    }
+    if (node instanceof AST.ASTObject) {
+        let value = node.object?.Value;
+        if (value !== undefined && value !== null) {
+            return value.toString();
+        }
+    }
+    let fragment = node.codeFragment?.();
+    if (!fragment) {
+        return null;
+    }
+    fragment = fragment.toString ? fragment.toString() : fragment;
+    if (typeof fragment !== 'string') {
+        return null;
+    }
+    const trimmed = fragment.trim();
+    if ((trimmed.startsWith("'") && trimmed.endsWith("'")) ||
+        (trimmed.startsWith('"') && trimmed.endsWith('"'))) {
+        return trimmed.substring(1, trimmed.length - 1);
+    }
+    return trimmed;
+}
+
+function storeMatchesAnnotation(storeNode, annotationKeyNode) {
+    if (!(storeNode instanceof AST.ASTStore)) {
+        return false;
+    }
+    const annotationName = getAnnotationTargetName(annotationKeyNode);
+    if (!annotationName) {
+        return false;
+    }
+
+    const dest = storeNode.dest;
+    if (dest instanceof AST.ASTName) {
+        return dest.name === annotationName;
+    }
+    return false;
+}
+
+function handleStoreSubscr() {
+    if (this.unpack) {
+        let subscrNode = this.dataStack.pop();
+        let destNode = this.dataStack.pop();
+
+        let saveNode = new AST.ASTSubscr(destNode, subscrNode);
+
+        let tupleNode = this.dataStack.top();
+        if (tupleNode instanceof AST.ASTTuple)
+            tupleNode.add(saveNode);
+        else if (global.g_cliArgs?.debug)
+            console.error("Something TERRIBLE happened!\n");
+
+        if (--this.unpack <= 0) {
+            this.dataStack.pop();
+            let seqNode = this.dataStack.pop();
+            if (seqNode instanceof AST.ASTChainStore) {
+                seqNode.line = this.code.Current.LineNo;
+                this.append_to_chain_store(seqNode, tupleNode);
+            } else {
+                let node = new AST.ASTStore(seqNode, tupleNode);
+                node.line = this.code.Current.LineNo;
+                this.curBlock.append(node);
+            }
+        }
+    } else {
+        let subscrNode = this.dataStack.pop();
+        let destNode = this.dataStack.pop();
+        let srcNode = this.dataStack.pop();
+
+        // If variable annotations are enabled, we'll need to check for them here.
+        // Python handles a varaible annotation by setting:
+        // __annotations__['var-name'] = type
+        let found_annotated_var = (this.variable_annotations && destNode instanceof AST.ASTName
+            && destNode.name == "__annotations__");
+
+        if (found_annotated_var) {
+            // Annotations can be done alone or as part of an assignment.
+            // In the case of an assignment, we'll see a NODE_STORE on the this.dataStack.
+            if (!this.curBlock.nodes.empty()) {
+                // Replace the existing NODE_STORE with a new one that includes the annotation.
+                let store = this.curBlock.nodes.top();
+                if (store instanceof AST.ASTStore && storeMatchesAnnotation(store, subscrNode)) {
+                    this.curBlock.removeLast();
+                    let node = new AST.ASTStore(store.src,
+                        new AST.ASTAnnotatedVar(subscrNode, srcNode)
+                    );
+                    node.line = this.code.Current.LineNo;
+                    this.curBlock.append(node);
+                } else {
+                    let node = new AST.ASTAnnotatedVar(subscrNode, srcNode);
+                    node.line = this.code.Current.LineNo;
+                    this.curBlock.append(node);
+                }
+            } else {
+                let node = new AST.ASTAnnotatedVar(subscrNode, srcNode);
+                node.line = this.code.Current.LineNo;
+                this.curBlock.append(node);
+            }
+        } else {
+            if (destNode instanceof AST.ASTMap) {
+                destNode.add(subscrNode, srcNode);
+            } else if (srcNode instanceof AST.ASTChainStore) {
+                this.append_to_chain_store(srcNode, new AST.ASTSubscr(destNode, subscrNode));
+            } else {
+                let node = new AST.ASTStore(srcNode,
+                    new AST.ASTSubscr(destNode, subscrNode)
+                );
+                node.line = this.code.Current.LineNo;
+                this.curBlock.append(node);
+            }
+        }
+    }
+}
+
+module.exports = {
+    handleBinarySubscr,
+    handleMapAddA,
+    handleStoreMap,
+    handleBuildSliceA,
+    handleDeleteSlice0,
+    handleDeleteSlice1,
+    handleDeleteSlice2,
+    handleDeleteSlice3,
+    handleDeleteSubscr,
+    handleSlice0,
+    handleSlice1,
+    handleSlice2,
+    handleSlice3,
+    handleStoreSlice0,
+    handleStoreSlice1,
+    handleStoreSlice2,
+    handleStoreSlice3,
+    handleStoreSubscr,
+};

package/lib/handlers/unary_ops.js

@@ -0,0 +1,91 @@
+const AST = require('../ast/ast_node');
+
+function handleUnaryCall() {
+    let funcNode = this.dataStack.pop();
+    let node = new AST.ASTCall(funcNode, [], []);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+}
+
+function handleConvertValueA() {
+    // Python 3.14 CONVERT_VALUE: capture requested conversion for upcoming FORMAT_*.
+    const val = this.dataStack.pop();
+    const flag = this.code.Current.Argument;
+    let conversion = AST.ASTFormattedValue.ConversionFlag.None;
+
+    if (flag === 1) {
+        conversion = AST.ASTFormattedValue.ConversionFlag.Str;
+    } else if (flag === 2) {
+        conversion = AST.ASTFormattedValue.ConversionFlag.Repr;
+    } else if (flag === 3) {
+        conversion = AST.ASTFormattedValue.ConversionFlag.ASCII;
+    }
+
+    let node;
+    if (val instanceof AST.ASTFormattedValue) {
+        val.m_conversion = conversion;
+        node = val;
+    } else {
+        node = new AST.ASTFormattedValue(val, conversion, null);
+        node.line = this.code.Current.LineNo;
+    }
+    this.dataStack.push(node);
+}
+
+function handleUnaryConvert() {
+    let name = this.dataStack.pop();
+    let node = new AST.ASTConvert(name);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+}
+
+function handleUnaryInvert() {
+    let arg = this.dataStack.pop();
+    let node = new AST.ASTUnary(arg, AST.ASTUnary.UnaryOp.Invert);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);    
+}
+
+function handleUnaryNegative() {
+    let arg = this.dataStack.pop();
+    let node = new AST.ASTUnary(arg, AST.ASTUnary.UnaryOp.Negative);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);    
+}
+
+function handleUnaryNot() {
+    let arg = this.dataStack.pop();
+    let node = new AST.ASTUnary(arg, AST.ASTUnary.UnaryOp.Not);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);    
+}
+
+function handleUnaryPositive() {
+    let arg = this.dataStack.pop();
+    let node = new AST.ASTUnary(arg, AST.ASTUnary.UnaryOp.Positive);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);    
+}
+
+function handleToBool() {
+    // Python 3.13+ TO_BOOL: normalize truthiness. Preserve stack value.
+    const arg = this.dataStack.pop();
+    this.dataStack.push(arg);
+}
+
+function handleExitInitCheck() {
+    // Python 3.14 EXIT_INIT_CHECK: no-op for decompiler.
+}
+
+
+module.exports = {
+    handleUnaryCall,
+    handleConvertValueA,
+    handleUnaryConvert,
+    handleUnaryInvert,
+    handleUnaryNegative,
+    handleUnaryNot,
+    handleUnaryPositive,
+    handleToBool,
+    handleExitInitCheck
+};

package/lib/handlers/unpack.js

@@ -0,0 +1,141 @@
+const PycObject = require('../PythonObject').PythonObject;
+const AST = require('../ast/ast_node');
+
+function handleUnpackListA() {
+    processUnpack.call(this);
+}
+
+function handleUnpackTupleA() {
+    processUnpack.call(this);
+}
+
+function handleUnpackSequenceA() {
+    processUnpack.call(this);
+}
+
+function processUnpack() {
+    this.unpack = this.code.Current.Argument;
+
+    // Record pattern operation if in pattern matching
+    if (this.inMatchPattern) {
+        this.patternOps.push({
+            type: 'UNPACK_SEQUENCE',
+            count: this.unpack
+        });
+    }
+
+    if (this.unpack > 0) {
+        let node = new AST.ASTTuple([]);
+        node.line = this.code.Current.LineNo;
+        this.dataStack.push(node);
+    } else {
+        // Unpack zero values and assign it to top of stack or for loop variable.
+        // E.g. [] = TOS / for [] in X
+        let tupleNode = new AST.ASTTuple([]);
+        if (this.curBlock.blockType == AST.ASTBlock.BlockType.For
+            && !this.curBlock.inited) {
+            tupleNode.requireParens = true;
+            this.curBlock.index = tupleNode;
+        } else if (this.dataStack.top() instanceof AST.ASTChainStore) {
+            let chainStore = this.dataStack.pop();
+            chainStore.line = this.code.Current.LineNo;
+            this.append_to_chain_store(chainStore, tupleNode);
+        } else {
+            let node = new AST.ASTStore(this.dataStack.pop(), tupleNode);
+            node.line = this.code.Current.LineNo;
+            this.curBlock.append(node);
+        }
+    }
+}
+
+function handleUnpackArgA() {
+    let data = this.dataStack.pop();
+    this.object.ArgCount = this.code.Current.Argument;
+    for (let idx = 0; idx < this.code.Current.Argument; idx++) {                                
+        this.object.VarNames.Value.push(data[idx]);
+    }
+    this.code.GoNext(this.code.Current.Argument);
+}
+
+function handleUnpackExA() {
+    this.unpack = (this.code.Current.Argument & 0xFF);
+    this.starPos = this.unpack;
+    this.unpack += 1 + (this.code.Current.Argument >> 8) & 0xFF;
+
+    let source = this.dataStack.pop();
+    let tuple = new AST.ASTTuple([]);
+    tuple.requireParens = false;
+    this.dataStack.push(new PycObject("Py_Null"));
+    this.dataStack.push(new AST.ASTChainStore([], source));
+    this.dataStack.push(tuple);
+}
+
+function handleBuildListUnpackA() {
+    processBuild.call(this);
+}
+
+function handleBuildTupleUnpackA() {
+    processBuild.call(this);
+}
+
+function handleBuildTupleUnpackWithCallA() {
+    // Python 3.6+ - same as BUILD_TUPLE_UNPACK but with better error messages
+    processBuild.call(this);
+}
+
+function processBuild() {
+    let values = [];
+    for (let idx = 0; idx < this.code.Current.Argument; idx++) {
+        values.unshift(this.dataStack.pop());
+    }
+    let listNode = new AST.ASTList(values); // Or ASTTuple based on opcode
+    this.dataStack.push(listNode);
+}
+
+function handleBuildSetUnpackA() {
+    let values = [];
+    for (let idx = 0; idx < this.code.Current.Argument; idx++) {
+        values.unshift(this.dataStack.pop());
+    }
+    let setNode = new AST.ASTSet(values);
+    this.dataStack.push(setNode);
+}
+
+function handleBuildMapUnpackA() {
+    processBuildMapUnpack.call(this);
+}
+
+function handleBuildMapUnpackWithCallA() {
+    processBuildMapUnpack.call(this);
+}
+
+function processBuildMapUnpack() {
+    let mapNode = new AST.ASTMap();
+    for (let idx = 0; idx < this.code.Current.Argument; idx++) {
+        let pair = this.dataStack.pop(); // Should be a dictionary
+        if (pair instanceof AST.ASTMap) {
+            for (const entry of pair.values) {
+                mapNode.add(entry.key, entry.value);
+            }
+        } else {
+            if (global.g_cliArgs?.debug) {
+                console.error("Expected a map for BUILD_MAP_UNPACK");
+            }
+        }
+    }
+    this.dataStack.push(mapNode);
+}
+
+module.exports = {
+    handleUnpackListA,
+    handleUnpackTupleA,
+    handleUnpackSequenceA,
+    handleUnpackArgA,
+    handleUnpackExA,
+    handleBuildListUnpackA,
+    handleBuildTupleUnpackA,
+    handleBuildTupleUnpackWithCallA,
+    handleBuildSetUnpackA,
+    handleBuildMapUnpackA,
+    handleBuildMapUnpackWithCallA
+};

package/lib/stack_history.js

@@ -0,0 +1,63 @@
+
+function classSaver(key, value) {
+    if (value && typeof(value) == "object") {
+        value.___serialized__class_name = value.constructor.name;
+        return value;
+    }
+    return value;
+}
+
+function restoreObjectPrototype(obj) {
+    if (obj) {
+        for (let subObject of Object.values(obj)) {
+            if (subObject && typeof(subObject) == "object") {
+                restoreObjectPrototype(subObject);
+                if (subObject.___serialized__class_name) {
+                    Object.setPrototypeOf(subObject, global[subObject.___serialized__class_name]);
+                    delete subObject.___serialized__class_name;
+                    subObject = subObject;
+                }
+            }
+        }
+    }    
+}
+
+class StackHistory {
+    history = [];
+
+    push(historyElement) {
+        this.history.push(JSON.stringify(historyElement, classSaver));
+    }
+
+    top() {
+        if (this.history.length == 0) {
+            return [];
+        }
+        try {
+            let value = JSON.parse(this.history[this.history.length - 1]);
+            restoreObjectPrototype(value);
+            return value;
+        } catch (ex) {
+            return [];
+        }
+    }
+
+    pop() {
+        let stack = this.top();
+        this.history.pop();
+        return stack;
+    }
+    get length() {
+        return this.history.length;
+    }
+
+    set length(value) {
+        this.history.length = value;
+    }
+
+    empty() {
+        return this.history.length == 0;
+    }
+}
+
+module.exports = StackHistory;