let this = self.eval_context_ref();
let os_str = this.read_os_str_from_c_str(ptr)?;
- Ok(match this.convert_path_separator(Cow::Borrowed(os_str), PathConversion::TargetToHost) {
+ Ok(match this.convert_path(Cow::Borrowed(os_str), PathConversion::TargetToHost) {
Cow::Borrowed(x) => Cow::Borrowed(Path::new(x)),
Cow::Owned(y) => Cow::Owned(PathBuf::from(y)),
})
let this = self.eval_context_ref();
let os_str = this.read_os_str_from_wide_str(ptr)?;
- Ok(this
- .convert_path_separator(Cow::Owned(os_str), PathConversion::TargetToHost)
- .into_owned()
- .into())
+ Ok(this.convert_path(Cow::Owned(os_str), PathConversion::TargetToHost).into_owned().into())
}
/// Write a Path to the machine memory (as a null-terminated sequence of bytes),
size: u64,
) -> InterpResult<'tcx, (bool, u64)> {
let this = self.eval_context_mut();
- let os_str = this
- .convert_path_separator(Cow::Borrowed(path.as_os_str()), PathConversion::HostToTarget);
+ let os_str =
+ this.convert_path(Cow::Borrowed(path.as_os_str()), PathConversion::HostToTarget);
this.write_os_str_to_c_str(&os_str, ptr, size)
}
size: u64,
) -> InterpResult<'tcx, (bool, u64)> {
let this = self.eval_context_mut();
- let os_str = this
- .convert_path_separator(Cow::Borrowed(path.as_os_str()), PathConversion::HostToTarget);
+ let os_str =
+ this.convert_path(Cow::Borrowed(path.as_os_str()), PathConversion::HostToTarget);
this.write_os_str_to_wide_str(&os_str, ptr, size)
}
memkind: MemoryKind<MiriMemoryKind>,
) -> InterpResult<'tcx, Pointer<Option<Provenance>>> {
let this = self.eval_context_mut();
- let os_str = this
- .convert_path_separator(Cow::Borrowed(path.as_os_str()), PathConversion::HostToTarget);
+ let os_str =
+ this.convert_path(Cow::Borrowed(path.as_os_str()), PathConversion::HostToTarget);
this.alloc_os_str_as_c_str(&os_str, memkind)
}
- fn convert_path_separator<'a>(
+ fn convert_path<'a>(
&self,
os_str: Cow<'a, OsStr>,
direction: PathConversion,
) -> Cow<'a, OsStr> {
let this = self.eval_context_ref();
let target_os = &this.tcx.sess.target.os;
+
#[cfg(windows)]
return if target_os == "windows" {
// Windows-on-Windows, all fine.
PathConversion::HostToTarget => ('\\', '/'),
PathConversion::TargetToHost => ('/', '\\'),
};
- let converted = os_str
+ let mut converted = os_str
.encode_wide()
.map(|wchar| if wchar == from as u16 { to as u16 } else { wchar })
.collect::<Vec<_>>();
+ // We also have to ensure that absolute paths remain absolute.
+ match direction {
+ PathConversion::HostToTarget => {
+ // If this is an absolute Windows path that starts with a drive letter (`C:/...`
+ // after separator conversion), it would not be considered absolute by Unix
+ // target code.
+ if converted.get(1).copied() == Some(':' as u16)
+ && converted.get(2).copied() == Some('/' as u16)
+ {
+ // We add a `/` at the beginning, to store the absolute Windows
+ // path in something that looks like an absolute Unix path.
+ converted.insert(0, '/' as u16);
+ }
+ }
+ PathConversion::TargetToHost => {
+ // If the path is `\C:\`, the leading backslash was probably added by the above code
+ // and we should get rid of it again.
+ if converted.get(0).copied() == Some('\\' as u16)
+ && converted.get(2).copied() == Some(':' as u16)
+ && converted.get(3).copied() == Some('\\' as u16)
+ {
+ converted.remove(0);
+ }
+ }
+ }
Cow::Owned(OsString::from_wide(&converted))
};
#[cfg(unix)]
.iter()
.map(|&wchar| if wchar == from as u8 { to as u8 } else { wchar })
.collect::<Vec<_>>();
+ // TODO: Once we actually support file system things on Windows targets, we'll probably
+ // have to also do something clever for absolute path preservation here, like above.
Cow::Owned(OsString::from_vec(converted))
} else {
// Unix-on-Unix, all is fine.