ENHANCED: Read more characters at once, significantly speeding up library(pio).

src/machine/system_calls.rs

@@ -2256,6 +2256,64 @@ impl MachineState {
                     }
                 }
             }
+            &SystemClauseType::GetNChars => {
+                let stream =
+                    self.get_stream_or_alias(self[temp_v!(1)], indices, "get_n_chars", 3)?;
+
+                let num =
+                    match Number::try_from((self[temp_v!(2)], &self.heap)) {
+                        Ok(Number::Fixnum(n)) => {
+                            usize::try_from(n).unwrap()
+                        }
+                        Ok(Number::Integer(n)) => {
+                            match n.to_usize() {
+                                Some(u) => { u }
+                                _ => { self.fail = true; return Ok(()); }
+                            }
+                        }
+                        _ => { unreachable!() }
+                    };
+
+                let chars = {
+                   let mut str = String::new();
+
+                   if stream.options.stream_type == StreamType::Binary {
+                        let mut mstream = stream.clone();
+                        for _ in 0..num {
+                            let mut b = [0u8; 1];
+
+                            match mstream.read(&mut b) {
+                                Ok(1) => {
+                                    str.push(b[0] as char);
+                                }
+                                _ => {
+                                    break;
+                                }
+                            }
+                        }
+                    } else {
+                        let mut iter = self.open_parsing_stream(stream.clone(),
+                                                                "get_n_chars",
+                                                                2,
+                                                                )?;
+
+                        for _ in 0..num {
+                             let result = iter.next();
+
+                             match result {
+                                 Some(Ok(c)) => {
+                                    str.push(c);
+                                 }
+                                 _ => { break;
+                                 }
+                              }
+                         }
+                    }
+                    str
+                };
+                let str = self.heap.put_complete_string(&chars);
+                self.unify(self[temp_v!(3)], str);
+            }
             &SystemClauseType::GetCode => {
                 let mut stream =
                     self.get_stream_or_alias(self[temp_v!(1)], indices, "get_code", 2)?;