pub(crate) fn parse_number_from_string(
&mut self,
- mut string: String,
+ string: &str,
indices: &IndexStore,
stub_gen: impl Fn() -> FunctorStub,
) -> CallResult {
}
}
- string.push('.');
+ let mut dot_buf: [u8; '.'.len_utf8()] = [0u8];
+ '.'.encode_utf8(&mut dot_buf);
- let stream = CharReader::new(std::io::Cursor::new(string));
- let mut parser = Parser::new(stream, self);
+ let cursor = std::io::Cursor::new(string);
+ let iter = std::io::Read::chain(cursor, std::io::Cursor::new(dot_buf));
+
+ let mut parser = Parser::new(CharReader::new(iter), self);
match parser.read_term(&CompositeOpDir::new(&indices.op_dir, None)) {
Err(err) => {
}
}
(HeapCellValueTag::Char, c) => {
- Some(AtomOrString::Atom(self.atom_tbl.build_with(&c.to_string())))
+ Some(AtomOrString::String(c.to_string()))
}
_ => {
if value.is_constant() {
let a2 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
if let Some(str_like) = self.machine_st.value_to_str_like(a2) {
- let atom = match str_like {
+ let atom_cell = match str_like {
AtomOrString::Atom(atom) => {
- if atom == atom!("[]") {
+ atom_as_cell!(if atom == atom!("[]") {
self.machine_st.atom_tbl.build_with("")
} else {
atom
- }
+ })
}
AtomOrString::String(string) => {
- self.machine_st.atom_tbl.build_with(&string)
+ atom_as_cell!(self.machine_st.atom_tbl.build_with(&string))
}
};
- self.machine_st.bind(a1.as_var().unwrap(), atom_as_cell!(atom));
+ self.machine_st.bind(a1.as_var().unwrap(), atom_cell);
return;
}
if let Some(atom_or_string) = self.machine_st.value_to_str_like(a1) {
self.machine_st.parse_number_from_string(
- atom_or_string.to_string(),
+ atom_or_string.as_str(),
&self.indices,
stub_gen,
)?;
}
Ok(addrs) => {
let string = self.machine_st.codes_to_string(addrs.into_iter(), stub_gen)?;
- self.machine_st.parse_number_from_string(string, &self.indices, stub_gen)?;
+ self.machine_st.parse_number_from_string(string.as_str(), &self.indices, stub_gen)?;
}
}
Err(e) => return Err(e)
};
if let Some(address_sink) = self.machine_st.value_to_str_like(address_sink) {
- let address_string = match address_sink {
- AtomOrString::Atom(atom) => {
- String::from(atom.as_str())
- }
- AtomOrString::String(string) => {
- String::from(string.as_str())
- }
- };
+ let address_string = address_sink.as_str(); //to_string();
let address: Uri = address_string.parse().unwrap();
let stream = self.runtime.block_on(async {
let options = self.machine_st.to_stream_options(alias, eof_action, reposition, stream_type);
let src_sink = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
- if let Some(str_like) = self.machine_st.value_to_str_like(src_sink) {
- let file_spec = match str_like {
- AtomOrString::Atom(atom) => {
- atom
- }
- AtomOrString::String(string) => {
- self.machine_st.atom_tbl.build_with(&string)
- }
- };
+ if let Some(file_spec) = self.machine_st.value_to_str_like(src_sink) {
+ let file_spec = file_spec.as_atom(&mut self.machine_st.atom_tbl);
let mut stream = self.machine_st.stream_from_file_spec(
file_spec,
}
}
-/*
-impl<R: Seek> BufReader<R> {
- /// Seeks relative to the current position. If the new position lies within the buffer,
- /// the buffer will not be flushed, allowing for more efficient seeks.
- /// This method does not return the location of the underlying reader, so the caller
- /// must track this information themselves if it is required.
- #[stable(feature = "bufreader_seek_relative", since = "1.53.0")]
- pub fn seek_relative(&mut self, offset: i64) -> io::Result<()> {
- let pos = self.pos as u64;
- if offset < 0 {
- if let Some(new_pos) = pos.checked_sub((-offset) as u64) {
- self.pos = new_pos as usize;
- return Ok(());
- }
- } else {
- if let Some(new_pos) = pos.checked_add(offset as u64) {
- if new_pos <= self.cap as u64 {
- self.pos = new_pos as usize;
- return Ok(());
- }
- }
- }
- self.seek(SeekFrom::Current(offset)).map(drop)
- }
-}
-*/
-
impl<R: Read> Read for CharReader<R> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
// // If we don't have any buffered data and we're doing a massive read
}
}
-/*
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<R: Seek> Seek for BufReader<R> {
- /// Seek to an offset, in bytes, in the underlying reader.
- ///
- /// The position used for seeking with [`SeekFrom::Current`]`(_)` is the
- /// position the underlying reader would be at if the `BufReader<R>` had no
- /// internal buffer.
- ///
- /// Seeking always discards the internal buffer, even if the seek position
- /// would otherwise fall within it. This guarantees that calling
- /// [`BufReader::into_inner()`] immediately after a seek yields the underlying reader
- /// at the same position.
- ///
- /// To seek without discarding the internal buffer, use [`BufReader::seek_relative`].
- ///
- /// See [`std::io::Seek`] for more details.
- ///
- /// Note: In the edge case where you're seeking with [`SeekFrom::Current`]`(n)`
- /// where `n` minus the internal buffer length overflows an `i64`, two
- /// seeks will be performed instead of one. If the second seek returns
- /// [`Err`], the underlying reader will be left at the same position it would
- /// have if you called `seek` with [`SeekFrom::Current`]`(0)`.
- ///
- /// [`std::io::Seek`]: Seek
- fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
- let result: u64;
- if let SeekFrom::Current(n) = pos {
- let remainder = (self.cap - self.pos) as i64;
- // it should be safe to assume that remainder fits within an i64 as the alternative
- // means we managed to allocate 8 exbibytes and that's absurd.
- // But it's not out of the realm of possibility for some weird underlying reader to
- // support seeking by i64::MIN so we need to handle underflow when subtracting
- // remainder.
- if let Some(offset) = n.checked_sub(remainder) {
- result = self.inner.seek(SeekFrom::Current(offset))?;
- } else {
- // seek backwards by our remainder, and then by the offset
- self.inner.seek(SeekFrom::Current(-remainder))?;
- self.discard_buffer();
- result = self.inner.seek(SeekFrom::Current(n))?;
- }
- } else {
- // Seeking with Start/End doesn't care about our buffer length.
- result = self.inner.seek(pos)?;
- }
- self.discard_buffer();
- Ok(result)
- }
-
- /// Returns the current seek position from the start of the stream.
- ///
- /// The value returned is equivalent to `self.seek(SeekFrom::Current(0))`
- /// but does not flush the internal buffer. Due to this optimization the
- /// function does not guarantee that calling `.into_inner()` immediately
- /// afterwards will yield the underlying reader at the same position. Use
- /// [`BufReader::seek`] instead if you require that guarantee.
- ///
- /// # Panics
- ///
- /// This function will panic if the position of the inner reader is smaller
- /// than the amount of buffered data. That can happen if the inner reader
- /// has an incorrect implementation of [`Seek::stream_position`], or if the
- /// position has gone out of sync due to calling [`Seek::seek`] directly on
- /// the underlying reader.
- ///
- /// # Example
- ///
- /// ```no_run
- /// use std::{
- /// io::{self, BufRead, BufReader, Seek},
- /// fs::File,
- /// };
- ///
- /// fn main() -> io::Result<()> {
- /// let mut f = BufReader::new(File::open("foo.txt")?);
- ///
- /// let before = f.stream_position()?;
- /// f.read_line(&mut String::new())?;
- /// let after = f.stream_position()?;
- ///
- /// println!("The first line was {} bytes long", after - before);
- /// Ok(())
- /// }
- /// ```
- fn stream_position(&mut self) -> io::Result<u64> {
- let remainder = (self.cap - self.pos) as u64;
- self.inner.stream_position().map(|pos| {
- pos.checked_sub(remainder).expect(
- "overflow when subtracting remaining buffer size from inner stream position",
- )
- })
- }
-}
-*/
-/*
-impl<T> SizeHint for CharReader<T> {
- fn lower_bound(&self) -> usize {
- self.buffer().len()
- }
-}
-*/
#[cfg(test)]
mod tests {
projects / scryer-prolog.git / commitdiff