zexus 1.6.8 → 1.7.2

package/src/zexus/vm/bytecode.py

@@ -62,6 +62,7 @@ class Opcode(IntEnum):
     BUILD_SET = 62      # Build set from stack items
     INDEX = 63          # Index into collection
     SLICE = 64          # Slice operation
+    GET_ATTR = 65       # Get attribute/property of object
     
     # Async/Concurrency
     SPAWN = 70          # Spawn coroutine/task
@@ -146,7 +147,33 @@ class Opcode(IntEnum):
     DEFINE_SCREEN = 120
     DEFINE_COMPONENT = 121
     DEFINE_THEME = 122
-    
+
+    # Security & Contracts (130-149)
+    REQUIRE = 130       # require(condition, message)
+    DEFINE_CONTRACT = 131 # Define smart contract
+    DEFINE_ENTITY = 132   # Define entity
+    DEFINE_CAPABILITY = 133 # Define capability
+    GRANT_CAPABILITY = 134  # Grant capability
+    REVOKE_CAPABILITY = 135 # Revoke capability
+    
+    # Audit & Access Control (136-139)
+    AUDIT_LOG = 136     # Audit log
+    RESTRICT_ACCESS = 137 # Restrict access
+    
+    # Exception Handling (140-149)
+    SETUP_TRY = 140     # Start try block
+    POP_TRY = 141       # End try block / clean up handler
+    THROW = 142         # Throw exception
+    
+    # Iteration (150-159)
+    FOR_ITER = 150      # Get next item from iterator
+    
+    # System & Modes (160-169)
+    ENABLE_ERROR_MODE = 160 # Enable global continue-on-error mode
+
+    # Register-based operations (200-299) - Phase 5
+    # FOR_ITER removed (duplicate)
+
     # Special
     NOP = 255           # No operation
 
@@ -250,12 +277,33 @@ class BytecodeBuilder:
         self._label_positions: Dict[str, int] = {}
         self._forward_refs: Dict[str, List[int]] = {}
     
-    def emit(self, opcode: str, operand: Any = None) -> int:
-        """Emit an instruction"""
-        return self.bytecode.add_instruction(opcode, operand)
-    
-    def emit_constant(self, value: Any) -> int:
-        """Emit LOAD_CONST instruction"""
+    def emit(self, opcode: Any, operand: Any = None) -> int:
+        """Emit an instruction, normalizing opcode names to Opcode enum when possible."""
+        normalized = opcode
+        if isinstance(opcode, str):
+            try:
+                normalized = Opcode[opcode]
+            except KeyError:
+                normalized = opcode  # Leave custom opcodes untouched
+        return self.bytecode.add_instruction(normalized, operand)
+    
+    def emit_constant(self, value: Any, legacy_operand: Any = None) -> int:
+        """Emit LOAD_CONST instruction (legacy-compatible)."""
+        # Legacy call signature: emit_constant("LOAD_CONST", actual_value)
+        if legacy_operand is not None and isinstance(value, str):
+            opcode = value
+            operand = legacy_operand
+
+            if opcode == "LOAD_CONST":
+                const_idx = self.bytecode.add_constant(operand)
+                return self.emit("LOAD_CONST", const_idx)
+            if opcode == "LOAD_NAME":
+                # Legacy builder pushed raw identifiers instead of constant indices
+                return self.emit("LOAD_NAME", operand)
+            if opcode == "STORE_NAME":
+                return self.emit("STORE_NAME", operand)
+            return self.emit(opcode, operand)
+
         const_idx = self.bytecode.add_constant(value)
         return self.emit("LOAD_CONST", const_idx)
     
@@ -317,14 +365,14 @@ class BytecodeBuilder:
         """Emit MERKLE_ROOT - expects leaf_count items on stack"""
         return self.emit("MERKLE_ROOT", leaf_count)
     
-    def emit_state_read(self, key: str) -> int:
+    def emit_state_read(self, key: Any) -> int:
         """Emit STATE_READ instruction"""
-        key_idx = self.bytecode.add_constant(key)
+        key_idx = key if isinstance(key, int) else self.bytecode.add_constant(key)
         return self.emit("STATE_READ", key_idx)
     
-    def emit_state_write(self, key: str) -> int:
+    def emit_state_write(self, key: Any) -> int:
         """Emit STATE_WRITE instruction - expects value on stack"""
-        key_idx = self.bytecode.add_constant(key)
+        key_idx = key if isinstance(key, int) else self.bytecode.add_constant(key)
         return self.emit("STATE_WRITE", key_idx)
     
     def emit_tx_begin(self) -> int:

package/src/zexus/vm/bytecode_converter.py

@@ -126,49 +126,63 @@ class BytecodeConverter:
         if start >= len(instructions):
             return None, 0
         
+        def _op_name(op):
+            return op.name if hasattr(op, "name") else op
+
         # Pattern 1: Constant arithmetic (LOAD_CONST, LOAD_CONST, BINARY_OP)
         if start + 2 < len(instructions):
             inst1, inst2, inst3 = instructions[start:start+3]
             
-            if (inst1[0] == Opcode.LOAD_CONST and
-                inst2[0] == Opcode.LOAD_CONST and
-                inst3[0] in [Opcode.ADD, Opcode.SUB, Opcode.MUL, Opcode.DIV, Opcode.MOD, Opcode.POW]):
+            op1 = _op_name(inst1[0])
+            op2 = _op_name(inst2[0])
+            op3 = _op_name(inst3[0])
+            if (op1 == Opcode.LOAD_CONST.name and
+                op2 == Opcode.LOAD_CONST.name and
+                op3 in [Opcode.ADD.name, Opcode.SUB.name, Opcode.MUL.name, Opcode.DIV.name, Opcode.MOD.name, Opcode.POW.name]):
                 
                 return {
                     'type': 'const_binary_op',
                     'const1': inst1[1],
                     'const2': inst2[1],
-                    'operation': inst3[0],
+                    'operation': Opcode[op3],
                 }, 3
         
         # Pattern 2: Variable arithmetic (LOAD_NAME, LOAD_CONST, BINARY_OP)
         if start + 2 < len(instructions):
             inst1, inst2, inst3 = instructions[start:start+3]
             
-            if (inst1[0] == Opcode.LOAD_NAME and
-                inst2[0] == Opcode.LOAD_CONST and
-                inst3[0] in [Opcode.ADD, Opcode.SUB, Opcode.MUL, Opcode.DIV]):
+            op1 = _op_name(inst1[0])
+            op2 = _op_name(inst2[0])
+            op3 = _op_name(inst3[0])
+            if (op1 == Opcode.LOAD_NAME.name and
+                op2 == Opcode.LOAD_CONST.name and
+                op3 in [Opcode.ADD.name, Opcode.SUB.name, Opcode.MUL.name, Opcode.DIV.name,
+                        Opcode.MOD.name, Opcode.POW.name]):
                 
                 return {
                     'type': 'var_const_binary_op',
                     'var_name': inst1[1],
                     'const': inst2[1],
-                    'operation': inst3[0],
+                    'operation': Opcode[op3],
                 }, 3
         
         # Pattern 3: Two variables (LOAD_NAME x, LOAD_NAME y, BINARY_OP)
         if start + 2 < len(instructions):
             inst1, inst2, inst3 = instructions[start:start+3]
             
-            if (inst1[0] == Opcode.LOAD_NAME and
-                inst2[0] == Opcode.LOAD_NAME and
-                inst3[0] in [Opcode.ADD, Opcode.SUB, Opcode.MUL, Opcode.DIV]):
+            op1 = _op_name(inst1[0])
+            op2 = _op_name(inst2[0])
+            op3 = _op_name(inst3[0])
+            if (op1 == Opcode.LOAD_NAME.name and
+                op2 == Opcode.LOAD_NAME.name and
+                op3 in [Opcode.ADD.name, Opcode.SUB.name, Opcode.MUL.name, Opcode.DIV.name,
+                        Opcode.MOD.name, Opcode.POW.name]):
                 
                 return {
                     'type': 'var_var_binary_op',
                     'var1': inst1[1],
                     'var2': inst2[1],
-                    'operation': inst3[0],
+                    'operation': Opcode[op3],
                 }, 3
         
         # Pattern 4: Store result (... STORE_NAME)