throw resource error if OpenOptions raises an error of uncategorized kind (#1375)

src/machine/machine_errors.rs

@@ -77,6 +77,12 @@ impl ValidType {
     }
 }
 
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum ResourceError {
+    FiniteMemory(HeapCellValue),
+    OutOfFiles
+}
+
 pub(crate) trait TypeError {
     fn type_error(self, machine_st: &mut MachineState, valid_type: ValidType) -> MachineError;
 }
@@ -284,11 +290,21 @@ impl MachineState {
         }
     }
 
-    pub(super) fn resource_error(&mut self, value: HeapCellValue) -> MachineError {
+    pub(super) fn resource_error(&mut self, err: ResourceError) -> MachineError {
-        let stub = functor!(
+        let stub = match err {
-            atom!("resource_error"),
+            ResourceError::FiniteMemory(size_requested) => {
-            [atom(atom!("finite_memory")), cell(value)]
+                functor!(
-        );
+                    atom!("resource_error"),
+                    [atom(atom!("finite_memory")), cell(size_requested)]
+                )
+            }
+            ResourceError::OutOfFiles => {
+                functor!(
+                    atom!("resource_atom"),
+                    [atom(atom!("out_of_files"))]
+                )
+            }
+        };
 
         MachineError {
             stub,

src/machine/streams.rs

@@ -1804,7 +1804,7 @@ impl MachineState {
     ) -> Result<Stream, MachineStub> {
         if file_spec == atom!("") {
             let stub = functor_stub(atom!("open"), 4);
-            let err = self.domain_error(DomainErrorType::SourceSink, self[temp_v!(1)]);
+            let err = self.domain_error(DomainErrorType::SourceSink, self.registers[1]);
 
             return Err(self.error_form(err, stub));
         }
@@ -1816,9 +1816,7 @@ impl MachineState {
             }
         }
 
-        let mode = MachineState::deref(self, self[temp_v!(2)]);
+        let mode = cell_as_atom!(self.store(MachineState::deref(self, self.registers[2])));
-        let mode = cell_as_atom!(self.store(mode));
-
         let mut open_options = OpenOptions::new();
 
         let (is_input_file, in_append_mode) = match mode {
@@ -1875,8 +1873,9 @@ impl MachineState {
                         ));
                     }
                     _ => {
+                        // assume the OS is out of file descriptors.
                         let stub = functor_stub(atom!("open"), 4);
-                        let err = self.syntax_error(ParserError::IO(err));
+                        let err = self.resource_error(ResourceError::OutOfFiles);
 
                         return Err(self.error_form(err, stub));
                     }

src/machine/system_calls.rs

@@ -4244,7 +4244,7 @@ impl Machine {
             Ok(Number::Integer(n)) => match (&*n).try_into() as Result<usize, _> {
                 Ok(n) => n,
                 Err(_) => {
-                    let err = self.machine_st.resource_error(len);
+                    let err = self.machine_st.resource_error(ResourceError::FiniteMemory(len));
                     return Err(self.machine_st.error_form(err, stub_gen()));
                 }
             },