Function encode_code_page_errors

crates/vm/src/stdlib/_codecs.rs:872–1045

Encode character by character with error handling.

(
        code_page: u32,
        s: &PyStrRef,
        errors: &str,
        encoding_name: &str,
        vm: &VirtualMachine,
    )

    /// Encode character by character with error handling.
    fn encode_code_page_errors(
        code_page: u32,
        s: &PyStrRef,
        errors: &str,
        encoding_name: &str,
        vm: &VirtualMachine,
    ) -> PyResult<(Vec<u8>, usize)> {
        use crate::builtins::{PyBytes, PyStr, PyTuple};
        use windows_sys::Win32::Globalization::WideCharToMultiByte;

        let char_len = s.char_len();
        let flags = encode_code_page_flags(code_page, errors);
        let use_default_char = code_page != 65001 && code_page != 65000;
        let encoding_str = vm.ctx.new_str(encoding_name);
        let reason_str = vm.ctx.new_str("invalid character");

        // For strict mode, find the first unencodable character and raise
        if errors == "strict" {
            // Find the failing position by trying each character
            let mut fail_pos = 0;
            for cp in s.as_wtf8().code_points() {
                let ch = cp.to_u32();
                if (0xD800..=0xDFFF).contains(&ch) {
                    break;
                }
                let mut wchars = [0u16; 2];
                let wchar_len = if ch < 0x10000 {
                    wchars[0] = ch as u16;
                    1
                } else {
                    wchars[0] = ((ch - 0x10000) >> 10) as u16 + 0xD800;
                    wchars[1] = ((ch - 0x10000) & 0x3FF) as u16 + 0xDC00;
                    2
                };
                let mut used_default_char: i32 = 0;
                let pused = if use_default_char {
                    &mut used_default_char as *mut i32
                } else {
                    core::ptr::null_mut()
                };
                let outsize = unsafe {
                    WideCharToMultiByte(
                        code_page,
                        flags,
                        wchars.as_ptr(),
                        wchar_len,
                        core::ptr::null_mut(),
                        0,
                        core::ptr::null(),
                        pused,
                    )
                };
                if outsize <= 0 || (use_default_char && used_default_char != 0) {
                    break;
                }
                fail_pos += 1;
            }
            return Err(vm.new_unicode_encode_error_real(