Add Python 3.14 opcode support and 3.11+ zero-cost exception decompilation

Extend the decompiler to handle Python 3.14 bytecode and reconstruct
try/except/finally from the zero-cost exception model introduced in 3.11.

Python 3.14:
- Update the 3.14 magic number and remap opcodes to their argument-bearing
  forms (LOAD_FAST_BORROW, LOAD_COMMON_CONSTANT, LOAD_SPECIAL,
  BUILD_INTERPOLATION, STORE_FAST_MAYBE_NULL).
- Decode LOAD_SMALL_INT, LOAD_COMMON_CONSTANT, LOAD_SPECIAL, and the
  LOAD_FAST_BORROW family; treat LOAD_FAST_CHECK as a plain fast load.
- Reconstruct PEP 750 t-strings via BUILD_INTERPOLATION / BUILD_TEMPLATE,
  reusing the f-string rendering path and prefixing templates with 't'.
- Normalize the standalone PUSH_NULL layout so CALL sees NULL, callable.
- Skip specialized/adaptive opcodes defensively rather than aborting.

Zero-cost exceptions (3.11+):
- Pre-scan co_exceptiontable to locate try bodies and handlers, then rebuild
  try/except/finally structure while walking the linear byte stream.
- Recover `except <type>:`, bare `except:`, and `except ... as <name>`,
  suppressing the compiler-generated alias cleanup.

Tests:
- Add except_as covering bare, typed, and aliased except clauses under the
  Python 3.14 zero-cost exception layout.

Author: Aasyaco

ASTNode.h

@@ -578,9 +578,15 @@ class ASTCondBlock : public ASTBlock {
     PycRef<ASTNode> cond() const { return m_cond; }
     bool negative() const { return m_negative; }
 
+    /* For BLK_EXCEPT: the optional `as <name>` alias (Python 3.11+ zero-cost
+       exception reconstruction). */
+    PycRef<ASTNode> exceptAs() const { return m_exceptAs; }
+    void setExceptAs(PycRef<ASTNode> name) { m_exceptAs = std::move(name); }
+
 private:
     PycRef<ASTNode> m_cond;
     bool m_negative;
+    PycRef<ASTNode> m_exceptAs;
 };
 
 
@@ -717,13 +723,16 @@ class ASTJoinedStr : public ASTNode {
 public:
     typedef std::list<PycRef<ASTNode>> value_t;
 
-    ASTJoinedStr(value_t values)
-        : ASTNode(NODE_JOINEDSTR), m_values(std::move(values)) { }
+    ASTJoinedStr(value_t values, bool is_template = false)
+        : ASTNode(NODE_JOINEDSTR), m_values(std::move(values)),
+          m_template(is_template) { }
 
     const value_t& values() const { return m_values; }
+    bool isTemplate() const { return m_template; }
 
 private:
     value_t m_values;
+    bool m_template;
 };
 
 class ASTAnnotatedVar : public ASTNode {

ASTree.cpp

@@ -128,11 +128,6 @@ OPCODE(BUILD_TEMPLATE)                  // Python 3.14 ->
 OPCODE(BINARY_OP_INPLACE_ADD_UNICODE)
 OPCODE(NOT_TAKEN)
 OPCODE(POP_ITER)
-OPCODE(BUILD_INTERPOLATION)
-OPCODE(LOAD_COMMON_CONSTANT)
-OPCODE(LOAD_FAST_BORROW)
-OPCODE(LOAD_FAST_BORROW_LOAD_FAST_BORROW)
-OPCODE(LOAD_SPECIAL)
 OPCODE(BINARY_OP_ADD_FLOAT)
 OPCODE(BINARY_OP_ADD_INT)
 OPCODE(BINARY_OP_ADD_UNICODE)
@@ -220,7 +215,6 @@ OPCODE(ANNOTATIONS_PLACEHOLDER)
 OPCODE(JUMP)
 OPCODE(JUMP_NO_INTERRUPT)
 OPCODE(SETUP_CLEANUP)
-OPCODE(STORE_FAST_MAYBE_NULL)
 
 /* Has parameter word */
 OPCODE_A_FIRST(STORE_NAME)              // Python 1.0 ->                names[A]
@@ -371,6 +365,12 @@ OPCODE_A(SET_FUNCTION_ATTRIBUTE)        // Python 3.13 ->               A=attrib
 OPCODE_A(STORE_FAST_LOAD_FAST)          // Python 3.13 ->               A=locals[A<<4]+locals[A&0xf]
 OPCODE_A(STORE_FAST_STORE_FAST)         // Python 3.13 ->               A=locals[A<<4]+locals[A&0xf]
 OPCODE_A(LOAD_SMALL_INT)                // Python 3.14 ->               A=small int range(256)
+OPCODE_A(LOAD_FAST_BORROW)              // Python 3.14 ->               locals[A]
+OPCODE_A(LOAD_FAST_BORROW_LOAD_FAST_BORROW) // Python 3.14 ->           A=locals[A<<4]+locals[A&0xf]
+OPCODE_A(LOAD_COMMON_CONSTANT)          // Python 3.14 ->               A=common_constant_index
+OPCODE_A(LOAD_SPECIAL)                  // Python 3.14 ->               A=special_method_index
+OPCODE_A(BUILD_INTERPOLATION)           // Python 3.14 ->               A=(format&0x03)+(conversion<<2)
+OPCODE_A(STORE_FAST_MAYBE_NULL)         // Python 3.14 ->               locals[A]
 
 /* Instrumented opcodes */
 OPCODE_A(INSTRUMENTED_LOAD_SUPER_ATTR)      // Python 3.12 ->           (see LOAD_SUPER_ATTR)

bytecode_ops.inl

@@ -46,7 +46,7 @@ BEGIN_MAP(3, 14)
     MAP_OP(42, UNARY_NOT)
     MAP_OP(43, WITH_EXCEPT_START)
     MAP_OP(44, BINARY_OP_A)
-    MAP_OP(45, BUILD_INTERPOLATION)
+    MAP_OP(45, BUILD_INTERPOLATION_A)
     MAP_OP(46, BUILD_LIST_A)
     MAP_OP(47, BUILD_MAP_A)
     MAP_OP(48, BUILD_SET_A)
@@ -82,21 +82,21 @@ BEGIN_MAP(3, 14)
     MAP_OP(78, LIST_APPEND)
     MAP_OP(79, LIST_EXTEND_A)
     MAP_OP(80, LOAD_ATTR_A)
-    MAP_OP(81, LOAD_COMMON_CONSTANT)
+    MAP_OP(81, LOAD_COMMON_CONSTANT_A)
     MAP_OP(82, LOAD_CONST_A)
     MAP_OP(83, LOAD_DEREF_A)
     MAP_OP(84, LOAD_FAST_A)
     MAP_OP(85, LOAD_FAST_AND_CLEAR_A)
-    MAP_OP(86, LOAD_FAST_BORROW)
-    MAP_OP(87, LOAD_FAST_BORROW_LOAD_FAST_BORROW)
+    MAP_OP(86, LOAD_FAST_BORROW_A)
+    MAP_OP(87, LOAD_FAST_BORROW_LOAD_FAST_BORROW_A)
     MAP_OP(88, LOAD_FAST_CHECK_A)
     MAP_OP(89, LOAD_FAST_LOAD_FAST_A)
     MAP_OP(90, LOAD_FROM_DICT_OR_DEREF_A)
     MAP_OP(91, LOAD_FROM_DICT_OR_GLOBALS_A)
     MAP_OP(92, LOAD_GLOBAL_A)
     MAP_OP(93, LOAD_NAME_A)
     MAP_OP(94, LOAD_SMALL_INT_A)
-    MAP_OP(95, LOAD_SPECIAL)
+    MAP_OP(95, LOAD_SPECIAL_A)
     MAP_OP(96, LOAD_SUPER_ATTR_A)
     MAP_OP(97, MAKE_CELL_A)
     MAP_OP(98, MAP_ADD_A)
@@ -238,5 +238,5 @@ BEGIN_MAP(3, 14)
     MAP_OP(263, SETUP_CLEANUP)
     MAP_OP(264, SETUP_FINALLY_A)
     MAP_OP(265, SETUP_WITH_A)
-    MAP_OP(266, STORE_FAST_MAYBE_NULL)
+    MAP_OP(266, STORE_FAST_MAYBE_NULL_A)
 END_MAP()

bytes/python_3_14.cpp

@@ -36,7 +36,7 @@ enum PycMagic {
     MAGIC_3_11 = 0x0A0D0DA7,
     MAGIC_3_12 = 0x0A0D0DCB,
     MAGIC_3_13 = 0x0A0D0DF3,
-    MAGIC_3_14 = 0x0A0D0E29,
+    MAGIC_3_14 = 0x0A0D0E2B,
 
     INVALID = 0,
 };

pyc_module.h

@@ -0,0 +1,22 @@
+def bare():
+    try:
+        a = 1
+    except:
+        a = 2
+    b = 3
+
+
+def typed():
+    try:
+        a = 1
+    except ValueError:
+        a = 2
+    b = 3
+
+
+def alias():
+    try:
+        a = 1
+    except ValueError as e:
+        a = e
+    b = 3

tests/compiled/except_as.3.14.pyc

@@ -0,0 +1,35 @@
+def bare ( ) : <EOL>
+<INDENT>
+try : <EOL>
+<INDENT>
+a = 1 <EOL>
+<OUTDENT>
+except : <EOL>
+<INDENT>
+a = 2 <EOL>
+<OUTDENT>
+b = 3 <EOL>
+<OUTDENT>
+def typed ( ) : <EOL>
+<INDENT>
+try : <EOL>
+<INDENT>
+a = 1 <EOL>
+<OUTDENT>
+except ValueError : <EOL>
+<INDENT>
+a = 2 <EOL>
+<OUTDENT>
+b = 3 <EOL>
+<OUTDENT>
+def alias ( ) : <EOL>
+<INDENT>
+try : <EOL>
+<INDENT>
+a = 1 <EOL>
+<OUTDENT>
+except ValueError as e : <EOL>
+<INDENT>
+a = e <EOL>
+<OUTDENT>
+b = 3 <EOL>