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.

1 files 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);
         }
     }