Function decode_code_page_errors

crates/vm/src/stdlib/_codecs.rs:1148–1358

Decode byte by byte with error handling (slow path).

(
        code_page: u32,
        data: &[u8],
        errors: &str,
        is_final: bool,
        encoding_name: &str,
        vm: &VirtualMachine,
    )

    /// Decode byte by byte with error handling (slow path).
    fn decode_code_page_errors(
        code_page: u32,
        data: &[u8],
        errors: &str,
        is_final: bool,
        encoding_name: &str,
        vm: &VirtualMachine,
    ) -> PyResult<(PyStrRef, usize)> {
        use crate::builtins::PyTuple;
        use crate::common::wtf8::Wtf8Buf;
        use windows_sys::Win32::Globalization::{MB_ERR_INVALID_CHARS, MultiByteToWideChar};

        let len = data.len();
        let encoding_str = vm.ctx.new_str(encoding_name);
        let reason_str = vm
            .ctx
            .new_str("No mapping for the Unicode character exists in the target code page.");

        // For strict+final, find the failing position and raise
        if errors == "strict" && is_final {
            // Find the exact failing byte position by trying byte by byte
            let mut fail_pos = 0;
            let mut flags_s: u32 = MB_ERR_INVALID_CHARS;
            let mut buf = [0u16; 2];
            while fail_pos < len {
                let mut in_size = 1;
                let mut found = false;
                while in_size <= 4 && fail_pos + in_size <= len {
                    let outsize = unsafe {
                        MultiByteToWideChar(
                            code_page,
                            flags_s,
                            data[fail_pos..].as_ptr().cast(),
                            in_size as i32,
                            buf.as_mut_ptr(),
                            2,
                        )
                    };
                    if outsize > 0 {
                        fail_pos += in_size;
                        found = true;
                        break;
                    }
                    let err_code = std::io::Error::last_os_error().raw_os_error().unwrap_or(0);
                    if err_code == 1004 && flags_s != 0 {
                        flags_s = 0;
                        continue;
                    }
                    in_size += 1;
                }
                if !found {
                    break;
                }
            }
            let object = vm.ctx.new_bytes(data.to_vec());
            return Err(vm.new_unicode_decode_error_real(
                encoding_str,
                object,