From 967866ca2ec7d066e510b287522c8f69de2c3232 Mon Sep 17 00:00:00 2001
From: Ben Bridle <ben@derelict.engineering>
Date: Thu, 18 Sep 2025 19:23:56 +1200
Subject: Use an error flag for file device errors

This was a change that was made in the latest revision of the
specification (revision 2). The action port of the file device had
previously reported successes, but it will now report errors instead.
---
 src/devices/file_device.rs | 58 +++++++++++++++++++++++++++++-----------------
 1 file changed, 37 insertions(+), 21 deletions(-)

diff --git a/src/devices/file_device.rs b/src/devices/file_device.rs
index 73f05cc..83f0a56 100644
--- a/src/devices/file_device.rs
+++ b/src/devices/file_device.rs
@@ -12,7 +12,7 @@ pub struct FileDevice {
     pub entry: Option<(Entry, BedrockFilePath, Instant)>,
     pub cached_dir: Option<(Entry, BedrockFilePath, Instant)>,
 
-    pub success: bool,
+    pub error: bool,
     pub pointer_write: u32,
     pub length_write: u32,
 
@@ -30,7 +30,7 @@ impl Device for FileDevice {
         if !self.enable { return 0x00; }
         match port {
             0x0 => read_b!(self.entry.is_some()),
-            0x1 => read_b!(self.success),
+            0x1 => read_b!(std::mem::take(&mut self.error)),
             0x2 => self.read_byte(),
             0x3 => self.read_byte(),
             0x4 => self.path_buffer.read(),
@@ -121,7 +121,7 @@ impl FileDevice {
             entry: None,
             cached_dir: None,
 
-            success: false,
+            error: false,
             pointer_write: 0,
             length_write: 0,
 
@@ -134,6 +134,12 @@ impl FileDevice {
         }
     }
 
+    pub fn check_success(&mut self, success: bool) {
+        if !success {
+            self.error = true;
+        }
+    }
+
     /// Safely close the current entry, cleaning up entry variables.
     pub fn close(&mut self) {
         self.entry_buffer.clear();
@@ -192,10 +198,16 @@ impl FileDevice {
     pub fn write_to_entry_port(&mut self, byte: u8) {
         if let Some(buffer) = self.entry_buffer.write(byte) {
             self.close();
-            match BedrockFilePath::from_buffer(buffer, &self.base_path) {
-                Some(path) => self.success = self.open(path).is_ok(),
-                None =>       self.success = false,
-            };
+            // Attempt to open file if buffer was not empty.
+            if buffer[0] != 0 {
+                let success = match BedrockFilePath::from_buffer(buffer, &self.base_path) {
+                    Some(path) => self.open(path).is_ok(),
+                    None => false,
+                };
+                self.check_success(success);
+            } else {
+                self.check_success(true);
+            }
         }
     }
 
@@ -204,22 +216,23 @@ impl FileDevice {
         if let Some(buffer) = self.action_buffer.write(byte) {
             let destination_blank = buffer[0] == 0x00;
             let destination = BedrockFilePath::from_buffer(buffer, &self.base_path);
-            self.success = false;
 
             if let Some((_, source, _)) = &self.entry {
                 if destination_blank {
                     if self.enable_delete {
-                        self.success = delete_entry(&source.as_path());
+                        self.check_success(delete_entry(&source.as_path()));
                     }
                 } else if let Some(dest) = destination {
                     if self.enable_move {
-                        self.success = move_entry(&source.as_path(), &dest.as_path());
+                        self.check_success(move_entry(&source.as_path(), &dest.as_path()));
                     }
                 }
             } else if let Some(dest) = destination {
                 if self.enable_create {
-                    self.success = create_file(&dest.as_path());
+                    self.check_success(create_file(&dest.as_path()));
                 }
+            } else {
+                self.check_success(false);
             }
             self.close();
         }
@@ -228,27 +241,30 @@ impl FileDevice {
     /// Attempt to open the parent directory of the current entry.
     pub fn ascend_to_parent(&mut self) {
         if let Some((_, path, _)) = &self.entry {
-            match path.parent() {
-                Some(parent) => self.success = self.open(parent).is_ok(),
-                None         => self.success = false,
+            let success = match path.parent() {
+                Some(parent) => self.open(parent).is_ok(),
+                None         => false,
             };
+            self.check_success(success);
         } else {
-            match BedrockFilePath::from_path(&self.default_path, &self.base_path) {
-                Some(default) => self.success = self.open(default).is_ok(),
-                None          => self.success = false,
+            let success = match BedrockFilePath::from_path(&self.default_path, &self.base_path) {
+                Some(default) => self.open(default).is_ok(),
+                None          => false,
             };
+            self.check_success(success);
         }
     }
 
     /// Attempt to open the selected child of the current directory.
     pub fn descend_to_child(&mut self) {
         if let Some((Entry::Directory(dir), _, _)) = &self.entry {
-            match dir.child_path() {
-                Some(child) => self.success = self.open(child).is_ok(),
-                None        => self.success = false,
+            let success = match dir.child_path() {
+                Some(child) => self.open(child).is_ok(),
+                None        => false,
             };
+            self.check_success(success);
         } else {
-            self.success = false;
+            self.check_success(false);
         }
     }
 
-- 
cgit v1.2.3-70-g09d2