depyo 1.0.2 → 1.1.0

package/depyo.js

@@ -22,6 +22,7 @@ global.g_cliArgs = {
     sendToStdout: false,
     marshal: false,
     marshalScan: false,
+    strict: false,
     pyVersion: null,
     silent: false,
     fileExt: 'py',
@@ -29,6 +30,8 @@ global.g_cliArgs = {
     filenames: []
 };
 
+let g_dirtyFiles = [];   // Files where decompiler caught at least one opcode exception.
+
 let g_totalInThroughput = 0;
 let g_totalOutThroughput = 0;
 let g_totalExecTime = 0;
@@ -51,6 +54,7 @@ Options:
   --out               Print decompiled source to stdout instead of files
   --marshal           Treat input as raw marshalled data (no .pyc header)
   --marshal-scan      Fast scan of marshal blobs (no decompile, prints version)
+  --strict            Re-throw on first opcode handler exception (default: log + continue + non-zero exit)
   --py-version <x.y>  Python bytecode version hint (auto-scan if omitted)
   --basedir <path>    Output base directory (default: alongside input)
   --file-ext <ext>    Extension for generated source (default: py)
@@ -83,6 +87,8 @@ function parseCLIParams() {
         } else if (cliParam.toLowerCase() == "--marshal-scan" || cliParam.toLowerCase() == "--marshal-smoke") {
             g_cliArgs.marshalScan = true;
             g_cliArgs.marshal = true;
+        } else if (cliParam.toLowerCase() == "--strict") {
+            g_cliArgs.strict = true;
         } else if (cliParam.toLowerCase() == "--py-version") {
             g_cliArgs.pyVersion = process.argv[++idx];
         } else if (cliParam.toLowerCase() == "--basedir") {
@@ -341,9 +347,33 @@ function decompilePycObject(data) {
             let genStartTS = process.hrtime.bigint();
             let decompiler = new PycDecompiler(obj);
             let ast = decompiler.decompile();
-            let pycResult = ast.codeFragment();
-            pySrc = pycResult.toString();
+            let renderError = null;
+            try {
+                let pycResult = ast.codeFragment();
+                pySrc = pycResult.toString();
+            } catch (ex) {
+                if (g_cliArgs.strict) throw ex;
+                renderError = ex;
+                decompiler.errors.push({
+                    opcode: 'RENDER',
+                    codeObject: obj?.Name?.toString?.() || '<root>',
+                    message: ex.message,
+                    stack: ex.stack
+                });
+                decompiler.cleanBuild = false;
+                pySrc = `# DECOMPILER ERROR: codeFragment() threw: ${ex.message}\n`;
+                if (!g_cliArgs.silent) {
+                    console.error(`RENDER EXCEPTION in '${obj?.Name}': ${ex.message}`);
+                    if (g_cliArgs.debug) console.error(ex.stack);
+                }
+            }
             genSecs = Number(process.hrtime.bigint() - genStartTS) / 1000000000;
+            if (!decompiler.cleanBuild) {
+                g_dirtyFiles.push({
+                    file: typeof data === 'string' ? data : (obj?.FileName || '<buffer>'),
+                    errors: decompiler.errors.length
+                });
+            }
         }
         if (!pySrc.endsWith("\n")) {
             pySrc += "\n";
@@ -434,3 +464,14 @@ if (!g_cliArgs.sendToStdout) {
     const outRate = (g_totalOutThroughput / g_totalExecTime).toFixed(2);
     console.log(`Processed ${g_totalFiles} files in ${g_totalExecTime.toFixed(3)}s. In: ${g_totalInThroughput} bytes (${inRate} B/s). Out: ${g_totalOutThroughput} bytes (${outRate} B/s).`);
 }
+
+if (g_dirtyFiles.length > 0) {
+    console.error(`\nDirty decompile: ${g_dirtyFiles.length} file(s) had handler exceptions (output may be partial):`);
+    for (const d of g_dirtyFiles.slice(0, 20)) {
+        console.error(`  - ${d.file}  (${d.errors} opcode error${d.errors === 1 ? '' : 's'})`);
+    }
+    if (g_dirtyFiles.length > 20) {
+        console.error(`  ... and ${g_dirtyFiles.length - 20} more`);
+    }
+    process.exit(1);
+}

package/lib/OpCodes.js

@@ -329,6 +329,9 @@ class OpCodes
     static LOAD_ZERO_SUPER_ATTR_A = 319;           // Python 3.13+ zero-cost super attr
     static LOAD_ZERO_SUPER_METHOD_A = 320;         // Python 3.13+ zero-cost super method
 
+    // Python 3.15 new opcodes
+    static TRACE_RECORD_A = 321;                   // Python 3.15 ->           trace recording (ignore)
+
 
     // enum cmp_op
     // {
@@ -391,7 +394,7 @@ class OpCodes
 
         if (reader.versionCompare(3, 6) >= 0) {
             while (opCodeID == OpCodes.EXTENDED_ARG_A) {
-                argument = argument | code[++opOffset] << 8;
+                argument = (argument << 8) | code[++opOffset];
                 opCodeID = this.GetOpCodeID(code, ++opOffset);
 
                 // Break if we hit end of bytecode
@@ -401,9 +404,15 @@ class OpCodes
             }
             argument <<= 8;
         } else {
+            // Pre-3.6: EXTENDED_ARG carries a 16-bit operand that becomes
+            // the upper 16 bits of the next instruction's argument. After
+            // reading both operand bytes we must advance opOffset one more
+            // step so the caller lands on the real opcode (not the trailing
+            // operand byte of EXTENDED_ARG).
             if (opCodeID == OpCodes.EXTENDED_ARG_A) {
                 argument = code[++opOffset] | code[++opOffset] << 8;
                 argument <<= 16;
+                opOffset++;
             }
         }
 
@@ -522,10 +531,18 @@ class OpCodes
                         opCode.Name = this.CodeObject.Names.Value[opCode.Argument].toString();
                     }
                 } else if (opCode.HasFree) {
-                    if (opCode.Argument < this.CodeObject.CellVars.Value.length) {
-                        opCode.FreeName = this.CodeObject.CellVars.Value[opCode.Argument].toString();
-                    } else if ((opCode.Argument - this.CodeObject.CellVars.Value.length) < this.CodeObject.FreeVars.Value.length) {
-                        opCode.FreeName = this.CodeObject.FreeVars.Value[opCode.Argument - this.CodeObject.CellVars.Value.length].toString();
+                    // 3.11+ stores cells/frees inside localsplus, so the opcode argument
+                    // is an index into [locals | cells | frees]. Strip the locals prefix
+                    // before looking up into the split CellVars/FreeVars tuples.
+                    const isNewLayout = this.CodeObject.Reader?.versionCompare?.(3, 11) >= 0;
+                    const localsLen = isNewLayout ? (this.CodeObject.VarNames?.Value?.length ?? 0) : 0;
+                    const freeIdx = opCode.Argument - localsLen;
+                    const cellLen = this.CodeObject.CellVars?.Value?.length ?? 0;
+                    const freeLen = this.CodeObject.FreeVars?.Value?.length ?? 0;
+                    if (freeIdx >= 0 && freeIdx < cellLen) {
+                        opCode.FreeName = this.CodeObject.CellVars.Value[freeIdx].toString();
+                    } else if (freeIdx >= cellLen && (freeIdx - cellLen) < freeLen) {
+                        opCode.FreeName = this.CodeObject.FreeVars.Value[freeIdx - cellLen].toString();
                     } else {
                         opCode.FreeName = `##FREEVAR_${opCode.Argument}##`;
                     }