echo Cleanup workspace build artifacts and extra target output
# clean just the direct members of the current workspace, use cargo metadata to generalize to all rust projects
-cargo clean -p `cargo metadata --no-deps --offline --format-version 1 | jq -r '[.workspace_members[]|split(" ")|.[0]]|join(" ")'`
+cargo clean --workspace
# remove directories in /target/ that are not named `debug` or `release`
before=`du -s target | awk '{print $1}'`
crypto-inpure = ["dep:ring"]
crypto-full = ["crypto-inpure"]
+[lints.clippy]
+collapsible_match = "allow"
+
[lints.rust]
unexpected_cfgs = { level = "deny", check-cfg = [
'cfg(rust_version, values("1.87.0"))',
] }
function_casts_as_integer = "deny"
-
[build-dependencies]
proc-macro2 = "1.0.86"
quote = "1.0.36"
use std::fmt;
use std::fmt::Debug;
use std::hash::{Hash, Hasher};
+use std::io::PipeReader;
+use std::io::PipeWriter;
use std::mem;
use std::mem::ManuallyDrop;
use std::net::TcpListener;
use std::ptr::addr_of_mut;
use std::ptr::NonNull;
-use crate::machine::streams::{PipeReader, PipeWriter};
-
macro_rules! arena_alloc {
($e:expr, $arena:expr) => {{
let result = $e;
settings.trust_me()
});
- combined_code.extend(code.into_iter());
+ combined_code.extend(code);
}
}
}
self.skeleton.clauses.push_back(clause_index_info);
- code.extend(clause_code.into_iter());
+ code.extend(clause_code);
}
let index_code = if clauses_len > 1 || self.settings.is_extensible {
}
}
- code.extend(code_segment.into_iter());
+ code.extend(code_segment);
}
Ok(code)
/// The entry point for the Scryer Prolog CLI.
pub fn run_binary() -> std::process::ExitCode {
use crate::atom_table::Atom;
+
+ #[cfg(feature = "repl")]
use crate::machine::INTERRUPT;
#[cfg(feature = "repl")]
self.trail
.push((TrailRef::pstr_loc(pstr_loc_idx), old_cell));
- let old_tail_idx = if (pstr_loc + offset + 1) % Heap::heap_cell_alignment() == 0 {
- cell_index!(pstr_loc + offset) + 2
- } else {
- cell_index!(pstr_loc + offset) + 1
- };
+ let old_tail_idx =
+ if (pstr_loc + offset + 1).is_multiple_of(Heap::heap_cell_alignment()) {
+ cell_index!(pstr_loc + offset) + 2
+ } else {
+ cell_index!(pstr_loc + offset) + 1
+ };
let tail_cell = self.target[old_tail_idx];
let first_branch_num = Arc::new(self.current_branch_num.split());
let branches: Vec<_> = std::iter::once(head)
- .chain(unfold_by_str(tail, atom!(";")).into_iter())
+ .chain(unfold_by_str(tail, atom!(";")))
.collect();
let mut branch_numbers = vec![first_branch_num];
self.current_branch_num.halve_delta(),
)));
- let iter = branches.into_iter().zip(branch_numbers.into_iter());
+ let iter = branches.into_iter().zip(branch_numbers);
let final_disjunct_loc = state_stack.len();
for (term, branch_num) in iter.rev() {
// takes a heap index, returns a cell index
#[inline]
pub const fn pstr_tail_idx(pstr_zero_byte_loc: usize) -> usize {
- if (pstr_zero_byte_loc + 1) % Heap::heap_cell_alignment() == 0 {
+ if (pstr_zero_byte_loc + 1).is_multiple_of(Heap::heap_cell_alignment()) {
cell_index!(pstr_zero_byte_loc) + 2
} else {
cell_index!(pstr_zero_byte_loc) + 1
}
#[derive(Debug, Clone, Copy)]
+#[cfg_attr(not(feature = "ffi"), expect(dead_code))]
pub(crate) enum DomainErrorType {
IOMode,
NotLessThanZero,
// from 7.12.2 f) of 13211-1:1995
#[derive(Debug, Clone, Copy)]
+#[cfg_attr(not(feature = "ffi"), expect(dead_code))]
pub(crate) enum RepFlag {
Character,
CharacterCode,
}
#[derive(Debug)]
+#[cfg_attr(not(feature = "ffi"), expect(dead_code))]
pub enum ExistenceError {
Module(Atom),
ModuleSource(ModuleSource),
return true;
}
- // use strict_add once msrv is >= 1.91.0
- self.cwil.global_count = self.cwil.global_count.checked_add(1).unwrap();
+ self.cwil.global_count = self.cwil.global_count.strict_add(1);
if let Some(&(ref limit, block)) = self.cwil.limits.last() {
if self.cwil.local_count == *limit {
mut var_list: Vec<(VarKey, HeapCellValue, usize)>,
singleton_heap_list: HeapCellValue,
) -> CallResult {
- var_list.sort_by(|(_, _, idx_1), (_, _, idx_2)| idx_1.cmp(idx_2));
+ var_list.sort_by_key(|(_, _, idx_1)| *idx_1);
let singleton_addr = self.registers[3];
unify_fn!(*self, singleton_heap_list, singleton_addr);
}
pub(crate) fn add_limit(&mut self, mut limit: u128, block: usize) -> u128 {
- // use strict_add once msrv is >= 1.91.0
- limit = limit.checked_add(self.local_count).unwrap();
+ limit = limit.strict_add(self.local_count);
match self.limits.last() {
Some((ref inner_limit, _)) if *inner_limit <= limit => {}
// exposed provenance, we need to expose the provenance here, even though we don't
// actually use the value for anything. This is a reminder that `expose_provenance`
// isn't just a cast from a pointer to an integer but has actual side effects.
- // FIXME(msrv) remove the as_ptr() call once MSRV reaches 1.89.0
- cell_ptr.as_ptr().expose_provenance();
+ cell_ptr.expose_provenance();
offset += mem::size_of::<HeapCellValue>();
}
// exposed provenance, we need to expose the provenance here, even though we don't
// actually use the value for anything. This is a reminder that `expose_provenance`
// isn't just a cast from a pointer to an integer but has actual side effects.
- // FIXME(msrv) remove as_ptr() call once msrv reaches 1.89.0
- cell_ptr.as_ptr().expose_provenance();
+ cell_ptr.expose_provenance();
offset += mem::size_of::<HeapCellValue>();
}
use std::fs::{File, OpenOptions};
use std::hash::Hash;
use std::io;
+use std::io::PipeReader;
+use std::io::PipeWriter;
use std::io::{Cursor, ErrorKind, Read, Seek, SeekFrom, Write};
use std::mem::ManuallyDrop;
use std::net::{Shutdown, TcpStream};
#[cfg(feature = "http")]
use warp::hyper;
-mod compat;
-pub use compat::*;
-
#[derive(Debug, Specifier, Clone, Copy, PartialEq, Eq, Hash)]
#[bits = 1]
pub enum StreamType {
+++ /dev/null
-#[cfg(rust_version = "1.87.0")]
-pub use ge_1_87_0::{PipeReader, PipeWriter};
-
-#[cfg(not(rust_version = "1.87.0"))]
-pub use lt_1_87_0::{PipeReader, PipeWriter};
-
-#[cfg(not(rust_version = "1.87.0"))]
-pub(crate) use lt_1_87_0::PipeReaderInner;
-
-#[cfg(not(rust_version = "1.87.0"))]
-mod lt_1_87_0 {
- use std::process::{ChildStderr, ChildStdout};
-
- pub type PipeWriter = std::process::ChildStdin;
-
- #[derive(Debug)]
- pub struct PipeReader(pub(crate) PipeReaderInner);
-
- #[derive(Debug)]
- pub(crate) enum PipeReaderInner {
- Stdout(ChildStdout),
- Stderr(ChildStderr),
- }
-
- impl std::io::Read for PipeReader {
- fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
- match &mut self.0 {
- PipeReaderInner::Stdout(child_stdout) => child_stdout.read(buf),
- PipeReaderInner::Stderr(child_stderr) => child_stderr.read(buf),
- }
- }
-
- fn read_vectored(
- &mut self,
- bufs: &mut [std::io::IoSliceMut<'_>],
- ) -> std::io::Result<usize> {
- match &mut self.0 {
- PipeReaderInner::Stdout(child_stdout) => child_stdout.read_vectored(bufs),
- PipeReaderInner::Stderr(child_stderr) => child_stderr.read_vectored(bufs),
- }
- }
-
- fn read_to_end(&mut self, buf: &mut Vec<u8>) -> std::io::Result<usize> {
- match &mut self.0 {
- PipeReaderInner::Stdout(child_stdout) => child_stdout.read_to_end(buf),
- PipeReaderInner::Stderr(child_stderr) => child_stderr.read_to_end(buf),
- }
- }
-
- fn read_to_string(&mut self, buf: &mut String) -> std::io::Result<usize> {
- match &mut self.0 {
- PipeReaderInner::Stdout(child_stdout) => child_stdout.read_to_string(buf),
- PipeReaderInner::Stderr(child_stderr) => child_stderr.read_to_string(buf),
- }
- }
-
- fn read_exact(&mut self, buf: &mut [u8]) -> std::io::Result<()> {
- match &mut self.0 {
- PipeReaderInner::Stdout(child_stdout) => child_stdout.read_exact(buf),
- PipeReaderInner::Stderr(child_stderr) => child_stderr.read_exact(buf),
- }
- }
- }
-}
-
-#[cfg(rust_version = "1.87.0")]
-mod ge_1_87_0 {
- #![allow(clippy::incompatible_msrv)]
-
- pub type PipeReader = std::io::PipeReader;
- pub type PipeWriter = std::io::PipeWriter;
-}
Some(atom!("std")) => Stdio::inherit(),
Some(atom!("null")) => Stdio::null(),
Some(atom!("pipe")) => {
- #[cfg(rust_version = "1.87.0")]
- #[allow(clippy::incompatible_msrv)]
- {
- let (reader, writer) = match std::io::pipe() {
- Ok(pipe_pair) => pipe_pair,
- Err(_) => {
- return Err(self.machine_st.open_permission_error(
- atom!("anonymous_pipe"),
- atom!("process_create"),
- 3,
- ));
- }
- };
-
- let stream = Stream::from_pipe_writer(writer, &mut self.machine_st.arena);
+ let (reader, writer) = match std::io::pipe() {
+ Ok(pipe_pair) => pipe_pair,
+ Err(_) => {
+ return Err(self.machine_st.open_permission_error(
+ atom!("anonymous_pipe"),
+ atom!("process_create"),
+ 3,
+ ));
+ }
+ };
- self.indices
- .add_stream(stream, atom!("process_create"), 3)
- .map_err(|stub_gen| stub_gen(&mut self.machine_st))?;
+ let stream = Stream::from_pipe_writer(writer, &mut self.machine_st.arena);
- self.machine_st
- .bind(args[1].as_var().unwrap(), stream.into());
+ self.indices
+ .add_stream(stream, atom!("process_create"), 3)
+ .map_err(|stub_gen| stub_gen(&mut self.machine_st))?;
- Stdio::from(reader)
- }
+ self.machine_st
+ .bind(args[1].as_var().unwrap(), stream.into());
- #[cfg(not(rust_version = "1.87.0"))]
- {
- Stdio::piped()
- }
+ Stdio::from(reader)
}
Some(atom!("file")) => {
let path = self.machine_st.value_to_str_like(args[1]).unwrap();
#[cfg(feature = "crypto-inpure")]
fn rng() -> &'static dyn SecureRandom {
- use lazy_static::lazy_static;
use std::ops::Deref;
static RANDOM: LazyLock<SystemRandom> = LazyLock::new(SystemRandom::new);
use crate::helper::load_module_test;
use crate::helper::load_module_test_with_input;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "http", not(target_arch = "wasm32")))]
use crate::helper::load_module_test_with_tokio_runtime_and_input;
use serial_test::serial;
}
#[test]
-#[cfg(feature = "http")]
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "http", not(target_arch = "wasm32")))]
#[cfg_attr(miri, ignore = "it takes too long to run")]
fn http_open_hanging() {
load_module_test_with_tokio_runtime_and_input(
projects / scryer-prolog.git / commitdiff