lexer_kit 0.5.0

data/ext/lexer_kit_rust/src/opcodes.rs

@@ -0,0 +1,718 @@
+//! Opcode definitions and handlers
+//!
+//! This module defines all opcodes and their execution handlers.
+//! Must match lib/lexer_kit/ir/opcode.rb and ext/lexer_kit/lexer_kit_ext.h
+
+use crate::dfa::{match_literal, scan_until, scan_until_escape};
+use crate::trie;
+use crate::types::{
+    CompiledProgram, EmitResult, VmResult, VmState, MAX_MODE_STACK, MAX_ZERO_PROGRESS_TOKENS,
+};
+
+// =============================================================================
+// Opcode Definitions
+// =============================================================================
+
+/// DFA operations
+pub const OP_DFA_RUN: u8 = 0x01;
+pub const OP_DFA_RUN_IF_MATCH: u8 = 0x02;
+
+/// Delimiter/literal operations
+pub const OP_SCAN_UNTIL: u8 = 0x10;
+pub const OP_MATCH_LITERAL: u8 = 0x12;
+pub const OP_SCAN_UNTIL_ESCAPE: u8 = 0x13;
+pub const OP_MATCH_RANGE: u8 = 0x14;
+pub const OP_MATCH_LITERAL_OR_JUMP: u8 = 0x16;
+
+/// Branch/control operations
+pub const OP_SWITCH_BYTE: u8 = 0x20;
+pub const OP_JUMP: u8 = 0x21;
+pub const OP_JUMP_IF_EOF: u8 = 0x24;
+
+/// Mode operations
+pub const OP_PUSH_MODE: u8 = 0x30;
+pub const OP_POP_MODE: u8 = 0x31;
+
+/// Token operations
+pub const OP_EMIT: u8 = 0x40;
+pub const OP_EMIT_SKIP: u8 = 0x41;
+pub const OP_EMIT_ERROR: u8 = 0x42;
+pub const OP_MARK: u8 = 0x43;
+pub const OP_EMIT_AND_JUMP: u8 = 0x44;
+pub const OP_KEYWORD_LOOKUP: u8 = 0x45;
+pub const OP_LITERAL_TRIE_RUN: u8 = 0x46;
+pub const OP_CLEAR_BEST: u8 = 0x49;
+pub const OP_COMMIT_BEST: u8 = 0x4C;
+pub const OP_SET_MATCH: u8 = 0x4D;
+pub const OP_LITERAL_TRIE_COMMIT: u8 = 0x4E;
+pub const OP_EMIT_SKIP_AND_JUMP: u8 = 0x4F;
+
+/// Special
+pub const OP_HALT: u8 = 0xFF;
+
+// =============================================================================
+// Helper Types
+// =============================================================================
+
+/// Packed argument with two fields: upper 10 bits and lower 14 bits
+///
+/// Used by opcodes that encode two values in a single 24-bit argument:
+/// - DFA_RUN_IF_MATCH: dfa_id (10) + fail_target (14)
+/// - MATCH_LITERAL_OR_JUMP: const_id (10) + fail_target (14)
+/// - EMIT_AND_JUMP: token_id (10) + jump_target (14)
+/// - SET_MATCH: order (10) + action_ip (14)
+/// - LITERAL_TRIE_COMMIT: const_id (10) + fail_target (14)
+#[derive(Debug, Clone, Copy)]
+pub struct PackedArg {
+    /// Upper 10 bits (bits 23:14)
+    pub upper: u16,
+    /// Lower 14 bits (bits 13:0)
+    pub lower: u32,
+}
+
+impl PackedArg {
+    /// Extract packed argument from a 24-bit value
+    #[inline]
+    pub fn from_u32(val: u32) -> Self {
+        Self {
+            upper: ((val >> 14) & 0x3FF) as u16,
+            lower: val & 0x3FFF,
+        }
+    }
+}
+
+// =============================================================================
+// Helper Functions
+// =============================================================================
+
+/// Validate jump target
+#[inline]
+fn validate_jump(target: u32, prog: &CompiledProgram) -> VmResult {
+    if (target as usize) < prog.instructions.len() {
+        VmResult::Continue
+    } else {
+        VmResult::Halt
+    }
+}
+
+/// Load constant from pool, setting failure state if not found
+///
+/// Returns Some(data) if constant exists, None if not found (and sets vm.failed)
+#[inline]
+fn load_constant_or_fail<'a>(vm: &mut VmState<'a>, const_id: usize) -> Option<&'a [u8]> {
+    match vm.prog.constant_pool.get(const_id) {
+        Some(data) => Some(data),
+        None => {
+            vm.failed = true;
+            vm.ip += 1;
+            None
+        }
+    }
+}
+
+/// Check for zero-progress after emit (infinite loop detection)
+#[inline]
+fn check_zero_progress(vm: &mut VmState) -> VmResult {
+    if vm.pos == vm.last_emit_pos {
+        vm.zero_progress_count += 1;
+        if vm.zero_progress_count >= MAX_ZERO_PROGRESS_TOKENS {
+            return VmResult::Halt;
+        }
+    } else {
+        vm.zero_progress_count = 0;
+        vm.last_emit_pos = vm.pos;
+    }
+    VmResult::Continue
+}
+
+/// Read u16 from bytes (big-endian)
+#[inline]
+fn read_u16(bytes: &[u8]) -> u16 {
+    ((bytes[0] as u16) << 8) | (bytes[1] as u16)
+}
+
+// =============================================================================
+// Opcode Handlers
+// =============================================================================
+
+/// Execute a single opcode
+///
+/// Returns (VmResult, Option<EmitResult>)
+pub fn execute(vm: &mut VmState, opcode: u8, arg: u32) -> (VmResult, Option<EmitResult>) {
+    match opcode {
+        OP_HALT => (VmResult::Halt, None),
+
+        // DFA operations
+        OP_DFA_RUN => {
+            op_dfa_run(vm, arg);
+            (VmResult::Continue, None)
+        }
+        OP_DFA_RUN_IF_MATCH => (op_dfa_run_if_match(vm, arg), None),
+
+        // Delimiter/literal operations
+        OP_SCAN_UNTIL => {
+            op_scan_until(vm, arg);
+            (VmResult::Continue, None)
+        }
+        OP_MATCH_LITERAL => {
+            op_match_literal(vm, arg);
+            (VmResult::Continue, None)
+        }
+        OP_SCAN_UNTIL_ESCAPE => {
+            op_scan_until_escape(vm, arg);
+            (VmResult::Continue, None)
+        }
+        OP_MATCH_RANGE => {
+            op_match_range(vm, arg);
+            (VmResult::Continue, None)
+        }
+        OP_MATCH_LITERAL_OR_JUMP => (op_match_literal_or_jump(vm, arg), None),
+
+        // Branch/control operations
+        OP_SWITCH_BYTE => (op_switch_byte(vm, arg), None),
+        OP_JUMP => (op_jump(vm, arg), None),
+        OP_JUMP_IF_EOF => (op_jump_if_eof(vm, arg), None),
+
+        // Mode operations
+        OP_PUSH_MODE => (op_push_mode(vm, arg), None),
+        OP_POP_MODE => (op_pop_mode(vm), None),
+
+        // Token operations
+        OP_EMIT | OP_EMIT_ERROR => op_emit(vm, arg),
+        OP_EMIT_SKIP => {
+            let result = op_emit_skip(vm);
+            (result, None)
+        }
+        OP_MARK => {
+            op_mark(vm);
+            (VmResult::Continue, None)
+        }
+        OP_EMIT_AND_JUMP => op_emit_and_jump(vm, arg),
+        OP_KEYWORD_LOOKUP => {
+            op_keyword_lookup(vm, arg);
+            (VmResult::Continue, None)
+        }
+        OP_LITERAL_TRIE_RUN => {
+            op_literal_trie_run(vm, arg);
+            (VmResult::Continue, None)
+        }
+        OP_CLEAR_BEST => {
+            op_clear_best(vm);
+            (VmResult::Continue, None)
+        }
+        OP_COMMIT_BEST => (op_commit_best(vm, arg), None),
+        OP_SET_MATCH => {
+            op_set_match(vm, arg);
+            (VmResult::Continue, None)
+        }
+        OP_LITERAL_TRIE_COMMIT => (op_literal_trie_commit(vm, arg), None),
+        OP_EMIT_SKIP_AND_JUMP => (op_emit_skip_and_jump(vm, arg), None),
+
+        // Unknown opcode
+        _ => (VmResult::Halt, None),
+    }
+}
+
+// =============================================================================
+// Individual Opcode Implementations
+// =============================================================================
+
+/// OP_MARK: Set mark position
+fn op_mark(vm: &mut VmState) {
+    vm.mark = vm.pos;
+    vm.ip += 1;
+}
+
+/// OP_DFA_RUN: Execute DFA and advance position
+fn op_dfa_run(vm: &mut VmState, arg: u32) {
+    let dfa_id = arg as usize;
+    if dfa_id >= vm.prog.dfa_tables.len() {
+        vm.failed = true;
+        vm.last_match_len = 0;
+        vm.ip += 1;
+        return;
+    }
+
+    let dfa = &vm.prog.dfa_tables[dfa_id];
+    if let Some(m) = dfa.run(vm.remaining_bytes()) {
+        vm.pos += m.length;
+        vm.failed = false;
+        vm.last_match_len = m.length;
+    } else {
+        vm.failed = true;
+        vm.last_match_len = 0;
+    }
+    vm.ip += 1;
+}
+
+/// OP_DFA_RUN_IF_MATCH: Run DFA with integrated failure jump
+///
+/// Argument encoding:
+///   - arg[23:14] = dfa_id (10 bits)
+///   - arg[13:0]  = fail_target (14 bits)
+fn op_dfa_run_if_match(vm: &mut VmState, arg: u32) -> VmResult {
+    let packed = PackedArg::from_u32(arg);
+    let dfa_id = packed.upper as usize;
+    let fail_target = packed.lower;
+
+    if dfa_id >= vm.prog.dfa_tables.len() {
+        vm.failed = true;
+        vm.last_match_len = 0;
+        vm.ip = fail_target;
+        return validate_jump(fail_target, vm.prog);
+    }
+
+    let dfa = &vm.prog.dfa_tables[dfa_id];
+    if let Some(m) = dfa.run(vm.remaining_bytes()) {
+        vm.pos += m.length;
+        vm.failed = false;
+        vm.last_match_len = m.length;
+        vm.ip += 1;
+        VmResult::Continue
+    } else {
+        vm.failed = true;
+        vm.last_match_len = 0;
+        vm.ip = fail_target;
+        validate_jump(fail_target, vm.prog)
+    }
+}
+
+/// OP_SCAN_UNTIL: Scan until delimiter found
+fn op_scan_until(vm: &mut VmState, arg: u32) {
+    let Some(delim) = load_constant_or_fail(vm, arg as usize) else {
+        return;
+    };
+
+    let remaining = vm.remaining_bytes();
+    let scanned = scan_until(remaining, delim);
+    vm.pos += scanned;
+    vm.failed = scanned >= remaining.len();
+    vm.ip += 1;
+}
+
+/// OP_SCAN_UNTIL_ESCAPE: Scan until delimiter found, skipping escape sequences
+fn op_scan_until_escape(vm: &mut VmState, arg: u32) {
+    let Some(config) = load_constant_or_fail(vm, arg as usize) else {
+        return;
+    };
+    if config.len() < 4 {
+        vm.failed = true;
+        vm.ip += 1;
+        return;
+    }
+
+    let close_len = read_u16(&config[0..2]) as usize;
+    let escape_len = read_u16(&config[2..4]) as usize;
+
+    if 4 + close_len + escape_len > config.len() {
+        vm.failed = true;
+        vm.ip += 1;
+        return;
+    }
+
+    let close = &config[4..4 + close_len];
+    let escape = &config[4 + close_len..4 + close_len + escape_len];
+
+    let (found, end_pos) = scan_until_escape(vm.remaining_bytes(), close, escape);
+
+    if found {
+        vm.pos += end_pos;
+        vm.failed = false;
+    } else {
+        vm.pos = vm.bytes.len();
+        vm.failed = true;
+    }
+    vm.ip += 1;
+}
+
+/// OP_MATCH_LITERAL: Match literal string
+fn op_match_literal(vm: &mut VmState, arg: u32) {
+    let Some(lit) = load_constant_or_fail(vm, arg as usize) else {
+        vm.last_match_len = 0;
+        return;
+    };
+
+    if match_literal(vm.remaining_bytes(), lit) {
+        vm.pos += lit.len();
+        vm.failed = false;
+        vm.last_match_len = lit.len();
+    } else {
+        vm.failed = true;
+        vm.last_match_len = 0;
+    }
+    vm.ip += 1;
+}
+
+/// OP_MATCH_LITERAL_OR_JUMP: Match literal with integrated failure jump
+///
+/// Argument encoding:
+///   - arg[23:14] = const_id (10 bits)
+///   - arg[13:0]  = fail_target (14 bits)
+fn op_match_literal_or_jump(vm: &mut VmState, arg: u32) -> VmResult {
+    let packed = PackedArg::from_u32(arg);
+    let const_id = packed.upper as usize;
+    let fail_target = packed.lower;
+
+    let lit = match vm.prog.constant_pool.get(const_id) {
+        Some(l) => l,
+        None => {
+            vm.failed = true;
+            vm.last_match_len = 0;
+            vm.ip = fail_target;
+            return validate_jump(fail_target, vm.prog);
+        }
+    };
+
+    if match_literal(vm.remaining_bytes(), lit) {
+        vm.pos += lit.len();
+        vm.failed = false;
+        vm.last_match_len = lit.len();
+        vm.ip += 1;
+        VmResult::Continue
+    } else {
+        vm.failed = true;
+        vm.last_match_len = 0;
+        vm.ip = fail_target;
+        validate_jump(fail_target, vm.prog)
+    }
+}
+
+/// OP_MATCH_RANGE: Match byte in range [lo, hi]
+fn op_match_range(vm: &mut VmState, arg: u32) {
+    let lo = ((arg >> 8) & 0xFF) as u8;
+    let hi = (arg & 0xFF) as u8;
+
+    if lo > hi {
+        vm.failed = true;
+        vm.last_match_len = 0;
+    } else if let Some(byte) = vm.current_byte() {
+        if byte >= lo && byte <= hi {
+            vm.pos += 1;
+            vm.failed = false;
+            vm.last_match_len = 1;
+        } else {
+            vm.failed = true;
+            vm.last_match_len = 0;
+        }
+    } else {
+        vm.failed = true;
+        vm.last_match_len = 0;
+    }
+    vm.ip += 1;
+}
+
+/// OP_SWITCH_BYTE: Jump based on current byte
+fn op_switch_byte(vm: &mut VmState, arg: u32) -> VmResult {
+    let jt_id = arg as usize;
+    if jt_id >= vm.prog.jump_tables.len() {
+        vm.ip += 1;
+        return VmResult::Continue;
+    }
+
+    let jt = &vm.prog.jump_tables[jt_id];
+    let target = if let Some(byte) = vm.current_byte() {
+        jt.lookup[byte as usize]
+    } else {
+        jt.default_offset
+    };
+
+    if validate_jump(target, vm.prog) == VmResult::Halt {
+        return VmResult::Halt;
+    }
+    vm.ip = target;
+    VmResult::Continue
+}
+
+/// OP_JUMP: Unconditional jump
+fn op_jump(vm: &mut VmState, arg: u32) -> VmResult {
+    if validate_jump(arg, vm.prog) == VmResult::Halt {
+        return VmResult::Halt;
+    }
+    vm.ip = arg;
+    VmResult::Continue
+}
+
+/// OP_JUMP_IF_EOF: Jump if at end of input
+fn op_jump_if_eof(vm: &mut VmState, arg: u32) -> VmResult {
+    if vm.is_eof() {
+        if validate_jump(arg, vm.prog) == VmResult::Halt {
+            return VmResult::Halt;
+        }
+        vm.ip = arg;
+    } else {
+        vm.ip += 1;
+    }
+    VmResult::Continue
+}
+
+/// OP_PUSH_MODE: Push current mode and switch to new mode
+fn op_push_mode(vm: &mut VmState, arg: u32) -> VmResult {
+    if vm.mode_sp as usize >= MAX_MODE_STACK {
+        vm.error = Some("mode stack overflow: exceeded maximum depth of 64");
+        return VmResult::Halt;
+    }
+    vm.mode_stack[vm.mode_sp as usize] = vm.mode;
+    vm.mode_sp += 1;
+    vm.mode = arg as u16;
+
+    let offset = vm.prog.find_mode_offset(arg as u16);
+    if validate_jump(offset, vm.prog) == VmResult::Halt {
+        return VmResult::Halt;
+    }
+    vm.ip = offset;
+    VmResult::Continue
+}
+
+/// OP_POP_MODE: Pop mode from stack and return to it
+fn op_pop_mode(vm: &mut VmState) -> VmResult {
+    if vm.mode_sp > 0 {
+        vm.mode_sp -= 1;
+        vm.mode = vm.mode_stack[vm.mode_sp as usize];
+    }
+
+    let offset = vm.prog.find_mode_offset(vm.mode);
+    if validate_jump(offset, vm.prog) == VmResult::Halt {
+        return VmResult::Halt;
+    }
+    vm.ip = offset;
+    VmResult::Continue
+}
+
+/// OP_EMIT: Emit token
+fn op_emit(vm: &mut VmState, arg: u32) -> (VmResult, Option<EmitResult>) {
+    let token_id = if vm.has_pending_token {
+        let id = vm.pending_token_id;
+        vm.has_pending_token = false;
+        id
+    } else {
+        arg as u16
+    };
+
+    let start = vm.mark;
+    let length = vm.pos.saturating_sub(vm.mark);
+    vm.mark = vm.pos;
+    vm.ip += 1;
+
+    if check_zero_progress(vm) == VmResult::Halt {
+        return (VmResult::Halt, None);
+    }
+
+    (
+        VmResult::Emit,
+        Some(EmitResult {
+            token_id,
+            start,
+            length,
+        }),
+    )
+}
+
+/// OP_EMIT_SKIP: Skip matched content without emitting
+fn op_emit_skip(vm: &mut VmState) -> VmResult {
+    vm.mark = vm.pos;
+    vm.ip += 1;
+    check_zero_progress(vm)
+}
+
+/// OP_EMIT_AND_JUMP: Emit token and jump
+///
+/// Argument encoding:
+///   - arg[23:14] = token_id (10 bits)
+///   - arg[13:0]  = jump_target (14 bits)
+fn op_emit_and_jump(vm: &mut VmState, arg: u32) -> (VmResult, Option<EmitResult>) {
+    let packed = PackedArg::from_u32(arg);
+    let token_id_arg = packed.upper;
+    let target = packed.lower;
+
+    let token_id = if vm.has_pending_token {
+        let id = vm.pending_token_id;
+        vm.has_pending_token = false;
+        id
+    } else {
+        token_id_arg
+    };
+
+    let start = vm.mark;
+    let length = vm.pos.saturating_sub(vm.mark);
+    vm.mark = vm.pos;
+
+    if check_zero_progress(vm) == VmResult::Halt {
+        return (VmResult::Halt, None);
+    }
+
+    if validate_jump(target, vm.prog) == VmResult::Halt {
+        return (VmResult::Halt, None);
+    }
+    vm.ip = target;
+
+    (
+        VmResult::Emit,
+        Some(EmitResult {
+            token_id,
+            start,
+            length,
+        }),
+    )
+}
+
+/// OP_EMIT_SKIP_AND_JUMP: Skip content and jump
+fn op_emit_skip_and_jump(vm: &mut VmState, arg: u32) -> VmResult {
+    vm.mark = vm.pos;
+
+    if check_zero_progress(vm) == VmResult::Halt {
+        return VmResult::Halt;
+    }
+
+    if validate_jump(arg, vm.prog) == VmResult::Halt {
+        return VmResult::Halt;
+    }
+    vm.ip = arg;
+    VmResult::Continue
+}
+
+/// OP_KEYWORD_LOOKUP: Look up matched text in keyword table
+fn op_keyword_lookup(vm: &mut VmState, arg: u32) {
+    let kt_id = arg as usize;
+    if kt_id >= vm.prog.keyword_tables.len() {
+        vm.ip += 1;
+        return;
+    }
+
+    let kt = &vm.prog.keyword_tables[kt_id];
+
+    // Guard against mark being beyond input bounds
+    let mark = vm.mark.min(vm.bytes.len());
+    let match_len = vm.pos.saturating_sub(mark);
+    let match_text = &vm.bytes[mark..mark + match_len];
+
+    vm.pending_token_id = kt.base_token_id;
+    vm.has_pending_token = true;
+
+    for entry in &kt.entries {
+        if entry.keyword.len() == match_len && entry.keyword == match_text {
+            vm.pending_token_id = entry.token_id;
+            break;
+        }
+    }
+
+    vm.ip += 1;
+}
+
+/// OP_LITERAL_TRIE_RUN: Run literal trie with integrated best-match update
+fn op_literal_trie_run(vm: &mut VmState, arg: u32) {
+    let Some(trie_data) = load_constant_or_fail(vm, arg as usize) else {
+        vm.last_match_len = 0;
+        vm.reset_pos_to_mark();
+        return;
+    };
+
+    if let Some(m) = trie::run(trie_data, vm.remaining_bytes()) {
+        vm.pos += m.length;
+        vm.failed = false;
+        vm.last_match_len = m.length;
+        vm.last_match_order = m.order;
+        vm.last_match_ip = m.action_ip;
+
+        // Update best match if longer or same length with earlier order
+        vm.update_best_if_better();
+    } else {
+        vm.failed = true;
+        vm.last_match_len = 0;
+    }
+
+    // Reset to mark for next candidate
+    vm.reset_pos_to_mark();
+    vm.ip += 1;
+}
+
+/// OP_SET_MATCH: Combined regex candidate match update
+///
+/// Argument encoding:
+///   - arg[23:14] = order (10 bits)
+///   - arg[13:0]  = action_ip (14 bits)
+fn op_set_match(vm: &mut VmState, arg: u32) {
+    let packed = PackedArg::from_u32(arg);
+    vm.last_match_order = packed.upper;
+    vm.last_match_ip = packed.lower;
+
+    // Update best match if longer or same length with earlier order
+    if vm.last_match_len > 0 {
+        vm.update_best_if_better();
+    }
+
+    // Reset to mark for next candidate
+    vm.reset_pos_to_mark();
+    vm.ip += 1;
+}
+
+/// OP_CLEAR_BEST: Reset best match tracking
+fn op_clear_best(vm: &mut VmState) {
+    vm.clear_best();
+    vm.ip += 1;
+}
+
+/// OP_COMMIT_BEST: Jump to best match action or default
+fn op_commit_best(vm: &mut VmState, arg: u32) -> VmResult {
+    if vm.best_match_len > 0 {
+        vm.pos = vm.mark + vm.best_match_len;
+        if validate_jump(vm.best_match_ip, vm.prog) == VmResult::Halt {
+            return VmResult::Halt;
+        }
+        vm.ip = vm.best_match_ip;
+    } else {
+        if validate_jump(arg, vm.prog) == VmResult::Halt {
+            return VmResult::Halt;
+        }
+        vm.ip = arg;
+    }
+    VmResult::Continue
+}
+
+/// OP_LITERAL_TRIE_COMMIT: Combined CLEAR_BEST + LITERAL_TRIE_RUN + COMMIT_BEST
+///
+/// Argument encoding:
+///   - arg[23:14] = const_id (10 bits)
+///   - arg[13:0]  = fail_target (14 bits)
+fn op_literal_trie_commit(vm: &mut VmState, arg: u32) -> VmResult {
+    let packed = PackedArg::from_u32(arg);
+    let const_id = packed.upper as usize;
+    let fail_target = packed.lower;
+
+    // CLEAR_BEST
+    vm.clear_best();
+
+    // LITERAL_TRIE_RUN logic
+    let trie_data = match vm.prog.constant_pool.get(const_id) {
+        Some(t) => t,
+        None => {
+            if validate_jump(fail_target, vm.prog) == VmResult::Halt {
+                return VmResult::Halt;
+            }
+            vm.ip = fail_target;
+            return VmResult::Continue;
+        }
+    };
+
+    if let Some(m) = trie::run(trie_data, vm.remaining_bytes()) {
+        // Match found - update best_match (always better since we just cleared)
+        vm.best_match_len = m.length;
+        vm.best_match_order = m.order;
+        vm.best_match_ip = m.action_ip;
+    }
+
+    // COMMIT_BEST
+    if vm.best_match_len > 0 {
+        vm.pos = vm.mark + vm.best_match_len;
+        if validate_jump(vm.best_match_ip, vm.prog) == VmResult::Halt {
+            return VmResult::Halt;
+        }
+        vm.ip = vm.best_match_ip;
+    } else {
+        if validate_jump(fail_target, vm.prog) == VmResult::Halt {
+            return VmResult::Halt;
+        }
+        vm.ip = fail_target;
+    }
+
+    VmResult::Continue
+}