struct NextOrFail;
struct RegType;
+#[allow(clippy::enum_variant_names)]
#[allow(dead_code)]
#[derive(ToDeriveInput, EnumDiscriminants)]
#[strum_discriminants(derive(EnumProperty, EnumString))]
NumberEqual(ArithmeticTerm, ArithmeticTerm),
}
+#[allow(clippy::enum_variant_names)]
#[allow(dead_code)]
#[derive(ToDeriveInput, EnumDiscriminants)]
#[strum_discriminants(derive(EnumProperty, EnumString))]
AddNonCountedBacktracking,
}
+#[allow(clippy::upper_case_acronyms)]
#[allow(dead_code)]
#[derive(ToDeriveInput, EnumDiscriminants)]
#[strum_discriminants(derive(EnumProperty, EnumString))]
}
impl ArithmeticTerm {
- fn into_functor(&self, arena: &mut Arena) -> MachineStub {
+ fn into_functor(self, arena: &mut Arena) -> MachineStub {
match self {
- &ArithmeticTerm::Reg(r) => reg_type_into_functor(r),
- &ArithmeticTerm::Interm(i) => {
+ ArithmeticTerm::Reg(r) => reg_type_into_functor(r),
+ ArithmeticTerm::Interm(i) => {
functor!(atom!("intermediate"), [fixnum(i)])
}
- &ArithmeticTerm::Number(n) => {
+ ArithmeticTerm::Number(n) => {
vec![HeapCellValue::from((n, arena))]
}
}
impl NextOrFail {
#[inline]
pub fn is_next(&self) -> bool {
- if let NextOrFail::Next(_) = self {
- true
- } else {
- false
- }
+ matches!(self, NextOrFail::Next(_))
}
}
- #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+ #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Death {
Finite(usize),
+ #[default]
Infinity,
}
- impl Default for Death {
- fn default() -> Self {
- Death::Infinity
- }
- }
-
#[derive(Clone, Copy, Debug)]
pub enum IndexedChoiceInstruction {
Retry(usize),
impl IndexedChoiceInstruction {
pub(crate) fn offset(&self) -> usize {
- match self {
- &IndexedChoiceInstruction::Retry(offset) => offset,
- &IndexedChoiceInstruction::Trust(offset) => offset,
- &IndexedChoiceInstruction::Try(offset) => offset,
- &IndexedChoiceInstruction::DefaultRetry(offset) => offset,
- &IndexedChoiceInstruction::DefaultTrust(offset) => offset,
+ match *self {
+ IndexedChoiceInstruction::Retry(offset) => offset,
+ IndexedChoiceInstruction::Trust(offset) => offset,
+ IndexedChoiceInstruction::Try(offset) => offset,
+ IndexedChoiceInstruction::DefaultRetry(offset) => offset,
+ IndexedChoiceInstruction::DefaultTrust(offset) => offset,
}
}
- pub(crate) fn to_functor(&self) -> MachineStub {
+ pub(crate) fn to_functor(self) -> MachineStub {
match self {
- &IndexedChoiceInstruction::Try(offset) => {
+ IndexedChoiceInstruction::Try(offset) => {
functor!(atom!("try"), [fixnum(offset)])
}
- &IndexedChoiceInstruction::Trust(offset) => {
+ IndexedChoiceInstruction::Trust(offset) => {
functor!(atom!("trust"), [fixnum(offset)])
}
- &IndexedChoiceInstruction::Retry(offset) => {
+ IndexedChoiceInstruction::Retry(offset) => {
functor!(atom!("retry"), [fixnum(offset)])
}
- &IndexedChoiceInstruction::DefaultTrust(offset) => {
+ IndexedChoiceInstruction::DefaultTrust(offset) => {
functor!(atom!("default_trust"), [fixnum(offset)])
}
- &IndexedChoiceInstruction::DefaultRetry(offset) => {
+ IndexedChoiceInstruction::DefaultRetry(offset) => {
functor!(atom!("default_retry"), [fixnum(offset)])
}
}
]
)
}
- &IndexingInstruction::SwitchOnConstant(ref constants) => {
+ IndexingInstruction::SwitchOnConstant(constants) => {
let mut key_value_list_stub = vec![];
let orig_h = h;
[key_value_list_stub]
)
}
- &IndexingInstruction::SwitchOnStructure(ref structures) => {
+ IndexingInstruction::SwitchOnStructure(structures) => {
let mut key_value_list_stub = vec![];
let orig_h = h;
#[inline]
pub fn is_head_instr(&self) -> bool {
- match self {
+ matches!(self,
Instruction::Deallocate |
Instruction::GetConstant(..) |
Instruction::GetList(..) |
Instruction::SetLocalValue(..) |
Instruction::SetVariable(..) |
Instruction::SetValue(..) |
- Instruction::SetVoid(..) => true,
- _ => false,
- }
+ Instruction::SetVoid(..))
}
pub fn enqueue_functors(
functors: &mut Vec<MachineStub>,
) {
match self {
- &Instruction::IndexingCode(ref indexing_instrs) => {
+ Instruction::IndexingCode(indexing_instrs) => {
for indexing_instr in indexing_instrs {
match indexing_instr {
IndexingLine::Indexing(indexing_instr) => {
let mut is_inlined_arms = vec![];
is_inbuilt_arms.push(quote! {
- (atom!(":-"), 1 | 2) => true
+ (atom!(":-"), 1 | 2)
});
for (name, arity, variant) in instr_data.compare_number_variants {
});
is_inbuilt_arms.push(quote! {
- (atom!(#name), #arity) => true
+ (atom!(#name), #arity)
});
is_inlined_arms.push(quote! {
- (atom!(#name), #arity) => true
+ (atom!(#name), #arity)
});
}
});
is_inbuilt_arms.push(quote! {
- (atom!(#name), #arity) => true
+ (atom!(#name), #arity)
});
}
});
is_inbuilt_arms.push(quote! {
- (atom!(#name), #arity) => true
+ (atom!(#name), #arity)
});
}
});
is_inbuilt_arms.push(quote! {
- (atom!(#name), #arity) => true
+ (atom!(#name), #arity)
});
is_inlined_arms.push(quote! {
- (atom!(#name), #arity) => true
+ (atom!(#name), #arity)
});
}
for (name, arity, variant) in instr_data.system_clause_type_variants {
let ident = variant.ident.clone();
+ let ident_s = ident.to_string();
let variant_fields: Vec<_> = variant
.fields
.collect();
clause_type_from_name_and_arity_arms.push(if !variant_fields.is_empty() {
- if ident.to_string() == "SetCutPoint" {
- quote! {
- (atom!(#name), #arity) => ClauseType::System(
- SystemClauseType::#ident(temp_v!(1))
- )
- }
- } else if ident.to_string() == "SetCutPointByDefault" {
+ if ident_s == "SetCutPoint" || ident_s == "SetCutPointByDefault" {
quote! {
(atom!(#name), #arity) => ClauseType::System(
SystemClauseType::#ident(temp_v!(1))
)
}
- } else if ident.to_string() == "InlineCallN" {
+ } else if ident_s == "InlineCallN" {
quote! {
(atom!(#name), arity) => ClauseType::System(
SystemClauseType::#ident(arity)
is_inbuilt_arms.push(if let Arity::Ident("arity") = &arity {
quote! {
- (atom!(#name), _arity) => true
+ (atom!(#name), _)
}
} else {
quote! {
- (atom!(#name), #arity) => true
+ (atom!(#name), #arity)
}
});
}
});
is_inbuilt_arms.push(quote! {
- (atom!(#name), #arity) => true
+ (atom!(#name), #arity)
});
}
});
is_inbuilt_arms.push(quote! {
- (atom!(#name), _arity) => true
+ (atom!(#name), _)
});
}
let placeholder_ids: Vec<_> =
(0..enum_arity).map(|n| format_ident!("f_{}", n)).collect();
- if variant_string.starts_with("Call") {
- let execute_ident = format_ident!("Execute{}", variant_string["Call".len()..]);
+ if let Some(variant_suffix) = variant_string.strip_prefix("Call") {
+ let execute_ident = format_ident!("Execute{}", variant_suffix);
Some(if enum_arity == 0 {
quote! {
Instruction::#execute_ident(#(#placeholder_ids),*)
}
})
- } else if variant_string.starts_with("DefaultCall") {
- let execute_ident =
- format_ident!("DefaultExecute{}", variant_string["DefaultCall".len()..]);
+ } else if let Some(variant_suffix) = variant_string.strip_prefix("DefaultCall") {
+ let execute_ident = format_ident!("DefaultExecute{}", variant_suffix);
Some(if enum_arity == 0 {
quote! {
0
};
- if variant_string.starts_with("Execute") {
+ if variant_string.starts_with("Execute") || variant_string.starts_with("DefaultExecute")
+ {
Some(if enum_arity == 0 {
quote! {
- Instruction::#variant_ident => true
+ Instruction::#variant_ident
}
} else {
quote! {
- Instruction::#variant_ident(..) => true
- }
- })
- } else if variant_string.starts_with("DefaultExecute") {
- Some(if enum_arity == 0 {
- quote! {
- Instruction::#variant_ident => true
- }
- } else {
- quote! {
- Instruction::#variant_ident(..) => true
+ Instruction::#variant_ident(..)
}
})
} else if variant_string == "JmpByExecute" {
Some(quote! {
- Instruction::#variant_ident(..) => true
+ Instruction::#variant_ident(..)
})
} else {
None
Some(if enum_arity == 0 {
quote! {
- Instruction::#variant_ident => true
+ Instruction::#variant_ident
}
} else {
quote! {
- Instruction::#variant_ident(..) => true
+ Instruction::#variant_ident(..)
}
})
})
.iter()
.rev() // produce default, execute & default & execute cases first.
.cloned()
- .filter_map(|(name, arity, _, variant)| {
+ .map(|(name, arity, _, variant)| {
let variant_ident = variant.ident.clone();
let variant_string = variant.ident.to_string();
let arity = match arity {
_ => 1,
};
+ #[allow(clippy::collapsible_else_if)]
Some(if variant_string.starts_with("Execute") {
if arity == 0 {
quote! {
match arity {
Arity::Static(_) if enum_arity == 0 => {
- quote! { &Instruction::#ident => (atom!(#name), #arity) }
+ quote! { Instruction::#ident => (atom!(#name), #arity) }
}
Arity::Static(_) => {
- quote! { &Instruction::#ident(..) => (atom!(#name), #arity) }
+ quote! { Instruction::#ident(..) => (atom!(#name), #arity) }
}
Arity::Ident(_) if enum_arity == 0 => {
quote! { &Instruction::#ident(#arity) => (atom!(#name), #arity) }
}
pub fn is_inbuilt(name: Atom, arity: usize) -> bool {
- match (name, arity) {
- #(
- #is_inbuilt_arms,
- )*
- _ => false,
- }
+ matches!((name, arity),
+ #(#is_inbuilt_arms)|*
+ )
}
pub fn name(&self) -> Atom {
}
pub fn is_inlined(name: Atom, arity: usize) -> bool {
- match (name, arity) {
- #(
- #is_inlined_arms,
- )*
- _ => false,
- }
+ matches!((name, arity),
+ #(#is_inlined_arms)|*
+ )
}
}
}
pub fn is_execute(&self) -> bool {
- match self {
- #(
- #is_execute_arms,
- )*
- _ => false,
- }
+ matches!(self,
+ #(#is_execute_arms)|*
+ )
}
pub fn is_ctrl_instr(&self) -> bool {
- match self {
- &Instruction::Allocate(_) |
- &Instruction::Deallocate |
- &Instruction::Proceed |
- &Instruction::RevJmpBy(_) => true,
- #(
- #control_flow_arms,
- )*
- _ => false,
- }
+ matches!(self,
+ Instruction::Allocate(_) |
+ Instruction::Deallocate |
+ Instruction::Proceed |
+ Instruction::RevJmpBy(_) |
+ #(#control_flow_arms)|*
+ )
}
pub fn is_query_instr(&self) -> bool {
- match self {
+ matches!(self,
&Instruction::GetVariable(..) |
&Instruction::PutConstant(..) |
&Instruction::PutList(..) |
&Instruction::SetLocalValue(..) |
&Instruction::SetVariable(..) |
&Instruction::SetValue(..) |
- &Instruction::SetVoid(..) => true,
- _ => false,
- }
+ &Instruction::SetVoid(..)
+ )
}
}
impl From<&'static str> for Arity {
fn from(arity: &'static str) -> Self {
- usize::from_str_radix(&arity, 10)
+ arity
+ .parse::<usize>()
.map(Arity::Static)
.unwrap_or_else(|_| Arity::Ident(arity))
}
panic!("type ID is: {}", id);
};
- let v_string = variant.ident.to_string();
-
- let v_ident = if v_string.starts_with("Call") {
- format_ident!("{}", v_string["Call".len()..])
- } else {
- variant.ident.clone()
- };
+ let v_ident = variant
+ .ident
+ .to_string()
+ .strip_prefix("Call")
+ .map(|s| format_ident!("{}", s))
+ .unwrap_or_else(|| variant.ident.clone());
let generated_variant =
create_instr_variant(format_ident!("{}{}", prefix, v_ident), variant.clone());
let out_dir = env::var("OUT_DIR").unwrap();
let dest_path = Path::new(&out_dir).join("libraries.rs");
- let mut libraries = File::create(&dest_path).unwrap();
+ let mut libraries = File::create(dest_path).unwrap();
let lib_path = Path::new("src/lib");
libraries
)
.unwrap();
- find_prolog_files(&mut libraries, "", &lib_path);
+ find_prolog_files(&mut libraries, "", lib_path);
libraries.write_all(b"\n m\n };\n}\n").unwrap();
let instructions_path = Path::new(&out_dir).join("instructions.rs");
arms.push(input.parse()?);
while !input.is_empty() {
- if let Ok(_) = input.parse::<Token![,]>() {}
+ let _ = input.parse::<Token![,]>();
arms.push(input.parse()?);
}
}
while !input.is_empty() {
- if let Ok(_) = input.parse::<Token![,]>() {}
+ let _ = input.parse::<Token![,]>();
args.push(input.parse()?);
}
let Macro { path, .. } = m;
if path.is_ident("atom") {
- if let Some(Lit::Str(string)) = m.parse_body::<Lit>().ok() {
+ if let Ok(Lit::Str(string)) = m.parse_body::<Lit>() {
self.static_strs.insert(string.value());
}
} else if path.is_ident("read_heap_cell") || path.is_ident("match_untyped_arena_ptr") {
- if let Some(m) = m.parse_body::<ReadHeapCellExprAndArms>().ok() {
+ if let Ok(m) = m.parse_body::<ReadHeapCellExprAndArms>() {
self.visit_expr(&m.expr);
for e in m.arms {
self.visit_arm(&e);
}
}
- } else {
- if let Some(m) = m.parse_body::<MacroFnArgs>().ok() {
- for e in m.args {
- self.visit_expr(&e);
- }
+ } else if let Ok(m) = m.parse_body::<MacroFnArgs>() {
+ for e in m.args {
+ self.visit_expr(&e);
}
}
}
visitor.visit_file(&syntax);
}
- match process_filepath(instruction_rs_path) {
- Ok(syntax) => visitor.visit_file(&syntax),
- Err(_) => {}
+ if let Ok(syntax) = process_filepath(instruction_rs_path) {
+ visitor.visit_file(&syntax)
}
let indices = (0..visitor.static_strs.len()).map(|i| (i << 3) as u64);
quote! {
use phf;
- static STRINGS: [&'static str; #static_strs_len] = [
+ static STRINGS: [&str; #static_strs_len] = [
#(
#static_strs,
)*
code: &mut CodeDeque,
);
+ #[allow(clippy::too_many_arguments)]
fn mark_reserved_var<'a, Target: CompilationTarget<'a>>(
&mut self,
var_num: usize,
fn reset(&mut self);
fn reset_arg(&mut self, arg_num: usize);
- fn reset_at_head(&mut self, args: &Vec<Term>);
+ fn reset_at_head(&mut self, args: &[Term]);
fn reset_contents(&mut self);
fn advance_arg(&mut self);
) -> RcuRef<RawBlock<F64Table>, UnsafeCell<OrderedFloat<f64>>> {
let f64table = global_f64table()
.read()
- .unwrap()
+ .unwrap()
.upgrade()
.expect("We should only be looking up floats while there is a float table");
RcuRef::try_map(f64table.block.active_epoch(), |raw_block| unsafe {
raw_block
.base
- .offset(offset.0 as isize)
+ .add(offset.0)
.cast_mut()
.cast::<UnsafeCell<OrderedFloat<f64>>>()
.as_ref()
}
}
+ #[allow(clippy::missing_safety_doc)]
pub unsafe fn build_with(&self, value: f64) -> F64Offset {
let update_guard = self.update.lock();
ptr::write(ptr as *mut OrderedFloat<f64>, OrderedFloat(value));
- let float = F64Offset {
- 0: ptr as usize - block_epoch.base as usize,
- };
+ let float = F64Offset(ptr as usize - block_epoch.base as usize);
// atometable would have to update the index table at this point
impl<T: ?Sized + PartialEq> PartialEq for TypedArenaPtr<T> {
fn eq(&self, other: &TypedArenaPtr<T>) -> bool {
- self.0 == other.0 || &**self == &**other
+ self.0 == other.0 || **self == **other
}
}
impl<T: ?Sized + Hash> Hash for TypedArenaPtr<T> {
#[inline(always)]
fn hash<H: Hasher>(&self, hasher: &mut H) {
- (&*self as &T).hash(hasher)
+ (self as &T).hash(hasher)
}
}
impl<T: ?Sized> Clone for TypedArenaPtr<T> {
fn clone(&self) -> Self {
- TypedArenaPtr(self.0)
+ *self
}
}
impl<T: ?Sized + ArenaAllocated> TypedArenaPtr<T> {
// data must be allocated in the arena already.
+ #[allow(clippy::not_unsafe_ptr_arg_deref)]
#[inline]
pub const fn new(data: *mut T) -> Self {
- let result = unsafe { TypedArenaPtr(ptr::NonNull::new_unchecked(data)) };
- result
+ unsafe { TypedArenaPtr(ptr::NonNull::new_unchecked(data)) }
}
#[inline]
mem::size_of::<ArenaHeader>()
}
+ #[allow(clippy::missing_safety_doc)]
unsafe fn alloc(arena: &mut Arena, value: Self) -> Self::PtrToAllocated {
let size = value.size() + mem::size_of::<AllocSlab>();
(*slab).header = ArenaHeader::build_with(value.size() as u64, Self::tag());
let offset = (*slab).payload_offset();
- let result = value.copy_to_arena(offset as *mut Self);
+ let result = value.copy_to_arena(offset);
arena.base = slab;
impl PartialOrd for F64Ptr {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
- (**self).partial_cmp(&**other)
+ Some(self.cmp(other))
}
}
impl Hash for F64Ptr {
#[inline(always)]
fn hash<H: Hasher>(&self, hasher: &mut H) {
- (&*self as &OrderedFloat<f64>).hash(hasher)
+ (self as &OrderedFloat<f64>).hash(hasher)
}
}
impl fmt::Display for F64Ptr {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "{}", *self)
+ write!(f, "{}", self as &OrderedFloat<f64>)
}
}
#[inline]
fn deref(&self) -> &Self::Target {
- unsafe { &*self.0.get().as_ref().unwrap() }
+ unsafe { self.0.get().as_ref().unwrap() }
}
}
impl PartialOrd for F64Offset {
#[inline(always)]
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
- self.as_ptr().partial_cmp(&other.as_ptr())
+ Some(self.cmp(other))
}
}
mem::size_of::<Self>()
}
+ #[allow(clippy::not_unsafe_ptr_arg_deref)]
#[inline]
fn copy_to_arena(self, dst: *mut Self) -> Self::PtrToAllocated {
unsafe {
ptr::write(dst, self);
- TypedArenaPtr::new(dst as *mut Self)
+ TypedArenaPtr::new(dst)
}
}
}
mem::size_of::<Self>()
}
+ #[allow(clippy::not_unsafe_ptr_arg_deref)]
#[inline]
fn copy_to_arena(self, dst: *mut Self) -> Self::PtrToAllocated {
unsafe {
ptr::write(dst, self);
- TypedArenaPtr::new(dst as *mut Self)
+ TypedArenaPtr::new(dst)
}
}
}
mem::size_of::<Self>()
}
+ #[allow(clippy::not_unsafe_ptr_arg_deref)]
#[inline]
fn copy_to_arena(self, dst: *mut Self) -> Self::PtrToAllocated {
unsafe {
ptr::write(dst, self);
- TypedArenaPtr::new(dst as *mut Self)
+ TypedArenaPtr::new(dst)
}
}
}
mem::size_of::<Self>()
}
+ #[allow(clippy::not_unsafe_ptr_arg_deref)]
#[inline]
fn copy_to_arena(self, dst: *mut Self) -> Self::PtrToAllocated {
unsafe {
ptr::write(dst, self);
- TypedArenaPtr::new(dst as *mut Self)
+ TypedArenaPtr::new(dst)
}
}
}
mem::size_of::<Self>()
}
+ #[allow(clippy::not_unsafe_ptr_arg_deref)]
#[inline]
fn copy_to_arena(self, dst: *mut Self) -> Self::PtrToAllocated {
unsafe {
ptr::write(dst, self);
- TypedArenaPtr::new(dst as *mut Self)
+ TypedArenaPtr::new(dst)
}
}
}
mem::size_of::<Self>()
}
+ #[allow(clippy::not_unsafe_ptr_arg_deref)]
#[inline]
fn copy_to_arena(self, dst: *mut Self) -> Self::PtrToAllocated {
unsafe {
ptr::write(dst, self);
- TypedArenaPtr::new(dst as *mut Self)
+ TypedArenaPtr::new(dst)
}
}
}
mem::size_of::<Self>()
}
+ #[allow(clippy::not_unsafe_ptr_arg_deref)]
#[inline]
fn copy_to_arena(self, dst: *mut Self) -> Self::PtrToAllocated {
unsafe {
ptr::write(dst, self);
- TypedArenaPtr::new(dst as *mut Self)
+ TypedArenaPtr::new(dst)
}
}
(*slab).next = arena.base;
- let result = value.copy_to_arena(mem::transmute::<_, *mut IndexPtr>(&(*slab).header));
+ let result = value.copy_to_arena(
+ &(*slab).header as *const crate::arena::ArenaHeader
+ as *mut crate::machine::machine_indices::IndexPtr,
+ );
arena.base = slab;
result
unsafe impl Send for Arena {}
unsafe impl Sync for Arena {}
+#[allow(clippy::new_without_default)]
impl Arena {
#[inline]
pub fn new() -> Self {
let mut cell = HeapCellValue::from(fp.clone());
assert_eq!(cell.get_tag(), HeapCellValueTag::F64);
- assert_eq!(cell.get_mark_bit(), false);
+ assert!(!cell.get_mark_bit());
assert_eq!(fp.deref(), &OrderedFloat(f));
cell.set_mark_bit(true);
- assert_eq!(cell.get_mark_bit(), true);
+ assert!(cell.get_mark_bit());
read_heap_cell!(cell,
(HeapCellValueTag::F64, ptr) => {
);
}
None => {
- assert!(false);
+ unreachable!();
}
}
);
}
None => {
- assert!(false);
+ unreachable!();
}
}
}
let untyped_arena_ptr = match cell.to_untyped_arena_ptr() {
Some(ptr) => ptr,
None => {
- assert!(false);
unreachable!()
}
};
);
}
None => {
- assert!(false); // we fail.
+ unreachable!();
}
}
assert_eq!(&*atom.as_str(), "f");
}
None => {
- assert!(false);
+ unreachable!();
}
}
assert_eq!(&*pstr.as_str_from(0), "ronan");
}
None => {
- assert!(false);
+ unreachable!();
}
}
match fixnum_cell.to_fixnum() {
Some(n) => assert_eq!(n.get_num(), 3),
- None => assert!(false),
+ None => unreachable!(),
}
read_heap_cell!(fixnum_cell,
match fixnum_b_cell.to_fixnum() {
Some(n) => assert_eq!(n.get_num(), 1 << 54),
- None => assert!(false),
+ None => unreachable!(),
}
- match Fixnum::build_with_checked(1 << 56) {
- Ok(_) => assert!(false),
- _ => assert!(true),
+ if Fixnum::build_with_checked(1 << 56).is_ok() {
+ unreachable!()
}
- match Fixnum::build_with_checked(i64::MAX) {
- Ok(_) => assert!(false),
- _ => assert!(true),
+ if Fixnum::build_with_checked(i64::MAX).is_ok() {
+ unreachable!()
}
- match Fixnum::build_with_checked(i64::MIN) {
- Ok(_) => assert!(false),
- _ => assert!(true),
+ if Fixnum::build_with_checked(i64::MIN).is_ok() {
+ unreachable!()
}
match Fixnum::build_with_checked(-1) {
Ok(n) => assert_eq!(n.get_num(), -1),
- _ => assert!(false),
+ _ => unreachable!(),
}
match Fixnum::build_with_checked((1 << 55) - 1) {
Ok(n) => assert_eq!(n.get_num(), (1 << 55) - 1),
- _ => assert!(false),
+ _ => unreachable!(),
}
match Fixnum::build_with_checked(-(1 << 55)) {
Ok(n) => assert_eq!(n.get_num(), -(1 << 55)),
- _ => assert!(false),
+ _ => unreachable!(),
}
- match Fixnum::build_with_checked(-(1 << 55) - 1) {
- Ok(_n) => assert!(false),
- _ => assert!(true),
+ if Fixnum::build_with_checked(-(1 << 55) - 1).is_ok() {
+ unreachable!()
}
match Fixnum::build_with_checked(-1) {
Ok(n) => assert_eq!(-n, Fixnum::build_with(1)),
- _ => assert!(false),
+ _ => unreachable!(),
}
// float
- let float = 3.1415926f64;
+ let float = std::f64::consts::PI;
let float_ptr = float_alloc!(float, wam.machine_st.arena);
let cell = HeapCellValue::from(float_ptr);
let ninterm = if a1.interm_or(0) == 0 {
self.incr_interm()
} else {
- self.interm.push(a1.clone());
+ self.interm.push(a1);
a1.interm_or(0)
};
arg: usize,
) -> Result<ArithCont, ArithmeticError> {
let mut code = CodeDeque::new();
- let mut iter = src.iter()?;
- while let Some(term_ref) = iter.next() {
+ for term_ref in src.iter()? {
match term_ref? {
ArithTermRef::Literal(c) => push_literal(&mut self.interm, c)?,
ArithTermRef::Var(lvl, cell, name) => {
}
// integer division rounding function -- 9.1.3.1.
-pub(crate) fn rnd_i<'a>(n: &'a Number, arena: &mut Arena) -> Number {
+pub(crate) fn rnd_i(n: &'_ Number, arena: &mut Arena) -> Number {
match n {
&Number::Integer(i) => {
let result = (&*i).try_into();
- if let Ok(value) = result{
+ if let Ok(value) = result {
fixnum!(Number, value, arena)
} else {
*n
}
}
- &Number::Fixnum(_) => *n,
+ Number::Fixnum(_) => *n,
&Number::Float(f) => {
let f = f.floor();
Number::Integer(arena_alloc!(Integer::from(f.0 as i64), arena))
}
}
- &Number::Rational(ref r) => {
+ Number::Rational(ref r) => {
let (_, floor) = (r.fract(), r.floor());
if let Ok(value) = (&floor).try_into() {
pub(crate) fn rnd_f(n: &Number) -> f64 {
match n {
&Number::Fixnum(n) => n.get_num() as f64,
- &Number::Integer(ref n) => n.to_f64().value(),
+ Number::Integer(ref n) => n.to_f64().value(),
&Number::Float(OrderedFloat(f)) => f,
- &Number::Rational(ref r) => r.to_f64().value(),
+ Number::Rational(ref r) => r.to_f64().value(),
}
}
fn eq(&self, rhs: &Self) -> bool {
match (self, rhs) {
(&Number::Fixnum(n1), &Number::Fixnum(n2)) => n1.eq(&n2),
- (&Number::Fixnum(n1), &Number::Integer(ref n2)) => n1.get_num().num_eq(&**n2),
- (&Number::Integer(ref n1), &Number::Fixnum(n2)) => (&**n1).num_eq(&n2.get_num()),
- (&Number::Fixnum(n1), &Number::Rational(ref n2)) => Integer::from(n1.get_num()).num_eq(&**n2),
- (&Number::Rational(ref n1), &Number::Fixnum(n2)) => (&**n1).num_eq(&Integer::from(n2.get_num())),
+ (&Number::Fixnum(n1), Number::Integer(ref n2)) => n1.get_num().num_eq(&**n2),
+ (Number::Integer(ref n1), &Number::Fixnum(n2)) => n1.num_eq(&n2.get_num()),
+ (&Number::Fixnum(n1), Number::Rational(ref n2)) => {
+ Integer::from(n1.get_num()).num_eq(&**n2)
+ }
+ (Number::Rational(ref n1), &Number::Fixnum(n2)) => {
+ n1.num_eq(&Integer::from(n2.get_num()))
+ }
(&Number::Fixnum(n1), &Number::Float(n2)) => OrderedFloat(n1.get_num() as f64).eq(&n2),
(&Number::Float(n1), &Number::Fixnum(n2)) => n1.eq(&OrderedFloat(n2.get_num() as f64)),
- (&Number::Integer(ref n1), &Number::Integer(ref n2)) => n1.eq(n2),
- (&Number::Integer(ref n1), Number::Float(n2)) => {
+ (Number::Integer(ref n1), Number::Integer(ref n2)) => n1.eq(n2),
+ (Number::Integer(ref n1), Number::Float(n2)) => {
OrderedFloat(n1.to_f64().value()).eq(n2)
}
- (&Number::Float(n1), &Number::Integer(ref n2)) => {
+ (&Number::Float(n1), Number::Integer(ref n2)) => {
n1.eq(&OrderedFloat(n2.to_f64().value()))
}
- (&Number::Integer(ref n1), &Number::Rational(ref n2)) => {
+ (Number::Integer(ref n1), Number::Rational(ref n2)) => {
#[cfg(feature = "num")]
{
&Rational::from(&**n1) == &**n2
}
#[cfg(not(feature = "num"))]
{
- (&**n1).num_eq(&**n2)
+ n1.num_eq(&**n2)
}
}
- (&Number::Rational(ref n1), &Number::Integer(ref n2)) => {
+ (Number::Rational(ref n1), Number::Integer(ref n2)) => {
#[cfg(feature = "num")]
{
- &**n1 == &Rational::from(&**n2)
+ n1 == &Rational::from(&**n2)
}
#[cfg(not(feature = "num"))]
{
- (&**n1).num_eq(&**n2)
+ n1.num_eq(&**n2)
}
}
- (&Number::Rational(ref n1), &Number::Float(n2)) => {
+ (Number::Rational(ref n1), &Number::Float(n2)) => {
OrderedFloat(n1.to_f64().value()).eq(&n2)
}
- (&Number::Float(n1), &Number::Rational(ref n2)) => {
+ (&Number::Float(n1), Number::Rational(ref n2)) => {
n1.eq(&OrderedFloat(n2.to_f64().value()))
}
(&Number::Float(f1), &Number::Float(f2)) => f1.eq(&f2),
- (&Number::Rational(ref r1), &Number::Rational(ref r2)) => r1.eq(&r2),
+ (Number::Rational(ref r1), Number::Rational(ref r2)) => r1.eq(r2),
}
}
}
(n as usize).partial_cmp(rhs)
}
}
- Number::Integer(n) => Some((&**n).num_cmp(rhs)),
- Number::Rational(r) => Some((&**r).num_cmp(&Integer::from(*rhs))),
+ Number::Integer(n) => Some((n).num_cmp(rhs)),
+ Number::Rational(r) => Some((r).num_cmp(&Integer::from(*rhs))),
Number::Float(f) => f.partial_cmp(&OrderedFloat(*rhs as f64)),
}
}
(n as usize).eq(rhs)
}
}
- Number::Integer(n) => (&**n).num_eq(rhs),
- Number::Rational(r) => (&**r).num_eq(&Integer::from(*rhs)),
+ Number::Integer(n) => (n).num_eq(rhs),
+ Number::Rational(r) => (r).num_eq(&Integer::from(*rhs)),
Number::Float(f) => f.eq(&OrderedFloat(*rhs as f64)),
}
}
fn cmp(&self, rhs: &Number) -> Ordering {
match (self, rhs) {
(&Number::Fixnum(n1), &Number::Fixnum(n2)) => n1.get_num().cmp(&n2.get_num()),
- (&Number::Fixnum(n1), Number::Integer(n2)) => Integer::from(n1.get_num()).cmp(&*n2),
- (Number::Integer(n1), &Number::Fixnum(n2)) => (&**n1).cmp(&Integer::from(n2.get_num())),
- (&Number::Fixnum(n1), Number::Rational(n2)) => Rational::from(n1.get_num()).cmp(&*n2),
+ (&Number::Fixnum(n1), Number::Integer(n2)) => Integer::from(n1.get_num()).cmp(n2),
+ (Number::Integer(n1), &Number::Fixnum(n2)) => (**n1).cmp(&Integer::from(n2.get_num())),
+ (&Number::Fixnum(n1), Number::Rational(n2)) => Rational::from(n1.get_num()).cmp(n2),
(Number::Rational(n1), &Number::Fixnum(n2)) => {
- (&**n1).cmp(&Rational::from(n2.get_num()))
+ (**n1).cmp(&Rational::from(n2.get_num()))
}
(&Number::Fixnum(n1), &Number::Float(n2)) => OrderedFloat(n1.get_num() as f64).cmp(&n2),
(&Number::Float(n1), &Number::Fixnum(n2)) => n1.cmp(&OrderedFloat(n2.get_num() as f64)),
(&Number::Integer(n1), &Number::Integer(n2)) => (*n1).cmp(&*n2),
(&Number::Integer(n1), Number::Float(n2)) => OrderedFloat(n1.to_f64().value()).cmp(n2),
- (&Number::Float(n1), &Number::Integer(ref n2)) => {
+ (&Number::Float(n1), Number::Integer(ref n2)) => {
n1.cmp(&OrderedFloat(n2.to_f64().value()))
}
(&Number::Integer(n1), &Number::Rational(n2)) => {
}
#[cfg(not(feature = "num"))]
{
- (&*n1).num_partial_cmp(&*n2).unwrap_or(Ordering::Less)
+ (*n1).num_partial_cmp(&*n2).unwrap_or(Ordering::Less)
}
}
(&Number::Rational(n1), &Number::Integer(n2)) => {
}
#[cfg(not(feature = "num"))]
{
- (&*n1).num_partial_cmp(&*n2).unwrap_or(Ordering::Less)
+ (*n1).num_partial_cmp(&*n2).unwrap_or(Ordering::Less)
}
}
(&Number::Rational(n1), &Number::Float(n2)) => {
unsafe {
AtomTableRef::try_map(atom_table.buf(), |buf| {
(buf as *const u8)
- .offset(((self.index as usize) - (STRINGS.len() << 3)) as isize)
+ .add((self.index as usize) - (STRINGS.len() << 3))
.as_ref()
})
}
}
}
+ pub fn is_empty(self) -> bool {
+ self.len() == 0
+ }
+
#[inline(always)]
pub fn flat_index(self) -> u64 {
- (self.index >> 3) as u64
+ self.index >> 3
}
pub fn as_char(self) -> Option<char> {
pub fn as_str(&self) -> AtomString<'static> {
if self.is_static() {
AtomString::Static(STRINGS[(self.index >> 3) as usize])
+ } else if let Some(ptr) = self.as_ptr() {
+ AtomString::Dynamic(AtomTableRef::map(ptr, |ptr| {
+ let header =
+ unsafe { ptr::read::<AtomHeader>(ptr as *const u8 as *const AtomHeader) };
+ let len = header.len() as usize;
+ let buf = unsafe { (ptr as *const u8).add(mem::size_of::<AtomHeader>()) };
+
+ unsafe { str::from_utf8_unchecked(slice::from_raw_parts(buf, len)) }
+ }))
} else {
- if let Some(ptr) = self.as_ptr() {
- AtomString::Dynamic(AtomTableRef::map(ptr, |ptr| {
- let header =
- unsafe { ptr::read::<AtomHeader>(ptr as *const u8 as *const AtomHeader) };
- let len = header.len() as usize;
- let buf =
- unsafe { (ptr as *const u8).offset(mem::size_of::<AtomHeader>() as isize) };
-
- unsafe { str::from_utf8_unchecked(slice::from_raw_parts(buf, len)) }
- }))
- } else {
- AtomString::Static(&STRINGS[(self.index >> 3) as usize])
- }
+ AtomString::Static(STRINGS[(self.index >> 3) as usize])
}
}
return *self;
};
- AtomTable::build_with(&atom_tbl, &sub_str)
+ AtomTable::build_with(atom_tbl, sub_str)
}
}
unsafe fn write_to_ptr(string: &str, ptr: *mut u8) {
ptr::write(ptr as *mut _, AtomHeader::build_with(string.len() as u64));
let str_ptr = (ptr as usize + mem::size_of::<AtomHeader>()) as *mut u8;
- ptr::copy_nonoverlapping(string.as_ptr(), str_ptr as *mut u8, string.len());
+ ptr::copy_nonoverlapping(string.as_ptr(), str_ptr, string.len());
}
impl PartialOrd for Atom {
fn main() -> std::process::ExitCode {
- use scryer_prolog::*;
use scryer_prolog::atom_table::Atom;
+ use scryer_prolog::*;
use std::sync::atomic::Ordering;
#[cfg(feature = "repl")]
jump_span -= code.len() + 1;
} else {
jump_span -= code.len() + 1;
- code.push_back(instr!("jmp_by_call", jump_span as usize));
+ code.push_back(instr!("jmp_by_call", jump_span));
jump_span -= 1;
}
for mut branch_arm in self.stack.drain(self.stack.len() - depth..).rev() {
let num_branch_arms = branch_arm.len();
- branch_arm
- .last_mut()
- .map(|code| code.extend(combined_code.drain(..)));
+ if let Some(code) = branch_arm.last_mut() {
+ code.extend(combined_code.drain(..))
+ }
for (idx, code) in branch_arm.into_iter().enumerate() {
combined_code.push_back(if idx == 0 {
Target: crate::targets::CompilationTarget<'a>,
{
if let Some(ref mut instr) = target.back_mut() {
- if Target::is_void_instr(&*instr) {
+ if Target::is_void_instr(instr) {
Target::incr_void_instr(instr);
return;
}
.mark_non_var::<Target>(Level::Deep, term_loc, cell, target);
target.push_back(Target::clause_arg_to_instr(cell.get()));
}
- &Term::Literal(_, ref constant) => {
- target.push_back(Target::constant_subterm(constant.clone()));
+ Term::Literal(_, ref constant) => {
+ target.push_back(Target::constant_subterm(*constant));
}
- &Term::Var(ref cell, ref var_ptr) => {
+ Term::Var(ref cell, ref var_ptr) => {
self.deep_var_instr::<Target>(
cell,
var_ptr.to_var_num().unwrap(),
TermRef::PartialString(lvl, cell, string, tail) => {
self.marker
.mark_non_var::<Target>(lvl, term_loc, cell, &mut target);
- let atom = AtomTable::build_with(&self.atom_tbl, &string);
+ let atom = AtomTable::build_with(self.atom_tbl, string);
target.push_back(Target::to_pstr(lvl, atom, cell.get(), true));
self.subterm_to_instr::<Target>(tail, term_loc, &mut target);
}
}
- fn compile_inlined<'a>(
+ fn compile_inlined(
&mut self,
ct: &InlinedClauseType,
- terms: &'a Vec<Term>,
+ terms: &'_ [Term],
term_loc: GenContext,
code: &mut CodeDeque,
) -> Result<(), CompilationError> {
compare_number_instr!(cmp, at_1, at_2)
}
- &InlinedClauseType::IsAtom(..) => match &terms[0] {
- &Term::Literal(_, Literal::Char(_))
- | &Term::Literal(_, Literal::Atom(atom!("[]")))
- | &Term::Literal(_, Literal::Atom(..)) => {
+ InlinedClauseType::IsAtom(..) => match &terms[0] {
+ Term::Literal(_, Literal::Char(_))
+ | Term::Literal(_, Literal::Atom(atom!("[]")))
+ | Term::Literal(_, Literal::Atom(..)) => {
instr!("$succeed")
}
- &Term::Var(ref vr, ref name) => {
+ Term::Var(ref vr, ref name) => {
self.marker.reset_arg(1);
let r = self.marker.mark_non_callable(
instr!("$fail")
}
},
- &InlinedClauseType::IsAtomic(..) => match &terms[0] {
- &Term::AnonVar
- | &Term::Clause(..)
- | &Term::Cons(..)
- | &Term::PartialString(..)
- | &Term::CompleteString(..) => {
+ InlinedClauseType::IsAtomic(..) => match &terms[0] {
+ Term::AnonVar
+ | Term::Clause(..)
+ | Term::Cons(..)
+ | Term::PartialString(..)
+ | Term::CompleteString(..) => {
instr!("$fail")
}
- &Term::Literal(_, Literal::String(_)) => {
+ Term::Literal(_, Literal::String(_)) => {
instr!("$fail")
}
- &Term::Literal(..) => {
+ Term::Literal(..) => {
instr!("$succeed")
}
- &Term::Var(ref vr, ref name) => {
+ Term::Var(ref vr, ref name) => {
self.marker.reset_arg(1);
let r = self.marker.mark_non_callable(
instr!("atomic", r)
}
},
- &InlinedClauseType::IsCompound(..) => match &terms[0] {
- &Term::Clause(..)
- | &Term::Cons(..)
- | &Term::PartialString(..)
- | &Term::CompleteString(..)
- | &Term::Literal(_, Literal::String(..)) => {
+ InlinedClauseType::IsCompound(..) => match &terms[0] {
+ Term::Clause(..)
+ | Term::Cons(..)
+ | Term::PartialString(..)
+ | Term::CompleteString(..)
+ | Term::Literal(_, Literal::String(..)) => {
instr!("$succeed")
}
- &Term::Var(ref vr, ref name) => {
+ Term::Var(ref vr, ref name) => {
self.marker.reset_arg(1);
let r = self.marker.mark_non_callable(
instr!("$fail")
}
},
- &InlinedClauseType::IsRational(..) => match &terms[0] {
- &Term::Literal(_, Literal::Rational(_)) => {
+ InlinedClauseType::IsRational(..) => match terms[0] {
+ Term::Literal(_, Literal::Rational(_)) => {
instr!("$succeed")
}
- &Term::Var(ref vr, ref name) => {
+ Term::Var(ref vr, ref name) => {
self.marker.reset_arg(1);
let r = self.marker.mark_non_callable(
name.to_var_num().unwrap(),
instr!("$fail")
}
},
- &InlinedClauseType::IsFloat(..) => match &terms[0] {
- &Term::Literal(_, Literal::Float(_)) => {
+ InlinedClauseType::IsFloat(..) => match terms[0] {
+ Term::Literal(_, Literal::Float(_)) => {
instr!("$succeed")
}
- &Term::Var(ref vr, ref name) => {
+ Term::Var(ref vr, ref name) => {
self.marker.reset_arg(1);
let r = self.marker.mark_non_callable(
instr!("$fail")
}
},
- &InlinedClauseType::IsNumber(..) => match &terms[0] {
- &Term::Literal(_, Literal::Float(_))
- | &Term::Literal(_, Literal::Rational(_))
- | &Term::Literal(_, Literal::Integer(_))
- | &Term::Literal(_, Literal::Fixnum(_)) => {
+ InlinedClauseType::IsNumber(..) => match terms[0] {
+ Term::Literal(_, Literal::Float(_))
+ | Term::Literal(_, Literal::Rational(_))
+ | Term::Literal(_, Literal::Integer(_))
+ | Term::Literal(_, Literal::Fixnum(_)) => {
instr!("$succeed")
}
- &Term::Var(ref vr, ref name) => {
+ Term::Var(ref vr, ref name) => {
self.marker.reset_arg(1);
let r = self.marker.mark_non_callable(
instr!("$fail")
}
},
- &InlinedClauseType::IsNonVar(..) => match &terms[0] {
- &Term::AnonVar => {
+ InlinedClauseType::IsNonVar(..) => match terms[0] {
+ Term::AnonVar => {
instr!("$fail")
}
- &Term::Var(ref vr, ref name) => {
+ Term::Var(ref vr, ref name) => {
self.marker.reset_arg(1);
let r = self.marker.mark_non_callable(
instr!("$succeed")
}
},
- &InlinedClauseType::IsInteger(..) => match &terms[0] {
- &Term::Literal(_, Literal::Integer(_)) | &Term::Literal(_, Literal::Fixnum(_)) => {
+ InlinedClauseType::IsInteger(..) => match &terms[0] {
+ Term::Literal(_, Literal::Integer(_)) | Term::Literal(_, Literal::Fixnum(_)) => {
instr!("$succeed")
}
- &Term::Var(ref vr, ref name) => {
+ Term::Var(ref vr, name) => {
self.marker.reset_arg(1);
let r = self.marker.mark_non_callable(
instr!("$fail")
}
},
- &InlinedClauseType::IsVar(..) => match &terms[0] {
- &Term::Literal(..)
- | &Term::Clause(..)
- | &Term::Cons(..)
- | &Term::PartialString(..)
- | &Term::CompleteString(..) => {
+ InlinedClauseType::IsVar(..) => match terms[0] {
+ Term::Literal(..)
+ | Term::Clause(..)
+ | Term::Cons(..)
+ | Term::PartialString(..)
+ | Term::CompleteString(..) => {
instr!("$fail")
}
- &Term::AnonVar => {
+ Term::AnonVar => {
instr!("$succeed")
}
- &Term::Var(ref vr, ref name) => {
+ Term::Var(ref vr, ref name) => {
self.marker.reset_arg(1);
let r = self.marker.mark_non_callable(
fn compile_is_call(
&mut self,
- terms: &Vec<Term>,
+ terms: &[Term],
code: &mut CodeDeque,
term_loc: GenContext,
call_policy: CallPolicy,
self.marker.reset_arg(2);
- let at = match &terms[0] {
- &Term::Var(ref vr, ref name) => {
+ let at = match terms[0] {
+ Term::Var(ref vr, ref name) => {
let var_num = name.to_var_num().unwrap();
if self.marker.var_data.records[var_num].num_occurrences > 1 {
compile_expr!(self, &terms[1], term_loc, code)
}
}
- &Term::Literal(
+ Term::Literal(
_,
c @ Literal::Integer(_)
| c @ Literal::Float(_)
Ok(())
}
- fn compile_seq<'a>(
+ fn compile_seq(
&mut self,
clauses: &ChunkedTermVec,
code: &mut CodeDeque,
self.marker.reset_at_head(args);
- let iter = FactIterator::from_rule_head_clause(&args);
+ let iter = FactIterator::from_rule_head_clause(args);
let fact = self.compile_target::<FactInstruction, _>(iter, GenContext::Head);
if self.marker.max_reg_allocated() > MAX_ARITY {
}
self.marker.reset_free_list();
- code.extend(fact.into_iter());
+ code.extend(fact);
self.compile_seq(clauses, &mut code)?;
return Err(CompilationError::ExceededMaxArity);
}
- code.extend(compiled_fact.into_iter());
+ code.extend(compiled_fact);
}
code.push(instr!("proceed"));
let iter = QueryIterator::new(term);
let query = self.compile_target::<QueryInstruction, _>(iter, term_loc);
- code.extend(query.into_iter());
+ code.extend(query);
match term {
&QueryTerm::Clause(_, ref ct, _, call_policy) => {
let clause_code = match clause {
PredicateClause::Fact(fact, var_data) => {
- let var_data = std::mem::replace(var_data, VarData::default());
- self.compile_fact(&fact, var_data)?
+ let var_data = std::mem::take(var_data);
+ self.compile_fact(fact, var_data)?
}
PredicateClause::Rule(rule, var_data) => {
- let var_data = std::mem::replace(var_data, VarData::default());
- self.compile_rule(&rule, var_data)?
+ let var_data = std::mem::take(var_data);
+ self.compile_rule(rule, var_data)?
}
};
skip_stub_try_me_else = !self.settings.is_dynamic();
}
- let arg = clause
- .args()
- .and_then(|args| args.iter().nth(optimal_index));
+ let arg = clause.args().and_then(|args| args.get(optimal_index));
if let Some(arg) = arg {
let index = code.len();
let mut result = 0;
for reg in self.temp_lb.. {
- if !self.is_in_use(reg) {
- if !temp_var_data.no_use_set.contains(reg) {
- result = reg;
- break;
- }
+ if !self.is_in_use(reg) && !temp_var_data.no_use_set.contains(reg) {
+ result = reg;
+ break;
}
}
let mut result = 0;
for reg in self.temp_lb.. {
- if !self.is_in_use(reg) {
- if !temp_var_data.no_use_set.contains(reg) {
- if !temp_var_data.conflict_set.contains(reg) {
- result = reg;
- break;
- }
- }
+ if !self.is_in_use(reg)
+ && !temp_var_data.no_use_set.contains(reg)
+ && !temp_var_data.conflict_set.contains(reg)
+ {
+ result = reg;
+ break;
}
}
// consider its use set. T == par_k iff
// (GenContext::Last(_), k) is in t_var.use_set.
- match &self.var_data.records[t_var].allocation {
- VarAlloc::Temp { temp_var_data, .. } => {
- if !temp_var_data
- .use_set
- .contains(&(GenContext::Last(chunk_num), k))
- {
- return Some((t_var, self.alloc_with_ca(t_var)));
- }
+ if let VarAlloc::Temp { temp_var_data, .. } =
+ &self.var_data.records[t_var].allocation
+ {
+ if !temp_var_data
+ .use_set
+ .contains(&(GenContext::Last(chunk_num), k))
+ {
+ return Some((t_var, self.alloc_with_ca(t_var)));
}
- _ => {}
}
None
chunk_num: usize,
code: &mut CodeDeque,
) {
- match self.alloc_in_last_goal_hint(chunk_num) {
- Some((var_num, r)) => {
- let k = self.arg_c;
+ if let Some((var_num, r)) = self.alloc_in_last_goal_hint(chunk_num) {
+ let k = self.arg_c;
- if r != k {
- let r = RegType::Temp(r);
+ if r != k {
+ let r = RegType::Temp(r);
- code.push_back(Target::move_to_register(r, k));
+ code.push_back(Target::move_to_register(r, k));
- self.shallow_temp_mappings.swap_remove(&k);
- self.shallow_temp_mappings.insert(r.reg_num(), var_num);
+ self.shallow_temp_mappings.swap_remove(&k);
+ self.shallow_temp_mappings.insert(r.reg_num(), var_num);
- self.var_data.records[var_num]
- .allocation
- .set_register(r.reg_num());
- self.in_use.insert(r.reg_num());
- }
+ self.var_data.records[var_num]
+ .allocation
+ .set_register(r.reg_num());
+ self.in_use.insert(r.reg_num());
}
- _ => {}
};
}
}
fn add_perm_to_free_list(&mut self, chunk_num: usize, var_num: usize) {
- match &self.var_data.records[var_num].allocation {
- VarAlloc::Perm(..) => {
- self.perm_free_list.push_back((chunk_num, var_num));
- }
- _ => {}
+ if let VarAlloc::Perm(..) = &self.var_data.records[var_num].allocation {
+ self.perm_free_list.push_back((chunk_num, var_num));
}
}
}
pub(crate) fn free_var(&mut self, chunk_num: usize, var_num: usize) {
- match &mut self.var_data.records[var_num].allocation {
- VarAlloc::Perm(_, allocation) => {
- *allocation = PermVarAllocation::Pending;
- self.add_perm_to_free_list(chunk_num, var_num);
- }
- _ => {}
+ if let VarAlloc::Perm(_, allocation) = &mut self.var_data.records[var_num].allocation {
+ *allocation = PermVarAllocation::Pending;
+ self.add_perm_to_free_list(chunk_num, var_num);
}
}
*shallow_safety = VarSafetyStatus::unneeded(branch_designator);
} else if term_loc == GenContext::Head {
*shallow_safety = VarSafetyStatus::GloballyUnneeded;
- } else {
- if let Some(temp_var_num) = self.shallow_temp_mappings.get(&self.arg_c).cloned()
- {
- match &mut self.var_data.records[temp_var_num].allocation {
- VarAlloc::Temp {
- ref mut to_perm_var_num,
- ..
- } => {
- *to_perm_var_num = Some(var_num);
- }
- _ => unreachable!(),
+ } else if let Some(&temp_var_num) = self.shallow_temp_mappings.get(&self.arg_c) {
+ match &mut self.var_data.records[temp_var_num].allocation {
+ VarAlloc::Temp {
+ ref mut to_perm_var_num,
+ ..
+ } => {
+ *to_perm_var_num = Some(var_num);
}
+ _ => unreachable!(),
}
}
}
self.arg_c += 1;
}
- fn reset_at_head(&mut self, args: &Vec<Term>) {
+ fn reset_at_head(&mut self, args: &[Term]) {
self.reset_arg(args.len());
self.arity = args.len();
for (idx, arg) in args.iter().enumerate() {
- if let &Term::Var(_, ref var) = arg {
+ if let Term::Var(_, ref var) = arg {
let var_num = var.to_var_num().unwrap();
let r = self.get_binding(var_num);
use std::error::Error;
use std::ffi::{c_void, CString};
-use libffi::low::{ffi_abi_FFI_DEFAULT_ABI, ffi_cif, ffi_type, prep_cif, type_tag, types, CodePtr};
+use libffi::low::type_tag::STRUCT;
+use libffi::low::{ffi_abi_FFI_DEFAULT_ABI, ffi_cif, ffi_type, prep_cif, types, CodePtr};
use libloading::{Library, Symbol};
pub struct FunctionDefinition {
}
pub fn define_struct(&mut self, name: &str, atom_fields: Vec<Atom>) {
- let mut fields: Vec<_> = atom_fields.iter().map(|x| self.map_type_ffi(&x)).collect();
+ let mut fields: Vec<_> = atom_fields.iter().map(|x| self.map_type_ffi(x)).collect();
fields.push(std::ptr::null_mut::<ffi_type>());
- let mut struct_type: ffi_type = Default::default();
- struct_type.type_ = type_tag::STRUCT;
- struct_type.elements = fields.as_mut_ptr();
+ let struct_type = ffi_type {
+ type_: STRUCT,
+ elements: fields.as_mut_ptr(),
+ ..Default::default()
+ };
self.structs.insert(
name.to_string(),
StructImpl {
let symbol_name: CString = CString::new(function.name.clone())?;
let code_ptr: Symbol<*mut c_void> =
library.get(&symbol_name.into_bytes_with_nul())?;
- let mut args: Vec<_> = function
- .args
- .iter()
- .map(|x| self.map_type_ffi(&x))
- .collect();
+ let mut args: Vec<_> = function.args.iter().map(|x| self.map_type_ffi(x)).collect();
let mut cif: ffi_cif = Default::default();
prep_cif(
&mut cif,
fn build_pointer_args(
args: &mut Vec<Value>,
- type_args: &Vec<*mut ffi_type>,
+ type_args: &[*mut ffi_type],
structs_table: &mut HashMap<String, StructImpl>,
) -> Result<PointerArgs, FFIError> {
let mut pointers = Vec::with_capacity(args.len());
let ptr = alloc(layout) as *mut c_void;
let mut field_ptr = ptr;
+ #[allow(clippy::needless_range_loop)]
for i in 0..(struct_type.fields.len() - 1) {
macro_rules! try_write_int {
($type:ty) => {{
std::ptr::copy(
&*struct_ptr as *const _ as *const c_void,
- field_ptr as *mut c_void,
+ field_ptr,
struct_size,
);
field_ptr = field_ptr.add(struct_size);
}
}
}
- return Ok((Box::from_raw(ptr), size, align));
+ #[allow(clippy::from_raw_with_void_ptr)]
+ Ok((Box::from_raw(ptr), size, align))
} else {
- return Err(FFIError::InvalidStructName);
+ Err(FFIError::InvalidStructName)
}
}
- _ => return Err(FFIError::ValueCast),
+ _ => Err(FFIError::ValueCast),
}
}
}
&mut function_impl.cif,
Some(*function_impl.code_ptr.as_safe_fun()),
&mut *n as *mut _ as *mut c_void,
- pointer_args.pointers.as_mut_ptr() as *mut *mut c_void,
+ pointer_args.pointers.as_mut_ptr(),
);
Ok(Value::Int(
i64::try_from(*n).map_err(|_| FFIError::ValueDontFit)?,
&mut function_impl.cif,
Some(*function_impl.code_ptr.as_safe_fun()),
&mut *n as *mut _ as *mut c_void,
- pointer_args.pointers.as_mut_ptr() as *mut *mut c_void,
+ pointer_args.pointers.as_mut_ptr(),
);
Ok(Value::Float((*n).into()))
}
&mut function_impl.cif,
Some(*function_impl.code_ptr.as_safe_fun()),
&mut *n as *mut _ as *mut c_void,
- pointer_args.pointers.as_mut_ptr() as *mut *mut c_void,
+ pointer_args.pointers.as_mut_ptr(),
);
Ok(Value::Float(*n))
}
libffi::raw::ffi_call(
&mut function_impl.cif,
Some(*function_impl.code_ptr.as_safe_fun()),
- &mut *ptr as *mut _ as *mut c_void,
- pointer_args.pointers.as_mut_ptr() as *mut *mut c_void,
+ &mut *ptr as *mut _,
+ pointer_args.pointers.as_mut_ptr(),
);
let struct_val = self.read_struct(ptr, name, struct_type);
+ #[allow(clippy::from_raw_with_void_ptr)]
drop(Box::from_raw(ptr));
struct_val
}
.ok_or(FFIError::StructNotFound)?;
field_ptr = field_ptr
.add(field_ptr.align_offset(struct_type.ffi_type.alignment as usize));
- let struct_val = self.read_struct(field_ptr, &*substruct, struct_type);
+ let struct_val = self.read_struct(field_ptr, &substruct, struct_type);
returns.push(struct_val?);
field_ptr = field_ptr.add(struct_type.ffi_type.size);
}
use crate::parser::parser::CompositeOpDesc;
use crate::types::*;
+use dashu::base::Signed;
use fxhash::FxBuildHasher;
use indexmap::{IndexMap, IndexSet};
impl RootIterationPolicy {
#[inline(always)]
pub fn iterable(&self) -> bool {
- if let RootIterationPolicy::Iterated = self {
- true
- } else {
- false
- }
+ matches!(self, RootIterationPolicy::Iterated)
}
}
}
impl ChunkedTermVec {
+ #[allow(clippy::new_without_default)]
#[inline]
pub fn new() -> Self {
Self {
// register, clause type, subterms, clause call policy.
Clause(Cell<RegType>, ClauseType, Vec<Term>, CallPolicy),
Fail,
- LocalCut { var_num: usize, cut_prev: bool }, // var_num
- GlobalCut(usize), // var_num
+ LocalCut { var_num: usize, cut_prev: bool }, // var_num
+ GlobalCut(usize), // var_num
GetCutPoint { var_num: usize, prev_b: bool },
GetLevel(usize), // var_num
}
impl QueryTerm {
pub(crate) fn arity(&self) -> usize {
match self {
- &QueryTerm::Clause(_, _, ref subterms, ..) => subterms.len(),
+ QueryTerm::Clause(_, _, subterms, ..) => subterms.len(),
&QueryTerm::GetLevel(_) | &QueryTerm::GetCutPoint { .. } => 1,
_ => 0,
}
impl ClauseInfo for PredicateClause {
fn name(&self) -> Option<Atom> {
match self {
- &PredicateClause::Fact(ref term, ..) => term.head.name(),
- &PredicateClause::Rule(ref rule, ..) => rule.name(),
+ PredicateClause::Fact(ref term, ..) => term.head.name(),
+ PredicateClause::Rule(ref rule, ..) => rule.name(),
}
}
fn arity(&self) -> usize {
match self {
- &PredicateClause::Fact(ref term, ..) => term.head.arity(),
- &PredicateClause::Rule(ref rule, ..) => rule.arity(),
+ PredicateClause::Fact(ref term, ..) => term.head.arity(),
+ PredicateClause::Rule(ref rule, ..) => rule.arity(),
}
}
}
pub(crate) fn args(&self) -> Option<&[Term]> {
match self {
PredicateClause::Fact(term, ..) => match &term.head {
- Term::Clause(_, _, args) => Some(&args),
+ Term::Clause(_, _, args) => Some(args),
_ => None,
},
PredicateClause::Rule(rule, ..) => {
pub(crate) fn insert_into_op_dir(&self, op_dir: &mut OpDir) -> Option<OpDesc> {
let key = (self.name, fixity(self.op_desc.get_spec() as u32));
- match op_dir.get_mut(&key) {
- Some(cell) => {
- let (old_prec, old_spec) = cell.get();
- cell.set(self.op_desc.get_prec(), self.op_desc.get_spec());
- return Some(OpDesc::build_with(old_prec, old_spec));
- }
- None => {}
+ if let Some(cell) = op_dir.get_mut(&key) {
+ let (old_prec, old_spec) = cell.get();
+ cell.set(self.op_desc.get_prec(), self.op_desc.get_spec());
+ return Some(OpDesc::build_with(old_prec, old_spec));
}
op_dir.insert(key, self.op_desc)
existing_desc: Option<CompositeOpDesc>,
op_dir: &mut OpDir,
) -> Result<(), SessionError> {
- let (spec, name) = (self.op_desc.get_spec(), self.name.clone());
+ let (spec, name) = (self.op_desc.get_spec(), self.name);
if is_infix!(spec as u32) {
if let Some(desc) = existing_desc {
pub fn as_atom(&self, atom_tbl: &AtomTable) -> Atom {
match self {
&AtomOrString::Atom(atom) => atom,
- AtomOrString::String(string) => AtomTable::build_with(atom_tbl, &string),
+ AtomOrString::String(string) => AtomTable::build_with(atom_tbl, string),
}
}
AtomOrString::String(string) => AtomString::Static(string.as_str()),
}
}
+}
- #[inline]
- pub fn to_string(self) -> String {
- match self {
+impl From<AtomOrString> for String {
+ fn from(val: AtomOrString) -> Self {
+ match val {
AtomOrString::Atom(atom) => atom.as_str().to_owned(),
AtomOrString::String(string) => string,
}
}
}),
1 => {
- if let Some(op_desc) = op_dir.get(&(name.clone(), Fixity::Pre)) {
+ if let Some(op_desc) = op_dir.get(&(name, Fixity::Pre)) {
if op_desc.get_prec() > 0 {
return Some(*op_desc);
}
impl Number {
pub(crate) fn sign(&self) -> Number {
match self {
- &Number::Float(f) if f == 0.0 => Number::Float(OrderedFloat(0f64)),
- &Number::Float(f) => Number::Float(OrderedFloat(f.signum())),
+ Number::Float(f) if *f == 0.0 => Number::Float(OrderedFloat(0f64)),
+ Number::Float(f) => Number::Float(OrderedFloat(f.signum())),
_ => {
if self.is_positive() {
Number::Fixnum(Fixnum::build_with(1))
#[inline]
pub(crate) fn is_positive(&self) -> bool {
match self {
- &Number::Fixnum(n) => n.get_num() > 0,
- &Number::Integer(ref n) => &**n > &Integer::from(0),
- &Number::Float(f) => f.is_sign_positive(),
- &Number::Rational(ref r) => &**r > &Rational::from(0),
+ Number::Fixnum(n) => n.get_num() > 0,
+ Number::Integer(ref n) => n.is_positive(),
+ Number::Float(f) => f.is_sign_positive(),
+ Number::Rational(ref r) => r.is_positive(),
}
}
#[inline]
pub(crate) fn is_negative(&self) -> bool {
match self {
- &Number::Fixnum(n) => n.get_num() < 0,
- &Number::Integer(ref n) => &**n < &Integer::from(0),
- &Number::Float(OrderedFloat(f)) => f.is_sign_negative() && OrderedFloat(f) != -0f64,
- &Number::Rational(ref r) => &**r < &Rational::from(0),
+ Number::Fixnum(n) => n.get_num() < 0,
+ Number::Integer(ref n) => n.is_negative(),
+ &Number::Float(OrderedFloat(f)) => f.is_sign_negative() && f != -0f64,
+ Number::Rational(ref r) => r.is_negative(),
}
}
#[inline]
pub(crate) fn is_zero(&self) -> bool {
match self {
- &Number::Fixnum(n) => n.get_num() == 0,
- &Number::Integer(ref n) => &**n == &Integer::from(0),
- &Number::Float(f) => f == OrderedFloat(0f64) || f == OrderedFloat(-0f64),
- &Number::Rational(ref r) => &**r == &Rational::from(0),
+ Number::Fixnum(n) => n.get_num() == 0,
+ Number::Integer(ref n) => n.is_zero(),
+ &Number::Float(OrderedFloat(f)) => f == 0.0 || f == -0.0,
+ Number::Rational(ref r) => r.is_zero(),
}
}
#[inline]
pub(crate) fn is_integer(&self) -> bool {
- match self {
- Number::Fixnum(_) | Number::Integer(_) => true,
- _ => false,
- }
+ matches!(self, Number::Fixnum(_) | Number::Integer(_))
}
}
#[inline]
pub(crate) fn add_retracted_dynamic_clause_info(&mut self, clause_info: ClauseIndexInfo) {
- debug_assert_eq!(self.is_dynamic, true);
+ debug_assert!(self.is_dynamic);
if self.retracted_dynamic_clauses.is_none() {
self.retracted_dynamic_clauses = Some(vec![]);
) -> Option<usize> {
let search_result = self.core.clause_clause_locs.make_contiguous()
[0..self.core.clause_assert_margin]
- .binary_search_by(|loc| clause_clause_loc.cmp(&loc));
+ .binary_search_by(|loc| clause_clause_loc.cmp(loc));
match search_result {
Ok(loc) => Some(loc),
self.start_value.set_mark_bit(true);
self.iter_stack.push(self.start_value);
- while let Some(_) = self.follow() {}
+ while self.follow().is_some() {}
}
}
let arity = cell_as_atom_cell!(self.heap[s]).get_arity();
for idx in (s + 1 .. s + arity + 1).rev() {
- if self.heap[idx].get_mark_bit() != self.mark_phase {
+ if self.heap[idx].get_mark_bit() != self.mark_phase {
self.iter_stack.push(self.heap[idx]);
self.heap[idx].set_mark_bit(self.mark_phase);
- }
+ }
}
}
(HeapCellValueTag::Lis, l) => {
- if self.heap[l+1].get_mark_bit() != self.mark_phase {
- self.iter_stack.push(self.heap[l+1]);
- self.heap[l+1].set_mark_bit(self.mark_phase);
- }
-
- if self.heap[l].get_mark_bit() != self.mark_phase {
- self.iter_stack.push(self.heap[l]);
- self.heap[l].set_mark_bit(self.mark_phase);
- }
+ if self.heap[l+1].get_mark_bit() != self.mark_phase {
+ self.iter_stack.push(self.heap[l+1]);
+ self.heap[l+1].set_mark_bit(self.mark_phase);
+ }
+
+ if self.heap[l].get_mark_bit() != self.mark_phase {
+ self.iter_stack.push(self.heap[l]);
+ self.heap[l].set_mark_bit(self.mark_phase);
+ }
}
(HeapCellValueTag::AttrVar | HeapCellValueTag::Var, h) => {
let var_value = self.heap[h];
fn focus(&self) -> IterStackLoc;
}
-impl<'a, ElideLists: ListElisionPolicy> FocusedHeapIter for StackfulPreOrderHeapIter<'a, ElideLists> {
+impl<'a, ElideLists: ListElisionPolicy> FocusedHeapIter
+ for StackfulPreOrderHeapIter<'a, ElideLists>
+{
#[inline]
fn focus(&self) -> IterStackLoc {
self.h
}
#[inline(always)]
-pub(crate) fn cycle_detecting_stackless_preorder_iter<'a>(
- heap: &'a mut [HeapCellValue],
+pub(crate) fn cycle_detecting_stackless_preorder_iter(
+ heap: &'_ mut [HeapCellValue],
start: usize,
-) -> CycleDetectingIter<'a, true> {
+) -> CycleDetectingIter<'_, true> {
// const generics argument of true so that cycle discovery stops
// the iterator.
CycleDetectingIter::new(heap, start)
#[cfg(test)]
mod tests {
use super::*;
+ use crate::machine::gc::IteratorUMP;
use crate::machine::mock_wam::*;
- use crate::machine::gc::{IteratorUMP};
pub(crate) type RightistPostOrderHeapIter<'a> =
PostOrderIterator<StacklessPreOrderHeapIter<'a, IteratorUMP>>;
#[inline(always)]
pub(crate) fn stackless_preorder_iter(
- heap: &mut Vec<HeapCellValue>,
+ heap: &mut [HeapCellValue],
start: usize,
) -> StacklessPreOrderHeapIter<IteratorUMP> {
StacklessPreOrderHeapIter::<IteratorUMP>::new(heap, start)
}
#[inline]
- pub(crate) fn stackless_post_order_iter<'a>(
- heap: &'a mut Heap,
+ pub(crate) fn stackless_post_order_iter(
+ heap: &'_ mut Heap,
start: usize,
- ) -> RightistPostOrderHeapIter<'a> {
+ ) -> RightistPostOrderHeapIter {
PostOrderIterator::new(stackless_preorder_iter(heap, start))
}
let pstr_offset_cell = pstr_offset_as_cell!(0);
assert_eq!(unmark_cell_bits!(iter.next().unwrap()), pstr_offset_cell);
- assert_eq!(unmark_cell_bits!(iter.next().unwrap()), fixnum_as_cell!(Fixnum::build_with(2)));
+ assert_eq!(
+ unmark_cell_bits!(iter.next().unwrap()),
+ fixnum_as_cell!(Fixnum::build_with(2))
+ );
assert_eq!(unmark_cell_bits!(iter.next().unwrap()), pstr_cell);
assert_eq!(unmark_cell_bits!(iter.next().unwrap()), pstr_second_cell);
let pstr_offset_cell = pstr_offset_as_cell!(0);
assert_eq!(unmark_cell_bits!(iter.next().unwrap()), pstr_cell);
- assert_eq!(unmark_cell_bits!(iter.next().unwrap()), pstr_loc_as_cell!(4));
+ assert_eq!(
+ unmark_cell_bits!(iter.next().unwrap()),
+ pstr_loc_as_cell!(4)
+ );
assert_eq!(unmark_cell_bits!(iter.next().unwrap()), pstr_offset_cell);
assert_eq!(unmark_cell_bits!(iter.next().unwrap()), pstr_offset_cell);
- assert_eq!(unmark_cell_bits!(iter.next().unwrap()), fixnum_as_cell!(Fixnum::build_with(0)));
+ assert_eq!(
+ unmark_cell_bits!(iter.next().unwrap()),
+ fixnum_as_cell!(Fixnum::build_with(0))
+ );
assert_eq!(iter.next(), None);
}
let mut iter = stackless_preorder_iter(&mut wam.machine_st.heap, 6);
assert_eq!(unmark_cell_bits!(iter.next().unwrap()), pstr_cell);
- assert_eq!(unmark_cell_bits!(iter.next().unwrap()), pstr_loc_as_cell!(4));
+ assert_eq!(
+ unmark_cell_bits!(iter.next().unwrap()),
+ pstr_loc_as_cell!(4)
+ );
assert_eq!(
unmark_cell_bits!(iter.next().unwrap()),
}
assert_eq!(wam.machine_st.heap[4], pstr_offset_as_cell!(0));
- assert_eq!(wam.machine_st.heap[5], fixnum_as_cell!(Fixnum::build_with(1i64)));
+ assert_eq!(
+ wam.machine_st.heap[5],
+ fixnum_as_cell!(Fixnum::build_with(1i64))
+ );
all_cells_unmarked(&wam.machine_st.heap);
wam.machine_st.heap.clear();
{
- wam.machine_st.heap.push(fixnum_as_cell!(Fixnum::build_with(0)));
+ wam.machine_st
+ .heap
+ .push(fixnum_as_cell!(Fixnum::build_with(0)));
let mut iter = stackless_preorder_iter(&mut wam.machine_st.heap, 0);
atom_as_cell!(atom!("y"))
);
- assert_eq!(unmark_cell_bits!(iter.next().unwrap()), heap_loc_as_cell!(0));
+ assert_eq!(
+ unmark_cell_bits!(iter.next().unwrap()),
+ heap_loc_as_cell!(0)
+ );
assert!(iter.next().is_none());
}
wam.machine_st.heap.push(heap_loc_as_cell!(0));
{
- let mut iter = stackless_preorder_iter(
- &mut wam.machine_st.heap,
- 9,
- );
+ let mut iter = stackless_preorder_iter(&mut wam.machine_st.heap, 9);
/*
while let Some(_) = iter.next() {
{
wam.machine_st.heap.push(heap_loc_as_cell!(0));
- let mut iter =
- stackless_post_order_iter(&mut wam.machine_st.heap, 0);
+ let mut iter = stackless_post_order_iter(&mut wam.machine_st.heap, 0);
assert_eq!(
unmark_cell_bits!(iter.next().unwrap()),
wam.machine_st.heap.push(empty_list_as_cell!());
{
- let mut iter =
- stackless_post_order_iter(&mut wam.machine_st.heap, 0);
+ let mut iter = stackless_post_order_iter(&mut wam.machine_st.heap, 0);
assert_eq!(
unmark_cell_bits!(iter.next().unwrap()),
wam.machine_st.heap.push(heap_loc_as_cell!(0));
{
- let mut iter =
- stackless_post_order_iter(&mut wam.machine_st.heap, 0);
+ let mut iter = stackless_post_order_iter(&mut wam.machine_st.heap, 0);
// the cycle will be iterated twice before being detected.
assert_eq!(
}
{
- let mut iter =
- stackless_post_order_iter(&mut wam.machine_st.heap, 0);
+ let mut iter = stackless_post_order_iter(&mut wam.machine_st.heap, 0);
// cut the iteration short to check that all cells are
// unmarked and unforwarded by the Drop instance of
wam.machine_st.heap.push(pstr_loc_as_cell!(0));
{
- let mut iter =
- stackless_post_order_iter(&mut wam.machine_st.heap, 2);
+ let mut iter = stackless_post_order_iter(&mut wam.machine_st.heap, 2);
assert_eq!(
unmark_cell_bits!(iter.next().unwrap()),
unmark_cell_bits!(iter.next().unwrap()),
heap_loc_as_cell!(3)
);
- assert_eq!(
- unmark_cell_bits!(iter.next().unwrap()),
- pstr_second_cell
- );
+ assert_eq!(unmark_cell_bits!(iter.next().unwrap()), pstr_second_cell);
assert_eq!(unmark_cell_bits!(iter.next().unwrap()), pstr_cell);
assert_eq!(iter.next(), None);
}
use crate::arena::*;
use crate::atom_table::*;
use crate::parser::ast::*;
-use crate::parser::dashu::{ibig, Integer, Rational};
use crate::parser::dashu::base::RemEuclid;
use crate::parser::dashu::integer::Sign;
+use crate::parser::dashu::{ibig, Integer, Rational};
use crate::{
alpha_numeric_char, capital_letter_char, cut_char, decimal_digit_char, graphic_token_char,
is_fx, is_infix, is_postfix, is_prefix, is_xf, is_xfx, is_xfy, is_yfx, semicolon_char,
use crate::machine::streams::*;
use crate::types::*;
+use dashu::base::Signed;
use ordered_float::OrderedFloat;
use indexmap::IndexMap;
oc == '(' || alpha_numeric_char!(oc)
} else if graphic_token_char!(ac) {
graphic_token_char!(oc)
- } else if variable_indicator_char!(ac) {
- alpha_numeric_char!(oc)
- } else if capital_letter_char!(ac) {
+ } else if variable_indicator_char!(ac) || capital_letter_char!(ac) {
alpha_numeric_char!(oc)
} else if sign_char!(ac) {
sign_char!(oc) || decimal_digit_char!(oc)
fn non_quoted_graphic_token<Iter: Iterator<Item = char>>(mut iter: Iter, c: char) -> bool {
if c == '/' {
- return match iter.next() {
+ match iter.next() {
None => true,
Some('*') => false, // if we start with comment token, we must quote.
Some(c) => {
false
}
}
- };
+ }
} else if c == '.' {
- return match iter.next() {
+ match iter.next() {
None => false,
Some(c) => {
if graphic_token_char!(c) {
false
}
}
- };
+ }
} else {
iter.all(|c| graphic_token_char!(c))
}
iter.all(|c| alpha_numeric_char!(c))
} else if graphic_token_char!(c) {
non_quoted_graphic_token(iter, c)
- } else if semicolon_char!(c) {
- iter.next().is_none()
- } else if cut_char!(c) {
+ } else if semicolon_char!(c) || cut_char!(c) {
iter.next().is_none()
} else if c == '[' {
iter.next() == Some(']') && iter.next().is_none()
}
}
+#[allow(clippy::len_without_is_empty)]
pub trait HCValueOutputter {
type Output;
}
fn begin_new_var(&mut self) {
- if self.contents.len() != 0 {
+ if !self.contents.is_empty() {
self.contents += ", ";
}
}
op.is_negative_sign()
&& iter.leftmost_leaf_has_property(op_dir, |addr| match Number::try_from(addr) {
Ok(Number::Fixnum(n)) => n.get_num() > 0,
- Ok(Number::Float(f)) => f > OrderedFloat(0f64),
- Ok(Number::Integer(n)) => &*n > &Integer::from(0),
- Ok(Number::Rational(n)) => &*n > &Rational::from(0),
+ Ok(Number::Float(OrderedFloat(f))) => f > 0f64,
+ Ok(Number::Integer(n)) => n.is_positive(),
+ Ok(Number::Rational(n)) => n.is_positive(),
_ => false,
})
} else {
}
match Number::try_from(addr) {
- Ok(Number::Fixnum(n)) => {
- if n.get_num() >= 0 {
- Some(numbervar(offset + Integer::from(n.get_num())))
- } else {
- None
- }
- }
- Ok(Number::Integer(n)) => {
- if &*n >= &Integer::from(0) {
- Some(numbervar(Integer::from(offset + &*n)))
- } else {
- None
- }
+ Ok(Number::Fixnum(n)) if n.get_num() >= 0 => {
+ Some(numbervar(offset + Integer::from(n.get_num())))
}
+ Ok(Number::Integer(n)) if !n.is_negative() => Some(numbervar(Integer::from(offset + &*n))),
_ => None,
}
}
self.state_stack.push(TokenOrRedirect::Op(name, spec));
}
} else {
- match &*name.as_str() {
- "|" => {
- self.format_bar_separator_op(max_depth, name, spec);
- return;
- }
- _ => {}
+ if let "|" = &*name.as_str() {
+ self.format_bar_separator_op(max_depth, name, spec);
+ return;
};
if self.max_depth_exhausted(max_depth) {
if is_xfy!(spec.get_spec()) {
let left_directed_op = DirectedOp::Left(name, spec);
- self.state_stack.push(TokenOrRedirect::CompositeRedirect(
- 0,
- left_directed_op,
- ));
+ self.state_stack
+ .push(TokenOrRedirect::CompositeRedirect(0, left_directed_op));
self.state_stack.push(TokenOrRedirect::Op(name, spec));
self.state_stack.push(TokenOrRedirect::StackPop);
- } else { // is_yfx!
+ } else {
+ // is_yfx!
let right_directed_op = DirectedOp::Right(name, spec);
self.state_stack.push(TokenOrRedirect::StackPop);
self.state_stack.push(TokenOrRedirect::Op(name, spec));
- self.state_stack.push(TokenOrRedirect::CompositeRedirect(
- 0,
- right_directed_op,
- ));
+ self.state_stack
+ .push(TokenOrRedirect::CompositeRedirect(0, right_directed_op));
}
} else {
let left_directed_op = DirectedOp::Left(name, spec);
let h = self.iter.stack_last().unwrap();
let cell = self.iter.read_cell(h);
- let cell = heap_bound_store(&self.iter.heap, heap_bound_deref(&self.iter.heap, cell));
+ let cell = heap_bound_store(self.iter.heap, heap_bound_deref(self.iter.heap, cell));
// 7.10.4
if let Some(var) = numbervar(&self.numbervars_offset, cell) {
name: Atom,
op_desc: Option<OpDesc>,
) -> bool {
- if self.numbervars && is_numbered_var(name, arity) {
- if self.format_numbered_vars() {
- return true;
- }
+ if self.numbervars && is_numbered_var(name, arity) && self.format_numbered_vars() {
+ return true;
}
let dot_atom = atom!(".");
if let Some(spec) = op_desc {
- if dot_atom == name && is_infix!(spec.get_spec()) {
- if !self.ignore_ops {
- self.push_list(max_depth);
- return true;
- }
+ if dot_atom == name && is_infix!(spec.get_spec()) && !self.ignore_ops {
+ self.push_list(max_depth);
+ return true;
}
if !self.ignore_ops && spec.get_prec() > 0 {
}
}
- return match (name, arity) {
+ match (name, arity) {
(atom!("{}"), 1) if !self.ignore_ops => self.format_curly_braces(max_depth),
_ => self.format_struct(max_depth, arity, name),
- };
+ }
}
fn offset_as_string(&mut self, h: IterStackLoc) -> Option<String> {
loop {
let is_cyclic = orig_cell.get_forwarding_bit();
- let cell = heap_bound_store(self.iter.heap, heap_bound_deref(self.iter.heap, orig_cell));
+ let cell =
+ heap_bound_store(self.iter.heap, heap_bound_deref(self.iter.heap, orig_cell));
let cell = unmark_cell_bits!(cell);
match self.var_names.get(&cell).cloned() {
}
let h = cell.get_value() as usize;
- self.iter.push_stack(IterStackLoc::iterable_loc(h, HeapOrStackTag::Heap));
+ self.iter.push_stack(IterStackLoc::iterable_loc(
+ h,
+ HeapOrStackTag::Heap,
+ ));
if let Some(cell) = self.iter.next() {
orig_cell = cell;
}
}
} else {
- while let Some(_) = self.iter.pop_stack() {}
+ while self.iter.pop_stack().is_none() {}
None
}
}
fn print_impromptu_atom(&mut self, atom: Atom) {
- let result = self.print_op_addendum(&*atom.as_str());
+ let result = self.print_op_addendum(&atom.as_str());
push_space_if_amb!(self, result.as_str(), {
append_str!(self, &result);
self.state_stack.push(TokenOrRedirect::Open);
self.state_stack.push(TokenOrRedirect::Atom(rdiv_ct));
}
-
- return;
}
_ => {
unreachable!()
let mut heap_pstr_iter = HeapPStrIter::new(self.iter.heap, focus.value() as usize);
if heap_pstr_iter.next().is_some() {
- while let Some(_) = heap_pstr_iter.next() {}
+ for _ in heap_pstr_iter.by_ref() {}
} else {
return self.push_list(max_depth);
}
let at_cdr = self.outputter.ends_with("|");
- if self.double_quotes {
- if !self.ignore_ops && end_cell.is_string_terminator(&self.iter.heap) {
- self.remove_list_children(focus.value() as usize);
- return self.print_proper_string(focus.value() as usize, max_depth);
- }
+ if self.double_quotes && !self.ignore_ops && end_cell.is_string_terminator(self.iter.heap) {
+ self.remove_list_children(focus.value() as usize);
+ return self.print_proper_string(focus.value() as usize, max_depth);
}
if self.ignore_ops {
append_str!(self, "[]");
}
} else {
- self.state_stack.push(TokenOrRedirect::FunctorRedirect(max_depth));
- self.iter.push_stack(IterStackLoc::iterable_loc(end_h, HeapOrStackTag::Heap));
+ self.state_stack
+ .push(TokenOrRedirect::FunctorRedirect(max_depth));
+ self.iter
+ .push_stack(IterStackLoc::iterable_loc(end_h, HeapOrStackTag::Heap));
}
}
} else {
read_heap_cell!(value,
(HeapCellValueTag::Lis) => {
- return self.push_list(max_depth);
+ self.push_list(max_depth)
}
_ => {
let switch = Rc::new(Cell::new((!at_cdr, 0)));
let switch = self.close_list(cell);
- self.state_stack.push(TokenOrRedirect::FunctorRedirect(max_depth));
+ self.state_stack
+ .push(TokenOrRedirect::FunctorRedirect(max_depth));
self.state_stack.push(TokenOrRedirect::HeadTailSeparator); // bar
- self.state_stack.push(TokenOrRedirect::FunctorRedirect(max_depth + 1));
+ self.state_stack
+ .push(TokenOrRedirect::FunctorRedirect(max_depth + 1));
self.open_list(switch);
}
+ #[allow(clippy::too_many_arguments)]
fn handle_op_as_struct(
&mut self,
name: Atom,
for op in &[op, parent_op] {
if let Some(ref op) = &op {
if op.is_left()
- && (op.is_prefix() || requires_space(&*op.as_atom().as_str(), "("))
+ && (op.is_prefix() || requires_space(&op.as_atom().as_str(), "("))
{
self.state_stack.push(TokenOrRedirect::Space);
return;
#[allow(dead_code)]
fn print_tcp_listener(&mut self, tcp_listener: &TcpListener, max_depth: usize) {
- let (ip, port) = if let Some(addr) = tcp_listener.local_addr().ok() {
+ let (ip, port) = if let Ok(addr) = tcp_listener.local_addr() {
(addr.ip(), addr.port())
} else {
let disconnected_atom = atom!("$disconnected_tcp_listener");
}
fn print_comma_separated_char_list(&mut self, char_list: CommaSeparatedCharList) {
- let CommaSeparatedCharList { pstr, offset, max_depth, end_cell, end_h } = char_list;
+ let CommaSeparatedCharList {
+ pstr,
+ offset,
+ max_depth,
+ end_cell,
+ end_h,
+ } = char_list;
let pstr_str = pstr.as_str_from(offset);
if let Some(c) = pstr_str.chars().next() {
let offset = offset + c.len_utf8();
if !self.max_depth_exhausted(max_depth) {
- self.state_stack.push(TokenOrRedirect::CommaSeparatedCharList(CommaSeparatedCharList {
- pstr,
- offset,
- max_depth: max_depth.saturating_sub(1),
- end_cell,
- end_h,
- }));
+ self.state_stack
+ .push(TokenOrRedirect::CommaSeparatedCharList(
+ CommaSeparatedCharList {
+ pstr,
+ offset,
+ max_depth: max_depth.saturating_sub(1),
+ end_cell,
+ end_h,
+ },
+ ));
let max_depth_allows = self.max_depth == 0 || max_depth > 1;
- if max_depth_allows && pstr_str.chars().skip(1).next().is_some() {
+ if max_depth_allows && pstr_str.chars().nth(1).is_some() {
self.state_stack.push(TokenOrRedirect::Comma);
}
self.state_stack.push(TokenOrRedirect::HeadTailSeparator);
} else if end_cell != empty_list_as_cell!() {
if let Some(end_h) = end_h {
- self.iter.push_stack(IterStackLoc::iterable_loc(end_h, HeapOrStackTag::Heap));
+ self.iter
+ .push_stack(IterStackLoc::iterable_loc(end_h, HeapOrStackTag::Heap));
}
- self.state_stack.push(TokenOrRedirect::FunctorRedirect(max_depth + 1));
+ self.state_stack
+ .push(TokenOrRedirect::FunctorRedirect(max_depth + 1));
self.state_stack.push(TokenOrRedirect::HeadTailSeparator);
}
}
let print_struct = |printer: &mut Self, name: Atom, arity: usize| {
if name == atom!("[]") && arity == 0 {
- match printer.state_stack.last() {
- Some(TokenOrRedirect::CloseList(_) | TokenOrRedirect::ChildCloseList) => {
- if printer.at_cdr("") {
- return;
- }
+ if let Some(TokenOrRedirect::CloseList(_) | TokenOrRedirect::ChildCloseList) =
+ printer.state_stack.last()
+ {
+ if printer.at_cdr("") {
+ return;
}
- _ => {}
}
append_str!(printer, "[]");
result.push('(');
}
- result += &printer.print_op_addendum(&*name.as_str());
+ result += &printer.print_op_addendum(&name.as_str());
if op.is_some() {
result.push(')');
append_str!(printer, &result);
});
} else {
- push_space_if_amb!(printer, &*name.as_str(), {
+ push_space_if_amb!(printer, &name.as_str(), {
printer.print_impromptu_atom(name);
});
}
};
if !addr.is_var()
- && !addr.is_compound(&self.iter.heap)
+ && !addr.is_compound(self.iter.heap)
&& self.max_depth_exhausted(max_depth)
{
if !(addr == atom_as_cell!(atom!("[]")) && self.at_cdr("")) {
TokenOrRedirect::BarAsOp => append_str!(self, " | "),
TokenOrRedirect::Char(c) => print_char!(self, self.quoted, c),
TokenOrRedirect::Op(atom, op) => {
- self.print_op(&*atom.as_str());
+ self.print_op(&atom.as_str());
if is_prefix!(op.get_spec()) {
self.set_parent_of_first_op(Some(DirectedOp::Left(atom, op)));
-use std::sync::{Arc, Mutex, Condvar};
use std::io::BufRead;
+use std::sync::{Arc, Condvar, Mutex};
use warp::http;
pub(crate) fn remove_constant_indices(
constant: Literal,
overlapping_constants: &[Literal],
- indexing_code: &mut Vec<IndexingLine>,
+ indexing_code: &mut [IndexingLine],
offset: usize,
) {
let mut index = 0;
pub(crate) fn remove_structure_index(
name: Atom,
arity: usize,
- indexing_code: &mut Vec<IndexingLine>,
+ indexing_code: &mut [IndexingLine],
offset: usize,
) {
let mut index = 0;
IndexingLine::Indexing(IndexingInstruction::SwitchOnStructure(ref mut structures)) => {
structures_index = index;
- match structures.get(&(name.clone(), arity)).cloned() {
+ match structures.get(&(name, arity)).cloned() {
Some(IndexingCodePtr::DynamicExternal(_))
| Some(IndexingCodePtr::External(_)) => {
- structures.remove(&(name.clone(), arity));
+ structures.remove(&(name, arity));
break;
}
Some(IndexingCodePtr::Internal(o)) => {
IndexingLine::Indexing(IndexingInstruction::SwitchOnStructure(
ref mut structures,
)) => {
- structures.insert((name.clone(), arity), ext);
+ structures.insert((name, arity), ext);
}
_ => {
unreachable!()
IndexingLine::Indexing(IndexingInstruction::SwitchOnStructure(
ref mut structures,
)) => {
- structures.insert((name.clone(), arity), ext);
+ structures.insert((name, arity), ext);
}
_ => {
unreachable!()
}
}
-pub(crate) fn remove_list_index(indexing_code: &mut Vec<IndexingLine>, offset: usize) {
+pub(crate) fn remove_list_index(indexing_code: &mut [IndexingLine], offset: usize) {
let mut index = 0;
match &mut indexing_code[index] {
pub(crate) fn remove_index(
opt_arg_index_key: &OptArgIndexKey,
- indexing_code: &mut Vec<IndexingLine>,
+ indexing_code: &mut [IndexingLine],
clause_loc: usize,
) {
match opt_arg_index_key {
#[inline]
fn cap_choice_seq(prelude: &mut [IndexedChoiceInstruction]) {
- prelude.first_mut().map(|instr| {
+ if let Some(instr) = prelude.first_mut() {
*instr = IndexedChoiceInstruction::Try(instr.offset());
- });
+ }
cap_choice_seq_with_trust(prelude);
}
#[inline]
fn cap_choice_seq_with_trust(prelude: &mut [IndexedChoiceInstruction]) {
- prelude.last_mut().map(|instr| match instr {
- IndexedChoiceInstruction::Retry(i) => {
- *instr = IndexedChoiceInstruction::Trust(*i);
- }
- IndexedChoiceInstruction::DefaultRetry(i) => {
- *instr = IndexedChoiceInstruction::DefaultTrust(*i);
+ if let Some(instr) = prelude.last_mut() {
+ match instr {
+ IndexedChoiceInstruction::Retry(i) => {
+ *instr = IndexedChoiceInstruction::Trust(*i);
+ }
+ IndexedChoiceInstruction::DefaultRetry(i) => {
+ *instr = IndexedChoiceInstruction::DefaultTrust(*i);
+ }
+ _ => {}
}
- _ => {}
- });
+ }
}
#[inline]
fn uncap_choice_seq_with_trust(prelude: &mut [IndexedChoiceInstruction]) {
- prelude.last_mut().map(|instr| match instr {
- IndexedChoiceInstruction::Trust(i) => {
- *instr = IndexedChoiceInstruction::Retry(*i);
- }
- IndexedChoiceInstruction::DefaultTrust(i) => {
- *instr = IndexedChoiceInstruction::DefaultRetry(*i);
+ if let Some(instr) = prelude.last_mut() {
+ match instr {
+ IndexedChoiceInstruction::Trust(i) => {
+ *instr = IndexedChoiceInstruction::Retry(*i);
+ }
+ IndexedChoiceInstruction::DefaultTrust(i) => {
+ *instr = IndexedChoiceInstruction::DefaultRetry(*i);
+ }
+ _ => {}
}
- _ => {}
- });
+ }
}
#[inline]
fn uncap_choice_seq_with_try(prelude: &mut [IndexedChoiceInstruction]) {
- prelude.first_mut().map(|instr| {
+ if let Some(instr) = prelude.first_mut() {
if let IndexedChoiceInstruction::Try(i) = instr {
*instr = IndexedChoiceInstruction::Retry(*i);
}
- });
+ }
}
pub(crate) fn constant_key_alternatives(
}
}
Literal::Char(c) => {
- let atom = AtomTable::build_with(&atom_tbl, &c.to_string());
+ let atom = AtomTable::build_with(atom_tbl, &c.to_string());
constants.push(Literal::Atom(atom));
}
/*
Literal::Integer(ref n) => {
let result = (&**n).try_into();
if let Ok(value) = result {
- Fixnum::build_with_checked(value).map(|n| {
- constants.push(Literal::Fixnum(n));
- }).unwrap();
+ Fixnum::build_with_checked(value)
+ .map(|n| {
+ constants.push(Literal::Fixnum(n));
+ })
+ .unwrap();
}
}
_ => {}
index_locs.insert(key, IndexingCodePtr::Internal(prelude.len() + 1));
cap_choice_seq_with_trust(code.make_contiguous());
prelude.push_back(IndexingLine::from(code));
- } else {
- code.front().map(|i| {
- index_locs.insert(key, IndexingCodePtr::External(i.offset()));
- });
+ } else if let Some(i) = code.front() {
+ index_locs.insert(key, IndexingCodePtr::External(i.offset()));
}
}
) -> IndexingCodePtr {
if lists.len() > 1 {
cap_choice_seq_with_trust(lists.make_contiguous());
- let lists = mem::replace(lists, VecDeque::new());
+ let lists = std::mem::take(lists);
prelude.push_back(IndexingLine::from(lists));
IndexingCodePtr::Internal(1)
prelude.push_back(IndexingLine::DynamicIndexedChoice(
code.into_iter().collect(),
));
- } else {
- code.front().map(|i| {
- index_locs.insert(key, IndexingCodePtr::DynamicExternal(*i));
- });
+ } else if let Some(i) = code.front() {
+ index_locs.insert(key, IndexingCodePtr::DynamicExternal(*i));
}
}
prelude: &mut VecDeque<IndexingLine>,
) -> IndexingCodePtr {
if lists.len() > 1 {
- let lists = mem::replace(lists, VecDeque::new());
+ let lists = std::mem::take(lists);
prelude.push_back(IndexingLine::DynamicIndexedChoice(
lists.into_iter().collect(),
));
index: usize,
) -> Vec<Literal> {
let overlapping_constants = constant_key_alternatives(constant, atom_tbl);
- let code = self
- .indices
- .constants()
- .entry(constant)
- .or_insert(VecDeque::new());
+ let code = self.indices.constants().entry(constant).or_default();
let is_initial_index = code.is_empty();
code.push_back(I::compute_index(
));
for constant in &overlapping_constants {
- let code = self
- .indices
- .constants()
- .entry(*constant)
- .or_insert(VecDeque::new());
+ let code = self.indices.constants().entry(*constant).or_default();
let is_initial_index = code.is_empty();
let index = I::compute_index(is_initial_index, index, self.non_counted_bt);
}
fn index_structure(&mut self, name: Atom, arity: usize, index: usize) -> usize {
- let code = self
- .indices
- .structures()
- .entry((name.clone(), arity))
- .or_insert(VecDeque::new());
+ let code = self.indices.structures().entry((name, arity)).or_default();
let code_len = code.len();
let is_initial_index = code.is_empty();
}
&Term::Clause(_, name, ref terms) => {
clause_index_info.opt_arg_index_key =
- OptArgIndexKey::Structure(self.optimal_index, 0, name.clone(), terms.len());
+ OptArgIndexKey::Structure(self.optimal_index, 0, name, terms.len());
self.index_structure(name, terms.len(), index);
}
&mut prelude,
);
- match &mut str_loc {
- IndexingCodePtr::Internal(ref mut i) => {
- *i += emitted_switch_on_constant as usize; // con_loc.is_internal() as usize;
- }
- _ => {}
- };
+ if let IndexingCodePtr::Internal(ref mut i) = &mut str_loc {
+ *i += emitted_switch_on_constant as usize; // con_loc.is_internal() as usize;
+ }
- match &mut lst_loc {
- IndexingCodePtr::Internal(ref mut i) => {
- *i += emitted_switch_on_constant as usize; // con_loc.is_internal() as usize;
- *i += emitted_switch_on_structure as usize; // str_loc.is_internal() as usize;
- }
- _ => {}
- };
+ if let IndexingCodePtr::Internal(ref mut i) = &mut lst_loc {
+ *i += emitted_switch_on_constant as usize; // con_loc.is_internal() as usize;
+ *i += emitted_switch_on_structure as usize; // str_loc.is_internal() as usize;
+ }
let var_offset = 1 + skip_stub_try_me_else as usize;
use std::iter::*;
use std::vec::Vec;
+#[allow(clippy::borrowed_box)]
#[derive(Debug, Clone)]
pub(crate) enum TermRef<'a> {
AnonVar(Level),
}
*/
+#[allow(clippy::borrowed_box)]
#[derive(Debug)]
pub(crate) enum TermIterState<'a> {
AnonVar(Level),
fn extend_state(&mut self, lvl: Level, term: &'a QueryTerm) {
match term {
- &QueryTerm::Clause(ref cell, ClauseType::CallN(_), ref terms, _) => {
+ QueryTerm::Clause(ref cell, ClauseType::CallN(_), ref terms, _) => {
self.state_stack
.push(TermIterState::Clause(lvl, 1, cell, atom!("$call"), terms));
}
- &QueryTerm::Clause(ref cell, ref ct, ref terms, _) => {
+ QueryTerm::Clause(ref cell, ref ct, ref terms, _) => {
self.state_stack
.push(TermIterState::Clause(lvl, 0, cell, ct.name(), terms));
}
.push_back(TermIterState::subterm_to_state(lvl, term));
}
- pub(crate) fn from_rule_head_clause(terms: &'a Vec<Term>) -> Self {
+ pub(crate) fn from_rule_head_clause(terms: &'a [Term]) -> Self {
let state_queue = terms
.iter()
.map(|bt| TermIterState::subterm_to_state(Level::Shallow, bt))
}
}
-pub(crate) fn post_order_iter<'a>(term: &'a Term) -> QueryIterator<'a> {
+pub(crate) fn post_order_iter(term: &'_ Term) -> QueryIterator {
QueryIterator::from_term(term)
}
-pub(crate) fn breadth_first_iter<'a>(
- term: &'a Term,
+pub(crate) fn breadth_first_iter(
+ term: &'_ Term,
iterable_root: RootIterationPolicy,
-) -> FactIterator<'a> {
+) -> FactIterator {
FactIterator::new(term, iterable_root)
}
remaining_chunks_on_stack: usize,
}
-fn state_from_chunked_terms<'a>(chunk_vec: &'a VecDeque<ChunkedTerms>) -> ClauseIteratorState<'a> {
+fn state_from_chunked_terms(chunk_vec: &'_ VecDeque<ChunkedTerms>) -> ClauseIteratorState {
if chunk_vec.len() == 1 {
if let Some(ChunkedTerms::Branch(ref branches)) = chunk_vec.front() {
return ClauseIteratorState::RemainingBranches(branches, 0);
if focus < branches.len() =>
{
self.state_stack
- .push(ClauseIteratorState::RemainingBranches(&branches, focus + 1));
+ .push(ClauseIteratorState::RemainingBranches(branches, focus + 1));
let state = state_from_chunked_terms(&branches[focus]);
if let ClauseIteratorState::RemainingChunks(..) = &state {
#[macro_use]
extern crate static_assertions;
#[cfg(test)]
-#[macro_use] extern crate maplit;
+#[macro_use]
+extern crate maplit;
#[macro_use]
pub mod macros;
#[wasm_bindgen]
pub fn eval_code(s: &str) -> String {
use machine::mock_wam::*;
+ use web_sys::console;
let mut wam = Machine::with_test_streams();
let bytes = wam.test_load_string(s);
}
}
}
+
+impl Default for MachineArgs {
+ fn default() -> Self {
+ Self::new()
+ }
+}
use dashu::base::{Abs, Gcd, Signed, UnsignedAbs};
-use dashu::integer::IBig;
use dashu::integer::fast_div::ConstDivisor;
+use dashu::integer::IBig;
use divrem::*;
use num_order::NumOrd;
fn isize_gcd(n1: isize, n2: isize) -> Option<isize> {
if n1 == 0 {
- return n2.checked_abs().map(|n| n as isize);
+ return n2.checked_abs();
}
if n2 == 0 {
- return n1.checked_abs().map(|n| n as isize);
+ return n1.checked_abs();
}
let n1 = n1.checked_abs();
let n2 = n2.checked_abs();
- let mut n1 = if let Some(n1) = n1 { n1 } else { return None };
- let mut n2 = if let Some(n2) = n2 { n2 } else { return None };
+ let mut n1 = n1?;
+ let mut n2 = n2?;
let mut shift = 0;
}
if n1 > n2 {
- let t = n2;
- n2 = n1;
- n1 = t;
+ std::mem::swap(&mut n2, &mut n1);
}
n2 -= n1;
(Number::Fixnum(n1), Number::Integer(n2)) => {
let n1_i = n1.get_num();
- if !(n1_i == 1 || n1_i == 0 || n1_i == -1) && &*n2 < &Integer::from(0) {
+ if !(n1_i == 1 || n1_i == 0 || n1_i == -1) && n2.is_zero() {
let n = Number::Fixnum(n1);
Err(numerical_type_error(ValidType::Float, n, stub_gen))
} else {
let n1 = Integer::from(n1_i);
- Ok(Number::arena_from(binary_pow(n1, &*n2), arena))
+ Ok(Number::arena_from(binary_pow(n1, &n2), arena))
}
}
(Number::Integer(n1), Number::Fixnum(n2)) => {
let n2_i = n2.get_num();
- if !(&*n1 == &Integer::from(1)
- || &*n1 == &Integer::from(0)
- || &*n1 == &Integer::from(-1))
- && n2_i < 0
- {
+ if !(*n1 == Integer::from(1) || n1.is_zero() || *n1 == Integer::from(-1)) && n2_i < 0 {
let n = Number::Integer(n1);
Err(numerical_type_error(ValidType::Float, n, stub_gen))
} else {
}
}
(Number::Integer(n1), Number::Integer(n2)) => {
- if !(&*n1 == &Integer::from(1)
- || &*n1 == &Integer::from(0)
- || &*n1 == &Integer::from(-1))
- && &*n2 < &Integer::from(0)
+ if !(*n1 == Integer::from(1) || n1.is_zero() || *n1 == Integer::from(-1))
+ && n2.is_zero()
{
let n = Number::Integer(n1);
Err(numerical_type_error(ValidType::Float, n, stub_gen))
} else {
- Ok(Number::arena_from(binary_pow((*n1).clone(), &*n2), arena))
+ Ok(Number::arena_from(binary_pow((*n1).clone(), &n2), arena))
}
}
(n1, Number::Integer(n2)) => {
}
}
(Number::Fixnum(n1), Number::Integer(n2)) => {
- if (&*n2).num_gt(&n1.get_num()) {
+ if (*n2).num_gt(&n1.get_num()) {
Ok(Number::Integer(n2))
} else {
Ok(Number::Fixnum(n1))
}
}
(Number::Integer(n1), Number::Fixnum(n2)) => {
- if (&*n1).num_gt(&n2.get_num()) {
+ if (*n1).num_gt(&n2.get_num()) {
Ok(Number::Integer(n1))
} else {
Ok(Number::Fixnum(n2))
}
}
(Number::Fixnum(n1), Number::Integer(n2)) => {
- if (&*n2).num_lt(&n1.get_num()) {
+ if (*n2).num_lt(&n1.get_num()) {
Ok(Number::Integer(n2))
} else {
Ok(Number::Fixnum(n1))
}
}
(Number::Integer(n1), Number::Fixnum(n2)) => {
- if (&*n1).num_lt(&n2.get_num()) {
+ if (*n1).num_lt(&n2.get_num()) {
Ok(Number::Integer(n1))
} else {
Ok(Number::Fixnum(n2))
(Number::Fixnum(n1), Number::Fixnum(n2)) => {
if n2.get_num() == 0 {
Err(zero_divisor_eval_error(stub_gen))
+ } else if let Some(result) = n1.get_num().checked_div(n2.get_num()) {
+ Ok(Number::arena_from(result, arena))
} else {
- if let Some(result) = n1.get_num().checked_div(n2.get_num()) {
- Ok(Number::arena_from(result, arena))
- } else {
- let n1 = Integer::from(n1.get_num());
- let n2 = Integer::from(n2.get_num());
+ let n1 = Integer::from(n1.get_num());
+ let n2 = Integer::from(n2.get_num());
- Ok(Number::arena_from(n1 / n2, arena))
- }
+ Ok(Number::arena_from(n1 / n2, arena))
}
}
(Number::Fixnum(n1), Number::Integer(n2)) => {
let n1 = Integer::from(n1_i);
if let Ok(n2) = usize::try_from(n2_i) {
- return Ok(Number::arena_from(n1 >> n2, arena));
+ Ok(Number::arena_from(n1 >> n2, arena))
} else {
- return Ok(Number::arena_from(n1 >> usize::max_value(), arena));
+ Ok(Number::arena_from(n1 >> usize::max_value(), arena))
}
}
(Number::Fixnum(n1), Number::Integer(n2)) => {
let result: Result<usize, _> = (&*n2).try_into();
match result {
- Ok(n2) => {
- Ok(Number::arena_from(n1 >> n2, arena))
- }
- Err(_) => {
- Ok(Number::arena_from(n1 >> usize::max_value(), arena))
- }
+ Ok(n2) => Ok(Number::arena_from(n1 >> n2, arena)),
+ Err(_) => Ok(Number::arena_from(n1 >> usize::max_value(), arena)),
}
}
(Number::Integer(n1), Number::Fixnum(n2)) => match usize::try_from(n2.get_num()) {
let result: Result<usize, _> = (&*n2).try_into();
match result {
- Ok(n2) => {
- Ok(Number::arena_from(Integer::from(&*n1 >> n2), arena))
- }
- Err(_) => {
- Ok(Number::arena_from(Integer::from(&*n1 >> usize::max_value()), arena))
- }
+ Ok(n2) => Ok(Number::arena_from(Integer::from(&*n1 >> n2), arena)),
+ Err(_) => Ok(Number::arena_from(
+ Integer::from(&*n1 >> usize::max_value()),
+ arena,
+ )),
}
- },
+ }
(Number::Integer(_), n2) => Err(numerical_type_error(ValidType::Integer, n2, stub_gen)),
(Number::Fixnum(_), n2) => Err(numerical_type_error(ValidType::Integer, n2, stub_gen)),
(n1, _) => Err(numerical_type_error(ValidType::Integer, n1, stub_gen)),
let n1 = Integer::from(n1_i);
if let Ok(n2) = usize::try_from(n2_i) {
- return Ok(Number::arena_from(n1 << n2, arena));
+ Ok(Number::arena_from(n1 << n2, arena))
} else {
- return Ok(Number::arena_from(n1 << usize::max_value(), arena));
+ Ok(Number::arena_from(n1 << usize::max_value(), arena))
}
}
(Number::Fixnum(n1), Number::Integer(n2)) => {
Ok(n2) => {
let n1: u64 = n1.try_into().unwrap();
Ok(Number::arena_from(n1 << n2, arena))
- },
- _ => {
- Ok(Number::arena_from(n1 << usize::max_value(), arena))
- }
+ }
+ _ => Ok(Number::arena_from(n1 << usize::max_value(), arena)),
}
}
(Number::Integer(n1), Number::Fixnum(n2)) => match usize::try_from(n2.get_num()) {
Ok(n2) => {
let n1: u64 = (&*n1).try_into().unwrap();
Ok(Number::arena_from(Integer::from(n1 << n2), arena))
- },
- _ => {
- Ok(Number::arena_from(Integer::from(&*n1 << usize::max_value()),arena))
- }
+ }
+ _ => Ok(Number::arena_from(
+ Integer::from(&*n1 << usize::max_value()),
+ arena,
+ )),
},
(Number::Integer(_), n2) => Err(numerical_type_error(ValidType::Integer, n2, stub_gen)),
(Number::Fixnum(_), n2) => Err(numerical_type_error(ValidType::Integer, n2, stub_gen)),
Err(zero_divisor_eval_error(stub_gen))
} else {
let n1 = Integer::from(n1.get_num());
- Ok(Number::arena_from(ibig_rem_floor(&n1, &*n2), arena))
+ Ok(Number::arena_from(ibig_rem_floor(&n1, &n2), arena))
}
}
(Number::Integer(n1), Number::Fixnum(n2)) => {
Err(zero_divisor_eval_error(stub_gen))
} else {
let n2 = Integer::from(n2_i);
- Ok(Number::arena_from(ibig_rem_floor(&*n1, &n2), arena))
+ Ok(Number::arena_from(ibig_rem_floor(&n1, &n2), arena))
}
}
(Number::Integer(n1), Number::Integer(n2)) => {
if n2.is_zero() {
Err(zero_divisor_eval_error(stub_gen))
} else {
- Ok(Number::arena_from(ibig_rem_floor(&*n1, &*n2), arena))
+ Ok(Number::arena_from(ibig_rem_floor(&n1, &n2), arena))
}
}
(Number::Integer(_), n2) | (Number::Fixnum(_), n2) => {
&mut self.interms[i - 1],
Number::Fixnum(Fixnum::build_with(0)),
)),
- &ArithmeticTerm::Number(n) => Ok(n),
+ ArithmeticTerm::Number(n) => Ok(*n),
}
}
value: HeapCellValue,
) -> Result<Number, MachineStub> {
let stub_gen = || functor_stub(atom!("is"), 2);
- let mut iter = stackful_post_order_iter::<NonListElider>
- (&mut self.heap, &mut self.stack, value);
+ let mut iter =
+ stackful_post_order_iter::<NonListElider>(&mut self.heap, &mut self.stack, value);
while let Some(value) = iter.next() {
if value.get_forwarding_bit() {
let mut seen_set = IndexSet::new();
let mut seen_vars = vec![];
- let mut iter = stackful_preorder_iter::<NonListElider>
- (&mut self.heap, &mut self.stack, cell);
+ let mut iter =
+ stackful_preorder_iter::<NonListElider>(&mut self.heap, &mut self.stack, cell);
while let Some(value) = iter.next() {
read_heap_cell!(value,
.unwrap(),
);
- match &mut code[inner_try_me_else_loc] {
- Instruction::TryMeElse(ref mut o) => {
- retraction_info.push_record(RetractionRecord::ModifiedTryMeElse(
- inner_try_me_else_loc,
- *o,
- ));
+ if let Instruction::TryMeElse(ref mut o) = &mut code[inner_try_me_else_loc] {
+ retraction_info.push_record(RetractionRecord::ModifiedTryMeElse(
+ inner_try_me_else_loc,
+ *o,
+ ));
- match *o {
- 0 => {
- code[inner_try_me_else_loc] = Instruction::TrustMe(0);
- }
- o => match &code[inner_try_me_else_loc + o] {
- Instruction::RevJmpBy(0) => {
- code[inner_try_me_else_loc] = Instruction::TrustMe(o);
- }
- _ => {
- code[inner_try_me_else_loc] = Instruction::RetryMeElse(o);
- }
- },
+ match *o {
+ 0 => {
+ code[inner_try_me_else_loc] = Instruction::TrustMe(0);
}
+ o => match &code[inner_try_me_else_loc + o] {
+ Instruction::RevJmpBy(0) => {
+ code[inner_try_me_else_loc] = Instruction::TrustMe(o);
+ }
+ _ => {
+ code[inner_try_me_else_loc] = Instruction::RetryMeElse(o);
+ }
+ },
}
- _ => {}
}
thread_choice_instr_at_to(
retraction_info,
);
}
- None => match &mut code[outer_threaded_choice_instr_loc] {
- Instruction::TryMeElse(ref mut o) => {
+ None => {
+ if let Instruction::TryMeElse(ref mut o) = &mut code[outer_threaded_choice_instr_loc] {
retraction_info
.push_record(RetractionRecord::ModifiedTryMeElse(inner_trust_me_loc, *o));
return Some(IndexPtr::index(outer_threaded_choice_instr_loc + 1));
}
- _ => {}
- },
+ }
}
None
retraction_info,
);
- code.extend(prepend_queue.into_iter());
+ code.extend(prepend_queue);
if skeleton.core.is_dynamic {
clause_loc
internalize_choice_instr_at(code, old_clause_start, retraction_info);
- code.extend(prepend_queue.into_iter());
+ code.extend(prepend_queue);
clause_loc // + (outer_thread_choice_offset == 0 as usize)
}
internalize_choice_instr_at(code, old_clause_start, retraction_info);
- code.extend(prepend_queue.into_iter());
+ code.extend(prepend_queue);
// skeleton.clauses[0].opt_arg_index_key += clause_loc;
skeleton.clauses[0].clause_start = clause_loc;
internalize_choice_instr_at(code, old_clause_start, retraction_info);
- code.extend(prepend_queue.into_iter());
+ code.extend(prepend_queue);
// skeleton.clauses[0].opt_arg_index_key += clause_loc;
skeleton.clauses[0].clause_start = clause_loc;
skeleton.clauses[target_pos].opt_arg_index_key += clause_loc;
code.extend(clause_code.drain(1..));
- match skeleton.clauses[target_pos]
+ if let Some(index_loc) = skeleton.clauses[target_pos]
.opt_arg_index_key
.switch_on_term_loc()
{
- Some(index_loc) => {
- // point to the inner-threaded TryMeElse(0) if target_pos is
- // indexed, and make switch_on_term point one line after it in
- // its variable offset.
- skeleton.clauses[target_pos].clause_start += 2;
-
- if !skeleton.core.is_dynamic {
- set_switch_var_offset(code, index_loc, 2, retraction_info);
- }
+ // point to the inner-threaded TryMeElse(0) if target_pos is
+ // indexed, and make switch_on_term point one line after it in
+ // its variable offset.
+ skeleton.clauses[target_pos].clause_start += 2;
+
+ if !skeleton.core.is_dynamic {
+ set_switch_var_offset(code, index_loc, 2, retraction_info);
}
- None => {}
}
match skeleton.clauses[lower_bound]
clause_clause_locs.push_back(clause_index_info.clause_start);
}
- match &mut code[0] {
- Instruction::TryMeElse(0) => {
- code_ptr += 1;
- }
- _ => {}
+ if let Instruction::TryMeElse(0) = &mut code[0] {
+ code_ptr += 1;
}
match self
Some(skeleton) => {
let skeleton_clause_len = skeleton.clauses.len();
- skeleton.clauses.extend(cg.skeleton.clauses.into_iter());
+ skeleton.clauses.extend(cg.skeleton.clauses);
skeleton
.core
.clause_clause_locs
index_ptr,
);
- self.wam_prelude.code.extend(code.into_iter());
+ self.wam_prelude.code.extend(code);
Ok(code_index)
}
let global_clock = LS::machine_st(&mut self.payload).global_clock;
let result = append_compiled_clause(
- &mut self.wam_prelude.code,
+ self.wam_prelude.code,
clause_code,
skeleton,
&mut self.payload.retraction_info,
let global_clock = LS::machine_st(&mut self.payload).global_clock;
let new_code_ptr = prepend_compiled_clause(
- &mut self.wam_prelude.code,
+ self.wam_prelude.code,
compilation_target,
key,
clause_code,
.switch_on_term_loc()
{
Some(index_loc) => find_inner_choice_instr(
- &self.wam_prelude.code,
+ self.wam_prelude.code,
skeleton.clauses[target_pos].clause_start,
index_loc,
),
if target_pos == 0 || (lower_bound + 1 == target_pos && lower_bound_is_unindexed) {
// the clause preceding target_pos, if there is one, is of
// key type OptArgIndexKey::None.
- match skeleton.clauses[target_pos]
+ if let Some(index_loc) = skeleton.clauses[target_pos]
.opt_arg_index_key
.switch_on_term_loc()
{
- Some(index_loc) => {
- let inner_clause_start = find_inner_choice_instr(
- code,
- skeleton.clauses[target_pos].clause_start,
- index_loc,
- );
+ let inner_clause_start = find_inner_choice_instr(
+ code,
+ skeleton.clauses[target_pos].clause_start,
+ index_loc,
+ );
- remove_index_from_subsequence(
- code,
- &skeleton.clauses[target_pos].opt_arg_index_key,
- inner_clause_start,
- &mut self.payload.retraction_info,
- );
+ remove_index_from_subsequence(
+ code,
+ &skeleton.clauses[target_pos].opt_arg_index_key,
+ inner_clause_start,
+ &mut self.payload.retraction_info,
+ );
- match derelictize_try_me_else(
- code,
- inner_clause_start,
- &mut self.payload.retraction_info,
- ) {
- Some(offset) => {
- let instr_loc = find_inner_choice_instr(
- code,
- inner_clause_start + offset,
- index_loc,
- );
+ match derelictize_try_me_else(
+ code,
+ inner_clause_start,
+ &mut self.payload.retraction_info,
+ ) {
+ Some(offset) => {
+ let instr_loc =
+ find_inner_choice_instr(code, inner_clause_start + offset, index_loc);
- let clause_loc = blunt_leading_choice_instr(
- code,
- instr_loc,
- &mut self.payload.retraction_info,
- );
+ let clause_loc = blunt_leading_choice_instr(
+ code,
+ instr_loc,
+ &mut self.payload.retraction_info,
+ );
- set_switch_var_offset(
- code,
- index_loc,
- clause_loc - index_loc,
- &mut self.payload.retraction_info,
- );
+ set_switch_var_offset(
+ code,
+ index_loc,
+ clause_loc - index_loc,
+ &mut self.payload.retraction_info,
+ );
- self.payload.retraction_info.push_record(
- RetractionRecord::SkeletonClauseStartReplaced(
- payload_compilation_target,
- key,
- target_pos + 1,
- skeleton.clauses[target_pos + 1].clause_start,
- ),
- );
+ self.payload.retraction_info.push_record(
+ RetractionRecord::SkeletonClauseStartReplaced(
+ payload_compilation_target,
+ key,
+ target_pos + 1,
+ skeleton.clauses[target_pos + 1].clause_start,
+ ),
+ );
- skeleton.clauses[target_pos + 1].clause_start =
- skeleton.clauses[target_pos].clause_start;
+ skeleton.clauses[target_pos + 1].clause_start =
+ skeleton.clauses[target_pos].clause_start;
- let update_code_index = target_pos == 0
- && skeleton.clauses[target_pos + 1]
- .opt_arg_index_key
- .switch_on_term_loc()
- .is_none();
+ let update_code_index = target_pos == 0
+ && skeleton.clauses[target_pos + 1]
+ .opt_arg_index_key
+ .switch_on_term_loc()
+ .is_none();
- let index_ptr_opt = if update_code_index {
- Some(IndexPtr::index(clause_loc))
- } else {
- None
- };
+ let index_ptr_opt = if update_code_index {
+ Some(IndexPtr::index(clause_loc))
+ } else {
+ None
+ };
- return finalize_retract(
- key,
- payload_compilation_target,
- skeleton,
- code_index,
- target_pos,
- index_ptr_opt,
+ return finalize_retract(
+ key,
+ payload_compilation_target,
+ skeleton,
+ code_index,
+ target_pos,
+ index_ptr_opt,
+ &mut self.payload.retraction_info,
+ );
+ }
+ None => {
+ let index_ptr_opt = if target_pos > 0 {
+ let preceding_choice_instr_loc =
+ skeleton.clauses[target_pos - 1].clause_start;
+
+ remove_non_leading_clause(
+ code,
+ preceding_choice_instr_loc,
+ skeleton.clauses[target_pos].clause_start - 2,
&mut self.payload.retraction_info,
- );
- }
- None => {
- let index_ptr_opt = if target_pos > 0 {
- let preceding_choice_instr_loc =
- skeleton.clauses[target_pos - 1].clause_start;
-
- remove_non_leading_clause(
- code,
- preceding_choice_instr_loc,
- skeleton.clauses[target_pos].clause_start - 2,
- &mut self.payload.retraction_info,
- )
- } else {
- remove_leading_unindexed_clause(
- code,
- skeleton.clauses[target_pos].clause_start - 2,
- &mut self.payload.retraction_info,
- )
- };
-
- return finalize_retract(
- key,
- payload_compilation_target,
- skeleton,
- code_index,
- target_pos,
- index_ptr_opt,
+ )
+ } else {
+ remove_leading_unindexed_clause(
+ code,
+ skeleton.clauses[target_pos].clause_start - 2,
&mut self.payload.retraction_info,
- );
- }
+ )
+ };
+
+ return finalize_retract(
+ key,
+ payload_compilation_target,
+ skeleton,
+ code_index,
+ target_pos,
+ index_ptr_opt,
+ &mut self.payload.retraction_info,
+ );
}
}
- None => {}
}
}
Instruction::RevJmpBy(target_indexing_loc - later_indexing_loc),
);
- match target_indexing_line {
- Instruction::IndexingCode(indexing_code) => {
- self.payload.retraction_info.push_record(
- RetractionRecord::ReplacedIndexingLine(
- target_indexing_loc,
- indexing_code,
- ),
- );
- }
- _ => {}
+ if let Instruction::IndexingCode(indexing_code) = target_indexing_line {
+ self.payload.retraction_info.push_record(
+ RetractionRecord::ReplacedIndexingLine(
+ target_indexing_loc,
+ indexing_code,
+ ),
+ );
}
result = merge_indexed_subsequences(
&mut self.payload.retraction_info,
);
- match &mut code[preceding_choice_instr_loc] {
- Instruction::TryMeElse(0) => {
- set_switch_var_offset(
- code,
- index_loc,
- preceding_choice_instr_loc + 1 - index_loc,
- &mut self.payload.retraction_info,
- );
- }
- _ => {}
+ if let Instruction::TryMeElse(0) =
+ &mut code[preceding_choice_instr_loc]
+ {
+ set_switch_var_offset(
+ code,
+ index_loc,
+ preceding_choice_instr_loc + 1 - index_loc,
+ &mut self.payload.retraction_info,
+ );
}
}
}
{
Some(skeleton) if append_or_prepend.is_append() => {
let tail_num = skeleton.core.clause_clause_locs.len() - num_clause_predicates;
- skeleton.core.clause_clause_locs.make_contiguous()[tail_num..]
- .iter()
- .cloned()
- .collect()
+ skeleton.core.clause_clause_locs.make_contiguous()[tail_num..].to_vec()
}
Some(skeleton) => skeleton.core.clause_clause_locs.make_contiguous()
[0..num_clause_predicates]
- .iter()
- .cloned()
- .collect(),
+ .to_vec(),
None => {
unreachable!()
}
)?;
}
} else {
- if is_cross_module_clause {
- if !local_predicate_info.is_extensible {
- if predicate_info.is_multifile {
- println!(
- "Warning: overwriting multifile predicate {}:{}/{} because \
- it was not locally declared multifile.",
- self.payload.predicates.compilation_target,
- key.0.as_str(),
- key.1
- );
- }
-
- if let Some(skeleton) = self.wam_prelude.indices.remove_predicate_skeleton(
- &self.payload.predicates.compilation_target,
- &key,
- ) {
- let compilation_target = self.payload.predicates.compilation_target;
-
- if predicate_info.is_dynamic {
- let clause_clause_compilation_target = match compilation_target {
- CompilationTarget::User => {
- CompilationTarget::Module(atom!("builtins"))
- }
- module => module,
- };
-
- self.retract_local_clauses_by_locs(
- clause_clause_compilation_target,
- (atom!("$clause"), 2),
- (0..skeleton.clauses.len()).map(Some).collect(),
- false, // the builtin M:'$clause'/2 is never dynamic.
- );
-
- predicate_info.is_dynamic = false;
- }
+ if is_cross_module_clause && !local_predicate_info.is_extensible {
+ if predicate_info.is_multifile {
+ println!(
+ "Warning: overwriting multifile predicate {}:{}/{} because \
+ it was not locally declared multifile.",
+ self.payload.predicates.compilation_target,
+ key.0.as_str(),
+ key.1
+ );
+ }
- self.payload.retraction_info.push_record(
- RetractionRecord::RemovedSkeleton(compilation_target, key, skeleton),
+ if let Some(skeleton) = self
+ .wam_prelude
+ .indices
+ .remove_predicate_skeleton(&self.payload.predicates.compilation_target, &key)
+ {
+ let compilation_target = self.payload.predicates.compilation_target;
+
+ if predicate_info.is_dynamic {
+ let clause_clause_compilation_target = match compilation_target {
+ CompilationTarget::User => CompilationTarget::Module(atom!("builtins")),
+ module => module,
+ };
+
+ self.retract_local_clauses_by_locs(
+ clause_clause_compilation_target,
+ (atom!("$clause"), 2),
+ (0..skeleton.clauses.len()).map(Some).collect(),
+ false, // the builtin M:'$clause'/2 is never dynamic.
);
+
+ predicate_info.is_dynamic = false;
}
+
+ self.payload
+ .retraction_info
+ .push_record(RetractionRecord::RemovedSkeleton(
+ compilation_target,
+ key,
+ skeleton,
+ ));
}
}
let code_index = self.compile(key, predicates, settings)?;
if let Some(filename) = self.listing_src_file_name() {
- match self.wam_prelude.indices.modules.get_mut(&filename) {
- Some(ref mut module) => {
- let index_ptr = code_index.get();
- let code_index = module.code_dir.entry(key).or_insert(code_index).clone();
+ if let Some(ref mut module) = self.wam_prelude.indices.modules.get_mut(&filename) {
+ let index_ptr = code_index.get();
+ let code_index = *module.code_dir.entry(key).or_insert(code_index);
- set_code_index(
- &mut self.payload.retraction_info,
- &CompilationTarget::Module(filename),
- key,
- code_index,
- index_ptr,
- );
- }
- None => {}
+ set_code_index(
+ &mut self.payload.retraction_info,
+ &CompilationTarget::Module(filename),
+ key,
+ code_index,
+ index_ptr,
+ );
}
}
}
};
let StandaloneCompileResult { clause_code, .. } = compile()?;
- self.code.extend(clause_code.into_iter());
+ self.code.extend(clause_code);
Ok(())
}
fn copy_attr_var_lists(&mut self) {
while !self.attr_var_list_locs.is_empty() {
- let iter = mem::replace(&mut self.attr_var_list_locs, vec![]);
+ let iter = std::mem::take(&mut self.attr_var_list_locs);
for (threshold, list_loc) in iter {
self.target[threshold] = list_loc_as_cell!(self.target.threshold());
fn traverse_subterm(&mut self, h: usize, arity: usize) -> Option<usize> {
let mut last_cell_loc = h + arity - 1;
- for idx in (h .. h + arity).rev() {
+ for idx in (h..h + arity).rev() {
if self.heap[idx].get_forwarding_bit() {
if self.cycle_detection_active() {
self.cycle_found = true;
#[inline]
fn continue_forwarding(&self) -> bool {
- self.heap[self.current].get_mark_bit() != self.mark_phase ||
- self.heap[self.current].get_forwarding_bit()
+ self.heap[self.current].get_mark_bit() != self.mark_phase
+ || self.heap[self.current].get_forwarding_bit()
}
fn forward(&mut self) -> Option<HeapCellValue> {
}
if self.cycle_detection_active() {
- for idx in (h + 1 .. last_cell_loc).rev() {
+ for idx in (h + 1..last_cell_loc).rev() {
if self.heap[idx].get_forwarding_bit() {
self.cycle_found = true;
return None;
};
if self.cycle_detection_active() {
- for idx in (self.next as usize .. last_cell_loc).rev() {
+ for idx in (self.next as usize..last_cell_loc).rev() {
if self.heap[idx].get_forwarding_bit() {
self.cycle_found = true;
return None;
HeapCellValueTag::Str => {
let mut new_str_back_link = self.current;
- for idx in (0 .. self.current).rev() {
- if self.heap[idx].get_tag() == HeapCellValueTag::Atom {
- if cell_as_atom_cell!(self.heap[idx]).get_arity() > 0 {
- new_str_back_link = idx;
- break;
- }
+ for idx in (0..self.current).rev() {
+ if self.heap[idx].get_tag() == HeapCellValueTag::Atom
+ && cell_as_atom_cell!(self.heap[idx]).get_arity() > 0
+ {
+ new_str_back_link = idx;
+ break;
}
- if self.heap[idx].get_mark_bit() != self.mark_phase {
- if !self.heap[idx].get_forwarding_bit() {
- new_str_back_link = idx;
- break;
- }
+ if self.heap[idx].get_mark_bit() != self.mark_phase
+ && !self.heap[idx].get_forwarding_bit()
+ {
+ new_str_back_link = idx;
+ break;
}
}
self.next = self.heap[self.start].get_value();
self.current = self.start;
- while let Some(_) = self.forward() {}
+ while self.forward().is_some() {}
}
}
}
}
-
impl<'a, const STOP_AT_CYCLES: bool> Drop for CycleDetectingIter<'a, STOP_AT_CYCLES> {
fn drop(&mut self) {
self.invert_marker();
for mut branch in branches {
branch_info.branch_num = branch.branch_num;
- branch_info.chunks.extend(branch.chunks.drain(..));
+ branch_info.chunks.append(&mut branch.chunks);
}
branch_info.branch_num.delta = branch_info.branch_num.delta * Integer::from(2);
fn merge_branches(&mut self) {
for branches in self.branch_map.values_mut() {
- let mut old_branches = std::mem::replace(branches, vec![]);
+ let mut old_branches = std::mem::take(branches);
while let Some(last_branch_num) = old_branches.last().map(|bi| &bi.branch_num) {
let mut old_branches_len = old_branches.len();
.current_chunk_type
.to_gen_context(self.current_chunk_num);
- let branch_info_v = self
- .branch_map
- .entry(var_info.var_ptr.clone())
- .or_insert_with(|| vec![]);
+ let branch_info_v = self.branch_map.entry(var_info.var_ptr.clone()).or_default();
let needs_new_branch = if let Some(last_bi) = branch_info_v.last() {
!self.root_set.contains(&last_bi.branch_num)
arity: term.arity(),
};
- match term {
- Term::Clause(_, _, terms) => {
- for term in terms.into_iter() {
- for term_ref in breadth_first_iter(term, RootIterationPolicy::Iterated) {
- if let TermRef::Var(lvl, _, var_ptr) = term_ref {
- // a body term, so we need the child level here.
- let lvl = lvl.child_level();
-
- // the body of the if let here is an inlined
- // "probe_head_var". note the difference between it
- // and "probe_body_var".
- let branch_info_v = self
- .branch_map
- .entry(var_ptr.clone())
- .or_insert_with(|| vec![]);
-
- let needs_new_branch = branch_info_v.is_empty();
-
- if needs_new_branch {
- branch_info_v
- .push(BranchInfo::new(self.current_branch_num.clone()));
- }
+ if let Term::Clause(_, _, terms) = term {
+ for term in terms.iter() {
+ for term_ref in breadth_first_iter(term, RootIterationPolicy::Iterated) {
+ if let TermRef::Var(lvl, _, var_ptr) = term_ref {
+ // a body term, so we need the child level here.
+ let lvl = lvl.child_level();
- let branch_info = branch_info_v.last_mut().unwrap();
- let needs_new_chunk = branch_info.chunks.is_empty();
+ // the body of the if let here is an inlined
+ // "probe_head_var". note the difference between it
+ // and "probe_body_var".
+ let branch_info_v = self.branch_map.entry(var_ptr.clone()).or_default();
- if needs_new_chunk {
- branch_info.chunks.push(ChunkInfo {
- chunk_num: self.current_chunk_num,
- term_loc: GenContext::Head,
- vars: vec![],
- });
- }
+ let needs_new_branch = branch_info_v.is_empty();
- let chunk_info = branch_info.chunks.last_mut().unwrap();
- let var_info = VarInfo {
- var_ptr,
- classify_info,
- chunk_type: self.current_chunk_type,
- lvl,
- };
+ if needs_new_branch {
+ branch_info_v.push(BranchInfo::new(self.current_branch_num.clone()));
+ }
- chunk_info.vars.push(var_info);
+ let branch_info = branch_info_v.last_mut().unwrap();
+ let needs_new_chunk = branch_info.chunks.is_empty();
+
+ if needs_new_chunk {
+ branch_info.chunks.push(ChunkInfo {
+ chunk_num: self.current_chunk_num,
+ term_loc: GenContext::Head,
+ vars: vec![],
+ });
}
- }
- classify_info.arg_c += 1;
+ let chunk_info = branch_info.chunks.last_mut().unwrap();
+ let var_info = VarInfo {
+ var_ptr,
+ classify_info,
+ chunk_type: self.current_chunk_type,
+ lvl,
+ };
+
+ chunk_info.vars.push(var_info);
+ }
}
+
+ classify_info.arg_c += 1;
}
- _ => {}
}
Ok(())
build_stack.push_chunk_term(if is_global {
QueryTerm::GlobalCut(var_num)
} else {
- QueryTerm::LocalCut { var_num, cut_prev: false }
+ QueryTerm::LocalCut {
+ var_num,
+ cut_prev: false,
+ }
});
}
TraversalState::CutPrev(var_num) => {
self.probe_in_situ_var(var_num);
- build_stack.push_chunk_term(QueryTerm::LocalCut { var_num, cut_prev: true });
+ build_stack.push_chunk_term(QueryTerm::LocalCut {
+ var_num,
+ cut_prev: true,
+ });
}
TraversalState::Fail => {
build_stack.push_chunk_term(QueryTerm::Fail);
state_stack.push(TraversalState::BuildDisjunct(build_stack_len));
state_stack.push(TraversalState::Fail);
state_stack.push(TraversalState::CutPrev(self.var_num));
- state_stack.push(TraversalState::ResetGlobalCutVarOverride(self.global_cut_var_num_override));
+ state_stack.push(TraversalState::ResetGlobalCutVarOverride(
+ self.global_cut_var_num_override,
+ ));
state_stack.push(TraversalState::Term(not_term));
state_stack.push(TraversalState::OverrideGlobalCutVar(self.var_num));
state_stack.push(TraversalState::GetCutPoint {
impl Machine {
pub(super) fn find_living_dynamic_else(&self, mut p: usize) -> Option<(usize, usize)> {
loop {
- match &self.code[p] {
- &Instruction::DynamicElse(birth, death, NextOrFail::Next(i)) => {
+ match self.code[p] {
+ Instruction::DynamicElse(birth, death, NextOrFail::Next(i)) => {
if birth < self.machine_st.cc && Death::Finite(self.machine_st.cc) <= death {
return Some((p, i));
} else if i > 0 {
return None;
}
}
- &Instruction::DynamicElse(birth, death, NextOrFail::Fail(_)) => {
+ Instruction::DynamicElse(birth, death, NextOrFail::Fail(_)) => {
if birth < self.machine_st.cc && Death::Finite(self.machine_st.cc) <= death {
return Some((p, 0));
} else {
return None;
}
}
- &Instruction::DynamicInternalElse(birth, death, NextOrFail::Next(i)) => {
+ Instruction::DynamicInternalElse(birth, death, NextOrFail::Next(i)) => {
if birth < self.machine_st.cc && Death::Finite(self.machine_st.cc) <= death {
return Some((p, i));
} else if i > 0 {
return None;
}
}
- &Instruction::DynamicInternalElse(birth, death, NextOrFail::Fail(_)) => {
+ Instruction::DynamicInternalElse(birth, death, NextOrFail::Fail(_)) => {
if birth < self.machine_st.cc && Death::Finite(self.machine_st.cc) <= death {
return Some((p, 0));
} else {
return None;
}
}
- &Instruction::RevJmpBy(i) => {
+ Instruction::RevJmpBy(i) => {
p -= i;
}
_ => {
fn execute_switch_on_term(&mut self) {
#[inline(always)]
fn dynamic_external_of_clause_is_valid(machine: &mut Machine, p: usize) -> bool {
- match &machine.code[p] {
- Instruction::DynamicInternalElse(..) => {
- machine.machine_st.dynamic_mode = FirstOrNext::First;
- return true;
- }
- _ => {}
+ if let Instruction::DynamicInternalElse(..) = machine.code[p] {
+ machine.machine_st.dynamic_mode = FirstOrNext::First;
+ return true;
}
- match &machine.code[p - 1] {
- &Instruction::DynamicInternalElse(birth, death, _) => {
- if birth < machine.machine_st.cc
- && Death::Finite(machine.machine_st.cc) <= death
- {
- return true;
- } else {
- return false;
- }
- }
- _ => {}
+ if let Instruction::DynamicInternalElse(birth, death, _) = machine.code[p - 1] {
+ return birth < machine.machine_st.cc
+ && Death::Finite(machine.machine_st.cc) <= death;
}
true
self.machine_st.backtrack();
}
}
- &Instruction::CallNumberLessThanOrEqual(ref at_1, ref at_2) => {
+ Instruction::CallNumberLessThanOrEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::ExecuteNumberLessThanOrEqual(ref at_1, ref at_2) => {
+ Instruction::ExecuteNumberLessThanOrEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::CallNumberEqual(ref at_1, ref at_2) => {
+ Instruction::CallNumberEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::ExecuteNumberEqual(ref at_1, ref at_2) => {
+ Instruction::ExecuteNumberEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::CallNumberNotEqual(ref at_1, ref at_2) => {
+ Instruction::CallNumberNotEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::ExecuteNumberNotEqual(ref at_1, ref at_2) => {
+ Instruction::ExecuteNumberNotEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::CallNumberGreaterThanOrEqual(ref at_1, ref at_2) => {
+ Instruction::CallNumberGreaterThanOrEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::ExecuteNumberGreaterThanOrEqual(ref at_1, ref at_2) => {
+ Instruction::ExecuteNumberGreaterThanOrEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::CallNumberGreaterThan(ref at_1, ref at_2) => {
+ Instruction::CallNumberGreaterThan(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::ExecuteNumberGreaterThan(ref at_1, ref at_2) => {
+ Instruction::ExecuteNumberGreaterThan(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::CallNumberLessThan(ref at_1, ref at_2) => {
+ Instruction::CallNumberLessThan(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::ExecuteNumberLessThan(ref at_1, ref at_2) => {
+ Instruction::ExecuteNumberLessThan(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::DefaultCallNumberLessThanOrEqual(ref at_1, ref at_2) => {
+ Instruction::DefaultCallNumberLessThanOrEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::DefaultExecuteNumberLessThanOrEqual(ref at_1, ref at_2) => {
+ Instruction::DefaultExecuteNumberLessThanOrEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::DefaultCallNumberNotEqual(ref at_1, ref at_2) => {
+ Instruction::DefaultCallNumberNotEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::DefaultExecuteNumberNotEqual(ref at_1, ref at_2) => {
+ Instruction::DefaultExecuteNumberNotEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::DefaultCallNumberEqual(ref at_1, ref at_2) => {
+ Instruction::DefaultCallNumberEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::DefaultExecuteNumberEqual(ref at_1, ref at_2) => {
+ Instruction::DefaultExecuteNumberEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::DefaultCallNumberGreaterThanOrEqual(ref at_1, ref at_2) => {
+ Instruction::DefaultCallNumberGreaterThanOrEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::DefaultExecuteNumberGreaterThanOrEqual(ref at_1, ref at_2) => {
+ Instruction::DefaultExecuteNumberGreaterThanOrEqual(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::DefaultCallNumberGreaterThan(ref at_1, ref at_2) => {
+ Instruction::DefaultCallNumberGreaterThan(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::DefaultExecuteNumberGreaterThan(ref at_1, ref at_2) => {
+ Instruction::DefaultExecuteNumberGreaterThan(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::DefaultCallNumberLessThan(ref at_1, ref at_2) => {
+ Instruction::DefaultCallNumberLessThan(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
}
}
}
- &Instruction::DefaultExecuteNumberLessThan(ref at_1, ref at_2) => {
+ Instruction::DefaultExecuteNumberLessThan(ref at_1, ref at_2) => {
let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_1));
let n2 = try_or_throw!(self.machine_st, self.machine_st.get_number(at_2));
self.machine_st.p += 1;
}
- &Instruction::IndexingCode(ref indexing_lines) => {
+ Instruction::IndexingCode(ref indexing_lines) => {
match &indexing_lines[self.machine_st.oip as usize] {
IndexingLine::Indexing(_) => {
self.execute_switch_on_term();
}
}
IndexingLine::IndexedChoice(ref indexed_choice) => {
- match &indexed_choice[self.machine_st.iip as usize] {
- &IndexedChoiceInstruction::Try(offset) => {
+ match indexed_choice[self.machine_st.iip as usize] {
+ IndexedChoiceInstruction::Try(offset) => {
self.indexed_try(offset);
}
- &IndexedChoiceInstruction::Retry(l) => {
+ IndexedChoiceInstruction::Retry(l) => {
self.retry(l);
increment_call_count!(self.machine_st);
}
- &IndexedChoiceInstruction::DefaultRetry(l) => {
+ IndexedChoiceInstruction::DefaultRetry(l) => {
self.retry(l);
}
- &IndexedChoiceInstruction::Trust(l) => {
+ IndexedChoiceInstruction::Trust(l) => {
self.trust(l);
increment_call_count!(self.machine_st);
}
- &IndexedChoiceInstruction::DefaultTrust(l) => {
+ IndexedChoiceInstruction::DefaultTrust(l) => {
self.trust(l);
}
}
.get_predicate_skeleton_mut(&compilation_target, &key)
.unwrap();
- match skeleton.target_pos_of_clause_clause_loc(l) {
- Some(n) => {
- let r = self
- .machine_st
- .store(self.machine_st.deref(self.machine_st.registers[5]));
+ if let Some(n) = skeleton.target_pos_of_clause_clause_loc(l) {
+ let r = self
+ .machine_st
+ .store(self.machine_st.deref(self.machine_st.registers[5]));
- self.machine_st
- .unify_fixnum(Fixnum::build_with(n as i64), r);
- }
- None => {}
+ self.machine_st
+ .unify_fixnum(Fixnum::build_with(n as i64), r);
}
self.machine_st.call_at_index(2, p);
.get_predicate_skeleton_mut(&compilation_target, &key)
.unwrap();
- match skeleton.target_pos_of_clause_clause_loc(l) {
- Some(n) => {
- let r = self
- .machine_st
- .store(self.machine_st.deref(self.machine_st.registers[5]));
+ if let Some(n) = skeleton.target_pos_of_clause_clause_loc(l) {
+ let r = self
+ .machine_st
+ .store(self.machine_st.deref(self.machine_st.registers[5]));
- self.machine_st
- .unify_fixnum(Fixnum::build_with(n as i64), r);
- }
- None => {}
+ self.machine_st
+ .unify_fixnum(Fixnum::build_with(n as i64), r);
}
self.machine_st.execute_at_index(2, p);
// So we only have access to a runtime handle in here and can't shut it down.
// Since I'm not aware of the consequences of deactivating this new code which came in while PR 1880
// was not merged, I'm only deactivating it for now.
-
+
//#[cfg(not(target_arch = "wasm32"))]
//let runtime = tokio::runtime::Runtime::new().unwrap();
//#[cfg(target_arch = "wasm32")]
fn forward_attr_var(iter: &mut StacklessPreOrderHeapIter<Self>) -> Option<HeapCellValue>
where
Self: Sized;
- fn invert_marker(iter: &mut StacklessPreOrderHeapIter<Self>) where Self: Sized;
+ fn invert_marker(iter: &mut StacklessPreOrderHeapIter<Self>)
+ where
+ Self: Sized;
fn mark_phase(&self) -> bool;
#[inline]
- fn report_var_link(iter: &StacklessPreOrderHeapIter<Self>) -> bool where Self: Sized {
+ fn report_var_link(iter: &StacklessPreOrderHeapIter<Self>) -> bool
+ where
+ Self: Sized,
+ {
iter.heap[iter.next as usize].get_mark_bit() == iter.iter_state.mark_phase()
}
#[inline(always)]
- fn record_focus(_iter: &mut StacklessPreOrderHeapIter<Self>) where Self: Sized {
+ fn record_focus(_iter: &mut StacklessPreOrderHeapIter<Self>)
+ where
+ Self: Sized,
+ {
}
}
iter.next = iter.heap[iter.start].get_value();
iter.current = iter.start;
- while let Some(_) = iter.forward() {}
+ while iter.forward().is_some() {}
}
impl UnmarkPolicy for IteratorUMP {
start,
current: start,
next,
- iter_state: IteratorUMP { mark_phase: true,},
+ iter_state: IteratorUMP { mark_phase: true },
}
}
}
return Some(cell);
}
- if self.next < self.heap.len() as u64 {
- if UMP::report_var_link(self) {
- let tag = HeapCellValueTag::AttrVar;
- return Some(HeapCellValue::build_with(tag, next as u64));
- }
+ if self.next < self.heap.len() as u64 && UMP::report_var_link(self) {
+ let tag = HeapCellValueTag::AttrVar;
+ return Some(HeapCellValue::build_with(tag, next as u64));
}
}
HeapCellValueTag::Var => {
return Some(cell);
}
- if self.next < self.heap.len() as u64 {
- if UMP::report_var_link(self) {
- let tag = HeapCellValueTag::Var;
- return Some(HeapCellValue::build_with(tag, next as u64));
- }
+ if self.next < self.heap.len() as u64 && UMP::report_var_link(self) {
+ let tag = HeapCellValueTag::Var;
+ return Some(HeapCellValue::build_with(tag, next as u64));
}
}
HeapCellValueTag::Str => {
return Some(self.backward_and_return());
}
}
- } else {
- if self.backward() {
- return None;
- }
+ } else if self.backward() {
+ return None;
}
}
}
pub fn mark_cells(heap: &mut Heap, start: usize) {
let mut iter = StacklessPreOrderHeapIter::<MarkerUMP>::new(heap, start);
- while let Some(_) = iter.forward() {}
+ while iter.forward().is_some() {}
}
#[cfg(test)]
wam.machine_st.heap.push(pstr_loc_as_cell!(1));
- let pstr_var_cell = put_partial_string(&mut wam.machine_st.heap, "abc ", &wam.machine_st.atom_tbl);
+ let pstr_var_cell =
+ put_partial_string(&mut wam.machine_st.heap, "abc ", &wam.machine_st.atom_tbl);
let pstr_cell = wam.machine_st.heap[pstr_var_cell.get_value() as usize];
mark_cells(&mut wam.machine_st.heap, 0);
all_cells_marked_and_unforwarded(&wam.machine_st.heap);
- assert_eq!(unmark_cell_bits!(wam.machine_st.heap[0]), pstr_loc_as_cell!(1));
+ assert_eq!(
+ unmark_cell_bits!(wam.machine_st.heap[0]),
+ pstr_loc_as_cell!(1)
+ );
assert_eq!(unmark_cell_bits!(wam.machine_st.heap[1]), pstr_cell);
assert_eq!(
unmark_cell_bits!(wam.machine_st.heap[2]),
mark_cells(&mut wam.machine_st.heap, 7);
- all_cells_marked_and_unforwarded(&wam.machine_st.heap[1 ..]);
+ all_cells_marked_and_unforwarded(&wam.machine_st.heap[1..]);
assert_eq!(unmark_cell_bits!(wam.machine_st.heap[1]), pstr_cell);
assert_eq!(
mark_cells(&mut wam.machine_st.heap, 0);
- all_cells_marked_and_unforwarded(&mut wam.machine_st.heap[0..24]);
+ all_cells_marked_and_unforwarded(&wam.machine_st.heap[0..24]);
for cell in &wam.machine_st.heap[24..] {
- assert_eq!(cell.get_mark_bit(), false);
+ assert!(!cell.get_mark_bit());
}
assert_eq!(
let orig_h = heap.len();
loop {
- if src == "" {
+ if src.is_empty() {
return if orig_h == heap.len() {
None
} else {
heap.push(string_as_pstr_cell!(pstr));
- if rest_src != "" {
+ if !rest_src.is_empty() {
heap.push(pstr_loc_as_cell!(h + 2));
src = rest_src;
} else {
Ok(Number::Integer(n)) => {
let value: usize = (&*n).try_into().unwrap();
Some(value)
- },
+ }
_ => None,
}
};
use crate::atom_table;
use crate::heap_print::{HCPrinter, HCValueOutputter, PrinterOutputter};
-use crate::machine::{BREAK_FROM_DISPATCH_LOOP_LOC, LIB_QUERY_SUCCESS};
+use crate::machine::machine_indices::VarKey;
use crate::machine::mock_wam::CompositeOpDir;
+use crate::machine::{BREAK_FROM_DISPATCH_LOOP_LOC, LIB_QUERY_SUCCESS};
+use crate::parser::ast::{Var, VarPtr};
use crate::parser::parser::{Parser, Tokens};
use crate::read::write_term_to_heap;
-use crate::machine::machine_indices::VarKey;
-use crate::parser::ast::{Var, VarPtr};
use indexmap::IndexMap;
use super::{
- Machine, MachineConfig, QueryResult, QueryResolutionLine,
- Atom, AtomCell, HeapCellValue, HeapCellValueTag, Value, QueryResolution,
- streams::Stream
+ streams::Stream, Atom, AtomCell, HeapCellValue, HeapCellValueTag, Machine, MachineConfig,
+ QueryResolution, QueryResolutionLine, QueryResult, Value,
};
impl Machine {
pub fn consult_module_string(&mut self, module_name: &str, program: String) {
let stream = Stream::from_owned_string(program, &mut self.machine_st.arena);
self.machine_st.registers[1] = stream_as_cell!(stream);
- self.machine_st.registers[2] = atom_as_cell!(&atom_table::AtomTable::build_with(&self.machine_st.atom_tbl, module_name));
+ self.machine_st.registers[2] = atom_as_cell!(&atom_table::AtomTable::build_with(
+ &self.machine_st.atom_tbl,
+ module_name
+ ));
self.run_module_predicate(atom!("loader"), (atom!("consult_stream"), 2));
}
// Parse the query so we can analyze and then call the term
let mut parser = Parser::new(
Stream::from_owned_string(query, &mut self.machine_st.arena),
- &mut self.machine_st
+ &mut self.machine_st,
);
let op_dir = CompositeOpDir::new(&self.indices.op_dir, None);
- let term = parser.read_term(&op_dir, Tokens::Default).expect("Failed to parse query");
+ let term = parser
+ .read_term(&op_dir, Tokens::Default)
+ .expect("Failed to parse query");
// Write parsed term to heap
- let term_write_result = write_term_to_heap(&term, &mut self.machine_st.heap, &mut self.machine_st.atom_tbl).expect("couldn't write term to heap");
+ let term_write_result =
+ write_term_to_heap(&term, &mut self.machine_st.heap, &self.machine_st.atom_tbl)
+ .expect("couldn't write term to heap");
// Write term to heap
self.machine_st.registers[1] = self.machine_st.heap[term_write_result.heap_loc];
self.machine_st.cp = LIB_QUERY_SUCCESS; // BREAK_FROM_DISPATCH_LOOP_LOC;
- self.machine_st.p = self.indices.code_dir.get(&(atom!("call"), 1)).expect("couldn't get code index").local().unwrap();
-
- let var_names: IndexMap<_, _> = term_write_result.var_dict.iter()
+ self.machine_st.p = self
+ .indices
+ .code_dir
+ .get(&(atom!("call"), 1))
+ .expect("couldn't get code index")
+ .local()
+ .unwrap();
+
+ let var_names: IndexMap<_, _> = term_write_result
+ .var_dict
+ .iter()
.map(|(var_key, cell)| match var_key {
// NOTE: not the intention behind Var::InSitu here but
// we can hijack it to store anonymous variables
//println!("stub_b: {}", stub_b);
//println!("fail: {}", self.machine_st.fail);
- if self.machine_st.ball.stub.len() != 0 {
+ if !self.machine_st.ball.stub.is_empty() {
// NOTE: this means an exception was thrown, at which
// point we backtracked to the stub choice point.
// this should halt the search for solutions as it
// does in the Scryer top-level. the exception term is
// contained in self.machine_st.ball.
- let error_string = self.machine_st.ball.stub
+ let error_string = self
+ .machine_st
+ .ball
+ .stub
.iter()
- .filter(|h| match h.get_tag() {
- HeapCellValueTag::Atom => true,
- HeapCellValueTag::Fixnum => true,
- _ => false,
+ .filter(|h| {
+ matches!(
+ h.get_tag(),
+ HeapCellValueTag::Atom | HeapCellValueTag::Fixnum
+ )
})
.map(|h| match h.get_tag() {
HeapCellValueTag::Atom => {
let (name, _) = cell_as_atom_cell!(h).get_name_and_arity();
name.as_str().to_string()
}
- HeapCellValueTag::Fixnum => {
- h.get_value().clone().to_string()
- },
+ HeapCellValueTag::Fixnum => h.get_value().clone().to_string(),
_ => unreachable!(),
})
.collect::<Vec<String>>()
let mut bindings: BTreeMap<String, Value> = BTreeMap::new();
for (var_key, term_to_be_printed) in &term_write_result.var_dict {
- if var_key.to_string().starts_with("_") {
+ if var_key.to_string().starts_with('_') {
continue;
}
let mut printer = HCPrinter::new(
use ordered_float::OrderedFloat;
use super::*;
- use crate::machine::{QueryMatch, Value, QueryResolution};
+ use crate::machine::{QueryMatch, QueryResolution, Value};
#[test]
fn programatic_query() {
let output = machine.run_query(query);
assert_eq!(
output,
- Err(String::from("error existence_error procedure / triple 3 / triple 3"))
+ Err(String::from(
+ "error existence_error procedure / triple 3 / triple 3"
+ ))
);
}
constructor(xyz, '[{action: "addLink", source: "this", predicate: "recipe://title", target: "literal://string:Meta%20Muffins"}]').
"#.to_string());
- let result = machine.run_query(String::from("subject_class(\"Todo\", C), constructor(C, Actions)."));
+ let result = machine.run_query(String::from(
+ "subject_class(\"Todo\", C), constructor(C, Actions).",
+ ));
assert_eq!(
result,
- Ok(QueryResolution::Matches(vec![
- QueryMatch::from(btreemap! {
+ Ok(QueryResolution::Matches(vec![QueryMatch::from(
+ btreemap! {
"C" => Value::from("c"),
"Actions" => Value::from("[{action: \"addLink\", source: \"this\", predicate: \"todo://state\", target: \"todo://ready\"}]"),
- }),
- ]))
+ }
+ ),]))
);
- let result = machine.run_query(String::from("subject_class(\"Recipe\", C), constructor(C, Actions)."));
+ let result = machine.run_query(String::from(
+ "subject_class(\"Recipe\", C), constructor(C, Actions).",
+ ));
assert_eq!(
result,
- Ok(QueryResolution::Matches(vec![
- QueryMatch::from(btreemap! {
+ Ok(QueryResolution::Matches(vec![QueryMatch::from(
+ btreemap! {
"C" => Value::from("xyz"),
"Actions" => Value::from("[{action: \"addLink\", source: \"this\", predicate: \"recipe://title\", target: \"literal://string:Meta%20Muffins\"}]"),
- }),
- ]))
+ }
+ ),]))
);
let result = machine.run_query(String::from("subject_class(Class, _)."));
let mut machine = Machine::new_lib();
machine.load_module_string(
"facts",
- r#"
+ r#"
list([1,2,3]).
- "#.to_string());
+ "#
+ .to_string(),
+ );
let result = machine.run_query(String::from("list(X)."));
assert_eq!(
result,
- Ok(QueryResolution::Matches(vec![
- QueryMatch::from(btreemap! {
+ Ok(QueryResolution::Matches(vec![QueryMatch::from(
+ btreemap! {
"X" => Value::List(
Vec::from([
Value::Float(OrderedFloat::from(1.0)),
Value::Float(OrderedFloat::from(3.0))
])
)
- }),
- ]))
+ }
+ ),]))
);
}
-
#[test]
fn consult() {
let mut machine = Machine::new_lib();
machine.run_query(String::from(r#"triple("a","new","b")."#)),
Ok(QueryResolution::True)
);
-
}
#[ignore = "fails on windows"]
),
);
- let query = String::from(r#"findall([Predicate, Target], triple(_,Predicate,Target), Result)."#);
+ let query =
+ String::from(r#"findall([Predicate, Target], triple(_,Predicate,Target), Result)."#);
let output = machine.run_query(query);
assert_eq!(
output,
- Ok(QueryResolution::Matches(vec![
- QueryMatch::from(btreemap! {
+ Ok(QueryResolution::Matches(vec![QueryMatch::from(
+ btreemap! {
"Predicate" => Value::from("Predicate"),
"Result" => Value::List(
Vec::from([
])
),
"Target" => Value::from("Target"),
- }),
- ]))
+ }
+ ),]))
);
-
}
}
if let Some(src_code_index) = imported_module.code_dir.get(&key).cloned() {
let arena = &mut LS::machine_st(payload).arena;
- let target_code_index = code_dir
+ let target_code_index = *code_dir
.entry(key)
- .or_insert_with(|| CodeIndex::default(arena))
- .clone();
+ .or_insert_with(|| CodeIndex::default(arena));
set_code_index(
&mut payload.retraction_info,
let key = (*name, *arity);
if let Some(meta_specs) = imported_module.meta_predicates.get(&key) {
- meta_predicates.insert(key.clone(), meta_specs.clone());
+ meta_predicates.insert(key, meta_specs.clone());
}
if let Some(src_code_index) = imported_module.code_dir.get(&key) {
let arena = &mut LS::machine_st(payload).arena;
- let target_code_index = code_dir
+ let target_code_index = *code_dir
.entry(key)
- .or_insert_with(|| CodeIndex::default(arena))
- .clone();
+ .or_insert_with(|| CodeIndex::default(arena));
set_code_index(
&mut payload.retraction_info,
);
} else {
return Err(SessionError::ModuleDoesNotContainExport(
- imported_module.module_decl.name.clone(),
+ imported_module.module_decl.name,
(*name, *arity),
));
}
wam_prelude
.indices
.meta_predicates
- .insert(key.clone(), meta_specs.clone());
+ .insert(key, meta_specs.clone());
}
if let Some(src_code_index) = imported_module.code_dir.get(&key) {
let arena = &mut LS::machine_st(payload).arena;
- let target_code_index = wam_prelude
+ let target_code_index = *wam_prelude
.indices
.code_dir
- .entry(key.clone())
- .or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), arena))
- .clone();
+ .entry(key)
+ .or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), arena));
set_code_index(
&mut payload.retraction_info,
);
} else {
return Err(SessionError::ModuleDoesNotContainExport(
- imported_module.module_decl.name.clone(),
+ imported_module.module_decl.name,
(*name, *arity),
));
}
if let Some(src_code_index) = imported_module.code_dir.get(&key) {
let arena = &mut LS::machine_st(payload).arena;
- let target_code_index = code_dir
+ let target_code_index = *code_dir
.entry(key)
- .or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), arena))
- .clone();
+ .or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), arena));
set_code_index(
&mut payload.retraction_info,
);
} else {
return Err(SessionError::ModuleDoesNotContainExport(
- imported_module.module_decl.name.clone(),
+ imported_module.module_decl.name,
(*name, *arity),
));
}
payload_compilation_target,
clause_clause_compilation_target,
key,
- mem::replace(&mut skeleton.clause_clause_locs, VecDeque::new()),
+ std::mem::take(&mut skeleton.clause_clause_locs),
),
);
}
};
- self.retract_local_clauses_impl(clause_clause_compilation_target, key, &clause_locs);
+ self.retract_local_clauses_impl(clause_clause_compilation_target, key, clause_locs);
}
pub(super) fn try_term_to_tl(
key: PredicateKey,
) -> CodeIndex {
match self.wam_prelude.indices.modules.get_mut(&module_name) {
- Some(ref mut module) => module
- .code_dir
- .entry(key)
- .or_insert_with(|| {
- CodeIndex::new(
- IndexPtr::undefined(),
- &mut LS::machine_st(&mut self.payload).arena,
- )
- })
- .clone(),
+ Some(ref mut module) => *module.code_dir.entry(key).or_insert_with(|| {
+ CodeIndex::new(
+ IndexPtr::undefined(),
+ &mut LS::machine_st(&mut self.payload).arena,
+ )
+ }),
None => {
self.add_dynamically_generated_module(module_name);
match self.wam_prelude.indices.modules.get_mut(&module_name) {
- Some(ref mut module) => module
- .code_dir
- .entry(key)
- .or_insert_with(|| {
- CodeIndex::new(
- IndexPtr::undefined(),
- &mut LS::machine_st(&mut self.payload).arena,
- )
- })
- .clone(),
+ Some(ref mut module) => *module.code_dir.entry(key).or_insert_with(|| {
+ CodeIndex::new(
+ IndexPtr::undefined(),
+ &mut LS::machine_st(&mut self.payload).arena,
+ )
+ }),
None => {
unreachable!()
}
let arena = &mut LS::machine_st(&mut self.payload).arena;
match compilation_target {
- CompilationTarget::User => self
+ CompilationTarget::User => *self
.wam_prelude
.indices
.code_dir
.entry(key)
- .or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), arena))
- .clone(),
+ .or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), arena)),
CompilationTarget::Module(module_name) => {
self.get_or_insert_local_code_index(module_name, key)
}
let arena = &mut LS::machine_st(&mut self.payload).arena;
if module_name == atom!("user") {
- return self
+ return *self
.wam_prelude
.indices
.code_dir
.entry(key)
- .or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), arena))
- .clone();
+ .or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), arena));
} else {
self.get_or_insert_local_code_index(module_name, key)
}
}
CompilationTarget::Module(module_name) => {
if let Some(module) = self.wam_prelude.indices.modules.get_mut(&module_name) {
- module.extensible_predicates.insert(key.clone(), skeleton);
+ module.extensible_predicates.insert(key, skeleton);
let record = RetractionRecord::AddedExtensiblePredicate(
CompilationTarget::Module(module_name),
match payload_compilation_target {
CompilationTarget::User => {
if let Some(filename) = listing_src_file_name {
- match self.wam_prelude.indices.modules.get_mut(&filename) {
- Some(ref mut module) => {
- op_decl.insert_into_op_dir(&mut module.op_dir);
- }
- None => {}
+ if let Some(ref mut module) =
+ self.wam_prelude.indices.modules.get_mut(&filename)
+ {
+ op_decl.insert_into_op_dir(&mut module.op_dir);
}
}
}
}
}
- _ => {
- match self.wam_prelude.indices.modules.get_mut(&module_name) {
- Some(ref mut module) => {
- match module.meta_predicates.insert(key.clone(), meta_specs) {
- Some(old_meta_specs) => {
- self.payload.retraction_info.push_record(
- RetractionRecord::ReplacedMetaPredicate(
- module_name,
- key.0,
- old_meta_specs,
- ),
- );
- }
- None => {
- self.payload.retraction_info.push_record(
- RetractionRecord::AddedMetaPredicate(module_name, key),
- );
- }
- }
+ _ => match self.wam_prelude.indices.modules.get_mut(&module_name) {
+ Some(ref mut module) => match module.meta_predicates.insert(key, meta_specs) {
+ Some(old_meta_specs) => {
+ self.payload.retraction_info.push_record(
+ RetractionRecord::ReplacedMetaPredicate(
+ module_name,
+ key.0,
+ old_meta_specs,
+ ),
+ );
}
None => {
- self.add_dynamically_generated_module(module_name);
-
- if let Some(module) = self.wam_prelude.indices.modules.get_mut(&module_name)
- {
- module.meta_predicates.insert(key.clone(), meta_specs);
- } else {
- unreachable!()
- }
+ self.payload
+ .retraction_info
+ .push_record(RetractionRecord::AddedMetaPredicate(module_name, key));
+ }
+ },
+ None => {
+ self.add_dynamically_generated_module(module_name);
- self.payload.retraction_info.push_record(
- RetractionRecord::AddedMetaPredicate(module_name.clone(), key),
- );
+ if let Some(module) = self.wam_prelude.indices.modules.get_mut(&module_name) {
+ module.meta_predicates.insert(key, meta_specs);
+ } else {
+ unreachable!()
}
+
+ self.payload
+ .retraction_info
+ .push_record(RetractionRecord::AddedMetaPredicate(module_name, key));
}
- }
+ },
}
}
pub(super) fn add_dynamically_generated_module(&mut self, module_name: Atom) {
let module_decl = ModuleDecl {
- name: module_name.clone(),
+ name: module_name,
exports: vec![],
};
self.payload
.retraction_info
- .push_record(RetractionRecord::AddedModule(module_name.clone()));
+ .push_record(RetractionRecord::AddedModule(module_name));
- self.wam_prelude
- .indices
- .modules
- .insert(module_name.clone(), module);
+ self.wam_prelude.indices.modules.insert(module_name, module);
}
fn import_builtins_in_module(
self.remove_module_exports(module_name);
self.remove_replaced_in_situ_module(module_name);
- match self.wam_prelude.indices.modules.get_mut(&module_name) {
- Some(module) => {
- let old_module_decl = mem::replace(&mut module.module_decl, module_decl.clone());
+ if let Some(module) = self.wam_prelude.indices.modules.get_mut(&module_name) {
+ let old_module_decl = mem::replace(&mut module.module_decl, module_decl.clone());
+
+ let local_extensible_predicates = mem::replace(
+ &mut module.local_extensible_predicates,
+ LocalExtensiblePredicates::with_hasher(FxBuildHasher::default()),
+ );
- let local_extensible_predicates = mem::replace(
- &mut module.local_extensible_predicates,
- LocalExtensiblePredicates::with_hasher(FxBuildHasher::default()),
+ for ((compilation_target, key), skeleton) in local_extensible_predicates.iter() {
+ self.retract_local_clauses_impl(
+ *compilation_target,
+ *key,
+ &skeleton.clause_clause_locs,
);
- for ((compilation_target, key), skeleton) in local_extensible_predicates.iter() {
- self.retract_local_clauses_impl(
- *compilation_target,
- *key,
+ let is_dynamic = self
+ .wam_prelude
+ .indices
+ .get_predicate_skeleton(compilation_target, key)
+ .map(|skeleton| skeleton.core.is_dynamic)
+ .unwrap_or(false);
+
+ if is_dynamic {
+ let clause_clause_compilation_target = match compilation_target {
+ CompilationTarget::User => CompilationTarget::Module(atom!("builtins")),
+ module => *module,
+ };
+
+ self.retract_local_clause_clauses(
+ clause_clause_compilation_target,
&skeleton.clause_clause_locs,
);
-
- let is_dynamic = self
- .wam_prelude
- .indices
- .get_predicate_skeleton(compilation_target, key)
- .map(|skeleton| skeleton.core.is_dynamic)
- .unwrap_or(false);
-
- if is_dynamic {
- let clause_clause_compilation_target = match compilation_target {
- CompilationTarget::User => CompilationTarget::Module(atom!("builtins")),
- module => module.clone(),
- };
-
- self.retract_local_clause_clauses(
- clause_clause_compilation_target,
- &skeleton.clause_clause_locs,
- );
- }
}
-
- self.payload
- .retraction_info
- .push_record(RetractionRecord::ReplacedModule(
- old_module_decl,
- listing_src.clone(),
- local_extensible_predicates,
- ));
}
- None => {}
+
+ self.payload
+ .retraction_info
+ .push_record(RetractionRecord::ReplacedModule(
+ old_module_decl,
+ listing_src.clone(),
+ local_extensible_predicates,
+ ));
}
}
}
ModuleSource::Library(library) => match LIBRARIES.borrow().get(&*library.as_str()) {
Some(code) => {
- if let Some(ref module) = self.wam_prelude.indices.modules.get(&library) {
+ if let Some(module) = self.wam_prelude.indices.modules.get(&library) {
if let ListingSource::DynamicallyGenerated = &module.listing_src {
(
Stream::from_static_string(
- *code,
+ code,
&mut LS::machine_st(&mut self.payload).arena,
),
ListingSource::User,
} else {
(
Stream::from_static_string(
- *code,
+ code,
&mut LS::machine_st(&mut self.payload).arena,
),
ListingSource::User,
} else {
(
Stream::from_static_string(
- *code,
+ code,
&mut LS::machine_st(&mut self.payload).arena,
),
ListingSource::User,
use std::collections::VecDeque;
use std::convert::TryFrom;
use std::fmt;
-use std::mem;
use std::ops::{Deref, DerefMut};
/*
Self {
orig_code_extent,
- records: mem::replace(&mut self.records, vec![]),
+ records: std::mem::take(&mut self.records),
}
}
}
#[inline]
pub(super) fn take(&mut self) -> Self {
Self {
- predicates: mem::replace(&mut self.predicates, vec![]),
- compilation_target: self.compilation_target.clone(),
+ predicates: std::mem::take(&mut self.predicates),
+ compilation_target: self.compilation_target,
}
}
#[inline(always)]
fn machine_st(loader: &mut Self::LoaderFieldType) -> &mut MachineState {
- &mut loader.term_stream.parser.lexer.machine_st
+ loader.term_stream.parser.lexer.machine_st
}
#[inline(always)]
#[inline(always)]
fn machine_st(load_state: &mut Self::LoaderFieldType) -> &mut MachineState {
- &mut load_state.machine_st
+ load_state.machine_st
}
#[inline(always)]
RetractionRecord::AddedDiscontiguousPredicate(compilation_target, key) => {
match compilation_target {
CompilationTarget::User => {
- self.wam_prelude
- .indices
- .extensible_predicates
- .get_mut(&key)
- .map(|skeleton| {
- skeleton.core.is_discontiguous = false;
- });
+ if let Some(skeleton) =
+ self.wam_prelude.indices.extensible_predicates.get_mut(&key)
+ {
+ skeleton.core.is_discontiguous = false;
+ }
}
CompilationTarget::Module(module_name) => {
- match self.wam_prelude.indices.modules.get_mut(&module_name) {
- Some(ref mut module) => {
- module.extensible_predicates.get_mut(&key).map(|skeleton| {
- skeleton.core.is_discontiguous = false;
- });
+ if let Some(ref mut module) =
+ self.wam_prelude.indices.modules.get_mut(&module_name)
+ {
+ if let Some(skeleton) = module.extensible_predicates.get_mut(&key) {
+ skeleton.core.is_discontiguous = false;
}
- None => {}
}
}
}
RetractionRecord::AddedDynamicPredicate(compilation_target, key) => {
match compilation_target {
CompilationTarget::User => {
- self.wam_prelude
- .indices
- .extensible_predicates
- .get_mut(&key)
- .map(|skeleton| {
- skeleton.core.is_dynamic = false;
- });
+ if let Some(skeleton) =
+ self.wam_prelude.indices.extensible_predicates.get_mut(&key)
+ {
+ skeleton.core.is_dynamic = false;
+ }
}
CompilationTarget::Module(module_name) => {
- match self.wam_prelude.indices.modules.get_mut(&module_name) {
- Some(ref mut module) => {
- module.extensible_predicates.get_mut(&key).map(|skeleton| {
- skeleton.core.is_dynamic = false;
- skeleton.core.retracted_dynamic_clauses = None;
- });
- }
- None => {}
+ if let Some(ref mut module) =
+ self.wam_prelude.indices.modules.get_mut(&module_name)
+ {
+ if let Some(skeleton) = module.extensible_predicates.get_mut(&key) {
+ skeleton.core.is_dynamic = false;
+ skeleton.core.retracted_dynamic_clauses = None;
+ };
}
}
}
RetractionRecord::AddedMultifilePredicate(compilation_target, key) => {
match compilation_target {
CompilationTarget::User => {
- self.wam_prelude
- .indices
- .extensible_predicates
- .get_mut(&key)
- .map(|skeleton| {
- skeleton.core.is_multifile = false;
- });
+ if let Some(skeleton) =
+ self.wam_prelude.indices.extensible_predicates.get_mut(&key)
+ {
+ skeleton.core.is_multifile = false;
+ }
}
CompilationTarget::Module(module_name) => {
- match self.wam_prelude.indices.modules.get_mut(&module_name) {
- Some(ref mut module) => {
- module.extensible_predicates.get_mut(&key).map(|skeleton| {
- skeleton.core.is_multifile = false;
- });
+ if let Some(ref mut module) =
+ self.wam_prelude.indices.modules.get_mut(&module_name)
+ {
+ if let Some(skeleton) = module.extensible_predicates.get_mut(&key) {
+ skeleton.core.is_multifile = false;
}
- None => {}
}
}
}
}
RetractionRecord::AddedModuleOp(module_name, mut op_decl) => {
- match self.wam_prelude.indices.modules.get_mut(&module_name) {
- Some(ref mut module) => {
- op_decl.remove(&mut module.op_dir);
- }
- None => {}
+ if let Some(ref mut module) =
+ self.wam_prelude.indices.modules.get_mut(&module_name)
+ {
+ op_decl.remove(&mut module.op_dir);
}
}
RetractionRecord::ReplacedModuleOp(module_name, mut op_decl, op_desc) => {
- match self.wam_prelude.indices.modules.get_mut(&module_name) {
- Some(ref mut module) => {
- op_decl.op_desc = op_desc;
- op_decl.insert_into_op_dir(&mut module.op_dir);
- }
- None => {}
+ if let Some(ref mut module) =
+ self.wam_prelude.indices.modules.get_mut(&module_name)
+ {
+ op_decl.op_desc = op_desc;
+ op_decl.insert_into_op_dir(&mut module.op_dir);
}
}
RetractionRecord::AddedModulePredicate(module_name, key) => {
- match self.wam_prelude.indices.modules.get_mut(&module_name) {
- Some(ref mut module) => {
- module.code_dir.remove(&key);
- }
- None => {}
+ if let Some(ref mut module) =
+ self.wam_prelude.indices.modules.get_mut(&module_name)
+ {
+ module.code_dir.remove(&key);
}
}
RetractionRecord::ReplacedModulePredicate(module_name, key, old_code_idx) => {
- match self.wam_prelude.indices.modules.get_mut(&module_name) {
- Some(ref mut module) => {
- module
- .code_dir
- .get_mut(&key)
- .map(|code_idx| code_idx.set(old_code_idx));
+ if let Some(ref mut module) =
+ self.wam_prelude.indices.modules.get_mut(&module_name)
+ {
+ if let Some(code_idx) = module.code_dir.get_mut(&key) {
+ code_idx.set(old_code_idx)
}
- None => {}
}
}
RetractionRecord::AddedExtensiblePredicate(compilation_target, key) => {
self.wam_prelude.indices.code_dir.remove(&key);
}
RetractionRecord::ReplacedUserPredicate(key, old_code_idx) => {
- self.wam_prelude
- .indices
- .code_dir
- .get_mut(&key)
- .map(|code_idx| code_idx.set(old_code_idx));
+ if let Some(code_idx) = self.wam_prelude.indices.code_dir.get_mut(&key) {
+ code_idx.set(old_code_idx)
+ }
}
RetractionRecord::AddedIndex(index_key, clause_loc) => {
if let Some(index_loc) = index_key.switch_on_term_loc() {
};
}
RetractionRecord::ReplacedSwitchOnTermVarIndex(index_loc, old_v) => {
- match self.wam_prelude.code[index_loc] {
- Instruction::IndexingCode(ref mut indexing_code) => {
- match &mut indexing_code[0] {
- IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(
- _,
- ref mut v,
- ..,
- )) => {
- *v = old_v;
- }
- _ => {}
- }
+ if let Instruction::IndexingCode(ref mut indexing_code) =
+ self.wam_prelude.code[index_loc]
+ {
+ if let IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(
+ _,
+ ref mut v,
+ ..,
+ )) = &mut indexing_code[0]
+ {
+ *v = old_v;
}
- _ => {}
}
}
RetractionRecord::ModifiedTryMeElse(instr_loc, o) => {
self.wam_prelude.code[instr_loc] = Instruction::RevJmpBy(o);
}
RetractionRecord::SkeletonClausePopBack(compilation_target, key) => {
- match self
+ if let Some(skeleton) = self
.wam_prelude
.indices
.get_predicate_skeleton_mut(&compilation_target, &key)
{
- Some(skeleton) => {
- skeleton.clauses.pop_back();
- skeleton.core.clause_clause_locs.pop_back();
- }
- None => {}
+ skeleton.clauses.pop_back();
+ skeleton.core.clause_clause_locs.pop_back();
}
}
RetractionRecord::SkeletonClausePopFront(compilation_target, key) => {
- match self
+ if let Some(skeleton) = self
.wam_prelude
.indices
.get_predicate_skeleton_mut(&compilation_target, &key)
{
- Some(skeleton) => {
- skeleton.clauses.pop_front();
- skeleton.core.clause_clause_locs.pop_front();
- skeleton.core.clause_assert_margin -= 1;
- }
- None => {}
+ skeleton.clauses.pop_front();
+ skeleton.core.clause_clause_locs.pop_front();
+ skeleton.core.clause_assert_margin -= 1;
}
}
RetractionRecord::SkeletonLocalClauseClausePopFront(
) => {
let listing_src_file_name = self.listing_src_file_name();
- match self.wam_prelude.indices.get_local_predicate_skeleton_mut(
- src_compilation_target,
- local_compilation_target,
- listing_src_file_name,
- key,
- ) {
- Some(skeleton) => {
- skeleton.clause_clause_locs.pop_front();
- }
- None => {}
+ if let Some(skeleton) =
+ self.wam_prelude.indices.get_local_predicate_skeleton_mut(
+ src_compilation_target,
+ local_compilation_target,
+ listing_src_file_name,
+ key,
+ )
+ {
+ skeleton.clause_clause_locs.pop_front();
}
}
RetractionRecord::SkeletonLocalClauseClausePopBack(
) => {
let listing_src_file_name = self.listing_src_file_name();
- match self.wam_prelude.indices.get_local_predicate_skeleton_mut(
- src_compilation_target,
- local_compilation_target,
- listing_src_file_name,
- key,
- ) {
- Some(skeleton) => {
- skeleton.clause_clause_locs.pop_back();
- }
- None => {}
+ if let Some(skeleton) =
+ self.wam_prelude.indices.get_local_predicate_skeleton_mut(
+ src_compilation_target,
+ local_compilation_target,
+ listing_src_file_name,
+ key,
+ )
+ {
+ skeleton.clause_clause_locs.pop_back();
}
}
RetractionRecord::SkeletonLocalClauseTruncateBack(
) => {
let listing_src_file_name = self.listing_src_file_name();
- match self.wam_prelude.indices.get_local_predicate_skeleton_mut(
- src_compilation_target,
- local_compilation_target,
- listing_src_file_name,
- key,
- ) {
- Some(skeleton) => {
- skeleton.clause_clause_locs.truncate(len);
- }
- None => {}
+ if let Some(skeleton) =
+ self.wam_prelude.indices.get_local_predicate_skeleton_mut(
+ src_compilation_target,
+ local_compilation_target,
+ listing_src_file_name,
+ key,
+ )
+ {
+ skeleton.clause_clause_locs.truncate(len);
}
}
RetractionRecord::SkeletonClauseTruncateBack(compilation_target, key, len) => {
- match self
+ if let Some(skeleton) = self
.wam_prelude
.indices
.get_predicate_skeleton_mut(&compilation_target, &key)
{
- Some(skeleton) => {
- skeleton.clauses.truncate(len);
- skeleton.core.clause_clause_locs.truncate(len);
- }
- None => {}
+ skeleton.clauses.truncate(len);
+ skeleton.core.clause_clause_locs.truncate(len);
}
}
RetractionRecord::SkeletonClauseStartReplaced(
target_pos,
clause_start,
) => {
- match self
+ if let Some(skeleton) = self
.wam_prelude
.indices
.get_predicate_skeleton_mut(&compilation_target, &key)
{
- Some(skeleton) => {
- skeleton.clauses[target_pos].clause_start = clause_start;
- }
- None => {}
+ skeleton.clauses[target_pos].clause_start = clause_start;
}
}
RetractionRecord::RemovedDynamicSkeletonClause(
target_pos,
clause_clause_loc,
) => {
- match self
+ if let Some(skeleton) = self
.wam_prelude
.indices
.get_predicate_skeleton_mut(&compilation_target, &key)
{
- Some(skeleton) => {
- if let Some(removed_clauses) =
- &mut skeleton.core.retracted_dynamic_clauses
- {
- let clause_index_info = removed_clauses.pop().unwrap();
+ if let Some(removed_clauses) = &mut skeleton.core.retracted_dynamic_clauses
+ {
+ let clause_index_info = removed_clauses.pop().unwrap();
- skeleton
- .core
- .clause_clause_locs
- .insert(target_pos, clause_clause_loc);
+ skeleton
+ .core
+ .clause_clause_locs
+ .insert(target_pos, clause_clause_loc);
- skeleton.clauses.insert(target_pos, clause_index_info);
- }
+ skeleton.clauses.insert(target_pos, clause_index_info);
}
- None => {}
}
}
RetractionRecord::RemovedSkeletonClause(
clause_index_info,
clause_clause_loc,
) => {
- match self
+ if let Some(skeleton) = self
.wam_prelude
.indices
.get_predicate_skeleton_mut(&compilation_target, &key)
{
- Some(skeleton) => {
- skeleton
- .core
- .clause_clause_locs
- .insert(target_pos, clause_clause_loc);
- skeleton.clauses.insert(target_pos, clause_index_info);
- }
- None => {}
+ skeleton
+ .core
+ .clause_clause_locs
+ .insert(target_pos, clause_clause_loc);
+ skeleton.clauses.insert(target_pos, clause_index_info);
}
}
RetractionRecord::ReplacedIndexingLine(index_loc, indexing_code) => {
) => {
let listing_src_file_name = self.listing_src_file_name();
- match self.wam_prelude.indices.get_local_predicate_skeleton_mut(
- compilation_target,
- local_compilation_target,
- listing_src_file_name,
- key,
- ) {
- Some(skeleton) => skeleton.clause_clause_locs = clause_locs,
- None => {}
+ if let Some(skeleton) =
+ self.wam_prelude.indices.get_local_predicate_skeleton_mut(
+ compilation_target,
+ local_compilation_target,
+ listing_src_file_name,
+ key,
+ )
+ {
+ skeleton.clause_clause_locs = clause_locs
}
}
RetractionRecord::RemovedSkeleton(compilation_target, key, skeleton) => {
let export_list = machine_st.read_term_from_heap(cell);
let atom_tbl = &mut LS::machine_st(&mut self.payload).atom_tbl;
- let export_list = setup_module_export_list(export_list, &atom_tbl)?;
+ let export_list = setup_module_export_list(export_list, atom_tbl)?;
Ok(export_list.into_iter().collect())
}
*key,
) {
Some(skeleton) if !skeleton.clause_clause_locs.is_empty() => {
- mem::replace(&mut skeleton.clause_clause_locs, VecDeque::new())
+ std::mem::take(&mut skeleton.clause_clause_locs)
}
_ => return,
};
CompilationTarget::User => CompositeOpDir::new(&self.indices.op_dir, None),
CompilationTarget::Module(ref module_name) => {
match self.indices.modules.get(module_name) {
- Some(ref module) => {
- CompositeOpDir::new(&self.indices.op_dir, Some(&module.op_dir))
- }
+ Some(module) => CompositeOpDir::new(&self.indices.op_dir, Some(&module.op_dir)),
None => {
unreachable!()
}
}
impl MachineState {
- pub(super) fn read_term_from_heap(
- &mut self,
- term_addr: HeapCellValue,
- ) -> Term {
+ pub(super) fn read_term_from_heap(&mut self, term_addr: HeapCellValue) -> Term {
let mut term_stack = vec![];
- let mut iter = stackful_post_order_iter::<NonListElider>
- (&mut self.heap, &mut self.stack, term_addr);
+ let mut iter =
+ stackful_post_order_iter::<NonListElider>(&mut self.heap, &mut self.stack, term_addr);
while let Some(addr) = iter.next() {
let addr = unmark_cell_bits!(addr);
let arity = self.deref_register(3);
let arity = match Number::try_from(arity) {
- Ok(Number::Integer(n)) if &*n >= &Integer::ZERO && &*n <= &Integer::from(MAX_ARITY) => {
+ Ok(Number::Integer(n)) if *n >= Integer::ZERO && *n <= Integer::from(MAX_ARITY) => {
let value: usize = (&*n).try_into().unwrap();
Ok(value)
- },
+ }
Ok(Number::Fixnum(n)) if n.get_num() >= 0 && n.get_num() <= MAX_ARITY as i64 => {
Ok(usize::try_from(n.get_num()).unwrap())
}
&ListingSource::DynamicallyGenerated,
);
- match loader.wam_prelude.indices.modules.get_mut(&module_name) {
- Some(module) => {
- for (key, value) in module.op_dir.drain(0..) {
- let mut op_decl = OpDecl::new(value, key.0);
- op_decl.remove(&mut loader.wam_prelude.indices.op_dir);
- }
+ if let Some(module) = loader.wam_prelude.indices.modules.get_mut(&module_name) {
+ for (key, value) in module.op_dir.drain(0..) {
+ let mut op_decl = OpDecl::new(value, key.0);
+ op_decl.remove(&mut loader.wam_prelude.indices.op_dir);
}
- None => {}
}
}
}
self.restore_load_state_payload(result)
}
- pub(crate) fn loader_from_heap_evacuable<'a>(
- &'a mut self,
+ pub(crate) fn loader_from_heap_evacuable(
+ &mut self,
r: RegType,
- ) -> Loader<'a, LiveLoadAndMachineState<'a>> {
+ ) -> Loader<'_, LiveLoadAndMachineState<'_>> {
let mut load_state = cell_as_load_state_payload!(self
.machine_st
.store(self.machine_st.deref(self.machine_st[r])));
let path = cell_as_atom!(self.deref_register(2));
self.load_contexts
- .push(LoadContext::new(&*path.as_str(), stream));
+ .push(LoadContext::new(&path.as_str(), stream));
Ok(())
}
loader.payload.compilation_target = compilation_target;
- let head = LiveLoadAndMachineState::machine_st(&mut loader.payload)
- .read_term_from_heap(head);
+ let head =
+ LiveLoadAndMachineState::machine_st(&mut loader.payload).read_term_from_heap(head);
let name = if let Some(name) = head.name() {
name
Ok(Number::Integer(n)) => {
let value: usize = (&*n).try_into().unwrap();
value
- },
+ }
Ok(Number::Fixnum(n)) => usize::try_from(n.get_num()).unwrap(),
_ => unreachable!(),
};
import_module_exports::<LiveLoadAndMachineState>(
&mut payload,
- &compilation_target,
+ compilation_target,
module,
code_dir,
op_dir,
#[derive(Debug, Clone, Copy)]
pub(crate) enum ResourceError {
FiniteMemory(HeapCellValue),
- OutOfFiles
+ OutOfFiles,
}
pub(crate) trait TypeError {
) -> MachineError {
let stub = functor!(
atom!("permission_error"),
- [atom(perm.as_atom()), atom(index_atom), cell(atom_as_cell!(self))]
+ [
+ atom(perm.as_atom()),
+ atom(index_atom),
+ cell(atom_as_cell!(self))
+ ]
);
MachineError {
)
}
ResourceError::OutOfFiles => {
- functor!(
- atom!("resource_error"),
- [atom(atom!("file_descriptors"))]
- )
+ functor!(atom!("resource_error"), [atom(atom!("file_descriptors"))])
}
};
from: ErrorProvenance::Received,
}
}
- ExistenceError::QualifiedProcedure { module_name, name, arity } => {
+ ExistenceError::QualifiedProcedure {
+ module_name,
+ name,
+ arity,
+ } => {
let h = self.heap.len();
let ind_stub = functor!(atom!("/"), [atom(name), fixnum(arity)]);
let res_stub = functor!(atom!(":"), [atom(module_name), str(h + 3, 0)], [ind_stub]);
- let stub = functor!(atom!("existence_error"), [atom(atom!("procedure")), str(h, 0)], [res_stub]);
+ let stub = functor!(
+ atom!("existence_error"),
+ [atom(atom!("procedure")), str(h, 0)],
+ [res_stub]
+ );
MachineError {
stub,
pub(super) fn session_error(&mut self, err: SessionError) -> MachineError {
match err {
- SessionError::CannotOverwriteBuiltIn(key) => {
- self.permission_error(
- Permission::Modify,
- atom!("static_procedure"),
- functor_stub(key.0, key.1)
- .into_iter()
- .collect::<MachineStub>(),
- )
- }
+ SessionError::CannotOverwriteBuiltIn(key) => self.permission_error(
+ Permission::Modify,
+ atom!("static_procedure"),
+ functor_stub(key.0, key.1)
+ .into_iter()
+ .collect::<MachineStub>(),
+ ),
SessionError::CannotOverwriteBuiltInModule(module) => {
- self.permission_error(
- Permission::Modify,
- atom!("static_module"),
- module,
- )
+ self.permission_error(Permission::Modify, atom!("static_module"), module)
}
SessionError::ExistenceError(err) => self.existence_error(err),
SessionError::ModuleDoesNotContainExport(..) => {
self.ball.boundary = 0;
self.ball.stub.truncate(0);
- self.heap.extend(err.into_iter());
+ self.heap.extend(err);
self.registers[1] = if err_len == 1 {
heap_loc_as_cell!(h)
impl CompilationError {
pub(crate) fn line_and_col_num(&self) -> Option<(usize, usize)> {
match self {
- &CompilationError::ParserError(ref err) => err.line_and_col_num(),
+ CompilationError::ParserError(err) => err.line_and_col_num(),
_ => None,
}
}
pub(crate) fn as_functor(&self) -> MachineStub {
match self {
- &CompilationError::Arithmetic(..) => {
+ CompilationError::Arithmetic(..) => {
functor!(atom!("arithmetic_error"))
}
- &CompilationError::CannotParseCyclicTerm => {
+ CompilationError::CannotParseCyclicTerm => {
functor!(atom!("cannot_parse_cyclic_term"))
}
- &CompilationError::ExceededMaxArity => {
+ CompilationError::ExceededMaxArity => {
functor!(atom!("exceeded_max_arity"))
}
- &CompilationError::ExpectedRel => {
+ CompilationError::ExpectedRel => {
functor!(atom!("expected_relation"))
}
- &CompilationError::InadmissibleFact => {
+ CompilationError::InadmissibleFact => {
// TODO: type_error(callable, _).
functor!(atom!("inadmissible_fact"))
}
- &CompilationError::InadmissibleQueryTerm => {
+ CompilationError::InadmissibleQueryTerm => {
// TODO: type_error(callable, _).
functor!(atom!("inadmissible_query_term"))
}
- &CompilationError::InconsistentEntry => {
+ CompilationError::InconsistentEntry => {
functor!(atom!("inconsistent_entry"))
}
- &CompilationError::InvalidMetaPredicateDecl => {
+ CompilationError::InvalidMetaPredicateDecl => {
functor!(atom!("invalid_meta_predicate_decl"))
}
- &CompilationError::InvalidModuleDecl => {
+ CompilationError::InvalidModuleDecl => {
functor!(atom!("invalid_module_declaration"))
}
- &CompilationError::InvalidModuleExport => {
+ CompilationError::InvalidModuleExport => {
functor!(atom!("invalid_module_export"))
}
- &CompilationError::InvalidModuleResolution(ref module_name) => {
+ CompilationError::InvalidModuleResolution(ref module_name) => {
functor!(atom!("no_such_module"), [atom(module_name)])
}
- &CompilationError::InvalidRuleHead => {
+ CompilationError::InvalidRuleHead => {
functor!(atom!("invalid_head_of_rule")) // TODO: type_error(callable, _).
}
- &CompilationError::InvalidUseModuleDecl => {
+ CompilationError::InvalidUseModuleDecl => {
functor!(atom!("invalid_use_module_declaration"))
}
- &CompilationError::ParserError(ref err) => {
+ CompilationError::ParserError(ref err) => {
functor!(err.as_atom())
}
- &CompilationError::UnreadableTerm => {
+ CompilationError::UnreadableTerm => {
functor!(atom!("unreadable_term"))
}
}
Module(Atom),
ModuleSource(ModuleSource),
Procedure(Atom, usize),
- QualifiedProcedure { module_name: Atom, name: Atom, arity: usize },
+ QualifiedProcedure {
+ module_name: Atom,
+ name: Atom,
+ arity: usize,
+ },
SourceSink(HeapCellValue),
Stream(HeapCellValue),
}
#[inline(always)]
pub(crate) fn is_undefined(&self) -> bool {
- match self.tag() {
- IndexPtrTag::Undefined => true,
- _ => false,
- }
+ matches!(self.tag(), IndexPtrTag::Undefined)
}
#[inline(always)]
pub(crate) fn is_dynamic_undefined(&self) -> bool {
- match self.tag() {
- IndexPtrTag::DynamicUndefined => true,
- _ => false,
- }
+ matches!(self.tag(), IndexPtrTag::DynamicUndefined)
}
}
}
impl VarKey {
+ #[allow(clippy::inherent_to_string)]
#[inline]
pub(crate) fn to_string(&self) -> String {
match self {
#[inline(always)]
pub(crate) fn is_anon(&self) -> bool {
- if let VarKey::AnonVar(_) = self {
- true
- } else {
- false
- }
+ matches!(self, VarKey::AnonVar(_))
}
}
match compilation_target {
CompilationTarget::User => self.meta_predicates.get(&(name, arity)),
CompilationTarget::Module(ref module_name) => match self.modules.get(module_name) {
- Some(ref module) => module
+ Some(module) => module
.meta_predicates
- .get(&(name.clone(), arity))
+ .get(&(name, arity))
.or_else(|| self.meta_predicates.get(&(name, arity))),
None => self.meta_predicates.get(&(name, arity)),
},
.map(|skeleton| skeleton.core.is_dynamic)
.unwrap_or(false),
_ => match self.modules.get(&module_name) {
- Some(ref module) => module
+ Some(module) => module
.extensible_predicates
.get(&key)
.map(|skeleton| skeleton.core.is_dynamic)
}
pub(crate) fn increment_call_count(&mut self) -> bool {
- if self.cwil.inference_limit_exceeded || self.ball.stub.len() > 0 {
+ if self.cwil.inference_limit_exceeded || !self.ball.stub.is_empty() {
return true;
}
let mut singleton_var_set: IndexMap<Ref, bool> = IndexMap::new();
- for cell in stackful_preorder_iter::<NonListElider>(&mut self.heap, &mut self.stack, heap_loc) {
+ for cell in
+ stackful_preorder_iter::<NonListElider>(&mut self.heap, &mut self.stack, heap_loc)
+ {
let cell = unmark_cell_bits!(cell);
if let Some(var) = cell.as_var() {
) -> Result<OnEOF, MachineStub> {
self.eof_action(self.registers[2], stream, atom!("read_term"), 3)?;
- if stream.options().eof_action() == EOFAction::Reset {
- if self.fail == false {
- return Ok(OnEOF::Continue);
- }
+ if stream.options().eof_action() == EOFAction::Reset && !self.fail {
+ return Ok(OnEOF::Continue);
}
Ok(OnEOF::Return)
if let Stream::Byte(_) = stream {
return self.read_term(
- stream,
- indices,
- MachineState::read_term_from_user_input_eof_handler
- )
+ stream,
+ indices,
+ MachineState::read_term_from_user_input_eof_handler,
+ );
}
unreachable!("Stream must be a Stream::Readline(_)")
} else if stream.past_end_of_stream() {
self.eof_action(self.registers[2], stream, atom!("read_term"), 3)?;
- if stream.options().eof_action() == EOFAction::Reset {
- if self.fail == false {
- return Ok(OnEOF::Continue);
- }
+ if stream.options().eof_action() == EOFAction::Reset && !self.fail {
+ return Ok(OnEOF::Continue);
}
}
)?;
if stream.past_end_of_stream() {
- if EOFAction::Reset != stream.options().eof_action() {
- return Ok(());
- } else if self.fail {
- return Ok(());
- }
+ return Ok(());
}
loop {
}
}
+#[allow(clippy::upper_case_acronyms)]
#[derive(Debug)]
pub(crate) struct CWIL {
count: Integer,
TrailRef::BlackboardEntry(key_atom) => {
self.trail.push(TrailEntry::build_with(
TrailEntryTag::TrailedBlackboardEntry,
- key_atom.index as u64,
+ key_atom.index,
));
self.tr += 1;
TrailRef::BlackboardOffset(key_atom, value_cell) => {
self.trail.push(TrailEntry::build_with(
TrailEntryTag::TrailedBlackboardOffset,
- key_atom.index as u64,
+ key_atom.index,
));
self.trail
pub fn compare_term_test(&mut self, var_comparison: VarComparison) -> Option<Ordering> {
let mut tabu_list = IndexSet::new();
- while !self.pdl.is_empty() {
- let s1 = self.pdl.pop().unwrap();
+ while let Some(s1) = self.pdl.pop() {
let s1 = self.deref(s1);
let s2 = self.pdl.pop().unwrap();
let s = string.as_str();
- match heap_pstr_iter.compare_pstr_to_string(&*s) {
+ match heap_pstr_iter.compare_pstr_to_string(&s) {
Some(PStrPrefixCmpResult {
focus,
offset,
let cycle_found = {
let mut iter = cycle_detecting_stackless_preorder_iter(&mut self.heap, h);
- while let Some(_) = iter.next() {}
+ for _ in iter.by_ref() {}
iter.cycle_found()
};
let mut type_error = |arity| {
let err = self.type_error(ValidType::Integer, arity);
- return Err(self.error_form(err, stub_gen()));
+ Err(self.error_form(err, stub_gen()))
};
let arity = match Number::try_from(arity) {
) -> Result<Vec<HeapCellValue>, MachineStub> {
let mut heap_pstr_iter = HeapPStrIter::new(&self.heap, h);
- while let Some(iteratee) = heap_pstr_iter.next() {
+ for iteratee in heap_pstr_iter.by_ref() {
match iteratee {
PStrIteratee::Char(_, c) => chars.push(char_as_cell!(c)),
PStrIteratee::PStrSegment(_, pstr_atom, n) => {
let addr = self.store(self.deref(addr));
match Number::try_from(addr) {
- Ok(Number::Fixnum(n)) => match u8::try_from(n.get_num()) {
- Ok(b) => bytes.push(b),
- Err(_) => {}
- },
+ Ok(Number::Fixnum(n)) => {
+ if let Ok(b) = u8::try_from(n.get_num()) {
+ bytes.push(b)
+ }
+ }
Ok(Number::Integer(n)) => {
let b: u8 = (&*n).try_into().unwrap();
}
}
+impl Default for MockWAM {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
#[cfg(test)]
pub struct TermCopyingMockWAM<'a> {
pub wam: &'a mut MockWAM,
type Target = MockWAM;
fn deref(&self) -> &Self::Target {
- &self.wam
+ self.wam
}
}
#[cfg(test)]
impl<'a> DerefMut for TermCopyingMockWAM<'a> {
fn deref_mut(&mut self) -> &mut Self::Target {
- &mut self.wam
+ self.wam
}
}
#[cfg(test)]
pub fn all_cells_marked_and_unforwarded(heap: &[HeapCellValue]) {
for (idx, cell) in heap.iter().enumerate() {
- assert_eq!(
+ assert!(
cell.get_mark_bit(),
- true,
"cell {:?} at index {} is not marked",
cell,
idx
&mut self.machine_st.arena,
);
- self.load_file(file.into(), stream);
+ self.load_file(file, stream);
self.user_output.bytes().map(|b| b.unwrap()).collect()
}
pub fn test_load_string(&mut self, code: &str) -> Vec<u8> {
- let stream = Stream::from_owned_string(
- code.to_owned(),
- &mut self.machine_st.arena,
- );
+ let stream = Stream::from_owned_string(code.to_owned(), &mut self.machine_st.arena);
- self.load_file("<stdin>".into(), stream);
+ self.load_file("<stdin>", stream);
self.user_output.bytes().map(|b| b.unwrap()).collect()
}
-
}
#[cfg(test)]
use lazy_static::lazy_static;
use ordered_float::OrderedFloat;
+use rand::rngs::StdRng;
+use rand::SeedableRng;
use std::cmp::Ordering;
use std::env;
use std::io::Read;
use self::config::MachineConfig;
use self::parsed_results::*;
-use rand::rngs::StdRng;
-use rand::SeedableRng;
lazy_static! {
pub static ref INTERRUPT: AtomicBool = AtomicBool::new(false);
for key in keys {
let idx = code_dir.get(&key).unwrap();
- builtins.code_dir.insert(key, idx.clone());
+ builtins.code_dir.insert(key, *idx);
builtins
.module_decl
.exports
key: PredicateKey,
) -> std::process::ExitCode {
if let Some(module) = self.indices.modules.get(&module_name) {
- if let Some(ref code_index) = module.code_dir.get(&key) {
+ if let Some(code_index) = module.code_dir.get(&key) {
let p = code_index.local().unwrap();
self.machine_st.cp = BREAK_FROM_DISPATCH_LOOP_LOC;
path_buf.push("src/toplevel.pl");
let path = path_buf.to_str().unwrap();
- let toplevel_stream =
- Stream::from_static_string(program, &mut self.machine_st.arena);
-
+ let toplevel_stream = Stream::from_static_string(program, &mut self.machine_st.arena);
self.load_file(path, toplevel_stream);
}
}
- pub fn run_top_level(&mut self, module_name: Atom, key: PredicateKey) -> std::process::ExitCode {
+ pub fn run_top_level(
+ &mut self,
+ module_name: Atom,
+ key: PredicateKey,
+ ) -> std::process::ExitCode {
let mut arg_pstrs = vec![];
for arg in env::args() {
pub(crate) fn add_impls_to_indices(&mut self) {
let impls_offset = self.code.len() + 4;
- self.code.extend(
- vec![
- Instruction::BreakFromDispatchLoop,
- Instruction::InstallVerifyAttr,
- Instruction::VerifyAttrInterrupt,
- Instruction::BreakFromDispatchLoop, // the location of LIB_QUERY_SUCCESS
- Instruction::ExecuteTermGreaterThan,
- Instruction::ExecuteTermLessThan,
- Instruction::ExecuteTermGreaterThanOrEqual,
- Instruction::ExecuteTermLessThanOrEqual,
- Instruction::ExecuteTermEqual,
- Instruction::ExecuteTermNotEqual,
- Instruction::ExecuteNumberGreaterThan(ar_reg!(temp_v!(1)), ar_reg!(temp_v!(2))),
- Instruction::ExecuteNumberLessThan(ar_reg!(temp_v!(1)), ar_reg!(temp_v!(2))),
- Instruction::ExecuteNumberGreaterThanOrEqual(
- ar_reg!(temp_v!(1)),
- ar_reg!(temp_v!(2)),
- ),
- Instruction::ExecuteNumberLessThanOrEqual(ar_reg!(temp_v!(1)), ar_reg!(temp_v!(2))),
- Instruction::ExecuteNumberEqual(ar_reg!(temp_v!(1)), ar_reg!(temp_v!(2))),
- Instruction::ExecuteNumberNotEqual(ar_reg!(temp_v!(1)), ar_reg!(temp_v!(2))),
- Instruction::ExecuteIs(temp_v!(1), ar_reg!(temp_v!(2))),
- Instruction::ExecuteAcyclicTerm,
- Instruction::ExecuteArg,
- Instruction::ExecuteCompare,
- Instruction::ExecuteCopyTerm,
- Instruction::ExecuteFunctor,
- Instruction::ExecuteGround,
- Instruction::ExecuteKeySort,
- Instruction::ExecuteSort,
- Instruction::ExecuteN(1),
- Instruction::ExecuteN(2),
- Instruction::ExecuteN(3),
- Instruction::ExecuteN(4),
- Instruction::ExecuteN(5),
- Instruction::ExecuteN(6),
- Instruction::ExecuteN(7),
- Instruction::ExecuteN(8),
- Instruction::ExecuteN(9),
- Instruction::ExecuteIsAtom(temp_v!(1)),
- Instruction::ExecuteIsAtomic(temp_v!(1)),
- Instruction::ExecuteIsCompound(temp_v!(1)),
- Instruction::ExecuteIsInteger(temp_v!(1)),
- Instruction::ExecuteIsNumber(temp_v!(1)),
- Instruction::ExecuteIsRational(temp_v!(1)),
- Instruction::ExecuteIsFloat(temp_v!(1)),
- Instruction::ExecuteIsNonVar(temp_v!(1)),
- Instruction::ExecuteIsVar(temp_v!(1)),
- ]
- .into_iter(),
- );
+ self.code.extend(vec![
+ Instruction::BreakFromDispatchLoop,
+ Instruction::InstallVerifyAttr,
+ Instruction::VerifyAttrInterrupt,
+ Instruction::BreakFromDispatchLoop, // the location of LIB_QUERY_SUCCESS
+ Instruction::ExecuteTermGreaterThan,
+ Instruction::ExecuteTermLessThan,
+ Instruction::ExecuteTermGreaterThanOrEqual,
+ Instruction::ExecuteTermLessThanOrEqual,
+ Instruction::ExecuteTermEqual,
+ Instruction::ExecuteTermNotEqual,
+ Instruction::ExecuteNumberGreaterThan(ar_reg!(temp_v!(1)), ar_reg!(temp_v!(2))),
+ Instruction::ExecuteNumberLessThan(ar_reg!(temp_v!(1)), ar_reg!(temp_v!(2))),
+ Instruction::ExecuteNumberGreaterThanOrEqual(ar_reg!(temp_v!(1)), ar_reg!(temp_v!(2))),
+ Instruction::ExecuteNumberLessThanOrEqual(ar_reg!(temp_v!(1)), ar_reg!(temp_v!(2))),
+ Instruction::ExecuteNumberEqual(ar_reg!(temp_v!(1)), ar_reg!(temp_v!(2))),
+ Instruction::ExecuteNumberNotEqual(ar_reg!(temp_v!(1)), ar_reg!(temp_v!(2))),
+ Instruction::ExecuteIs(temp_v!(1), ar_reg!(temp_v!(2))),
+ Instruction::ExecuteAcyclicTerm,
+ Instruction::ExecuteArg,
+ Instruction::ExecuteCompare,
+ Instruction::ExecuteCopyTerm,
+ Instruction::ExecuteFunctor,
+ Instruction::ExecuteGround,
+ Instruction::ExecuteKeySort,
+ Instruction::ExecuteSort,
+ Instruction::ExecuteN(1),
+ Instruction::ExecuteN(2),
+ Instruction::ExecuteN(3),
+ Instruction::ExecuteN(4),
+ Instruction::ExecuteN(5),
+ Instruction::ExecuteN(6),
+ Instruction::ExecuteN(7),
+ Instruction::ExecuteN(8),
+ Instruction::ExecuteN(9),
+ Instruction::ExecuteIsAtom(temp_v!(1)),
+ Instruction::ExecuteIsAtomic(temp_v!(1)),
+ Instruction::ExecuteIsCompound(temp_v!(1)),
+ Instruction::ExecuteIsInteger(temp_v!(1)),
+ Instruction::ExecuteIsNumber(temp_v!(1)),
+ Instruction::ExecuteIsRational(temp_v!(1)),
+ Instruction::ExecuteIsFloat(temp_v!(1)),
+ Instruction::ExecuteIsNonVar(temp_v!(1)),
+ Instruction::ExecuteIsVar(temp_v!(1)),
+ ]);
for (p, instr) in self.code[impls_offset..].iter().enumerate() {
let key = instr.to_name_and_arity();
}
}
+ #[allow(clippy::new_without_default)]
pub fn new(config: MachineConfig) -> Self {
use ref_thread_local::RefThreadLocal;
self.reset_attr_var_state(or_frame.prelude.attr_var_queue_len);
self.machine_st.hb = target_h;
- self.machine_st.p = self.machine_st.p + offset;
+ self.machine_st.p += offset;
self.machine_st.stack.truncate(b);
self.machine_st.heap.truncate(target_h);
} else {
Err(self.machine_st.throw_undefined_error(name, arity))
}
- } else {
- if let Some(module) = self.indices.modules.get(&module_name) {
- if let Some(idx) = module.code_dir.get(&(name, arity)).cloned() {
- self.try_call(name, arity, idx.get())
- } else {
- self.undefined_procedure(name, arity)
- }
+ } else if let Some(module) = self.indices.modules.get(&module_name) {
+ if let Some(idx) = module.code_dir.get(&(name, arity)).cloned() {
+ self.try_call(name, arity, idx.get())
} else {
- let stub = functor_stub(name, arity);
- let err = self
- .machine_st
- .existence_error(ExistenceError::QualifiedProcedure { module_name, name, arity });
-
- Err(self.machine_st.error_form(err, stub))
+ self.undefined_procedure(name, arity)
}
+ } else {
+ let stub = functor_stub(name, arity);
+ let err = self
+ .machine_st
+ .existence_error(ExistenceError::QualifiedProcedure {
+ module_name,
+ name,
+ arity,
+ });
+
+ Err(self.machine_st.error_form(err, stub))
}
}
} else {
self.undefined_procedure(name, arity)
}
- } else {
- if let Some(module) = self.indices.modules.get(&module_name) {
- if let Some(idx) = module.code_dir.get(&(name, arity)).cloned() {
- self.try_execute(name, arity, idx.get())
- } else {
- self.undefined_procedure(name, arity)
- }
+ } else if let Some(module) = self.indices.modules.get(&module_name) {
+ if let Some(idx) = module.code_dir.get(&(name, arity)).cloned() {
+ self.try_execute(name, arity, idx.get())
} else {
- let stub = functor_stub(name, arity);
- let err = self
- .machine_st
- .existence_error(ExistenceError::QualifiedProcedure { module_name, name, arity });
-
- Err(self.machine_st.error_form(err, stub))
+ self.undefined_procedure(name, arity)
}
+ } else {
+ let stub = functor_stub(name, arity);
+ let err = self
+ .machine_st
+ .existence_error(ExistenceError::QualifiedProcedure {
+ module_name,
+ name,
+ arity,
+ });
+
+ Err(self.machine_st.error_form(err, stub))
}
}
use crate::atom_table::*;
-use ordered_float::OrderedFloat;
use dashu::*;
+use ordered_float::OrderedFloat;
use std::collections::BTreeMap;
use std::collections::HashMap;
// If there is only one line, and it is an empty match, return true.
if query_result_lines.len() == 1 {
- match query_result_lines[0].clone() {
- QueryResolutionLine::Match(m) => {
- if m.is_empty() {
- return QueryResolution::True;
- }
+ if let QueryResolutionLine::Match(m) = query_result_lines[0].clone() {
+ if m.is_empty() {
+ return QueryResolution::True;
}
- _ => {}
}
}
if query_result_lines
.iter()
.any(|l| l == &QueryResolutionLine::True)
- && !query_result_lines.iter().any(|l| {
- if let &QueryResolutionLine::Match(_) = l {
- true
- } else {
- false
- }
- })
+ && !query_result_lines
+ .iter()
+ .any(|l| matches!(l, QueryResolutionLine::Match(_)))
{
return QueryResolution::True;
}
// If there is at least one match, return all matches.
let all_matches = query_result_lines
.into_iter()
- .filter(|l| {
- if let &QueryResolutionLine::Match(_) = l {
- true
- } else {
- false
- }
- })
+ .filter(|l| matches!(l, QueryResolutionLine::Match(_)))
.map(|l| match l {
QueryResolutionLine::Match(m) => QueryMatch::from(m),
_ => unreachable!(),
')' => level_parenthesis -= 1,
'"' => in_double_quotes = !in_double_quotes,
'\'' => in_single_quotes = !in_single_quotes,
- ',' if level_bracket == 0 && level_parenthesis == 0 && !in_double_quotes && !in_single_quotes => {
+ ',' if level_bracket == 0
+ && level_parenthesis == 0
+ && !in_double_quotes
+ && !in_single_quotes =>
+ {
result.push(input[start..i].trim().to_string());
start = i + 1;
}
let key = result.0;
let value = result.1;
// cut off at given characters/strings:
- let value = value.split("\n").next().unwrap().to_string();
- let value = value.split(" ").next().unwrap().to_string();
- let value = value.split("\t").next().unwrap().to_string();
+ let value = value.split('\n').next().unwrap().to_string();
+ let value = value.split(' ').next().unwrap().to_string();
+ let value = value.split('\t').next().unwrap().to_string();
let value = value.split("error").next().unwrap().to_string();
map.insert(key, value);
}
-
+
map
}
Ok((key, Value::try_from(value)?))
})
.filter_map(Result::ok)
- .collect::<BTreeMap<_, _>>()
- )
- ),
+ .collect::<BTreeMap<_, _>>(),
+ )),
}
}
}
Ok(Value::Float(OrderedFloat(float_value)))
} else if let Ok(int_value) = string.parse::<i128>() {
Ok(Value::Integer(int_value.into()))
- } else if trimmed.starts_with("'") && trimmed.ends_with("'") {
- Ok(Value::String(trimmed[1..trimmed.len() - 1].into()))
- } else if trimmed.starts_with("\"") && trimmed.ends_with("\"") {
+ } else if trimmed.starts_with('\'') && trimmed.ends_with('\'')
+ || trimmed.starts_with('"') && trimmed.ends_with('"')
+ {
Ok(Value::String(trimmed[1..trimmed.len() - 1].into()))
- } else if trimmed.starts_with("[") && trimmed.ends_with("]") {
+ } else if trimmed.starts_with('[') && trimmed.ends_with(']') {
let split = split_nested_list(&trimmed[1..trimmed.len() - 1]);
-
+
let values = split
.into_iter()
.map(Value::try_from)
.collect::<Result<Vec<_>, _>>()?;
Ok(Value::List(values))
- } else if trimmed.starts_with("{") && trimmed.ends_with("}") {
- let mut iter = trimmed[1..trimmed.len() - 1].split(",");
+ } else if trimmed.starts_with('{') && trimmed.ends_with('}') {
+ let iter = trimmed[1..trimmed.len() - 1].split(',');
let mut values = vec![];
- while let Some(value) = iter.next() {
- let items: Vec<_> = value.split(":").collect();
+ for value in iter {
+ let items: Vec<_> = value.split(':').collect();
if items.len() == 2 {
let _key = items[0].to_string();
let value = items[1].to_string();
Ok(Value::Structure(atom!("{}"), values))
} else if trimmed.starts_with("<<") && trimmed.ends_with(">>") {
- let mut iter = trimmed[2..trimmed.len() - 2].split(",");
+ let iter = trimmed[2..trimmed.len() - 2].split(',');
let mut values = vec![];
- while let Some(value) = iter.next() {
- let items: Vec<_> = value.split(":").collect();
+ for value in iter {
+ let items: Vec<_> = value.split(':').collect();
if items.len() == 2 {
let _key = items[0].to_string();
let value = items[1].to_string();
}
Ok(Value::Structure(atom!("<<>>"), values))
- } else if !trimmed.contains(",") && !trimmed.contains("'") && !trimmed.contains("\"") {
+ } else if !trimmed.contains(',') && !trimmed.contains('\'') && !trimmed.contains('"') {
Ok(Value::String(trimmed.into()))
} else {
Err(())
}
}
-impl Into<Atom> for PartialString {
+impl From<PartialString> for Atom {
#[inline]
- fn into(self: Self) -> Atom {
- self.0
+ fn from(val: PartialString) -> Self {
+ val.0
}
}
#[inline]
pub(super) fn new<'a>(src: &'a str, atom_tbl: &AtomTable) -> Option<(Self, &'a str)> {
let terminator_idx = scan_for_terminator(src.chars());
- let pstr = PartialString(AtomTable::build_with(&atom_tbl, &src[..terminator_idx]));
+ let pstr = PartialString(AtomTable::build_with(atom_tbl, &src[..terminator_idx]));
Some(if terminator_idx < src.as_bytes().len() {
(pstr, &src[terminator_idx + 1..])
} else {
let s = &s[result.prefix_len..];
if s.len() >= t.len() {
- if (&*s).starts_with(&*t) {
+ if s.starts_with(&*t) {
result.prefix_len += t.len();
result.offset += t.len();
} else {
return None;
}
- } else if t.starts_with(&s) {
+ } else if t.starts_with(s) {
result.prefix_len += s.len();
result.offset += s.len();
self.brent_st.hare = orig_hare;
}
+ #[allow(clippy::inherent_to_string)]
pub fn to_string(&mut self) -> String {
let mut buf = String::with_capacity(32);
- while let Some(iteratee) = self.next() {
+ for iteratee in self.by_ref() {
match iteratee {
PStrIteratee::Char(_, c) => {
buf.push(c);
heap_bound_deref(self.heap, self.heap[h]),
);
- return if let Some(c) = value.as_char() {
- Some(PStrIterStep {
+ return value.as_char().map(|c| PStrIterStep {
iteratee: PStrIteratee::Char(curr_hare, c),
next_hare: h+1,
- })
- } else {
- None
- };
+ });
}
(HeapCellValueTag::Str, s) => {
let (name, arity) = cell_as_atom_cell!(self.heap[s])
heap_bound_deref(self.heap, self.heap[s+1]),
);
- if let Some(c) = value.as_char() {
- Some(PStrIterStep {
+ value.as_char().map(|c| PStrIterStep {
iteratee: PStrIteratee::Char(curr_hare, c),
next_hare: s+2,
})
- } else {
- None
- }
} else {
None
};
match self.brent_st.step(next_hare) {
Some(cycle_result) => {
- debug_assert!(match cycle_result {
- CycleSearchResult::Cyclic(..) => true,
- _ => false,
- });
+ debug_assert!(matches!(cycle_result, CycleSearchResult::Cyclic(..)));
self.walk_hare_to_cycle_end();
self.stepper = HeapPStrIter::post_cycle_discovery_stepper;
impl PStrCmpResult {
#[inline]
pub fn is_second_iter(&self) -> bool {
- if let PStrCmpResult::SecondIterContinuable(_) = self {
- true
- } else {
- false
- }
+ matches!(self, PStrCmpResult::SecondIterContinuable(_))
}
}
return PStrCmpResult::Ordered(c1.cmp(&c2));
}
- cycle_detection_step(i1, i2, &step_1);
- let both_cyclic = cycle_detection_step(i2, i1, &step_2);
+ cycle_detection_step(i1, i2, step_1);
+ let both_cyclic = cycle_detection_step(i2, i1, step_2);
r1 = step(i1, i1.brent_st.hare);
r2 = step(i2, i2.brent_st.hare);
if n1 < pstr_atom.len() {
step_2.iteratee = PStrIteratee::PStrSegment(f2, pstr_atom, n1);
- let c1_result = cycle_detection_step(i1, i2, &step_1);
+ let c1_result = cycle_detection_step(i1, i2, step_1);
r1 = step(i1, i1.brent_st.hare);
if !c1_result {
continue;
}
} else {
- cycle_detection_step(i1, i2, &step_1);
- let both_cyclic = cycle_detection_step(i2, i1, &step_2);
+ cycle_detection_step(i1, i2, step_1);
+ let both_cyclic = cycle_detection_step(i2, i1, step_2);
r1 = step(i1, i1.brent_st.hare);
r2 = step(i2, i2.brent_st.hare);
}
}
} else {
- let c2_result = cycle_detection_step(i2, i1, &step_2);
+ let c2_result = cycle_detection_step(i2, i1, step_2);
r2 = step(i2, i2.brent_st.hare);
if !c2_result {
if n1 < pstr_atom.len() {
step_1.iteratee = PStrIteratee::PStrSegment(f1, pstr_atom, n1);
- let c2_result = cycle_detection_step(i2, i1, &step_2);
+ let c2_result = cycle_detection_step(i2, i1, step_2);
r2 = step(i2, step_2.next_hare);
if !c2_result {
continue;
}
} else {
- cycle_detection_step(i1, i2, &step_1);
- let both_cyclic = cycle_detection_step(i2, i1, &step_2);
+ cycle_detection_step(i1, i2, step_1);
+ let both_cyclic = cycle_detection_step(i2, i1, step_2);
r1 = step(i1, i1.brent_st.hare);
r2 = step(i2, i2.brent_st.hare);
}
}
} else {
- let c1_result = cycle_detection_step(i1, i2, &step_1);
+ let c1_result = cycle_detection_step(i1, i2, step_1);
r1 = step(i1, i1.brent_st.hare);
if !c1_result {
PStrIteratee::PStrSegment(f2, pstr2_atom, n2),
) => {
if pstr1_atom == pstr2_atom && n1 == n2 {
- cycle_detection_step(i1, i2, &step_1);
- let both_cyclic = cycle_detection_step(i2, i1, &step_2);
+ cycle_detection_step(i1, i2, step_1);
+ let both_cyclic = cycle_detection_step(i2, i1, step_2);
r1 = step(i1, i1.brent_st.hare);
r2 = step(i2, i2.brent_st.hare);
let str2 = pstr2.as_str_from(n2);
match str1.len().cmp(&str2.len()) {
- Ordering::Equal if &*str1 == &*str2 => {
- cycle_detection_step(i1, i2, &step_1);
- let both_cyclic = cycle_detection_step(i2, i1, &step_2);
+ Ordering::Equal if *str1 == *str2 => {
+ cycle_detection_step(i1, i2, step_1);
+ let both_cyclic = cycle_detection_step(i2, i1, step_2);
r1 = step(i1, i1.brent_st.hare);
r2 = step(i2, i2.brent_st.hare);
Ordering::Less if str2.starts_with(&*str1) => {
step_2.iteratee =
PStrIteratee::PStrSegment(f2, pstr2_atom, n2 + str1.len());
- let c1_result = cycle_detection_step(i1, i2, &step_1);
+ let c1_result = cycle_detection_step(i1, i2, step_1);
r1 = step(i1, i1.brent_st.hare);
if !c1_result {
Ordering::Greater if str1.starts_with(&*str2) => {
step_1.iteratee =
PStrIteratee::PStrSegment(f1, pstr1_atom, n1 + str2.len());
- let c2_result = cycle_detection_step(i2, i1, &step_2);
+ let c2_result = cycle_detection_step(i2, i1, step_2);
r2 = step(i2, i2.brent_st.hare);
if !c2_result {
} else {
PStrCmpResult::FirstIterContinuable(r1.unwrap().iteratee)
}
+ } else if i1.is_continuable() && i2.is_continuable() {
+ PStrCmpResult::Ordered(Ordering::Equal)
} else {
- if i1.is_continuable() && i2.is_continuable() {
- PStrCmpResult::Ordered(Ordering::Equal)
- } else {
- PStrCmpResult::Unordered
- }
+ PStrCmpResult::Unordered
}
}
{
let mut iter = HeapPStrIter::new(&wam.machine_st.heap, 0);
- while let Some(_) = iter.next() {}
+ for _ in iter.by_ref() {}
assert!(!iter.at_string_terminator());
}
unify!(wam.machine_st, cstr_var_cell, heap_loc_as_cell!(1));
- assert_eq!(wam.machine_st.fail, false);
+ assert!(!wam.machine_st.fail);
assert_eq!(wam.machine_st.heap[2], char_as_cell!('a'),);
unify!(wam.machine_st, cstr_var_cell, heap_loc_as_cell!(1));
- assert_eq!(wam.machine_st.fail, false);
+ assert!(!wam.machine_st.fail);
// test "abc" = [X,b,Z].
unify!(wam.machine_st, cstr_var_cell, heap_loc_as_cell!(1));
- assert_eq!(wam.machine_st.fail, false);
+ assert!(!wam.machine_st.fail);
assert_eq!(wam.machine_st.heap[2], char_as_cell!('a'),);
print_heap_terms(wam.machine_st.heap.iter(), 0);
- assert_eq!(wam.machine_st.fail, false);
+ assert!(!wam.machine_st.fail);
assert_eq!(wam.machine_st.heap[2], pstr_loc_as_cell!(5));
assert_eq!(wam.machine_st.heap[3], pstr_loc_as_cell!(1));
// assert!(iter.next().is_none());
- while let Some(_) = iter.next() {}
+ for _ in iter {}
}
}
}
}
pub(crate) fn build_rule_body(vars: &[Term], body_term: Term) -> Term {
- let head_term = Term::Clause(Cell::default(), atom!(""), vars.iter().cloned().collect());
+ let head_term = Term::Clause(Cell::default(), atom!(""), vars.to_vec());
let rule = vec![head_term, body_term];
Term::Clause(Cell::default(), atom!(":-"), rule)
) -> Result<(Atom, Vec<MetaSpec>), CompilationError> {
let mut meta_specs = vec![];
- for meta_spec in terms.into_iter() {
+ for meta_spec in terms.iter_mut() {
match meta_spec {
Term::Literal(_, Literal::Atom(meta_spec)) => {
let meta_spec = match meta_spec {
}
(atom!("module"), 2) => {
let atom_tbl = &mut LS::machine_st(&mut loader.payload).atom_tbl;
- Ok(Declaration::Module(setup_module_decl(terms, &atom_tbl)?))
+ Ok(Declaration::Module(setup_module_decl(terms, atom_tbl)?))
}
(atom!("op"), 3) => {
let atom_tbl = &mut LS::machine_st(&mut loader.payload).atom_tbl;
- Ok(Declaration::Op(setup_op_decl(terms, &atom_tbl)?))
+ Ok(Declaration::Op(setup_op_decl(terms, atom_tbl)?))
}
(atom!("non_counted_backtracking"), 1) => {
let (name, arity) = setup_predicate_indicator(&mut terms.pop().unwrap())?;
(atom!("use_module"), 1) => Ok(Declaration::UseModule(setup_use_module_decl(terms)?)),
(atom!("use_module"), 2) => {
let atom_tbl = &mut LS::machine_st(&mut loader.payload).atom_tbl;
- let (name, exports) = setup_qualified_import(terms, &atom_tbl)?;
+ let (name, exports) = setup_qualified_import(terms, atom_tbl)?;
Ok(Declaration::UseQualifiedModule(name, exports))
}
let index_offset = (index - 1) * mem::size_of::<HeapCellValue>();
unsafe {
- let ptr = mem::transmute::<&AndFrame, *const u8>(self);
+ let ptr = self as *const crate::machine::stack::AndFrame as *const u8;
let ptr = ptr as usize + prelude_offset + index_offset;
&*(ptr as *const HeapCellValue)
let index_offset = (index - 1) * mem::size_of::<HeapCellValue>();
unsafe {
- let ptr = mem::transmute::<&mut AndFrame, *const u8>(self);
+ let ptr = self as *mut crate::machine::stack::AndFrame as *const u8;
let ptr = ptr as usize + prelude_offset + index_offset;
&mut *(ptr as *mut HeapCellValue)
let index_offset = index * mem::size_of::<HeapCellValue>();
unsafe {
- let ptr = mem::transmute::<&OrFrame, *const u8>(self);
+ let ptr = self as *const crate::machine::stack::OrFrame as *const u8;
let ptr = ptr as usize + prelude_offset + index_offset;
&*(ptr as *const HeapCellValue)
let index_offset = index * mem::size_of::<HeapCellValue>();
unsafe {
- let ptr = mem::transmute::<&mut OrFrame, *const u8>(self);
+ let ptr = self as *mut crate::machine::stack::OrFrame as *const u8;
let ptr = ptr as usize + prelude_offset + index_offset;
&mut *(ptr as *mut HeapCellValue)
use std::fs::{File, OpenOptions};
use std::hash::Hash;
use std::io;
-use std::io::{Cursor, ErrorKind, Read, Seek, SeekFrom, Write};
#[cfg(feature = "http")]
use std::io::BufRead;
+use std::io::{Cursor, ErrorKind, Read, Seek, SeekFrom, Write};
use std::mem;
use std::net::{Shutdown, TcpStream};
use std::ops::{Deref, DerefMut};
// its pending buffer length from position.
self.get_mut()
.file
- .seek(SeekFrom::Current(0))
+ .stream_position()
.map(|pos| pos - self.stream.rem_buf_len() as u64)
.ok()
}
#[inline]
fn flush(&mut self) -> std::io::Result<()> {
- Ok(())
+ Ok(())
}
}
#[cfg(feature = "http")]
impl HttpWriteStream {
fn drop(&mut self) {
- let headers = unsafe { mem::ManuallyDrop::take(&mut self.headers) };
- let buffer = unsafe { mem::ManuallyDrop::take(&mut self.buffer) };
-
- let (ready, response, cvar) = &**self.response;
-
- let mut ready = ready.lock().unwrap();
- {
- let mut response = response.lock().unwrap();
-
- let mut response_ = warp::http::Response::builder()
- .status(self.status_code);
- *response_.headers_mut().unwrap() = headers;
- *response = Some(response_.body(warp::hyper::Body::from(buffer)).unwrap());
- }
- *ready = true;
- cvar.notify_one();
+ let headers = unsafe { mem::ManuallyDrop::take(&mut self.headers) };
+ let buffer = unsafe { mem::ManuallyDrop::take(&mut self.buffer) };
+
+ let (ready, response, cvar) = &**self.response;
+
+ let mut ready = ready.lock().unwrap();
+ {
+ let mut response = response.lock().unwrap();
+
+ let mut response_ = warp::http::Response::builder().status(self.status_code);
+ *response_.headers_mut().unwrap() = headers;
+ *response = Some(response_.body(warp::hyper::Body::from(buffer)).unwrap());
+ }
+ *ready = true;
+ cvar.notify_one();
}
}
-
#[derive(Debug)]
pub struct StandardOutputStream {}
#[inline]
pub fn get_alias(self) -> Option<Atom> {
if self.has_alias() {
- Some(Atom::from((self.alias() as u64) << 3))
+ Some(Atom::from(self.alias() << 3))
} else {
None
}
mem::size_of::<StreamLayout<$stream_type>>()
}
+ #[allow(clippy::not_unsafe_ptr_arg_deref)]
#[inline]
fn copy_to_arena(self, dst: *mut Self) -> Self::PtrToAllocated {
unsafe {
#[inline]
pub fn is_stderr(&self) -> bool {
- if let Stream::StandardError(_) = self {
- true
- } else {
- false
- }
+ matches!(self, Stream::StandardError(_))
}
#[inline]
pub fn is_stdout(&self) -> bool {
- if let Stream::StandardOutput(_) = self {
- true
- } else {
- false
- }
+ matches!(self, Stream::StandardOutput(_))
}
#[inline]
pub fn is_stdin(&self) -> bool {
- if let Stream::Readline(_) = self {
- true
- } else {
- false
- }
+ matches!(self, Stream::Readline(_))
}
pub fn as_ptr(&self) -> *const ArenaHeader {
impl Read for Stream {
#[inline]
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
- let bytes_read = match self {
+ match self {
Stream::InputFile(file) => (*file).read(buf),
Stream::NamedTcp(tcp_stream) => (*tcp_stream).read(buf),
#[cfg(feature = "tls")]
ErrorKind::PermissionDenied,
StreamError::ReadFromOutputStream,
)),
- };
-
- bytes_read
+ }
}
}
cursor: &Cursor<T>,
cursor_len: u64,
) -> AtEndOfStream {
- let position = cursor.position();
-
- let at_end_of_stream = match position.cmp(&cursor_len) {
+ match cursor.position().cmp(&cursor_len) {
Ordering::Equal => AtEndOfStream::At,
Ordering::Greater => {
*past_end_of_stream = true;
AtEndOfStream::Past
}
Ordering::Less => AtEndOfStream::Not,
- };
-
- at_end_of_stream
+ }
}
impl Stream {
#[inline]
pub(crate) fn set_position(&mut self, position: u64) {
- match self {
- Stream::InputFile(stream_layout) => {
- let StreamLayout {
- past_end_of_stream,
- stream,
- ..
- } = &mut **stream_layout;
-
- stream
- .get_mut()
- .file
- .seek(SeekFrom::Start(position))
- .unwrap();
- stream.reset_buffer(); // flush the internal buffer.
-
- if let Ok(metadata) = stream.get_ref().file.metadata() {
- *past_end_of_stream = position > metadata.len();
- }
+ if let Stream::InputFile(stream_layout) = self {
+ let StreamLayout {
+ past_end_of_stream,
+ stream,
+ ..
+ } = &mut **stream_layout;
+
+ stream
+ .get_mut()
+ .file
+ .seek(SeekFrom::Start(position))
+ .unwrap();
+ stream.reset_buffer(); // flush the internal buffer.
+
+ if let Ok(metadata) = stream.get_ref().file.metadata() {
+ *past_end_of_stream = position > metadata.len();
}
- _ => {}
}
}
headers: hyper::HeaderMap,
arena: &mut Arena,
) -> Self {
- Stream::HttpWrite(arena_alloc!(
- StreamLayout::new(CharReader::new(HttpWriteStream {
- response,
- status_code,
- headers: mem::ManuallyDrop::new(headers),
- buffer: mem::ManuallyDrop::new(Vec::new()),
- })),
- arena
- ))
+ Stream::HttpWrite(arena_alloc!(
+ StreamLayout::new(CharReader::new(HttpWriteStream {
+ response,
+ status_code,
+ headers: mem::ManuallyDrop::new(headers),
+ buffer: mem::ManuallyDrop::new(Vec::new()),
+ })),
+ arena
+ ))
}
#[inline]
Ok(())
}
#[cfg(feature = "http")]
- Stream::HttpWrite(ref mut http_stream) => {
- http_stream.inner_mut().drop();
+ Stream::HttpWrite(ref mut http_stream) => {
+ http_stream.inner_mut().drop();
unsafe {
http_stream.set_tag(ArenaHeaderTag::Dropped);
std::ptr::drop_in_place(&mut http_stream.inner_mut().buffer as *mut _);
#[inline]
pub(crate) fn is_null_stream(&self) -> bool {
- if let Stream::Null(_) = self {
- true
- } else {
- false
- }
+ matches!(self, Stream::Null(_))
}
#[inline]
self.set_lines_read(0);
self.set_past_end_of_stream(false);
- loop {
- match self {
- Stream::Byte(ref mut cursor) => {
- cursor.stream.get_mut().0.set_position(0);
- return true;
- }
- Stream::InputFile(ref mut file_stream) => {
- file_stream
- .stream
- .get_mut()
- .file
- .seek(SeekFrom::Start(0))
- .unwrap();
- return true;
- }
- Stream::Readline(ref mut readline_stream) => {
- readline_stream.reset();
- return true;
- }
- _ => {
- return false;
- }
+ match self {
+ Stream::Byte(ref mut cursor) => {
+ cursor.stream.get_mut().0.set_position(0);
+ true
}
+ Stream::InputFile(ref mut file_stream) => {
+ file_stream
+ .stream
+ .get_mut()
+ .file
+ .seek(SeekFrom::Start(0))
+ .unwrap();
+ true
+ }
+ Stream::Readline(ref mut readline_stream) => {
+ readline_stream.reset();
+ true
+ }
+ _ => false,
}
}
stream.set_past_end_of_stream(true);
}
- Ok(self.fail = stream.past_end_of_stream())
+ self.fail = stream.past_end_of_stream();
+ Ok(())
}
}
}
- pub(crate) fn to_stream_options(
+ pub(crate) fn get_stream_options(
&mut self,
alias: HeapCellValue,
eof_action: HeapCellValue,
caller: Atom,
arity: usize,
) -> CallResult {
- let opt_err = if input.is_some() && !stream.is_input_stream() {
- Some(atom!("stream")) // 8.14.2.3 g)
- } else if input.is_none() && !stream.is_output_stream() {
+ let opt_err = if input.is_some() && !stream.is_input_stream()
+ || input.is_none() && !stream.is_output_stream()
+ {
Some(atom!("stream")) // 8.14.2.3 g)
} else if stream.options().stream_type() != expected_type {
Some(expected_type.other().as_atom()) // 8.14.2.3 h)
use crate::heap_iter::*;
use crate::heap_print::*;
#[cfg(feature = "http")]
-use crate::http::{HttpRequestData, HttpListener, HttpResponse, HttpRequest};
+use crate::http::{HttpListener, HttpRequest, HttpRequestData, HttpResponse};
use crate::instructions::*;
use crate::machine;
use crate::machine::code_walker::*;
use std::cell::Cell;
use std::cmp::Ordering;
-use std::collections::{BTreeSet};
+use std::collections::BTreeSet;
use std::convert::TryFrom;
use std::env;
#[cfg(feature = "ffi")]
use std::ffi::CString;
use std::fs;
use std::hash::{BuildHasher, BuildHasherDefault};
-use std::io::{ErrorKind, Read, Write};
#[cfg(feature = "http")]
use std::io::BufRead;
+use std::io::{ErrorKind, Read, Write};
use std::iter::{once, FromIterator};
use std::mem;
-use std::net::{TcpListener, TcpStream};
#[cfg(feature = "http")]
use std::net::{SocketAddr, ToSocketAddrs};
+use std::net::{TcpListener, TcpStream};
use std::num::NonZeroU32;
use std::ops::Sub;
use std::process;
#[cfg(feature = "http")]
use std::str::FromStr;
#[cfg(feature = "http")]
-use std::sync::{Mutex, Arc, Condvar};
+use std::sync::{Arc, Condvar, Mutex};
use chrono::{offset::Local, DateTime};
#[cfg(not(target_arch = "wasm32"))]
use select;
#[cfg(feature = "http")]
-use warp::hyper::header::{HeaderValue, HeaderName};
+use futures::future;
#[cfg(feature = "http")]
-use warp::hyper::{HeaderMap, Method};
+use reqwest::Url;
#[cfg(feature = "http")]
-use warp::{Buf, Filter};
+use warp::hyper::header::{HeaderName, HeaderValue};
#[cfg(feature = "http")]
-use reqwest::Url;
+use warp::hyper::{HeaderMap, Method};
#[cfg(feature = "http")]
-use futures::future;
+use warp::{Buf, Filter};
#[cfg(feature = "repl")]
pub(crate) fn get_key() -> KeyEvent {
enable_raw_mode().expect("failed to enable raw mode");
loop {
let key_ = read();
- if let Ok(key_) = key_ {
- if let Event::Key(key_) = key_ {
- match key_.code {
- KeyCode::Char(_) | KeyCode::Enter | KeyCode::Tab => {
- key = key_;
- break;
- }
- _ => (),
+ if let Ok(Event::Key(key_)) = key_ {
+ match key_.code {
+ KeyCode::Char(_) | KeyCode::Enter | KeyCode::Tab => {
+ key = key_;
+ break;
}
+ _ => (),
}
}
}
#[inline(always)]
pub fn num_steps(&self) -> usize {
- return self.lam + self.pstr_chars + self.power - 1;
+ self.lam + self.pstr_chars + self.power - 1
}
#[inline(always)]
read_heap_cell!(value,
(HeapCellValueTag::PStrLoc, h) => {
- return self.add_pstr_chars_and_step(&heap, h);
+ return self.add_pstr_chars_and_step(heap, h);
}
(HeapCellValueTag::CStr | HeapCellValueTag::PStrOffset) => {
- return self.add_pstr_chars_and_step(&heap, self.hare);
+ return self.add_pstr_chars_and_step(heap, self.hare);
}
(HeapCellValueTag::Lis, h) => {
return self.step(h+1);
offset+1
}
(HeapCellValueTag::PStrLoc, h) => {
- let (h_offset, n) = pstr_loc_and_offset(&heap, h);
+ let (h_offset, n) = pstr_loc_and_offset(heap, h);
let n = n.get_num() as usize;
let pstr = cell_as_string!(heap[h_offset]);
}
}
(HeapCellValueTag::PStrLoc, h) => {
- let (h_offset, n) = pstr_loc_and_offset(&heap, h);
+ let (h_offset, n) = pstr_loc_and_offset(heap, h);
let n = n.get_num() as usize;
let pstr = cell_as_string!(heap[h_offset]);
debug_assert!(heap[h].get_tag() == HeapCellValueTag::PStrOffset);
if heap[h_offset].get_tag() == HeapCellValueTag::CStr {
- return if pstr_chars + 1 <= max_steps {
+ return if pstr_chars < max_steps {
CycleSearchResult::ProperList(pstr_chars + 1)
} else {
CycleSearchResult::UntouchedCStr(pstr.into(), max_steps)
loop {
if brent_st.exhausted_max_steps() {
- return brent_st.to_result(&heap);
+ return brent_st.to_result(heap);
}
if let Some(result) = brent_st.cycle_step(heap) {
loop {
read_heap_cell!(value,
(HeapCellValueTag::PStrLoc, h) => {
- let (h_offset, _) = pstr_loc_and_offset(&heap, h);
+ let (h_offset, _) = pstr_loc_and_offset(heap, h);
return h_offset+1;
}
(HeapCellValueTag::Lis, h) => {
let value: i64 = (&*n).try_into().unwrap();
Some(value)
- },
+ }
_ => None,
};
if let Some(max_steps) = max_steps_n {
- if max_steps.abs() as u64 <= 1 << 63 {
+ if max_steps.unsigned_abs() <= 1 << 63 {
if max_steps >= 0 {
max_old = max_steps;
} else {
let mut seen_set = IndexSet::new();
{
- let mut iter = stackful_post_order_iter::<NonListElider>(&mut self.heap, &mut self.stack, term);
+ let mut iter =
+ stackful_post_order_iter::<NonListElider>(&mut self.heap, &mut self.stack, term);
while let Some(value) = iter.next() {
if iter.parent_stack_len() >= max_depth {
use crate::parser::lexer::*;
let nx = self.store(self.deref(self.registers[2]));
- let add_dot = !string.ends_with(".");
+ let add_dot = !string.ends_with('.');
let cursor = std::io::Cursor::new(string);
let iter = std::io::Read::chain(cursor, {
let addr = self.store(self.deref(addr));
match Number::try_from(addr) {
- Ok(Number::Fixnum(n)) => match u32::try_from(n.get_num()) {
- Ok(n) => {
+ Ok(Number::Fixnum(n)) => {
+ if let Ok(n) = u32::try_from(n.get_num()) {
if let Some(c) = std::char::from_u32(n) {
string.push(c);
continue;
}
}
- _ => {}
- },
+ }
Ok(Number::Integer(n)) => {
let n: u32 = (&*n).try_into().unwrap();
if let Some(c) = std::char::from_u32(n) {
let bp = or_frame.prelude.bp;
match &self.code[bp] {
- &Instruction::IndexingCode(ref indexing_code) => {
+ Instruction::IndexingCode(ref indexing_code) => {
match &indexing_code[or_frame.prelude.boip as usize] {
- &IndexingLine::IndexedChoice(ref indexed_choice) => {
+ IndexingLine::IndexedChoice(ref indexed_choice) => {
let p = or_frame.prelude.biip as usize - 1;
match &indexed_choice[p] {
}
match &self.code[bp] {
- &Instruction::IndexingCode(ref indexing_code) => {
+ Instruction::IndexingCode(ref indexing_code) => {
let indexing_code_ptr = match &indexing_code[0] {
&IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(
_,
let boip = extract_ptr!(indexing_code_ptr);
let boip = match &indexing_code[boip] {
- &IndexingLine::Indexing(IndexingInstruction::SwitchOnStructure(ref hm)) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnStructure(ref hm)) => {
boip + extract_ptr!(hm.get(&key).cloned().unwrap())
}
- &IndexingLine::Indexing(IndexingInstruction::SwitchOnConstant(ref hm)) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnConstant(ref hm)) => {
boip + extract_ptr!(hm.get(&Literal::Atom(key.0)).cloned().unwrap())
}
_ => boip,
};
match &indexing_code[boip] {
- &IndexingLine::IndexedChoice(ref indexed_choice) => {
+ IndexingLine::IndexedChoice(indexed_choice) => {
return (
skeleton.core.clause_clause_locs.back().cloned().unwrap(),
bp + indexed_choice.back().unwrap().offset(),
heap_loc_as_cell!(0),
);
- if module_loc.is_var() || module_loc == atom_as_cell!(atom!("user")) {
- if arg_term.is_var() && supp_var.is_var() {
- return arg_term == *supp_var;
- }
+ if (module_loc.is_var() || module_loc == atom_as_cell!(atom!("user"))) && arg_term.is_var() && supp_var.is_var() {
+ return arg_term == *supp_var;
}
false
result.goal
} else {
let mut unexpanded_vars = IndexSet::with_hasher(FxBuildHasher::default());
- self.machine_st.variable_set(&mut unexpanded_vars, self.machine_st.registers[5]);
+ self.machine_st
+ .variable_set(&mut unexpanded_vars, self.machine_st.registers[5]);
// all supp_vars must appear later!
let vars = IndexSet::<HeapCellValue, BuildHasherDefault<FxHasher>>::from_iter(
#[inline(always)]
pub(crate) fn is_reset_cont_marker(&self, p: usize) -> bool {
- match &self.code[p] {
+ matches!(
+ &self.code[p],
&Instruction::CallResetContinuationMarker
- | &Instruction::ExecuteResetContinuationMarker => true,
- _ => false,
- }
+ | &Instruction::ExecuteResetContinuationMarker
+ )
}
#[inline(always)]
Ok(Number::Integer(n)) => {
let value: usize = (&*n).try_into().unwrap();
Some(value)
- },
+ }
_ => {
unreachable!()
}
self.machine_st.fail = true;
}
+ #[cfg(not(target_arch = "wasm32"))]
#[inline(always)]
pub(crate) fn current_hostname(&mut self) {
- #[cfg(feature = "hostname")]
- match hostname::get().ok() {
- Some(host) => match host.to_str() {
- Some(host) => {
- let hostname = AtomTable::build_with(&self.machine_st.atom_tbl, host);
+ if let Ok(host) = hostname::get() {
+ if let Some(host) = host.to_str() {
+ let hostname = AtomTable::build_with(&self.machine_st.atom_tbl, host);
- let a1 = self.deref_register(1);
- self.machine_st.unify_atom(hostname, a1);
+ let a1 = self.deref_register(1);
+ self.machine_st.unify_atom(hostname, a1);
- return;
- }
- None => {}
- },
- None => {}
+ return;
+ }
}
self.machine_st.fail = true;
}
+ #[cfg(target_arch = "wasm32")]
+ pub(crate) fn current_hostname(&mut self) {
+ unimplemented!()
+ }
+
#[inline(always)]
pub(crate) fn current_input(&mut self) -> CallResult {
let addr = self.deref_register(1);
}
};
- let current_atom = AtomTable::build_with(&self.machine_st.atom_tbl, ¤t);
+ let current_atom = AtomTable::build_with(&self.machine_st.atom_tbl, current);
let a1 = self.deref_register(1);
self.machine_st.unify_complete_string(current_atom, a1);
.machine_st
.value_to_str_like(self.machine_st.registers[1])
{
- match fs::canonicalize(&*path.as_str()) {
- Ok(canonical) => {
- let cs = match canonical.to_str() {
- Some(s) => s,
- _ => {
- let stub = functor_stub(atom!("path_canonical"), 2);
- let err = self.machine_st.representation_error(RepFlag::Character);
- let err = self.machine_st.error_form(err, stub);
+ if let Ok(canonical) = fs::canonicalize(&*path.as_str()) {
+ let cs = match canonical.to_str() {
+ Some(s) => s,
+ _ => {
+ let stub = functor_stub(atom!("path_canonical"), 2);
+ let err = self.machine_st.representation_error(RepFlag::Character);
+ let err = self.machine_st.error_form(err, stub);
- return Err(err);
- }
- };
+ return Err(err);
+ }
+ };
- let canonical_atom = AtomTable::build_with(&self.machine_st.atom_tbl, cs);
+ let canonical_atom = AtomTable::build_with(&self.machine_st.atom_tbl, cs);
- let a2 = self.deref_register(2);
- self.machine_st.unify_complete_string(canonical_atom, a2);
+ let a2 = self.deref_register(2);
+ self.machine_st.unify_complete_string(canonical_atom, a2);
- return Ok(());
- }
- _ => {}
+ return Ok(());
}
}
let atom_or_string = self.machine_st.value_to_str_like(a1).unwrap();
self.machine_st
- .parse_number_from_string(&*atom_or_string.as_str(), &self.indices, stub_gen)
+ .parse_number_from_string(&atom_or_string.as_str(), &self.indices, stub_gen)
}
#[inline(always)]
let mut iter = HeapPStrIter::new(&self.machine_st.heap, h);
- while let Some(_) = iter.next() {}
+ for _ in iter.by_ref() {}
let at_end_of_pstr = iter.focus.is_var() || iter.at_string_terminator();
self.machine_st.fail = !at_end_of_pstr;
)?;
if stream.past_end_of_stream() {
- if EOFAction::Reset != stream.options().eof_action() {
- return Ok(());
- } else if self.machine_st.fail {
- return Ok(());
- }
+ return Ok(());
}
let addr = self.deref_register(2);
2,
)?;
- if EOFAction::Reset != stream.options().eof_action() {
- break;
- } else if self.machine_st.fail {
+ if EOFAction::Reset != stream.options().eof_action() || self.machine_st.fail {
break;
}
}
2,
)?;
- if stream.past_end_of_stream() {
- if EOFAction::Reset != stream.options().eof_action() {
- return Ok(());
- } else if self.machine_st.fail {
- return Ok(());
- }
+ if stream.past_end_of_stream()
+ && (EOFAction::Reset != stream.options().eof_action() || self.machine_st.fail)
+ {
+ return Ok(());
}
let a2 = self.deref_register(2);
2,
)?;
- if EOFAction::Reset != stream.options().eof_action() {
- break;
- } else if self.machine_st.fail {
+ if EOFAction::Reset != stream.options().eof_action() || self.machine_st.fail {
break;
}
}
2,
)?;
- if stream.past_end_of_stream() {
- if EOFAction::Reset != stream.options().eof_action() {
- return Ok(());
- } else if self.machine_st.fail {
- return Ok(());
- }
+ if stream.past_end_of_stream()
+ && (EOFAction::Reset != stream.options().eof_action() || self.machine_st.fail)
+ {
+ return Ok(());
}
let a2 = self.deref_register(2);
Ok(Number::Integer(n)) => {
let n: u32 = (&*n).try_into().unwrap();
- let n = std::char::from_u32(n).and_then(|_| Some(n));
+ let n = std::char::from_u32(n).map(|_| n);
if let Some(n) = n {
fixnum_as_cell!(Fixnum::build_with(n as i64))
Ok(Number::Fixnum(n)) => {
let n = u32::try_from(n.get_num())
.ok()
- .and_then(|n| std::char::from_u32(n).and_then(|_| Some(n)));
+ .and_then(|n| std::char::from_u32(n).map(|_| n));
if let Some(n) = n {
fixnum_as_cell!(Fixnum::build_with(n as i64))
2,
)?;
- if EOFAction::Reset != stream.options().eof_action() {
- break;
- } else if self.machine_st.fail {
+ if EOFAction::Reset != stream.options().eof_action() || self.machine_st.fail {
break;
}
}
}
}
- return Ok(());
+ Ok(())
}
#[inline(always)]
}
};
- let chars_atom = AtomTable::build_with(&self.machine_st.atom_tbl, &string.trim());
+ let chars_atom = AtomTable::build_with(&self.machine_st.atom_tbl, string.trim());
self.machine_st.unify_complete_string(chars_atom, chs);
}
return Ok(());
}
Ok(Number::Fixnum(n)) => {
- match u32::try_from(n.get_num()) {
- Ok(n) => {
- if let Some(c) = std::char::from_u32(n) {
- self.machine_st.unify_char(c, a1);
- return Ok(());
- }
+ if let Ok(n) = u32::try_from(n.get_num()) {
+ if let Some(c) = std::char::from_u32(n) {
+ self.machine_st.unify_char(c, a1);
+ return Ok(());
}
- _ => {}
}
let err = self.machine_st.representation_error(RepFlag::CharacterCode);
let h = self.machine_st.heap.len();
let stub = ball.copy_and_align(h);
- self.machine_st.heap.extend(stub.into_iter());
+ self.machine_st.heap.extend(stub);
unify_fn!(self.machine_st, addr, heap_loc_as_cell!(h));
if addr.is_var() {
let err = self.machine_st.instantiation_error();
- return Err(self.machine_st.error_form(err, stub_gen()));
+ Err(self.machine_st.error_form(err, stub_gen()))
} else {
match Number::try_from(addr) {
Ok(Number::Integer(n)) => {
let n: u32 = (&*n).try_into().unwrap();
let n = char::try_from(n);
- if let Some(c) = n.ok() {
+ if let Ok(c) = n {
write!(&mut stream, "{}", c).unwrap();
return Ok(());
}
Ok(Number::Fixnum(n)) => {
let n = n.get_num();
- if let Some(c) = u32::try_from(n).ok().and_then(|c| char::from_u32(c)) {
+ if let Some(c) = u32::try_from(n).ok().and_then(char::from_u32) {
write!(&mut stream, "{}", c).unwrap();
return Ok(());
}
}
let err = self.machine_st.representation_error(RepFlag::CharacterCode);
- return Err(self.machine_st.error_form(err, stub_gen()));
+ Err(self.machine_st.error_form(err, stub_gen()))
}
}
if addr.is_var() {
let err = self.machine_st.instantiation_error();
- return Err(self.machine_st.error_form(err, stub_gen()));
+ Err(self.machine_st.error_form(err, stub_gen()))
} else {
read_heap_cell!(addr,
(HeapCellValueTag::Atom, (name, _arity)) => {
);
let err = self.machine_st.type_error(ValidType::Character, addr);
- return Err(self.machine_st.error_form(err, stub_gen()));
+ Err(self.machine_st.error_form(err, stub_gen()))
}
}
Ok(Number::Integer(n)) => {
let n: u8 = (&*n).try_into().unwrap();
- match n {
- nb => {
- match stream.write(&mut [nb]) {
- Ok(1) => {
- return Ok(());
- }
- _ => {
- let err = self.machine_st.existence_error(
- ExistenceError::Stream(stream_as_cell!(stream))
- );
+ match stream.write(&[n]) {
+ Ok(1) => {
+ return Ok(());
+ }
+ _ => {
+ let err = self
+ .machine_st
+ .existence_error(ExistenceError::Stream(stream_as_cell!(stream)));
- return Err(self.machine_st.error_form(err, stub_gen()));
- }
- }
+ return Err(self.machine_st.error_form(err, stub_gen()));
}
}
}
Ok(Number::Fixnum(n)) => {
if let Ok(nb) = u8::try_from(n.get_num()) {
- match stream.write(&mut [nb]) {
+ match stream.write(&[nb]) {
Ok(1) => {
return Ok(());
}
2,
)?;
- if EOFAction::Reset != stream.options().eof_action() {
- return Ok(());
- } else if self.machine_st.fail {
+ if EOFAction::Reset != stream.options().eof_action() || self.machine_st.fail {
return Ok(());
}
}
}
};
- loop {
- let mut b = [0u8; 1];
+ let mut b = [0u8; 1];
- match stream.read(&mut b) {
- Ok(1) => {
- self.machine_st
- .unify_fixnum(Fixnum::build_with(b[0] as i64), addr);
- break;
- }
- _ => {
- stream.set_past_end_of_stream(true);
- self.machine_st
- .unify_fixnum(Fixnum::build_with(-1), self.machine_st.registers[2]);
- break;
- }
+ match stream.read(&mut b) {
+ Ok(1) => {
+ self.machine_st
+ .unify_fixnum(Fixnum::build_with(b[0] as i64), addr);
+ }
+ _ => {
+ stream.set_past_end_of_stream(true);
+ self.machine_st
+ .unify_fixnum(Fixnum::build_with(-1), self.machine_st.registers[2]);
}
}
2,
)?;
- if stream.past_end_of_stream() {
- if EOFAction::Reset != stream.options().eof_action() {
- return Ok(());
- } else if self.machine_st.fail {
- return Ok(());
- }
+ if stream.past_end_of_stream()
+ && (EOFAction::Reset != stream.options().eof_action() || self.machine_st.fail)
+ {
+ return Ok(());
}
let addr = self.deref_register(2);
2,
)?;
- if EOFAction::Reset != stream.options().eof_action() {
- break;
- } else if self.machine_st.fail {
+ if EOFAction::Reset != stream.options().eof_action() || self.machine_st.fail {
break;
}
}
let num = match Number::try_from(self.deref_register(2)) {
Ok(Number::Fixnum(n)) => usize::try_from(n.get_num()).unwrap(),
Ok(Number::Integer(n)) => match (&*n).try_into() as Result<usize, _> {
- Ok(u) => {
- u
- }
+ Ok(u) => u,
_ => {
self.machine_st.fail = true;
return Ok(());
2,
)?;
- if stream.past_end_of_stream() {
- if EOFAction::Reset != stream.options().eof_action() {
- return Ok(());
- } else if self.machine_st.fail {
- return Ok(());
- }
+ if stream.past_end_of_stream()
+ && (EOFAction::Reset != stream.options().eof_action() || self.machine_st.fail)
+ {
+ return Ok(());
}
let addr = self.deref_register(2);
Ok(Number::Fixnum(n)) => {
let nf = u32::try_from(n.get_num())
.ok()
- .and_then(|n| std::char::from_u32(n));
+ .and_then(std::char::from_u32);
if nf.is_some() {
fixnum_as_cell!(n)
2,
)?;
- if EOFAction::Reset != stream.options().eof_action() {
- break;
- } else if self.machine_st.fail {
+ if EOFAction::Reset != stream.options().eof_action() || self.machine_st.fail {
break;
}
}
let close_result = stream.close();
- if let Err(_) = close_result {
+ if close_result.is_err() {
let stub = functor_stub(atom!("close"), 1);
let addr = stream_as_cell!(stream);
let err = self
Ok(Number::Integer(n)) => {
let value: usize = (&*n).try_into().unwrap();
Some(value)
- },
+ }
_ => None,
};
heap.extend(functor!(
atom!("op"),
- [fixnum(prec), cell(atom_as_cell!(spec_atom)), cell(atom_as_cell!(name))]
+ [
+ fixnum(prec),
+ cell(atom_as_cell!(spec_atom)),
+ cell(atom_as_cell!(name))
+ ]
));
num_functors += 1;
+ op_descs[1].is_some() as usize
+ op_descs[2].is_some() as usize;
- let op_descs = op_descs.into_iter().filter_map(|op_desc| {
- op_desc.map(|op_desc| (orig_op, *op_desc))
- });
+ let op_descs = op_descs
+ .into_iter()
+ .filter_map(|op_desc| op_desc.map(|op_desc| (orig_op, *op_desc)));
if number_of_keys == 0 {
self.machine_st.fail = true;
} else {
- let num_functors = write_op_functors_to_heap(
- &mut self.machine_st.heap,
- op_descs,
- );
+ let num_functors =
+ write_op_functors_to_heap(&mut self.machine_st.heap, op_descs);
let h = iter_to_heap_list(
&mut self.machine_st.heap,
Ok(Number::Integer(n)) => match (&*n).try_into() as Result<usize, _> {
Ok(n) => n,
Err(_) => {
- let err = self.machine_st.resource_error(ResourceError::FiniteMemory(len));
+ let err = self
+ .machine_st
+ .resource_error(ResourceError::FiniteMemory(len));
return Err(self.machine_st.error_form(err, stub_gen()));
}
},
(HeapCellValueTag::Str, s) => {
let name = cell_as_atom_cell!(self.machine_st.heap[s]).get_name();
let value = self.machine_st.value_to_str_like(self.machine_st.heap[s + 1]).unwrap();
- header_map.insert(HeaderName::from_str(&*name.as_str()).unwrap(), HeaderValue::from_str(&*value.as_str()).unwrap());
+ header_map.insert(HeaderName::from_str(&name.as_str()).unwrap(), HeaderValue::from_str(&value.as_str()).unwrap());
}
_ => {
unreachable!()
let mut req = reqwest::blocking::Request::new(method, address);
*req.headers_mut() = headers;
- if bytes.len() > 0 {
+ if !bytes.is_empty() {
*req.body_mut() = Some(reqwest::blocking::Body::from(bytes));
}
)))]
);
- self.machine_st.heap.extend(header_term.into_iter());
+ self.machine_st.heap.extend(header_term);
str_loc_as_cell!(h)
})
.collect();
#[inline(always)]
pub(crate) fn http_listen(&mut self) -> CallResult {
let address_sink = self.deref_register(1);
- let tls_key = self.deref_register(3);
- let tls_cert = self.deref_register(4);
- let content_length_limit = self.deref_register(5);
- const CONTENT_LENGTH_LIMIT_DEFAULT: u64 = 32768;
- let content_length_limit = match Number::try_from(content_length_limit) {
- Ok(Number::Fixnum(n)) => if n.get_num() >= 0 {
- n.get_num() as u64
- } else {
- CONTENT_LENGTH_LIMIT_DEFAULT
- },
- Ok(Number::Integer(n)) => {
+ let tls_key = self.deref_register(3);
+ let tls_cert = self.deref_register(4);
+ let content_length_limit = self.deref_register(5);
+ const CONTENT_LENGTH_LIMIT_DEFAULT: u64 = 32768;
+ let content_length_limit = match Number::try_from(content_length_limit) {
+ Ok(Number::Fixnum(n)) => {
+ if n.get_num() >= 0 {
+ n.get_num() as u64
+ } else {
+ CONTENT_LENGTH_LIMIT_DEFAULT
+ }
+ }
+ Ok(Number::Integer(n)) => {
let n: Result<u64, _> = (&*n).try_into();
- match n {
- Ok(u) => u,
- Err(_) => CONTENT_LENGTH_LIMIT_DEFAULT,
- }
- }
- _ => CONTENT_LENGTH_LIMIT_DEFAULT,
- };
-
- let ssl_server: Option<(String,String)> = {
- match self.machine_st.value_to_str_like(tls_key) {
- Some(key) => {
- match self.machine_st.value_to_str_like(tls_cert) {
- Some(cert) => {
- let key_str = key.as_str();
- let cert_str = cert.as_str();
-
- if key_str.is_empty() || cert_str.is_empty() {
- None
- } else {
- Some((key_str.to_string(), cert_str.to_string()))
- }
- }
- None => None
- }
- }
- None => None
- }
- };
-
- if let Some(address_str) = self.machine_st.value_to_str_like(address_sink) {
- let address_string = address_str.as_str();
- let addr: SocketAddr = match address_string.to_socket_addrs().ok().and_then(|mut s| s.next()) {
- Some(addr) => addr,
- _ => {
- self.machine_st.fail = true;
- return Ok(());
+ match n {
+ Ok(u) => u,
+ Err(_) => CONTENT_LENGTH_LIMIT_DEFAULT,
+ }
}
+ _ => CONTENT_LENGTH_LIMIT_DEFAULT,
};
- let (tx, rx) = std::sync::mpsc::sync_channel(1024);
-
- let runtime = tokio::runtime::Handle::current();
- let _guard = runtime.enter();
-
- fn get_reader(body: impl Buf + Send + 'static) -> Box<dyn BufRead + Send> {
- Box::new(body.reader())
- }
-
- let serve = warp::body::aggregate()
- .and(warp::header::optional::<u64>(warp::http::header::CONTENT_LENGTH.as_str()))
- .and(warp::method())
- .and(warp::header::headers_cloned())
- .and(warp::path::full())
- .and(warp::query::raw().or_else(|_| future::ready(Ok::<(String,), warp::Rejection>(("".to_string(),)))))
- .map(move |body, content_length, method, headers: warp::http::HeaderMap, path: warp::filters::path::FullPath, query| {
- if let Some(content_length) = content_length {
- if content_length > content_length_limit {
- return warp::http::Response::builder()
- .status(413)
- .body(warp::hyper::Body::empty())
- .unwrap();
- }
- }
-
- let http_request_data = HttpRequestData {
- method,
- headers,
- path: path.as_str().to_string(),
- query,
- body: get_reader(body),
- };
- let response = Arc::new((Mutex::new(false), Mutex::new(None), Condvar::new()));
- let http_request = HttpRequest { request_data: http_request_data, response: Arc::clone(&response) };
- // we send the request to http_accept
- tx.send(http_request).unwrap();
-
- // we wait for the Response info from Prolog
- {
- let (ready, _response, cvar) = &*response;
- let mut ready = ready.lock().unwrap();
- while !*ready {
- ready = cvar.wait(ready).unwrap();
- }
- }
- {
- let (_, response, _) = &*response;
- let response = response.lock().unwrap().take();
- response.expect("Data race error in HTTP server")
- }
- });
-
- runtime.spawn(async move {
- match ssl_server {
- Some((key, cert)) => {
- warp::serve(serve).tls().key(key).cert(cert).run(addr).await
- }
- None => {
- warp::serve(serve).run(addr).await
- }
- }
- });
-
- let http_listener = HttpListener { incoming: rx };
- let http_listener = arena_alloc!(http_listener, &mut self.machine_st.arena);
+ let ssl_server: Option<(String, String)> = {
+ match self.machine_st.value_to_str_like(tls_key) {
+ Some(key) => match self.machine_st.value_to_str_like(tls_cert) {
+ Some(cert) => {
+ let key_str = key.as_str();
+ let cert_str = cert.as_str();
- let addr = self.deref_register(2);
- self.machine_st.bind(
- addr.as_var().unwrap(),
- typed_arena_ptr_as_cell!(http_listener),
- );
+ if key_str.is_empty() || cert_str.is_empty() {
+ None
+ } else {
+ Some((key_str.to_string(), cert_str.to_string()))
+ }
+ }
+ None => None,
+ },
+ None => None,
+ }
+ };
+
+ if let Some(address_str) = self.machine_st.value_to_str_like(address_sink) {
+ let address_string = address_str.as_str();
+ let addr: SocketAddr = match address_string
+ .to_socket_addrs()
+ .ok()
+ .and_then(|mut s| s.next())
+ {
+ Some(addr) => addr,
+ _ => {
+ self.machine_st.fail = true;
+ return Ok(());
+ }
+ };
+
+ let (tx, rx) = std::sync::mpsc::sync_channel(1024);
+
+ let runtime = tokio::runtime::Handle::current();
+ let _guard = runtime.enter();
+
+ fn get_reader(body: impl Buf + Send + 'static) -> Box<dyn BufRead + Send> {
+ Box::new(body.reader())
+ }
+
+ let serve = warp::body::aggregate()
+ .and(warp::header::optional::<u64>(
+ warp::http::header::CONTENT_LENGTH.as_str(),
+ ))
+ .and(warp::method())
+ .and(warp::header::headers_cloned())
+ .and(warp::path::full())
+ .and(warp::query::raw().or_else(|_| {
+ future::ready(Ok::<(String,), warp::Rejection>(("".to_string(),)))
+ }))
+ .map(
+ move |body,
+ content_length,
+ method,
+ headers: warp::http::HeaderMap,
+ path: warp::filters::path::FullPath,
+ query| {
+ if let Some(content_length) = content_length {
+ if content_length > content_length_limit {
+ return warp::http::Response::builder()
+ .status(413)
+ .body(warp::hyper::Body::empty())
+ .unwrap();
+ }
+ }
+
+ let http_request_data = HttpRequestData {
+ method,
+ headers,
+ path: path.as_str().to_string(),
+ query,
+ body: get_reader(body),
+ };
+ let response =
+ Arc::new((Mutex::new(false), Mutex::new(None), Condvar::new()));
+ let http_request = HttpRequest {
+ request_data: http_request_data,
+ response: Arc::clone(&response),
+ };
+ // we send the request to http_accept
+ tx.send(http_request).unwrap();
+
+ // we wait for the Response info from Prolog
+ {
+ let (ready, _response, cvar) = &*response;
+ let mut ready = ready.lock().unwrap();
+ while !*ready {
+ ready = cvar.wait(ready).unwrap();
+ }
+ }
+ {
+ let (_, response, _) = &*response;
+ let response = response.lock().unwrap().take();
+ response.expect("Data race error in HTTP server")
+ }
+ },
+ );
+
+ runtime.spawn(async move {
+ match ssl_server {
+ Some((key, cert)) => {
+ warp::serve(serve).tls().key(key).cert(cert).run(addr).await
+ }
+ None => warp::serve(serve).run(addr).await,
+ }
+ });
+
+ let http_listener = HttpListener { incoming: rx };
+ let http_listener = arena_alloc!(http_listener, &mut self.machine_st.arena);
+
+ let addr = self.deref_register(2);
+ self.machine_st.bind(
+ addr.as_var().unwrap(),
+ typed_arena_ptr_as_cell!(http_listener),
+ );
}
Ok(())
}
#[cfg(feature = "http")]
#[inline(always)]
pub(crate) fn http_accept(&mut self) -> CallResult {
- let culprit = self.deref_register(1);
- let method = self.deref_register(2);
- let path = self.deref_register(3);
- let query = self.deref_register(5);
- let stream_addr = self.deref_register(6);
- let handle_addr = self.deref_register(7);
- read_heap_cell!(culprit,
- (HeapCellValueTag::Cons, cons_ptr) => {
- match_untyped_arena_ptr!(cons_ptr,
- (ArenaHeaderTag::HttpListener, http_listener) => {
- loop {
- match http_listener.incoming.recv_timeout(std::time::Duration::from_millis(200)) {
- Ok(request) => {
- let method_atom = match request.request_data.method {
- Method::GET => atom!("get"),
- Method::POST => atom!("post"),
- Method::PUT => atom!("put"),
- Method::DELETE => atom!("delete"),
- Method::PATCH => atom!("patch"),
- Method::HEAD => atom!("head"),
- Method::OPTIONS => atom!("options"),
- Method::TRACE => atom!("trace"),
- Method::CONNECT => atom!("connect"),
- _ => atom!("unsupported_extension"),
- };
- let path_atom = AtomTable::build_with(&self.machine_st.atom_tbl, &request.request_data.path);
- let path_cell = atom_as_cstr_cell!(path_atom);
- let headers: Vec<HeapCellValue> = request.request_data.headers.iter().map(|(header_name, header_value)| {
- let h = self.machine_st.heap.len();
- let header_term = functor!(AtomTable::build_with(&self.machine_st.atom_tbl, header_name.as_str()), [cell(string_as_cstr_cell!(AtomTable::build_with(&self.machine_st.atom_tbl, header_value.to_str().unwrap())))]);
+ let culprit = self.deref_register(1);
+ let method = self.deref_register(2);
+ let path = self.deref_register(3);
+ let query = self.deref_register(5);
+ let stream_addr = self.deref_register(6);
+ let handle_addr = self.deref_register(7);
+ read_heap_cell!(culprit,
+ (HeapCellValueTag::Cons, cons_ptr) => {
+ match_untyped_arena_ptr!(cons_ptr,
+ (ArenaHeaderTag::HttpListener, http_listener) => {
+ loop {
+ match http_listener.incoming.recv_timeout(std::time::Duration::from_millis(200)) {
+ Ok(request) => {
+ let method_atom = match request.request_data.method {
+ Method::GET => atom!("get"),
+ Method::POST => atom!("post"),
+ Method::PUT => atom!("put"),
+ Method::DELETE => atom!("delete"),
+ Method::PATCH => atom!("patch"),
+ Method::HEAD => atom!("head"),
+ Method::OPTIONS => atom!("options"),
+ Method::TRACE => atom!("trace"),
+ Method::CONNECT => atom!("connect"),
+ _ => atom!("unsupported_extension"),
+ };
+ let path_atom = AtomTable::build_with(&self.machine_st.atom_tbl, &request.request_data.path);
+ let path_cell = atom_as_cstr_cell!(path_atom);
+ let headers: Vec<HeapCellValue> = request.request_data.headers.iter().map(|(header_name, header_value)| {
+ let h = self.machine_st.heap.len();
+ let header_term = functor!(AtomTable::build_with(&self.machine_st.atom_tbl, header_name.as_str()), [cell(string_as_cstr_cell!(AtomTable::build_with(&self.machine_st.atom_tbl, header_value.to_str().unwrap())))]);
self.machine_st.heap.extend(header_term.into_iter());
str_loc_as_cell!(h)
let headers_list = iter_to_heap_list(&mut self.machine_st.heap, headers.into_iter());
- let query_str = request.request_data.query;
- let query_atom = AtomTable::build_with(&self.machine_st.atom_tbl, &query_str);
- let query_cell = string_as_cstr_cell!(query_atom);
+ let query_str = request.request_data.query;
+ let query_atom = AtomTable::build_with(&self.machine_st.atom_tbl, &query_str);
+ let query_cell = string_as_cstr_cell!(query_atom);
- let mut stream = Stream::from_http_stream(
- path_atom,
- request.request_data.body,
- &mut self.machine_st.arena
- );
- *stream.options_mut() = StreamOptions::default();
- stream.options_mut().set_stream_type(StreamType::Binary);
- self.indices.streams.insert(stream);
- let stream = stream_as_cell!(stream);
+ let mut stream = Stream::from_http_stream(
+ path_atom,
+ request.request_data.body,
+ &mut self.machine_st.arena
+ );
+ *stream.options_mut() = StreamOptions::default();
+ stream.options_mut().set_stream_type(StreamType::Binary);
+ self.indices.streams.insert(stream);
+ let stream = stream_as_cell!(stream);
let handle = arena_alloc!(request.response, &mut self.machine_st.arena);
self.machine_st.bind(query.as_var().unwrap(), query_cell);
self.machine_st.bind(stream_addr.as_var().unwrap(), stream);
self.machine_st.bind(handle_addr.as_var().unwrap(), typed_arena_ptr_as_cell!(handle));
- break
+ break
}
- Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
- let interrupted = machine::INTERRUPT.load(std::sync::atomic::Ordering::Relaxed);
-
- match machine::INTERRUPT.compare_exchange(
- interrupted,
- false,
- std::sync::atomic::Ordering::Relaxed,
- std::sync::atomic::Ordering::Relaxed,
- ) {
- Ok(interruption) => {
- if interruption {
- self.machine_st.throw_interrupt_exception();
- self.machine_st.backtrack();
+ Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
+ let interrupted = machine::INTERRUPT.load(std::sync::atomic::Ordering::Relaxed);
+
+ match machine::INTERRUPT.compare_exchange(
+ interrupted,
+ false,
+ std::sync::atomic::Ordering::Relaxed,
+ std::sync::atomic::Ordering::Relaxed,
+ ) {
+ Ok(interruption) => {
+ if interruption {
+ self.machine_st.throw_interrupt_exception();
+ self.machine_st.backtrack();
// We have extracted controll over the Tokio runtime to the calling context for enabling library use case
// (see https://github.com/mthom/scryer-prolog/pull/1880)
// So we only have access to a runtime handle in here and can't shut it down.
// Since I'm not aware of the consequences of deactivating this new code which came in while PR 1880
// was not merged, I'm only deactivating it for now.
- //let old_runtime = std::mem::replace(&mut self.runtime, tokio::runtime::Runtime::new().unwrap());
- //old_runtime.shutdown_background();
- break
- }
- }
- Err(_) => unreachable!(),
- }
-
- }
- Err(_) => {
+ //let old_runtime = std::mem::replace(&mut self.runtime, tokio::runtime::Runtime::new().unwrap());
+ //old_runtime.shutdown_background();
+ break
+ }
+ }
+ Err(_) => unreachable!(),
+ }
+
+ }
+ Err(_) => {
self.machine_st.fail = true;
}
- }
+ }
}
}
_ => {
#[cfg(feature = "http")]
#[inline(always)]
pub(crate) fn http_answer(&mut self) -> CallResult {
- let culprit = self.deref_register(1);
- let status_code = self.deref_register(2);
- let status_code: u16 = match Number::try_from(status_code) {
- Ok(Number::Fixnum(n)) => n.get_num() as u16,
- Ok(Number::Integer(n)) => {
- let n: Result<u16, _> = (&*n).try_into();
-
- if let Ok(value) = n {
- value
- } else {
- self.machine_st.fail = true;
- return Ok(());
+ let culprit = self.deref_register(1);
+ let status_code = self.deref_register(2);
+ let status_code: u16 = match Number::try_from(status_code) {
+ Ok(Number::Fixnum(n)) => n.get_num() as u16,
+ Ok(Number::Integer(n)) => {
+ let n: Result<u16, _> = (&*n).try_into();
+
+ if let Ok(value) = n {
+ value
+ } else {
+ self.machine_st.fail = true;
+ return Ok(());
+ }
}
- }
- _ => unreachable!()
- };
- let stub_gen = || functor_stub(atom!("http_listen"), 2);
- let headers = match self.machine_st.try_from_list(self.machine_st.registers[3], stub_gen) {
+ _ => unreachable!(),
+ };
+ let stub_gen = || functor_stub(atom!("http_listen"), 2);
+ let headers = match self
+ .machine_st
+ .try_from_list(self.machine_st.registers[3], stub_gen)
+ {
Ok(addrs) => {
let mut header_map = HeaderMap::new();
for heap_cell in addrs {
(HeapCellValueTag::Str, s) => {
let name = cell_as_atom_cell!(self.machine_st.heap[s]).get_name();
let value = self.machine_st.value_to_str_like(self.machine_st.heap[s + 1]).unwrap();
- header_map.insert(HeaderName::from_str(&*name.as_str()).unwrap(), HeaderValue::from_str(&*value.as_str()).unwrap());
+ header_map.insert(HeaderName::from_str(&name.as_str()).unwrap(), HeaderValue::from_str(&value.as_str()).unwrap());
}
_ => {
unreachable!()
}
)
}
- if let Ok(_) = self
+ if self
.foreign_function_table
- .load_library(&*library_name.as_str(), &functions)
+ .load_library(&library_name.as_str(), &functions)
+ .is_ok()
{
return Ok(());
}
let return_value = self.deref_register(3);
if let Some(function_name) = self.machine_st.value_to_str_like(function_name) {
let stub_gen = || functor_stub(atom!("foreign_call"), 3);
- fn map_arg(
- mut machine_st: &mut MachineState,
- source: HeapCellValue,
- ) -> crate::ffi::Value {
+ fn map_arg(machine_st: &mut MachineState, source: HeapCellValue) -> crate::ffi::Value {
match Number::try_from(source) {
Ok(Number::Fixnum(n)) => Value::Int(n.get_num()),
Ok(Number::Float(n)) => Value::Float(n.into_inner()),
{
Value::Struct(
struct_name.as_str().to_string(),
- iter.map(|x| map_arg(&mut machine_st, x)).collect(),
+ iter.map(|x| map_arg(machine_st, x)).collect(),
)
} else {
unreachable!()
.collect();
match self
.foreign_function_table
- .exec(&*function_name.as_str(), args)
+ .exec(&function_name.as_str(), args)
{
Ok(result) => {
match result {
Err(e) => return Err(e),
};
self.foreign_function_table
- .define_struct(&*struct_name.as_str(), fields);
+ .define_struct(&struct_name.as_str(), fields);
return Ok(());
}
self.machine_st.fail = true;
let reposition = self.machine_st.registers[6];
let stream_type = self.machine_st.registers[7];
- let options = self
- .machine_st
- .to_stream_options(alias, eof_action, reposition, stream_type);
+ let options =
+ self.machine_st
+ .get_stream_options(alias, eof_action, reposition, stream_type);
let src_sink = self.deref_register(1);
if let Some(file_spec) = self.machine_st.value_to_str_like(src_sink) {
- let file_spec = file_spec.as_atom(&*self.machine_st.atom_tbl);
+ let file_spec = file_spec.as_atom(&self.machine_st.atom_tbl);
let mut stream =
self.machine_st
Ok(Number::Integer(n)) => {
let n: u16 = (&*n).try_into().unwrap();
n
- },
+ }
Ok(Number::Fixnum(n)) => u16::try_from(n.get_num()).unwrap(),
_ => {
unreachable!();
.map_err(SessionError::from)
.and_then(|mut op_decl| {
if op_decl.op_desc.get_prec() == 0 {
- Ok(op_decl.remove(&mut self.indices.op_dir))
+ op_decl.remove(&mut self.indices.op_dir);
+ Ok(())
} else {
let spec = get_op_desc(
op_decl.name,
let reposition = self.machine_st.registers[4];
let stream_type = self.machine_st.registers[5];
- let options = self
- .machine_st
- .to_stream_options(alias, eof_action, reposition, stream_type);
+ let options =
+ self.machine_st
+ .get_stream_options(alias, eof_action, reposition, stream_type);
*stream.options_mut() = options;
Ok(())
Ok(Number::Integer(n)) => {
let value: usize = (&*n).try_into().unwrap();
Some(value)
- },
+ }
Ok(Number::Fixnum(n)) => usize::try_from(n.get_num()).ok(),
_ => {
self.machine_st.fail = true;
let module = self.deref_register(2);
- match self.match_attribute(self.machine_st.heap[attr_var_list], module, attr) {
- Some(AttrListMatch {
- prev_tail,
- match_site: MatchSite::Match(match_site),
- }) => {
- let prev_tail = if let Some(prev_tail) = prev_tail {
- // not at the head.
- prev_tail
- } else {
- if self.machine_st.heap[match_site + 1].is_var() {
- let h = attr_var.get_value() as usize;
-
- self.machine_st.heap[h] = heap_loc_as_cell!(h);
- self.machine_st.trail(TrailRef::Ref(Ref::attr_var(h)));
- }
-
- // at the head.
- attr_var_list
- };
+ if let Some(AttrListMatch {
+ prev_tail,
+ match_site: MatchSite::Match(match_site),
+ }) = self.match_attribute(self.machine_st.heap[attr_var_list], module, attr)
+ {
+ let prev_tail = if let Some(prev_tail) = prev_tail {
+ // not at the head.
+ prev_tail
+ } else {
+ if self.machine_st.heap[match_site + 1].is_var() {
+ let h = attr_var.get_value() as usize;
- if self.machine_st.heap[match_site + 1].get_tag() == HeapCellValueTag::Lis {
- let prev_tail_value = self.machine_st.heap[match_site + 1].get_value();
- self.machine_st.heap[prev_tail].set_value(prev_tail_value);
- } else {
- self.machine_st.heap[prev_tail] = heap_loc_as_cell!(prev_tail);
+ self.machine_st.heap[h] = heap_loc_as_cell!(h);
+ self.machine_st.trail(TrailRef::Ref(Ref::attr_var(h)));
}
- self.machine_st
- .trail(TrailRef::AttrVarListLink(prev_tail, match_site));
+ // at the head.
+ attr_var_list
+ };
+
+ if self.machine_st.heap[match_site + 1].get_tag() == HeapCellValueTag::Lis {
+ let prev_tail_value = self.machine_st.heap[match_site + 1].get_value();
+ self.machine_st.heap[prev_tail].set_value(prev_tail_value);
+ } else {
+ self.machine_st.heap[prev_tail] = heap_loc_as_cell!(prev_tail);
}
- _ => {}
+
+ self.machine_st
+ .trail(TrailRef::AttrVarListLink(prev_tail, match_site));
}
}
Ok(Number::Integer(n)) => {
let n: u8 = (&*n).try_into().unwrap();
n
- },
+ }
Ok(Number::Rational(r)) => {
// n has already been confirmed as an integer, and
// internally, Rational is assumed reduced, so its
Ok(Number::Integer(n)) => {
let value: usize = (&*n).try_into().unwrap();
value
- },
+ }
_ => {
let stub = functor_stub(atom!("call_with_inference_limit"), 3);
let count = self.machine_st.cwil.add_limit(n, bp);
let result = count.try_into();
- if let Ok(value) = result{
+ if let Ok(value) = result {
self.machine_st.unify_fixnum(Fixnum::build_with(value), a3);
} else {
let count = arena_alloc!(count.clone(), &mut self.machine_st.arena);
.map(|index| index.get())
.unwrap_or(IndexPtr::dynamic_undefined());
- match index.tag() {
- IndexPtrTag::DynamicUndefined | IndexPtrTag::Undefined => false,
- _ => true,
- }
+ !matches!(index.tag(), IndexPtrTag::DynamicUndefined | IndexPtrTag::Undefined)
}
}
(HeapCellValueTag::Atom, (name, arity)) => {
.map(|index| index.get())
.unwrap_or(IndexPtr::dynamic_undefined());
- match index.tag() {
- IndexPtrTag::DynamicUndefined => false,
- _ => true,
- }
+ !matches!(index.tag(), IndexPtrTag::DynamicUndefined)
}
}
_ => {
let count = self.machine_st.cwil.remove_limit(block).clone();
let result = count.clone().try_into();
- if let Ok(value) = result{
+ if let Ok(value) = result {
self.machine_st.unify_fixnum(Fixnum::build_with(value), a2);
} else {
let count = arena_alloc!(count.clone(), &mut self.machine_st.arena);
let addr = self.deref_register(1);
let h = self.machine_st.heap.len();
- if self.machine_st.ball.stub.len() > 0 {
+ if !self.machine_st.ball.stub.is_empty() {
let stub = self.machine_st.ball.copy_and_align(h);
- self.machine_st.heap.extend(stub.into_iter());
+ self.machine_st.heap.extend(stub);
} else {
self.machine_st.fail = true;
return;
#[inline(always)]
pub(crate) fn push_ball_stack(&mut self) {
- if self.machine_st.ball.stub.len() > 0 {
+ if !self.machine_st.ball.stub.is_empty() {
self.machine_st
.ball_stack
.push(mem::replace(&mut self.machine_st.ball, Ball::new()));
Ok(()) => Ok(()),
Err(e) => {
self.user_input.reset();
- return Err(e);
+ Err(e)
}
}
}
atom_or_string: AtomOrString,
) -> Result<Option<TermWriteResult>, MachineStub> {
let string = match atom_or_string {
- AtomOrString::Atom(atom) if atom == atom!("[]") => "".to_owned(),
- _ => atom_or_string.to_string(),
+ AtomOrString::Atom(atom!("[]")) => "".to_owned(),
+ _ => atom_or_string.into(),
};
let chars = CharReader::new(ByteStream::from_string(string));
let n: u64 = Integer::from(n).try_into().unwrap();
let rng: StdRng = SeedableRng::seed_from_u64(n);
self.rng = rng;
- },
+ }
Ok(Number::Integer(n)) => {
let n: u64 = (&*n).try_into().unwrap();
let rng: StdRng = SeedableRng::seed_from_u64(n);
self.rng = rng;
- },
+ }
Ok(Number::Rational(n)) => {
- if n.denominator() == &UBig::from(1 as u32) {
+ if n.denominator() == &UBig::ONE {
let n: u64 = n.numerator().try_into().unwrap();
let rng: StdRng = SeedableRng::seed_from_u64(n);
self.rng = rng;
let reposition = self.machine_st.registers[6];
let stream_type = self.machine_st.registers[7];
- let options = self
- .machine_st
- .to_stream_options(alias, eof_action, reposition, stream_type);
+ let options =
+ self.machine_st
+ .get_stream_options(alias, eof_action, reposition, stream_type);
if options.reposition() {
return Err(self
let reposition = self.machine_st.registers[6];
let stream_type = self.machine_st.registers[7];
- let options = self
- .machine_st
- .to_stream_options(alias, eof_action, reposition, stream_type);
+ let options =
+ self.machine_st
+ .get_stream_options(alias, eof_action, reposition, stream_type);
if options.reposition() {
return Err(self
)?;
let connector = TlsConnector::new().unwrap();
- let stream = match connector.connect(&*hostname.as_str(), stream0) {
+ let stream = match connector.connect(&hostname.as_str(), stream0) {
Ok(tls_stream) => tls_stream,
Err(_) => {
return Err(self.machine_st.open_permission_error(
.machine_st
.value_to_str_like(self.machine_st.registers[2])
{
- let identity = match Identity::from_pkcs12(&pkcs12, &*password.as_str()) {
+ let identity = match Identity::from_pkcs12(&pkcs12, &password.as_str()) {
Ok(identity) => identity,
Err(_) => {
return Err(self.machine_st.open_permission_error(
let err = self.machine_st.type_error(ValidType::TcpListener, culprit);
let stub = functor_stub(atom!("socket_server_close"), 1);
- return Err(self.machine_st.error_form(err, stub));
+ Err(self.machine_st.error_form(err, stub))
}
#[inline(always)]
]
);
- self.machine_st.heap.extend(position_term.into_iter());
+ self.machine_st.heap.extend(position_term);
str_loc_as_cell!(h)
} else {
self.machine_st.fail = true;
instr.enqueue_functors(h, &mut self.machine_st.arena, &mut functors);
let new_len = functors.len();
+ #[allow(clippy::needless_range_loop)]
for index in old_len..new_len {
let functor_len = functors[index].len();
Ok(Number::Integer(n)) => {
let value: usize = (&*n).try_into().unwrap();
value
- },
+ }
_ => {
unreachable!()
}
};
let first_idx = match first_idx {
- Some(ref idx) if idx.local().is_some() => {
+ Some(idx) if idx.local().is_some() => {
if let Some(idx) = idx.local() {
idx
} else {
Ok(Number::Integer(n)) => {
let value: usize = (&*n).try_into().unwrap();
value
- },
+ }
_ => {
unreachable!()
}
};
let salt = hkdf::Salt::new(digest_alg, &salt);
- let mut bytes: Vec<u8> = Vec::new();
-
- bytes.resize(length, 0);
+ let mut bytes: Vec<u8> = vec![0; length];
match salt.extract(&data).expand(&[&info[..]], MyKey(length)) {
Ok(r) => {
return;
}
}
- },
+ }
_ => {
unreachable!()
}
}
};
- if buffer.len() == 0 {
+ if buffer.is_empty() {
empty_list_as_cell!()
} else {
atom_as_cstr_cell!(AtomTable::build_with(&self.machine_st.atom_tbl, &buffer))
.machine_st
.value_to_str_like(self.machine_st.registers[1])
{
- match roxmltree::Document::parse(&*string.as_str()) {
+ match roxmltree::Document::parse(&string.as_str()) {
Ok(doc) => {
let result = self.xml_node_to_term(doc.root_element());
unify!(self.machine_st, self.machine_st.registers[2], result);
match env::var("SHELL") {
Ok(value) => {
- let command = process::Command::new(&value)
+ let command = process::Command::new(value)
.arg("-c")
.arg(&*command.as_str())
.status();
}
_ => match env::var("COMSPEC") {
Ok(value) => {
- let command = process::Command::new(&value)
+ let command = process::Command::new(value)
.arg("/C")
.arg(&*command.as_str())
.status();
let padding = cell_as_atom!(self.deref_register(3));
let charset = cell_as_atom!(self.deref_register(4));
- let config = if padding == atom!("true") {
- if charset == atom!("standard") {
- base64::STANDARD
- } else {
- base64::URL_SAFE
- }
- } else {
- if charset == atom!("standard") {
- base64::STANDARD_NO_PAD
- } else {
- base64::URL_SAFE_NO_PAD
- }
+ let config = match (padding, charset) {
+ (atom!("true"), atom!("standard")) => base64::STANDARD,
+ (atom!("true"), _) => base64::URL_SAFE,
+ (_, atom!("standard")) => base64::STANDARD_NO_PAD,
+ (_, _) => base64::URL_SAFE_NO_PAD,
};
if self.deref_register(1).is_var() {
}
let b64 = base64::encode_config(bytes, config);
- let string = self.u8s_to_string(&b64.as_bytes());
+ let string = self.u8s_to_string(b64.as_bytes());
unify!(self.machine_st, self.machine_st.registers[2], string);
}
}
Ok(Number::Integer(n)) => {
let value: usize = if n.sign() == Sign::Positive {
- UBig::from((&*n).clone().into_parts().1).count_ones()
- } else { 0 };
+ (*n).clone().into_parts().1.count_ones()
+ } else {
+ 0
+ };
Number::arena_from(value, &mut self.machine_st.arena)
}
_ => {
let name = AtomTable::build_with(&self.machine_st.atom_tbl, attr.name());
let value = put_complete_string(
&mut self.machine_st.heap,
- &attr.value(),
+ attr.value(),
&self.machine_st.atom_tbl,
);
let name = AtomTable::build_with(&self.machine_st.atom_tbl, attr.0);
let value = put_complete_string(
&mut self.machine_st.heap,
- &attr.1,
+ attr.1,
&self.machine_st.atom_tbl,
);
pub(super) fn u8s_to_string(&mut self, data: &[u8]) -> HeapCellValue {
let buffer = String::from_iter(data.iter().map(|b| *b as char));
- if buffer.len() == 0 {
+ if buffer.is_empty() {
empty_list_as_cell!()
} else {
atom_as_cstr_cell!(AtomTable::build_with(&self.machine_st.atom_tbl, &buffer))
use crate::arena::*;
use crate::forms::*;
-use crate::heap_iter::{NonListElider, stackful_preorder_iter};
+use crate::heap_iter::{stackful_preorder_iter, NonListElider};
use crate::machine::machine_state::*;
use crate::machine::partial_string::*;
use crate::machine::*;
let mut focus = pstr_iter2.focus;
- 'outer: loop {
+ 'outer: {
while let Some(c) = chars_iter.peek() {
read_heap_cell!(focus,
(HeapCellValueTag::Lis, l) => {
machine_st.pdl.push(focus);
machine_st.pdl.push(chars_iter.iter.focus);
-
- break;
}
}
PStrCmpResult::Unordered => {
}
}
(HeapCellValueTag::Lis, l1) => {
- if d2.is_ref() {
- if tabu_list.contains(&(d1, d2)) {
- continue;
- }
+ if d2.is_ref() && tabu_list.contains(&(d1, d2)) {
+ continue;
}
Self::unify_list(self, l1, d2);
if !value.is_constant() {
let machine_st: &mut MachineState = unifier.deref_mut();
- for cell in stackful_preorder_iter::<NonListElider>(&mut machine_st.heap, &mut machine_st.stack, value) {
+ for cell in stackful_preorder_iter::<NonListElider>(
+ &mut machine_st.heap,
+ &mut machine_st.stack,
+ value,
+ ) {
let cell = unmark_cell_bits!(cell);
if let Some(inner_r) = cell.as_var() {
U::bind(unifier, r, value);
}
- return occurs_triggered;
+ occurs_triggered
}
#[derive(Deref, DerefMut)]
#[inline]
pub fn is_last(self) -> bool {
- if let GenContext::Last(_) = self {
- true
- } else {
- false
- }
+ matches!(self, GenContext::Last(_))
}
}
// name and fixity -> operator type and precedence.
pub type OpDir = IndexMap<(Atom, Fixity), OpDesc, FxBuildHasher>;
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Default, Clone, Copy)]
pub struct MachineFlags {
pub double_quotes: DoubleQuotes,
pub unknown: Unknown,
}
-impl Default for MachineFlags {
- fn default() -> Self {
- MachineFlags {
- double_quotes: DoubleQuotes::default(),
- unknown: Unknown::default(),
- }
- }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Default, Clone, Copy, PartialEq)]
pub enum DoubleQuotes {
Atom,
+ #[default]
Chars,
Codes,
}
}
}
-impl Default for DoubleQuotes {
- fn default() -> Self {
- DoubleQuotes::Chars
- }
-}
-
#[derive(Debug, Clone, Copy)]
pub enum Unknown {
Error,
#[inline]
pub(crate) fn get(&self, name: Atom, fixity: Fixity) -> Option<OpDesc> {
- let entry = if let Some(ref primary_op_dir) = &self.primary_op_dir {
+ let entry = if let Some(primary_op_dir) = &self.primary_op_dir {
primary_op_dir.get(&(name, fixity))
} else {
None
const UPPER_BOUND: i64 = (1 << 55) - 1;
const LOWER_BOUND: i64 = -(1 << 55);
- if LOWER_BOUND <= num && num <= UPPER_BOUND {
+ if (LOWER_BOUND..=UPPER_BOUND).contains(&num) {
Ok(Fixnum::new()
.with_m(false)
.with_f(false)
pub fn get_num(self) -> i64 {
let n = self.num() as i64;
let (n, overflowed) = (n << 8).overflowing_shr(8);
- debug_assert_eq!(overflowed, false);
+ debug_assert!(!overflowed);
n
}
}
#[inline(always)]
pub fn as_str(&self) -> Option<&str> {
match self {
- Var::Named(value) => Some(&value),
+ Var::Named(value) => Some(value),
_ => None,
}
}
+ #[allow(clippy::inherent_to_string)]
#[inline(always)]
pub fn to_string(&self) -> String {
match self {
#[inline]
pub fn source_arity(terms: &[Term]) -> usize {
- if let Some(last_arg) = terms.last() {
- if let Term::Literal(_, Literal::CodeIndex(_)) = last_arg {
- return terms.len() - 1;
- }
+ if let Some(Term::Literal(_, Literal::CodeIndex(_))) = terms.last() {
+ return terms.len() - 1;
}
terms.len()
pub(crate) fn unfold_by_str_once(term: &mut Term, s: Atom) -> Option<(Term, Term)> {
if let Term::Clause(_, ref name, ref mut subterms) = term {
- if let Some(last_arg) = subterms.last() {
- if let Term::Literal(_, Literal::CodeIndex(_)) = last_arg {
- subterms.pop();
- }
+ if let Some(Term::Literal(_, Literal::CodeIndex(_))) = subterms.last() {
+ subterms.pop();
}
if name == &s && subterms.len() == 2 {
pub fn peek_byte(&mut self) -> Option<io::Result<u8>> {
match self.refresh_buffer() {
- Ok(_buf) => {}
- Err(e) => return Some(Err(e)),
+ Ok(_buf) => _buf.first().cloned().map(Ok),
+ Err(e) => Some(Err(e)),
}
-
- return if let Some(b) = self.buf.get(0).cloned() {
- Some(Ok(b))
- } else {
- None
- };
}
}
io::ErrorKind::InvalidData,
BadUtf8Error { bytes: badbytes },
)));
- } else {
- if self.pos >= self.buf.len() {
- return None;
- } else if self.buf.len() - self.pos >= 4 {
- return match str::from_utf8(&self.buf[self.pos..e.valid_up_to()]) {
- Ok(s) => {
- let mut chars = s.chars();
- let c = chars.next().unwrap();
-
- Some(Ok(c))
- }
- Err(e) => {
- let badbytes = self.buf[self.pos..e.valid_up_to()].to_vec();
-
- Some(Err(io::Error::new(
- io::ErrorKind::InvalidData,
- BadUtf8Error { bytes: badbytes },
- )))
- }
- };
- } else {
- let buf_len = self.buf.len();
-
- for (c, idx) in (self.pos..buf_len).enumerate() {
- self.buf[c] = self.buf[idx];
+ } else if self.pos >= self.buf.len() {
+ return None;
+ } else if self.buf.len() - self.pos >= 4 {
+ return match str::from_utf8(&self.buf[self.pos..e.valid_up_to()]) {
+ Ok(s) => {
+ let mut chars = s.chars();
+ let c = chars.next().unwrap();
+
+ Some(Ok(c))
}
+ Err(e) => {
+ let badbytes = self.buf[self.pos..e.valid_up_to()].to_vec();
- self.buf.truncate(buf_len - self.pos);
+ Some(Err(io::Error::new(
+ io::ErrorKind::InvalidData,
+ BadUtf8Error { bytes: badbytes },
+ )))
+ }
+ };
+ } else {
+ let buf_len = self.buf.len();
- let buf_len = self.buf.len();
+ for (c, idx) in (self.pos..buf_len).enumerate() {
+ self.buf[c] = self.buf[idx];
+ }
- let mut word = [0u8; 4];
- let word_slice = &mut word[buf_len..4];
+ self.buf.truncate(buf_len - self.pos);
- match self.inner.read(word_slice) {
- Err(e) => return Some(Err(e)),
- Ok(nread) => {
- self.buf.extend_from_slice(&word_slice[0..nread]);
- }
- }
+ let buf_len = self.buf.len();
- self.pos = 0;
+ let mut word = [0u8; 4];
+ let word_slice = &mut word[buf_len..4];
+
+ match self.inner.read(word_slice) {
+ Err(e) => return Some(Err(e)),
+ Ok(nread) => {
+ self.buf.extend_from_slice(&word_slice[0..nread]);
+ }
}
+
+ self.pos = 0;
}
} else {
return None;
impl Token {
#[inline]
pub(super) fn is_end(&self) -> bool {
- if let Token::End = self {
- true
- } else {
- false
- }
+ matches!(self, Token::End)
}
}
break;
}
}
- } else if cut_char!(c) {
- self.skip_char(c);
- token.push(c);
- } else if semicolon_char!(c) {
+ } else if cut_char!(c) || semicolon_char!(c) {
self.skip_char(c);
token.push(c);
} else if single_quote_char!(c) {
if self.reader.peek_char().is_none() {
self.return_char('.');
- i64::from_str_radix(&token, 10)
+ token
+ .parse::<i64>()
.map(|n| Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena)))
.or_else(|_| {
token
token.push(c);
let c = match self.lookahead_char() {
- Err(_) => return Ok(self.vacate_with_float(token)?),
+ Err(_) => return self.vacate_with_float(token),
Ok(c) => c,
};
if !sign_char!(c) && !decimal_digit_char!(c) {
- return Ok(self.vacate_with_float(token)?);
+ return self.vacate_with_float(token);
}
if sign_char!(c) {
let c = match self.lookahead_char() {
Err(_) => {
self.return_char(token.pop().unwrap());
- return Ok(self.vacate_with_float(token)?);
+ return self.vacate_with_float(token);
}
Ok(c) => c,
};
if !decimal_digit_char!(c) {
self.return_char(token.pop().unwrap());
- return Ok(self.vacate_with_float(token)?);
+ return self.vacate_with_float(token);
}
}
self.machine_st.arena
))))
} else {
- return Ok(self.vacate_with_float(token)?);
+ return self.vacate_with_float(token);
}
} else {
let n = parse_lossy::<f64, _>(token.as_bytes())?;
} else {
self.return_char('.');
- i64::from_str_radix(&token, 10)
+ token
+ .parse::<i64>()
.map(|n| Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena)))
.or_else(|_| {
token
.map_err(|_| ParserError::ParseBigInt(self.line_num, self.col_num))
})
}
- } else {
- if token.starts_with('0') && token.len() == 1 {
- if c == 'x' {
- self.hexadecimal_constant(c).or_else(|e| {
- if let ParserError::ParseBigInt(..) = e {
- i64::from_str_radix(&token, 10)
- .map(|n| {
- Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
- })
- .or_else(|_| {
- token
- .parse::<Integer>()
- .map(|n| {
- Token::Literal(Literal::Integer(arena_alloc!(
- n,
- &mut self.machine_st.arena
- )))
- })
- .map_err(|_| {
- ParserError::ParseBigInt(self.line_num, self.col_num)
- })
- })
- } else {
- Err(e)
- }
- })
- } else if c == 'o' {
- self.octal_constant(c).or_else(|e| {
- if let ParserError::ParseBigInt(..) = e {
- i64::from_str_radix(&token, 10)
- .map(|n| {
- Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
- })
- .or_else(|_| {
- token
- .parse::<Integer>()
- .map(|n| {
- Token::Literal(Literal::Integer(arena_alloc!(
- n,
- &mut self.machine_st.arena
- )))
- })
- .map_err(|_| {
- ParserError::ParseBigInt(self.line_num, self.col_num)
- })
- })
- } else {
- Err(e)
- }
- })
- } else if c == 'b' {
- self.binary_constant(c).or_else(|e| {
- if let ParserError::ParseBigInt(..) = e {
- i64::from_str_radix(&token, 10)
- .map(|n| {
- Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
- })
- .or_else(|_| {
- token
- .parse::<Integer>()
- .map(|n| {
- Token::Literal(Literal::Integer(arena_alloc!(
- n,
- &mut self.machine_st.arena
- )))
- })
- .map_err(|_| {
- ParserError::ParseBigInt(self.line_num, self.col_num)
- })
- })
- } else {
- Err(e)
- }
- })
- } else if single_quote_char!(c) {
+ } else if token.starts_with('0') && token.len() == 1 {
+ if c == 'x' {
+ self.hexadecimal_constant(c).or_else(|e| {
+ if let ParserError::ParseBigInt(..) = e {
+ token
+ .parse::<i64>()
+ .map(|n| {
+ Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
+ })
+ .or_else(|_| {
+ token
+ .parse::<Integer>()
+ .map(|n| {
+ Token::Literal(Literal::Integer(arena_alloc!(
+ n,
+ &mut self.machine_st.arena
+ )))
+ })
+ .map_err(|_| {
+ ParserError::ParseBigInt(self.line_num, self.col_num)
+ })
+ })
+ } else {
+ Err(e)
+ }
+ })
+ } else if c == 'o' {
+ self.octal_constant(c).or_else(|e| {
+ if let ParserError::ParseBigInt(..) = e {
+ token
+ .parse::<i64>()
+ .map(|n| {
+ Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
+ })
+ .or_else(|_| {
+ token
+ .parse::<Integer>()
+ .map(|n| {
+ Token::Literal(Literal::Integer(arena_alloc!(
+ n,
+ &mut self.machine_st.arena
+ )))
+ })
+ .map_err(|_| {
+ ParserError::ParseBigInt(self.line_num, self.col_num)
+ })
+ })
+ } else {
+ Err(e)
+ }
+ })
+ } else if c == 'b' {
+ self.binary_constant(c).or_else(|e| {
+ if let ParserError::ParseBigInt(..) = e {
+ token
+ .parse::<i64>()
+ .map(|n| {
+ Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
+ })
+ .or_else(|_| {
+ token
+ .parse::<Integer>()
+ .map(|n| {
+ Token::Literal(Literal::Integer(arena_alloc!(
+ n,
+ &mut self.machine_st.arena
+ )))
+ })
+ .map_err(|_| {
+ ParserError::ParseBigInt(self.line_num, self.col_num)
+ })
+ })
+ } else {
+ Err(e)
+ }
+ })
+ } else if single_quote_char!(c) {
+ self.skip_char(c);
+ let c = self.lookahead_char()?;
+
+ if backslash_char!(c) {
self.skip_char(c);
let c = self.lookahead_char()?;
- if backslash_char!(c) {
+ if new_line_char!(c) {
self.skip_char(c);
- let c = self.lookahead_char()?;
+ self.return_char('\'');
- if new_line_char!(c) {
- self.skip_char(c);
- self.return_char('\'');
+ return Ok(Token::Literal(Literal::Fixnum(Fixnum::build_with(0))));
+ } else {
+ self.return_char('\\');
+ }
+ }
- return Ok(Token::Literal(Literal::Fixnum(Fixnum::build_with(0))));
- } else {
- self.return_char('\\');
+ self.get_single_quoted_char()
+ .map(|c| Token::Literal(Literal::Fixnum(Fixnum::build_with(c as i64))))
+ .or_else(|err| {
+ match err {
+ ParserError::UnexpectedChar('\'', ..) => {}
+ err => return Err(err),
}
- }
- self.get_single_quoted_char()
- .map(|c| Token::Literal(Literal::Fixnum(Fixnum::build_with(c as i64))))
- .or_else(|err| {
- match err {
- ParserError::UnexpectedChar('\'', ..) => {}
- err => return Err(err),
- }
+ self.return_char(c);
- self.return_char(c);
-
- i64::from_str_radix(&token, 10)
- .map(|n| {
- Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
- })
- .or_else(|_| {
- token
- .parse::<Integer>()
- .map(|n| {
- Token::Literal(Literal::Integer(arena_alloc!(
- n,
- &mut self.machine_st.arena
- )))
- })
- .map_err(|_| {
- ParserError::ParseBigInt(self.line_num, self.col_num)
- })
- })
- })
- } else {
- i64::from_str_radix(&token, 10)
- .map(|n| Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena)))
- .or_else(|_| {
- token
- .parse::<Integer>()
- .map(|n| {
- Token::Literal(Literal::Integer(arena_alloc!(
- n,
- &mut self.machine_st.arena
- )))
- })
- .map_err(|_| ParserError::ParseBigInt(self.line_num, self.col_num))
- })
- }
+ token
+ .parse::<i64>()
+ .map(|n| {
+ Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
+ })
+ .or_else(|_| {
+ token
+ .parse::<Integer>()
+ .map(|n| {
+ Token::Literal(Literal::Integer(arena_alloc!(
+ n,
+ &mut self.machine_st.arena
+ )))
+ })
+ .map_err(|_| {
+ ParserError::ParseBigInt(self.line_num, self.col_num)
+ })
+ })
+ })
} else {
- i64::from_str_radix(&token, 10)
+ token
+ .parse::<i64>()
.map(|n| Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena)))
.or_else(|_| {
token
.map_err(|_| ParserError::ParseBigInt(self.line_num, self.col_num))
})
}
+ } else {
+ token
+ .parse::<i64>()
+ .map(|n| Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena)))
+ .or_else(|_| {
+ token
+ .parse::<Integer>()
+ .map(|n| {
+ Token::Literal(Literal::Integer(arena_alloc!(
+ n,
+ &mut self.machine_st.arena
+ )))
+ })
+ .map_err(|_| ParserError::ParseBigInt(self.line_num, self.col_num))
+ })
}
}
c: Option<char>,
layout_info: &mut LayoutInfo,
) -> Result<(), ParserError> {
+ #[allow(clippy::redundant_guards)]
match c {
Some(c) if layout_char!(c) => {
self.skip_char(c);
#[macro_export]
macro_rules! decimal_digit_char {
($c: expr) => {
- ('0'..='9').contains(&$c)
+ $c.is_ascii_digit()
};
}
#[macro_export]
macro_rules! hexadecimal_digit_char {
($c: expr) => {
- ('0'..='9').contains(&$c) || ('A'..='F').contains(&$c) || ('a'..='f').contains(&$c)
+ $c.is_ascii_digit() || ('A'..='F').contains(&$c) || ('a'..='f').contains(&$c)
};
}
#[macro_use]
pub mod macros;
pub mod lexer;
+#[allow(clippy::module_inception)]
pub mod parser;
Token::End => TokenType::End,
};
- self.stack.push(TokenDesc { tt, priority, spec, unfold_bounds: 0, });
+ self.stack.push(TokenDesc {
+ tt,
+ priority,
+ spec,
+ unfold_bounds: 0,
+ });
}
fn reduce_op(&mut self, priority: usize) {
if let Some(desc1) = self.stack.pop() {
if let Some(desc2) = self.stack.pop() {
if let Some(desc3) = self.stack.pop() {
- if is_xfx!(desc2.spec) && affirm_xfx(priority, desc2, desc3, desc1) {
- self.push_binary_op(desc2, LTERM);
- continue;
- } else if is_yfx!(desc2.spec) && affirm_yfx(priority, desc2, desc3, desc1) {
+ if is_xfx!(desc2.spec) && affirm_xfx(priority, desc2, desc3, desc1)
+ || is_yfx!(desc2.spec) && affirm_yfx(priority, desc2, desc3, desc1)
+ {
self.push_binary_op(desc2, LTERM);
continue;
} else if is_xfy!(desc2.spec) && affirm_xfy(priority, desc2, desc3, desc1) {
if self.stack.len() > 2 * arity {
let idx = self.stack.len() - 2 * arity - 1;
- if is_infix!(self.stack[idx].spec) && idx > 0 {
- if !is_op!(self.stack[idx - 1].spec) && !self.stack[idx - 1].tt.is_sep() {
- return false;
- }
+ if is_infix!(self.stack[idx].spec)
+ && idx > 0
+ && !is_op!(self.stack[idx - 1].spec)
+ && !self.stack[idx - 1].tt.is_sep()
+ {
+ return false;
}
} else {
return false;
let stack_len = self.stack.len() - 2 * arity - 1;
let idx = self.terms.len() - arity;
- if TokenType::Term == self.stack[stack_len].tt {
- if atomize_term(&self.lexer.machine_st.atom_tbl, &self.terms[idx - 1]).is_some() {
- self.stack.truncate(stack_len + 1);
-
- let mut subterms: Vec<_> = self.terms.drain(idx..).collect();
+ if TokenType::Term == self.stack[stack_len].tt
+ && atomize_term(&self.lexer.machine_st.atom_tbl, &self.terms[idx - 1]).is_some()
+ {
+ self.stack.truncate(stack_len + 1);
- if let Some(name) = self
- .terms
- .pop()
- .and_then(|t| atomize_term(&self.lexer.machine_st.atom_tbl, &t))
- {
- // reduce the '.' functor to a cons cell if it applies.
- if name == atom!(".") && subterms.len() == 2 {
- let tail = subterms.pop().unwrap();
- let head = subterms.pop().unwrap();
-
- self.terms.push(match as_partial_string(head, tail) {
- Ok((string_buf, Some(tail))) => {
- Term::PartialString(Cell::default(), string_buf, tail)
- }
- Ok((string_buf, None)) => {
- let atom = AtomTable::build_with(
- &self.lexer.machine_st.atom_tbl,
- &string_buf,
- );
- Term::CompleteString(Cell::default(), atom)
- }
- Err(term) => term,
- });
- } else {
- self.terms
- .push(Term::Clause(Cell::default(), name, subterms));
- }
+ let mut subterms: Vec<_> = self.terms.drain(idx..).collect();
- if let Some(&mut TokenDesc {
- ref mut tt,
- ref mut priority,
- ref mut spec,
- ref mut unfold_bounds,
- }) = self.stack.last_mut()
- {
- if *spec == BTERM {
- return false;
+ if let Some(name) = self
+ .terms
+ .pop()
+ .and_then(|t| atomize_term(&self.lexer.machine_st.atom_tbl, &t))
+ {
+ // reduce the '.' functor to a cons cell if it applies.
+ if name == atom!(".") && subterms.len() == 2 {
+ let tail = subterms.pop().unwrap();
+ let head = subterms.pop().unwrap();
+
+ self.terms.push(match as_partial_string(head, tail) {
+ Ok((string_buf, Some(tail))) => {
+ Term::PartialString(Cell::default(), string_buf, tail)
}
+ Ok((string_buf, None)) => {
+ let atom =
+ AtomTable::build_with(&self.lexer.machine_st.atom_tbl, &string_buf);
+ Term::CompleteString(Cell::default(), atom)
+ }
+ Err(term) => term,
+ });
+ } else {
+ self.terms
+ .push(Term::Clause(Cell::default(), name, subterms));
+ }
- *tt = TokenType::Term;
- *priority = 0;
- *spec = TERM;
- *unfold_bounds = 0;
+ if let Some(&mut TokenDesc {
+ ref mut tt,
+ ref mut priority,
+ ref mut spec,
+ ref mut unfold_bounds,
+ }) = self.stack.last_mut()
+ {
+ if *spec == BTERM {
+ return false;
}
- return true;
+ *tt = TokenType::Term;
+ *priority = 0;
+ *spec = TERM;
+ *unfold_bounds = 0;
}
+
+ return true;
}
}
/* '|' is a head-tail separator here, not
* an operator, so expand the
* terms it compacted out again. */
- match (term.name(), term.arity()) {
- (Some(name), 2) if name == atom!(",") => {
- let terms = if op_desc.unfold_bounds == 0 {
- unfold_by_str(term, atom!(","))
- } else {
- let mut terms = vec![];
+ if let (Some(atom!(",")), 2) = (term.name(), term.arity()) {
+ let terms = if op_desc.unfold_bounds == 0 {
+ unfold_by_str(term, atom!(","))
+ } else {
+ let mut terms = vec![];
- while let Some((fst, snd)) = unfold_by_str_once(&mut term, atom!(",")) {
- terms.push(fst);
- term = snd;
+ while let Some((fst, snd)) = unfold_by_str_once(&mut term, atom!(",")) {
+ terms.push(fst);
+ term = snd;
- op_desc.unfold_bounds -= 2;
+ op_desc.unfold_bounds -= 2;
- if op_desc.unfold_bounds == 0 {
- break;
- }
+ if op_desc.unfold_bounds == 0 {
+ break;
}
+ }
- terms.push(term);
- terms
- };
+ terms.push(term);
+ terms
+ };
- let arity = terms.len() - 1;
+ let arity = terms.len() - 1;
- self.terms.extend(terms.into_iter());
- return arity;
- }
- _ => {}
+ self.terms.extend(terms);
+ return arity;
}
}
} else {
return None;
}
- } else {
- if desc.tt == TokenType::HeadTailSeparator {
- if arity == 1 {
- continue;
- }
-
- return None;
- } else if desc.tt == TokenType::OpenList {
- return Some(arity);
- } else if desc.tt != TokenType::Comma {
- return None;
+ } else if desc.tt == TokenType::HeadTailSeparator {
+ if arity == 1 {
+ continue;
}
+ return None;
+ } else if desc.tt == TokenType::OpenList {
+ return Some(arity);
+ } else if desc.tt != TokenType::Comma {
+ return None;
}
}
.push(Term::Literal(Cell::default(), Literal::Atom(atom)));
}
- self.stack[idx].spec = if self.stack[idx].priority > 0 { TERM } else { BTERM };
+ self.stack[idx].spec = if self.stack[idx].priority > 0 {
+ TERM
+ } else {
+ BTERM
+ };
self.stack[idx].tt = TokenType::Term;
self.stack[idx].priority = 0;
Token::Open => self.shift(Token::Open, 1300, DELIMITER),
Token::OpenCT => self.shift(Token::OpenCT, 1300, DELIMITER),
Token::Close => {
- if !self.reduce_term() {
- if !self.reduce_brackets() {
- return Err(ParserError::IncompleteReduction(
- self.lexer.line_num,
- self.lexer.col_num,
- ));
- }
+ if !self.reduce_term() && !self.reduce_brackets() {
+ return Err(ParserError::IncompleteReduction(
+ self.lexer.line_num,
+ self.lexer.col_num,
+ ));
}
}
Token::OpenList => self.shift(Token::OpenList, 1300, DELIMITER),
}
}
+ #[allow(clippy::new_without_default)]
pub fn new() -> Self {
let mut block = Self::empty_block();
} else {
let allocated = (*self.ptr.get()) as usize - self.base as usize;
self.base.copy_to(new_block.base.cast_mut(), allocated);
- *new_block.ptr.get_mut() = new_block.base.offset(allocated as isize).cast_mut();
+ *new_block.ptr.get_mut() = new_block.base.add(allocated).cast_mut();
Some(new_block)
}
}
ptr::NonNull,
sync::{
atomic::{AtomicPtr, AtomicU8},
- Arc, Weak, RwLock
+ Arc, RwLock, Weak,
},
};
// register the current threads epoch counter on init
EPOCH_COUNTERS
.write()
- .unwrap()
+ .unwrap()
.push(Arc::downgrade(&epoch_counter));
epoch_counter
});
type SubtermDeque = VecDeque<(usize, usize)>;
-pub(crate) fn devour_whitespace<'a, R: CharRead>(
- parser: &mut Parser<'a, R>,
+pub(crate) fn devour_whitespace<R: CharRead>(
+ parser: &mut Parser<'_, R>,
) -> Result<bool, ParserError> {
match parser.lexer.scan_for_layout() {
Err(e) if e.is_unexpected_eof() => Ok(true),
static mut PROMPT: bool = false;
#[cfg(feature = "repl")]
-const HISTORY_FILE: &'static str = ".scryer_history";
+const HISTORY_FILE: &str = ".scryer_history";
pub(crate) fn set_prompt(value: bool) {
unsafe {
ReadlineStream {
rl,
pending_input: CharReader::new(Cursor::new(pending_input.to_owned())),
- add_history: add_history,
+ add_history,
}
}
{
ReadlineStream {
pending_input: CharReader::new(Cursor::new(pending_input.to_owned())),
- add_history: add_history,
+ add_history,
}
}
}
PROMPT = false;
}
- if self.pending_input.get_ref().get_ref().chars().last() != Some('\n') {
+ if !self.pending_input.get_ref().get_ref().ends_with('\n') {
*self.pending_input.get_mut().get_mut() += "\n";
}
}
}
#[inline]
-pub(crate) fn write_term_to_heap<'a, 'b>(
- term: &'a Term,
- heap: &'b mut Heap,
+pub(crate) fn write_term_to_heap(
+ term: &Term,
+ heap: &mut Heap,
atom_tbl: &AtomTable,
) -> Result<TermWriteResult, CompilationError> {
let term_writer = TermWriter::new(heap, atom_tbl);
match term {
&TermRef::Cons(..) => list_loc_as_cell!(h),
&TermRef::AnonVar(_) | &TermRef::Var(..) => heap_loc_as_cell!(h),
- &TermRef::CompleteString(_, _, ref src) => {
+ TermRef::CompleteString(_, _, src) => {
if src.as_str().is_empty() {
empty_list_as_cell!()
} else if self.heap[h].get_tag() == HeapCellValueTag::CStr {
}
&TermRef::PartialString(..) => pstr_loc_as_cell!(h),
&TermRef::Literal(_, _, literal) => HeapCellValue::from(*literal),
- &TermRef::Clause(_, _, _, subterms) if subterms.len() == 0 => heap_loc_as_cell!(h),
+ &TermRef::Clause(_, _, _, subterms) if subterms.is_empty() => heap_loc_as_cell!(h),
&TermRef::Clause(..) => str_loc_as_cell!(h),
}
}
return Err(CompilationError::ExceededMaxArity);
}
- self.heap.push(if subterms.len() == 0 {
+ self.heap.push(if subterms.is_empty() {
heap_loc_as_cell!(heap_loc + 1)
} else {
str_loc_as_cell!(heap_loc + 1)
continue;
}
- &TermRef::CompleteString(_, _, ref src) => {
+ TermRef::CompleteString(_, _, src) => {
let src = src.as_str().to_owned();
put_complete_string(self.heap, &src, self.atom_tbl);
}
- &TermRef::PartialString(lvl, _, ref src, _) => {
+ &TermRef::PartialString(lvl, _, src, _) => {
if let Level::Root = lvl {
// Var tags can't refer directly to partial strings,
// so a PStrLoc cell must be pushed.
continue;
}
}
- &TermRef::Var(.., ref var) => {
+ TermRef::Var(.., var) => {
if let Some((arity, site_h)) = self.queue.pop_front() {
let var_key = VarKey::VarPtr(var.clone());
}
fn is_void_instr(instr: &Instruction) -> bool {
- match instr {
- &Instruction::UnifyVoid(_) => true,
- _ => false,
- }
+ matches!(instr, &Instruction::UnifyVoid(_))
}
fn to_pstr(lvl: Level, string: Atom, r: RegType, has_tail: bool) -> Instruction {
}
fn incr_void_instr(instr: &mut Instruction) {
- match instr {
- &mut Instruction::UnifyVoid(ref mut incr) => *incr += 1,
- _ => {}
+ if let &mut Instruction::UnifyVoid(ref mut incr) = instr {
+ *incr += 1
}
}
}
fn is_void_instr(instr: &Instruction) -> bool {
- match instr {
- &Instruction::SetVoid(_) => true,
- _ => false,
- }
+ matches!(instr, &Instruction::SetVoid(_))
}
fn incr_void_instr(instr: &mut Instruction) {
- match instr {
- &mut Instruction::SetVoid(ref mut incr) => *incr += 1,
- _ => {}
+ if let &mut Instruction::SetVoid(ref mut incr) = instr {
+ *incr += 1
}
}
BlackboardOffset(Atom, HeapCellValue), // key atom, key value
}
+#[allow(clippy::enum_variant_names)]
#[derive(BitfieldSpecifier, Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[bits = 6]
pub(crate) enum TrailEntryTag {
}
}
-impl<'a> From<(Number, &mut Arena)> for HeapCellValue {
+impl From<(Number, &mut Arena)> for HeapCellValue {
#[inline(always)]
fn from((n, arena): (Number, &mut Arena)) -> HeapCellValue {
use ordered_float::OrderedFloat;
#[inline]
pub fn is_ref(self) -> bool {
- match self.get_tag() {
+ matches!(
+ self.get_tag(),
HeapCellValueTag::Str
- | HeapCellValueTag::Lis
- | HeapCellValueTag::Var
- | HeapCellValueTag::StackVar
- | HeapCellValueTag::AttrVar
- | HeapCellValueTag::PStrLoc
- | HeapCellValueTag::PStrOffset => true,
- _ => false,
- }
+ | HeapCellValueTag::Lis
+ | HeapCellValueTag::Var
+ | HeapCellValueTag::StackVar
+ | HeapCellValueTag::AttrVar
+ | HeapCellValueTag::PStrLoc
+ | HeapCellValueTag::PStrOffset
+ )
}
#[inline]
#[inline]
pub fn get_value(self) -> u64 {
- self.val() as u64
+ self.val()
}
#[inline]
#[inline]
pub fn payload_offset(self) -> *const u8 {
- unsafe {
- self.get_ptr()
- .offset(mem::size_of::<ArenaHeader>() as isize)
- }
+ unsafe { self.get_ptr().add(mem::size_of::<ArenaHeader>()) }
}
#[inline]
| tag @ HeapCellValueTag::PStrLoc
| tag @ HeapCellValueTag::Var
| tag @ HeapCellValueTag::AttrVar => {
- HeapCellValue::build_with(tag, self.get_value() + rhs.abs() as u64)
+ HeapCellValue::build_with(tag, self.get_value() + rhs.unsigned_abs())
}
_ => self,
}
#[inline]
pub(crate) fn pending(&self) -> bool {
- match self {
- &PermVarAllocation::Pending => true,
- _ => false,
- }
+ matches!(self, &PermVarAllocation::Pending)
}
}
impl VarAlloc {
#[inline]
pub(crate) fn as_reg_type(&self) -> RegType {
- match self {
- &VarAlloc::Temp { temp_reg, .. } => RegType::Temp(temp_reg),
- &VarAlloc::Perm(r, _) => RegType::Perm(r),
+ match *self {
+ VarAlloc::Temp { temp_reg, .. } => RegType::Temp(temp_reg),
+ VarAlloc::Perm(r, _) => RegType::Perm(r),
}
}
}
}
- return false;
+ false
}
pub(crate) fn populate_conflict_set(&mut self) {
IndexMap::new();
for (var_gen_index, record) in self.0.iter_mut().enumerate() {
- match &mut record.allocation {
- VarAlloc::Temp { temp_var_data, .. } => {
- let use_set = std::mem::replace(
- &mut temp_var_data.use_set,
- IndexSet::with_hasher(FxBuildHasher::default()),
- );
-
- use_sets.insert(var_gen_index, use_set);
- }
- _ => {}
+ if let VarAlloc::Temp { temp_var_data, .. } = &mut record.allocation {
+ let use_set = std::mem::replace(
+ &mut temp_var_data.use_set,
+ IndexSet::with_hasher(FxBuildHasher::default()),
+ );
+
+ use_sets.insert(var_gen_index, use_set);
}
}
for &(term_loc, reg) in &use_set {
if let GenContext::Last(cn_u) = term_loc {
for (var_gen_index, record) in self.0.iter_mut().enumerate() {
- match &mut record.allocation {
- VarAlloc::Temp {
- term_loc,
- temp_var_data,
- ..
- } => {
- if cn_u == term_loc.chunk_num() && u != var_gen_index {
- if !temp_var_data.uses_reg(reg) {
- temp_var_data.no_use_set.insert(reg);
- }
- }
+ if let VarAlloc::Temp {
+ term_loc,
+ temp_var_data,
+ ..
+ } = &mut record.allocation
+ {
+ if cn_u == term_loc.chunk_num()
+ && u != var_gen_index
+ && !temp_var_data.uses_reg(reg)
+ {
+ temp_var_data.no_use_set.insert(reg);
}
- _ => {}
}
}
}
#[test]
fn occurs_check_flag() {
run_top_level_test_with_args(
- &["tests-pl/issue841-occurs-check.pl"],
+ ["tests-pl/issue841-occurs-check.pl"],
"\
f(X, X).\n\
halt.\n\
// issue #839
#[test]
fn op3() {
- run_top_level_test_with_args(&["tests-pl/issue839-op3.pl", "-g", "halt"], "", "")
+ run_top_level_test_with_args(["tests-pl/issue839-op3.pl", "-g", "halt"], "", "")
}
// issue #820
#[test]
fn multiple_goals() {
run_top_level_test_with_args(
- &["-g", "test", "-g", "halt", "tests-pl/issue820-goals.pl"],
+ ["-g", "test", "-g", "halt", "tests-pl/issue820-goals.pl"],
"",
"helloworld\n",
);
#[test]
fn compound_goal() {
run_top_level_test_with_args(
- &["-g", "test,halt", "tests-pl/issue820-goals.pl"],
+ ["-g", "test,halt", "tests-pl/issue820-goals.pl"],
"",
"helloworld\n",
)
#[test]
fn setup_call_cleanup_process() {
run_top_level_test_with_args(
- &["src/tests/setup_call_cleanup.pl", "-f", "-g", "halt"],
+ ["src/tests/setup_call_cleanup.pl", "-f", "-g", "halt"],
"",
"1+21+31+2>A+B1+G1+2>41+2>B1+2>31+2>31+2>4ba",
);
#[test]
fn dif_tests() {
run_top_level_test_with_args(
- &["src/tests/dif.pl", "-f", "-g", "main_quiet"],
+ ["src/tests/dif.pl", "-f", "-g", "main_quiet"],
"",
"All tests passed",
);
#[test]
fn ground_tests() {
run_top_level_test_with_args(
- &["src/tests/ground.pl", "-f", "-g", "main_quiet"],
+ ["src/tests/ground.pl", "-f", "-g", "main_quiet"],
"",
"All tests passed",
);
#[test]
fn term_variables_tests() {
run_top_level_test_with_args(
- &["src/tests/term_variables.pl", "-f", "-g", "main_quiet"],
+ ["src/tests/term_variables.pl", "-f", "-g", "main_quiet"],
"",
"All tests passed",
);
#[test]
fn acyclic_term_tests() {
run_top_level_test_with_args(
- &["src/tests/acyclic_term.pl", "-f", "-g", "main_quiet"],
+ ["src/tests/acyclic_term.pl", "-f", "-g", "main_quiet"],
"",
"All tests passed",
);
projects / scryer-prolog.git / commitdiff