Rewrite emulatorv1.0.0-alpha1

This is a complete rewrite and restructure of the entire emulator
project, as part of the effort in locking down the Bedrock specification
and in creating much better tooling for creating and using Bedrock
programs.

This commit adds a command-line argument scheme, an embedded assembler,
a headless emulator for use in non-graphical environments, deferred
window creation for programs that do not access the screen device,
and new versions of phosphor and bedrock-core. The new version of
phosphor supports multi-window programs, which will make it possible to
implement program forking in the system device later on, and the new
version of bedrock-core implements the final core specification.

6 files changed, 691 insertions, 0 deletions

diff --git a/src/devices/file_device/bedrock_file_path.rs b/src/devices/file_device/bedrock_file_path.rs
new file mode 100644
index 0000000..fdd8f79
--- /dev/null
+++ b/src/devices/file_device/bedrock_file_path.rs
@@ -0,0 +1,287 @@
+use super::*;
+
+use std::cmp::Ordering;
+use std::ffi::OsString;
+
+
+#[derive(Clone)]
+pub struct BedrockFilePath {
+    /// Sandbox directory
+    base: PathBuf,
+    /// Path relative to sandbox directory
+    relative: PathBuf,
+    bytes: Vec<u8>,
+    entry_type: Option<EntryType>,
+}
+
+impl BedrockFilePath {
+    pub fn from_buffer(buffer: [u8; 256], base: &Path) -> Option<Self> {
+        let base = base.to_path_buf();
+        let relative = buffer_to_path(buffer)?;
+        let bytes = path_to_bytes(&relative)?;
+        let entry_type = get_entry_type(base.join(&relative));
+        assert_path_is_safe(&relative, &base)?;
+        Some(Self { base, relative, bytes, entry_type })
+    }
+
+    /// Construct an instance from an absolute path and a prefix of that path.
+    pub fn from_path(path: &Path, base: &Path) -> Option<Self> {
+        let base = base.to_path_buf();
+        let relative = path.strip_prefix(&base).ok()?.to_path_buf();
+        let bytes = path_to_bytes(&relative)?;
+        let entry_type = get_entry_type(base.join(&relative));
+        assert_path_is_safe(&relative, &base)?;
+        Some( Self { base, relative, bytes, entry_type } )
+    }
+
+    /// Get the base path used by this path.
+    pub fn base(&self) -> &Path {
+        &self.base
+    }
+
+    /// Get this path as a Bedrock-style path, which can be passed to
+    /// a Bedrock program.
+    pub fn as_bytes(&self) -> &[u8] {
+        &self.bytes
+    }
+
+    /// Get this path as a byte buffer, from which a CircularPathBuffer
+    /// can be populated.
+    pub fn as_buffer(&self) -> [u8; 256] {
+        let mut buffer: [u8; 256] = [0; 256];
+        buffer[..self.bytes.len()].copy_from_slice(&self.bytes);
+        return buffer;
+    }
+
+    /// Get this path as an absolute operating-system path, which can
+    /// be used to open a file or directory.
+    pub fn as_path(&self) -> PathBuf {
+        self.base.join(&self.relative)
+    }
+
+    /// Get the entry type of this path.
+    pub fn entry_type(&self) -> Option<EntryType> {
+        self.entry_type
+    }
+
+    /// Get a path which represents the parent of this path.
+    pub fn parent(&self) -> Option<Self> {
+        #[cfg(target_family = "unix")] {
+            Self::from_path(self.as_path().parent()?, &self.base)
+        }
+        #[cfg(target_family = "windows")] {
+            if self.base.components().count() != 0 {
+                // Sandboxed path, cannot ascend to a virtual root directory.
+                Self::from_path(self.as_path().parent()?, &self.base)
+            } else {
+                // Unsandboxed path, we can ascend to a virtual root directory.
+                match self.as_path().parent() {
+                    // Ascend to concrete parent directory.
+                    Some(parent) => Self::from_path(parent, &self.base),
+                    // Ascend into a virtual root directory.
+                    None => {
+                        if self.relative.components().count() != 0 {
+                            // Ascend from concrete path to virtual root.
+                            let blank = PathBuf::from("");
+                            BedrockFilePath::from_path(&blank, &blank)
+                        } else {
+                            // Cannot ascend above the virtual root.
+                            None
+                        }
+                    },
+                }
+            }
+        }
+    }
+
+    /// Returns true if the file would be hidden by the default file browser.
+    pub fn is_hidden(&self) -> bool {
+        #[cfg(target_family = "unix")] {
+            if let Some(stem) = self.relative.file_stem() {
+                if let Some(string) = stem.to_str() {
+                    return string.starts_with('.');
+                }
+            }
+        }
+        #[cfg(target_family = "windows")] {
+            use std::os::windows::fs::MetadataExt;
+            // See https://learn.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants
+            // const FILE_ATTRIBUTE_HIDDEN: u32 = 0x00000002;
+            // const FILE_ATTRIBUTE_NOT_CONTENT_INDEXED: u32 = 0x00002000;
+            if let Ok(metadata) = std::fs::metadata(self.as_path()) {
+                return metadata.file_attributes() & 0x2002 != 0;
+            }
+        }
+        return false;
+    }
+}
+
+
+/// Converts the contents of a CircularPathBuffer to a relative path.
+fn buffer_to_path(bytes: [u8; 256]) -> Option<PathBuf> {
+    // The buffer must be non-empty and slash-prefixed.
+    if bytes[0] != ('/' as u8) {
+        return None;
+    }
+
+    // Find the index of the first null byte.
+    let mut null_i = None;
+    for (i, b) in bytes.iter().enumerate() {
+        if *b == 0x00 {
+            null_i = Some(i);
+            break;
+        }
+    }
+    // Take a slice, excluding the leading slash, up to the trailing null.
+    let slice = &bytes[1..null_i?];
+
+    #[cfg(target_family = "unix")] {
+        use std::os::unix::ffi::OsStringExt;
+        let vec = Vec::from(slice);
+        return Some(OsString::from_vec(vec).into())
+    }
+    #[cfg(target_family = "windows")] {
+        use std::os::windows::ffi::OsStringExt;
+        let mut string = String::from_utf8_lossy(slice).to_string();
+        // Convert drive-current-directory paths to drive-root paths. This is
+        // needed because the paths C: and C:/ point to separate directories,
+        // but trailing forward-slashes are optional in Bedrock.
+        if string.ends_with(':') {
+            string.push('/');
+        }
+        let utf16: Vec<u16> = string.replace(r"/", r"\").encode_utf16().collect();
+        return Some(OsString::from_wide(&utf16).into())
+    }
+}
+
+/// Convert an operating system path to a Bedrock-style byte path.
+///
+/// A byte path contains at most 255 bytes, and is not null-terminated.
+fn path_to_bytes(path: &Path) -> Option<Vec<u8>> {
+    #[cfg(target_family = "unix")]
+    let string = path.as_os_str().to_str()?.to_string();
+    #[cfg(target_family = "windows")]
+    let string = path.as_os_str().to_str()?.replace(r"\", r"/");
+
+    // Remove any trailing forward-slash and add a leading forward-slash.
+    let mut prefixed_string = String::from("/");
+    prefixed_string.push_str(string.trim_end_matches('/'));
+    let slice = prefixed_string.as_bytes();
+
+    // Error if bytes does not fit into a CircularPathBuffer.
+    if slice.len() > 255 { return None; }
+
+    Some(Vec::from(slice))
+}
+
+/// Returns true if a relative path can be safely attached to a base without
+/// breaking out of the sandbox.
+fn assert_path_is_safe(relative: &Path, _base: &Path) -> Option<()> {
+    #[cfg(target_family = "unix")] {
+        // Error if path contains special components.
+        for component in relative.components() {
+            match component {
+                Component::Normal(_) => continue,
+                _ => return None,
+            }
+        }
+    }
+    #[cfg(target_family = "windows")] {
+        // If the base path is empty, the relative path needs to be able to
+        // contain the prefix and root element. If the base path is not
+        // empty, the relative path must not contain these elements else
+        // they will override the base path when joined.
+        if _base.components().count() != 0 {
+            for component in relative.components() {
+                match component {
+                    Component::Normal(_) => continue,
+                    _ => return None,
+                }
+            }
+        }
+    }
+    return Some(());
+}
+
+fn get_entry_type(absolute: PathBuf) -> Option<EntryType> {
+    #[cfg(target_family = "windows")] {
+        // If path is empty, this is a virtual root directory.
+        if absolute.components().count() == 0 {
+            return Some(EntryType::Directory)
+        }
+    }
+    let metadata = std::fs::metadata(absolute).ok()?;
+    if metadata.is_file() {
+        Some(EntryType::File)
+    } else if metadata.is_dir() {
+        Some(EntryType::Directory)
+    } else {
+        None
+    }
+}
+
+impl std::fmt::Debug for BedrockFilePath {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        self.as_path().fmt(f)
+    }
+}
+
+// ---------------------------------------------------------------------------
+
+impl PartialEq for BedrockFilePath {
+    fn eq(&self, other: &Self) -> bool {
+        self.bytes == other.bytes && self.entry_type == other.entry_type
+    }
+}
+
+impl Eq for BedrockFilePath {}
+
+impl PartialOrd for BedrockFilePath {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for BedrockFilePath {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match self.entry_type.cmp(&other.entry_type) {
+            Ordering::Equal => compare_ascii_slices(&self.bytes, &other.bytes),
+            ordering => ordering,
+        }
+    }
+}
+
+/// Compare two ASCII byte-slices in case-agnostic alphabetic order.
+fn compare_ascii_slices(left: &[u8], right: &[u8]) -> Ordering {
+    let l = std::cmp::min(left.len(), right.len());
+    let lhs = &left[..l];
+    let rhs = &right[..l];
+
+    for i in 0..l {
+        let a = remap_ascii(lhs[i]);
+        let b = remap_ascii(rhs[i]);
+        match a.cmp(&b) {
+            Ordering::Equal => (),
+            non_eq => return non_eq,
+        }
+    }
+
+    left.len().cmp(&right.len())
+}
+
+/// Remap ASCII values so that they sort in case-agnostic alphabetic order:
+///
+/// ```text
+///    !"#$%&'()*+,-./0123456789:;<=>?
+///   @`AaBbCcDdEeFfGgHhIiJjKkLlMmNnOo
+///   PpQqRrSsTtUuVvWwXxYyZz[{\|]}^~_
+/// ```
+fn remap_ascii(c: u8) -> u8 {
+    if 0x40 <= c && c <= 0x5F {
+        (c - 0x40) * 2 + 0x40
+    } else if 0x60 <= c && c <= 0x7F {
+        (c - 0x60) * 2 + 0x41
+    } else {
+        c
+    }
+}
diff --git a/src/devices/file_device/bedrock_path_buffer.rs b/src/devices/file_device/bedrock_path_buffer.rs
new file mode 100644
index 0000000..d6a0861
--- /dev/null
+++ b/src/devices/file_device/bedrock_path_buffer.rs
@@ -0,0 +1,60 @@
+pub struct BedrockPathBuffer {
+    buffer: [u8; 256],
+    pointer: u8,
+}
+
+impl BedrockPathBuffer {
+    pub fn new() -> Self {
+        Self { buffer: [0; 256] , pointer: 0 }
+    }
+
+    /// Clear the buffer, returning the previous buffer contents.
+    pub fn clear(&mut self) -> [u8; 256] {
+        self.pointer = 0;
+        std::mem::replace(&mut self.buffer, [0; 256])
+    }
+
+    /// Reset the pointer and hot-swap the byte buffer.
+    pub fn populate(&mut self, buffer: [u8; 256]) {
+        self.pointer = 0;
+        self.buffer = buffer;
+    }
+
+    /// Move internal pointer to the start of the path or file name.
+    ///
+    /// If value is non-zero, the pointer will be moved to the byte
+    /// directly following the final forward-slash.
+    pub fn set_pointer(&mut self, value: u8) {
+        self.pointer = 0;
+        // Set the pointer to the start of the filename if value is truthy.
+        if value != 0x00 {
+            for (i, c) in self.buffer.iter().enumerate() {
+                match c {
+                    b'/' => self.pointer = (i as u8).saturating_add(1),
+                    0x00 => break,
+                    _ => continue,
+                }
+            }
+        }
+    }
+
+    /// Read a single byte from the buffer.
+    pub fn read(&mut self) -> u8 {
+        let pointer = self.pointer as usize;
+        self.pointer = self.pointer.wrapping_add(1);
+        self.buffer[pointer]
+    }
+
+    /// Write a single byte to the buffer.
+    ///
+    /// If a null-byte is written, the buffer will be cleared and returned.
+    pub fn write(&mut self, byte: u8) -> Option<[u8; 256]> {
+        if byte == 0x00 {
+            Some(self.clear())
+        } else {
+            self.buffer[self.pointer as usize] = byte;
+            self.pointer = self.pointer.saturating_add(1);
+            None
+        }
+    }
+}
diff --git a/src/devices/file_device/buffered_file.rs b/src/devices/file_device/buffered_file.rs
new file mode 100644
index 0000000..3487d54
--- /dev/null
+++ b/src/devices/file_device/buffered_file.rs
@@ -0,0 +1,146 @@
+use std::fs::File;
+use std::io::{BufReader, BufWriter};
+use std::io::{Read, Write};
+use std::io::{ErrorKind, Seek, SeekFrom};
+
+use crate::*;
+
+
+pub struct BufferedFile {
+    file: AccessMode,
+}
+
+impl BufferedFile {
+    pub fn new(file: File) -> Self {
+        Self {
+            file: AccessMode::Read(BufReader::new(file)),
+        }
+    }
+
+    pub fn close(&mut self) {
+        self.file = AccessMode::None;
+    }
+
+    pub fn read(&mut self) -> u8 {
+        let mut buffer = [0u8; 1];
+
+        let read_result = match &mut self.file {
+            AccessMode::Read(reader) => reader.read_exact(&mut buffer),
+            AccessMode::Write(writer) => {
+                let address = writer.stream_position().unwrap();
+                let file = std::mem::take(&mut self.file).unwrap();
+                let mut reader = BufReader::new(file);
+                reader.seek(SeekFrom::Start(address)).unwrap();
+                let read_result = reader.read_exact(&mut buffer);
+                self.file = AccessMode::Read(reader);
+                read_result
+            }
+            AccessMode::None => unreachable!(),
+        };
+
+        match read_result {
+            Ok(_) => buffer[0],
+            Err(error) => match error.kind() {
+                ErrorKind::UnexpectedEof => 0,
+                _ => { error!("BufferedFile::read", "{error:?}"); 0 },
+            }
+        }
+    }
+
+    pub fn write(&mut self, byte: u8) {
+        let mut buffer = [byte; 1];
+
+        let write_result = match &mut self.file {
+            AccessMode::Write(writer) => writer.write_all(&mut buffer),
+            AccessMode::Read(reader) => {
+                let address = reader.stream_position().unwrap();
+                let file = std::mem::take(&mut self.file).unwrap();
+                let mut writer = BufWriter::new(file);
+                writer.seek(SeekFrom::Start(address)).unwrap();
+                let write_result = writer.write_all(&mut buffer);
+                self.file = AccessMode::Write(writer);
+                write_result
+            }
+            AccessMode::None => unreachable!(),
+        };
+
+        write_result.unwrap();
+    }
+
+    pub fn pointer(&mut self) -> u32 {
+        let position = match &mut self.file {
+            AccessMode::Read(reader) => reader.stream_position(),
+            AccessMode::Write(writer) => writer.stream_position(),
+            AccessMode::None => unreachable!(),
+        };
+        u32::try_from(position.unwrap()).unwrap_or(u32::MAX)
+    }
+
+    pub fn set_pointer(&mut self, pointer: u32) {
+        let position = SeekFrom::Start(pointer as u64);
+        match &mut self.file {
+            AccessMode::Read(reader) => reader.seek(position).unwrap(),
+            AccessMode::Write(writer) => writer.seek(position).unwrap(),
+            AccessMode::None => unreachable!(),
+        };
+    }
+
+    pub fn length(&mut self) -> u32 {
+        let length = match &mut self.file {
+            AccessMode::Read(reader) => reader.stream_len(),
+            AccessMode::Write(writer) => writer.stream_len(),
+            AccessMode::None => unreachable!(),
+        };
+        u32::try_from(length.unwrap()).unwrap_or(u32::MAX)
+    }
+
+    pub fn set_length(&mut self, length: u32) {
+        match &mut self.file {
+            AccessMode::Read(_) => {
+                let file = std::mem::take(&mut self.file).unwrap();
+                file.set_len(length as u64).unwrap();
+                self.file = AccessMode::Read(BufReader::new(file));
+            }
+            AccessMode::Write(_) => {
+                let file = std::mem::take(&mut self.file).unwrap();
+                file.set_len(length as u64).unwrap();
+                self.file = AccessMode::Read(BufReader::new(file));
+            }
+            AccessMode::None => unreachable!(),
+        };
+    }
+
+    pub fn flush(&mut self) {
+        if let AccessMode::Write(writer) = &mut self.file {
+            writer.flush().unwrap();
+        }
+    }
+}
+
+impl Drop for BufferedFile {
+    fn drop(&mut self) {
+        self.flush()
+    }
+}
+
+enum AccessMode {
+    Read(BufReader<File>),
+    Write(BufWriter<File>),
+    None,
+}
+
+impl AccessMode {
+    pub fn unwrap(self) -> File {
+        match self {
+            Self::Read(reader) => reader.into_inner(),
+            Self::Write(writer) => writer.into_inner().unwrap(),
+            Self::None => unreachable!(),
+        }
+    }
+}
+
+impl Default for AccessMode {
+    fn default() -> Self {
+        Self::None
+    }
+}
diff --git a/src/devices/file_device/directory_listing.rs b/src/devices/file_device/directory_listing.rs
new file mode 100644
index 0000000..1d7ddd2
--- /dev/null
+++ b/src/devices/file_device/directory_listing.rs
@@ -0,0 +1,115 @@
+use super::*;
+
+
+pub struct DirectoryListing {
+    children: Vec<BedrockFilePath>,
+    length: u32,
+    selected: Option<u32>,
+    child_path_buffer: BedrockPathBuffer,
+}
+
+
+impl DirectoryListing {
+    pub fn from_path(path: &BedrockFilePath) -> Option<Self> {
+        macro_rules! unres {
+            ($result:expr) => { match $result { Ok(v) => v, Err(_) => continue} };
+        }
+        macro_rules! unopt {
+            ($option:expr) => { match $option { Some(v) => v, None => continue} };
+        }
+
+        #[cfg(target_family = "windows")] {
+            if path.as_path().components().count() == 0 {
+                return Some(Self::construct_virtual_root())
+            }
+        }
+
+        let mut children = Vec::new();
+        if let Ok(dir_listing) = std::fs::read_dir(path.as_path()) {
+            for (i, entry_result) in dir_listing.enumerate() {
+                // Firebreak to prevent emulator from consuming an absurd amount
+                // of memory when opening too large of a directory.
+                if i == (u16::MAX as usize) {
+                    break;
+                }
+
+                let entry = unres!(entry_result);
+                let entry_path = unopt!(BedrockFilePath::from_path(&entry.path(), path.base()));
+                if entry_path.is_hidden() {
+                    continue;
+                }
+
+                children.push(entry_path);
+            }
+        }
+
+        children.sort();
+        let length = u32::try_from(children.len()).ok()?;
+        let selected = None;
+        let child_path_buffer = BedrockPathBuffer::new();
+        Some( Self { children, length, selected, child_path_buffer } )
+    }
+
+    /// Generate entries for a virtual root directory.
+    #[cfg(target_family = "windows")]
+    fn construct_virtual_root() -> Self {
+        let mut children = Vec::new();
+        let base = PathBuf::from("");
+        let drive_bits = unsafe {
+            windows::Win32::Storage::FileSystem::GetLogicalDrives()
+        };
+        for i in 0..26 {
+            if drive_bits & (0x1 << i) != 0 {
+                let letter: char = (b'A' + i).into();
+                let path = PathBuf::from(format!("{letter}:/"));
+                if let Some(drive) = BedrockFilePath::from_path(&path, &base) {
+                    children.push(drive);
+                }
+            }
+        }
+
+        let length = children.len() as u32;
+        let selected = None;
+        let child_path_buffer = BedrockPathBuffer::new();
+        Self { children, length, selected, child_path_buffer }
+    }
+
+    /// Attempts to return a directory child by index.
+    pub fn get(&self, index: u32) -> Option<&BedrockFilePath> {
+        self.children.get(index as usize)
+    }
+
+    pub fn length(&self) -> u32 {
+        self.length
+    }
+
+    /// Returns the index of the selected child, or zero if no child is selected.
+    pub fn selected(&self) -> u32 {
+        self.selected.unwrap_or(0)
+    }
+
+    /// Attempts to select a child by index.
+    pub fn set_selected(&mut self, index: u32) {
+        if let Some(child) = self.get(index) {
+            let buffer = child.as_buffer();
+            self.child_path_buffer.populate(buffer);
+            self.selected = Some(index);
+        } else {
+            self.child_path_buffer.clear();
+            self.selected = None;
+        }
+    }
+
+    pub fn child_path_buffer(&mut self) -> &mut BedrockPathBuffer {
+        &mut self.child_path_buffer
+    }
+
+    pub fn child_type(&self) -> Option<EntryType> {
+        self.selected.and_then(|s| self.get(s).and_then(|i| i.entry_type()))
+    }
+
+    pub fn child_path(&self) -> Option<BedrockFilePath> {
+        self.selected.and_then(|s| self.get(s).and_then(|i| Some(i.clone())))
+    }
+}
+
diff --git a/src/devices/file_device/entry.rs b/src/devices/file_device/entry.rs
new file mode 100644
index 0000000..d604bb7
--- /dev/null
+++ b/src/devices/file_device/entry.rs
@@ -0,0 +1,36 @@
+use super::*;
+
+use std::cmp::Ordering;
+
+pub enum Entry {
+    File(BufferedFile),
+    Directory(DirectoryListing),
+}
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum EntryType {
+    File,
+    Directory,
+}
+
+impl PartialOrd for EntryType {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match (self, other) {
+            (EntryType::Directory, EntryType::Directory) => Some(Ordering::Equal  ),
+            (EntryType::Directory, EntryType::File     ) => Some(Ordering::Less   ),
+            (EntryType::File,      EntryType::Directory) => Some(Ordering::Greater),
+            (EntryType::File,      EntryType::File     ) => Some(Ordering::Equal  ),
+        }
+    }
+}
+
+impl Ord for EntryType {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match (self, other) {
+            (EntryType::Directory, EntryType::Directory) => Ordering::Equal  ,
+            (EntryType::Directory, EntryType::File     ) => Ordering::Less   ,
+            (EntryType::File,      EntryType::Directory) => Ordering::Greater,
+            (EntryType::File,      EntryType::File     ) => Ordering::Equal  ,
+        }
+    }
+}
diff --git a/src/devices/file_device/operations.rs b/src/devices/file_device/operations.rs
new file mode 100644
index 0000000..3a3f81b
--- /dev/null
+++ b/src/devices/file_device/operations.rs
@@ -0,0 +1,47 @@
+use std::io::ErrorKind;
+use std::path::Path;
+
+
+/// Create a new file if it doesn't already exist, returning true if successful.
+pub fn create_file(destination: &Path) -> bool {
+    if entry_exists(destination) {
+        false
+    } else {
+        if let Some(parent_path) = destination.parent() {
+            let _ = std::fs::create_dir_all(parent_path);
+        }
+        std::fs::OpenOptions::new().write(true).create_new(true)
+            .open(destination).is_ok()
+    }
+}
+
+/// Move an entry from one location to another, returning true if successful.
+pub fn move_entry(source: &Path, destination: &Path) -> bool {
+    if !entry_exists(source) || entry_exists(destination) {
+        return false;
+    }
+    std::fs::rename(source, destination).is_ok()
+}
+
+/// Delete an entry, returning true if successful.
+pub fn delete_entry(source: &Path) -> bool {
+    match std::fs::remove_file(source) {
+        Ok(_) => true,
+        Err(e) => match e.kind() {
+            ErrorKind::NotFound => true,
+            ErrorKind::IsADirectory => match std::fs::remove_dir_all(source) {
+                Ok(_) => true,
+                Err(e) => match e.kind() {
+                    ErrorKind::NotFound => true,
+                    _ => false,
+                }
+            }
+            _ => false,
+        }
+    }
+}
+
+/// Returns true if an entry already exists at the given path.
+fn entry_exists(source: &Path) -> bool {
+    std::fs::metadata(source).is_ok()
+}