Function strftime_crt

crates/vm/src/stdlib/time.rs:640–736

(format: &PyStrRef, checked_tm: CheckedTm, vm: &VirtualMachine)

    #[cfg(any(unix, windows))]
    fn strftime_crt(format: &PyStrRef, checked_tm: CheckedTm, vm: &VirtualMachine) -> PyResult {
        #[cfg(unix)]
        let _keep_zone_alive = &checked_tm.zone;
        let mut tm = checked_tm.tm;
        tm.tm_isdst = tm.tm_isdst.clamp(-1, 1);

        // MSVC strftime requires year in [1; 9999]
        #[cfg(windows)]
        {
            let year = tm.tm_year + 1900;
            if !(1..=9999).contains(&year) {
                return Err(vm.new_value_error("strftime() requires year in [1; 9999]"));
            }
        }

        #[cfg(unix)]
        fn strftime_ascii(fmt: &str, tm: &libc::tm, vm: &VirtualMachine) -> PyResult<String> {
            let fmt_c =
                CString::new(fmt).map_err(|_| vm.new_value_error("embedded null character"))?;
            let mut size = 1024usize;
            let max_scale = 256usize.saturating_mul(fmt.len().max(1));
            loop {
                let mut out = vec![0u8; size];
                let written = unsafe {
                    libc::strftime(
                        out.as_mut_ptr().cast(),
                        out.len(),
                        fmt_c.as_ptr(),
                        tm as *const libc::tm,
                    )
                };
                if written > 0 || size >= max_scale {
                    return Ok(String::from_utf8_lossy(&out[..written]).into_owned());
                }
                size = size.saturating_mul(2);
            }
        }

        #[cfg(windows)]
        fn strftime_ascii(fmt: &str, tm: &libc::tm, vm: &VirtualMachine) -> PyResult<String> {
            if fmt.contains('\0') {
                return Err(vm.new_value_error("embedded null character"));
            }
            // Use wcsftime for proper Unicode output (e.g. %Z timezone names)
            let fmt_wide: Vec<u16> = fmt.encode_utf16().chain(core::iter::once(0)).collect();
            let mut size = 1024usize;
            let max_scale = 256usize.saturating_mul(fmt.len().max(1));
            loop {
                let mut out = vec![0u16; size];
                let written = unsafe {
                    rustpython_common::suppress_iph!(wcsftime(
                        out.as_mut_ptr(),
                        out.len(),
                        fmt_wide.as_ptr(),
                        tm as *const libc::tm,
                    ))
                };
                if written > 0 || size >= max_scale {