use windows::Win32::Globalization::{
CP_ACP, MB_ERR_INVALID_CHARS, MultiByteToWideChar, WideCharToMultiByte,
};
pub fn pwstr_to_string(ptr: *const u16, maxlen: usize) -> String {
if ptr.is_null() {
return String::new();
}
let maxlen = maxlen & !1 / 2;
let slice = unsafe { std::slice::from_raw_parts(ptr, maxlen) };
let len = slice.iter().position(|&c| c == 0).unwrap_or(maxlen);
String::from_utf16_lossy(&slice[..len])
}
pub fn pstr_to_string(ptr: *const u8, maxlen: usize) -> String {
if ptr.is_null() {
return String::new();
}
let wide_vec = convert_ansi_to_wide_string(ptr, maxlen);
pwstr_to_string(wide_vec.as_ptr(), wide_vec.len() * 2)
}
pub fn string_to_pwstr(s: &str, ptr: *const u16, maxlen: usize) {
if ptr.is_null() {
return;
}
let wide: Vec<u16> = s.encode_utf16().collect();
let len = wide.len().min(maxlen / 2 - 1);
unsafe {
std::ptr::copy_nonoverlapping(wide.as_ptr(), ptr as *mut u16, len);
*((ptr as *mut u16).add(len)) = 0; }
}
pub fn string_to_pstr(s: &str, ptr: *const u8, maxlen: usize) {
if ptr.is_null() {
return;
}
let wide: Vec<u16> = s.encode_utf16().collect(); let ansi_vec = convert_wide_to_ansi_string(wide.as_ptr(), wide.len());
let len = ansi_vec.len().min(maxlen - 1);
unsafe {
std::ptr::copy_nonoverlapping(ansi_vec.as_ptr(), ptr as *mut u8, len);
*((ptr as *mut u8).add(len)) = 0; }
}
fn convert_ansi_to_wide_string(ansi_str_ptr: *const u8, max_ansi_bytes: usize) -> Vec<u16> {
let null_terminated_empty_wide = || vec![0u16];
if ansi_str_ptr.is_null() {
return null_terminated_empty_wide();
}
let ansi_buffer_slice = unsafe { std::slice::from_raw_parts(ansi_str_ptr, max_ansi_bytes) };
let ansi_len_no_null = ansi_buffer_slice
.iter()
.position(|&byte| byte == 0)
.unwrap_or(max_ansi_bytes);
let ansi_content_slice = &ansi_buffer_slice[..ansi_len_no_null];
if ansi_content_slice.is_empty() {
return null_terminated_empty_wide();
}
let required_wide_chars = unsafe {
MultiByteToWideChar(
CP_ACP,
MB_ERR_INVALID_CHARS,
ansi_content_slice,
None, )
};
if required_wide_chars <= 0 {
return null_terminated_empty_wide();
}
let mut wide_buffer: Vec<u16> = vec![0u16; (required_wide_chars + 1) as usize];
let chars_written = unsafe {
MultiByteToWideChar(
CP_ACP,
MB_ERR_INVALID_CHARS,
ansi_content_slice,
Some(&mut wide_buffer), )
};
if chars_written <= 0 {
return null_terminated_empty_wide();
}
wide_buffer[chars_written as usize] = 0;
wide_buffer.truncate((chars_written + 1) as usize);
wide_buffer
}
pub fn convert_wide_to_ansi_string(wide_str_ptr: *const u16, max_wide_chars: usize) -> Vec<u8> {
let null_terminated_empty_ansi = || vec![0u8];
if wide_str_ptr.is_null() {
return null_terminated_empty_ansi();
}
let wide_buffer_slice = unsafe { std::slice::from_raw_parts(wide_str_ptr, max_wide_chars) };
let wide_len_no_null = wide_buffer_slice
.iter()
.position(|&wide_char| wide_char == 0)
.unwrap_or(max_wide_chars);
let wide_content_slice = &wide_buffer_slice[..wide_len_no_null];
if wide_content_slice.is_empty() {
return null_terminated_empty_ansi();
}
let required_ansi_bytes = unsafe {
WideCharToMultiByte(
CP_ACP,
0,
wide_content_slice,
None, None, None, )
};
if required_ansi_bytes <= 0 {
return null_terminated_empty_ansi();
}
let mut ansi_buffer: Vec<u8> = vec![0u8; (required_ansi_bytes + 1) as usize];
let bytes_written = unsafe {
WideCharToMultiByte(
CP_ACP,
0,
wide_content_slice,
Some(&mut ansi_buffer), None, None, )
};
if bytes_written <= 0 {
return null_terminated_empty_ansi();
}
ansi_buffer[bytes_written as usize] = 0;
ansi_buffer.truncate((bytes_written + 1) as usize);
ansi_buffer
}