using use declarations in main.rs so that use paths don't need to be updated as well, this will be done in a later commit
for entry in entries.filter_map(Result::ok).map(|e| e.path()) {
if entry.is_dir() {
if let Some(file_name) = entry.file_name() {
- let new_prefix =
- prefix.to_owned() + file_name.to_str().unwrap() + "/";
+ let new_prefix = prefix.to_owned() + file_name.to_str().unwrap() + "/";
find_prolog_files(libraries, &new_prefix, &entry);
}
} else if entry.is_file() {
let ext = std::ffi::OsStr::new("pl");
if entry.extension() == Some(ext) {
- let contain =
- String::from_utf8(fs::read(&entry).unwrap()).unwrap();
+ let contain = String::from_utf8(fs::read(&entry).unwrap()).unwrap();
let name = entry.file_stem().unwrap().to_str().unwrap();
let line = format!(
libraries
.write_all(
- b"ref_thread_local! {
+ b"ref_thread_local::ref_thread_local! {
pub static managed LIBRARIES: IndexMap<&'static str, &'static str> = {
let mut m = IndexMap::new();\n",
)
use crate::prolog_parser_rebis::ast::*;
+use crate::prolog_parser_rebis::temp_v;
use crate::fixtures::*;
use crate::forms::*;
fn mark_anon_var<Target>(&mut self, _: Level, _: GenContext, _: &mut Vec<Target>)
where
Target: CompilationTarget<'a>;
- fn mark_non_var<Target>(&mut self, _: Level, _: GenContext, _: &'a Cell<RegType>, _: &mut Vec<Target>)
- where
+ fn mark_non_var<Target>(
+ &mut self,
+ _: Level,
+ _: GenContext,
+ _: &'a Cell<RegType>,
+ _: &mut Vec<Target>,
+ ) where
Target: CompilationTarget<'a>;
fn mark_reserved_var<Target>(
&mut self,
_: bool,
) where
Target: CompilationTarget<'a>;
- fn mark_var<Target>(&mut self, _: Rc<Var>, _: Level, _: &'a Cell<VarReg>, _: GenContext, _: &mut Vec<Target>)
- where
+ fn mark_var<Target>(
+ &mut self,
+ _: Rc<Var>,
+ _: Level,
+ _: &'a Cell<VarReg>,
+ _: GenContext,
+ _: &mut Vec<Target>,
+ ) where
Target: CompilationTarget<'a>;
fn reset(&mut self);
fn drain_var_data(
&mut self,
vs: VariableFixtures<'a>,
- num_of_chunks: usize
+ num_of_chunks: usize,
) -> VariableFixtures<'a> {
let mut perm_vs = VariableFixtures::new();
use crate::prolog_parser_rebis::ast::*;
+use crate::prolog_parser_rebis::{atom, clause_name};
use crate::clause_types::*;
use crate::fixtures::*;
fn push_constant(&mut self, c: &Constant) -> Result<(), ArithmeticError> {
match c {
- &Constant::Fixnum(n) => self
- .interm
- .push(ArithmeticTerm::Number(Number::Fixnum(n))),
+ &Constant::Fixnum(n) => self.interm.push(ArithmeticTerm::Number(Number::Fixnum(n))),
&Constant::Integer(ref n) => self
.interm
.push(ArithmeticTerm::Number(Number::Integer(n.clone()))),
// integer division rounding function -- 9.1.3.1.
pub fn rnd_i<'a>(n: &'a Number) -> RefOrOwned<'a, Number> {
match n {
- &Number::Integer(_) => {
- RefOrOwned::Borrowed(n)
- }
- &Number::Float(OrderedFloat(f)) => {
- RefOrOwned::Owned(Number::from(
- Integer::from_f64(f.floor()).unwrap_or_else(|| Integer::from(0))
- ))
- }
- &Number::Fixnum(n) => {
- RefOrOwned::Owned(Number::from(n))
- }
+ &Number::Integer(_) => RefOrOwned::Borrowed(n),
+ &Number::Float(OrderedFloat(f)) => RefOrOwned::Owned(Number::from(
+ Integer::from_f64(f.floor()).unwrap_or_else(|| Integer::from(0)),
+ )),
+ &Number::Fixnum(n) => RefOrOwned::Owned(Number::from(n)),
&Number::Rational(ref r) => {
let r_ref = r.fract_floor_ref();
let (mut fract, mut floor) = (Rational::new(), Integer::new());
Number::from(Integer::from(n1) + Integer::from(n2))
})
}
- (Number::Fixnum(n1), Number::Integer(n2)) |
- (Number::Integer(n2), Number::Fixnum(n1)) => {
+ (Number::Fixnum(n1), Number::Integer(n2))
+ | (Number::Integer(n2), Number::Fixnum(n1)) => {
Ok(Number::from(Integer::from(n1) + &*n2))
}
- (Number::Fixnum(n1), Number::Rational(n2)) |
- (Number::Rational(n2), Number::Fixnum(n1)) => {
+ (Number::Fixnum(n1), Number::Rational(n2))
+ | (Number::Rational(n2), Number::Fixnum(n1)) => {
Ok(Number::from(Rational::from(n1) + &*n2))
}
- (Number::Fixnum(n1), Number::Float(OrderedFloat(n2))) |
- (Number::Float(OrderedFloat(n2)), Number::Fixnum(n1)) => {
+ (Number::Fixnum(n1), Number::Float(OrderedFloat(n2)))
+ | (Number::Float(OrderedFloat(n2)), Number::Fixnum(n1)) => {
Ok(Number::Float(add_f(float_fn_to_f(n1)?, n2)?))
}
(Number::Integer(n1), Number::Integer(n2)) => {
Ok(Number::from(Integer::from(&*n1) + &*n2)) // add_i
}
(Number::Integer(n1), Number::Float(OrderedFloat(n2)))
- | (Number::Float(OrderedFloat(n2)), Number::Integer(n1)) => {
+ | (Number::Float(OrderedFloat(n2)), Number::Integer(n1)) => {
Ok(Number::Float(add_f(float_i_to_f(&n1)?, n2)?))
}
(Number::Integer(n1), Number::Rational(n2))
- | (Number::Rational(n2), Number::Integer(n1)) => {
+ | (Number::Rational(n2), Number::Integer(n1)) => {
Ok(Number::from(Rational::from(&*n1) + &*n2))
}
(Number::Rational(n1), Number::Float(OrderedFloat(n2)))
- | (Number::Float(OrderedFloat(n2)), Number::Rational(n1)) => {
+ | (Number::Float(OrderedFloat(n2)), Number::Rational(n1)) => {
Ok(Number::Float(add_f(float_r_to_f(&n1)?, n2)?))
}
(Number::Float(OrderedFloat(f1)), Number::Float(OrderedFloat(f2))) => {
fn neg(self) -> Self::Output {
match self {
- Number::Fixnum(n) =>
+ Number::Fixnum(n) => {
if let Some(n) = n.checked_neg() {
Number::Fixnum(n)
} else {
Number::from(-Integer::from(n))
}
+ }
Number::Integer(n) => Number::Integer(Rc::new(-Integer::from(&*n))),
Number::Float(OrderedFloat(f)) => Number::Float(OrderedFloat(-f)),
Number::Rational(r) => Number::Rational(Rc::new(-Rational::from(&*r))),
Number::from(Integer::from(n1) * Integer::from(n2))
})
}
- (Number::Fixnum(n1), Number::Integer(n2)) |
- (Number::Integer(n2), Number::Fixnum(n1)) => {
+ (Number::Fixnum(n1), Number::Integer(n2))
+ | (Number::Integer(n2), Number::Fixnum(n1)) => {
Ok(Number::from(Integer::from(n1) * &*n2))
}
- (Number::Fixnum(n1), Number::Rational(n2)) |
- (Number::Rational(n2), Number::Fixnum(n1)) => {
+ (Number::Fixnum(n1), Number::Rational(n2))
+ | (Number::Rational(n2), Number::Fixnum(n1)) => {
Ok(Number::from(Rational::from(n1) * &*n2))
}
- (Number::Fixnum(n1), Number::Float(OrderedFloat(n2))) |
- (Number::Float(OrderedFloat(n2)), Number::Fixnum(n1)) => {
+ (Number::Fixnum(n1), Number::Float(OrderedFloat(n2)))
+ | (Number::Float(OrderedFloat(n2)), Number::Fixnum(n1)) => {
Ok(Number::Float(mul_f(float_fn_to_f(n1)?, n2)?))
}
(Number::Integer(n1), Number::Integer(n2)) => {
fn div(self, rhs: Number) -> Self::Output {
match (self, rhs) {
- (Number::Fixnum(n1), Number::Fixnum(n2)) => {
- Ok(Number::Float(div_f(
- float_fn_to_f(n1)?,
- float_fn_to_f(n2)?,
- )?))
- }
- (Number::Fixnum(n1), Number::Integer(n2)) => {
- Ok(Number::Float(div_f(
- float_fn_to_f(n1)?,
- float_i_to_f(&n2)?,
- )?))
- }
- (Number::Integer(n1), Number::Fixnum(n2)) => {
- Ok(Number::Float(div_f(
- float_i_to_f(&n1)?,
- float_fn_to_f(n2)?,
- )?))
- }
- (Number::Fixnum(n1), Number::Rational(n2)) => {
- Ok(Number::Float(div_f(
- float_fn_to_f(n1)?,
- float_r_to_f(&n2)?,
- )?))
- }
- (Number::Rational(n1), Number::Fixnum(n2)) => {
- Ok(Number::Float(div_f(
- float_r_to_f(&n1)?,
- float_fn_to_f(n2)?,
- )?))
- }
+ (Number::Fixnum(n1), Number::Fixnum(n2)) => Ok(Number::Float(div_f(
+ float_fn_to_f(n1)?,
+ float_fn_to_f(n2)?,
+ )?)),
+ (Number::Fixnum(n1), Number::Integer(n2)) => Ok(Number::Float(div_f(
+ float_fn_to_f(n1)?,
+ float_i_to_f(&n2)?,
+ )?)),
+ (Number::Integer(n1), Number::Fixnum(n2)) => Ok(Number::Float(div_f(
+ float_i_to_f(&n1)?,
+ float_fn_to_f(n2)?,
+ )?)),
+ (Number::Fixnum(n1), Number::Rational(n2)) => Ok(Number::Float(div_f(
+ float_fn_to_f(n1)?,
+ float_r_to_f(&n2)?,
+ )?)),
+ (Number::Rational(n1), Number::Fixnum(n2)) => Ok(Number::Float(div_f(
+ float_r_to_f(&n1)?,
+ float_fn_to_f(n2)?,
+ )?)),
(Number::Fixnum(n1), Number::Float(OrderedFloat(n2))) => {
- Ok(Number::Float(div_f(
- float_fn_to_f(n1)?,
- n2,
- )?))
+ Ok(Number::Float(div_f(float_fn_to_f(n1)?, n2)?))
}
(Number::Float(OrderedFloat(n1)), Number::Fixnum(n2)) => {
- Ok(Number::Float(div_f(
- n1,
- float_fn_to_f(n2)?,
- )?))
- }
- (Number::Integer(n1), Number::Integer(n2)) => {
- Ok(Number::Float(div_f(
- float_i_to_f(&n1)?,
- float_i_to_f(&n2)?,
- )?))
+ Ok(Number::Float(div_f(n1, float_fn_to_f(n2)?)?))
}
+ (Number::Integer(n1), Number::Integer(n2)) => Ok(Number::Float(div_f(
+ float_i_to_f(&n1)?,
+ float_i_to_f(&n2)?,
+ )?)),
(Number::Integer(n1), Number::Float(OrderedFloat(n2))) => {
Ok(Number::Float(div_f(float_i_to_f(&n1)?, n2)?))
}
(Number::Float(OrderedFloat(n2)), Number::Integer(n1)) => {
Ok(Number::Float(div_f(n2, float_i_to_f(&n1)?)?))
}
- (Number::Integer(n1), Number::Rational(n2)) => {
- Ok(Number::Float(div_f(
- float_i_to_f(&n1)?,
- float_r_to_f(&n2)?,
- )?))
- }
- (Number::Rational(n2), Number::Integer(n1)) => {
- Ok(Number::Float(div_f(
- float_r_to_f(&n2)?,
- float_i_to_f(&n1)?,
- )?))
- }
+ (Number::Integer(n1), Number::Rational(n2)) => Ok(Number::Float(div_f(
+ float_i_to_f(&n1)?,
+ float_r_to_f(&n2)?,
+ )?)),
+ (Number::Rational(n2), Number::Integer(n1)) => Ok(Number::Float(div_f(
+ float_r_to_f(&n2)?,
+ float_i_to_f(&n1)?,
+ )?)),
(Number::Rational(n1), Number::Float(OrderedFloat(n2))) => {
Ok(Number::Float(div_f(float_r_to_f(&n1)?, n2)?))
}
fn try_from((addr, heap): (Addr, &'a Heap)) -> Result<Number, Self::Error> {
match addr {
- Addr::Fixnum(n) => {
- Ok(Number::from(n))
- }
- Addr::Float(n) => {
- Ok(Number::Float(n))
- }
+ Addr::Fixnum(n) => Ok(Number::from(n)),
+ Addr::Float(n) => Ok(Number::Float(n)),
Addr::Usize(n) => {
if let Ok(n) = isize::try_from(n) {
Ok(Number::from(n))
Ok(Number::from(Integer::from(n)))
}
}
- Addr::Con(h) => {
- Number::try_from(&heap[h])
- }
- _ => {
- Err(())
- }
+ Addr::Con(h) => Number::try_from(&heap[h]),
+ _ => Err(()),
}
}
}
fn try_from(value: &'a HeapCellValue) -> Result<Number, Self::Error> {
match value {
- HeapCellValue::Addr(addr) => {
- match addr {
- &Addr::Fixnum(n) => {
+ HeapCellValue::Addr(addr) => match addr {
+ &Addr::Fixnum(n) => Ok(Number::from(n)),
+ &Addr::Float(n) => Ok(Number::Float(n)),
+ &Addr::Usize(n) => {
+ if let Ok(n) = isize::try_from(n) {
Ok(Number::from(n))
- }
- &Addr::Float(n) => {
- Ok(Number::Float(n))
- }
- &Addr::Usize(n) => {
- if let Ok(n) = isize::try_from(n) {
- Ok(Number::from(n))
- } else {
- Ok(Number::from(Integer::from(n)))
- }
- }
- _ => {
- Err(())
+ } else {
+ Ok(Number::from(Integer::from(n)))
}
}
- }
- HeapCellValue::Integer(n) => {
- Ok(Number::Integer(n.clone()))
- }
- HeapCellValue::Rational(n) => {
- Ok(Number::Rational(n.clone()))
- }
- _ => {
- Err(())
- }
+ _ => Err(()),
+ },
+ HeapCellValue::Integer(n) => Ok(Number::Integer(n.clone())),
+ HeapCellValue::Rational(n) => Ok(Number::Rational(n.clone())),
+ _ => Err(()),
}
}
}
use crate::prolog_parser_rebis::ast::*;
+use crate::prolog_parser_rebis::{clause_name, temp_v};
use crate::forms::Number;
use crate::machine::machine_indices::*;
use crate::rug::rand::RandState;
-use crate::ref_thread_local::RefThreadLocal;
+use crate::ref_thread_local::{ref_thread_local, RefThreadLocal};
use std::collections::BTreeMap;
&SystemClauseType::ClearAttributeGoals => clause_name!("$clear_attribute_goals"),
&SystemClauseType::CloneAttributeGoals => clause_name!("$clone_attribute_goals"),
&SystemClauseType::CodesToNumber => clause_name!("$codes_to_number"),
- &SystemClauseType::CopyTermWithoutAttrVars => clause_name!("$copy_term_without_attr_vars"),
+ &SystemClauseType::CopyTermWithoutAttrVars => {
+ clause_name!("$copy_term_without_attr_vars")
+ }
&SystemClauseType::CreatePartialString => clause_name!("$create_partial_string"),
&SystemClauseType::CurrentInput => clause_name!("$current_input"),
&SystemClauseType::CurrentHostname => clause_name!("$current_hostname"),
&SystemClauseType::WorkingDirectory => clause_name!("$working_directory"),
&SystemClauseType::PathCanonical => clause_name!("$path_canonical"),
&SystemClauseType::FileTime => clause_name!("$file_time"),
- &SystemClauseType::REPL(REPLCodePtr::AddDynamicPredicate) =>
- clause_name!("$add_dynamic_predicate"),
- &SystemClauseType::REPL(REPLCodePtr::AddGoalExpansionClause) =>
- clause_name!("$add_goal_expansion_clause"),
- &SystemClauseType::REPL(REPLCodePtr::AddTermExpansionClause) =>
- clause_name!("$add_term_expansion_clause"),
- &SystemClauseType::REPL(REPLCodePtr::ClauseToEvacuable) =>
- clause_name!("$clause_to_evacuable"),
- &SystemClauseType::REPL(REPLCodePtr::ConcludeLoad) =>
- clause_name!("$conclude_load"),
- &SystemClauseType::REPL(REPLCodePtr::DeclareModule) =>
- clause_name!("$declare_module"),
- &SystemClauseType::REPL(REPLCodePtr::LoadCompiledLibrary) =>
- clause_name!("$load_compiled_library"),
- &SystemClauseType::REPL(REPLCodePtr::PushLoadStatePayload) =>
- clause_name!("$push_load_state_payload"),
- &SystemClauseType::REPL(REPLCodePtr::Asserta) =>
- clause_name!("$asserta"),
- &SystemClauseType::REPL(REPLCodePtr::Assertz) =>
- clause_name!("$assertz"),
- &SystemClauseType::REPL(REPLCodePtr::Retract) =>
- clause_name!("$retract_clause"),
- &SystemClauseType::REPL(REPLCodePtr::UseModule) =>
- clause_name!("$use_module"),
- &SystemClauseType::REPL(REPLCodePtr::PushLoadContext) =>
- clause_name!("$push_load_context"),
- &SystemClauseType::REPL(REPLCodePtr::PopLoadContext) =>
- clause_name!("$pop_load_context"),
- &SystemClauseType::REPL(REPLCodePtr::PopLoadStatePayload) =>
- clause_name!("$pop_load_state_payload"),
- &SystemClauseType::REPL(REPLCodePtr::LoadContextSource) =>
- clause_name!("$prolog_lc_source"),
- &SystemClauseType::REPL(REPLCodePtr::LoadContextFile) =>
- clause_name!("$prolog_lc_file"),
- &SystemClauseType::REPL(REPLCodePtr::LoadContextDirectory) =>
- clause_name!("$prolog_lc_dir"),
- &SystemClauseType::REPL(REPLCodePtr::LoadContextModule) =>
- clause_name!("$prolog_lc_module"),
- &SystemClauseType::REPL(REPLCodePtr::LoadContextStream) =>
- clause_name!("$prolog_lc_stream"),
- &SystemClauseType::REPL(REPLCodePtr::MetaPredicateProperty) =>
- clause_name!("$cpp_meta_predicate_property"),
- &SystemClauseType::REPL(REPLCodePtr::BuiltInProperty) =>
- clause_name!("$cpp_built_in_property"),
- &SystemClauseType::REPL(REPLCodePtr::DynamicProperty) =>
- clause_name!("$cpp_dynamic_property"),
- &SystemClauseType::REPL(REPLCodePtr::MultifileProperty) =>
- clause_name!("$cpp_multifile_property"),
- &SystemClauseType::REPL(REPLCodePtr::DiscontiguousProperty) =>
- clause_name!("$cpp_discontiguous_property"),
- &SystemClauseType::REPL(REPLCodePtr::AbolishClause) =>
- clause_name!("$abolish_clause"),
+ &SystemClauseType::REPL(REPLCodePtr::AddDynamicPredicate) => {
+ clause_name!("$add_dynamic_predicate")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::AddGoalExpansionClause) => {
+ clause_name!("$add_goal_expansion_clause")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::AddTermExpansionClause) => {
+ clause_name!("$add_term_expansion_clause")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::ClauseToEvacuable) => {
+ clause_name!("$clause_to_evacuable")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::ConcludeLoad) => clause_name!("$conclude_load"),
+ &SystemClauseType::REPL(REPLCodePtr::DeclareModule) => clause_name!("$declare_module"),
+ &SystemClauseType::REPL(REPLCodePtr::LoadCompiledLibrary) => {
+ clause_name!("$load_compiled_library")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::PushLoadStatePayload) => {
+ clause_name!("$push_load_state_payload")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::Asserta) => clause_name!("$asserta"),
+ &SystemClauseType::REPL(REPLCodePtr::Assertz) => clause_name!("$assertz"),
+ &SystemClauseType::REPL(REPLCodePtr::Retract) => clause_name!("$retract_clause"),
+ &SystemClauseType::REPL(REPLCodePtr::UseModule) => clause_name!("$use_module"),
+ &SystemClauseType::REPL(REPLCodePtr::PushLoadContext) => {
+ clause_name!("$push_load_context")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::PopLoadContext) => {
+ clause_name!("$pop_load_context")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::PopLoadStatePayload) => {
+ clause_name!("$pop_load_state_payload")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::LoadContextSource) => {
+ clause_name!("$prolog_lc_source")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::LoadContextFile) => {
+ clause_name!("$prolog_lc_file")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::LoadContextDirectory) => {
+ clause_name!("$prolog_lc_dir")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::LoadContextModule) => {
+ clause_name!("$prolog_lc_module")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::LoadContextStream) => {
+ clause_name!("$prolog_lc_stream")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::MetaPredicateProperty) => {
+ clause_name!("$cpp_meta_predicate_property")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::BuiltInProperty) => {
+ clause_name!("$cpp_built_in_property")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::DynamicProperty) => {
+ clause_name!("$cpp_dynamic_property")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::MultifileProperty) => {
+ clause_name!("$cpp_multifile_property")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::DiscontiguousProperty) => {
+ clause_name!("$cpp_discontiguous_property")
+ }
+ &SystemClauseType::REPL(REPLCodePtr::AbolishClause) => clause_name!("$abolish_clause"),
&SystemClauseType::Close => clause_name!("$close"),
&SystemClauseType::CopyToLiftedHeap => clause_name!("$copy_to_lh"),
&SystemClauseType::DeleteAttribute => clause_name!("$del_attr_non_head"),
&SystemClauseType::EnqueueAttributeGoal => clause_name!("$enqueue_attribute_goal"),
&SystemClauseType::EnqueueAttributedVar => clause_name!("$enqueue_attr_var"),
&SystemClauseType::FetchGlobalVar => clause_name!("$fetch_global_var"),
- &SystemClauseType::FetchGlobalVarWithOffset =>
- clause_name!("$fetch_global_var_with_offset"),
+ &SystemClauseType::FetchGlobalVarWithOffset => {
+ clause_name!("$fetch_global_var_with_offset")
+ }
&SystemClauseType::FirstStream => clause_name!("$first_stream"),
&SystemClauseType::FlushOutput => clause_name!("$flush_output"),
&SystemClauseType::GetByte => clause_name!("$get_byte"),
clause_name!("$get_lh_from_offset_diff")
}
&SystemClauseType::GetBValue => clause_name!("$get_b_value"),
-// &SystemClauseType::GetClause => clause_name!("$get_clause"),
+ // &SystemClauseType::GetClause => clause_name!("$get_clause"),
&SystemClauseType::GetNextDBRef => clause_name!("$get_next_db_ref"),
&SystemClauseType::GetNextOpDBRef => clause_name!("$get_next_op_db_ref"),
&SystemClauseType::LookupDBRef => clause_name!("$lookup_db_ref"),
&SystemClauseType::LookupOpDBRef => clause_name!("$lookup_op_db_ref"),
&SystemClauseType::GetDoubleQuotes => clause_name!("$get_double_quotes"),
-// &SystemClauseType::GetModuleClause => clause_name!("$get_module_clause"),
+ // &SystemClauseType::GetModuleClause => clause_name!("$get_module_clause"),
&SystemClauseType::GetSCCCleaner => clause_name!("$get_scc_cleaner"),
&SystemClauseType::Halt => clause_name!("$halt"),
&SystemClauseType::HeadIsDynamic => clause_name!("$head_is_dynamic"),
// &SystemClauseType::ModuleAssertDynamicPredicateToBack => {
// clause_name!("$module_assertz")
// }
-// &SystemClauseType::ModuleHeadIsDynamic => clause_name!("$module_head_is_dynamic"),
+ // &SystemClauseType::ModuleHeadIsDynamic => clause_name!("$module_head_is_dynamic"),
&SystemClauseType::ModuleExists => clause_name!("$module_exists"),
&SystemClauseType::NextStream => clause_name!("$next_stream"),
&SystemClauseType::NoSuchPredicate => clause_name!("$no_such_predicate"),
&SystemClauseType::ReadTerm => clause_name!("$read_term"),
&SystemClauseType::ReadTermFromChars => clause_name!("$read_term_from_chars"),
&SystemClauseType::ResetGlobalVarAtKey => clause_name!("$reset_global_var_at_key"),
- &SystemClauseType::ResetGlobalVarAtOffset => clause_name!("$reset_global_var_at_offset"),
+ &SystemClauseType::ResetGlobalVarAtOffset => {
+ clause_name!("$reset_global_var_at_offset")
+ }
&SystemClauseType::ResetBlock => clause_name!("$reset_block"),
&SystemClauseType::ResetContinuationMarker => clause_name!("$reset_cont_marker"),
&SystemClauseType::ReturnFromVerifyAttr => clause_name!("$return_from_verify_attr"),
&SystemClauseType::SocketServerAccept => clause_name!("$socket_server_accept"),
&SystemClauseType::SocketServerClose => clause_name!("$socket_server_close"),
&SystemClauseType::Succeed => clause_name!("$succeed"),
- &SystemClauseType::TermAttributedVariables => clause_name!("$term_attributed_variables"),
+ &SystemClauseType::TermAttributedVariables => {
+ clause_name!("$term_attributed_variables")
+ }
&SystemClauseType::TermVariables => clause_name!("$term_variables"),
&SystemClauseType::TruncateLiftedHeapTo => clause_name!("$truncate_lh_to"),
&SystemClauseType::UnifyWithOccursCheck => clause_name!("$unify_with_occurs_check"),
&SystemClauseType::Ed25519Sign => clause_name!("$ed25519_sign"),
&SystemClauseType::Ed25519Verify => clause_name!("$ed25519_verify"),
&SystemClauseType::Ed25519NewKeyPair => clause_name!("$ed25519_new_keypair"),
- &SystemClauseType::Ed25519KeyPairPublicKey => clause_name!("$ed25519_keypair_public_key"),
+ &SystemClauseType::Ed25519KeyPairPublicKey => {
+ clause_name!("$ed25519_keypair_public_key")
+ }
&SystemClauseType::Curve25519ScalarMult => clause_name!("$curve25519_scalar_mult"),
&SystemClauseType::LoadHTML => clause_name!("$load_html"),
&SystemClauseType::LoadXML => clause_name!("$load_xml"),
pub fn from(name: &str, arity: usize) -> Option<SystemClauseType> {
match (name, arity) {
- ("$abolish_clause", 3) =>
- Some(SystemClauseType::REPL(REPLCodePtr::AbolishClause)),
- ("$add_dynamic_predicate", 3) =>
- Some(SystemClauseType::REPL(REPLCodePtr::AddDynamicPredicate)),
- ("$add_goal_expansion_clause", 4) =>
- Some(SystemClauseType::REPL(REPLCodePtr::AddGoalExpansionClause)),
- ("$add_term_expansion_clause", 3) =>
- Some(SystemClauseType::REPL(REPLCodePtr::AddTermExpansionClause)),
+ ("$abolish_clause", 3) => Some(SystemClauseType::REPL(REPLCodePtr::AbolishClause)),
+ ("$add_dynamic_predicate", 3) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::AddDynamicPredicate))
+ }
+ ("$add_goal_expansion_clause", 4) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::AddGoalExpansionClause))
+ }
+ ("$add_term_expansion_clause", 3) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::AddTermExpansionClause))
+ }
("$atom_chars", 2) => Some(SystemClauseType::AtomChars),
("$atom_codes", 2) => Some(SystemClauseType::AtomCodes),
("$atom_length", 2) => Some(SystemClauseType::AtomLength),
("$peek_code", 2) => Some(SystemClauseType::PeekCode),
("$is_partial_string", 1) => Some(SystemClauseType::IsPartialString),
("$fetch_global_var", 2) => Some(SystemClauseType::FetchGlobalVar),
- ("$fetch_global_var_with_offset", 3) => Some(SystemClauseType::FetchGlobalVarWithOffset),
+ ("$fetch_global_var_with_offset", 3) => {
+ Some(SystemClauseType::FetchGlobalVarWithOffset)
+ }
("$get_byte", 2) => Some(SystemClauseType::GetByte),
("$get_char", 2) => Some(SystemClauseType::GetChar),
("$get_n_chars", 3) => Some(SystemClauseType::GetNChars),
("$points_to_cont_reset_marker", 1) => {
Some(SystemClauseType::PointsToContinuationResetMarker)
}
- ("$put_byte", 2) => {
- Some(SystemClauseType::PutByte)
- }
- ("$put_char", 2) => {
- Some(SystemClauseType::PutChar)
- }
- ("$put_chars", 2) => {
- Some(SystemClauseType::PutChars)
- }
- ("$put_code", 2) => {
- Some(SystemClauseType::PutCode)
- }
+ ("$put_byte", 2) => Some(SystemClauseType::PutByte),
+ ("$put_char", 2) => Some(SystemClauseType::PutChar),
+ ("$put_chars", 2) => Some(SystemClauseType::PutChars),
+ ("$put_code", 2) => Some(SystemClauseType::PutCode),
("$reset_attr_var_state", 0) => Some(SystemClauseType::ResetAttrVarState),
("$truncate_if_no_lh_growth", 1) => {
Some(SystemClauseType::TruncateIfNoLiftedHeapGrowth)
("$socket_server_accept", 7) => Some(SystemClauseType::SocketServerAccept),
("$socket_server_close", 1) => Some(SystemClauseType::SocketServerClose),
("$store_global_var", 2) => Some(SystemClauseType::StoreGlobalVar),
- ("$store_global_var_with_offset", 2) => Some(SystemClauseType::StoreGlobalVarWithOffset),
+ ("$store_global_var_with_offset", 2) => {
+ Some(SystemClauseType::StoreGlobalVarWithOffset)
+ }
("$term_attributed_variables", 2) => Some(SystemClauseType::TermAttributedVariables),
("$term_variables", 2) => Some(SystemClauseType::TermVariables),
("$truncate_lh_to", 1) => Some(SystemClauseType::TruncateLiftedHeapTo),
("$working_directory", 2) => Some(SystemClauseType::WorkingDirectory),
("$path_canonical", 2) => Some(SystemClauseType::PathCanonical),
("$file_time", 3) => Some(SystemClauseType::FileTime),
- ("$clause_to_evacuable", 3) => Some(SystemClauseType::REPL(REPLCodePtr::ClauseToEvacuable)),
+ ("$clause_to_evacuable", 3) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::ClauseToEvacuable))
+ }
("$conclude_load", 1) => Some(SystemClauseType::REPL(REPLCodePtr::ConcludeLoad)),
("$use_module", 3) => Some(SystemClauseType::REPL(REPLCodePtr::UseModule)),
("$declare_module", 3) => Some(SystemClauseType::REPL(REPLCodePtr::DeclareModule)),
- ("$load_compiled_library", 2) => Some(SystemClauseType::REPL(REPLCodePtr::LoadCompiledLibrary)),
- ("$push_load_state_payload", 1) => Some(SystemClauseType::REPL(REPLCodePtr::PushLoadStatePayload)),
+ ("$load_compiled_library", 2) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::LoadCompiledLibrary))
+ }
+ ("$push_load_state_payload", 1) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::PushLoadStatePayload))
+ }
("$asserta", 5) => Some(SystemClauseType::REPL(REPLCodePtr::Asserta)),
("$assertz", 5) => Some(SystemClauseType::REPL(REPLCodePtr::Assertz)),
("$retract_clause", 4) => Some(SystemClauseType::REPL(REPLCodePtr::Retract)),
("$chars_base64", 4) => Some(SystemClauseType::CharsBase64),
("$load_library_as_stream", 3) => Some(SystemClauseType::LoadLibraryAsStream),
("$push_load_context", 2) => Some(SystemClauseType::REPL(REPLCodePtr::PushLoadContext)),
- ("$pop_load_state_payload", 1) => Some(SystemClauseType::REPL(REPLCodePtr::PopLoadStatePayload)),
+ ("$pop_load_state_payload", 1) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::PopLoadStatePayload))
+ }
("$pop_load_context", 0) => Some(SystemClauseType::REPL(REPLCodePtr::PopLoadContext)),
- ("$prolog_lc_source", 1) => Some(SystemClauseType::REPL(REPLCodePtr::LoadContextSource)),
+ ("$prolog_lc_source", 1) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::LoadContextSource))
+ }
("$prolog_lc_file", 1) => Some(SystemClauseType::REPL(REPLCodePtr::LoadContextFile)),
- ("$prolog_lc_dir", 1) => Some(SystemClauseType::REPL(REPLCodePtr::LoadContextDirectory)),
- ("$prolog_lc_module", 1) => Some(SystemClauseType::REPL(REPLCodePtr::LoadContextModule)),
- ("$prolog_lc_stream", 1) => Some(SystemClauseType::REPL(REPLCodePtr::LoadContextStream)),
- ("$cpp_meta_predicate_property", 4) => Some(SystemClauseType::REPL(REPLCodePtr::MetaPredicateProperty)),
- ("$cpp_built_in_property", 2) => Some(SystemClauseType::REPL(REPLCodePtr::BuiltInProperty)),
- ("$cpp_dynamic_property", 3) => Some(SystemClauseType::REPL(REPLCodePtr::DynamicProperty)),
- ("$cpp_multifile_property", 3) => Some(SystemClauseType::REPL(REPLCodePtr::MultifileProperty)),
- ("$cpp_discontiguous_property", 3) => Some(SystemClauseType::REPL(REPLCodePtr::DiscontiguousProperty)),
+ ("$prolog_lc_dir", 1) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::LoadContextDirectory))
+ }
+ ("$prolog_lc_module", 1) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::LoadContextModule))
+ }
+ ("$prolog_lc_stream", 1) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::LoadContextStream))
+ }
+ ("$cpp_meta_predicate_property", 4) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::MetaPredicateProperty))
+ }
+ ("$cpp_built_in_property", 2) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::BuiltInProperty))
+ }
+ ("$cpp_dynamic_property", 3) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::DynamicProperty))
+ }
+ ("$cpp_multifile_property", 3) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::MultifileProperty))
+ }
+ ("$cpp_discontiguous_property", 3) => {
+ Some(SystemClauseType::REPL(REPLCodePtr::DiscontiguousProperty))
+ }
_ => None,
}
}
match self {
&ClauseType::Op(_, ref spec, _) => Some(spec.clone()),
&ClauseType::Inlined(InlinedClauseType::CompareNumber(..))
- | &ClauseType::BuiltIn(BuiltInClauseType::Is(..))
- | &ClauseType::BuiltIn(BuiltInClauseType::CompareTerm(_))
- | &ClauseType::BuiltIn(BuiltInClauseType::NotEq)
- | &ClauseType::BuiltIn(BuiltInClauseType::Eq) => Some(SharedOpDesc::new(700, XFX)),
+ | &ClauseType::BuiltIn(BuiltInClauseType::Is(..))
+ | &ClauseType::BuiltIn(BuiltInClauseType::CompareTerm(_))
+ | &ClauseType::BuiltIn(BuiltInClauseType::NotEq)
+ | &ClauseType::BuiltIn(BuiltInClauseType::Eq) => Some(SharedOpDesc::new(700, XFX)),
_ => None,
}
}
/// Code generation to WAM-like instructions.
use crate::prolog_parser_rebis::ast::*;
use crate::prolog_parser_rebis::tabled_rc::TabledData;
+use crate::prolog_parser_rebis::{perm_v, temp_v};
use crate::allocator::*;
use crate::arithmetic::*;
self.has_deep_cut as usize
}
- fn mark_unsafe_vars(
- &self,
- mut unsafe_var_marker: UnsafeVarMarker,
- code: &mut Code,
- ) {
+ fn mark_unsafe_vars(&self, mut unsafe_var_marker: UnsafeVarMarker, code: &mut Code) {
if code.is_empty() {
return;
}
let mut code_index = 0;
- for phase in 0 .. {
+ for phase in 0.. {
while let Line::Query(ref query_instr) = &code[code_index] {
if !unsafe_var_marker.mark_safe_vars(query_instr) {
unsafe_var_marker.mark_phase(query_instr, phase);
code_index = 0;
- for phase in 0 .. {
+ for phase in 0.. {
while let Line::Query(ref mut query_instr) = &mut code[code_index] {
unsafe_var_marker.mark_unsafe_vars(query_instr, phase);
code_index += 1;
code: &mut Code,
) -> RegType {
let mut target = Vec::new();
- self.marker.mark_var(name, Level::Shallow, vr, term_loc, &mut target);
+ self.marker
+ .mark_var(name, Level::Shallow, vr, term_loc, &mut target);
if !target.is_empty() {
code.extend(target.into_iter().map(Line::Query));
code: &mut Code,
) -> RegType {
match self.marker.bindings().get(&name) {
- Some(&VarData::Temp(_, t, _)) if t != 0 => {
- RegType::Temp(t)
- }
+ Some(&VarData::Temp(_, t, _)) if t != 0 => RegType::Temp(t),
Some(&VarData::Perm(p)) if p != 0 => {
if let GenContext::Last(_) = term_loc {
self.mark_var_in_non_callable(name.clone(), term_loc, vr, code);
RegType::Perm(p)
}
}
- _ => {
- self.mark_var_in_non_callable(name, term_loc, vr, code)
- }
+ _ => self.mark_var_in_non_callable(name, term_loc, vr, code),
}
}
target: &mut Vec<Target>,
) {
if is_exposed || self.get_var_count(var.as_ref()) > 1 {
- self.marker.mark_var(var.clone(), Level::Deep, cell, term_loc, target);
+ self.marker
+ .mark_var(var.clone(), Level::Deep, cell, term_loc, target);
} else {
Self::add_or_increment_void_instr(target);
}
Self::add_or_increment_void_instr(target);
}
&Term::Cons(ref cell, _, _) | &Term::Clause(ref cell, _, _, _) => {
- self.marker.mark_non_var(Level::Deep, term_loc, cell, target);
+ self.marker
+ .mark_non_var(Level::Deep, term_loc, cell, target);
target.push(Target::clause_arg_to_instr(cell.get()));
}
&Term::Constant(_, ref constant) => {
};
}
- fn compile_target<Target, Iter>(
+ fn compile_target<Target, Iter>(
&mut self,
iter: Iter,
term_loc: GenContext,
}
}
- self.marker.mark_var(var.clone(), lvl, cell, term_loc, &mut target);
+ self.marker
+ .mark_var(var.clone(), lvl, cell, term_loc, &mut target);
}
TermRef::Var(lvl @ Level::Shallow, cell, var) => {
- self.marker.mark_var(var.clone(), lvl, cell, term_loc, &mut target);
- }
- _ => {
+ self.marker
+ .mark_var(var.clone(), lvl, cell, term_loc, &mut target);
}
+ _ => {}
};
}
while let Some((chunk_num, lt_arity, chunked_terms)) = iter.next() {
for (i, chunked_term) in chunked_terms.iter().enumerate() {
let term_loc = match chunked_term {
- &ChunkedTerm::HeadClause(..) =>
- GenContext::Head,
+ &ChunkedTerm::HeadClause(..) => GenContext::Head,
&ChunkedTerm::BodyTerm(_) => {
if i < chunked_terms.len() - 1 {
GenContext::Mid(chunk_num)
&QueryTerm::Clause(_, ref ct, ref terms, false) => {
code.push(call_clause!(ct.clone(), terms.len(), pvs));
}
- _ => {
- }
+ _ => {}
}
}
&mut ControlInstruction::JmpBy(_, _, _, ref mut last_call) => {
*last_call = true;
}
- &mut ControlInstruction::Proceed => {
- }
+ &mut ControlInstruction::Proceed => {}
_ => {
dealloc_index += 1;
}
Some(&mut Line::Cut(CutInstruction::Cut(_))) => {
dealloc_index += 1;
}
- _ => {
- }
+ _ => {}
};
dealloc_index
let (mut lcode, at_1) = self.call_arith_eval(terms[0].as_ref(), 1)?;
let (mut rcode, at_2) = self.call_arith_eval(terms[1].as_ref(), 2)?;
- let at_1 =
- if let &Term::Var(ref vr, ref name) = terms[0].as_ref() {
- ArithmeticTerm::Reg(
- self.mark_non_callable(name.clone(), 1, term_loc, vr, code)
- )
- } else {
- at_1.unwrap_or(interm!(1))
- };
-
- let at_2 =
- if let &Term::Var(ref vr, ref name) = terms[1].as_ref() {
- ArithmeticTerm::Reg(
- self.mark_non_callable(name.clone(), 2, term_loc, vr, code)
- )
- } else {
- at_2.unwrap_or(interm!(2))
- };
+ let at_1 = if let &Term::Var(ref vr, ref name) = terms[0].as_ref() {
+ ArithmeticTerm::Reg(self.mark_non_callable(name.clone(), 1, term_loc, vr, code))
+ } else {
+ at_1.unwrap_or(interm!(1))
+ };
+
+ let at_2 = if let &Term::Var(ref vr, ref name) = terms[1].as_ref() {
+ ArithmeticTerm::Reg(self.mark_non_callable(name.clone(), 2, term_loc, vr, code))
+ } else {
+ at_2.unwrap_or(interm!(2))
+ };
code.append(&mut lcode);
code.append(&mut rcode);
code.push(compare_number_instr!(cmp, at_1, at_2));
}
&InlinedClauseType::IsAtom(..) => match terms[0].as_ref() {
- &Term::Constant(_, Constant::Char(_)) |
- &Term::Constant(_, Constant::EmptyList) |
- &Term::Constant(_, Constant::Atom(..)) => {
+ &Term::Constant(_, Constant::Char(_))
+ | &Term::Constant(_, Constant::EmptyList)
+ | &Term::Constant(_, Constant::Atom(..)) => {
code.push(succeed!());
}
&Term::Var(ref vr, ref name) => {
}
},
&InlinedClauseType::IsNumber(..) => match terms[0].as_ref() {
- &Term::Constant(_, Constant::Float(_)) |
- &Term::Constant(_, Constant::Rational(_)) |
- &Term::Constant(_, Constant::Integer(_)) |
- &Term::Constant(_, Constant::Fixnum(_)) |
- &Term::Constant(_, Constant::Usize(_)) => {
+ &Term::Constant(_, Constant::Float(_))
+ | &Term::Constant(_, Constant::Rational(_))
+ | &Term::Constant(_, Constant::Integer(_))
+ | &Term::Constant(_, Constant::Fixnum(_))
+ | &Term::Constant(_, Constant::Usize(_)) => {
code.push(succeed!());
}
&Term::Var(ref vr, ref name) => {
}
},
&InlinedClauseType::IsInteger(..) => match terms[0].as_ref() {
- &Term::Constant(_, Constant::Integer(_)) |
- &Term::Constant(_, Constant::Fixnum(_)) |
- &Term::Constant(_, Constant::Usize(_)) => {
+ &Term::Constant(_, Constant::Integer(_))
+ | &Term::Constant(_, Constant::Fixnum(_))
+ | &Term::Constant(_, Constant::Usize(_)) => {
code.push(succeed!());
}
&Term::Var(ref vr, ref name) => {
&Term::Var(ref vr, ref name) => {
let mut target = vec![];
- self.marker.mark_var(name.clone(), Level::Shallow, vr, term_loc, &mut target);
+ self.marker
+ .mark_var(name.clone(), Level::Shallow, vr, term_loc, &mut target);
if !target.is_empty() {
code.extend(target.into_iter().map(Line::Query));
}
}
- &Term::Constant(_, ref c @ Constant::Integer(_)) |
- &Term::Constant(_, ref c @ Constant::Fixnum(_)) => {
+ &Term::Constant(_, ref c @ Constant::Integer(_))
+ | &Term::Constant(_, ref c @ Constant::Fixnum(_)) => {
code.push(Line::Query(put_constant!(
Level::Shallow,
c.clone(),
}
}
- let at =
- if let &Term::Var(ref vr, ref name) = terms[1].as_ref() {
- ArithmeticTerm::Reg(
- self.mark_non_callable(name.clone(), 2, term_loc, vr, code)
- )
- } else {
- at.unwrap_or(interm!(1))
- };
+ let at = if let &Term::Var(ref vr, ref name) = terms[1].as_ref() {
+ ArithmeticTerm::Reg(self.mark_non_callable(name.clone(), 2, term_loc, vr, code))
+ } else {
+ at.unwrap_or(interm!(1))
+ };
Ok(if use_default_call_policy {
code.push(is_call_by_default!(temp_v!(1), at));
&QueryTerm::GetLevelAndUnify(ref cell, ref var) => {
self.compile_get_level_and_unify(code, cell, var.clone(), term_loc)
}
- &QueryTerm::UnblockedCut(ref cell) => {
- self.compile_unblocked_cut(code, cell)
- }
- &QueryTerm::BlockedCut => {
- code.push(if chunk_num == 0 {
- Line::Cut(CutInstruction::NeckCut)
- } else {
- Line::Cut(CutInstruction::Cut(perm_v!(1)))
- })
- }
+ &QueryTerm::UnblockedCut(ref cell) => self.compile_unblocked_cut(code, cell),
+ &QueryTerm::BlockedCut => code.push(if chunk_num == 0 {
+ Line::Cut(CutInstruction::NeckCut)
+ } else {
+ Line::Cut(CutInstruction::Cut(perm_v!(1)))
+ }),
&QueryTerm::Clause(
_,
ClauseType::BuiltIn(BuiltInClauseType::Is(..)),
ref terms,
use_default_call_policy,
- ) => {
- self.compile_is_call(terms, code, term_loc, use_default_call_policy)?
- }
+ ) => self.compile_is_call(terms, code, term_loc, use_default_call_policy)?,
&QueryTerm::Clause(_, ClauseType::Inlined(ref ct), ref terms, _) => {
self.compile_inlined(ct, terms, term_loc, code)?
}
}
}
- fn compile_cleanup(&mut self, code: &mut Code, conjunct_info: &ConjunctInfo, toc: &'a QueryTerm) {
+ fn compile_cleanup(
+ &mut self,
+ code: &mut Code,
+ conjunct_info: &ConjunctInfo,
+ toc: &'a QueryTerm,
+ ) {
// add a proceed to bookend any trailing cuts.
match toc {
&QueryTerm::BlockedCut | &QueryTerm::UnblockedCut(..) => code.push(proceed!()),
if conjunct_info.allocates() {
let offset = self.global_jmp_by_locs_offset;
- if let Some(jmp_by_offset) = self.jmp_by_locs[offset ..].last_mut() {
+ if let Some(jmp_by_offset) = self.jmp_by_locs[offset..].last_mut() {
if *jmp_by_offset == dealloc_index {
*jmp_by_offset += 1;
}
self.add_conditional_call(code, term, num_perm_vars_left);
}
-/*
- pub fn compile_query(&mut self, query: &'a Vec<QueryTerm>) -> Result<Code, CompilationError> {
- let iter = ChunkedIterator::from_term_sequence(query);
- let conjunct_info = self.collect_var_data(iter);
+ /*
+ pub fn compile_query(&mut self, query: &'a Vec<QueryTerm>) -> Result<Code, CompilationError> {
+ let iter = ChunkedIterator::from_term_sequence(query);
+ let conjunct_info = self.collect_var_data(iter);
- let mut code = Vec::new();
- self.compile_seq_prelude(&conjunct_info, &mut code);
+ let mut code = Vec::new();
+ self.compile_seq_prelude(&conjunct_info, &mut code);
- let iter = ChunkedIterator::from_term_sequence(query);
- self.compile_seq(iter, &conjunct_info, &mut code, true)?;
+ let iter = ChunkedIterator::from_term_sequence(query);
+ self.compile_seq(iter, &conjunct_info, &mut code, true)?;
- conjunct_info.mark_unsafe_vars(UnsafeVarMarker::new(), &mut code);
+ conjunct_info.mark_unsafe_vars(UnsafeVarMarker::new(), &mut code);
- if let Some(query_term) = query.last() {
- Self::compile_cleanup(&mut code, &conjunct_info, query_term);
- }
+ if let Some(query_term) = query.last() {
+ Self::compile_cleanup(&mut code, &conjunct_info, query_term);
+ }
- Ok(code)
- }
-*/
+ Ok(code)
+ }
+ */
#[inline]
fn increment_jmp_by_locs_by(&mut self, incr: usize) {
let offset = self.global_jmp_by_locs_offset;
- for loc in &mut self.jmp_by_locs[offset ..] {
+ for loc in &mut self.jmp_by_locs[offset..] {
*loc += incr;
}
}
if skip_stub_try_me_else {
// skip the TryMeElse(0) also.
- self.increment_jmp_by_locs_by(2);
+ self.increment_jmp_by_locs_by(2);
} else {
self.increment_jmp_by_locs_by(1);
}
for (l, r) in split_pred {
let skel_lower_bound = self.skeleton.clauses.len();
- let code_segment = self.compile_pred_subseq(&clauses[l .. r], optimal_index)?;
+ let code_segment = self.compile_pred_subseq(&clauses[l..r], optimal_index)?;
let clause_start_offset = code.len();
if multi_seq {
if self.is_extensible {
let segment_is_indexed = to_indexing_line(&code_segment[0]).is_some();
- for clause_index_info in self.skeleton.clauses[skel_lower_bound ..].iter_mut() {
+ for clause_index_info in self.skeleton.clauses[skel_lower_bound..].iter_mut() {
clause_index_info.clause_start +=
clause_start_offset + 2 * (segment_is_indexed as usize);
- clause_index_info.opt_arg_index_key +=
- clause_start_offset + 1;
+ clause_index_info.opt_arg_index_key += clause_start_offset + 1;
}
}
use crate::indexmap::IndexMap;
use crate::prolog_parser_rebis::ast::*;
+use crate::prolog_parser_rebis::temp_v;
use crate::allocator::*;
use crate::fixtures::*;
(pr, true)
}
- r => {
- (r, false)
- }
+ r => (r, false),
};
self.mark_reserved_var(var, lvl, cell, term_loc, target, r, is_new_var);
use crate::prolog_parser_rebis::ast::*;
use crate::prolog_parser_rebis::parser::OpDesc;
+use crate::prolog_parser_rebis::{clause_name, is_infix, is_postfix};
use crate::clause_types::*;
use crate::machine::machine_errors::*;
#[derive(Debug, Clone, Copy)]
pub enum AppendOrPrepend {
Append,
- Prepend
+ Prepend,
}
impl AppendOrPrepend {
pub trait ClauseInfo {
fn is_consistent(&self, clauses: &Vec<PredicateClause>) -> bool {
match clauses.first() {
- Some(cl) => {
- self.name() == cl.name() && self.arity() == cl.arity()
- }
- None => {
- true
- }
+ Some(cl) => self.name() == cl.name() && self.arity() == cl.arity(),
+ None => true,
}
}
_ => Some(clause_name!(":-")),
}
}
- _ => {
- Some(name.clone())
- }
+ _ => Some(name.clone()),
}
}
- Term::Constant(_, Constant::Atom(ref name, _)) => {
- Some(name.clone())
- }
- _ => {
- None
- }
+ Term::Constant(_, Constant::Atom(ref name, _)) => Some(name.clone()),
+ _ => None,
}
}
fn arity(&self) -> usize {
match self {
- Term::Clause(_, ref name, ref terms, _) =>
- match name.as_str() {
- ":-" => {
- match terms.len() {
- 1 => 0,
- 2 => terms[0].arity(),
- _ => terms.len(),
- }
- }
- _ => {
- terms.len()
- }
+ Term::Clause(_, ref name, ref terms, _) => match name.as_str() {
+ ":-" => match terms.len() {
+ 1 => 0,
+ 2 => terms[0].arity(),
+ _ => terms.len(),
},
- _ => {
- 0
- }
+ _ => terms.len(),
+ },
+ _ => 0,
}
}
}
impl ClauseInfo for PredicateClause {
fn name(&self) -> Option<ClauseName> {
match self {
- &PredicateClause::Fact(ref term, ..) => {
- term.name()
- }
- &PredicateClause::Rule(ref rule, ..) => {
- rule.name()
- }
+ &PredicateClause::Fact(ref term, ..) => term.name(),
+ &PredicateClause::Rule(ref rule, ..) => rule.name(),
}
}
fn arity(&self) -> usize {
match self {
- &PredicateClause::Fact(ref term, ..) => {
- term.arity()
- }
- &PredicateClause::Rule(ref rule, ..) => {
- rule.arity()
- }
+ &PredicateClause::Fact(ref term, ..) => term.arity(),
+ &PredicateClause::Rule(ref rule, ..) => rule.arity(),
}
}
}
// TODO: add this to `Term` in `prolog_parser` like `first_arg`.
pub fn args(&self) -> Option<&[Box<Term>]> {
match *self {
- PredicateClause::Fact(ref term, ..) => {
- match term {
- Term::Clause(_, _, args, _) => Some(&args),
- _ => None,
- }
+ PredicateClause::Fact(ref term, ..) => match term {
+ Term::Clause(_, _, args, _) => Some(&args),
+ _ => None,
},
PredicateClause::Rule(ref rule, ..) => {
if rule.head.1.is_empty() {
pub fn arity(&self) -> usize {
match self {
- &PredicateClause::Fact(ref term, ..) => {
- term.arity()
- }
+ &PredicateClause::Fact(ref term, ..) => term.arity(),
&PredicateClause::Rule(ref rule, ..) => {
if rule.head.0.as_str() == ":" && rule.head.1.len() == 2 {
match (rule.head.1)[0].as_ref() {
- &Term::Constant(_, Constant::Atom(..)) => {
- }
+ &Term::Constant(_, Constant::Atom(..)) => {}
_ => {
return 2;
}
pub struct OpDecl {
pub prec: usize,
pub spec: Specifier,
- pub name: ClauseName
+ pub name: ClauseName,
}
impl OpDecl {
XFY | XFX | YFX => Fixity::In,
XF | YF => Fixity::Post,
FX | FY => Fixity::Pre,
- _ => unreachable!()
+ _ => unreachable!(),
}
}
Some(cell) => {
return Some(cell.shared_op_desc().replace((self.prec, self.spec)));
}
- None => {
- }
+ None => {}
}
- op_dir.insert(key, OpDirValue::new(self.spec, self.prec))
- .map(|op_dir_value| op_dir_value.shared_op_desc().get())
+ op_dir
+ .insert(key, OpDirValue::new(self.spec, self.prec))
+ .map(|op_dir_value| op_dir_value.shared_op_desc().get())
}
pub fn submit(
spec.or_else(|| fetch_op_spec(name, arity, op_dir))
}
-pub fn fetch_op_spec(
- name: ClauseName,
- arity: usize,
- op_dir: &OpDir,
-) -> Option<SharedOpDesc> {
+pub fn fetch_op_spec(name: ClauseName, arity: usize, op_dir: &OpDir) -> Option<SharedOpDesc> {
match arity {
2 => op_dir
.get(&(name, Fixity::In))
}
})
}
- _ => {
- None
- }
+ _ => None,
}
}
}
}
-
#[derive(Debug, Clone)]
pub enum Number {
Float(OrderedFloat<f64>),
}
}
-
impl Number {
#[inline]
pub fn is_positive(&self) -> bool {
#[inline]
pub fn abs(self) -> Self {
match self {
- Number::Fixnum(n) =>
+ Number::Fixnum(n) => {
if let Some(n) = n.checked_abs() {
Number::from(n)
} else {
Number::from(Integer::from(n).abs())
}
+ }
Number::Integer(n) => Number::from(Integer::from(n.abs_ref())),
Number::Float(f) => Number::Float(OrderedFloat(f.abs())),
Number::Rational(r) => Number::from(Rational::from(r.abs_ref())),
#[inline]
pub fn arg_num(&self) -> usize {
match &self {
- OptArgIndexKey::Constant(arg_num, ..) |
- OptArgIndexKey::Structure(arg_num, ..) |
- OptArgIndexKey::List(arg_num, _) => {
+ OptArgIndexKey::Constant(arg_num, ..)
+ | OptArgIndexKey::Structure(arg_num, ..)
+ | OptArgIndexKey::List(arg_num, _) => {
// these are always at least 1.
*arg_num
}
- OptArgIndexKey::None => {
- 0
- }
+ OptArgIndexKey::None => 0,
}
}
#[inline]
pub fn switch_on_term_loc(&self) -> Option<usize> {
match &self {
- OptArgIndexKey::Constant(_, loc, ..) |
- OptArgIndexKey::Structure(_, loc, ..) |
- OptArgIndexKey::List(_, loc) => {
- Some(*loc)
- }
- OptArgIndexKey::None => {
- None
- }
+ OptArgIndexKey::Constant(_, loc, ..)
+ | OptArgIndexKey::Structure(_, loc, ..)
+ | OptArgIndexKey::List(_, loc) => Some(*loc),
+ OptArgIndexKey::None => None,
}
}
#[inline]
pub fn set_switch_on_term_loc(&mut self, value: usize) {
match self {
- OptArgIndexKey::Constant(_, ref mut loc, ..) |
- OptArgIndexKey::Structure(_, ref mut loc, ..) |
- OptArgIndexKey::List(_, ref mut loc) => {
+ OptArgIndexKey::Constant(_, ref mut loc, ..)
+ | OptArgIndexKey::Structure(_, ref mut loc, ..)
+ | OptArgIndexKey::List(_, ref mut loc) => {
*loc = value;
}
- OptArgIndexKey::None => {
- }
+ OptArgIndexKey::None => {}
}
}
}
#[inline]
fn add_assign(&mut self, n: usize) {
match self {
- OptArgIndexKey::Constant(_, ref mut o, ..) |
- OptArgIndexKey::List(_, ref mut o) |
- OptArgIndexKey::Structure(_, ref mut o, ..) => {
+ OptArgIndexKey::Constant(_, ref mut o, ..)
+ | OptArgIndexKey::List(_, ref mut o)
+ | OptArgIndexKey::Structure(_, ref mut o, ..) => {
*o += n;
}
- OptArgIndexKey::None => {
- }
+ OptArgIndexKey::None => {}
}
}
}
use crate::prolog_parser_rebis::ast::*;
+use crate::prolog_parser_rebis::{
+ alpha_char, alpha_numeric_char, backslash_char, capital_letter_char, char_class, clause_name,
+ cut_char, decimal_digit_char, graphic_char, graphic_token_char, is_fx, is_infix, is_postfix,
+ is_prefix, is_xf, is_xfx, is_xfy, is_yfx, semicolon_char, sign_char, single_quote_char,
+ small_letter_char, solo_char, variable_indicator_char,
+};
use crate::clause_types::*;
use crate::forms::*;
use std::cell::Cell;
use std::convert::TryFrom;
-use std::iter::{FromIterator, once};
+use std::iter::{once, FromIterator};
use std::net::{IpAddr, TcpListener};
use std::ops::{Range, RangeFrom};
use std::rc::Rc;
None => return false,
};
- let mut parent_spec = DirectedOp::Left(
- clause_name!("-"),
- SharedOpDesc::new(200, FY),
- );
+ let mut parent_spec = DirectedOp::Left(clause_name!("-"), SharedOpDesc::new(200, FY));
loop {
match self.machine_st.store(self.machine_st.deref(addr)) {
'\u{07}' if is_quoted => "\\a".to_string(), // UTF-8 alert
'"' if is_quoted => "\\\"".to_string(),
'\\' if is_quoted => "\\\\".to_string(),
- '\'' | '\n' | '\r' | '\t' | '\u{0b}' | '\u{0c}' | '\u{08}' | '\u{07}' | '"' | '\\' =>
- c.to_string(),
- '\u{a0}' ..= '\u{d6}' => c.to_string(),
- '\u{d8}' ..= '\u{f6}' => c.to_string(),
- '\u{f8}' ..= '\u{74f}' => c.to_string(),
- '\x20' ..= '\x7e' => c.to_string(),
+ '\'' | '\n' | '\r' | '\t' | '\u{0b}' | '\u{0c}' | '\u{08}' | '\u{07}' | '"' | '\\' => {
+ c.to_string()
+ }
+ '\u{a0}'..='\u{d6}' => c.to_string(),
+ '\u{d8}'..='\u{f6}' => c.to_string(),
+ '\u{f8}'..='\u{74f}' => c.to_string(),
+ '\x20'..='\x7e' => c.to_string(),
_ => format!("\\x{:x}\\", c as u32),
}
}
#[inline]
fn negated_op_needs_bracketing(iter: &HCPreOrderIterator, op: &Option<DirectedOp>) -> bool {
if let Some(ref op) = op {
- op.is_negative_sign() &&
- iter.leftmost_leaf_has_property(|addr, heap| {
- match Number::try_from((addr, heap)) {
- Ok(Number::Fixnum(n)) => {
- n > 0
- }
- Ok(Number::Float(f)) => {
- f > OrderedFloat(0f64)
- }
- Ok(Number::Integer(n)) => {
- &*n > &0
- }
- Ok(Number::Rational(n)) => {
- &*n > &0
- }
- _ => {
- false
- }
- }
+ op.is_negative_sign()
+ && iter.leftmost_leaf_has_property(|addr, heap| match Number::try_from((addr, heap)) {
+ Ok(Number::Fixnum(n)) => n > 0,
+ Ok(Number::Float(f)) => f > OrderedFloat(0f64),
+ Ok(Number::Integer(n)) => &*n > &0,
+ Ok(Number::Rational(n)) => &*n > &0,
+ _ => false,
})
} else {
false
fn numbervar(n: Integer) -> Var {
static CHAR_CODES: [char; 26] = [
- 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
- 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
+ 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
];
let i = n.mod_u(26) as usize;
None
}
}
- _ => {
- None
- }
+ _ => None,
}
}
}
}
}
-pub(super)
-fn non_quoted_token<Iter: Iterator<Item = char>>(mut iter: Iter) -> bool {
+pub(super) fn non_quoted_token<Iter: Iterator<Item = char>>(mut iter: Iter) -> bool {
if let Some(c) = iter.next() {
if small_letter_char!(c) {
iter.all(|c| alpha_numeric_char!(c))
max_depth: 0,
}
}
-/*
- pub fn from_heap_locs(
- machine_st: &'a MachineState,
- op_dir: &'a OpDir,
- output: Outputter,
- ) -> Self {
- let mut printer = Self::new(machine_st, op_dir, output);
-
- printer.toplevel_spec = Some(DirectedOp::Right(
- clause_name!("="),
- SharedOpDesc::new(700, XFX),
- ));
+ /*
+ pub fn from_heap_locs(
+ machine_st: &'a MachineState,
+ op_dir: &'a OpDir,
+ output: Outputter,
+ ) -> Self {
+ let mut printer = Self::new(machine_st, op_dir, output);
+
+ printer.toplevel_spec = Some(DirectedOp::Right(
+ clause_name!("="),
+ SharedOpDesc::new(700, XFX),
+ ));
- printer.heap_locs = reverse_heap_locs(machine_st);
+ printer.heap_locs = reverse_heap_locs(machine_st);
- printer
- }
-*/
-/*
- pub fn drop_toplevel_spec(&mut self) {
- self.toplevel_spec = None;
- }
-*/
-/*
- #[inline]
- pub fn see_all_locs(&mut self) {
- for key in self.heap_locs.keys().cloned() {
- self.printed_vars.insert(key);
+ printer
}
- }
-*/
+ */
+ /*
+ pub fn drop_toplevel_spec(&mut self) {
+ self.toplevel_spec = None;
+ }
+ */
+ /*
+ #[inline]
+ pub fn see_all_locs(&mut self) {
+ for key in self.heap_locs.keys().cloned() {
+ self.printed_vars.insert(key);
+ }
+ }
+ */
#[inline]
fn ambiguity_check(&self, atom: &str) -> bool {
iter.stack().pop();
self.state_stack.push(TokenOrRedirect::Op(ct.name(), spec));
- self.state_stack.push(TokenOrRedirect::Atom(clause_name!("...")));
+ self.state_stack
+ .push(TokenOrRedirect::Atom(clause_name!("...")));
return;
}
if self.check_max_depth(&mut max_depth) {
iter.stack().pop();
- self.state_stack.push(TokenOrRedirect::Atom(clause_name!("...")));
+ self.state_stack
+ .push(TokenOrRedirect::Atom(clause_name!("...")));
self.state_stack.push(TokenOrRedirect::Op(ct.name(), spec));
return;
let left_directed_op = DirectedOp::Left(ct.name(), spec.clone());
- self.state_stack.push(TokenOrRedirect::CompositeRedirect(max_depth, left_directed_op));
+ self.state_stack.push(TokenOrRedirect::CompositeRedirect(
+ max_depth,
+ left_directed_op,
+ ));
self.state_stack.push(TokenOrRedirect::Op(ct.name(), spec));
} else {
match ct.name().as_str() {
iter.stack().pop();
iter.stack().pop();
- self.state_stack.push(TokenOrRedirect::Atom(clause_name!("...")));
+ self.state_stack
+ .push(TokenOrRedirect::Atom(clause_name!("...")));
self.state_stack.push(TokenOrRedirect::Op(ct.name(), spec));
- self.state_stack.push(TokenOrRedirect::Atom(clause_name!("...")));
+ self.state_stack
+ .push(TokenOrRedirect::Atom(clause_name!("...")));
return;
}
let left_directed_op = DirectedOp::Left(ct.name(), spec.clone());
let right_directed_op = DirectedOp::Right(ct.name(), spec.clone());
- self.state_stack
- .push(TokenOrRedirect::CompositeRedirect(max_depth, left_directed_op));
+ self.state_stack.push(TokenOrRedirect::CompositeRedirect(
+ max_depth,
+ left_directed_op,
+ ));
self.state_stack.push(TokenOrRedirect::Op(ct.name(), spec));
- self.state_stack
- .push(TokenOrRedirect::CompositeRedirect(max_depth, right_directed_op));
+ self.state_stack.push(TokenOrRedirect::CompositeRedirect(
+ max_depth,
+ right_directed_op,
+ ));
}
}
mut max_depth: usize,
arity: usize,
name: ClauseName,
- ) -> bool
- {
+ ) -> bool {
if self.check_max_depth(&mut max_depth) {
- for _ in 0 .. arity {
+ for _ in 0..arity {
iter.stack().pop();
}
self.state_stack.push(TokenOrRedirect::Close);
- self.state_stack.push(TokenOrRedirect::Atom(clause_name!("...")));
+ self.state_stack
+ .push(TokenOrRedirect::Atom(clause_name!("...")));
self.state_stack.push(TokenOrRedirect::Open);
self.state_stack.push(TokenOrRedirect::Atom(name));
self.state_stack.push(TokenOrRedirect::Close);
- for _ in 0 .. arity {
- self.state_stack.push(TokenOrRedirect::FunctorRedirect(max_depth));
+ for _ in 0..arity {
+ self.state_stack
+ .push(TokenOrRedirect::FunctorRedirect(max_depth));
self.state_stack.push(TokenOrRedirect::Comma);
}
iter: &mut HCPreOrderIterator,
mut max_depth: usize,
name: ClauseName,
- spec: SharedOpDesc)
- {
+ spec: SharedOpDesc,
+ ) {
if self.check_max_depth(&mut max_depth) {
iter.stack().pop();
- self.state_stack.push(TokenOrRedirect::Atom(clause_name!("...")));
+ self.state_stack
+ .push(TokenOrRedirect::Atom(clause_name!("...")));
self.state_stack.push(TokenOrRedirect::Space);
self.state_stack.push(TokenOrRedirect::Atom(name));
let op = DirectedOp::Left(name.clone(), spec);
- self.state_stack.push(TokenOrRedirect::CompositeRedirect(max_depth, op));
+ self.state_stack
+ .push(TokenOrRedirect::CompositeRedirect(max_depth, op));
self.state_stack.push(TokenOrRedirect::Space);
self.state_stack.push(TokenOrRedirect::Atom(name));
}
mut max_depth: usize,
name: ClauseName,
spec: SharedOpDesc,
- )
- {
+ ) {
if self.check_max_depth(&mut max_depth) {
iter.stack().pop();
- self.state_stack.push(TokenOrRedirect::Atom(clause_name!("...")));
+ self.state_stack
+ .push(TokenOrRedirect::Atom(clause_name!("...")));
self.state_stack.push(TokenOrRedirect::BarAsOp);
- self.state_stack.push(TokenOrRedirect::Atom(clause_name!("...")));
+ self.state_stack
+ .push(TokenOrRedirect::Atom(clause_name!("...")));
return;
}
let left_directed_op = DirectedOp::Left(name.clone(), spec.clone());
let right_directed_op = DirectedOp::Right(name.clone(), spec.clone());
- self.state_stack.push(TokenOrRedirect::CompositeRedirect(max_depth, left_directed_op));
+ self.state_stack.push(TokenOrRedirect::CompositeRedirect(
+ max_depth,
+ left_directed_op,
+ ));
self.state_stack.push(TokenOrRedirect::BarAsOp);
- self.state_stack.push(TokenOrRedirect::CompositeRedirect(max_depth, right_directed_op));
+ self.state_stack.push(TokenOrRedirect::CompositeRedirect(
+ max_depth,
+ right_directed_op,
+ ));
}
- fn format_curly_braces(&mut self, iter: &mut HCPreOrderIterator, mut max_depth: usize) -> bool
- {
+ fn format_curly_braces(&mut self, iter: &mut HCPreOrderIterator, mut max_depth: usize) -> bool {
if self.check_max_depth(&mut max_depth) {
iter.stack().pop();
self.state_stack.push(TokenOrRedirect::RightCurly);
- self.state_stack.push(TokenOrRedirect::Atom(clause_name!("...")));
+ self.state_stack
+ .push(TokenOrRedirect::Atom(clause_name!("...")));
self.state_stack.push(TokenOrRedirect::LeftCurly);
return false;
}
self.state_stack.push(TokenOrRedirect::RightCurly);
- self.state_stack.push(TokenOrRedirect::FunctorRedirect(max_depth));
+ self.state_stack
+ .push(TokenOrRedirect::FunctorRedirect(max_depth));
self.state_stack.push(TokenOrRedirect::LeftCurly);
true
}
match addr {
- Addr::Lis(h) | Addr::Str(h) => {
- Some(format!("{}", h))
- }
+ Addr::Lis(h) | Addr::Str(h) => Some(format!("{}", h)),
_ => {
if let Some(r) = addr.as_var() {
match r {
- Ref::StackCell(fr, sc) => {
- Some(format!("_s_{}_{}", fr, sc))
- }
- Ref::HeapCell(h) | Ref::AttrVar(h) => {
- Some(format!("_{}", h))
- }
+ Ref::StackCell(fr, sc) => Some(format!("_s_{}_{}", fr, sc)),
+ Ref::HeapCell(h) | Ref::AttrVar(h) => Some(format!("_{}", h)),
}
} else {
None
fn record_children_as_non_cyclic(&mut self, addr: &Addr) {
match addr {
&Addr::Lis(l) => {
- let c1 = self.machine_st.store(self.machine_st.deref(Addr::HeapCell(l)));
- let c2 = self.machine_st.store(self.machine_st.deref(Addr::HeapCell(l + 1)));
+ let c1 = self
+ .machine_st
+ .store(self.machine_st.deref(Addr::HeapCell(l)));
+ let c2 = self
+ .machine_st
+ .store(self.machine_st.deref(Addr::HeapCell(l + 1)));
if let Some(c) = functor_location(&c1) {
self.non_cyclic_terms.insert(c);
}
}
&Addr::Str(s) => {
- let arity =
- match &self.machine_st.heap[s] {
- HeapCellValue::NamedStr(arity, ..) => {
- arity
- }
- _ => {
- unreachable!()
- }
- };
+ let arity = match &self.machine_st.heap[s] {
+ HeapCellValue::NamedStr(arity, ..) => arity,
+ _ => {
+ unreachable!()
+ }
+ };
- for i in 1 .. arity + 1 {
- let c = self.machine_st.store(self.machine_st.deref(Addr::HeapCell(s + i)));
+ for i in 1..arity + 1 {
+ let c = self
+ .machine_st
+ .store(self.machine_st.deref(Addr::HeapCell(s + i)));
if let Some(c) = functor_location(&c) {
self.non_cyclic_terms.insert(c);
self.non_cyclic_terms.insert(c);
}
}
- _ => {
- }
+ _ => {}
}
}
- fn check_for_seen(
- &mut self,
- iter: &mut HCPreOrderIterator,
- ) -> Option<Addr> {
+ fn check_for_seen(&mut self, iter: &mut HCPreOrderIterator) -> Option<Addr> {
iter.stack().last().cloned().and_then(|addr| {
let addr = self.machine_st.store(self.machine_st.deref(addr));
}
None => {
let offset = match functor_location(&addr) {
- Some(offset) => {
- offset
- }
+ Some(offset) => offset,
None => {
return iter.next();
}
let rdiv_ct = clause_name!("rdiv");
- let left_directed_op =
- if spec.prec() > 0 {
- Some(DirectedOp::Left(rdiv_ct.clone(), spec.clone()))
- } else {
- None
- };
+ let left_directed_op = if spec.prec() > 0 {
+ Some(DirectedOp::Left(rdiv_ct.clone(), spec.clone()))
+ } else {
+ None
+ };
- let right_directed_op =
- if spec.prec() > 0 {
- Some(DirectedOp::Right(rdiv_ct.clone(), spec.clone()))
- } else {
- None
- };
+ let right_directed_op = if spec.prec() > 0 {
+ Some(DirectedOp::Right(rdiv_ct.clone(), spec.clone()))
+ } else {
+ None
+ };
if spec.prec() > 0 {
self.state_stack.push(TokenOrRedirect::Number(
left_directed_op,
));
- self.state_stack.push(TokenOrRedirect::Op(
- rdiv_ct,
- spec.clone(),
- ));
+ self.state_stack
+ .push(TokenOrRedirect::Op(rdiv_ct, spec.clone()));
self.state_stack.push(TokenOrRedirect::Number(
Number::from(r.numer()),
} else {
self.state_stack.push(TokenOrRedirect::Close);
- self.state_stack.push(TokenOrRedirect::Number(
- Number::from(r.denom()),
- None,
- ));
+ self.state_stack
+ .push(TokenOrRedirect::Number(Number::from(r.denom()), None));
self.state_stack.push(TokenOrRedirect::Comma);
- self.state_stack.push(TokenOrRedirect::Number(
- Number::from(r.numer()),
- None,
- ));
+ self.state_stack
+ .push(TokenOrRedirect::Number(Number::from(r.numer()), None));
self.state_stack.push(TokenOrRedirect::Open);
self.state_stack.push(TokenOrRedirect::Atom(rdiv_ct));
}
}
- fn print_char(&mut self, is_quoted: bool, c: char)
- {
+ fn print_char(&mut self, is_quoted: bool, c: char) {
if non_quoted_token(once(c)) {
let c = char_to_string(false, c);
fn print_proper_string(&mut self, buf: String, max_depth: usize) {
self.push_char('"');
- let buf =
- if max_depth == 0 {
- String::from_iter(buf.chars().map(|c| {
- char_to_string(self.quoted, c)
- }))
- } else {
- let mut char_count = 0;
- let mut buf =
- String::from_iter(buf.chars().take(max_depth).map(|c| {
- char_count += 1;
- char_to_string(self.quoted, c)
- }));
-
- if char_count == max_depth {
- buf += " ...";
- }
+ let buf = if max_depth == 0 {
+ String::from_iter(buf.chars().map(|c| char_to_string(self.quoted, c)))
+ } else {
+ let mut char_count = 0;
+ let mut buf = String::from_iter(buf.chars().take(max_depth).map(|c| {
+ char_count += 1;
+ char_to_string(self.quoted, c)
+ }));
- buf
- };
+ if char_count == max_depth {
+ buf += " ...";
+ }
+
+ buf
+ };
self.append_str(&buf);
self.push_char('"');
}
- fn print_list_like(
- &mut self,
- iter: &mut HCPreOrderIterator,
- addr: Addr,
- mut max_depth: usize,
- ) {
+ fn print_list_like(&mut self, iter: &mut HCPreOrderIterator, addr: Addr, mut max_depth: usize) {
if self.check_max_depth(&mut max_depth) {
iter.stack().pop();
iter.stack().pop();
- self.state_stack.push(TokenOrRedirect::Atom(clause_name!("...")));
+ self.state_stack
+ .push(TokenOrRedirect::Atom(clause_name!("...")));
return;
}
- let mut heap_pstr_iter =
- self.machine_st.heap_pstr_iter(addr);
+ let mut heap_pstr_iter = self.machine_st.heap_pstr_iter(addr);
let buf = heap_pstr_iter.to_string();
let buf_len = buf.len();
- let buf_iter: Box<dyn Iterator<Item=char>> =
- if self.max_depth == 0 {
- Box::new(buf.chars())
- } else {
- Box::new(buf.chars().take(max_depth))
- };
+ let buf_iter: Box<dyn Iterator<Item = char>> = if self.max_depth == 0 {
+ Box::new(buf.chars())
+ } else {
+ Box::new(buf.chars().take(max_depth))
+ };
let mut byte_len = 0;
byte_len += c.len_utf8();
}
- for _ in 0 .. char_count {
+ for _ in 0..char_count {
self.state_stack.push(TokenOrRedirect::Close);
}
if self.max_depth > 0 && buf_len > byte_len {
- self.state_stack.push(TokenOrRedirect::Atom(clause_name!("...")));
+ self.state_stack
+ .push(TokenOrRedirect::Atom(clause_name!("...")));
} else {
- self.state_stack.push(TokenOrRedirect::FunctorRedirect(max_depth));
+ self.state_stack
+ .push(TokenOrRedirect::FunctorRedirect(max_depth));
iter.stack().push(end_addr);
}
} else {
byte_len += c.len_utf8();
}
- self.state_stack.push(TokenOrRedirect::CloseList(Rc::new(
- Cell::new((switch, 0))
- )));
+ self.state_stack
+ .push(TokenOrRedirect::CloseList(Rc::new(Cell::new((switch, 0)))));
if self.max_depth > 0 && buf_len > byte_len {
- self.state_stack.push(TokenOrRedirect::Atom(clause_name!("...")));
- } else {
- self.outputter.truncate(self.outputter.len() - ','.len_utf8());
- self.state_stack.push(TokenOrRedirect::FunctorRedirect(max_depth));
+ self.state_stack
+ .push(TokenOrRedirect::Atom(clause_name!("...")));
+ } else {
+ self.outputter
+ .truncate(self.outputter.len() - ','.len_utf8());
+ self.state_stack
+ .push(TokenOrRedirect::FunctorRedirect(max_depth));
iter.stack().push(end_addr);
}
let cell = Rc::new(Cell::new((true, 0)));
- self.state_stack.push(TokenOrRedirect::CloseList(cell.clone()));
- self.state_stack.push(TokenOrRedirect::Atom(clause_name!("...")));
+ self.state_stack
+ .push(TokenOrRedirect::CloseList(cell.clone()));
+ self.state_stack
+ .push(TokenOrRedirect::Atom(clause_name!("...")));
self.state_stack.push(TokenOrRedirect::OpenList(cell));
return;
let cell = Rc::new(Cell::new((true, max_depth)));
- self.state_stack.push(TokenOrRedirect::CloseList(cell.clone()));
+ self.state_stack
+ .push(TokenOrRedirect::CloseList(cell.clone()));
- 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));
+ self.state_stack
+ .push(TokenOrRedirect::FunctorRedirect(max_depth));
self.state_stack.push(TokenOrRedirect::OpenList(cell));
}
max_depth: usize,
) {
let add_brackets = if !self.ignore_ops {
- negated_operand || if let Some(ref op) = op {
- if self.numbervars && arity == 1 && name.as_str() == "$VAR" {
- !iter.immediate_leaf_has_property(|addr, heap| {
- match heap.index_addr(&addr).as_ref() {
- &HeapCellValue::Integer(ref n) => &**n >= &0,
- &HeapCellValue::Addr(Addr::Fixnum(n)) => n >= 0,
- &HeapCellValue::Addr(Addr::Float(f)) => f >= OrderedFloat(0f64),
- &HeapCellValue::Rational(ref r) => &**r >= &0,
- _ => false
- }
- }) && needs_bracketing(&spec, op)
+ negated_operand
+ || if let Some(ref op) = op {
+ if self.numbervars && arity == 1 && name.as_str() == "$VAR" {
+ !iter.immediate_leaf_has_property(|addr, heap| {
+ match heap.index_addr(&addr).as_ref() {
+ &HeapCellValue::Integer(ref n) => &**n >= &0,
+ &HeapCellValue::Addr(Addr::Fixnum(n)) => n >= 0,
+ &HeapCellValue::Addr(Addr::Float(f)) => f >= OrderedFloat(0f64),
+ &HeapCellValue::Rational(ref r) => &**r >= &0,
+ _ => false,
+ }
+ }) && needs_bracketing(&spec, op)
+ } else {
+ needs_bracketing(&spec, op)
+ }
} else {
- needs_bracketing(&spec, op)
+ is_functor_redirect && spec.prec() >= 1000
}
- } else {
- is_functor_redirect && spec.prec() >= 1000
- }
} else {
false
};
tcp_listener: &TcpListener,
max_depth: usize,
) {
- let (ip, port) =
- if let Some(addr) = tcp_listener.local_addr().ok() {
- (addr.ip(), Number::from(addr.port() as isize))
- } else {
- let disconnected_atom = clause_name!("$disconnected_tcp_listener");
- self.state_stack.push(TokenOrRedirect::Atom(disconnected_atom));
+ let (ip, port) = if let Some(addr) = tcp_listener.local_addr().ok() {
+ (addr.ip(), Number::from(addr.port() as isize))
+ } else {
+ let disconnected_atom = clause_name!("$disconnected_tcp_listener");
+ self.state_stack
+ .push(TokenOrRedirect::Atom(disconnected_atom));
- return;
- };
+ return;
+ };
if self.format_struct(iter, max_depth, 1, clause_name!("$tcp_listener")) {
let atom = self.state_stack.pop().unwrap();
}
}
- fn print_stream(
- &mut self,
- iter: &mut HCPreOrderIterator,
- stream: &Stream,
- max_depth: usize,
- ) {
+ fn print_stream(&mut self, iter: &mut HCPreOrderIterator, stream: &Stream, max_depth: usize) {
if let Some(alias) = &stream.options.alias {
self.print_atom(alias);
} else {
if self.format_struct(iter, max_depth, 1, clause_name!("$stream")) {
- let atom =
- if stream.is_stdout() || stream.is_stdin() {
- TokenOrRedirect::Atom(clause_name!("user"))
- } else {
- TokenOrRedirect::RawPtr(stream.as_ptr())
- };
+ let atom = if stream.is_stdout() || stream.is_stdin() {
+ TokenOrRedirect::Atom(clause_name!("user"))
+ } else {
+ TokenOrRedirect::RawPtr(stream.as_ptr())
+ };
let stream_root = self.state_stack.pop().unwrap();
match self.machine_st.heap.index_addr(&addr).as_ref() {
&HeapCellValue::NamedStr(arity, ref name, ref spec) => {
- let spec = fetch_op_spec_from_existing(name.clone(), arity, spec.clone(), self.op_dir);
+ let spec =
+ fetch_op_spec_from_existing(name.clone(), arity, spec.clone(), self.op_dir);
if let Some(spec) = spec {
self.handle_op_as_struct(
use crate::prolog_parser_rebis::ast::*;
+use crate::prolog_parser_rebis::clause_name;
use crate::prolog_parser_rebis::tabled_rc::*;
use crate::forms::*;
#[inline]
fn has_key_type(&self, key_type: OptArgIndexKeyType) -> bool {
match (self, key_type) {
- (OptArgIndexKey::Constant(..), OptArgIndexKeyType::Constant) |
- (OptArgIndexKey::Structure(..), OptArgIndexKeyType::Structure) |
- (OptArgIndexKey::List(..), OptArgIndexKeyType::List) => {
- true
- }
- _ => {
- false
- }
+ (OptArgIndexKey::Constant(..), OptArgIndexKeyType::Constant)
+ | (OptArgIndexKey::Structure(..), OptArgIndexKeyType::Structure)
+ | (OptArgIndexKey::List(..), OptArgIndexKeyType::List) => true,
+ _ => false,
}
}
}
indexing_code: &'a mut Vec<IndexingLine>,
append_or_prepend: AppendOrPrepend,
) -> Self {
- Self { skeleton, indexing_code, offset: 0, append_or_prepend }
+ Self {
+ skeleton,
+ indexing_code,
+ offset: 0,
+ append_or_prepend,
+ }
}
- fn internalize_constant(&mut self, constant_ptr: IndexingCodePtr) {
- let constant_key =
- search_skeleton_for_first_key_type(
- self.skeleton,
- OptArgIndexKeyType::Constant,
- self.append_or_prepend,
- );
+ fn internalize_constant(&mut self, constant_ptr: IndexingCodePtr) {
+ let constant_key = search_skeleton_for_first_key_type(
+ self.skeleton,
+ OptArgIndexKeyType::Constant,
+ self.append_or_prepend,
+ );
let mut constants = IndexMap::new();
if let IndexingCodePtr::Internal(_) = constant_ptr {
self.indexing_code.push(IndexingLine::Indexing(
- IndexingInstruction::SwitchOnConstant(constants)
+ IndexingInstruction::SwitchOnConstant(constants),
));
let last_index = self.indexing_code.len() - 1;
self.offset = self.indexing_code.len();
self.indexing_code.push(IndexingLine::Indexing(
- IndexingInstruction::SwitchOnConstant(constants)
+ IndexingInstruction::SwitchOnConstant(constants),
));
}
}
- fn add_indexed_choice_for_constant(&mut self, external: usize, constant: Constant, index: usize)
- {
- let third_level_index =
- if self.append_or_prepend.is_append() {
- sdeq![
- IndexedChoiceInstruction::Try(external),
- IndexedChoiceInstruction::Trust(index)
- ]
- } else {
- sdeq![
- IndexedChoiceInstruction::Try(index),
- IndexedChoiceInstruction::Trust(external)
- ]
- };
+ fn add_indexed_choice_for_constant(
+ &mut self,
+ external: usize,
+ constant: Constant,
+ index: usize,
+ ) {
+ let third_level_index = if self.append_or_prepend.is_append() {
+ sdeq![
+ IndexedChoiceInstruction::Try(external),
+ IndexedChoiceInstruction::Trust(index)
+ ]
+ } else {
+ sdeq![
+ IndexedChoiceInstruction::Try(index),
+ IndexedChoiceInstruction::Trust(external)
+ ]
+ };
let indexing_code_len = self.indexing_code.len();
- self.indexing_code.push(IndexingLine::IndexedChoice(third_level_index));
+ self.indexing_code
+ .push(IndexingLine::IndexedChoice(third_level_index));
match &mut self.indexing_code[self.offset] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnConstant(ref mut constants)
- ) => {
- constants.insert(constant, IndexingCodePtr::Internal(indexing_code_len - self.offset));
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnConstant(ref mut constants)) => {
+ constants.insert(
+ constant,
+ IndexingCodePtr::Internal(indexing_code_len - self.offset),
+ );
}
_ => {
unreachable!()
fn extend_indexed_choice(&mut self, index: usize) {
match &mut self.indexing_code[self.offset] {
IndexingLine::IndexedChoice(ref mut indexed_choice_instrs)
- if self.append_or_prepend.is_append() => {
- uncap_choice_seq_with_trust(indexed_choice_instrs);
- indexed_choice_instrs.push_back(IndexedChoiceInstruction::Trust(index));
- }
+ if self.append_or_prepend.is_append() =>
+ {
+ uncap_choice_seq_with_trust(indexed_choice_instrs);
+ indexed_choice_instrs.push_back(IndexedChoiceInstruction::Trust(index));
+ }
IndexingLine::IndexedChoice(ref mut indexed_choice_instrs) => {
uncap_choice_seq_with_try(indexed_choice_instrs);
indexed_choice_instrs.push_front(IndexedChoiceInstruction::Try(index));
let indexing_code_len = self.indexing_code.len();
match &mut self.indexing_code[self.offset] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnTerm(_, _, ref mut c, ..)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, _, ref mut c, ..)) => {
match *c {
IndexingCodePtr::Fail => {
*c = IndexingCodePtr::External(index);
*c = IndexingCodePtr::Internal(indexing_code_len);
self.indexing_code.push(IndexingLine::Indexing(
- IndexingInstruction::SwitchOnConstant(constants)
+ IndexingInstruction::SwitchOnConstant(constants),
));
self.offset = indexing_code_len;
}
}
}
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnConstant(constants)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnConstant(constants)) => {
match constants.get(&overlapping_constant).cloned() {
None | Some(IndexingCodePtr::Fail) => {
- constants.insert(overlapping_constant, IndexingCodePtr::External(index));
+ constants
+ .insert(overlapping_constant, IndexingCodePtr::External(index));
}
Some(IndexingCodePtr::External(o)) => {
self.add_indexed_choice_for_constant(o, overlapping_constant, index);
break;
}
IndexingLine::IndexedChoice(_) => {
- self.internalize_constant(
- IndexingCodePtr::Internal(indexing_code_len - self.offset),
- );
+ self.internalize_constant(IndexingCodePtr::Internal(
+ indexing_code_len - self.offset,
+ ));
}
_ => {
unreachable!()
let indexing_code_len = self.indexing_code.len();
match &mut self.indexing_code[self.offset] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnTerm(_, _, ref mut c, ..)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, _, ref mut c, ..)) => {
match *c {
IndexingCodePtr::Fail => {
*c = IndexingCodePtr::External(index);
}
}
}
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnConstant(constants)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnConstant(constants)) => {
match constants.get(&constant).cloned() {
None | Some(IndexingCodePtr::Fail) => {
constants.insert(constant, IndexingCodePtr::External(index));
break;
}
IndexingLine::IndexedChoice(_) => {
- self.internalize_constant(
- IndexingCodePtr::Internal(indexing_code_len - self.offset),
- );
+ self.internalize_constant(IndexingCodePtr::Internal(
+ indexing_code_len - self.offset,
+ ));
}
_ => {
unreachable!()
}
}
- fn internalize_structure(&mut self, structure_ptr: IndexingCodePtr) {
- let structure_key =
- search_skeleton_for_first_key_type(
- self.skeleton,
- OptArgIndexKeyType::Structure,
- self.append_or_prepend,
- );
+ fn internalize_structure(&mut self, structure_ptr: IndexingCodePtr) {
+ let structure_key = search_skeleton_for_first_key_type(
+ self.skeleton,
+ OptArgIndexKeyType::Structure,
+ self.append_or_prepend,
+ );
let mut structures = IndexMap::new();
if let IndexingCodePtr::Internal(_) = structure_ptr {
self.indexing_code.push(IndexingLine::Indexing(
- IndexingInstruction::SwitchOnStructure(structures)
+ IndexingInstruction::SwitchOnStructure(structures),
));
let last_index = self.indexing_code.len() - 1;
self.offset = self.indexing_code.len();
self.indexing_code.push(IndexingLine::Indexing(
- IndexingInstruction::SwitchOnStructure(structures)
+ IndexingInstruction::SwitchOnStructure(structures),
));
}
}
- fn add_indexed_choice_for_structure(&mut self, external: usize, key: PredicateKey, index: usize)
- {
- let third_level_index =
- if self.append_or_prepend.is_append() {
- sdeq![
- IndexedChoiceInstruction::Try(external),
- IndexedChoiceInstruction::Trust(index)
- ]
- } else {
- sdeq![
- IndexedChoiceInstruction::Try(index),
- IndexedChoiceInstruction::Trust(external)
- ]
- };
+ fn add_indexed_choice_for_structure(
+ &mut self,
+ external: usize,
+ key: PredicateKey,
+ index: usize,
+ ) {
+ let third_level_index = if self.append_or_prepend.is_append() {
+ sdeq![
+ IndexedChoiceInstruction::Try(external),
+ IndexedChoiceInstruction::Trust(index)
+ ]
+ } else {
+ sdeq![
+ IndexedChoiceInstruction::Try(index),
+ IndexedChoiceInstruction::Trust(external)
+ ]
+ };
let indexing_code_len = self.indexing_code.len();
- self.indexing_code.push(IndexingLine::IndexedChoice(third_level_index));
+ self.indexing_code
+ .push(IndexingLine::IndexedChoice(third_level_index));
match &mut self.indexing_code[self.offset] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnStructure(ref mut structures)
- ) => {
- structures.insert(key, IndexingCodePtr::Internal(indexing_code_len - self.offset));
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnStructure(ref mut structures)) => {
+ structures.insert(
+ key,
+ IndexingCodePtr::Internal(indexing_code_len - self.offset),
+ );
}
_ => {
unreachable!()
let indexing_code_len = self.indexing_code.len();
match &mut self.indexing_code[self.offset] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnTerm(_, _, _, _, ref mut s)
- ) => {
- match *s {
- IndexingCodePtr::Fail => {
- *s = IndexingCodePtr::External(index);
- break;
- }
- IndexingCodePtr::External(o) => {
- *s = IndexingCodePtr::Internal(indexing_code_len - self.offset);
- self.internalize_structure(IndexingCodePtr::External(o));
- }
- IndexingCodePtr::Internal(o) => {
- self.offset += o;
- }
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(
+ _,
+ _,
+ _,
+ _,
+ ref mut s,
+ )) => match *s {
+ IndexingCodePtr::Fail => {
+ *s = IndexingCodePtr::External(index);
+ break;
}
- }
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnStructure(structures)
- ) => {
+ IndexingCodePtr::External(o) => {
+ *s = IndexingCodePtr::Internal(indexing_code_len - self.offset);
+ self.internalize_structure(IndexingCodePtr::External(o));
+ }
+ IndexingCodePtr::Internal(o) => {
+ self.offset += o;
+ }
+ },
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnStructure(structures)) => {
match structures.get(&key).cloned() {
None | Some(IndexingCodePtr::Fail) => {
structures.insert(key, IndexingCodePtr::External(index));
// replace this value, at self.offset, with
// SwitchOnStructures, and swap this IndexedChoice
// vector to the end of self.indexing_code.
- self.internalize_structure(
- IndexingCodePtr::Internal(indexing_code_len - self.offset),
- );
+ self.internalize_structure(IndexingCodePtr::Internal(
+ indexing_code_len - self.offset,
+ ));
}
_ => {
unreachable!()
let indexing_code_len = self.indexing_code.len();
match &mut self.indexing_code[self.offset] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnTerm(_, _, _, ref mut l, _)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, _, _, ref mut l, _)) => {
match *l {
IndexingCodePtr::Fail => {
*l = IndexingCodePtr::External(index);
IndexingCodePtr::External(o) => {
*l = IndexingCodePtr::Internal(indexing_code_len - self.offset);
- let third_level_index =
- if self.append_or_prepend.is_append() {
- sdeq![
- IndexedChoiceInstruction::Try(o),
- IndexedChoiceInstruction::Trust(index)
- ]
- } else {
- sdeq![
- IndexedChoiceInstruction::Try(index),
- IndexedChoiceInstruction::Trust(o)
- ]
- };
-
- self.indexing_code.push(
- IndexingLine::IndexedChoice(third_level_index),
- );
+ let third_level_index = if self.append_or_prepend.is_append() {
+ sdeq![
+ IndexedChoiceInstruction::Try(o),
+ IndexedChoiceInstruction::Trust(index)
+ ]
+ } else {
+ sdeq![
+ IndexedChoiceInstruction::Try(index),
+ IndexedChoiceInstruction::Trust(o)
+ ]
+ };
+
+ self.indexing_code
+ .push(IndexingLine::IndexedChoice(third_level_index));
}
IndexingCodePtr::Internal(o) => {
self.offset += o;
pub fn merge_clause_index(
target_indexing_code: &mut Vec<IndexingLine>,
skeleton: &mut [ClauseIndexInfo], // the clause to be merged is the last element in the skeleton.
- new_clause_loc: usize, // the absolute location of the new clause in the code vector.
+ new_clause_loc: usize, // the absolute location of the new clause in the code vector.
append_or_prepend: AppendOrPrepend,
) {
- let opt_arg_index_key =
- match append_or_prepend {
- AppendOrPrepend::Append => {
- skeleton.last_mut().unwrap().opt_arg_index_key.take()
- }
- AppendOrPrepend::Prepend => {
- skeleton.first_mut().unwrap().opt_arg_index_key.take()
- }
- };
+ let opt_arg_index_key = match append_or_prepend {
+ AppendOrPrepend::Append => skeleton.last_mut().unwrap().opt_arg_index_key.take(),
+ AppendOrPrepend::Prepend => skeleton.first_mut().unwrap().opt_arg_index_key.take(),
+ };
- let mut merging_ptr = IndexingCodeMergingPtr::new(
- skeleton,
- target_indexing_code,
- append_or_prepend,
- );
+ let mut merging_ptr =
+ IndexingCodeMergingPtr::new(skeleton, target_indexing_code, append_or_prepend);
match &opt_arg_index_key {
OptArgIndexKey::Constant(_, index_loc, ref constant, ref overlapping_constants) => {
for overlapping_constant in overlapping_constants {
merging_ptr.index_overlapping_constant(
- constant, overlapping_constant.clone(), offset,
+ constant,
+ overlapping_constant.clone(),
+ offset,
);
}
}
}
#[inline]
-fn remove_instruction_with_offset(
- code: &mut SliceDeque<IndexedChoiceInstruction>,
- offset: usize,
-) {
+fn remove_instruction_with_offset(code: &mut SliceDeque<IndexedChoiceInstruction>, offset: usize) {
for (index, line) in code.iter().enumerate() {
if offset == line.offset() {
code.remove(index);
let iter = once(constant).chain(overlapping_constants.iter());
match &mut indexing_code[index] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnTerm(_, _, ref mut c, ..)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, _, ref mut c, ..)) => {
match *c {
IndexingCodePtr::External(_) => {
*c = IndexingCodePtr::Fail;
let mut constants_index = 0;
- for constant in iter { // (constant, index_loc) in iter.zip(index_locs.iter()) {
+ for constant in iter {
+ // (constant, index_loc) in iter.zip(index_locs.iter()) {
loop {
match &mut indexing_code[index] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnConstant(ref mut constants)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnConstant(
+ ref mut constants,
+ )) => {
constants_index = index;
match constants.get(constant).cloned() {
if indexed_choice_instrs.len() == 1 {
let ext = IndexingCodePtr::External(
- indexed_choice_instrs.pop_back().unwrap().offset()
+ indexed_choice_instrs.pop_back().unwrap().offset(),
);
match &mut indexing_code[constants_index] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnTerm(_, _, ref mut c, ..)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(
+ _,
+ _,
+ ref mut c,
+ ..,
+ )) => {
*c = ext;
}
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnConstant(ref mut constants)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnConstant(
+ ref mut constants,
+ )) => {
constants.insert(constant.clone(), ext);
}
_ => {
}
match &indexing_code[constants_index] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnConstant(ref constants)
- ) if constants.is_empty() => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnConstant(ref constants))
+ if constants.is_empty() =>
+ {
match &mut indexing_code[0] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnTerm(_, _, ref mut c, ..)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, _, ref mut c, ..)) => {
*c = IndexingCodePtr::Fail;
}
_ => {
}
}
}
- _ => {
- }
+ _ => {}
}
}
let mut index = 0;
match &mut indexing_code[index] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnTerm(_, _, _, _, ref mut s)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, _, _, _, ref mut s)) => {
match *s {
IndexingCodePtr::External(_) => {
*s = IndexingCodePtr::Fail;
loop {
match &mut indexing_code[index] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnStructure(ref mut structures)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnStructure(ref mut structures)) => {
structures_index = index;
match structures.get(&(name.clone(), arity)).cloned() {
if indexed_choice_instrs.len() == 1 {
let ext = IndexingCodePtr::External(
- indexed_choice_instrs.pop_back().unwrap().offset()
+ indexed_choice_instrs.pop_back().unwrap().offset(),
);
match &mut indexing_code[structures_index] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnTerm(_, _, _, _, ref mut s)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(
+ _,
+ _,
+ _,
+ _,
+ ref mut s,
+ )) => {
*s = ext;
}
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnStructure(ref mut structures)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnStructure(
+ ref mut structures,
+ )) => {
structures.insert((name.clone(), arity), ext);
}
_ => {
}
match &indexing_code[structures_index] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnStructure(ref structures)
- ) if structures.is_empty() => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnStructure(ref structures))
+ if structures.is_empty() =>
+ {
match &mut indexing_code[0] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnTerm(_, _, _, _, ref mut s)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(
+ _,
+ _,
+ _,
+ _,
+ ref mut s,
+ )) => {
*s = IndexingCodePtr::Fail;
}
_ => {
}
}
}
- _ => {
- }
+ _ => {}
}
}
-pub fn remove_list_index(
- indexing_code: &mut Vec<IndexingLine>,
- offset: usize,
-) {
+pub fn remove_list_index(indexing_code: &mut Vec<IndexingLine>, offset: usize) {
let mut index = 0;
match &mut indexing_code[index] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnTerm(_, _, _, ref mut l, _)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, _, _, ref mut l, _)) => {
match *l {
IndexingCodePtr::External(_) => {
*l = IndexingCodePtr::Fail;
remove_instruction_with_offset(indexed_choice_instrs, offset);
if indexed_choice_instrs.len() == 1 {
- let ext = IndexingCodePtr::External(
- indexed_choice_instrs.pop_back().unwrap().offset()
- );
+ let ext =
+ IndexingCodePtr::External(indexed_choice_instrs.pop_back().unwrap().offset());
match &mut indexing_code[0] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnTerm(_, _, _, ref mut l, _)
- ) => {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(
+ _,
+ _,
+ _,
+ ref mut l,
+ _,
+ )) => {
*l = ext;
}
_ => {
fn second_level_index<IndexKey: Eq + Hash>(
indices: IndexMap<IndexKey, SliceDeque<IndexedChoiceInstruction>>,
prelude: &mut SliceDeque<IndexingLine>,
-) -> IndexMap<IndexKey, IndexingCodePtr>
-{
+) -> IndexMap<IndexKey, IndexingCodePtr> {
let mut index_locs = IndexMap::new();
for (key, mut code) in indices.into_iter() {
IndexingCodePtr::Internal(1)
} else {
- index.into_iter()
- .next()
- .map(|(_, v)| v)
- .unwrap_or(IndexingCodePtr::Fail)
+ index
+ .into_iter()
+ .next()
+ .map(|(_, v)| v)
+ .unwrap_or(IndexingCodePtr::Fail)
}
}
prelude.push_back(IndexingLine::from(lists));
IndexingCodePtr::Internal(1)
} else {
- lists.first()
- .map(|i| IndexingCodePtr::External(i.offset()))
- .unwrap_or(IndexingCodePtr::Fail)
+ lists
+ .first()
+ .map(|i| IndexingCodePtr::External(i.offset()))
+ .unwrap_or(IndexingCodePtr::Fail)
}
}
constants.push(Constant::Fixnum(n));
}
}
- _ => {
- }
+ _ => {}
}
constants
constants: IndexMap::new(),
lists: sdeq![],
structures: IndexMap::new(),
- optimal_index
+ optimal_index,
}
}
}
fn index_constant(&mut self, constant: &Constant, index: usize) -> Vec<Constant> {
- let overlapping_constants =
- constant_key_alternatives(constant, self.atom_tbl.clone());
+ let overlapping_constants = constant_key_alternatives(constant, self.atom_tbl.clone());
- let code = self.constants
- .entry(constant.clone())
- .or_insert(sdeq![]);
+ let code = self.constants.entry(constant.clone()).or_insert(sdeq![]);
let is_initial_index = code.is_empty();
code.push_back(compute_index(is_initial_index, index));
for constant in &overlapping_constants {
- let code = self.constants
- .entry(constant.clone())
- .or_insert(sdeq![]);
+ let code = self.constants.entry(constant.clone()).or_insert(sdeq![]);
let is_initial_index = code.is_empty();
let index = compute_index(is_initial_index, index);
self.index_structure(name, terms.len(), index);
}
&Term::Cons(..) | &Term::Constant(_, Constant::String(_)) => {
- clause_index_info.opt_arg_index_key =
- OptArgIndexKey::List(self.optimal_index, 0);
+ clause_index_info.opt_arg_index_key = OptArgIndexKey::List(self.optimal_index, 0);
self.index_list(index);
}
&Term::Constant(_, ref constant) => {
- let overlapping_constants =
- self.index_constant(constant, index);
+ let overlapping_constants = self.index_constant(constant, index);
- clause_index_info.opt_arg_index_key =
- OptArgIndexKey::Constant(
- self.optimal_index,
- 0,
- constant.clone(),
- overlapping_constants,
- );
- }
- _ => {
+ clause_index_info.opt_arg_index_key = OptArgIndexKey::Constant(
+ self.optimal_index,
+ 0,
+ constant.clone(),
+ overlapping_constants,
+ );
}
+ _ => {}
}
}
IndexingCodePtr::Internal(ref mut i) => {
*i += con_loc.is_internal() as usize;
}
- _ => {
- }
+ _ => {}
};
match &mut lst_loc {
*i += con_loc.is_internal() as usize;
*i += str_loc.is_internal() as usize;
}
- _ => {
- }
+ _ => {}
};
let var_offset = 1 + skip_stub_try_me_else as usize;
- prelude.push_front(IndexingLine::from(
- IndexingInstruction::SwitchOnTerm(self.optimal_index, var_offset, con_loc, lst_loc, str_loc)
- ));
+ prelude.push_front(IndexingLine::from(IndexingInstruction::SwitchOnTerm(
+ self.optimal_index,
+ var_offset,
+ con_loc,
+ lst_loc,
+ str_loc,
+ )));
prelude.into_iter().collect()
}
use crate::prolog_parser_rebis::ast::*;
+use crate::prolog_parser_rebis::clause_name;
use crate::clause_types::*;
use crate::forms::*;
impl ArithmeticTerm {
fn into_functor(&self) -> MachineStub {
match self {
- &ArithmeticTerm::Reg(r) => {
- reg_type_into_functor(r)
- }
+ &ArithmeticTerm::Reg(r) => reg_type_into_functor(r),
&ArithmeticTerm::Interm(i) => {
functor!("intermediate", [integer(i)])
}
pub fn enqueue_functors(&self, mut h: usize, functors: &mut Vec<MachineStub>) {
match self {
- &Line::Arithmetic(ref arith_instr) =>
- functors.push(arith_instr.to_functor(h)),
- &Line::Choice(ref choice_instr) =>
- functors.push(choice_instr.to_functor()),
- &Line::Control(ref control_instr) =>
- functors.push(control_instr.to_functor()),
- &Line::Cut(ref cut_instr) =>
- functors.push(cut_instr.to_functor(h)),
- &Line::Fact(ref fact_instr) =>
- functors.push(fact_instr.to_functor(h)),
+ &Line::Arithmetic(ref arith_instr) => functors.push(arith_instr.to_functor(h)),
+ &Line::Choice(ref choice_instr) => functors.push(choice_instr.to_functor()),
+ &Line::Control(ref control_instr) => functors.push(control_instr.to_functor()),
+ &Line::Cut(ref cut_instr) => functors.push(cut_instr.to_functor(h)),
+ &Line::Fact(ref fact_instr) => functors.push(fact_instr.to_functor(h)),
&Line::IndexingCode(ref indexing_instrs) => {
for indexing_instr in indexing_instrs {
match indexing_instr {
}
}
}
- &Line::IndexedChoice(ref indexed_choice_instr) =>
- functors.push(indexed_choice_instr.to_functor()),
- &Line::Query(ref query_instr) =>
- functors.push(query_instr.to_functor(h)),
+ &Line::IndexedChoice(ref indexed_choice_instr) => {
+ functors.push(indexed_choice_instr.to_functor())
+ }
+ &Line::Query(ref query_instr) => functors.push(query_instr.to_functor(h)),
}
}
}
#[inline]
pub fn to_indexing_line_mut(line: &mut Line) -> Option<&mut Vec<IndexingLine>> {
match line {
- Line::IndexingCode(ref mut indexing_code) => {
- Some(indexing_code)
- }
- _ => {
- None
- }
+ Line::IndexingCode(ref mut indexing_code) => Some(indexing_code),
+ _ => None,
}
}
#[inline]
pub fn to_indexing_line(line: &Line) -> Option<&Vec<IndexingLine>> {
match line {
- Line::IndexingCode(ref indexing_code) => {
- Some(indexing_code)
- }
- _ => {
- None
- }
+ Line::IndexingCode(ref indexing_code) => Some(indexing_code),
+ _ => None,
}
}
) -> MachineStub {
let at_stub = at.into_functor();
- functor!(
- name,
- [aux(h, 0), integer(t)],
- [at_stub]
- )
+ functor!(name, [aux(h, 0), integer(t)], [at_stub])
}
fn arith_instr_bin_functor(
&ArithmeticInstruction::Gcd(ref at_1, ref at_2, t) => {
arith_instr_bin_functor(h, "gcd", at_1, at_2, t)
}
- &ArithmeticInstruction::Sign(ref at, t) => {
- arith_instr_unary_functor(h, "sign", at, t)
- }
- &ArithmeticInstruction::Cos(ref at, t) => {
- arith_instr_unary_functor(h, "cos", at, t)
- }
- &ArithmeticInstruction::Sin(ref at, t) => {
- arith_instr_unary_functor(h, "sin", at, t)
- }
- &ArithmeticInstruction::Tan(ref at, t) => {
- arith_instr_unary_functor(h, "tan", at, t)
- }
- &ArithmeticInstruction::Log(ref at, t) => {
- arith_instr_unary_functor(h, "log", at, t)
- }
- &ArithmeticInstruction::Exp(ref at, t) => {
- arith_instr_unary_functor(h, "exp", at, t)
- }
- &ArithmeticInstruction::ACos(ref at, t) => {
- arith_instr_unary_functor(h, "acos", at, t)
- }
- &ArithmeticInstruction::ASin(ref at, t) => {
- arith_instr_unary_functor(h, "asin", at, t)
- }
- &ArithmeticInstruction::ATan(ref at, t) => {
- arith_instr_unary_functor(h, "atan", at, t)
- }
- &ArithmeticInstruction::Sqrt(ref at, t) => {
- arith_instr_unary_functor(h, "sqrt", at, t)
- }
- &ArithmeticInstruction::Abs(ref at, t) => {
- arith_instr_unary_functor(h, "abs", at, t)
- }
+ &ArithmeticInstruction::Sign(ref at, t) => arith_instr_unary_functor(h, "sign", at, t),
+ &ArithmeticInstruction::Cos(ref at, t) => arith_instr_unary_functor(h, "cos", at, t),
+ &ArithmeticInstruction::Sin(ref at, t) => arith_instr_unary_functor(h, "sin", at, t),
+ &ArithmeticInstruction::Tan(ref at, t) => arith_instr_unary_functor(h, "tan", at, t),
+ &ArithmeticInstruction::Log(ref at, t) => arith_instr_unary_functor(h, "log", at, t),
+ &ArithmeticInstruction::Exp(ref at, t) => arith_instr_unary_functor(h, "exp", at, t),
+ &ArithmeticInstruction::ACos(ref at, t) => arith_instr_unary_functor(h, "acos", at, t),
+ &ArithmeticInstruction::ASin(ref at, t) => arith_instr_unary_functor(h, "asin", at, t),
+ &ArithmeticInstruction::ATan(ref at, t) => arith_instr_unary_functor(h, "atan", at, t),
+ &ArithmeticInstruction::Sqrt(ref at, t) => arith_instr_unary_functor(h, "sqrt", at, t),
+ &ArithmeticInstruction::Abs(ref at, t) => arith_instr_unary_functor(h, "abs", at, t),
&ArithmeticInstruction::Float(ref at, t) => {
arith_instr_unary_functor(h, "float", at, t)
}
&ArithmeticInstruction::Floor(ref at, t) => {
arith_instr_unary_functor(h, "floor", at, t)
}
- &ArithmeticInstruction::Neg(ref at, t) => {
- arith_instr_unary_functor(h, "-", at, t)
- }
- &ArithmeticInstruction::Plus(ref at, t) => {
- arith_instr_unary_functor(h, "+", at, t)
- }
+ &ArithmeticInstruction::Neg(ref at, t) => arith_instr_unary_functor(h, "-", at, t),
+ &ArithmeticInstruction::Plus(ref at, t) => arith_instr_unary_functor(h, "+", at, t),
&ArithmeticInstruction::BitwiseComplement(ref at, t) => {
arith_instr_unary_functor(h, "\\", at, t)
}
CallClause(ClauseType, usize, usize, bool, bool),
Deallocate,
JmpBy(usize, usize, usize, bool), // arity, global_offset, perm_vars after threshold, last call.
- RevJmpBy(usize), // notice the lack of context change as in
- // JmpBy. RevJmpBy is used only to patch extensible
- // predicates together.
+ RevJmpBy(usize), // notice the lack of context change as in
+ // JmpBy. RevJmpBy is used only to patch extensible
+ // predicates together.
Proceed,
}
impl ControlInstruction {
pub fn perm_vars(&self) -> Option<usize> {
match self {
- ControlInstruction::CallClause(_, _, num_cells, ..) =>
- Some(*num_cells),
- ControlInstruction::JmpBy(_, _, num_cells, ..) =>
- Some(*num_cells),
- _ =>
- None
+ ControlInstruction::CallClause(_, _, num_cells, ..) => Some(*num_cells),
+ ControlInstruction::JmpBy(_, _, num_cells, ..) => Some(*num_cells),
+ _ => None,
}
}
#[derive(Debug)]
pub enum IndexingInstruction {
// The first index is the optimal argument being indexed.
- SwitchOnTerm(usize, usize, IndexingCodePtr, IndexingCodePtr, IndexingCodePtr),
+ SwitchOnTerm(
+ usize,
+ usize,
+ IndexingCodePtr,
+ IndexingCodePtr,
+ IndexingCodePtr,
+ ),
SwitchOnConstant(IndexMap<Constant, IndexingCodePtr>),
SwitchOnStructure(IndexMap<(ClauseName, usize), IndexingCodePtr>),
}
&IndexingInstruction::SwitchOnTerm(arg, vars, constants, lists, structures) => {
functor!(
"switch_on_term",
- [integer(arg),
- integer(vars),
- indexing_code_ptr(h, constants),
- indexing_code_ptr(h, lists),
- indexing_code_ptr(h, structures)]
+ [
+ integer(arg),
+ integer(vars),
+ indexing_code_ptr(h, constants),
+ indexing_code_ptr(h, lists),
+ indexing_code_ptr(h, structures)
+ ]
)
}
&IndexingInstruction::SwitchOnConstant(ref constants) => {
let key_value_pair = functor!(
":",
SharedOpDesc::new(600, XFY),
- [constant(c),
- indexing_code_ptr(h + 3, *ptr)]
+ [constant(c), indexing_code_ptr(h + 3, *ptr)]
);
key_value_list_stub.push(HeapCellValue::Addr(Addr::Lis(h + 1)));
key_value_list_stub.push(HeapCellValue::Addr(Addr::Str(h + 3)));
- key_value_list_stub.push(HeapCellValue::Addr(
- Addr::HeapCell(h + 3 + key_value_pair.len())
- ));
+ key_value_list_stub.push(HeapCellValue::Addr(Addr::HeapCell(
+ h + 3 + key_value_pair.len(),
+ )));
h += key_value_pair.len() + 3;
key_value_list_stub.extend(key_value_pair.into_iter());
let predicate_indicator_stub = functor!(
"/",
SharedOpDesc::new(400, YFX),
- [clause_name(name.clone()),
- integer(*arity)]
+ [clause_name(name.clone()), integer(*arity)]
);
let key_value_pair = functor!(
":",
SharedOpDesc::new(600, XFY),
- [aux(h + 3, 0),
- indexing_code_ptr(h + 3, *ptr)],
+ [aux(h + 3, 0), indexing_code_ptr(h + 3, *ptr)],
[predicate_indicator_stub]
);
key_value_list_stub.push(HeapCellValue::Addr(Addr::Lis(h + 1)));
key_value_list_stub.push(HeapCellValue::Addr(Addr::Str(h + 3)));
- key_value_list_stub.push(HeapCellValue::Addr(
- Addr::HeapCell(h + 3 + key_value_pair.len())
- ));
+ key_value_list_stub.push(HeapCellValue::Addr(Addr::HeapCell(
+ h + 3 + key_value_pair.len(),
+ )));
h += key_value_pair.len() + 3;
key_value_list_stub.extend(key_value_pair.into_iter());
match self {
&FactInstruction::GetConstant(lvl, ref c, r) => {
let lvl_stub = lvl.into_functor();
- let rt_stub = reg_type_into_functor(r);
+ let rt_stub = reg_type_into_functor(r);
functor!(
"get_constant",
}
&FactInstruction::GetList(lvl, r) => {
let lvl_stub = lvl.into_functor();
- let rt_stub = reg_type_into_functor(r);
+ let rt_stub = reg_type_into_functor(r);
- functor!(
- "get_list",
- [aux(h, 0), aux(h, 1)],
- [lvl_stub, rt_stub]
- )
+ functor!("get_list", [aux(h, 0), aux(h, 1)], [lvl_stub, rt_stub])
}
&FactInstruction::GetPartialString(lvl, ref s, r, has_tail) => {
let lvl_stub = lvl.into_functor();
- let rt_stub = reg_type_into_functor(r);
+ let rt_stub = reg_type_into_functor(r);
functor!(
"get_partial_string",
&FactInstruction::GetValue(r, arg) => {
let rt_stub = reg_type_into_functor(r);
- functor!(
- "get_value",
- [aux(h, 0), integer(arg)],
- [rt_stub]
- )
+ functor!("get_value", [aux(h, 0), integer(arg)], [rt_stub])
}
&FactInstruction::GetVariable(r, arg) => {
let rt_stub = reg_type_into_functor(r);
- functor!(
- "get_variable",
- [aux(h, 0), integer(arg)],
- [rt_stub]
- )
+ functor!("get_variable", [aux(h, 0), integer(arg)], [rt_stub])
}
&FactInstruction::UnifyConstant(ref c) => {
functor!("unify_constant", [constant(h, c)], [])
&FactInstruction::UnifyLocalValue(r) => {
let rt_stub = reg_type_into_functor(r);
- functor!(
- "unify_local_value",
- [aux(h, 0)],
- [rt_stub]
- )
+ functor!("unify_local_value", [aux(h, 0)], [rt_stub])
}
&FactInstruction::UnifyVariable(r) => {
let rt_stub = reg_type_into_functor(r);
- functor!(
- "unify_variable",
- [aux(h, 0)],
- [rt_stub]
- )
+ functor!("unify_variable", [aux(h, 0)], [rt_stub])
}
&FactInstruction::UnifyValue(r) => {
let rt_stub = reg_type_into_functor(r);
- functor!(
- "unify_value",
- [aux(h, 0)],
- [rt_stub]
- )
+ functor!("unify_value", [aux(h, 0)], [rt_stub])
}
&FactInstruction::UnifyVoid(vars) => {
functor!("unify_void", [integer(vars)])
impl QueryInstruction {
pub fn to_functor(&self, h: usize) -> MachineStub {
match self {
- &QueryInstruction::PutUnsafeValue(norm, arg) => functor!(
- "put_unsafe_value",
- [integer(norm), integer(arg)]
- ),
+ &QueryInstruction::PutUnsafeValue(norm, arg) => {
+ functor!("put_unsafe_value", [integer(norm), integer(arg)])
+ }
&QueryInstruction::PutConstant(lvl, ref c, r) => {
let lvl_stub = lvl.into_functor();
- let rt_stub = reg_type_into_functor(r);
+ let rt_stub = reg_type_into_functor(r);
functor!(
"put_constant",
}
&QueryInstruction::PutList(lvl, r) => {
let lvl_stub = lvl.into_functor();
- let rt_stub = reg_type_into_functor(r);
+ let rt_stub = reg_type_into_functor(r);
- functor!(
- "put_list",
- [aux(h, 0), aux(h, 1)],
- [lvl_stub, rt_stub]
- )
+ functor!("put_list", [aux(h, 0), aux(h, 1)], [lvl_stub, rt_stub])
}
&QueryInstruction::PutPartialString(lvl, ref s, r, has_tail) => {
let lvl_stub = lvl.into_functor();
- let rt_stub = reg_type_into_functor(r);
+ let rt_stub = reg_type_into_functor(r);
functor!(
"put_partial_string",
&QueryInstruction::PutValue(r, arg) => {
let rt_stub = reg_type_into_functor(r);
- functor!(
- "put_value",
- [aux(h, 0), integer(arg)],
- [rt_stub]
- )
+ functor!("put_value", [aux(h, 0), integer(arg)], [rt_stub])
}
&QueryInstruction::GetVariable(r, arg) => {
let rt_stub = reg_type_into_functor(r);
- functor!(
- "get_variable",
- [aux(h, 0), integer(arg)],
- [rt_stub]
- )
+ functor!("get_variable", [aux(h, 0), integer(arg)], [rt_stub])
}
&QueryInstruction::PutVariable(r, arg) => {
let rt_stub = reg_type_into_functor(r);
- functor!(
- "put_variable",
- [aux(h, 0), integer(arg)],
- [rt_stub]
- )
+ functor!("put_variable", [aux(h, 0), integer(arg)], [rt_stub])
}
&QueryInstruction::SetConstant(ref c) => {
functor!("set_constant", [constant(h, c)], [])
&QueryInstruction::SetLocalValue(r) => {
let rt_stub = reg_type_into_functor(r);
- functor!(
- "set_local_value",
- [aux(h, 0)],
- [rt_stub]
- )
+ functor!("set_local_value", [aux(h, 0)], [rt_stub])
}
&QueryInstruction::SetVariable(r) => {
let rt_stub = reg_type_into_functor(r);
- functor!(
- "set_variable",
- [aux(h, 0)],
- [rt_stub]
- )
+ functor!("set_variable", [aux(h, 0)], [rt_stub])
}
&QueryInstruction::SetValue(r) => {
let rt_stub = reg_type_into_functor(r);
- functor!(
- "set_value",
- [aux(h, 0)],
- [rt_stub]
- )
+ functor!("set_value", [aux(h, 0)], [rt_stub])
}
&QueryInstruction::SetVoid(vars) => {
functor!("set_void", [integer(vars)])
use crate::prolog_parser_rebis::ast::*;
+use crate::prolog_parser_rebis::rc_atom;
use crate::clause_types::*;
use crate::forms::*;
pub fn level(self) -> Level {
match self {
TermRef::AnonVar(lvl)
- | TermRef::Cons(lvl, ..)
- | TermRef::Constant(lvl, ..)
- | TermRef::Var(lvl, ..)
- | TermRef::Clause(lvl, ..) => lvl,
- | TermRef::PartialString(lvl, ..) => lvl,
+ | TermRef::Cons(lvl, ..)
+ | TermRef::Constant(lvl, ..)
+ | TermRef::Var(lvl, ..)
+ | TermRef::Clause(lvl, ..) => lvl,
+ TermRef::PartialString(lvl, ..) => lvl,
}
}
}
Var(Level, &'a Cell<VarReg>, Rc<Var>),
}
-fn is_partial_string<'a>(
- head: &'a Term,
- mut tail: &'a Term,
-) -> Option<(String, Option<&'a Term>)>
-{
- let mut string =
- match head {
- &Term::Constant(_, Constant::Atom(ref atom, _)) if atom.is_char() => {
- atom.as_str().chars().next().unwrap().to_string()
- }
- &Term::Constant(_, Constant::Char(c)) => {
- c.to_string()
- }
- _ => {
- return None;
- }
- };
+fn is_partial_string<'a>(head: &'a Term, mut tail: &'a Term) -> Option<(String, Option<&'a Term>)> {
+ let mut string = match head {
+ &Term::Constant(_, Constant::Atom(ref atom, _)) if atom.is_char() => {
+ atom.as_str().chars().next().unwrap().to_string()
+ }
+ &Term::Constant(_, Constant::Char(c)) => c.to_string(),
+ _ => {
+ return None;
+ }
+ };
while let Term::Cons(_, ref head, ref succ) = tail {
match head.as_ref() {
impl<'a> TermIterState<'a> {
pub fn subterm_to_state(lvl: Level, term: &'a Term) -> TermIterState<'a> {
match term {
- &Term::AnonVar => {
- TermIterState::AnonVar(lvl)
- }
+ &Term::AnonVar => TermIterState::AnonVar(lvl),
&Term::Clause(ref cell, ref name, ref subterms, ref spec) => {
let ct = if let Some(spec) = spec {
ClauseType::Op(name.clone(), spec.clone(), CodeIndex::default())
&Term::Cons(ref cell, ref head, ref tail) => {
TermIterState::InitialCons(lvl, cell, head.as_ref(), tail.as_ref())
}
- &Term::Constant(ref cell, ref constant) => {
- TermIterState::Constant(lvl, cell, constant)
- }
- &Term::Var(ref cell, ref var) => {
- TermIterState::Var(lvl, cell, var.clone())
- }
+ &Term::Constant(ref cell, ref constant) => TermIterState::Constant(lvl, cell, constant),
+ &Term::Var(ref cell, ref var) => TermIterState::Var(lvl, cell, var.clone()),
}
}
}
state_stack: vec![],
}
}
- &Term::Var(ref cell, ref var) =>
- TermIterState::Var(Level::Root, cell, (*var).clone()),
+ &Term::Var(ref cell, ref var) => TermIterState::Var(Level::Root, cell, (*var).clone()),
};
QueryIterator {
}
TermIterState::InitialCons(lvl, cell, head, tail) => {
if let Some((string, tail)) = is_partial_string(head, tail) {
- self.state_stack.push(TermIterState::PartialString(
- lvl,
- cell,
- string,
- tail,
- ));
+ self.state_stack
+ .push(TermIterState::PartialString(lvl, cell, string, tail));
if let Some(tail) = tail {
self.push_subterm(lvl.child_level(), tail);
}
} else {
- self.state_stack.push(TermIterState::FinalCons(lvl, cell, head, tail));
+ self.state_stack
+ .push(TermIterState::FinalCons(lvl, cell, head, tail));
self.push_subterm(lvl.child_level(), tail);
self.push_subterm(lvl.child_level(), head);
impl<'a> FactIterator<'a> {
fn push_subterm(&mut self, lvl: Level, term: &'a Term) {
- self.state_queue.push_back(TermIterState::subterm_to_state(lvl, term));
+ self.state_queue
+ .push_back(TermIterState::subterm_to_state(lvl, term));
}
pub fn from_rule_head_clause(terms: &'a Vec<Box<Term>>) -> Self {
TermIterState::Var(lvl, cell, var) => {
return Some(TermRef::Var(lvl, cell, var));
}
- _ => {
- }
+ _ => {}
}
}
}
}))
}
-/*
- pub fn from_term_sequence(terms: &'a [QueryTerm]) -> Self {
- ChunkedIterator {
- chunk_num: 0,
- iter: Box::new(terms.iter().map(|t| ChunkedTerm::BodyTerm(t))),
- deep_cut_encountered: false,
- cut_var_in_head: false,
+ /*
+ pub fn from_term_sequence(terms: &'a [QueryTerm]) -> Self {
+ ChunkedIterator {
+ chunk_num: 0,
+ iter: Box::new(terms.iter().map(|t| ChunkedTerm::BodyTerm(t))),
+ deep_cut_encountered: false,
+ cut_var_in_head: false,
+ }
}
- }
-*/
+ */
pub fn from_rule_body(p1: &'a QueryTerm, clauses: &'a Vec<QueryTerm>) -> Self {
let inner_iter = Box::new(once(ChunkedTerm::BodyTerm(p1)));
let iter = inner_iter.chain(clauses.iter().map(|t| ChunkedTerm::BodyTerm(t)));
use crate::divrem::*;
use crate::prolog_parser_rebis::ast::*;
+use crate::prolog_parser_rebis::clause_name;
use crate::arithmetic::*;
use crate::clause_types::*;
#[macro_export]
macro_rules! try_numeric_result {
- ($s: ident, $e: expr, $caller: expr) => (
+ ($s: ident, $e: expr, $caller: expr) => {
match $e {
- Ok(val) => {
- Ok(val)
- }
+ Ok(val) => Ok(val),
Err(e) => {
- let caller_copy =
- $caller.iter().map(|v| v.context_free_clone()).collect();
+ let caller_copy = $caller.iter().map(|v| v.context_free_clone()).collect();
Err($s.error_form(MachineError::evaluation_error(e), caller_copy))
}
}
- );
+ };
}
fn isize_gcd(n1: isize, n2: isize) -> Option<isize> {
}
impl MachineState {
- pub(crate)
- fn get_number(&mut self, at: &ArithmeticTerm) -> Result<Number, MachineStub> {
+ pub(crate) fn get_number(&mut self, at: &ArithmeticTerm) -> Result<Number, MachineStub> {
match at {
- &ArithmeticTerm::Reg(r) => {
- self.arith_eval_by_metacall(r)
- }
- &ArithmeticTerm::Interm(i) => Ok(mem::replace(
- &mut self.interms[i - 1],
- Number::Fixnum(0),
- )),
- &ArithmeticTerm::Number(ref n) => {
- Ok(n.clone())
+ &ArithmeticTerm::Reg(r) => self.arith_eval_by_metacall(r),
+ &ArithmeticTerm::Interm(i) => {
+ Ok(mem::replace(&mut self.interms[i - 1], Number::Fixnum(0)))
}
+ &ArithmeticTerm::Number(ref n) => Ok(n.clone()),
}
}
- pub(super)
- fn rational_from_number(
- &self,
- n: Number,
- ) -> Result<Rc<Rational>, MachineError> {
+ pub(super) fn rational_from_number(&self, n: Number) -> Result<Rc<Rational>, MachineError> {
match n {
- Number::Fixnum(n) => {
- Ok(Rc::new(Rational::from(n)))
- }
- Number::Rational(r) => {
- Ok(r)
- }
- Number::Float(OrderedFloat(f)) => {
- match Rational::from_f64(f) {
- Some(r) => {
- Ok(Rc::new(r))
- }
- None => {
- Err(MachineError::instantiation_error())
- }
- }
- }
- Number::Integer(n) => {
- Ok(Rc::new(Rational::from(&*n)))
- }
+ Number::Fixnum(n) => Ok(Rc::new(Rational::from(n))),
+ Number::Rational(r) => Ok(r),
+ Number::Float(OrderedFloat(f)) => match Rational::from_f64(f) {
+ Some(r) => Ok(Rc::new(r)),
+ None => Err(MachineError::instantiation_error()),
+ },
+ Number::Integer(n) => Ok(Rc::new(Rational::from(&*n))),
}
}
- pub(crate)
- fn get_rational(
+ pub(crate) fn get_rational(
&mut self,
at: &ArithmeticTerm,
caller: MachineStub,
match self.rational_from_number(n) {
Ok(r) => Ok((r, caller)),
- Err(e) => Err(self.error_form(e, caller))
+ Err(e) => Err(self.error_form(e, caller)),
}
}
- pub(crate)
- fn arith_eval_by_metacall(&self, r: RegType) -> Result<Number, MachineStub> {
+ pub(crate) fn arith_eval_by_metacall(&self, r: RegType) -> Result<Number, MachineStub> {
let caller = MachineError::functor_stub(clause_name!("is"), 2);
let mut interms: Vec<Number> = Vec::with_capacity(64);
"min" => interms.push(self.min(a1, a2)?),
"rdiv" => {
let r1 = self.rational_from_number(a1);
- let r2 = r1.and_then(|r1| {
- self.rational_from_number(a2).map(|r2| (r1, r2))
- });
+ let r2 =
+ r1.and_then(|r1| self.rational_from_number(a2).map(|r2| (r1, r2)));
match r2 {
Ok((r1, r2)) => {
&HeapCellValue::Addr(Addr::Fixnum(n)) => {
interms.push(Number::Fixnum(n));
}
- &HeapCellValue::Addr(Addr::Float(n)) => {
- interms.push(Number::Float(n))
- }
- &HeapCellValue::Integer(ref n) => {
- interms.push(Number::Integer(n.clone()))
- }
+ &HeapCellValue::Addr(Addr::Float(n)) => interms.push(Number::Float(n)),
+ &HeapCellValue::Integer(ref n) => interms.push(Number::Integer(n.clone())),
&HeapCellValue::Addr(Addr::Usize(n)) => {
interms.push(Number::Integer(Rc::new(Integer::from(n))));
}
- &HeapCellValue::Rational(ref n) => {
- interms.push(Number::Rational(n.clone()))
- }
+ &HeapCellValue::Rational(ref n) => interms.push(Number::Rational(n.clone())),
&HeapCellValue::Atom(ref name, _) if name.as_str() == "pi" => {
interms.push(Number::Float(OrderedFloat(f64::consts::PI)))
}
));
}
&HeapCellValue::Addr(addr) if addr.is_ref() => {
- return Err(self.error_form(
- MachineError::instantiation_error(),
- caller,
- ));
+ return Err(self.error_form(MachineError::instantiation_error(), caller));
}
val => {
return Err(self.type_error(
Ok(interms.pop().unwrap())
}
- pub(crate)
- fn rdiv(&self, r1: Rc<Rational>, r2: Rc<Rational>) -> Result<Rational, MachineStub> {
+ pub(crate) fn rdiv(&self, r1: Rc<Rational>, r2: Rc<Rational>) -> Result<Rational, MachineStub> {
if &*r2 == &0 {
let stub = MachineError::functor_stub(clause_name!("(rdiv)"), 2);
Err(self.error_form(MachineError::evaluation_error(EvalError::ZeroDivisor), stub))
}
}
- pub(crate)
- fn int_floor_div(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn int_floor_div(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
let stub = MachineError::functor_stub(clause_name!("(div)"), 2);
let modulus = self.modulus(n1.clone(), n2.clone())?;
self.idiv(try_numeric_result!(self, n1 - modulus, stub)?, n2)
}
- pub(crate)
- fn idiv(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn idiv(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
match (n1, n2) {
(Number::Fixnum(n1), Number::Fixnum(n2)) => {
if n2 == 0 {
let stub = MachineError::functor_stub(clause_name!("(//)"), 2);
- Err(self.error_form(
- MachineError::evaluation_error(
- EvalError::ZeroDivisor
- ),
- stub,
- ))
+ Err(self
+ .error_form(MachineError::evaluation_error(EvalError::ZeroDivisor), stub))
} else {
if let Some(result) = n1.checked_div(n2) {
Ok(Number::from(result))
if &*n2 == &0 {
let stub = MachineError::functor_stub(clause_name!("(//)"), 2);
- Err(self.error_form(
- MachineError::evaluation_error(
- EvalError::ZeroDivisor
- ),
- stub,
- ))
+ Err(self
+ .error_form(MachineError::evaluation_error(EvalError::ZeroDivisor), stub))
} else {
Ok(Number::from(Integer::from(n1) / &*n2))
}
if n1 == 0 {
let stub = MachineError::functor_stub(clause_name!("(//)"), 2);
- Err(self.error_form(
- MachineError::evaluation_error(
- EvalError::ZeroDivisor
- ),
- stub,
- ))
+ Err(self
+ .error_form(MachineError::evaluation_error(EvalError::ZeroDivisor), stub))
} else {
Ok(Number::from(&*n2 / Integer::from(n1)))
}
if &*n2 == &0 {
let stub = MachineError::functor_stub(clause_name!("(//)"), 2);
- Err(self.error_form(
- MachineError::evaluation_error(
- EvalError::ZeroDivisor
- ),
- stub,
- ))
+ Err(self
+ .error_form(MachineError::evaluation_error(EvalError::ZeroDivisor), stub))
} else {
- Ok(Number::from(<(Integer, Integer)>::from(n1.div_rem_ref(&*n2)).0))
+ Ok(Number::from(
+ <(Integer, Integer)>::from(n1.div_rem_ref(&*n2)).0,
+ ))
}
}
(Number::Fixnum(_), n2) | (Number::Integer(_), n2) => {
let stub = MachineError::functor_stub(clause_name!("(//)"), 2);
Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n2,
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n2),
stub,
))
}
let stub = MachineError::functor_stub(clause_name!("(//)"), 2);
Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n1,
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n1),
stub,
))
}
}
}
- pub(crate)
- fn div(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn div(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
let stub = MachineError::functor_stub(clause_name!("(/)"), 2);
if n2.is_zero() {
}
}
- pub(crate)
- fn atan2(&self, n1: Number, n2: Number) -> Result<f64, MachineStub> {
+ pub(crate) fn atan2(&self, n1: Number, n2: Number) -> Result<f64, MachineStub> {
let stub = MachineError::functor_stub(clause_name!("is"), 2);
if n1.is_zero() && n2.is_zero() {
}
}
- pub(crate)
- fn int_pow(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn int_pow(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
if n1.is_zero() && n2.is_negative() {
let stub = MachineError::functor_stub(clause_name!("is"), 2);
return Err(self.error_form(MachineError::evaluation_error(EvalError::Undefined), stub));
let stub = MachineError::functor_stub(clause_name!("^"), 2);
Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Float,
- n
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Float, n),
stub,
))
} else {
let stub = MachineError::functor_stub(clause_name!("^"), 2);
Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Float,
- n
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Float, n),
stub,
))
} else {
let stub = MachineError::functor_stub(clause_name!("^"), 2);
Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Float,
- n
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Float, n),
stub,
))
} else {
let stub = MachineError::functor_stub(clause_name!("^"), 2);
Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Float,
- n
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Float, n),
stub,
))
} else {
}
}
- pub(crate)
- fn gcd(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn gcd(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
match (n1, n2) {
(Number::Fixnum(n1), Number::Fixnum(n2)) => {
if let Some(result) = isize_gcd(n1, n2) {
Ok(Number::from(Integer::from(n1).gcd(&Integer::from(n2))))
}
}
- (Number::Fixnum(n1), Number::Integer(n2)) |
- (Number::Integer(n2), Number::Fixnum(n1)) => {
+ (Number::Fixnum(n1), Number::Integer(n2))
+ | (Number::Integer(n2), Number::Fixnum(n1)) => {
let n1 = Integer::from(n1);
Ok(Number::from(Integer::from(n2.gcd_ref(&n1))))
}
let stub = MachineError::functor_stub(clause_name!("gcd"), 2);
Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n),
stub,
))
}
let stub = MachineError::functor_stub(clause_name!("gcd"), 2);
Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n,
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n),
stub,
))
}
}
}
- pub(crate)
- fn float_pow(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn float_pow(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
let f1 = result_f(&n1, rnd_f);
let f2 = result_f(&n2, rnd_f);
)?)))
}
- pub(crate)
- fn pow(&self, n1: Number, n2: Number, culprit: &'static str) -> Result<Number, MachineStub> {
+ pub(crate) fn pow(
+ &self,
+ n1: Number,
+ n2: Number,
+ culprit: &'static str,
+ ) -> Result<Number, MachineStub> {
if n2.is_negative() && n1.is_zero() {
let stub = MachineError::functor_stub(clause_name!(culprit), 2);
return Err(self.error_form(MachineError::evaluation_error(EvalError::Undefined), stub));
}
#[inline]
- pub(crate)
- fn unary_float_fn_template<FloatFn>(&self, n1: Number, f: FloatFn) -> Result<f64, MachineStub>
+ pub(crate) fn unary_float_fn_template<FloatFn>(
+ &self,
+ n1: Number,
+ f: FloatFn,
+ ) -> Result<f64, MachineStub>
where
FloatFn: Fn(f64) -> f64,
{
}
#[inline]
- pub(crate)
- fn sin(&self, n1: Number) -> Result<f64, MachineStub> {
+ pub(crate) fn sin(&self, n1: Number) -> Result<f64, MachineStub> {
self.unary_float_fn_template(n1, |f| f.sin())
}
#[inline]
- pub(crate)
- fn cos(&self, n1: Number) -> Result<f64, MachineStub> {
+ pub(crate) fn cos(&self, n1: Number) -> Result<f64, MachineStub> {
self.unary_float_fn_template(n1, |f| f.cos())
}
#[inline]
- pub(crate)
- fn tan(&self, n1: Number) -> Result<f64, MachineStub> {
+ pub(crate) fn tan(&self, n1: Number) -> Result<f64, MachineStub> {
self.unary_float_fn_template(n1, |f| f.tan())
}
#[inline]
- pub(crate)
- fn log(&self, n1: Number) -> Result<f64, MachineStub> {
+ pub(crate) fn log(&self, n1: Number) -> Result<f64, MachineStub> {
self.unary_float_fn_template(n1, |f| f.log(f64::consts::E))
}
#[inline]
- pub(crate)
- fn exp(&self, n1: Number) -> Result<f64, MachineStub> {
+ pub(crate) fn exp(&self, n1: Number) -> Result<f64, MachineStub> {
self.unary_float_fn_template(n1, |f| f.exp())
}
#[inline]
- pub(crate)
- fn asin(&self, n1: Number) -> Result<f64, MachineStub> {
+ pub(crate) fn asin(&self, n1: Number) -> Result<f64, MachineStub> {
self.unary_float_fn_template(n1, |f| f.asin())
}
#[inline]
- pub(crate)
- fn acos(&self, n1: Number) -> Result<f64, MachineStub> {
+ pub(crate) fn acos(&self, n1: Number) -> Result<f64, MachineStub> {
self.unary_float_fn_template(n1, |f| f.acos())
}
#[inline]
- pub(crate)
- fn atan(&self, n1: Number) -> Result<f64, MachineStub> {
+ pub(crate) fn atan(&self, n1: Number) -> Result<f64, MachineStub> {
self.unary_float_fn_template(n1, |f| f.atan())
}
#[inline]
- pub(crate)
- fn sqrt(&self, n1: Number) -> Result<f64, MachineStub> {
+ pub(crate) fn sqrt(&self, n1: Number) -> Result<f64, MachineStub> {
if n1.is_negative() {
let stub = MachineError::functor_stub(clause_name!("is"), 2);
return Err(self.error_form(MachineError::evaluation_error(EvalError::Undefined), stub));
}
#[inline]
- pub(crate)
- fn float(&self, n: Number) -> Result<f64, MachineStub> {
+ pub(crate) fn float(&self, n: Number) -> Result<f64, MachineStub> {
let stub = MachineError::functor_stub(clause_name!("is"), 2);
try_numeric_result!(self, result_f(&n, rnd_f), stub)
}
#[inline]
- pub(crate)
- fn floor(&self, n1: Number) -> Number {
+ pub(crate) fn floor(&self, n1: Number) -> Number {
rnd_i(&n1).to_owned()
}
#[inline]
- pub(crate)
- fn ceiling(&self, n1: Number) -> Number {
+ pub(crate) fn ceiling(&self, n1: Number) -> Number {
-self.floor(-n1)
}
#[inline]
- pub(crate)
- fn truncate(&self, n: Number) -> Number {
+ pub(crate) fn truncate(&self, n: Number) -> Number {
if n.is_negative() {
-self.floor(n.abs())
} else {
}
}
- pub(crate)
- fn round(&self, n: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn round(&self, n: Number) -> Result<Number, MachineStub> {
let stub = MachineError::functor_stub(clause_name!("is"), 2);
let result = n + Number::Float(OrderedFloat(0.5f64));
Ok(self.floor(result))
}
- pub(crate)
- fn shr(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn shr(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
let stub = MachineError::functor_stub(clause_name!("(>>)"), 2);
match (n1, n2) {
_ => Ok(Number::from(n1 >> u32::max_value())),
}
}
- (Number::Integer(n1), Number::Fixnum(n2)) => {
- match u32::try_from(n2) {
- Ok(n2) => Ok(Number::from(Integer::from(&*n1 >> n2))),
- _ => Ok(Number::from(Integer::from(&*n1 >> u32::max_value()))),
- }
- }
- (Number::Integer(n1), Number::Integer(n2)) =>
- match n2.to_u32() {
- Some(n2) => Ok(Number::from(Integer::from(&*n1 >> n2))),
- _ => Ok(Number::from(Integer::from(&*n1 >> u32::max_value()))),
- },
+ (Number::Integer(n1), Number::Fixnum(n2)) => match u32::try_from(n2) {
+ Ok(n2) => Ok(Number::from(Integer::from(&*n1 >> n2))),
+ _ => Ok(Number::from(Integer::from(&*n1 >> u32::max_value()))),
+ },
+ (Number::Integer(n1), Number::Integer(n2)) => match n2.to_u32() {
+ Some(n2) => Ok(Number::from(Integer::from(&*n1 >> n2))),
+ _ => Ok(Number::from(Integer::from(&*n1 >> u32::max_value()))),
+ },
(Number::Integer(_), n2) => Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n2,
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n2),
stub,
)),
(n1, _) => Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n1,
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n1),
stub,
)),
}
}
- pub(crate)
- fn shl(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn shl(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
let stub = MachineError::functor_stub(clause_name!("(<<)"), 2);
match (n1, n2) {
_ => Ok(Number::from(n1 << u32::max_value())),
}
}
- (Number::Integer(n1), Number::Fixnum(n2)) => {
- match u32::try_from(n2) {
- Ok(n2) => Ok(Number::from(Integer::from(&*n1 << n2))),
- _ => Ok(Number::from(Integer::from(&*n1 << u32::max_value()))),
- }
- }
+ (Number::Integer(n1), Number::Fixnum(n2)) => match u32::try_from(n2) {
+ Ok(n2) => Ok(Number::from(Integer::from(&*n1 << n2))),
+ _ => Ok(Number::from(Integer::from(&*n1 << u32::max_value()))),
+ },
(Number::Integer(n1), Number::Integer(n2)) => match n2.to_u32() {
Some(n2) => Ok(Number::from(Integer::from(&*n1 << n2))),
_ => Ok(Number::from(Integer::from(&*n1 << u32::max_value()))),
},
(Number::Integer(_), n2) => Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n2,
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n2),
stub,
)),
(n1, _) => Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n1,
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n1),
stub,
)),
}
}
- pub(crate)
- fn bitwise_complement(&self, n1: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn bitwise_complement(&self, n1: Number) -> Result<Number, MachineStub> {
let stub = MachineError::functor_stub(clause_name!("(\\)"), 2);
match n1 {
Number::Fixnum(n) => Ok(Number::Fixnum(!n)),
Number::Integer(n1) => Ok(Number::from(Integer::from(!&*n1))),
_ => Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n1,
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n1),
stub,
)),
}
}
- pub(crate)
- fn xor(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn xor(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
let stub = MachineError::functor_stub(clause_name!("(xor)"), 2);
match (n1, n2) {
- (Number::Fixnum(n1), Number::Fixnum(n2)) => {
- Ok(Number::from(n1 ^ n2))
- }
+ (Number::Fixnum(n1), Number::Fixnum(n2)) => Ok(Number::from(n1 ^ n2)),
(Number::Fixnum(n1), Number::Integer(n2)) => {
let n1 = Integer::from(n1);
Ok(Number::from(n1 ^ &*n2))
}
- (Number::Integer(n1), Number::Fixnum(n2)) => {
- Ok(Number::from(&*n1 ^ Integer::from(n2)))
- }
+ (Number::Integer(n1), Number::Fixnum(n2)) => Ok(Number::from(&*n1 ^ Integer::from(n2))),
(Number::Integer(n1), Number::Integer(n2)) => {
Ok(Number::from(Integer::from(&*n1 ^ &*n2)))
}
- (Number::Integer(_), n2) | (Number::Fixnum(_), n2) => {
- Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n2
- ),
- stub,
- ))
- }
- (n1, _) => {
- Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n1
- ),
- stub,
- ))
- }
+ (Number::Integer(_), n2) | (Number::Fixnum(_), n2) => Err(self.error_form(
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n2),
+ stub,
+ )),
+ (n1, _) => Err(self.error_form(
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n1),
+ stub,
+ )),
}
}
- pub(crate)
- fn and(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn and(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
let stub = MachineError::functor_stub(clause_name!("(/\\)"), 2);
match (n1, n2) {
- (Number::Fixnum(n1), Number::Fixnum(n2)) => {
- Ok(Number::from(n1 & n2))
- }
+ (Number::Fixnum(n1), Number::Fixnum(n2)) => Ok(Number::from(n1 & n2)),
(Number::Fixnum(n1), Number::Integer(n2)) => {
let n1 = Integer::from(n1);
Ok(Number::from(n1 & &*n2))
}
- (Number::Integer(n1), Number::Fixnum(n2)) => {
- Ok(Number::from(&*n1 & Integer::from(n2)))
- }
+ (Number::Integer(n1), Number::Fixnum(n2)) => Ok(Number::from(&*n1 & Integer::from(n2))),
(Number::Integer(n1), Number::Integer(n2)) => {
Ok(Number::from(Integer::from(&*n1 & &*n2)))
}
- (Number::Integer(_), n2) | (Number::Fixnum(_), n2) => {
- Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n2,
- ),
- stub,
- ))
- }
+ (Number::Integer(_), n2) | (Number::Fixnum(_), n2) => Err(self.error_form(
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n2),
+ stub,
+ )),
(n1, _) => Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n1,
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n1),
stub,
)),
}
}
- pub(crate)
- fn or(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn or(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
let stub = MachineError::functor_stub(clause_name!("(\\/)"), 2);
match (n1, n2) {
- (Number::Fixnum(n1), Number::Fixnum(n2)) => {
- Ok(Number::from(n1 | n2))
- }
+ (Number::Fixnum(n1), Number::Fixnum(n2)) => Ok(Number::from(n1 | n2)),
(Number::Fixnum(n1), Number::Integer(n2)) => {
let n1 = Integer::from(n1);
Ok(Number::from(n1 | &*n2))
}
- (Number::Integer(n1), Number::Fixnum(n2)) => {
- Ok(Number::from(&*n1 | Integer::from(n2)))
- }
+ (Number::Integer(n1), Number::Fixnum(n2)) => Ok(Number::from(&*n1 | Integer::from(n2))),
(Number::Integer(n1), Number::Integer(n2)) => {
Ok(Number::from(Integer::from(&*n1 | &*n2)))
}
- (Number::Integer(_), n2) | (Number::Fixnum(_), n2) => {
- Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n2,
- ),
- stub,
- ))
- }
- (n1, _) => {
- Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n1
- ),
- stub,
- ))
- }
+ (Number::Integer(_), n2) | (Number::Fixnum(_), n2) => Err(self.error_form(
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n2),
+ stub,
+ )),
+ (n1, _) => Err(self.error_form(
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n1),
+ stub,
+ )),
}
}
- pub(crate)
- fn modulus(&self, x: Number, y: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn modulus(&self, x: Number, y: Number) -> Result<Number, MachineStub> {
let stub = MachineError::functor_stub(clause_name!("(mod)"), 2);
match (x, y) {
(Number::Fixnum(n1), Number::Fixnum(n2)) => {
if n2 == 0 {
- Err(self.error_form(
- MachineError::evaluation_error(EvalError::ZeroDivisor),
- stub,
- ))
+ Err(self
+ .error_form(MachineError::evaluation_error(EvalError::ZeroDivisor), stub))
} else {
Ok(Number::from(n1.rem_floor(n2)))
}
}
(Number::Fixnum(n1), Number::Integer(n2)) => {
if &*n2 == &0 {
- Err(self.error_form(
- MachineError::evaluation_error(EvalError::ZeroDivisor),
- stub,
- ))
+ Err(self
+ .error_form(MachineError::evaluation_error(EvalError::ZeroDivisor), stub))
} else {
let n1 = Integer::from(n1);
- Ok(Number::from(<(Integer, Integer)>::from(n1.div_rem_floor_ref(&*n2)).1))
+ Ok(Number::from(
+ <(Integer, Integer)>::from(n1.div_rem_floor_ref(&*n2)).1,
+ ))
}
}
(Number::Integer(n1), Number::Fixnum(n2)) => {
if n2 == 0 {
- Err(self.error_form(
- MachineError::evaluation_error(EvalError::ZeroDivisor),
- stub,
- ))
+ Err(self
+ .error_form(MachineError::evaluation_error(EvalError::ZeroDivisor), stub))
} else {
let n2 = Integer::from(n2);
- Ok(Number::from(<(Integer, Integer)>::from(n1.div_rem_floor_ref(&n2)).1))
+ Ok(Number::from(
+ <(Integer, Integer)>::from(n1.div_rem_floor_ref(&n2)).1,
+ ))
}
}
(Number::Integer(x), Number::Integer(y)) => {
if &*y == &0 {
- Err(self.error_form(
- MachineError::evaluation_error(EvalError::ZeroDivisor),
- stub,
- ))
+ Err(self
+ .error_form(MachineError::evaluation_error(EvalError::ZeroDivisor), stub))
} else {
- Ok(Number::from(<(Integer, Integer)>::from(x.div_rem_floor_ref(&*y)).1))
+ Ok(Number::from(
+ <(Integer, Integer)>::from(x.div_rem_floor_ref(&*y)).1,
+ ))
}
}
- (Number::Integer(_), n2) | (Number::Fixnum(_), n2) => {
- Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n2,
- ),
- stub,
- ))
- }
+ (Number::Integer(_), n2) | (Number::Fixnum(_), n2) => Err(self.error_form(
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n2),
+ stub,
+ )),
(n1, _) => Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n1,
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n1),
stub,
)),
}
}
- pub(crate)
- fn remainder(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn remainder(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
let stub = MachineError::functor_stub(clause_name!("(rem)"), 2);
match (n1, n2) {
(Number::Fixnum(n1), Number::Fixnum(n2)) => {
if n2 == 0 {
- Err(self.error_form(
- MachineError::evaluation_error(EvalError::ZeroDivisor),
- stub,
- ))
+ Err(self
+ .error_form(MachineError::evaluation_error(EvalError::ZeroDivisor), stub))
} else {
Ok(Number::from(n1 % n2))
}
}
(Number::Fixnum(n1), Number::Integer(n2)) => {
if &*n2 == &0 {
- Err(self.error_form(
- MachineError::evaluation_error(EvalError::ZeroDivisor),
- stub,
- ))
+ Err(self
+ .error_form(MachineError::evaluation_error(EvalError::ZeroDivisor), stub))
} else {
let n1 = Integer::from(n1);
Ok(Number::from(n1 % &*n2))
}
(Number::Integer(n1), Number::Fixnum(n2)) => {
if n2 == 0 {
- Err(self.error_form(
- MachineError::evaluation_error(EvalError::ZeroDivisor),
- stub,
- ))
+ Err(self
+ .error_form(MachineError::evaluation_error(EvalError::ZeroDivisor), stub))
} else {
let n2 = Integer::from(n2);
Ok(Number::from(&*n1 % n2))
}
(Number::Integer(n1), Number::Integer(n2)) => {
if &*n2 == &0 {
- Err(self.error_form(
- MachineError::evaluation_error(EvalError::ZeroDivisor),
- stub,
- ))
+ Err(self
+ .error_form(MachineError::evaluation_error(EvalError::ZeroDivisor), stub))
} else {
Ok(Number::from(Integer::from(&*n1 % &*n2)))
}
}
- (Number::Integer(_), n2) | (Number::Fixnum(_), n2) => {
- Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n2,
- ),
- stub,
- ))
- }
+ (Number::Integer(_), n2) | (Number::Fixnum(_), n2) => Err(self.error_form(
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n2),
+ stub,
+ )),
(n1, _) => Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- n1,
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Integer, n1),
stub,
)),
}
}
- pub(crate)
- fn max(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn max(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
match (n1, n2) {
(Number::Fixnum(n1), Number::Fixnum(n2)) => {
if n1 > n2 {
}
}
- pub(crate)
- fn min(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
+ pub(crate) fn min(&self, n1: Number, n2: Number) -> Result<Number, MachineStub> {
match (n1, n2) {
(Number::Fixnum(n1), Number::Fixnum(n2)) => {
if n1 < n2 {
}
}
- pub(crate)
- fn sign(&self, n: Number) -> Number {
+ pub(crate) fn sign(&self, n: Number) -> Number {
if n.is_positive() {
Number::from(1)
} else if n.is_negative() {
use crate::heap_iter::*;
use crate::machine::*;
+use crate::prolog_parser_rebis::temp_v;
use crate::indexmap::IndexSet;
}
impl AttrVarInitializer {
- pub(super)
- fn new(verify_attrs_loc: usize, project_attrs_loc: usize) -> Self {
+ pub(super) fn new(verify_attrs_loc: usize, project_attrs_loc: usize) -> Self {
AttrVarInitializer {
attribute_goals: vec![],
attr_var_queue: vec![],
}
#[inline]
- pub(super)
- fn reset(&mut self) {
- self.attribute_goals.clear();
+ pub(super) fn reset(&mut self) {
+ self.attribute_goals.clear();
self.attr_var_queue.clear();
self.bindings.clear();
}
#[inline]
- pub(super)
- fn backtrack(&mut self, queue_b: usize, bindings_b: usize) {
+ pub(super) fn backtrack(&mut self, queue_b: usize, bindings_b: usize) {
self.attr_var_queue.truncate(queue_b);
self.bindings.truncate(bindings_b);
}
}
impl MachineState {
- pub(super)
- fn push_attr_var_binding(&mut self, h: usize, addr: Addr) {
+ pub(super) fn push_attr_var_binding(&mut self, h: usize, addr: Addr) {
if self.attr_var_init.bindings.is_empty() {
self.attr_var_init.instigating_p = self.p.local();
let iter = self
.attr_var_init
.bindings
- .drain(0 ..)
+ .drain(0..)
.map(|(_, addr)| HeapCellValue::Addr(addr));
let value_list_addr = Addr::HeapCell(self.heap.to_list(iter));
self[temp_v!(2)] = value_list_addr;
}
- pub(super)
- fn gather_attr_vars_created_since(&self, b: usize) -> IntoIter<Addr> {
+ pub(super) fn gather_attr_vars_created_since(&self, b: usize) -> IntoIter<Addr> {
let mut attr_vars: Vec<_> = self.attr_var_init.attr_var_queue[b..]
.iter()
.filter_map(|h| match self.store(self.deref(Addr::HeapCell(*h))) {
})
.collect();
- attr_vars.sort_unstable_by(|a1, a2| {
- self.compare_term_test(a1, a2).unwrap_or(Ordering::Less)
- });
+ attr_vars
+ .sort_unstable_by(|a1, a2| self.compare_term_test(a1, a2).unwrap_or(Ordering::Less));
self.term_dedup(&mut attr_vars);
attr_vars.into_iter()
}
- pub(super)
- fn verify_attr_interrupt(&mut self, p: usize) {
+ pub(super) fn verify_attr_interrupt(&mut self, p: usize) {
self.allocate(self.num_of_args + 2);
let e = self.e;
self.stack.index_and_frame_mut(e).prelude.interrupt_cp = self.attr_var_init.cp;
- for i in 1 .. self.num_of_args + 1 {
+ for i in 1..self.num_of_args + 1 {
self.stack.index_and_frame_mut(e)[i] = self[RegType::Temp(i)];
}
- self.stack.index_and_frame_mut(e)[self.num_of_args + 1] =
- Addr::CutPoint(self.b0);
- self.stack.index_and_frame_mut(e)[self.num_of_args + 2] =
- Addr::Usize(self.num_of_args);
+ self.stack.index_and_frame_mut(e)[self.num_of_args + 1] = Addr::CutPoint(self.b0);
+ self.stack.index_and_frame_mut(e)[self.num_of_args + 2] = Addr::Usize(self.num_of_args);
self.verify_attributes();
self.p = CodePtr::Local(LocalCodePtr::DirEntry(p));
}
- pub(super)
- fn attr_vars_of_term(&self, addr: Addr) -> Vec<Addr> {
- let mut seen_set = IndexSet::new();
+ pub(super) fn attr_vars_of_term(&self, addr: Addr) -> Vec<Addr> {
+ let mut seen_set = IndexSet::new();
let mut seen_vars = vec![];
let mut iter = self.acyclic_pre_order_iter(addr);
+use crate::prolog_parser_rebis::clause_name;
+
use crate::codegen::*;
use crate::debray_allocator::*;
use crate::indexing::{merge_clause_index, remove_index};
use crate::machine::load_state::set_code_index;
-use crate::machine::loader::*;
use crate::machine::load_state::LoadState;
-use crate::machine::*;
+use crate::machine::loader::*;
use crate::machine::term_stream::*;
+use crate::machine::*;
use slice_deque::sdeq;
standalone_skeleton: PredicateSkeleton,
}
-pub(super)
-fn bootstrapping_compile(
+pub(super) fn bootstrapping_compile(
stream: Stream,
wam: &mut Machine,
listing_src: ListingSource,
) -> Result<(), SessionError> {
let stream = &mut parsing_stream(stream)?;
- let term_stream =
- BootstrappingTermStream::from_prolog_stream(
- stream,
- wam.machine_st.atom_tbl.clone(),
- wam.machine_st.flags,
- listing_src,
- );
+ let term_stream = BootstrappingTermStream::from_prolog_stream(
+ stream,
+ wam.machine_st.atom_tbl.clone(),
+ wam.machine_st.flags,
+ listing_src,
+ );
let loader = Loader::new(term_stream, wam);
loader.load()?;
}
// throw errors if declaration or query found.
-pub(super)
-fn compile_relation(
+pub(super) fn compile_relation(
cg: &mut CodeGenerator<DebrayAllocator>,
- tl: &TopLevel
+ tl: &TopLevel,
) -> Result<Code, CompilationError> {
match tl {
- &TopLevel::Declaration(_) | &TopLevel::Query(_) =>
- Err(CompilationError::ExpectedRel),
- &TopLevel::Predicate(ref clauses) =>
- cg.compile_predicate(&clauses),
- &TopLevel::Fact(ref fact, ..) =>
- Ok(cg.compile_fact(fact)),
- &TopLevel::Rule(ref rule, ..) =>
- cg.compile_rule(rule),
+ &TopLevel::Declaration(_) | &TopLevel::Query(_) => Err(CompilationError::ExpectedRel),
+ &TopLevel::Predicate(ref clauses) => cg.compile_predicate(&clauses),
+ &TopLevel::Fact(ref fact, ..) => Ok(cg.compile_fact(fact)),
+ &TopLevel::Rule(ref rule, ..) => cg.compile_rule(rule),
}
}
-pub(super)
-fn compile_appendix(
+pub(super) fn compile_appendix(
code: &mut Code,
queue: &VecDeque<TopLevel>,
jmp_by_locs: Vec<usize>,
return target_pos - 1;
}
- for index in (0 .. target_pos - 1).rev() {
+ for index in (0..target_pos - 1).rev() {
let current_arg_num = skeleton.clauses[index].opt_arg_index_key.arg_num();
if current_arg_num == 0 || current_arg_num != arg_num {
retraction_info: &mut RetractionInfo,
) -> Option<usize> {
match &mut code[index] {
- Line::Choice(ChoiceInstruction::TryMeElse(0)) => {
- None
- }
+ Line::Choice(ChoiceInstruction::TryMeElse(0)) => None,
Line::Choice(ChoiceInstruction::TryMeElse(ref mut offset)) => {
- retraction_info.push_record(
- RetractionRecord::ModifiedTryMeElse(index, *offset),
- );
+ retraction_info.push_record(RetractionRecord::ModifiedTryMeElse(index, *offset));
Some(mem::replace(offset, 0))
}
retraction_info: &mut RetractionInfo,
) {
for clause_index in index_range {
- if let Some(index_loc) = skeleton[clause_index].opt_arg_index_key.switch_on_term_loc() {
+ if let Some(index_loc) = skeleton[clause_index]
+ .opt_arg_index_key
+ .switch_on_term_loc()
+ {
let clause_loc =
find_inner_choice_instr(code, skeleton[clause_index].clause_start, index_loc);
- let target_indexing_line =
- to_indexing_line_mut(&mut code[target_index_loc]).unwrap();
+ let target_indexing_line = to_indexing_line_mut(&mut code[target_index_loc]).unwrap();
- skeleton[clause_index].opt_arg_index_key.set_switch_on_term_loc(target_index_loc);
+ skeleton[clause_index]
+ .opt_arg_index_key
+ .set_switch_on_term_loc(target_index_loc);
merge_clause_index(
target_indexing_line,
- &mut skeleton[0 .. clause_index + 1],
+ &mut skeleton[0..clause_index + 1],
clause_loc,
AppendOrPrepend::Append,
);
- retraction_info.push_record(
- RetractionRecord::AddedIndex(
- skeleton[clause_index].opt_arg_index_key.clone(),
- clause_loc,
- ),
- );
+ retraction_info.push_record(RetractionRecord::AddedIndex(
+ skeleton[clause_index].opt_arg_index_key.clone(),
+ clause_loc,
+ ));
} else {
break;
}
}
}
-fn find_inner_choice_instr(
- code: &Code,
- mut index: usize,
- index_loc: usize,
-) -> usize {
+fn find_inner_choice_instr(code: &Code, mut index: usize, index_loc: usize) -> usize {
loop {
match &code[index] {
- Line::Choice(ChoiceInstruction::TryMeElse(o)) |
- Line::Choice(ChoiceInstruction::RetryMeElse(o)) => {
+ Line::Choice(ChoiceInstruction::TryMeElse(o))
+ | Line::Choice(ChoiceInstruction::RetryMeElse(o)) => {
if *o > 0 {
return index;
} else {
Line::Choice(ChoiceInstruction::TrustMe(_)) => {
return index;
}
- Line::IndexingCode(indexing_code) => {
- match &indexing_code[0] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnTerm(_, v, ..)
- ) => {
- index += v;
- }
- _ => {
- unreachable!();
- }
+ Line::IndexingCode(indexing_code) => match &indexing_code[0] {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, v, ..)) => {
+ index += v;
}
- }
+ _ => {
+ unreachable!();
+ }
+ },
Line::Control(ControlInstruction::RevJmpBy(offset)) => {
index -= offset;
}
if let Some(index_loc) = opt_arg_index_key.switch_on_term_loc() {
let clause_start = find_inner_choice_instr(code, clause_start, index_loc);
- let target_indexing_line =
- to_indexing_line_mut(&mut code[index_loc]).unwrap();
+ let target_indexing_line = to_indexing_line_mut(&mut code[index_loc]).unwrap();
let offset = clause_start - index_loc + 1;
// TODO: this isn't sufficiently precise. The removed offset could
// appear anywhere inside an Internal record.
- retraction_info.push_record(
- RetractionRecord::RemovedIndex(
- index_loc,
- opt_arg_index_key.clone(),
- offset,
- ),
- );
+ retraction_info.push_record(RetractionRecord::RemovedIndex(
+ index_loc,
+ opt_arg_index_key.clone(),
+ offset,
+ ));
}
}
// instruction to TrustMe (or RetryMeElse), and derelict-ize
// target_pos + 1's inner TryMeElse.
- let inner_trust_me_loc =
- skeleton.clauses[upper_lower_bound - 2].clause_start;
+ let inner_trust_me_loc = skeleton.clauses[upper_lower_bound - 2].clause_start;
let inner_try_me_else_loc = find_inner_choice_instr(
code,
skeleton.clauses[upper_lower_bound].clause_start,
- skeleton.clauses[upper_lower_bound].opt_arg_index_key
- .switch_on_term_loc().unwrap(),
+ skeleton.clauses[upper_lower_bound]
+ .opt_arg_index_key
+ .switch_on_term_loc()
+ .unwrap(),
);
match &mut code[inner_try_me_else_loc] {
Line::Choice(ChoiceInstruction::TryMeElse(ref mut o)) => {
- retraction_info.push_record(
- RetractionRecord::ModifiedTryMeElse(
- skeleton.clauses[upper_lower_bound].clause_start,
- *o,
- ),
- );
+ retraction_info.push_record(RetractionRecord::ModifiedTryMeElse(
+ skeleton.clauses[upper_lower_bound].clause_start,
+ *o,
+ ));
match *o {
0 => {
- code[inner_try_me_else_loc] =
- Line::Choice(ChoiceInstruction::TrustMe(0));
+ code[inner_try_me_else_loc] = Line::Choice(ChoiceInstruction::TrustMe(0));
}
- o => {
- match &code[inner_try_me_else_loc + o] {
- Line::Control(ControlInstruction::RevJmpBy(0)) => {
- code[inner_try_me_else_loc] =
- Line::Choice(ChoiceInstruction::TrustMe(o));
- }
- _ => {
- code[inner_try_me_else_loc] =
- Line::Choice(ChoiceInstruction::RetryMeElse(o));
- }
+ o => match &code[inner_try_me_else_loc + o] {
+ Line::Control(ControlInstruction::RevJmpBy(0)) => {
+ code[inner_try_me_else_loc] = Line::Choice(ChoiceInstruction::TrustMe(o));
}
- }
+ _ => {
+ code[inner_try_me_else_loc] =
+ Line::Choice(ChoiceInstruction::RetryMeElse(o));
+ }
+ },
}
}
- _ => {
- }
+ _ => {}
}
thread_choice_instr_at_to(
let mut end_of_upper_lower_bound = None;
- for index in upper_lower_bound .. skeleton.clauses.len() {
+ for index in upper_lower_bound..skeleton.clauses.len() {
if !skeleton.clauses[index].opt_arg_index_key.is_some() {
end_of_upper_lower_bound = Some(index);
break;
}
}
- let outer_threaded_choice_instr_loc =
- skeleton.clauses[lower_upper_bound].clause_start - 2;
+ let outer_threaded_choice_instr_loc = skeleton.clauses[lower_upper_bound].clause_start - 2;
match end_of_upper_lower_bound {
Some(outer_threaded_clause_index) => {
retraction_info,
);
}
- None => {
- match &mut code[outer_threaded_choice_instr_loc] {
- Line::Choice(ChoiceInstruction::TryMeElse(ref mut o)) => {
- retraction_info.push_record(
- RetractionRecord::ModifiedTryMeElse(inner_trust_me_loc, *o),
- );
+ None => match &mut code[outer_threaded_choice_instr_loc] {
+ Line::Choice(ChoiceInstruction::TryMeElse(ref mut o)) => {
+ retraction_info
+ .push_record(RetractionRecord::ModifiedTryMeElse(inner_trust_me_loc, *o));
- *o = 0;
+ *o = 0;
- return Some(IndexPtr::Index(outer_threaded_choice_instr_loc + 1));
- }
- _ => {
- }
+ return Some(IndexPtr::Index(outer_threaded_choice_instr_loc + 1));
}
- }
+ _ => {}
+ },
}
None
let clause_clause_loc = skeleton.clause_clause_locs.remove(target_pos);
let clause_index_info = skeleton.clauses.remove(target_pos);
- retraction_info.push_record(
- RetractionRecord::RemovedDynamicSkeletonClause(
- compilation_target,
- key,
- target_pos,
- clause_index_info,
- clause_clause_loc,
- ),
- );
+ retraction_info.push_record(RetractionRecord::RemovedDynamicSkeletonClause(
+ compilation_target,
+ key,
+ target_pos,
+ clause_index_info,
+ clause_clause_loc,
+ ));
clause_clause_loc
}
loop {
match &mut code[instr_loc] {
Line::Choice(ChoiceInstruction::RetryMeElse(o)) => {
- retraction_info.push_record(
- RetractionRecord::ModifiedRetryMeElse(instr_loc, *o),
- );
+ retraction_info.push_record(RetractionRecord::ModifiedRetryMeElse(instr_loc, *o));
code[instr_loc] = Line::Choice(ChoiceInstruction::TryMeElse(*o));
return instr_loc;
}
Line::Choice(ChoiceInstruction::TrustMe(offset)) => {
- retraction_info.push_record(
- RetractionRecord::AppendedTrustMe(instr_loc, *offset, false),
- );
+ retraction_info
+ .push_record(RetractionRecord::AppendedTrustMe(instr_loc, *offset, false));
code[instr_loc] = Line::Choice(ChoiceInstruction::TryMeElse(0));
return instr_loc + 1;
offset: usize,
retraction_info: &mut RetractionInfo,
) {
- let target_indexing_line =
- to_indexing_line_mut(&mut code[index_loc]).unwrap();
+ let target_indexing_line = to_indexing_line_mut(&mut code[index_loc]).unwrap();
- let v =
- match &mut target_indexing_line[0] {
- IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, v, ..)) => {
- *v
- }
- _ => {
- unreachable!();
- }
- };
+ let v = match &mut target_indexing_line[0] {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, v, ..)) => *v,
+ _ => {
+ unreachable!();
+ }
+ };
match &code[index_loc + v] {
- Line::Choice(ChoiceInstruction::TryMeElse(_)) => {
- }
+ Line::Choice(ChoiceInstruction::TryMeElse(_)) => {}
_ => {
- set_switch_var_offset(
- code,
- index_loc,
- offset,
- retraction_info,
- );
+ set_switch_var_offset(code, index_loc, offset, retraction_info);
}
}
}
offset: usize,
retraction_info: &mut RetractionInfo,
) {
- let target_indexing_line =
- to_indexing_line_mut(&mut code[index_loc]).unwrap();
+ let target_indexing_line = to_indexing_line_mut(&mut code[index_loc]).unwrap();
- let old_v =
- match &mut target_indexing_line[0] {
- IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, ref mut v, ..)) => {
- mem::replace(v, offset)
- }
- _ => {
- unreachable!()
- }
- };
+ let old_v = match &mut target_indexing_line[0] {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, ref mut v, ..)) => {
+ mem::replace(v, offset)
+ }
+ _ => {
+ unreachable!()
+ }
+ };
- retraction_info.push_record(
- RetractionRecord::ReplacedSwitchOnTermVarIndex(index_loc, old_v),
- );
+ retraction_info.push_record(RetractionRecord::ReplacedSwitchOnTermVarIndex(
+ index_loc, old_v,
+ ));
}
fn internalize_choice_instr_at(
) {
match &mut code[instr_loc] {
Line::Choice(ChoiceInstruction::TryMeElse(0)) => {
- retraction_info.push_record(
- RetractionRecord::ModifiedTryMeElse(instr_loc, 0),
- );
+ retraction_info.push_record(RetractionRecord::ModifiedTryMeElse(instr_loc, 0));
code[instr_loc] = Line::Choice(ChoiceInstruction::TrustMe(0));
}
Line::Choice(ChoiceInstruction::TryMeElse(o)) => {
let o = *o;
- retraction_info.push_record(
- RetractionRecord::ModifiedTryMeElse(instr_loc, o),
- );
+ retraction_info.push_record(RetractionRecord::ModifiedTryMeElse(instr_loc, o));
match &mut code[instr_loc + o] {
- Line::Control(ControlInstruction::RevJmpBy(p))
- if *p == 0 => {
- code[instr_loc] = Line::Choice(ChoiceInstruction::TrustMe(o));
- }
+ Line::Control(ControlInstruction::RevJmpBy(p)) if *p == 0 => {
+ code[instr_loc] = Line::Choice(ChoiceInstruction::TrustMe(o));
+ }
_ => {
code[instr_loc] = Line::Choice(ChoiceInstruction::RetryMeElse(o));
}
) {
loop {
match &mut code[instr_loc] {
- Line::Choice(ChoiceInstruction::TryMeElse(ref mut o)) |
- Line::Choice(ChoiceInstruction::RetryMeElse(ref mut o))
- if target_loc >= instr_loc => {
- retraction_info.push_record(
- RetractionRecord::ReplacedChoiceOffset(instr_loc, *o),
- );
-
- *o = target_loc - instr_loc;
- return;
- }
- Line::Choice(ChoiceInstruction::TryMeElse(ref mut o)) |
- Line::Choice(ChoiceInstruction::RetryMeElse(ref mut o)) => {
+ Line::Choice(ChoiceInstruction::TryMeElse(ref mut o))
+ | Line::Choice(ChoiceInstruction::RetryMeElse(ref mut o))
+ if target_loc >= instr_loc =>
+ {
+ retraction_info.push_record(RetractionRecord::ReplacedChoiceOffset(instr_loc, *o));
+
+ *o = target_loc - instr_loc;
+ return;
+ }
+ Line::Choice(ChoiceInstruction::TryMeElse(ref mut o))
+ | Line::Choice(ChoiceInstruction::RetryMeElse(ref mut o)) => {
instr_loc += *o;
}
- Line::Control(ControlInstruction::RevJmpBy(ref mut o))
- if instr_loc >= target_loc => {
- retraction_info.push_record(
- RetractionRecord::ModifiedRevJmpBy(instr_loc, *o),
- );
+ Line::Control(ControlInstruction::RevJmpBy(ref mut o)) if instr_loc >= target_loc => {
+ retraction_info.push_record(RetractionRecord::ModifiedRevJmpBy(instr_loc, *o));
- *o = instr_loc - target_loc;
- return;
- }
- Line::Choice(ChoiceInstruction::TrustMe(ref mut o))
- if target_loc >= instr_loc => {
- retraction_info.push_record(
- RetractionRecord::AppendedTrustMe(instr_loc, *o, false),
- //choice_instr.is_default()),
- );
+ *o = instr_loc - target_loc;
+ return;
+ }
+ Line::Choice(ChoiceInstruction::TrustMe(ref mut o)) if target_loc >= instr_loc => {
+ retraction_info.push_record(
+ RetractionRecord::AppendedTrustMe(instr_loc, *o, false),
+ //choice_instr.is_default()),
+ );
- code[instr_loc] =
- Line::Choice(ChoiceInstruction::RetryMeElse(target_loc - instr_loc));
+ code[instr_loc] =
+ Line::Choice(ChoiceInstruction::RetryMeElse(target_loc - instr_loc));
- return;
- }
- Line::Choice(ChoiceInstruction::TrustMe(o))
- if *o > 0 => {
- instr_loc += *o;
- }
+ return;
+ }
+ Line::Choice(ChoiceInstruction::TrustMe(o)) if *o > 0 => {
+ instr_loc += *o;
+ }
_ => {
unreachable!()
}
Line::Choice(ChoiceInstruction::TrustMe(_)) => {
match &mut code[preceding_choice_instr_loc] {
Line::Choice(ChoiceInstruction::RetryMeElse(o)) => {
- retraction_info.push_record(
- RetractionRecord::ModifiedRetryMeElse(
- preceding_choice_instr_loc,
- *o,
- ),
- );
+ retraction_info.push_record(RetractionRecord::ModifiedRetryMeElse(
+ preceding_choice_instr_loc,
+ *o,
+ ));
- code[preceding_choice_instr_loc] =
- Line::Choice(ChoiceInstruction::TrustMe(0));
+ code[preceding_choice_instr_loc] = Line::Choice(ChoiceInstruction::TrustMe(0));
None
}
Line::Choice(ChoiceInstruction::TryMeElse(ref mut o)) => {
- retraction_info.push_record(
- RetractionRecord::ModifiedTryMeElse(
- preceding_choice_instr_loc,
- *o,
- )
- );
+ retraction_info.push_record(RetractionRecord::ModifiedTryMeElse(
+ preceding_choice_instr_loc,
+ *o,
+ ));
*o = 0;
index_ptr_opt: Option<IndexPtr>,
retraction_info: &mut RetractionInfo,
) -> usize {
- let clause_clause_loc =
- delete_from_dynamic_skeleton(
- compilation_target.clone(),
- key.clone(),
- skeleton,
- target_pos,
- retraction_info,
- );
+ let clause_clause_loc = delete_from_dynamic_skeleton(
+ compilation_target.clone(),
+ key.clone(),
+ skeleton,
+ target_pos,
+ retraction_info,
+ );
if let Some(index_ptr) = index_ptr_opt {
set_code_index(
match &mut code[non_indexed_choice_instr_loc] {
Line::Choice(ChoiceInstruction::TryMeElse(ref mut o)) => {
if *o > 0 {
- retraction_info.push_record(
- RetractionRecord::ModifiedTryMeElse(
- non_indexed_choice_instr_loc,
- *o,
- )
- );
+ retraction_info.push_record(RetractionRecord::ModifiedTryMeElse(
+ non_indexed_choice_instr_loc,
+ *o,
+ ));
let o = mem::replace(o, 0);
let target_arg_num = skeleton.clauses[0].opt_arg_index_key.arg_num();
let head_arg_num = skeleton.clauses[1].opt_arg_index_key.arg_num();
- if skeleton.clauses[0].opt_arg_index_key.switch_on_term_loc().is_some() {
+ if skeleton.clauses[0]
+ .opt_arg_index_key
+ .switch_on_term_loc()
+ .is_some()
+ {
match skeleton.clauses[1].opt_arg_index_key.switch_on_term_loc() {
Some(index_loc) if target_arg_num == head_arg_num => {
- prepend_queue.extend(clause_code.drain(3 ..));
+ prepend_queue.extend(clause_code.drain(3..));
skeleton.clauses[0].opt_arg_index_key += index_loc - 1;
skeleton.clauses[0].clause_start = clause_loc + 2;
- retraction_info.push_record(
- RetractionRecord::AddedIndex(
- skeleton.clauses[0].opt_arg_index_key.clone(),
- skeleton.clauses[0].clause_start,
- ),
- );
+ retraction_info.push_record(RetractionRecord::AddedIndex(
+ skeleton.clauses[0].opt_arg_index_key.clone(),
+ skeleton.clauses[0].clause_start,
+ ));
let outer_thread_choice_loc = skeleton.clauses[1].clause_start - 2;
- retraction_info.push_record(
- RetractionRecord::SkeletonClauseStartReplaced(
- compilation_target,
- key.clone(),
- 1,
- skeleton.clauses[1].clause_start,
- ),
- );
+ retraction_info.push_record(RetractionRecord::SkeletonClauseStartReplaced(
+ compilation_target,
+ key.clone(),
+ 1,
+ skeleton.clauses[1].clause_start,
+ ));
skeleton.clauses[1].clause_start =
- find_inner_choice_instr(
- code,
- skeleton.clauses[1].clause_start,
- index_loc,
- );
+ find_inner_choice_instr(code, skeleton.clauses[1].clause_start, index_loc);
let inner_thread_rev_offset =
3 + prepend_queue.len() + clause_loc - skeleton.clauses[1].clause_start;
- prepend_queue.push_back(
- Line::Control(ControlInstruction::RevJmpBy(inner_thread_rev_offset)),
- );
+ prepend_queue.push_back(Line::Control(ControlInstruction::RevJmpBy(
+ inner_thread_rev_offset,
+ )));
- prepend_queue.push_front(
- Line::Choice(ChoiceInstruction::TryMeElse(prepend_queue.len())),
- );
+ prepend_queue.push_front(Line::Choice(ChoiceInstruction::TryMeElse(
+ prepend_queue.len(),
+ )));
// prepend_queue is now:
// | TryMeElse N_2
// | (clause_code)
// +N_2 | RevJmpBy (RetryMeElse(M_1) or TryMeElse(0) at index_loc + 1)
- prepend_queue.push_front(
- Line::Control(ControlInstruction::RevJmpBy(
- 1 + clause_loc - index_loc
- )),
- );
+ prepend_queue.push_front(Line::Control(ControlInstruction::RevJmpBy(
+ 1 + clause_loc - index_loc,
+ )));
let outer_thread_choice_offset = // outer_thread_choice_loc WAS index_loc - 1..
match derelictize_try_me_else(code, outer_thread_choice_loc, retraction_info) {
}
};
- prepend_queue.push_front(
- Line::Choice(ChoiceInstruction::TryMeElse(outer_thread_choice_offset)),
- );
+ prepend_queue.push_front(Line::Choice(ChoiceInstruction::TryMeElse(
+ outer_thread_choice_offset,
+ )));
// prepend_queue is now:
// | TryMeElse N_3
AppendOrPrepend::Prepend,
);
- set_switch_var_offset(
+ set_switch_var_offset(code, index_loc, clause_loc - index_loc + 2, retraction_info);
+
+ internalize_choice_instr_at(
code,
- index_loc,
- clause_loc - index_loc + 2,
+ skeleton.clauses[1].clause_start,
retraction_info,
);
- internalize_choice_instr_at(code, skeleton.clauses[1].clause_start, retraction_info);
-
code.extend(prepend_queue.into_iter());
clause_loc + (outer_thread_choice_offset == 0) as usize
}
_ => {
- prepend_queue.extend(clause_code.drain(1 ..));
+ prepend_queue.extend(clause_code.drain(1..));
skeleton.clauses[0].opt_arg_index_key += clause_loc;
skeleton.clauses[0].clause_start = clause_loc + 2;
// this is a stub for chaining inner-threaded choice
// instructions.
- prepend_queue.push_back(
- Line::Control(ControlInstruction::RevJmpBy(0))
- );
+ prepend_queue.push_back(Line::Control(ControlInstruction::RevJmpBy(0)));
let prepend_queue_len = prepend_queue.len();
match &mut prepend_queue[1] {
- Line::Choice(ChoiceInstruction::TryMeElse(ref mut o))
- if *o == 0 => {
- *o = prepend_queue_len - 2;
- }
+ Line::Choice(ChoiceInstruction::TryMeElse(ref mut o)) if *o == 0 => {
+ *o = prepend_queue_len - 2;
+ }
_ => {
unreachable!();
}
}
- prepend_queue.push_back(
- Line::Control(ControlInstruction::RevJmpBy(inner_thread_rev_offset)),
- );
+ prepend_queue.push_back(Line::Control(ControlInstruction::RevJmpBy(
+ inner_thread_rev_offset,
+ )));
- prepend_queue.push_front(
- Line::Choice(ChoiceInstruction::TryMeElse(prepend_queue.len())),
- );
+ prepend_queue.push_front(Line::Choice(ChoiceInstruction::TryMeElse(
+ prepend_queue.len(),
+ )));
// prepend_queue is now:
// | TryMeElse(N_2)
} else {
match skeleton.clauses[1].opt_arg_index_key.switch_on_term_loc() {
Some(_) => {
- prepend_queue.extend(clause_code.drain(1 ..));
+ prepend_queue.extend(clause_code.drain(1..));
let old_clause_start = skeleton.clauses[1].clause_start - 2;
let inner_thread_rev_offset =
1 + prepend_queue.len() + clause_loc - old_clause_start;
- prepend_queue.push_back(
- Line::Control(ControlInstruction::RevJmpBy(inner_thread_rev_offset)),
- );
+ prepend_queue.push_back(Line::Control(ControlInstruction::RevJmpBy(
+ inner_thread_rev_offset,
+ )));
- prepend_queue.push_front(
- Line::Choice(ChoiceInstruction::TryMeElse(prepend_queue.len())),
- );
+ prepend_queue.push_front(Line::Choice(ChoiceInstruction::TryMeElse(
+ prepend_queue.len(),
+ )));
// prepend_queue is now:
// | TryMeElse(N_2)
clause_loc // + (outer_thread_choice_offset == 0 as usize)
}
None => {
- prepend_queue.extend(clause_code.drain(1 ..));
+ prepend_queue.extend(clause_code.drain(1..));
let old_clause_start = skeleton.clauses[1].clause_start;
let inner_thread_rev_offset =
1 + prepend_queue.len() + clause_loc - old_clause_start;
- prepend_queue.push_back(
- Line::Control(ControlInstruction::RevJmpBy(inner_thread_rev_offset)),
- );
+ prepend_queue.push_back(Line::Control(ControlInstruction::RevJmpBy(
+ inner_thread_rev_offset,
+ )));
- prepend_queue.push_front(
- Line::Choice(ChoiceInstruction::TryMeElse(prepend_queue.len())),
- );
+ prepend_queue.push_front(Line::Choice(ChoiceInstruction::TryMeElse(
+ prepend_queue.len(),
+ )));
// prepend_queue is now:
// | TryMeElse(N_2)
let lower_bound_arg_num = skeleton.clauses[lower_bound].opt_arg_index_key.arg_num();
let target_arg_num = skeleton.clauses[target_pos].opt_arg_index_key.arg_num();
- let threaded_choice_instr_loc =
- match skeleton.clauses[lower_bound].opt_arg_index_key.switch_on_term_loc() {
- Some(index_loc) if lower_bound_arg_num == target_arg_num => {
- code.extend(clause_code.drain(3 ..)); // skip the indexing code
+ let threaded_choice_instr_loc = match skeleton.clauses[lower_bound]
+ .opt_arg_index_key
+ .switch_on_term_loc()
+ {
+ Some(index_loc) if lower_bound_arg_num == target_arg_num => {
+ code.extend(clause_code.drain(3..)); // skip the indexing code
- // set skeleton[target_pos].opt_arg_index_key to
- // index_loc. its original value is always 1.
- skeleton.clauses[target_pos].opt_arg_index_key += index_loc - 1;
+ // set skeleton[target_pos].opt_arg_index_key to
+ // index_loc. its original value is always 1.
+ skeleton.clauses[target_pos].opt_arg_index_key += index_loc - 1;
- retraction_info.push_record(
- RetractionRecord::AddedIndex(
- skeleton.clauses[target_pos].opt_arg_index_key.clone(),
- skeleton.clauses[target_pos].clause_start,
- ),
- );
+ retraction_info.push_record(RetractionRecord::AddedIndex(
+ skeleton.clauses[target_pos].opt_arg_index_key.clone(),
+ skeleton.clauses[target_pos].clause_start,
+ ));
- let target_indexing_line = to_indexing_line_mut(&mut code[index_loc]).unwrap();
+ let target_indexing_line = to_indexing_line_mut(&mut code[index_loc]).unwrap();
- merge_clause_index(
- target_indexing_line,
- &mut skeleton.clauses[lower_bound ..],
- clause_loc,
- AppendOrPrepend::Append,
- );
+ merge_clause_index(
+ target_indexing_line,
+ &mut skeleton.clauses[lower_bound..],
+ clause_loc,
+ AppendOrPrepend::Append,
+ );
+
+ let target_pos_clause_start = find_inner_choice_instr(
+ code,
+ skeleton.clauses[target_pos - 1].clause_start,
+ index_loc,
+ );
- let target_pos_clause_start = find_inner_choice_instr(
+ if lower_bound + 1 == target_pos {
+ set_switch_var_offset(
code,
- skeleton.clauses[target_pos - 1].clause_start,
index_loc,
+ target_pos_clause_start - index_loc,
+ retraction_info,
);
-
- if lower_bound + 1 == target_pos {
- set_switch_var_offset(
- code,
- index_loc,
- target_pos_clause_start - index_loc,
- retraction_info,
- );
- }
-
- target_pos_clause_start // skeleton.clauses[target_pos - 1].clause_start
}
- _ => {
- skeleton.clauses[target_pos].opt_arg_index_key += clause_loc;
- code.extend(clause_code.drain(1 ..));
-
- match skeleton.clauses[lower_bound].opt_arg_index_key.switch_on_term_loc() {
- Some(_) => {
- if lower_bound == 0 {
- code_ptr_opt = Some(skeleton.clauses[lower_bound].clause_start - 2);
- }
- skeleton.clauses[lower_bound].clause_start - 2
+ target_pos_clause_start // skeleton.clauses[target_pos - 1].clause_start
+ }
+ _ => {
+ skeleton.clauses[target_pos].opt_arg_index_key += clause_loc;
+ code.extend(clause_code.drain(1..));
+
+ match skeleton.clauses[lower_bound]
+ .opt_arg_index_key
+ .switch_on_term_loc()
+ {
+ Some(_) => {
+ if lower_bound == 0 {
+ code_ptr_opt = Some(skeleton.clauses[lower_bound].clause_start - 2);
}
- None => {
- if lower_bound == 0 {
- code_ptr_opt = Some(skeleton.clauses[lower_bound].clause_start);
- }
- match 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;
+ skeleton.clauses[lower_bound].clause_start - 2
+ }
+ None => {
+ if lower_bound == 0 {
+ code_ptr_opt = Some(skeleton.clauses[lower_bound].clause_start);
+ }
- set_switch_var_offset(
- code,
- index_loc,
- 2,
- retraction_info,
- );
- }
- None => {
- }
+ match 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;
+
+ set_switch_var_offset(code, index_loc, 2, retraction_info);
}
-
- skeleton.clauses[lower_bound].clause_start
+ None => {}
}
+
+ skeleton.clauses[lower_bound].clause_start
}
}
- };
+ }
+ };
thread_choice_instr_at_to(code, threaded_choice_instr_loc, clause_loc, retraction_info);
let lower_bound_arg_num = skeleton.clauses[lower_bound].opt_arg_index_key.arg_num();
if target_pos + 1 < skeleton.clauses.len() {
- let succ_arg_num = skeleton.clauses[target_pos + 1].opt_arg_index_key.arg_num();
+ let succ_arg_num = skeleton.clauses[target_pos + 1].opt_arg_index_key.arg_num();
let target_arg_num = skeleton.clauses[target_pos].opt_arg_index_key.arg_num();
return target_arg_num != succ_arg_num && lower_bound_arg_num == succ_arg_num;
let code_len = self.wam.code_repo.code.len();
let mut code_ptr = code_len;
- let mut cg = CodeGenerator::<DebrayAllocator>::new(
- self.wam.machine_st.atom_tbl.clone(),
- settings,
- );
+ let mut cg =
+ CodeGenerator::<DebrayAllocator>::new(self.wam.machine_st.atom_tbl.clone(), settings);
let mut code = cg.compile_predicate(predicates)?;
Line::Choice(ChoiceInstruction::TryMeElse(0)) => {
code_ptr += 1;
}
- _ => {
- }
+ _ => {}
}
- match self.wam.indices.get_predicate_skeleton(
- &self.compilation_target,
- &key,
- ) {
+ match self
+ .wam
+ .indices
+ .get_predicate_skeleton(&self.compilation_target, &key)
+ {
Some(skeleton) => {
- self.retraction_info.push_record(
- RetractionRecord::SkeletonClauseTruncateBack(
+ self.retraction_info
+ .push_record(RetractionRecord::SkeletonClauseTruncateBack(
self.compilation_target.clone(),
key.clone(),
skeleton.clauses.len(),
- ),
- );
+ ));
skeleton.clauses.extend(cg.skeleton.clauses.into_iter());
}
Ok(code_index.get())
}
- fn record_incremental_compile(&mut self, key: PredicateKey, append_or_prepend: AppendOrPrepend)
- {
- self.retraction_info.push_record(
- match &self.compilation_target {
- CompilationTarget::User => {
- match append_or_prepend {
- AppendOrPrepend::Append => {
- RetractionRecord::AppendedUserExtensiblePredicate(
- key,
- )
- }
- AppendOrPrepend::Prepend => {
- RetractionRecord::PrependedUserExtensiblePredicate(
- key,
- )
- }
+ fn record_incremental_compile(
+ &mut self,
+ key: PredicateKey,
+ append_or_prepend: AppendOrPrepend,
+ ) {
+ self.retraction_info
+ .push_record(match &self.compilation_target {
+ CompilationTarget::User => match append_or_prepend {
+ AppendOrPrepend::Append => {
+ RetractionRecord::AppendedUserExtensiblePredicate(key)
}
- }
- CompilationTarget::Module(ref module_name) => {
- match append_or_prepend {
- AppendOrPrepend::Append => {
- RetractionRecord::AppendedModuleExtensiblePredicate(
- module_name.clone(), key,
- )
- }
- AppendOrPrepend::Prepend => {
- RetractionRecord::PrependedModuleExtensiblePredicate(
- module_name.clone(), key,
- )
- }
+ AppendOrPrepend::Prepend => {
+ RetractionRecord::PrependedUserExtensiblePredicate(key)
}
- }
- }
- );
+ },
+ CompilationTarget::Module(ref module_name) => match append_or_prepend {
+ AppendOrPrepend::Append => RetractionRecord::AppendedModuleExtensiblePredicate(
+ module_name.clone(),
+ key,
+ ),
+ AppendOrPrepend::Prepend => {
+ RetractionRecord::PrependedModuleExtensiblePredicate(
+ module_name.clone(),
+ key,
+ )
+ }
+ },
+ });
}
- pub(super)
- fn incremental_compile_clause(
+ pub(super) fn incremental_compile_clause(
&mut self,
key: PredicateKey,
clause: PredicateClause,
) -> Result<IndexPtr, SessionError> {
self.record_incremental_compile(key.clone(), append_or_prepend);
- let skeleton =
- match self.wam.indices.get_predicate_skeleton(
- &self.compilation_target,
- &key,
- ) {
- Some(skeleton) if !skeleton.clauses.is_empty() => {
- skeleton
- }
- _ => {
- // true because this predicate is extensible.
- let settings = CodeGenSettings::new(true, non_counted_bt);
- return self.compile(key, &vec![clause], &queue, settings);
- }
- };
+ let skeleton = match self
+ .wam
+ .indices
+ .get_predicate_skeleton(&self.compilation_target, &key)
+ {
+ Some(skeleton) if !skeleton.clauses.is_empty() => skeleton,
+ _ => {
+ // true because this predicate is extensible.
+ let settings = CodeGenSettings::new(true, non_counted_bt);
+ return self.compile(key, &vec![clause], &queue, settings);
+ }
+ };
let settings = CodeGenSettings::new(true, non_counted_bt);
let atom_tbl = self.wam.machine_st.atom_tbl.clone();
- let StandaloneCompileResult { clause_code, mut standalone_skeleton } =
- compile_standalone_clause(clause, queue, settings, atom_tbl)?;
+ let StandaloneCompileResult {
+ clause_code,
+ mut standalone_skeleton,
+ } = compile_standalone_clause(clause, queue, settings, atom_tbl)?;
match append_or_prepend {
AppendOrPrepend::Append => {
- skeleton.clauses.push_back(standalone_skeleton.clauses.pop_back().unwrap());
+ skeleton
+ .clauses
+ .push_back(standalone_skeleton.clauses.pop_back().unwrap());
- self.retraction_info.push_record(
- RetractionRecord::SkeletonClausePopBack(
+ self.retraction_info
+ .push_record(RetractionRecord::SkeletonClausePopBack(
self.compilation_target.clone(),
key.clone(),
- ),
- );
+ ));
- let result =
- append_compiled_clause(
- &mut self.wam.code_repo.code,
- clause_code,
- skeleton,
- &mut self.retraction_info,
- );
+ let result = append_compiled_clause(
+ &mut self.wam.code_repo.code,
+ clause_code,
+ skeleton,
+ &mut self.retraction_info,
+ );
let code_index = self.get_or_insert_code_index(key.clone());
Ok(code_index.get())
}
AppendOrPrepend::Prepend => {
- skeleton.clauses.push_front(standalone_skeleton.clauses.pop_back().unwrap());
+ skeleton
+ .clauses
+ .push_front(standalone_skeleton.clauses.pop_back().unwrap());
- self.retraction_info.push_record(
- RetractionRecord::SkeletonClausePopFront(
+ self.retraction_info
+ .push_record(RetractionRecord::SkeletonClausePopFront(
self.compilation_target.clone(),
key.clone(),
- ),
+ ));
+
+ let threaded_choice_instr_loc = prepend_compiled_clause(
+ &mut self.wam.code_repo.code,
+ self.compilation_target.clone(),
+ key.clone(),
+ clause_code,
+ skeleton,
+ &mut self.retraction_info,
);
- let threaded_choice_instr_loc =
- prepend_compiled_clause(
- &mut self.wam.code_repo.code,
- self.compilation_target.clone(),
- key.clone(),
- clause_code,
- skeleton,
- &mut self.retraction_info,
- );
-
let code_index = self.get_or_insert_code_index(key.clone());
set_code_index(
}
}
- pub(super)
- fn retract_clause(&mut self, key: PredicateKey, target_pos: usize) -> usize {
+ pub(super) fn retract_clause(&mut self, key: PredicateKey, target_pos: usize) -> usize {
let code_index = self.get_or_insert_code_index(key.clone());
- let skeleton =
- match self.wam.indices.get_predicate_skeleton(
- &self.compilation_target,
- &key,
- ) {
- Some(skeleton) => {
- skeleton
- }
- None => {
- unreachable!();
- }
- };
+ let skeleton = match self
+ .wam
+ .indices
+ .get_predicate_skeleton(&self.compilation_target, &key)
+ {
+ Some(skeleton) => skeleton,
+ None => {
+ unreachable!();
+ }
+ };
let code = &mut self.wam.code_repo.code;
let lower_bound = lower_bound_of_target_clause(skeleton, target_pos);
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].opt_arg_index_key.switch_on_term_loc() {
+ match skeleton.clauses[target_pos]
+ .opt_arg_index_key
+ .switch_on_term_loc()
+ {
Some(index_loc) => {
let inner_clause_start = find_inner_choice_instr(
code,
);
}
None => {
- let index_ptr_opt =
- if target_pos > 0 {
- let preceding_choice_instr_loc =
- skeleton.clauses[target_pos - 1].clause_start;
+ 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.retraction_info,
- )
- } else {
- remove_leading_unindexed_clause(
- code,
- skeleton.clauses[target_pos].clause_start - 2,
- &mut self.retraction_info,
- )
- };
+ remove_non_leading_clause(
+ code,
+ preceding_choice_instr_loc,
+ skeleton.clauses[target_pos].clause_start - 2,
+ &mut self.retraction_info,
+ )
+ } else {
+ remove_leading_unindexed_clause(
+ code,
+ skeleton.clauses[target_pos].clause_start - 2,
+ &mut self.retraction_info,
+ )
+ };
return finalize_retract(
key,
}
}
}
- None => {
- }
+ None => {}
}
}
- let index_ptr_opt =
- match skeleton.clauses[lower_bound].opt_arg_index_key.switch_on_term_loc() {
- Some(target_indexing_loc)
- if mergeable_indexed_subsequences(lower_bound, target_pos, skeleton) =>
- {
- let lower_bound_clause_start = find_inner_choice_instr(
- code,
- skeleton.clauses[lower_bound].clause_start,
- target_indexing_loc,
- );
+ let index_ptr_opt = match skeleton.clauses[lower_bound]
+ .opt_arg_index_key
+ .switch_on_term_loc()
+ {
+ Some(target_indexing_loc)
+ if mergeable_indexed_subsequences(lower_bound, target_pos, skeleton) =>
+ {
+ let lower_bound_clause_start = find_inner_choice_instr(
+ code,
+ skeleton.clauses[lower_bound].clause_start,
+ target_indexing_loc,
+ );
- let result;
+ let result;
- match skeleton.clauses[target_pos + 1].opt_arg_index_key.switch_on_term_loc() {
- Some(later_indexing_loc) if later_indexing_loc < target_indexing_loc => {
- let target_indexing_line = mem::replace(
- &mut code[target_indexing_loc],
- Line::Control(ControlInstruction::RevJmpBy(
- target_indexing_loc - later_indexing_loc
- )),
- );
+ match skeleton.clauses[target_pos + 1]
+ .opt_arg_index_key
+ .switch_on_term_loc()
+ {
+ Some(later_indexing_loc) if later_indexing_loc < target_indexing_loc => {
+ let target_indexing_line = mem::replace(
+ &mut code[target_indexing_loc],
+ Line::Control(ControlInstruction::RevJmpBy(
+ target_indexing_loc - later_indexing_loc,
+ )),
+ );
- match target_indexing_line {
- Line::IndexingCode(indexing_code) => {
- self.retraction_info.push_record(
- RetractionRecord::ReplacedIndexingLine(
- target_indexing_loc,
- indexing_code,
- ),
- );
- }
- _ => {
- }
+ match target_indexing_line {
+ Line::IndexingCode(indexing_code) => {
+ self.retraction_info.push_record(
+ RetractionRecord::ReplacedIndexingLine(
+ target_indexing_loc,
+ indexing_code,
+ ),
+ );
}
+ _ => {}
+ }
- result = merge_indexed_subsequences(
- code,
- skeleton,
- lower_bound,
- target_pos + 1,
- &mut self.retraction_info,
- );
-
- merge_indices(
- code,
- later_indexing_loc,
- 0 .. target_pos - lower_bound,
- &mut skeleton.clauses[lower_bound ..],
- &mut self.retraction_info,
- );
+ result = merge_indexed_subsequences(
+ code,
+ skeleton,
+ lower_bound,
+ target_pos + 1,
+ &mut self.retraction_info,
+ );
- set_switch_var_offset(
- code,
- later_indexing_loc,
- lower_bound_clause_start - later_indexing_loc,
- &mut self.retraction_info,
- );
- }
- _ => {
- result = merge_indexed_subsequences(
- code,
- skeleton,
- lower_bound,
- target_pos + 1,
- &mut self.retraction_info,
- );
+ merge_indices(
+ code,
+ later_indexing_loc,
+ 0..target_pos - lower_bound,
+ &mut skeleton.clauses[lower_bound..],
+ &mut self.retraction_info,
+ );
- merge_indices(
- code,
- target_indexing_loc,
- target_pos + 1 - lower_bound .. skeleton.clauses.len() - lower_bound,
- &mut skeleton.clauses[lower_bound ..],
- &mut self.retraction_info,
- );
+ set_switch_var_offset(
+ code,
+ later_indexing_loc,
+ lower_bound_clause_start - later_indexing_loc,
+ &mut self.retraction_info,
+ );
+ }
+ _ => {
+ result = merge_indexed_subsequences(
+ code,
+ skeleton,
+ lower_bound,
+ target_pos + 1,
+ &mut self.retraction_info,
+ );
- set_switch_var_offset_to_choice_instr(
- code,
- target_indexing_loc,
- lower_bound_clause_start - target_indexing_loc,
- &mut self.retraction_info,
- );
- }
- };
+ merge_indices(
+ code,
+ target_indexing_loc,
+ target_pos + 1 - lower_bound..skeleton.clauses.len() - lower_bound,
+ &mut skeleton.clauses[lower_bound..],
+ &mut self.retraction_info,
+ );
- result
- }
- _ => {
- if target_pos > 0 {
- remove_index_from_subsequence(
+ set_switch_var_offset_to_choice_instr(
code,
- &skeleton.clauses[target_pos].opt_arg_index_key,
- skeleton.clauses[target_pos].clause_start,
+ target_indexing_loc,
+ lower_bound_clause_start - target_indexing_loc,
&mut self.retraction_info,
);
+ }
+ };
- match skeleton.clauses[target_pos].opt_arg_index_key.switch_on_term_loc() {
- Some(index_loc) => {
- let preceding_choice_instr_loc = find_inner_choice_instr(
- code,
- skeleton.clauses[target_pos - 1].clause_start,
- index_loc,
- );
+ result
+ }
+ _ => {
+ if target_pos > 0 {
+ remove_index_from_subsequence(
+ code,
+ &skeleton.clauses[target_pos].opt_arg_index_key,
+ skeleton.clauses[target_pos].clause_start,
+ &mut self.retraction_info,
+ );
- remove_non_leading_clause(
- code,
- preceding_choice_instr_loc,
- skeleton.clauses[target_pos].clause_start,
- &mut self.retraction_info,
- );
+ match skeleton.clauses[target_pos]
+ .opt_arg_index_key
+ .switch_on_term_loc()
+ {
+ Some(index_loc) => {
+ let preceding_choice_instr_loc = find_inner_choice_instr(
+ code,
+ skeleton.clauses[target_pos - 1].clause_start,
+ index_loc,
+ );
- match &mut code[preceding_choice_instr_loc] {
- Line::Choice(ChoiceInstruction::TryMeElse(0)) => {
- set_switch_var_offset(
- code,
- index_loc,
- preceding_choice_instr_loc + 1 - index_loc,
- &mut self.retraction_info,
- );
- }
- _ => {
- }
- }
+ remove_non_leading_clause(
+ code,
+ preceding_choice_instr_loc,
+ skeleton.clauses[target_pos].clause_start,
+ &mut self.retraction_info,
+ );
- None
+ match &mut code[preceding_choice_instr_loc] {
+ Line::Choice(ChoiceInstruction::TryMeElse(0)) => {
+ set_switch_var_offset(
+ code,
+ index_loc,
+ preceding_choice_instr_loc + 1 - index_loc,
+ &mut self.retraction_info,
+ );
+ }
+ _ => {}
}
- None => {
- let preceding_choice_instr_loc =
- if skeleton.clauses[lower_bound].opt_arg_index_key.is_some() {
- skeleton.clauses[lower_bound].clause_start - 2
- } else {
- skeleton.clauses[lower_bound].clause_start
- };
- remove_non_leading_clause(
- code,
- preceding_choice_instr_loc,
- skeleton.clauses[target_pos].clause_start,
- &mut self.retraction_info,
- )
- }
+ None
+ }
+ None => {
+ let preceding_choice_instr_loc =
+ if skeleton.clauses[lower_bound].opt_arg_index_key.is_some() {
+ skeleton.clauses[lower_bound].clause_start - 2
+ } else {
+ skeleton.clauses[lower_bound].clause_start
+ };
+
+ remove_non_leading_clause(
+ code,
+ preceding_choice_instr_loc,
+ skeleton.clauses[target_pos].clause_start,
+ &mut self.retraction_info,
+ )
}
- } else {
- remove_leading_unindexed_clause(
- code,
- skeleton.clauses[target_pos].clause_start,
- &mut self.retraction_info,
- )
}
+ } else {
+ remove_leading_unindexed_clause(
+ code,
+ skeleton.clauses[target_pos].clause_start,
+ &mut self.retraction_info,
+ )
}
- };
+ }
+ };
finalize_retract(
key,
}
impl<'a, TS: TermStream> Loader<'a, TS> {
- pub(super)
- fn compile_clause_clauses<ClauseIter: Iterator<Item=(Term, Term)>>(
+ pub(super) fn compile_clause_clauses<ClauseIter: Iterator<Item = (Term, Term)>>(
&mut self,
key: PredicateKey,
compilation_target: CompilationTarget,
clause_clauses: ClauseIter,
append_or_prepend: AppendOrPrepend,
) -> Result<(), SessionError> {
- let clause_predicates =
- clause_clauses.map(|(head, body)| {
- PredicateClause::Fact(
- Term::Clause(
- Cell::default(),
- clause_name!("$clause"),
- vec![Box::new(head), Box::new(body)],
- None,
- )
- )
- });
-
- let clause_clause_compilation_target =
- match compilation_target {
- CompilationTarget::User => {
- CompilationTarget::Module(clause_name!("builtins"))
- }
- _ => {
- compilation_target.clone()
- }
- };
+ let clause_predicates = clause_clauses.map(|(head, body)| {
+ PredicateClause::Fact(Term::Clause(
+ Cell::default(),
+ clause_name!("$clause"),
+ vec![Box::new(head), Box::new(body)],
+ None,
+ ))
+ });
+
+ let clause_clause_compilation_target = match compilation_target {
+ CompilationTarget::User => CompilationTarget::Module(clause_name!("builtins")),
+ _ => compilation_target.clone(),
+ };
let old_compilation_target = mem::replace(
&mut self.load_state.compilation_target,
&(clause_name!("$clause"), 2),
) {
Some(skeleton) if append_or_prepend.is_append() => {
- skeleton.clause_clause_locs.extend_from_slice(&clause_clause_locs[0 ..]);
+ skeleton
+ .clause_clause_locs
+ .extend_from_slice(&clause_clause_locs[0..]);
}
Some(skeleton) => {
for loc in clause_clause_locs.iter() {
}
}
- match self.load_state.wam.indices.get_predicate_skeleton(
- &compilation_target,
- &key,
- ) {
+ match self
+ .load_state
+ .wam
+ .indices
+ .get_predicate_skeleton(&compilation_target, &key)
+ {
Some(skeleton) if append_or_prepend.is_append() => {
self.load_state.retraction_info.push_record(
RetractionRecord::SkeletonClauseClausesTruncateBack(
),
);
- skeleton.clause_clause_locs.append(
- &mut clause_clause_locs
- );
+ skeleton.clause_clause_locs.append(&mut clause_clause_locs);
}
Some(skeleton) => {
self.load_state.retraction_info.push_record(
skeleton.clause_clause_locs.push_front(*loc);
}
- self.load_state.increment_clause_assert_margin(
- clause_clause_locs.len()
- );
+ self.load_state
+ .increment_clause_assert_margin(clause_clause_locs.len());
}
None => {
unreachable!();
Ok(())
}
- pub(super)
- fn compile_and_submit(&mut self) -> Result<(), SessionError> {
+ pub(super) fn compile_and_submit(&mut self) -> Result<(), SessionError> {
let queue = self.preprocessor.parse_queue(&mut self.load_state)?;
- let key = self.predicates
+ let key = self
+ .predicates
.first()
.and_then(|cl| {
let arity = cl.arity();
})
.ok_or(SessionError::NamelessEntry)?;
- let (is_dynamic, is_extensible) = self.load_state.wam.indices
+ let (is_dynamic, is_extensible) = self
+ .load_state
+ .wam
+ .indices
.get_predicate_skeleton(&self.load_state.compilation_target, &key)
.map(|skeleton| (skeleton.is_dynamic, true))
.unwrap_or((false, false));
let non_counted_bt = self.non_counted_bt_preds.contains(&key);
let settings = CodeGenSettings::new(is_extensible, non_counted_bt);
- self.load_state.compile(key.clone(), &self.predicates, &queue, settings)?;
+ self.load_state
+ .compile(key.clone(), &self.predicates, &queue, settings)?;
if is_dynamic {
let iter = mem::replace(&mut self.clause_clauses, vec![]).into_iter();
let compilation_target = self.load_state.compilation_target.clone();
- self.compile_clause_clauses(
- key,
- compilation_target,
- iter,
- AppendOrPrepend::Append,
- )?;
+ self.compile_clause_clauses(key, compilation_target, iter, AppendOrPrepend::Append)?;
}
Ok(self.predicates.clear())
-use crate::machine::*;
use crate::machine::machine_indices::*;
-use crate::machine::term_stream::*;
+use crate::machine::*;
+use crate::prolog_parser_rebis::clause_name;
+use crate::machine::term_stream::*;
use indexmap::IndexSet;
use crate::ref_thread_local::RefThreadLocal;
pub(super) wam: &'a mut Machine,
}
-pub(super)
-fn set_code_index(
+pub(super) fn set_code_index(
retraction_info: &mut RetractionInfo,
compilation_target: &CompilationTarget,
key: PredicateKey,
code_index: &CodeIndex,
code_ptr: IndexPtr,
) {
- let record =
- match compilation_target {
- CompilationTarget::User => {
- if IndexPtr::Undefined == code_index.get() {
- code_index.set(code_ptr);
- RetractionRecord::AddedUserPredicate(key)
- } else {
- // TODO: emit warning about overwriting previous record
- let replaced = code_index.replace(code_ptr);
- RetractionRecord::ReplacedUserPredicate(key, replaced)
- }
+ let record = match compilation_target {
+ CompilationTarget::User => {
+ if IndexPtr::Undefined == code_index.get() {
+ code_index.set(code_ptr);
+ RetractionRecord::AddedUserPredicate(key)
+ } else {
+ // TODO: emit warning about overwriting previous record
+ let replaced = code_index.replace(code_ptr);
+ RetractionRecord::ReplacedUserPredicate(key, replaced)
}
- CompilationTarget::Module(ref module_name) => {
- if IndexPtr::Undefined == code_index.get() {
- code_index.set(code_ptr);
- RetractionRecord::AddedModulePredicate(module_name.clone(), key)
- } else {
- // TODO: emit warning about overwriting previous record
- let replaced = code_index.replace(code_ptr);
- RetractionRecord::ReplacedModulePredicate(module_name.clone(), key, replaced)
- }
+ }
+ CompilationTarget::Module(ref module_name) => {
+ if IndexPtr::Undefined == code_index.get() {
+ code_index.set(code_ptr);
+ RetractionRecord::AddedModulePredicate(module_name.clone(), key)
+ } else {
+ // TODO: emit warning about overwriting previous record
+ let replaced = code_index.replace(code_ptr);
+ RetractionRecord::ReplacedModulePredicate(module_name.clone(), key, replaced)
}
- };
+ }
+ };
retraction_info.push_record(record);
}
match op_decl.insert_into_op_dir(wam_op_dir) {
Some((prec, spec)) => {
- retraction_info.push_record(
- RetractionRecord::ReplacedUserOp(op_decl.clone(), prec, spec)
- );
+ retraction_info.push_record(RetractionRecord::ReplacedUserOp(
+ op_decl.clone(),
+ prec,
+ spec,
+ ));
module_op_exports.push((op_decl.clone(), Some((prec, spec))));
}
None => {
- retraction_info.push_record(
- RetractionRecord::AddedUserOp(op_decl.clone())
- );
+ retraction_info.push_record(RetractionRecord::AddedUserOp(op_decl.clone()));
module_op_exports.push((op_decl.clone(), None));
}
add_op_decl(retraction_info, compilation_target, module_op_dir, op_decl);
}
-pub(super)
-fn add_op_decl(
+pub(super) fn add_op_decl(
retraction_info: &mut RetractionInfo,
compilation_target: &CompilationTarget,
op_dir: &mut OpDir,
op_decl: &OpDecl,
) {
match op_decl.insert_into_op_dir(op_dir) {
- Some((prec, spec)) => {
- match &compilation_target {
- CompilationTarget::User => {
- retraction_info.push_record(
- RetractionRecord::ReplacedUserOp(op_decl.clone(), prec, spec),
- );
- }
- CompilationTarget::Module(ref module_name) => {
- retraction_info.push_record(
- RetractionRecord::ReplacedModuleOp(
- module_name.clone(), op_decl.clone(), prec, spec,
- ),
- );
- }
+ Some((prec, spec)) => match &compilation_target {
+ CompilationTarget::User => {
+ retraction_info.push_record(RetractionRecord::ReplacedUserOp(
+ op_decl.clone(),
+ prec,
+ spec,
+ ));
}
- }
- None => {
- match &compilation_target {
- CompilationTarget::User => {
- retraction_info.push_record(
- RetractionRecord::AddedUserOp(op_decl.clone()),
- );
- }
- CompilationTarget::Module(ref module_name) => {
- retraction_info.push_record(
- RetractionRecord::AddedModuleOp(module_name.clone(), op_decl.clone()),
- );
- }
+ CompilationTarget::Module(ref module_name) => {
+ retraction_info.push_record(RetractionRecord::ReplacedModuleOp(
+ module_name.clone(),
+ op_decl.clone(),
+ prec,
+ spec,
+ ));
+ }
+ },
+ None => match &compilation_target {
+ CompilationTarget::User => {
+ retraction_info.push_record(RetractionRecord::AddedUserOp(op_decl.clone()));
}
- }
+ CompilationTarget::Module(ref module_name) => {
+ retraction_info.push_record(RetractionRecord::AddedModuleOp(
+ module_name.clone(),
+ op_decl.clone(),
+ ));
+ }
+ },
}
}
-pub(super)
-fn import_module_exports(
+pub(super) fn import_module_exports(
retraction_info: &mut RetractionInfo,
compilation_target: &CompilationTarget,
imported_module: &Module,
}
}
ModuleExport::OpDecl(ref op_decl) => {
- add_op_decl(
- retraction_info,
- compilation_target,
- op_dir,
- op_decl,
- );
+ add_op_decl(retraction_info, compilation_target, op_dir, op_decl);
}
}
}
op_dir: &mut OpDir,
meta_predicates: &mut MetaPredicateDir,
wam_op_dir: &mut OpDir,
- module_op_exports: &mut ModuleOpExports
+ module_op_exports: &mut ModuleOpExports,
) {
for export in imported_module.module_decl.exports.iter() {
match export {
}
}
-
fn import_qualified_module_exports(
retraction_info: &mut RetractionInfo,
compilation_target: &CompilationTarget,
}
}
ModuleExport::OpDecl(ref op_decl) => {
- add_op_decl(
- retraction_info,
- compilation_target,
- op_dir,
- op_decl,
- );
+ add_op_decl(retraction_info, compilation_target, op_dir, op_decl);
}
}
}
impl<'a> LoadState<'a> {
#[inline]
- pub(super)
- fn increment_clause_assert_margin(&mut self, incr: usize) {
+ pub(super) fn increment_clause_assert_margin(&mut self, incr: usize) {
match &self.compilation_target {
- CompilationTarget::User => {
- }
+ CompilationTarget::User => {}
CompilationTarget::Module(ref module_name) => {
- self.retraction_info.push_record(
- RetractionRecord::IncreasedClauseAssertMargin(
+ self.retraction_info
+ .push_record(RetractionRecord::IncreasedClauseAssertMargin(
module_name.clone(),
incr,
- ),
- );
+ ));
- self.wam.indices.modules.get_mut(module_name)
+ self.wam
+ .indices
+ .modules
+ .get_mut(module_name)
.map(|module| module.clause_assert_margin += incr);
}
}
}
#[inline]
- pub(super)
- fn remove_module_op_exports(&mut self) {
- for (mut op_decl, record) in self.module_op_exports.drain(0 ..) {
+ pub(super) fn remove_module_op_exports(&mut self) {
+ for (mut op_decl, record) in self.module_op_exports.drain(0..) {
op_decl.remove(&mut self.wam.indices.op_dir);
if let Some((prec, spec)) = record {
key: PredicateKey,
) -> CodeIndex {
match self.wam.indices.modules.get_mut(&module_name) {
- Some(ref mut module) => {
- module.code_dir
- .entry(key)
- .or_insert_with(|| CodeIndex::new(IndexPtr::Undefined))
- .clone()
- }
+ Some(ref mut module) => module
+ .code_dir
+ .entry(key)
+ .or_insert_with(|| CodeIndex::new(IndexPtr::Undefined))
+ .clone(),
None => {
let mut module = Module::new(
- ModuleDecl { name: module_name.clone(), exports: vec![] },
+ ModuleDecl {
+ name: module_name.clone(),
+ exports: vec![],
+ },
ListingSource::DynamicallyGenerated,
);
- let code_index = module.code_dir
+ let code_index = module
+ .code_dir
.entry(key)
.or_insert_with(|| CodeIndex::new(IndexPtr::Undefined))
.clone();
- self.retraction_info.push_record(
- RetractionRecord::AddedModule(module_name.clone()),
- );
+ self.retraction_info
+ .push_record(RetractionRecord::AddedModule(module_name.clone()));
self.wam.indices.modules.insert(module_name, module);
code_index
}
}
- pub(super)
- fn get_or_insert_code_index(&mut self, key: PredicateKey) -> CodeIndex {
+ pub(super) fn get_or_insert_code_index(&mut self, key: PredicateKey) -> CodeIndex {
match self.compilation_target.clone() {
- CompilationTarget::User => {
- self.wam.indices.code_dir
- .entry(key)
- .or_insert_with(|| CodeIndex::new(IndexPtr::Undefined))
- .clone()
- }
+ CompilationTarget::User => self
+ .wam
+ .indices
+ .code_dir
+ .entry(key)
+ .or_insert_with(|| CodeIndex::new(IndexPtr::Undefined))
+ .clone(),
CompilationTarget::Module(module_name) => {
self.get_or_insert_local_code_index(module_name, key)
}
}
}
- pub(super)
- fn get_or_insert_qualified_code_index(
+ pub(super) fn get_or_insert_qualified_code_index(
&mut self,
module_name: ClauseName,
key: PredicateKey,
) -> CodeIndex {
if module_name.as_str() == "user" {
- return self.wam.indices.code_dir
+ return self
+ .wam
+ .indices
+ .code_dir
.entry(key)
.or_insert_with(|| CodeIndex::new(IndexPtr::Undefined))
.clone();
}
#[inline]
- pub(super)
- fn add_extensible_predicate(&mut self, key: PredicateKey, skeleton: PredicateSkeleton) {
+ pub(super) fn add_extensible_predicate(
+ &mut self,
+ key: PredicateKey,
+ skeleton: PredicateSkeleton,
+ ) {
match &self.compilation_target {
CompilationTarget::User => {
- self.wam.indices.extensible_predicates.insert(key.clone(), skeleton);
+ self.wam
+ .indices
+ .extensible_predicates
+ .insert(key.clone(), skeleton);
- self.retraction_info.push_record(
- RetractionRecord::AddedUserExtensiblePredicate(key),
- );
+ self.retraction_info
+ .push_record(RetractionRecord::AddedUserExtensiblePredicate(key));
}
CompilationTarget::Module(ref module_name) => {
if let Some(module) = self.wam.indices.modules.get_mut(module_name) {
}
}
- pub(super)
- fn add_op_decl(&mut self, op_decl: &OpDecl) {
+ pub(super) fn add_op_decl(&mut self, op_decl: &OpDecl) {
match &self.compilation_target {
CompilationTarget::User => {
add_op_decl(
}
}
- pub(super)
- fn get_clause_type(
+ pub(super) fn get_clause_type(
&mut self,
name: ClauseName,
arity: usize,
let idx = self.get_or_insert_code_index((name.clone(), arity));
ClauseType::Op(name, fixity, idx)
}
- ct => {
- ct
- }
+ ct => ct,
}
}
- pub(super)
- fn get_qualified_clause_type(
+ pub(super) fn get_qualified_clause_type(
&mut self,
module_name: ClauseName,
name: ClauseName,
ClauseType::Op(name, fixity, idx)
}
- ct => {
- ct
- }
+ ct => ct,
}
}
- pub(super)
- fn add_meta_predicate_record(
+ pub(super) fn add_meta_predicate_record(
&mut self,
module_name: ClauseName,
name: ClauseName,
match module_name.as_str() {
"user" => {
- match self.wam.indices.meta_predicates.insert(key.clone(), meta_specs) {
+ match self
+ .wam
+ .indices
+ .meta_predicates
+ .insert(key.clone(), meta_specs)
+ {
Some(old_meta_specs) => {
- self.retraction_info.push_record(
- RetractionRecord::ReplacedMetaPredicate(
- module_name.clone(), key.0, old_meta_specs,
- ),
- );
+ self.retraction_info
+ .push_record(RetractionRecord::ReplacedMetaPredicate(
+ module_name.clone(),
+ key.0,
+ old_meta_specs,
+ ));
}
None => {
- self.retraction_info.push_record(
- RetractionRecord::AddedMetaPredicate(
- module_name.clone(), key,
- )
- );
+ self.retraction_info
+ .push_record(RetractionRecord::AddedMetaPredicate(
+ module_name.clone(),
+ key,
+ ));
}
}
}
Some(old_meta_specs) => {
self.retraction_info.push_record(
RetractionRecord::ReplacedMetaPredicate(
- module_name.clone(), key.0, old_meta_specs,
+ module_name.clone(),
+ key.0,
+ old_meta_specs,
),
);
}
None => {
self.retraction_info.push_record(
- RetractionRecord::AddedMetaPredicate(
- module_name.clone(), key,
- )
+ RetractionRecord::AddedMetaPredicate(module_name.clone(), key),
);
}
}
module.meta_predicates.insert(key.clone(), meta_specs);
- self.retraction_info.push_record(
- RetractionRecord::AddedMetaPredicate(
- module_name.clone(), key,
- )
- );
+ self.retraction_info
+ .push_record(RetractionRecord::AddedMetaPredicate(
+ module_name.clone(),
+ key,
+ ));
- self.retraction_info.push_record(
- RetractionRecord::AddedModule(module_name.clone()),
- );
+ self.retraction_info
+ .push_record(RetractionRecord::AddedModule(module_name.clone()));
self.wam.indices.modules.insert(module_name, module);
}
}
}
- pub(crate)
- fn add_module(&mut self, module_decl: ModuleDecl, listing_src: ListingSource) {
+ pub(crate) fn add_module(&mut self, module_decl: ModuleDecl, listing_src: ListingSource) {
let module_name = module_decl.name.clone();
- let mut module =
- match self.wam.indices.modules.remove(&module_name) {
- Some(mut module) => {
- let old_module_decl = mem::replace(&mut module.module_decl, module_decl);
+ let mut module = match self.wam.indices.modules.remove(&module_name) {
+ Some(mut module) => {
+ let old_module_decl = mem::replace(&mut module.module_decl, module_decl);
- self.retraction_info.push_record(
- RetractionRecord::ReplacedModule(
- old_module_decl, listing_src.clone(),
- ),
- );
+ self.retraction_info
+ .push_record(RetractionRecord::ReplacedModule(
+ old_module_decl,
+ listing_src.clone(),
+ ));
- module.listing_src = listing_src;
- module
- }
- None => {
- self.retraction_info.push_record(
- RetractionRecord::AddedModule(module_name.clone()),
- );
+ module.listing_src = listing_src;
+ module
+ }
+ None => {
+ self.retraction_info
+ .push_record(RetractionRecord::AddedModule(module_name.clone()));
- Module::new(module_decl, listing_src)
- }
- };
+ Module::new(module_decl, listing_src)
+ }
+ };
self.import_builtins_in_module(
&mut module.code_dir,
self.wam.indices.modules.insert(module_name, module);
}
- pub(super)
- fn import_module(&mut self, module_name: ClauseName) -> Result<(), SessionError> {
+ pub(super) fn import_module(&mut self, module_name: ClauseName) -> Result<(), SessionError> {
if let Some(module) = self.wam.indices.modules.remove(&module_name) {
match &self.compilation_target {
CompilationTarget::User => {
self.wam.indices.modules.insert(module_name, module);
Ok(())
} else {
- Err(SessionError::ExistenceError(ExistenceError::Module(module_name)))
+ Err(SessionError::ExistenceError(ExistenceError::Module(
+ module_name,
+ )))
}
}
self.wam.indices.modules.insert(module_name, module);
Ok(())
} else {
- Err(SessionError::ExistenceError(ExistenceError::Module(module_name)))
+ Err(SessionError::ExistenceError(ExistenceError::Module(
+ module_name,
+ )))
}
}
- pub(crate)
- fn use_module(&mut self, module_src: ModuleSource) -> Result<(), SessionError> {
- let (stream, listing_src) =
- match module_src {
- ModuleSource::File(filename) => {
- let mut path_buf = PathBuf::from(filename.as_str());
- path_buf.set_extension("pl");
- let file = File::open(&path_buf)?;
-
- (Stream::from_file_as_input(filename.clone(), file),
- ListingSource::File(filename, path_buf))
- }
- ModuleSource::Library(library) => {
- match LIBRARIES.borrow().get(library.as_str()) {
- Some(code) => {
- if let Some(ref module) = self.wam.indices.modules.get(&library) {
- if let ListingSource::DynamicallyGenerated = &module.listing_src {
- (Stream::from(*code), ListingSource::User)
- } else {
- return self.import_module(library);
- }
- } else {
- (Stream::from(*code), ListingSource::User)
- }
- }
- None => {
+ pub(crate) fn use_module(&mut self, module_src: ModuleSource) -> Result<(), SessionError> {
+ let (stream, listing_src) = match module_src {
+ ModuleSource::File(filename) => {
+ let mut path_buf = PathBuf::from(filename.as_str());
+ path_buf.set_extension("pl");
+ let file = File::open(&path_buf)?;
+
+ (
+ Stream::from_file_as_input(filename.clone(), file),
+ ListingSource::File(filename, path_buf),
+ )
+ }
+ ModuleSource::Library(library) => match LIBRARIES.borrow().get(library.as_str()) {
+ Some(code) => {
+ if let Some(ref module) = self.wam.indices.modules.get(&library) {
+ if let ListingSource::DynamicallyGenerated = &module.listing_src {
+ (Stream::from(*code), ListingSource::User)
+ } else {
return self.import_module(library);
}
+ } else {
+ (Stream::from(*code), ListingSource::User)
}
}
- };
+ None => {
+ return self.import_module(library);
+ }
+ },
+ };
let compilation_target = {
let stream = &mut parsing_stream(stream)?;
// nothing to do.
Ok(())
}
- CompilationTarget::Module(module_name) => {
- self.import_module(module_name)
- }
+ CompilationTarget::Module(module_name) => self.import_module(module_name),
}
}
- pub(crate)
- fn use_qualified_module(
+ pub(crate) fn use_qualified_module(
&mut self,
module_src: ModuleSource,
exports: IndexSet<ModuleExport>,
) -> Result<(), SessionError> {
- let (stream, listing_src) =
- match module_src {
- ModuleSource::File(filename) => {
- let mut path_buf = PathBuf::from(filename.as_str());
- path_buf.set_extension("pl");
- let file = File::open(&path_buf)?;
-
- (Stream::from_file_as_input(filename.clone(), file),
- ListingSource::File(filename, path_buf))
- }
- ModuleSource::Library(library) => {
- match LIBRARIES.borrow().get(library.as_str()) {
- Some(code) => {
- if self.wam.indices.modules.contains_key(&library) {
- return self.import_qualified_module(library, exports);
- } else {
- (Stream::from(*code), ListingSource::User)
- }
- }
- None => {
- return self.import_qualified_module(library, exports);
- }
+ let (stream, listing_src) = match module_src {
+ ModuleSource::File(filename) => {
+ let mut path_buf = PathBuf::from(filename.as_str());
+ path_buf.set_extension("pl");
+ let file = File::open(&path_buf)?;
+
+ (
+ Stream::from_file_as_input(filename.clone(), file),
+ ListingSource::File(filename, path_buf),
+ )
+ }
+ ModuleSource::Library(library) => match LIBRARIES.borrow().get(library.as_str()) {
+ Some(code) => {
+ if self.wam.indices.modules.contains_key(&library) {
+ return self.import_qualified_module(library, exports);
+ } else {
+ (Stream::from(*code), ListingSource::User)
}
}
- };
+ None => {
+ return self.import_qualified_module(library, exports);
+ }
+ },
+ };
let compilation_target = {
let stream = &mut parsing_stream(stream)?;
}
#[inline]
- pub(super)
- fn composite_op_dir(&self) -> CompositeOpDir {
+ pub(super) fn composite_op_dir(&self) -> CompositeOpDir {
match &self.compilation_target {
- CompilationTarget::User => {
- CompositeOpDir::new(&self.wam.indices.op_dir, None)
- }
+ CompilationTarget::User => CompositeOpDir::new(&self.wam.indices.op_dir, None),
CompilationTarget::Module(ref module_name) => {
match self.wam.indices.modules.get(module_name) {
Some(ref module) => {
use prolog_parser_rebis::ast::*;
+use prolog_parser_rebis::{clause_name, temp_v};
use crate::forms::*;
use crate::indexing::*;
-use crate::machine::*;
use crate::machine::load_state::*;
use crate::machine::machine_indices::*;
use crate::machine::preprocessor::*;
+use crate::machine::*;
use indexmap::IndexSet;
SkeletonClausePopFront(CompilationTarget, PredicateKey),
SkeletonClauseTruncateBack(CompilationTarget, PredicateKey, usize),
SkeletonClauseStartReplaced(CompilationTarget, PredicateKey, usize, usize),
- RemovedDynamicSkeletonClause(CompilationTarget, PredicateKey, usize, ClauseIndexInfo, usize),
+ RemovedDynamicSkeletonClause(
+ CompilationTarget,
+ PredicateKey,
+ usize,
+ ClauseIndexInfo,
+ usize,
+ ),
ReplacedIndexingLine(usize, Vec<IndexingLine>),
}
impl RetractionInfo {
#[inline]
- pub(super)
- fn new(orig_code_extent: usize) -> Self {
+ pub(super) fn new(orig_code_extent: usize) -> Self {
Self {
orig_code_extent,
records: vec![], //BTreeMap::new(),
}
#[inline]
- pub(crate)
- fn push_record(&mut self, record: RetractionRecord) {
+ pub(crate) fn push_record(&mut self, record: RetractionRecord) {
self.records.push(record);
}
#[inline]
- pub(crate)
- fn reset(&mut self, code_len: usize) -> Self {
+ pub(crate) fn reset(&mut self, code_len: usize) -> Self {
let orig_code_extent = self.orig_code_extent;
self.orig_code_extent = code_len;
"user" => {
self.wam.indices.meta_predicates.remove(&key);
}
- _ => {
- match self.wam.indices.modules.get_mut(&target_module_name) {
- Some(ref mut module) => {
- module.meta_predicates.remove(&key);
- }
- _ => {
- unreachable!()
- }
+ _ => match self.wam.indices.modules.get_mut(&target_module_name) {
+ Some(ref mut module) => {
+ module.meta_predicates.remove(&key);
}
- }
+ _ => {
+ unreachable!()
+ }
+ },
}
}
RetractionRecord::ReplacedMetaPredicate(target_module_name, name, meta_specs) => {
match target_module_name.as_str() {
"user" => {
- self.wam.indices.meta_predicates.insert(
- (name, meta_specs.len()),
- meta_specs,
- );
+ self.wam
+ .indices
+ .meta_predicates
+ .insert((name, meta_specs.len()), meta_specs);
}
- _ => {
- match self.wam.indices.modules.get_mut(&target_module_name) {
- Some(ref mut module) => {
- module.meta_predicates.insert(
- (name, meta_specs.len()),
- meta_specs,
- );
- }
- _ => {
- unreachable!()
- }
+ _ => match self.wam.indices.modules.get_mut(&target_module_name) {
+ Some(ref mut module) => {
+ module
+ .meta_predicates
+ .insert((name, meta_specs.len()), meta_specs);
}
- }
+ _ => {
+ unreachable!()
+ }
+ },
}
}
RetractionRecord::AddedModule(module_name) => {
RetractionRecord::AddedModuleDynamicPredicate(module_name, key) => {
match self.wam.indices.modules.get_mut(&module_name) {
Some(ref mut module) => {
- module.extensible_predicates.get_mut(&key)
- .map(|skeleton| {
- skeleton.is_dynamic = false;
- });
- }
- None => {
+ module.extensible_predicates.get_mut(&key).map(|skeleton| {
+ skeleton.is_dynamic = false;
+ });
}
+ None => {}
}
}
RetractionRecord::AddedModuleExtensiblePredicate(module_name, key) => {
- self.wam.indices.remove_predicate_skeleton(
- &CompilationTarget::Module(module_name),
- &key,
- );
+ self.wam
+ .indices
+ .remove_predicate_skeleton(&CompilationTarget::Module(module_name), &key);
}
RetractionRecord::AppendedModuleExtensiblePredicate(module_name, key) => {
- self.wam.indices.get_predicate_skeleton(
- &CompilationTarget::Module(module_name),
- &key,
- ).map(|skeleton| {
- skeleton.clauses.pop_back();
- });
+ self.wam
+ .indices
+ .get_predicate_skeleton(&CompilationTarget::Module(module_name), &key)
+ .map(|skeleton| {
+ skeleton.clauses.pop_back();
+ });
}
RetractionRecord::PrependedModuleExtensiblePredicate(module_name, key) => {
- self.wam.indices.get_predicate_skeleton(
- &CompilationTarget::Module(module_name),
- &key,
- ).map(|skeleton| {
- skeleton.clauses.pop_front();
- });
+ self.wam
+ .indices
+ .get_predicate_skeleton(&CompilationTarget::Module(module_name), &key)
+ .map(|skeleton| {
+ skeleton.clauses.pop_front();
+ });
}
RetractionRecord::AddedModuleOp(module_name, mut op_decl) => {
match self.wam.indices.modules.get_mut(&module_name) {
Some(ref mut module) => {
op_decl.remove(&mut module.op_dir);
}
- None => {
- }
+ None => {}
}
}
RetractionRecord::ReplacedModuleOp(module_name, mut op_decl, prec, spec) => {
op_decl.spec = spec;
op_decl.insert_into_op_dir(&mut module.op_dir);
}
- None => {
- }
+ None => {}
}
}
RetractionRecord::AddedModulePredicate(module_name, key) => {
Some(ref mut module) => {
module.code_dir.remove(&key);
}
- None => {
- }
+ None => {}
}
}
RetractionRecord::ReplacedModulePredicate(module_name, key, old_code_idx) => {
match self.wam.indices.modules.get_mut(&module_name) {
Some(ref mut module) => {
- module.code_dir
+ module
+ .code_dir
.get_mut(&key)
.map(|code_idx| code_idx.replace(old_code_idx));
}
- None => {
- }
+ None => {}
}
}
RetractionRecord::AddedUserDynamicPredicate(key) => {
- self.wam.indices.extensible_predicates.get_mut(&key)
+ self.wam
+ .indices
+ .extensible_predicates
+ .get_mut(&key)
.map(|skeleton| {
skeleton.is_dynamic = false;
});
}
RetractionRecord::AddedUserExtensiblePredicate(key) => {
- self.wam.indices.remove_predicate_skeleton(
- &CompilationTarget::User,
- &key,
- );
+ self.wam
+ .indices
+ .remove_predicate_skeleton(&CompilationTarget::User, &key);
}
RetractionRecord::AppendedUserExtensiblePredicate(key) => {
- self.wam.indices.get_predicate_skeleton(
- &CompilationTarget::User,
- &key,
- ).map(|skeleton| {
- skeleton.clauses.pop_back();
- });
+ self.wam
+ .indices
+ .get_predicate_skeleton(&CompilationTarget::User, &key)
+ .map(|skeleton| {
+ skeleton.clauses.pop_back();
+ });
}
RetractionRecord::PrependedUserExtensiblePredicate(key) => {
- self.wam.indices.get_predicate_skeleton(
- &CompilationTarget::User,
- &key,
- ).map(|skeleton| {
- skeleton.clauses.pop_front();
- });
+ self.wam
+ .indices
+ .get_predicate_skeleton(&CompilationTarget::User, &key)
+ .map(|skeleton| {
+ skeleton.clauses.pop_front();
+ });
}
RetractionRecord::AddedUserOp(mut op_decl) => {
op_decl.remove(&mut self.wam.indices.op_dir);
self.wam.indices.code_dir.remove(&key);
}
RetractionRecord::ReplacedUserPredicate(key, old_code_idx) => {
- self.wam.indices.code_dir
+ self.wam
+ .indices
+ .code_dir
.get_mut(&key)
.map(|code_idx| code_idx.replace(old_code_idx));
}
- RetractionRecord::AddedIndex(index_key, clause_loc) => { // WAS: inner_index_locs) => {
+ RetractionRecord::AddedIndex(index_key, clause_loc) => {
+ // WAS: inner_index_locs) => {
if let Some(index_loc) = index_key.switch_on_term_loc() {
- let indexing_code =
- match &mut self.wam.code_repo.code[index_loc] {
- Line::IndexingCode(indexing_code) => {
- indexing_code
- }
- _ => {
- unreachable!()
- }
- };
+ let indexing_code = match &mut self.wam.code_repo.code[index_loc] {
+ Line::IndexingCode(indexing_code) => indexing_code,
+ _ => {
+ unreachable!()
+ }
+ };
match index_key {
- OptArgIndexKey::Constant(_, index_loc, constant, overlapping_constants) => {
+ OptArgIndexKey::Constant(
+ _,
+ index_loc,
+ constant,
+ overlapping_constants,
+ ) => {
remove_constant_indices(
&constant,
&overlapping_constants,
}
RetractionRecord::ReplacedChoiceOffset(instr_loc, offset) => {
match &mut self.wam.code_repo.code[instr_loc] {
- Line::Choice(ChoiceInstruction::TryMeElse(ref mut o)) |
- Line::Choice(ChoiceInstruction::RetryMeElse(ref mut o)) |
- Line::Choice(ChoiceInstruction::DefaultRetryMeElse(ref mut o)) => {
+ Line::Choice(ChoiceInstruction::TryMeElse(ref mut o))
+ | Line::Choice(ChoiceInstruction::RetryMeElse(ref mut o))
+ | Line::Choice(ChoiceInstruction::DefaultRetryMeElse(ref mut o)) => {
*o = offset;
}
_ => {
}
RetractionRecord::ReplacedSwitchOnTermVarIndex(index_loc, old_v) => {
match &mut self.wam.code_repo.code[index_loc] {
- Line::IndexingCode(ref mut indexing_code) => {
- match &mut indexing_code[0] {
- IndexingLine::Indexing(
- IndexingInstruction::SwitchOnTerm(_, ref mut v, ..)
- ) => {
- *v = old_v;
- }
- _ => {
- }
+ Line::IndexingCode(ref mut indexing_code) => match &mut indexing_code[0] {
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(
+ _,
+ ref mut v,
+ ..,
+ )) => {
+ *v = old_v;
}
- }
- _ => {
- }
+ _ => {}
+ },
+ _ => {}
}
}
RetractionRecord::ModifiedTryMeElse(instr_loc, o) => {
module.clause_assert_margin -= incr;
}
}
- RetractionRecord::SkeletonClauseClausesTruncateFront(compilation_target, key, len) => {
- match self.wam.indices.get_predicate_skeleton(
- &compilation_target,
- &key,
- ) {
+ RetractionRecord::SkeletonClauseClausesTruncateFront(
+ compilation_target,
+ key,
+ len,
+ ) => {
+ match self
+ .wam
+ .indices
+ .get_predicate_skeleton(&compilation_target, &key)
+ {
Some(skeleton) => {
skeleton.clause_clause_locs.truncate_front(len);
}
- None => {
- }
+ None => {}
}
- let compilation_target =
- match compilation_target {
- CompilationTarget::User => {
- CompilationTarget::Module(clause_name!("builtins"))
- }
- _ => {
- compilation_target
- }
- };
+ let compilation_target = match compilation_target {
+ CompilationTarget::User => {
+ CompilationTarget::Module(clause_name!("builtins"))
+ }
+ _ => compilation_target,
+ };
- match self.wam.indices.get_predicate_skeleton(
- &compilation_target,
- &(clause_name!("$clause"), 2),
- ) {
+ match self
+ .wam
+ .indices
+ .get_predicate_skeleton(&compilation_target, &(clause_name!("$clause"), 2))
+ {
Some(skeleton) => {
skeleton.clause_clause_locs.truncate_front(len);
}
- None => {
- }
+ None => {}
}
}
- RetractionRecord::SkeletonClauseClausesTruncateBack(compilation_target, key, len) => {
- match self.wam.indices.get_predicate_skeleton(
- &compilation_target,
- &key,
- ) {
+ RetractionRecord::SkeletonClauseClausesTruncateBack(
+ compilation_target,
+ key,
+ len,
+ ) => {
+ match self
+ .wam
+ .indices
+ .get_predicate_skeleton(&compilation_target, &key)
+ {
Some(skeleton) => {
skeleton.clause_clause_locs.truncate_back(len);
}
- None => {
- }
+ None => {}
}
- let compilation_target =
- match compilation_target {
- CompilationTarget::User => {
- CompilationTarget::Module(clause_name!("builtins"))
- }
- _ => {
- compilation_target
- }
- };
+ let compilation_target = match compilation_target {
+ CompilationTarget::User => {
+ CompilationTarget::Module(clause_name!("builtins"))
+ }
+ _ => compilation_target,
+ };
- match self.wam.indices.get_predicate_skeleton(
- &compilation_target,
- &(clause_name!("$clause"), 2),
- ) {
+ match self
+ .wam
+ .indices
+ .get_predicate_skeleton(&compilation_target, &(clause_name!("$clause"), 2))
+ {
Some(skeleton) => {
skeleton.clause_clause_locs.truncate_back(len);
}
- None => {
- }
+ None => {}
}
}
RetractionRecord::SkeletonClausePopBack(compilation_target, key) => {
- match self.wam.indices.get_predicate_skeleton(
- &compilation_target,
- &key,
- ) {
+ match self
+ .wam
+ .indices
+ .get_predicate_skeleton(&compilation_target, &key)
+ {
Some(skeleton) => {
skeleton.clauses.pop_back();
}
- None => {
- }
+ None => {}
}
}
RetractionRecord::SkeletonClausePopFront(compilation_target, key) => {
- match self.wam.indices.get_predicate_skeleton(
- &compilation_target,
- &key,
- ) {
+ match self
+ .wam
+ .indices
+ .get_predicate_skeleton(&compilation_target, &key)
+ {
Some(skeleton) => {
skeleton.clauses.pop_front();
}
- None => {
- }
+ None => {}
}
}
RetractionRecord::SkeletonClauseTruncateBack(compilation_target, key, len) => {
- match self.wam.indices.get_predicate_skeleton(
- &compilation_target,
- &key,
- ) {
+ match self
+ .wam
+ .indices
+ .get_predicate_skeleton(&compilation_target, &key)
+ {
Some(skeleton) => {
skeleton.clauses.truncate_back(len);
}
- None => {
- }
+ None => {}
}
}
RetractionRecord::SkeletonClauseStartReplaced(
target_pos,
clause_start,
) => {
- match self.wam.indices.get_predicate_skeleton(
- &compilation_target,
- &key,
- ) {
+ match self
+ .wam
+ .indices
+ .get_predicate_skeleton(&compilation_target, &key)
+ {
Some(skeleton) => {
skeleton.clauses[target_pos].clause_start = clause_start;
}
- None => {
- }
+ None => {}
}
}
RetractionRecord::RemovedDynamicSkeletonClause(
clause_index_info,
clause_clause_loc,
) => {
- match self.wam.indices.get_predicate_skeleton(
- &compilation_target,
- &key,
- ) {
+ match self
+ .wam
+ .indices
+ .get_predicate_skeleton(&compilation_target, &key)
+ {
Some(skeleton) => {
- skeleton.clause_clause_locs.insert(target_pos, clause_clause_loc);
+ skeleton
+ .clause_clause_locs
+ .insert(target_pos, clause_clause_loc);
skeleton.clauses.insert(target_pos, clause_index_info);
}
- None => {
- }
+ None => {}
}
}
RetractionRecord::ReplacedIndexingLine(index_loc, indexing_code) => {
impl CompilationTarget {
#[inline]
- pub(super)
- fn take(&mut self) -> CompilationTarget {
+ pub(super) fn take(&mut self) -> CompilationTarget {
mem::replace(self, CompilationTarget::User)
}
#[inline]
- pub(super)
- fn module_name(&self) -> ClauseName {
+ pub(super) fn module_name(&self) -> ClauseName {
match self {
CompilationTarget::User => {
clause_name!("user")
}
- CompilationTarget::Module(ref module_name) => {
- module_name.clone()
- }
+ CompilationTarget::Module(ref module_name) => module_name.clone(),
}
}
}
impl<'a, TS: TermStream> Loader<'a, TS> {
#[inline]
- pub(super)
- fn new(term_stream: TS, wam: &'a mut Machine) -> Self {
+ pub(super) fn new(term_stream: TS, wam: &'a mut Machine) -> Self {
let flags = wam.machine_st.flags;
let load_state = LoadState {
compilation_target: CompilationTarget::User,
}
}
- pub(crate)
- fn load(mut self) -> Result<TS::Evacuable, SessionError> {
+ pub(crate) fn load(mut self) -> Result<TS::Evacuable, SessionError> {
while let Some(decl) = self.dequeue_terms()? {
self.load_decl(decl)?;
}
)?;
match tl {
- TopLevel::Fact(fact) =>
- self.predicates.push(PredicateClause::Fact(fact)),
- TopLevel::Rule(rule) =>
- self.predicates.push(PredicateClause::Rule(rule)),
- TopLevel::Predicate(pred) =>
- self.predicates.extend(pred),
- TopLevel::Declaration(decl) =>
- return Ok(Some(decl)),
- TopLevel::Query(_) =>
- return Err(SessionError::QueryCannotBeDefinedAsFact),
+ TopLevel::Fact(fact) => self.predicates.push(PredicateClause::Fact(fact)),
+ TopLevel::Rule(rule) => self.predicates.push(PredicateClause::Rule(rule)),
+ TopLevel::Predicate(pred) => self.predicates.extend(pred),
+ TopLevel::Declaration(decl) => return Ok(Some(decl)),
+ TopLevel::Query(_) => return Err(SessionError::QueryCannotBeDefinedAsFact),
}
}
Ok(None)
}
- pub(super)
- fn load_decl(&mut self, decl: Declaration) -> Result<(), SessionError> {
+ pub(super) fn load_decl(&mut self, decl: Declaration) -> Result<(), SessionError> {
match decl {
Declaration::Dynamic(name, arity) => {
self.add_dynamic_predicate(name, arity);
}
Declaration::MetaPredicate(module_name, name, meta_specs) => {
- self.load_state.add_meta_predicate_record(
- module_name,
- name,
- meta_specs,
- );
+ self.load_state
+ .add_meta_predicate_record(module_name, name, meta_specs);
}
Declaration::Module(module_decl) => {
self.load_state.compilation_target =
CompilationTarget::Module(module_decl.name.clone());
- self.load_state.add_module(
- module_decl,
- self.term_stream.listing_src().clone(),
- );
+ self.load_state
+ .add_module(module_decl, self.term_stream.listing_src().clone());
}
Declaration::NonCountedBacktracking(name, arity) => {
self.non_counted_bt_preds.insert((name, arity));
Ok(())
}
- pub(super)
- fn read_term_from_heap(&self, heap_term_loc: RegType) -> Result<Term, SessionError> {
+ pub(super) fn read_term_from_heap(&self, heap_term_loc: RegType) -> Result<Term, SessionError> {
let machine_st = &self.load_state.wam.machine_st;
- let term_addr = machine_st[heap_term_loc];
+ let term_addr = machine_st[heap_term_loc];
if machine_st.is_cyclic_term(term_addr) {
return Err(SessionError::from(CompilationError::CannotParseCyclicTerm));
for addr in machine_st.post_order_iter(term_addr) {
match machine_st.heap.index_addr(&addr).as_ref() {
- HeapCellValue::Addr(Addr::Lis(_)) |
- HeapCellValue::Addr(Addr::PStrLocation(..)) => {
+ HeapCellValue::Addr(Addr::Lis(_)) | HeapCellValue::Addr(Addr::PStrLocation(..)) => {
let tail = term_stack.pop().unwrap();
let head = term_stack.pop().unwrap();
- term_stack.push(Term::Cons(
- Cell::default(),
- Box::new(head),
- Box::new(tail),
- ));
+ term_stack.push(Term::Cons(Cell::default(), Box::new(head), Box::new(tail)));
}
HeapCellValue::Addr(addr) => {
if let Some(r) = addr.as_var() {
- let offset_string =
- match r {
- Ref::HeapCell(h) | Ref::AttrVar(h) =>
- format!("_{}", h),
- Ref::StackCell(fr, sc) =>
- format!("_s_{}_{}", fr, sc),
- };
+ let offset_string = match r {
+ Ref::HeapCell(h) | Ref::AttrVar(h) => format!("_{}", h),
+ Ref::StackCell(fr, sc) => format!("_s_{}_{}", fr, sc),
+ };
- term_stack.push(Term::Var(
- Cell::default(),
- Rc::new(offset_string),
- ));
+ term_stack.push(Term::Var(Cell::default(), Rc::new(offset_string)));
} else {
match addr.as_constant_index(machine_st) {
Some(constant) => {
));
}
HeapCellValue::NamedStr(arity, ref name, ref shared_op_desc) => {
- let subterms = term_stack.drain(term_stack.len() - arity ..)
+ let subterms = term_stack
+ .drain(term_stack.len() - arity..)
.map(Box::new)
.collect();
fn add_clause_clause(&mut self, term: Term) -> Result<(), CompilationError> {
match term {
Term::Clause(_, turnstile, mut terms, _)
- if turnstile.as_str() == ":-" && terms.len() == 2 => {
- let body = *terms.pop().unwrap();
- let head = *terms.pop().unwrap();
+ if turnstile.as_str() == ":-" && terms.len() == 2 =>
+ {
+ let body = *terms.pop().unwrap();
+ let head = *terms.pop().unwrap();
- self.clause_clauses.push((head, body));
- }
- head @ Term::Constant(_, Constant::Atom(..)) |
- head @ Term::Clause(..) => {
- let body = Term::Constant(
- Cell::default(),
- Constant::Atom(clause_name!("true"), None),
- );
+ self.clause_clauses.push((head, body));
+ }
+ head @ Term::Constant(_, Constant::Atom(..)) | head @ Term::Clause(..) => {
+ let body =
+ Term::Constant(Cell::default(), Constant::Atom(clause_name!("true"), None));
self.clause_clauses.push((head, body));
}
match &self.load_state.compilation_target {
CompilationTarget::User => {
- match self.load_state.wam.indices.extensible_predicates.get_mut(&key) {
+ match self
+ .load_state
+ .wam
+ .indices
+ .extensible_predicates
+ .get_mut(&key)
+ {
Some(ref mut skeleton) => {
if !skeleton.is_dynamic {
skeleton.is_dynamic = true;
self.load_state.retraction_info.push_record(
- RetractionRecord::AddedUserDynamicPredicate(key.clone())
+ RetractionRecord::AddedUserDynamicPredicate(key.clone()),
);
}
}
None => {
- self.load_state.wam.indices.extensible_predicates.insert(
- key.clone(),
- PredicateSkeleton::new().set_dynamic(true),
- );
+ self.load_state
+ .wam
+ .indices
+ .extensible_predicates
+ .insert(key.clone(), PredicateSkeleton::new().set_dynamic(true));
self.load_state.retraction_info.push_record(
- RetractionRecord::AddedUserExtensiblePredicate(key.clone())
+ RetractionRecord::AddedUserExtensiblePredicate(key.clone()),
);
}
}
}
CompilationTarget::Module(ref module_name) => {
match self.load_state.wam.indices.modules.get_mut(module_name) {
- Some(ref mut module) => {
- match module.extensible_predicates.get_mut(&key) {
- Some(ref mut skeleton) => {
- if !skeleton.is_dynamic {
- skeleton.is_dynamic = true;
-
- self.load_state.retraction_info.push_record(
- RetractionRecord::AddedModuleDynamicPredicate(
- module_name.clone(),
- key.clone(),
- ),
- );
- }
- }
- None => {
- module.extensible_predicates.insert(
- key.clone(),
- PredicateSkeleton::new().set_dynamic(true),
- );
+ Some(ref mut module) => match module.extensible_predicates.get_mut(&key) {
+ Some(ref mut skeleton) => {
+ if !skeleton.is_dynamic {
+ skeleton.is_dynamic = true;
self.load_state.retraction_info.push_record(
- RetractionRecord::AddedModuleExtensiblePredicate(
+ RetractionRecord::AddedModuleDynamicPredicate(
module_name.clone(),
key.clone(),
),
);
}
}
- }
+ None => {
+ module
+ .extensible_predicates
+ .insert(key.clone(), PredicateSkeleton::new().set_dynamic(true));
+
+ self.load_state.retraction_info.push_record(
+ RetractionRecord::AddedModuleExtensiblePredicate(
+ module_name.clone(),
+ key.clone(),
+ ),
+ );
+ }
+ },
None => {
unreachable!();
}
}
impl Machine {
- pub(crate)
- fn use_module(&mut self) {
- let subevacuable_addr =
- self.machine_st.store(self.machine_st.deref(self.machine_st[temp_v!(2)]));
-
- let module_src =
- ModuleSource::Library(
- match subevacuable_addr {
- Addr::LoadStatePayload(payload) => {
- match &self.machine_st.heap[payload] {
- HeapCellValue::LoadStatePayload(payload) => {
- match &payload.compilation_target {
- CompilationTarget::Module(ref module_name) => {
- module_name.clone()
- }
- CompilationTarget::User => {
- return;
- }
- }
- }
- _ => {
- unreachable!()
- }
- }
- }
- _ => {
- unreachable!()
+ pub(crate) fn use_module(&mut self) {
+ let subevacuable_addr = self
+ .machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(2)]));
+
+ let module_src = ModuleSource::Library(match subevacuable_addr {
+ Addr::LoadStatePayload(payload) => match &self.machine_st.heap[payload] {
+ HeapCellValue::LoadStatePayload(payload) => match &payload.compilation_target {
+ CompilationTarget::Module(ref module_name) => module_name.clone(),
+ CompilationTarget::User => {
+ return;
}
+ },
+ _ => {
+ unreachable!()
}
- );
+ },
+ _ => {
+ unreachable!()
+ }
+ });
let (mut loader, evacuable_h) = self.loader_from_heap_evacuable(temp_v!(1));
if export_list.is_empty() {
loader.load_state.use_module(module_src)?;
} else {
- loader.load_state.use_qualified_module(module_src, export_list)?;
+ loader
+ .load_state
+ .use_qualified_module(module_src, export_list)?;
}
LiveTermStream::evacuate(loader)
self.restore_load_state_payload(result, evacuable_h);
}
- pub(crate)
- fn load_compiled_library(&mut self) {
+ pub(crate) fn load_compiled_library(&mut self) {
let library = atom_from!(
self.machine_st,
- self.machine_st.store(self.machine_st.deref(
- self.machine_st[temp_v!(1)]
- ))
+ self.machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(1)]))
);
if let Some(module) = self.indices.modules.get(&library) {
}
}
- pub(crate)
- fn declare_module(&mut self) {
+ pub(crate) fn declare_module(&mut self) {
let module_name = atom_from!(
self.machine_st,
- self.machine_st.store(self.machine_st.deref(
- self.machine_st[temp_v!(1)]
- ))
+ self.machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(1)]))
);
// let export_list = self.machine_st.extract_module_export_list(temp_v!(2));
self.restore_load_state_payload(result, evacuable_h);
}
- pub(crate)
- fn add_dynamic_predicate(&mut self) {
+ pub(crate) fn add_dynamic_predicate(&mut self) {
let predicate_name = atom_from!(
self.machine_st,
- self.machine_st.store(self.machine_st.deref(
- self.machine_st[temp_v!(1)]
- ))
+ self.machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(1)]))
);
- let arity =
- self.machine_st.store(self.machine_st.deref(self.machine_st[temp_v!(2)]));
-
- let arity =
- match Number::try_from((arity, &self.machine_st.heap)) {
- Ok(Number::Integer(n)) if &*n >= &0 && &*n <= &MAX_ARITY =>
- Ok(n.to_usize().unwrap()),
- Ok(Number::Fixnum(n)) if n >= 0 && n <= MAX_ARITY as isize =>
- Ok(usize::try_from(n).unwrap()),
- _ =>
- Err(SessionError::from(CompilationError::InvalidRuleHead))
- };
+ let arity = self
+ .machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(2)]));
+
+ let arity = match Number::try_from((arity, &self.machine_st.heap)) {
+ Ok(Number::Integer(n)) if &*n >= &0 && &*n <= &MAX_ARITY => Ok(n.to_usize().unwrap()),
+ Ok(Number::Fixnum(n)) if n >= 0 && n <= MAX_ARITY as isize => {
+ Ok(usize::try_from(n).unwrap())
+ }
+ _ => Err(SessionError::from(CompilationError::InvalidRuleHead)),
+ };
let (mut loader, evacuable_h) = self.loader_from_heap_evacuable(temp_v!(3));
self.restore_load_state_payload(result, evacuable_h);
}
- pub(crate)
- fn add_term_expansion_clause(&mut self) {
+ pub(crate) fn add_term_expansion_clause(&mut self) {
let (mut loader, evacuable_h) = self.loader_from_heap_evacuable(temp_v!(2));
let add_clause = || {
self.restore_load_state_payload(result, evacuable_h);
}
- pub(crate)
- fn add_goal_expansion_clause(&mut self) {
+ pub(crate) fn add_goal_expansion_clause(&mut self) {
let target_module_name = atom_from!(
self.machine_st,
- self.machine_st.store(self.machine_st.deref(
- self.machine_st[temp_v!(1)]
- ))
+ self.machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(1)]))
);
let (mut loader, evacuable_h) = self.loader_from_heap_evacuable(temp_v!(3));
- let compilation_target =
- match target_module_name.as_str() {
- "user" => CompilationTarget::User,
- _ => CompilationTarget::Module(target_module_name),
- };
+ let compilation_target = match target_module_name.as_str() {
+ "user" => CompilationTarget::User,
+ _ => CompilationTarget::Module(target_module_name),
+ };
let add_clause = || {
let term = loader.read_term_from_heap(temp_v!(2))?;
self.restore_load_state_payload(result, evacuable_h);
}
- pub(crate)
- fn loader_from_heap_evacuable(&mut self, r: RegType) -> (Loader<LiveTermStream>, usize) {
- let (load_state_payload, evacuable_h) =
- match self.machine_st.store(self.machine_st.deref(self.machine_st[r])) {
- Addr::LoadStatePayload(h) => {
- ( mem::replace(
- &mut self.machine_st.heap[h],
- HeapCellValue::Addr(Addr::EmptyList),
- ),
- h,
- )
- }
- _ => {
- unreachable!()
- }
- };
+ pub(crate) fn loader_from_heap_evacuable(
+ &mut self,
+ r: RegType,
+ ) -> (Loader<LiveTermStream>, usize) {
+ let (load_state_payload, evacuable_h) = match self
+ .machine_st
+ .store(self.machine_st.deref(self.machine_st[r]))
+ {
+ Addr::LoadStatePayload(h) => (
+ mem::replace(
+ &mut self.machine_st.heap[h],
+ HeapCellValue::Addr(Addr::EmptyList),
+ ),
+ h,
+ ),
+ _ => {
+ unreachable!()
+ }
+ };
match load_state_payload {
HeapCellValue::LoadStatePayload(payload) => {
}
#[inline]
- pub(crate)
- fn push_load_state_payload(&mut self) {
+ pub(crate) fn push_load_state_payload(&mut self) {
let payload = LoadStatePayload::new(self);
let addr = Addr::LoadStatePayload(
- self.machine_st.heap.push(HeapCellValue::LoadStatePayload(payload))
+ self.machine_st
+ .heap
+ .push(HeapCellValue::LoadStatePayload(payload)),
);
- self.machine_st.bind(self.machine_st[temp_v!(1)].as_var().unwrap(), addr);
+ self.machine_st
+ .bind(self.machine_st[temp_v!(1)].as_var().unwrap(), addr);
}
#[inline]
- pub(crate)
- fn pop_load_state_payload(&mut self) {
- let load_state_payload =
- match self.machine_st.store(self.machine_st.deref(self.machine_st[temp_v!(1)])) {
- Addr::LoadStatePayload(h) => {
- mem::replace(
- &mut self.machine_st.heap[h],
- HeapCellValue::Addr(Addr::EmptyList),
- )
- }
- _ => {
- unreachable!()
- }
- };
+ pub(crate) fn pop_load_state_payload(&mut self) {
+ let load_state_payload = match self
+ .machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(1)]))
+ {
+ Addr::LoadStatePayload(h) => mem::replace(
+ &mut self.machine_st.heap[h],
+ HeapCellValue::Addr(Addr::EmptyList),
+ ),
+ _ => {
+ unreachable!()
+ }
+ };
match load_state_payload {
HeapCellValue::LoadStatePayload(payload) => {
}
#[inline]
- pub(crate)
- fn pop_load_context(&mut self) {
+ pub(crate) fn pop_load_context(&mut self) {
self.load_contexts.pop();
}
- pub(crate)
- fn push_load_context(&mut self) {
- let stream =
- try_or_fail!(
- self.machine_st,
- self.machine_st.get_stream_or_alias(
- self.machine_st[temp_v!(1)],
- &self.indices,
- "$push_load_context",
- 2,
- )
- );
+ pub(crate) fn push_load_context(&mut self) {
+ let stream = try_or_fail!(
+ self.machine_st,
+ self.machine_st.get_stream_or_alias(
+ self.machine_st[temp_v!(1)],
+ &self.indices,
+ "$push_load_context",
+ 2,
+ )
+ );
- let path =
- atom_from!(
- self.machine_st,
- self.machine_st.store(self.machine_st.deref(
- self.machine_st[temp_v!(2)]
- ))
- );
+ let path = atom_from!(
+ self.machine_st,
+ self.machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(2)]))
+ );
- self.load_contexts.push(LoadContext::new(path.as_str(), stream));
+ self.load_contexts
+ .push(LoadContext::new(path.as_str(), stream));
}
- pub(crate)
- fn restore_load_state_payload(
+ pub(crate) fn restore_load_state_payload(
&mut self,
result: Result<LoadStatePayload, SessionError>,
evacuable_h: usize,
) {
match result {
Ok(payload) => {
- self.machine_st.heap[evacuable_h] = HeapCellValue::LoadStatePayload(
- payload
- );
+ self.machine_st.heap[evacuable_h] = HeapCellValue::LoadStatePayload(payload);
}
Err(e) => {
self.throw_session_error(e, (clause_name!("load"), 1));
}
}
- pub(crate)
- fn clause_to_evacuable(&mut self) {
+ pub(crate) fn clause_to_evacuable(&mut self) {
let (mut loader, evacuable_h) = self.loader_from_heap_evacuable(temp_v!(2));
let enqueue_term = || {
if let Some(predicate_name) = ClauseInfo::name(&term) {
let arity = ClauseInfo::arity(&term);
- let is_dynamic =
- loader.load_state.wam.indices.get_predicate_skeleton(
+ let is_dynamic = loader
+ .load_state
+ .wam
+ .indices
+ .get_predicate_skeleton(
&loader.load_state.compilation_target,
&(predicate_name, arity),
- ).map(|skeleton| skeleton.is_dynamic)
- .unwrap_or(false);
+ )
+ .map(|skeleton| skeleton.is_dynamic)
+ .unwrap_or(false);
if is_dynamic {
loader.add_clause_clause(term.clone())?;
self.restore_load_state_payload(result, evacuable_h);
}
- pub(crate)
- fn conclude_load(&mut self) {
+ pub(crate) fn conclude_load(&mut self) {
let (mut loader, evacuable_h) = self.loader_from_heap_evacuable(temp_v!(1));
let compile_final_terms = || {
self.restore_load_state_payload(result, evacuable_h);
}
- pub(crate)
- fn load_context_source(&mut self) {
+ pub(crate) fn load_context_source(&mut self) {
if let Some(load_context) = self.load_contexts.last() {
let path_str = load_context.path.to_str().unwrap();
- let path_atom =
- clause_name!(path_str.to_string(), self.machine_st.atom_tbl);
+ let path_atom = clause_name!(path_str.to_string(), self.machine_st.atom_tbl);
let path_addr = Addr::Con(
- self.machine_st.heap.push(HeapCellValue::Atom(path_atom, None))
+ self.machine_st
+ .heap
+ .push(HeapCellValue::Atom(path_atom, None)),
);
- self.machine_st.unify(path_addr, self.machine_st[temp_v!(1)]);
+ self.machine_st
+ .unify(path_addr, self.machine_st[temp_v!(1)]);
} else {
self.machine_st.fail = true;
}
}
- pub(crate)
- fn load_context_file(&mut self) {
+ pub(crate) fn load_context_file(&mut self) {
if let Some(load_context) = self.load_contexts.last() {
if let Some(file_name) = load_context.path.file_name() {
let file_name_str = file_name.to_str().unwrap();
clause_name!(file_name_str.to_string(), self.machine_st.atom_tbl);
let file_name_addr = Addr::Con(
- self.machine_st.heap.push(HeapCellValue::Atom(file_name_atom, None))
+ self.machine_st
+ .heap
+ .push(HeapCellValue::Atom(file_name_atom, None)),
);
- self.machine_st.unify(file_name_addr, self.machine_st[temp_v!(1)]);
+ self.machine_st
+ .unify(file_name_addr, self.machine_st[temp_v!(1)]);
return;
}
}
self.machine_st.fail = true;
}
- pub(crate)
- fn load_context_directory(&mut self) {
+ pub(crate) fn load_context_directory(&mut self) {
if let Some(load_context) = self.load_contexts.last() {
if let Some(directory) = load_context.path.ancestors().next() {
let directory_str = directory.to_str().unwrap();
clause_name!(directory_str.to_string(), self.machine_st.atom_tbl);
let directory_addr = Addr::Con(
- self.machine_st.heap.push(HeapCellValue::Atom(directory_atom, None))
+ self.machine_st
+ .heap
+ .push(HeapCellValue::Atom(directory_atom, None)),
);
- self.machine_st.unify(directory_addr, self.machine_st[temp_v!(1)]);
+ self.machine_st
+ .unify(directory_addr, self.machine_st[temp_v!(1)]);
return;
}
}
self.machine_st.fail = true;
}
- pub(crate)
- fn load_context_module(&mut self) {
+ pub(crate) fn load_context_module(&mut self) {
if let Some(load_context) = self.load_contexts.last() {
let module_name_addr = Addr::Con(
- self.machine_st.heap.push(HeapCellValue::Atom(
- load_context.module.clone(),
- None,
- ))
+ self.machine_st
+ .heap
+ .push(HeapCellValue::Atom(load_context.module.clone(), None)),
);
- self.machine_st.unify(module_name_addr, self.machine_st[temp_v!(1)]);
+ self.machine_st
+ .unify(module_name_addr, self.machine_st[temp_v!(1)]);
} else {
self.machine_st.fail = true;
}
}
- pub(crate)
- fn load_context_stream(&mut self) {
+ pub(crate) fn load_context_stream(&mut self) {
if let Some(load_context) = self.load_contexts.last() {
let stream_addr = Addr::Stream(
- self.machine_st.heap.push(HeapCellValue::Stream(
- load_context.stream.clone()
- ))
+ self.machine_st
+ .heap
+ .push(HeapCellValue::Stream(load_context.stream.clone())),
);
- self.machine_st.unify(stream_addr, self.machine_st[temp_v!(1)]);
+ self.machine_st
+ .unify(stream_addr, self.machine_st[temp_v!(1)]);
} else {
self.machine_st.fail = true;
}
}
- pub(crate)
- fn compile_assert(&mut self, append_or_prepend: AppendOrPrepend) {
- let key = self.machine_st.read_predicate_key(
- self.machine_st[temp_v!(3)],
- self.machine_st[temp_v!(4)],
- );
+ pub(crate) fn compile_assert(&mut self, append_or_prepend: AppendOrPrepend) {
+ let key = self
+ .machine_st
+ .read_predicate_key(self.machine_st[temp_v!(3)], self.machine_st[temp_v!(4)]);
let module_name = atom_from!(
self.machine_st,
- self.machine_st.store(self.machine_st.deref(
- self.machine_st[temp_v!(5)]
- ))
+ self.machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(5)]))
);
- let compilation_target =
- match module_name.as_str() {
- "user" => CompilationTarget::User,
- _ => CompilationTarget::Module(module_name),
- };
+ let compilation_target = match module_name.as_str() {
+ "user" => CompilationTarget::User,
+ _ => CompilationTarget::Module(module_name),
+ };
let compile_assert = || {
let mut loader = Loader::new(LiveTermStream::new(ListingSource::User), self);
let head = loader.read_term_from_heap(temp_v!(1))?;
let body = loader.read_term_from_heap(temp_v!(2))?;
- let asserted_clause =
- Term::Clause(
- Cell::default(),
- clause_name!(":-"),
- vec![Box::new(head.clone()), Box::new(body.clone())],
- fetch_op_spec(clause_name!(":-"), 2, &loader.load_state.wam.indices.op_dir),
- );
+ let asserted_clause = Term::Clause(
+ Cell::default(),
+ clause_name!(":-"),
+ vec![Box::new(head.clone()), Box::new(body.clone())],
+ fetch_op_spec(clause_name!(":-"), 2, &loader.load_state.wam.indices.op_dir),
+ );
loader.incremental_compile_clause(
key.clone(),
)?;
// if a new predicate was just created, make it dynamic.
- loader.load_state.wam.indices.get_predicate_skeleton(
- &compilation_target,
- &key,
- ).map(|skeleton| skeleton.is_dynamic = true);
+ loader
+ .load_state
+ .wam
+ .indices
+ .get_predicate_skeleton(&compilation_target, &key)
+ .map(|skeleton| skeleton.is_dynamic = true);
loader.compile_clause_clauses(
key,
};
match compile_assert() {
- Ok(_) => {
- }
+ Ok(_) => {}
Err(e) => {
- let error_pi =
- match append_or_prepend {
- AppendOrPrepend::Append => (clause_name!("assertz"), 1),
- AppendOrPrepend::Prepend => (clause_name!("asserta"), 1),
- };
+ let error_pi = match append_or_prepend {
+ AppendOrPrepend::Append => (clause_name!("assertz"), 1),
+ AppendOrPrepend::Prepend => (clause_name!("asserta"), 1),
+ };
self.throw_session_error(e, error_pi);
}
}
}
- pub(crate)
- fn abolish_clause(&mut self) {
+ pub(crate) fn abolish_clause(&mut self) {
let module_name = atom_from!(
self.machine_st,
- self.machine_st.store(self.machine_st.deref(
- self.machine_st[temp_v!(1)]
- ))
+ self.machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(1)]))
);
- let key =
- self.machine_st.read_predicate_key(
- self.machine_st[temp_v!(2)],
- self.machine_st[temp_v!(3)],
- );
+ let key = self
+ .machine_st
+ .read_predicate_key(self.machine_st[temp_v!(2)], self.machine_st[temp_v!(3)]);
- let compilation_target =
- match module_name.as_str() {
- "user" => CompilationTarget::User,
- _ => CompilationTarget::Module(module_name),
- };
+ let compilation_target = match module_name.as_str() {
+ "user" => CompilationTarget::User,
+ _ => CompilationTarget::Module(module_name),
+ };
let mut loader = Loader::new(LiveTermStream::new(ListingSource::User), self);
loader.load_state.compilation_target = compilation_target;
- match loader.load_state.wam.indices.get_predicate_skeleton(
- &loader.load_state.compilation_target,
- &key
- ) {
+ match loader
+ .load_state
+ .wam
+ .indices
+ .get_predicate_skeleton(&loader.load_state.compilation_target, &key)
+ {
Some(skeleton) => {
skeleton.clauses.clear();
skeleton.clause_clause_locs.clear();
loader.load_state.compilation_target =
CompilationTarget::Module(clause_name!("builtins"));
}
- _ => {
- }
+ _ => {}
};
match loader.load_state.wam.indices.get_predicate_skeleton(
}
}
- let clause_clause_code_index = loader.load_state.get_or_insert_code_index(
- (clause_name!("$clause"), 2),
- );
+ let clause_clause_code_index = loader
+ .load_state
+ .get_or_insert_code_index((clause_name!("$clause"), 2));
clause_clause_code_index.set(IndexPtr::DynamicUndefined);
}
- pub(crate)
- fn retract_clause(&mut self) {
- let key =
- self.machine_st.read_predicate_key(
- self.machine_st[temp_v!(1)],
- self.machine_st[temp_v!(2)],
- );
+ pub(crate) fn retract_clause(&mut self) {
+ let key = self
+ .machine_st
+ .read_predicate_key(self.machine_st[temp_v!(1)], self.machine_st[temp_v!(2)]);
- let target_pos =
- self.machine_st.store(self.machine_st.deref(self.machine_st[temp_v!(3)]));
+ let target_pos = self
+ .machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(3)]));
- let target_pos =
- match Number::try_from((target_pos, &self.machine_st.heap)) {
- Ok(Number::Integer(n)) =>
- n.to_usize().unwrap(),
- Ok(Number::Fixnum(n)) =>
- usize::try_from(n).unwrap(),
- _ =>
- unreachable!()
- };
+ let target_pos = match Number::try_from((target_pos, &self.machine_st.heap)) {
+ Ok(Number::Integer(n)) => n.to_usize().unwrap(),
+ Ok(Number::Fixnum(n)) => usize::try_from(n).unwrap(),
+ _ => unreachable!(),
+ };
let module_name = atom_from!(
self.machine_st,
- self.machine_st.store(self.machine_st.deref(
- self.machine_st[temp_v!(4)]
- ))
+ self.machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(4)]))
);
- let compilation_target =
- match module_name.as_str() {
- "user" => CompilationTarget::User,
- _ => CompilationTarget::Module(module_name),
- };
+ let compilation_target = match module_name.as_str() {
+ "user" => CompilationTarget::User,
+ _ => CompilationTarget::Module(module_name),
+ };
- let clause_clause_compilation_target =
- match &compilation_target {
- CompilationTarget::User => {
- CompilationTarget::Module(clause_name!("builtins"))
- }
- _ => {
- compilation_target.clone()
- }
- };
+ let clause_clause_compilation_target = match &compilation_target {
+ CompilationTarget::User => CompilationTarget::Module(clause_name!("builtins")),
+ _ => compilation_target.clone(),
+ };
let retract_clause = || {
let mut loader = Loader::new(LiveTermStream::new(ListingSource::User), self);
let clause_clause_loc = loader.load_state.retract_clause(key, target_pos);
- let clause_assert_margin =
- loader.load_state.wam.indices.modules
- .get(&clause_clause_compilation_target.module_name())
- .map(|module| module.clause_assert_margin)
- .unwrap();
-
- let target_pos =
- match loader.load_state.wam.indices.get_predicate_skeleton(
- &clause_clause_compilation_target,
- &(clause_name!("$clause"), 2),
- ) {
- Some(skeleton) => {
- let search_result =
- skeleton.clause_clause_locs[0 .. clause_assert_margin]
- .binary_search_by(|loc| clause_clause_loc.cmp(&loc));
-
- let result =
- search_result.unwrap_or_else(|_| {
- skeleton.clause_clause_locs[clause_assert_margin ..]
- .binary_search_by(|loc| loc.cmp(&clause_clause_loc))
- .unwrap() + clause_assert_margin
- });
-
- if result < clause_assert_margin {
- loader.load_state.wam.indices.modules
- .get_mut(&clause_clause_compilation_target.module_name())
- .map(|module| module.clause_assert_margin -= 1);
- }
+ let clause_assert_margin = loader
+ .load_state
+ .wam
+ .indices
+ .modules
+ .get(&clause_clause_compilation_target.module_name())
+ .map(|module| module.clause_assert_margin)
+ .unwrap();
+
+ let target_pos = match loader.load_state.wam.indices.get_predicate_skeleton(
+ &clause_clause_compilation_target,
+ &(clause_name!("$clause"), 2),
+ ) {
+ Some(skeleton) => {
+ let search_result = skeleton.clause_clause_locs[0..clause_assert_margin]
+ .binary_search_by(|loc| clause_clause_loc.cmp(&loc));
+
+ let result = search_result.unwrap_or_else(|_| {
+ skeleton.clause_clause_locs[clause_assert_margin..]
+ .binary_search_by(|loc| loc.cmp(&clause_clause_loc))
+ .unwrap()
+ + clause_assert_margin
+ });
- result
- }
- None => {
- unreachable!();
+ if result < clause_assert_margin {
+ loader
+ .load_state
+ .wam
+ .indices
+ .modules
+ .get_mut(&clause_clause_compilation_target.module_name())
+ .map(|module| module.clause_assert_margin -= 1);
}
- };
+
+ result
+ }
+ None => {
+ unreachable!();
+ }
+ };
loader.load_state.compilation_target = clause_clause_compilation_target;
- loader.load_state.retract_clause((clause_name!("$clause"), 2), target_pos);
+ loader
+ .load_state
+ .retract_clause((clause_name!("$clause"), 2), target_pos);
LiveTermStream::evacuate(loader)
};
match retract_clause() {
- Ok(_) => {
- }
+ Ok(_) => {}
Err(e) => {
self.throw_session_error(e, (clause_name!("retract"), 1));
}
}
}
- pub(crate)
- fn meta_predicate_property(&mut self) {
+ pub(crate) fn meta_predicate_property(&mut self) {
let module_name = atom_from!(
self.machine_st,
- self.machine_st.store(self.machine_st.deref(
- self.machine_st[temp_v!(1)]
- ))
+ self.machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(1)]))
);
- let (predicate_name, arity) =
- self.machine_st.read_predicate_key(
- self.machine_st[temp_v!(2)],
- self.machine_st[temp_v!(3)],
- );
+ let (predicate_name, arity) = self
+ .machine_st
+ .read_predicate_key(self.machine_st[temp_v!(2)], self.machine_st[temp_v!(3)]);
- let compilation_target =
- match module_name.as_str() {
- "user" => CompilationTarget::User,
- _ => CompilationTarget::Module(module_name),
- };
+ let compilation_target = match module_name.as_str() {
+ "user" => CompilationTarget::User,
+ _ => CompilationTarget::Module(module_name),
+ };
- match self.indices.get_meta_predicate_spec(predicate_name, arity, &compilation_target) {
+ match self
+ .indices
+ .get_meta_predicate_spec(predicate_name, arity, &compilation_target)
+ {
Some(meta_specs) => {
- let list_loc = self.machine_st.heap.to_list(
- meta_specs.iter().map(|meta_spec| {
- match meta_spec {
- MetaSpec::Minus => HeapCellValue::Atom(clause_name!("+"), None),
- MetaSpec::Plus => HeapCellValue::Atom(clause_name!("-"), None),
- MetaSpec::Either => HeapCellValue::Atom(clause_name!("?"), None),
- MetaSpec::RequiresExpansionWithArgument(ref arg_num) => {
- HeapCellValue::Addr(Addr::Usize(*arg_num))
- }
+ let list_loc = self
+ .machine_st
+ .heap
+ .to_list(meta_specs.iter().map(|meta_spec| match meta_spec {
+ MetaSpec::Minus => HeapCellValue::Atom(clause_name!("+"), None),
+ MetaSpec::Plus => HeapCellValue::Atom(clause_name!("-"), None),
+ MetaSpec::Either => HeapCellValue::Atom(clause_name!("?"), None),
+ MetaSpec::RequiresExpansionWithArgument(ref arg_num) => {
+ HeapCellValue::Addr(Addr::Usize(*arg_num))
}
- }),
- );
+ }));
- let heap_loc = self.machine_st.heap.push(
- HeapCellValue::NamedStr(1, clause_name!("meta_predicate"), None),
- );
+ let heap_loc = self.machine_st.heap.push(HeapCellValue::NamedStr(
+ 1,
+ clause_name!("meta_predicate"),
+ None,
+ ));
- self.machine_st.heap.push(HeapCellValue::Addr(Addr::HeapCell(list_loc)));
- self.machine_st.unify(Addr::HeapCell(heap_loc), self.machine_st[temp_v!(4)]);
+ self.machine_st
+ .heap
+ .push(HeapCellValue::Addr(Addr::HeapCell(list_loc)));
+ self.machine_st
+ .unify(Addr::HeapCell(heap_loc), self.machine_st[temp_v!(4)]);
}
None => {
self.machine_st.fail = true;
}
}
- pub(crate)
- fn dynamic_property(&mut self) {
+ pub(crate) fn dynamic_property(&mut self) {
let module_name = atom_from!(
self.machine_st,
- self.machine_st.store(self.machine_st.deref(
- self.machine_st[temp_v!(1)]
- ))
+ self.machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(1)]))
);
- let key =
- self.machine_st.read_predicate_key(
- self.machine_st[temp_v!(2)],
- self.machine_st[temp_v!(3)],
- );
+ let key = self
+ .machine_st
+ .read_predicate_key(self.machine_st[temp_v!(2)], self.machine_st[temp_v!(3)]);
- let compilation_target =
- match module_name.as_str() {
- "user" => CompilationTarget::User,
- _ => CompilationTarget::Module(module_name),
- };
+ let compilation_target = match module_name.as_str() {
+ "user" => CompilationTarget::User,
+ _ => CompilationTarget::Module(module_name),
+ };
- match self.indices.get_predicate_skeleton(
- &compilation_target,
- &key,
- ) {
+ match self
+ .indices
+ .get_predicate_skeleton(&compilation_target, &key)
+ {
Some(skeleton) => {
self.machine_st.fail = !skeleton.is_dynamic;
}
}
}
- pub(crate)
- fn multifile_property(&mut self) {
+ pub(crate) fn multifile_property(&mut self) {
let module_name = atom_from!(
self.machine_st,
- self.machine_st.store(self.machine_st.deref(
- self.machine_st[temp_v!(1)]
- ))
+ self.machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(1)]))
);
- let key =
- self.machine_st.read_predicate_key(
- self.machine_st[temp_v!(2)],
- self.machine_st[temp_v!(3)],
- );
+ let key = self
+ .machine_st
+ .read_predicate_key(self.machine_st[temp_v!(2)], self.machine_st[temp_v!(3)]);
- let compilation_target =
- match module_name.as_str() {
- "user" => CompilationTarget::User,
- _ => CompilationTarget::Module(module_name),
- };
+ let compilation_target = match module_name.as_str() {
+ "user" => CompilationTarget::User,
+ _ => CompilationTarget::Module(module_name),
+ };
- match self.indices.get_predicate_skeleton(
- &compilation_target,
- &key,
- ) {
+ match self
+ .indices
+ .get_predicate_skeleton(&compilation_target, &key)
+ {
Some(skeleton) => {
self.machine_st.fail = !skeleton.is_multifile;
}
}
}
- pub(crate)
- fn discontiguous_property(&mut self) {
+ pub(crate) fn discontiguous_property(&mut self) {
let module_name = atom_from!(
self.machine_st,
- self.machine_st.store(self.machine_st.deref(
- self.machine_st[temp_v!(1)]
- ))
+ self.machine_st
+ .store(self.machine_st.deref(self.machine_st[temp_v!(1)]))
);
- let key =
- self.machine_st.read_predicate_key(
- self.machine_st[temp_v!(2)],
- self.machine_st[temp_v!(3)],
- );
+ let key = self
+ .machine_st
+ .read_predicate_key(self.machine_st[temp_v!(2)], self.machine_st[temp_v!(3)]);
- let compilation_target =
- match module_name.as_str() {
- "user" => CompilationTarget::User,
- _ => CompilationTarget::Module(module_name),
- };
+ let compilation_target = match module_name.as_str() {
+ "user" => CompilationTarget::User,
+ _ => CompilationTarget::Module(module_name),
+ };
- match self.indices.get_predicate_skeleton(
- &compilation_target,
- &key,
- ) {
+ match self
+ .indices
+ .get_predicate_skeleton(&compilation_target, &key)
+ {
Some(skeleton) => {
self.machine_st.fail = !skeleton.is_discontiguous;
}
}
}
- pub(crate)
- fn builtin_property(&mut self) {
- let key =
- self.machine_st.read_predicate_key(
- self.machine_st[temp_v!(1)],
- self.machine_st[temp_v!(2)],
- );
+ pub(crate) fn builtin_property(&mut self) {
+ let key = self
+ .machine_st
+ .read_predicate_key(self.machine_st[temp_v!(1)], self.machine_st[temp_v!(2)]);
match ClauseType::from(key.0, key.1, None) {
ClauseType::BuiltIn(_) | ClauseType::Inlined(..) | ClauseType::CallN => {
}
ClauseType::Named(ref name, arity, _) => {
if let Some(module) = self.indices.modules.get(&(clause_name!("builtins"))) {
- self.machine_st.fail = !module.code_dir.contains_key(
- &(name.clone(), arity),
- );
+ self.machine_st.fail = !module.code_dir.contains_key(&(name.clone(), arity));
return;
}
}
ClauseType::Op(ref name, ref op_desc, _) => {
if let Some(module) = self.indices.modules.get(&(clause_name!("builtins"))) {
- self.machine_st.fail = !module.code_dir.contains_key(
- &(name.clone(), op_desc.arity()),
- );
+ self.machine_st.fail = !module
+ .code_dir
+ .contains_key(&(name.clone(), op_desc.arity()));
return;
}
}
- _ => {
- }
+ _ => {}
}
self.machine_st.fail = true;
}
impl<'a> Loader<'a, LiveTermStream> {
- pub(super)
- fn to_load_state_payload(mut self) -> LoadStatePayload {
+ pub(super) fn to_load_state_payload(mut self) -> LoadStatePayload {
LoadStatePayload {
- term_stream:
- mem::replace(
- &mut self.term_stream,
- LiveTermStream::new(ListingSource::User),
- ),
- preprocessor:
- mem::replace(
- &mut self.preprocessor,
- Preprocessor::new(self.load_state.wam.machine_st.flags),
- ),
- non_counted_bt_preds:
- mem::replace(
- &mut self.non_counted_bt_preds,
- IndexSet::new(),
- ),
- compilation_target:
- self.load_state.compilation_target.take(),
- retraction_info:
- mem::replace(
- &mut self.load_state.retraction_info,
- RetractionInfo::new(self.load_state.wam.code_repo.code.len()),
- ),
- predicates:
- mem::replace(
- &mut self.predicates,
- vec![],
- ),
- clause_clauses:
- mem::replace(
- &mut self.clause_clauses,
- vec![],
- ),
- module_op_exports:
- mem::replace(
- &mut self.load_state.module_op_exports,
- vec![],
- ),
+ term_stream: mem::replace(
+ &mut self.term_stream,
+ LiveTermStream::new(ListingSource::User),
+ ),
+ preprocessor: mem::replace(
+ &mut self.preprocessor,
+ Preprocessor::new(self.load_state.wam.machine_st.flags),
+ ),
+ non_counted_bt_preds: mem::replace(&mut self.non_counted_bt_preds, IndexSet::new()),
+ compilation_target: self.load_state.compilation_target.take(),
+ retraction_info: mem::replace(
+ &mut self.load_state.retraction_info,
+ RetractionInfo::new(self.load_state.wam.code_repo.code.len()),
+ ),
+ predicates: mem::replace(&mut self.predicates, vec![]),
+ clause_clauses: mem::replace(&mut self.clause_clauses, vec![]),
+ module_op_exports: mem::replace(&mut self.load_state.module_op_exports, vec![]),
}
}
- pub(super)
- fn from_load_state_payload(wam: &'a mut Machine, mut payload: LoadStatePayload) -> Self {
+ pub(super) fn from_load_state_payload(
+ wam: &'a mut Machine,
+ mut payload: LoadStatePayload,
+ ) -> Self {
Loader {
- term_stream:
- mem::replace(
- &mut payload.term_stream,
- LiveTermStream::new(ListingSource::User),
- ),
- preprocessor:
- mem::replace(
- &mut payload.preprocessor,
- Preprocessor::new(MachineFlags::default()),
- ),
- non_counted_bt_preds:
- mem::replace(
- &mut payload.non_counted_bt_preds,
- IndexSet::new(),
- ),
- clause_clauses:
- mem::replace(
- &mut payload.clause_clauses,
- vec![],
- ),
- predicates:
- mem::replace(
- &mut payload.predicates,
- vec![],
- ),
+ term_stream: mem::replace(
+ &mut payload.term_stream,
+ LiveTermStream::new(ListingSource::User),
+ ),
+ preprocessor: mem::replace(
+ &mut payload.preprocessor,
+ Preprocessor::new(MachineFlags::default()),
+ ),
+ non_counted_bt_preds: mem::replace(&mut payload.non_counted_bt_preds, IndexSet::new()),
+ clause_clauses: mem::replace(&mut payload.clause_clauses, vec![]),
+ predicates: mem::replace(&mut payload.predicates, vec![]),
load_state: LoadState {
compilation_target: payload.compilation_target.take(),
- module_op_exports:
- mem::replace(
- &mut payload.module_op_exports,
- vec![],
- ),
- retraction_info:
- mem::replace(
- &mut payload.retraction_info,
- RetractionInfo::new(0),
- ),
+ module_op_exports: mem::replace(&mut payload.module_op_exports, vec![]),
+ retraction_info: mem::replace(&mut payload.retraction_info, RetractionInfo::new(0)),
wam,
},
}
) -> Result<(), SessionError> {
let mut preprocessor = Preprocessor::new(self.load_state.wam.machine_st.flags);
- let tl = preprocessor.try_term_to_tl(
- &mut self.load_state,
- term,
- CutContext::BlocksCuts,
- )?;
+ let tl = preprocessor.try_term_to_tl(&mut self.load_state, term, CutContext::BlocksCuts)?;
let queue = preprocessor.parse_queue(&mut self.load_state)?;
- let clause =
- match tl {
- TopLevel::Fact(fact) => {
- PredicateClause::Fact(fact)
- }
- TopLevel::Rule(rule) => {
- PredicateClause::Rule(rule)
- }
- _ => {
- unreachable!()
- }
- };
+ let clause = match tl {
+ TopLevel::Fact(fact) => PredicateClause::Fact(fact),
+ TopLevel::Rule(rule) => PredicateClause::Rule(rule),
+ _ => {
+ unreachable!()
+ }
+ };
let compilation_target =
mem::replace(&mut self.load_state.compilation_target, compilation_target);
}
#[inline]
-pub(super)
-fn load_module(
+pub(super) fn load_module(
code_dir: &mut CodeDir,
op_dir: &mut OpDir,
meta_predicate_dir: &mut MetaPredicateDir,
use crate::prolog_parser_rebis::ast::*;
+use crate::prolog_parser_rebis::{clause_name, temp_v};
use crate::forms::{ModuleSource, Number}; //, PredicateKey};
use crate::machine::heap::*;
from: ErrorProvenance,
}
-pub(crate)
-trait TypeError {
+pub(crate) trait TypeError {
fn type_error(self, h: usize, valid_type: ValidType) -> MachineError;
}
impl TypeError for Addr {
fn type_error(self, _: usize, valid_type: ValidType) -> MachineError {
- let stub = functor!(
- "type_error",
- [atom(valid_type.as_str()), addr(self)]
- );
+ let stub = functor!("type_error", [atom(valid_type.as_str()), addr(self)]);
MachineError {
stub,
location: None,
- from: ErrorProvenance::Received
+ from: ErrorProvenance::Received,
}
}
}
impl TypeError for HeapCellValue {
fn type_error(self, _: usize, valid_type: ValidType) -> MachineError {
- let stub = functor!(
- "type_error",
- [atom(valid_type.as_str()), value(self)]
- );
+ let stub = functor!("type_error", [atom(valid_type.as_str()), value(self)]);
MachineError {
stub,
location: None,
- from: ErrorProvenance::Received
+ from: ErrorProvenance::Received,
}
}
}
impl TypeError for MachineStub {
fn type_error(self, h: usize, valid_type: ValidType) -> MachineError {
- let stub = functor!(
- "type_error",
- [atom(valid_type.as_str()), aux(h, 0)],
- [self]
- );
+ let stub = functor!("type_error", [atom(valid_type.as_str()), aux(h, 0)], [self]);
MachineError {
stub,
location: None,
- from: ErrorProvenance::Constructed
+ from: ErrorProvenance::Constructed,
}
}
}
impl TypeError for Number {
fn type_error(self, _h: usize, valid_type: ValidType) -> MachineError {
- let stub = functor!(
- "type_error",
- [atom(valid_type.as_str()), number(self)]
- );
+ let stub = functor!("type_error", [atom(valid_type.as_str()), number(self)]);
MachineError {
stub,
location: None,
- from: ErrorProvenance::Received
+ from: ErrorProvenance::Received,
}
}
}
-pub(crate)
-trait PermissionError {
+pub(crate) trait PermissionError {
fn permission_error(self, h: usize, index_str: &'static str, perm: Permission) -> MachineError;
}
MachineError {
stub,
location: None,
- from: ErrorProvenance::Received
+ from: ErrorProvenance::Received,
}
}
}
MachineError {
stub,
location: None,
- from: ErrorProvenance::Constructed
+ from: ErrorProvenance::Constructed,
}
}
}
-pub(super)
-trait DomainError {
+pub(super) trait DomainError {
fn domain_error(self, error: DomainErrorType) -> MachineError;
}
impl DomainError for Addr {
fn domain_error(self, error: DomainErrorType) -> MachineError {
- let stub = functor!(
- "domain_error",
- [atom(error.as_str()), addr(self)]
- );
+ let stub = functor!("domain_error", [atom(error.as_str()), addr(self)]);
MachineError {
stub,
impl DomainError for Number {
fn domain_error(self, error: DomainErrorType) -> MachineError {
- let stub = functor!(
- "domain_error",
- [atom(error.as_str()), number(self)]
- );
+ let stub = functor!("domain_error", [atom(error.as_str()), number(self)]);
MachineError {
stub,
}
impl MachineError {
- pub(super)
- fn functor_stub(name: ClauseName, arity: usize) -> MachineStub {
+ pub(super) fn functor_stub(name: ClauseName, arity: usize) -> MachineStub {
functor!(
"/",
SharedOpDesc::new(400, YFX),
}
#[inline]
- pub(super)
- fn interrupt_error() -> Self {
+ pub(super) fn interrupt_error() -> Self {
let stub = functor!("$interrupt_thrown");
MachineError {
}
}
- pub(super)
- fn evaluation_error(eval_error: EvalError) -> Self {
+ pub(super) fn evaluation_error(eval_error: EvalError) -> Self {
let stub = functor!("evaluation_error", [atom(eval_error.as_str())]);
MachineError {
}
}
- pub(super)
- fn type_error<T: TypeError>(h: usize, valid_type: ValidType, culprit: T) -> Self {
+ pub(super) fn type_error<T: TypeError>(h: usize, valid_type: ValidType, culprit: T) -> Self {
culprit.type_error(h, valid_type)
}
- pub(super)
- fn module_resolution_error(
+ pub(super) fn module_resolution_error(
h: usize,
mod_name: ClauseName,
name: ClauseName,
[res_stub]
);
- let stub = functor!(
- "evaluation_error",
- [aux(h, 0)],
- [ind_stub]
- );
+ let stub = functor!("evaluation_error", [aux(h, 0)], [ind_stub]);
MachineError {
stub,
}
}
- pub(super)
- fn existence_error(h: usize, err: ExistenceError) -> Self {
+ pub(super) fn existence_error(h: usize, err: ExistenceError) -> Self {
match err {
ExistenceError::Module(name) => {
- let stub = functor!(
- "existence_error",
- [atom("source_sink"), clause_name(name)]
- );
+ let stub = functor!("existence_error", [atom("source_sink"), clause_name(name)]);
MachineError {
stub,
[clause_name(name), integer(arity)]
);
- let stub = functor!(
- "existence_error",
- [atom("procedure"), aux(h, 0)],
- [culprit]
- );
+ let stub = functor!("existence_error", [atom("procedure"), aux(h, 0)], [culprit]);
MachineError {
stub,
}
}
ExistenceError::SourceSink(culprit) => {
- let stub = functor!(
- "existence_error",
- [atom("source_sink"), addr(culprit)]
- );
+ let stub = functor!("existence_error", [atom("source_sink"), addr(culprit)]);
MachineError {
stub,
}
}
ExistenceError::Stream(culprit) => {
- let stub = functor!(
- "existence_error",
- [atom("stream"), addr(culprit)]
- );
+ let stub = functor!("existence_error", [atom("stream"), addr(culprit)]);
MachineError {
stub,
}
}
- pub(super)
- fn permission_error<T: PermissionError>(
+ pub(super) fn permission_error<T: PermissionError>(
h: usize,
err: Permission,
index_str: &'static str,
culprit: T,
) -> Self {
- culprit.permission_error(
- h,
- index_str,
- err,
- )
+ culprit.permission_error(h, index_str, err)
}
fn arithmetic_error(h: usize, err: ArithmeticError) -> Self {
match err {
- ArithmeticError::UninstantiatedVar => {
- Self::instantiation_error()
- }
+ ArithmeticError::UninstantiatedVar => Self::instantiation_error(),
ArithmeticError::NonEvaluableFunctor(name, arity) => {
let culprit = functor!(
"/",
}
#[inline]
- pub(super)
- fn domain_error<T: DomainError>(error: DomainErrorType, culprit: T) -> Self {
+ pub(super) fn domain_error<T: DomainError>(error: DomainErrorType, culprit: T) -> Self {
culprit.domain_error(error)
}
- pub(super)
- fn instantiation_error() -> Self {
+ pub(super) fn instantiation_error() -> Self {
let stub = functor!("instantiation_error");
MachineError {
}
}
- pub(super)
- fn session_error(h: usize, err: SessionError) -> Self {
+ pub(super) fn session_error(h: usize, err: SessionError) -> Self {
match err {
// SessionError::CannotOverwriteBuiltIn(pred_str) |
/*
)
}
*/
- SessionError::ExistenceError(err) => {
- Self::existence_error(h, err)
- }
+ SessionError::ExistenceError(err) => Self::existence_error(h, err),
// SessionError::InvalidFileName(filename) => {
// Self::existence_error(h, ExistenceError::Module(filename))
// }
)
}
*/
- SessionError::ModuleCannotImportSelf(module_name) => {
- Self::permission_error(
- h,
- Permission::Modify,
- "module",
- functor!("module_cannot_import_self", [clause_name(module_name)]),
- )
- }
- SessionError::NamelessEntry => {
- Self::permission_error(
- h,
- Permission::Create,
- "static_procedure",
- functor!("nameless_procedure")
- )
- }
+ SessionError::ModuleCannotImportSelf(module_name) => Self::permission_error(
+ h,
+ Permission::Modify,
+ "module",
+ functor!("module_cannot_import_self", [clause_name(module_name)]),
+ ),
+ SessionError::NamelessEntry => Self::permission_error(
+ h,
+ Permission::Create,
+ "static_procedure",
+ functor!("nameless_procedure"),
+ ),
SessionError::OpIsInfixAndPostFix(op) => {
- Self::permission_error(
- h,
- Permission::Create,
- "operator",
- functor!(clause_name(op)),
- )
- }
- SessionError::CompilationError(err) => {
- Self::syntax_error(h, err)
- }
- SessionError::QueryCannotBeDefinedAsFact => {
- Self::permission_error(
- h,
- Permission::Create,
- "static_procedure",
- functor!("query_cannot_be_defined_as_fact")
- )
+ Self::permission_error(h, Permission::Create, "operator", functor!(clause_name(op)))
}
+ SessionError::CompilationError(err) => Self::syntax_error(h, err),
+ SessionError::QueryCannotBeDefinedAsFact => Self::permission_error(
+ h,
+ Permission::Create,
+ "static_procedure",
+ functor!("query_cannot_be_defined_as_fact"),
+ ),
}
}
- pub(super)
- fn syntax_error<E: Into<CompilationError>>(h: usize, err: E) -> Self {
+ pub(super) fn syntax_error<E: Into<CompilationError>>(h: usize, err: E) -> Self {
let err = err.into();
if let CompilationError::Arithmetic(err) = err {
let location = err.line_and_col_num();
let stub = err.as_functor(h);
- let stub = functor!(
- "syntax_error",
- [aux(h, 0)],
- [stub]
- );
+ let stub = functor!("syntax_error", [aux(h, 0)], [stub]);
MachineError {
stub,
}
}
- pub(super)
- fn representation_error(flag: RepFlag) -> Self {
+ pub(super) fn representation_error(flag: RepFlag) -> Self {
let stub = functor!("representation_error", [atom(flag.as_str())]);
MachineError {
impl CompilationError {
pub fn line_and_col_num(&self) -> Option<(usize, usize)> {
match self {
- &CompilationError::ParserError(ref err) =>
- err.line_and_col_num(),
- _ =>
- None
+ &CompilationError::ParserError(ref err) => err.line_and_col_num(),
+ _ => None,
}
}
pub fn as_functor(&self, _h: usize) -> MachineStub {
match self {
- &CompilationError::Arithmetic(..) =>
- functor!("arithmetic_error"),
+ &CompilationError::Arithmetic(..) => functor!("arithmetic_error"),
// &CompilationError::BadPendingByte =>
// functor!("bad_pending_byte"),
- &CompilationError::CannotParseCyclicTerm =>
- functor!("cannot_parse_cyclic_term"),
+ &CompilationError::CannotParseCyclicTerm => functor!("cannot_parse_cyclic_term"),
// &CompilationError::ExpandedTermsListNotAList =>
// functor!("expanded_terms_list_is_not_a_list"),
- &CompilationError::ExpectedRel =>
- functor!("expected_relation"),
+ &CompilationError::ExpectedRel => functor!("expected_relation"),
// &CompilationError::ExpectedTopLevelTerm =>
// functor!("expected_atom_or_cons_or_clause"),
- &CompilationError::InadmissibleFact =>
- functor!("inadmissible_fact"),
- &CompilationError::InadmissibleQueryTerm =>
- functor!("inadmissible_query_term"),
- &CompilationError::InconsistentEntry =>
- functor!("inconsistent_entry"),
+ &CompilationError::InadmissibleFact => functor!("inadmissible_fact"),
+ &CompilationError::InadmissibleQueryTerm => functor!("inadmissible_query_term"),
+ &CompilationError::InconsistentEntry => functor!("inconsistent_entry"),
// &CompilationError::InvalidDoubleQuotesDecl =>
// functor!("invalid_double_quotes_declaration"),
// &CompilationError::InvalidHook =>
// functor!("invalid_hook"),
- &CompilationError::InvalidMetaPredicateDecl =>
- functor!("invalid_meta_predicate_decl"),
- &CompilationError::InvalidModuleDecl =>
- functor!("invalid_module_declaration"),
- &CompilationError::InvalidModuleExport =>
- functor!("invalid_module_export"),
- &CompilationError::InvalidModuleResolution(ref module_name) =>
- functor!(
- "no_such_module",
- [clause_name(module_name.clone())]
- ),
- &CompilationError::InvalidRuleHead =>
- functor!("invalid_head_of_rule"),
- &CompilationError::InvalidUseModuleDecl =>
- functor!("invalid_use_module_declaration"),
- &CompilationError::ParserError(ref err) =>
- functor!(err.as_str()),
- &CompilationError::UnreadableTerm =>
- functor!("unreadable_term"),
+ &CompilationError::InvalidMetaPredicateDecl => functor!("invalid_meta_predicate_decl"),
+ &CompilationError::InvalidModuleDecl => functor!("invalid_module_declaration"),
+ &CompilationError::InvalidModuleExport => functor!("invalid_module_export"),
+ &CompilationError::InvalidModuleResolution(ref module_name) => {
+ functor!("no_such_module", [clause_name(module_name.clone())])
+ }
+ &CompilationError::InvalidRuleHead => functor!("invalid_head_of_rule"),
+ &CompilationError::InvalidUseModuleDecl => functor!("invalid_use_module_declaration"),
+ &CompilationError::ParserError(ref err) => functor!(err.as_str()),
+ &CompilationError::UnreadableTerm => functor!("unreadable_term"),
}
}
}
pub(super) enum CycleSearchResult {
EmptyList,
NotList,
- PartialList(usize, Ref), // the list length (up to max), and an offset into the heap.
- ProperList(usize), // the list length.
+ PartialList(usize, Ref), // the list length (up to max), and an offset into the heap.
+ ProperList(usize), // the list length.
PStrLocation(usize, usize, usize), // the list length (up to max), the heap offset, byte offset into the string.
UntouchedList(usize), // the address of an uniterated Addr::Lis(address).
}
impl MachineState {
// see 8.4.3 of Draft Technical Corrigendum 2.
- pub(super)
- fn check_sort_errors(&self) -> CallResult {
+ pub(super) fn check_sort_errors(&self) -> CallResult {
let stub = MachineError::functor_stub(clause_name!("sort"), 2);
let list = self.store(self.deref(self[temp_v!(1)].clone()));
let sorted = self.store(self.deref(self[temp_v!(2)].clone()));
return Err(self.error_form(MachineError::instantiation_error(), stub))
}
CycleSearchResult::NotList => {
- return Err(self.error_form(MachineError::type_error(0, ValidType::List, list), stub))
+ return Err(
+ self.error_form(MachineError::type_error(0, ValidType::List, list), stub)
+ )
}
_ => {}
};
new_l = l;
}
HeapCellValue::NamedStr(2, ref name, Some(_))
- if name.as_str() == "-" => {
+ if name.as_str() == "-" =>
+ {
break;
}
HeapCellValue::Addr(Addr::HeapCell(_)) => {
}
// see 8.4.4 of Draft Technical Corrigendum 2.
- pub(super)
- fn check_keysort_errors(&self) -> CallResult {
+ pub(super) fn check_keysort_errors(&self) -> CallResult {
let stub = MachineError::functor_stub(clause_name!("keysort"), 2);
- let pairs = self.store(self.deref(self[temp_v!(1)].clone()));
+ let pairs = self.store(self.deref(self[temp_v!(1)].clone()));
let sorted = self.store(self.deref(self[temp_v!(2)].clone()));
match self.detect_cycles(pairs.clone()) {
}
#[inline]
- pub(crate)
- fn type_error<T: TypeError>(
+ pub(crate) fn type_error<T: TypeError>(
&self,
valid_type: ValidType,
culprit: T,
arity: usize,
) -> MachineStub {
let stub = MachineError::functor_stub(caller, arity);
- let err = MachineError::type_error(
- self.heap.h(),
- valid_type,
- culprit,
- );
+ let err = MachineError::type_error(self.heap.h(), valid_type, culprit);
return self.error_form(err, stub);
}
#[inline]
- pub(crate)
- fn representation_error(
+ pub(crate) fn representation_error(
&self,
rep_flag: RepFlag,
caller: ClauseName,
arity: usize,
) -> MachineStub {
let stub = MachineError::functor_stub(caller, arity);
- let err = MachineError::representation_error(
- rep_flag,
- );
+ let err = MachineError::representation_error(rep_flag);
return self.error_form(err, stub);
}
- pub(super)
- fn error_form(&self, err: MachineError, src: MachineStub) -> MachineStub {
+ pub(super) fn error_form(&self, err: MachineError, src: MachineStub) -> MachineStub {
let location = err.location;
let err_len = err.len();
stub
}
- pub(super)
- fn throw_exception(&mut self, err: MachineStub) {
+ pub(super) fn throw_exception(&mut self, err: MachineStub) {
let h = self.heap.h();
self.ball.boundary = 0;
use crate::prolog_parser_rebis::ast::*;
+use crate::prolog_parser_rebis::clause_name;
use crate::clause_types::*;
use crate::fixtures::*;
use crate::forms::*;
-use crate::machine::CompilationTarget;
+use crate::instructions::*;
use crate::machine::code_repo::CodeRepo;
-use crate::machine::Ball;
use crate::machine::heap::*;
use crate::machine::machine_state::*;
use crate::machine::partial_string::*;
use crate::machine::raw_block::RawBlockTraits;
use crate::machine::streams::Stream;
use crate::machine::term_stream::LoadStatePayload;
-use crate::instructions::*;
+use crate::machine::Ball;
+use crate::machine::CompilationTarget;
use crate::ordered_float::OrderedFloat;
use crate::rug::{Integer, Rational};
fn cmp(&self, other: &Ref) -> Ordering {
match (self, other) {
(Ref::AttrVar(h1), Ref::AttrVar(h2))
- | (Ref::HeapCell(h1), Ref::HeapCell(h2))
- | (Ref::HeapCell(h1), Ref::AttrVar(h2))
- | (Ref::AttrVar(h1), Ref::HeapCell(h2)) => {
- h1.cmp(&h2)
- }
+ | (Ref::HeapCell(h1), Ref::HeapCell(h2))
+ | (Ref::HeapCell(h1), Ref::AttrVar(h2))
+ | (Ref::AttrVar(h1), Ref::HeapCell(h2)) => h1.cmp(&h2),
(Ref::StackCell(fr1, sc1), Ref::StackCell(fr2, sc2)) => {
fr1.cmp(&fr2).then_with(|| sc1.cmp(&sc2))
}
- (Ref::StackCell(..), _) => {
- Ordering::Greater
- }
- (_, Ref::StackCell(..)) => {
- Ordering::Less
- }
+ (Ref::StackCell(..), _) => Ordering::Greater,
+ (_, Ref::StackCell(..)) => Ordering::Less,
}
}
}
impl PartialOrd<Ref> for Addr {
fn partial_cmp(&self, r: &Ref) -> Option<Ordering> {
match self {
- &Addr::StackCell(fr, sc) => {
- match *r {
- Ref::AttrVar(_) | Ref::HeapCell(_) => {
+ &Addr::StackCell(fr, sc) => match *r {
+ Ref::AttrVar(_) | Ref::HeapCell(_) => Some(Ordering::Greater),
+ Ref::StackCell(fr1, sc1) => {
+ if fr1 < fr || (fr1 == fr && sc1 < sc) {
Some(Ordering::Greater)
- }
- Ref::StackCell(fr1, sc1) => {
- if fr1 < fr || (fr1 == fr && sc1 < sc) {
- Some(Ordering::Greater)
- } else if fr1 == fr && sc1 == sc {
- Some(Ordering::Equal)
- } else {
- Some(Ordering::Less)
- }
- }
- }
- }
- &Addr::HeapCell(h) | &Addr::AttrVar(h) => {
- match r {
- Ref::StackCell(..) => {
+ } else if fr1 == fr && sc1 == sc {
+ Some(Ordering::Equal)
+ } else {
Some(Ordering::Less)
}
- Ref::AttrVar(h1) | Ref::HeapCell(h1) => {
- h.partial_cmp(h1)
- }
}
- }
- _ => {
- None
- }
+ },
+ &Addr::HeapCell(h) | &Addr::AttrVar(h) => match r {
+ Ref::StackCell(..) => Some(Ordering::Less),
+ Ref::AttrVar(h1) | Ref::HeapCell(h1) => h.partial_cmp(h1),
+ },
+ _ => None,
}
}
}
#[inline]
pub fn is_heap_bound(&self) -> bool {
match self {
- Addr::Char(_) | Addr::EmptyList |
- Addr::CutPoint(_) | Addr::Usize(_) | Addr::Fixnum(_) |
- Addr::Float(_) => {
- false
- }
- _ => {
- true
- }
+ Addr::Char(_)
+ | Addr::EmptyList
+ | Addr::CutPoint(_)
+ | Addr::Usize(_)
+ | Addr::Fixnum(_)
+ | Addr::Float(_) => false,
+ _ => true,
}
}
#[inline]
pub fn is_ref(&self) -> bool {
match self {
- Addr::HeapCell(_) | Addr::StackCell(_, _) | Addr::AttrVar(_) => {
- true
- }
- _ => {
- false
- }
+ Addr::HeapCell(_) | Addr::StackCell(_, _) | Addr::AttrVar(_) => true,
+ _ => false,
}
}
}
}
- pub(super)
- fn order_category(&self, heap: &Heap) -> Option<TermOrderCategory> {
+ pub(super) fn order_category(&self, heap: &Heap) -> Option<TermOrderCategory> {
match Number::try_from((*self, heap)) {
Ok(Number::Integer(_)) | Ok(Number::Fixnum(_)) | Ok(Number::Rational(_)) => {
Some(TermOrderCategory::Integer)
}
- Ok(Number::Float(_)) => {
- Some(TermOrderCategory::FloatingPoint)
- }
- _ => {
- match self {
- Addr::HeapCell(_) | Addr::AttrVar(_) | Addr::StackCell(..) => {
- Some(TermOrderCategory::Variable)
- }
- Addr::Float(_) => {
- Some(TermOrderCategory::FloatingPoint)
- }
- &Addr::Con(h) => {
- match &heap[h] {
- HeapCellValue::Atom(..) => {
- Some(TermOrderCategory::Atom)
- }
- HeapCellValue::DBRef(_) => {
- None
- }
- _ => {
- unreachable!()
- }
- }
- }
- Addr::Char(_) | Addr::EmptyList => {
- Some(TermOrderCategory::Atom)
- }
- Addr::Fixnum(_) | Addr::Usize(_) => {
- Some(TermOrderCategory::Integer)
- }
- Addr::Lis(_) | Addr::PStrLocation(..) | Addr::Str(_) => {
- Some(TermOrderCategory::Compound)
- }
- Addr::CutPoint(_) | Addr::LoadStatePayload(_) | Addr::Stream(_) | Addr::TcpListener(_) => {
- None
+ Ok(Number::Float(_)) => Some(TermOrderCategory::FloatingPoint),
+ _ => match self {
+ Addr::HeapCell(_) | Addr::AttrVar(_) | Addr::StackCell(..) => {
+ Some(TermOrderCategory::Variable)
+ }
+ Addr::Float(_) => Some(TermOrderCategory::FloatingPoint),
+ &Addr::Con(h) => match &heap[h] {
+ HeapCellValue::Atom(..) => Some(TermOrderCategory::Atom),
+ HeapCellValue::DBRef(_) => None,
+ _ => {
+ unreachable!()
}
+ },
+ Addr::Char(_) | Addr::EmptyList => Some(TermOrderCategory::Atom),
+ Addr::Fixnum(_) | Addr::Usize(_) => Some(TermOrderCategory::Integer),
+ Addr::Lis(_) | Addr::PStrLocation(..) | Addr::Str(_) => {
+ Some(TermOrderCategory::Compound)
}
- }
+ Addr::CutPoint(_)
+ | Addr::LoadStatePayload(_)
+ | Addr::Stream(_)
+ | Addr::TcpListener(_) => None,
+ },
}
}
pub fn as_constant_index(&self, machine_st: &MachineState) -> Option<Constant> {
match self {
- &Addr::Char(c) => {
- Some(Constant::Char(c))
- }
- &Addr::Con(h) => {
- match &machine_st.heap[h] {
- &HeapCellValue::Atom(ref name, _) if name.is_char() => {
- Some(Constant::Char(name.as_str().chars().next().unwrap()))
- }
- &HeapCellValue::Atom(ref name, _) => {
- Some(Constant::Atom(name.clone(), None))
- }
- &HeapCellValue::Integer(ref n) => {
- Some(Constant::Integer(n.clone()))
- }
- &HeapCellValue::Rational(ref n) => {
- Some(Constant::Rational(n.clone()))
- }
- _ => {
- None
- }
+ &Addr::Char(c) => Some(Constant::Char(c)),
+ &Addr::Con(h) => match &machine_st.heap[h] {
+ &HeapCellValue::Atom(ref name, _) if name.is_char() => {
+ Some(Constant::Char(name.as_str().chars().next().unwrap()))
}
- }
- &Addr::EmptyList => {
- Some(Constant::EmptyList)
- }
- &Addr::Fixnum(n) => {
- Some(Constant::Fixnum(n))
- }
- &Addr::Float(f) => {
- Some(Constant::Float(f))
- }
- &Addr::Usize(n) => {
- Some(Constant::Usize(n))
- }
- _ => {
- None
- }
+ &HeapCellValue::Atom(ref name, _) => Some(Constant::Atom(name.clone(), None)),
+ &HeapCellValue::Integer(ref n) => Some(Constant::Integer(n.clone())),
+ &HeapCellValue::Rational(ref n) => Some(Constant::Rational(n.clone())),
+ _ => None,
+ },
+ &Addr::EmptyList => Some(Constant::EmptyList),
+ &Addr::Fixnum(n) => Some(Constant::Fixnum(n)),
+ &Addr::Float(f) => Some(Constant::Float(f)),
+ &Addr::Usize(n) => Some(Constant::Usize(n)),
+ _ => None,
}
}
#[inline]
pub fn as_addr(&self, focus: usize) -> Addr {
match self {
- HeapCellValue::Addr(ref a) => {
- *a
- }
- HeapCellValue::Atom(..) | HeapCellValue::DBRef(..) | HeapCellValue::Integer(..) |
- HeapCellValue::Rational(..) => {
- Addr::Con(focus)
- }
- HeapCellValue::LoadStatePayload(_) => {
- Addr::LoadStatePayload(focus)
- }
- HeapCellValue::NamedStr(_, _, _) => {
- Addr::Str(focus)
- }
- HeapCellValue::PartialString(..) => {
- Addr::PStrLocation(focus, 0)
- }
- HeapCellValue::Stream(_) => {
- Addr::Stream(focus)
- }
- HeapCellValue::TcpListener(_) => {
- Addr::TcpListener(focus)
- }
+ HeapCellValue::Addr(ref a) => *a,
+ HeapCellValue::Atom(..)
+ | HeapCellValue::DBRef(..)
+ | HeapCellValue::Integer(..)
+ | HeapCellValue::Rational(..) => Addr::Con(focus),
+ HeapCellValue::LoadStatePayload(_) => Addr::LoadStatePayload(focus),
+ HeapCellValue::NamedStr(_, _, _) => Addr::Str(focus),
+ HeapCellValue::PartialString(..) => Addr::PStrLocation(focus, 0),
+ HeapCellValue::Stream(_) => Addr::Stream(focus),
+ HeapCellValue::TcpListener(_) => Addr::TcpListener(focus),
}
}
#[inline]
pub fn context_free_clone(&self) -> HeapCellValue {
match self {
- &HeapCellValue::Addr(addr) => {
- HeapCellValue::Addr(addr)
- }
- &HeapCellValue::Atom(ref name, ref op) => {
- HeapCellValue::Atom(name.clone(), op.clone())
- }
- &HeapCellValue::DBRef(ref db_ref) => {
- HeapCellValue::DBRef(db_ref.clone())
- }
- &HeapCellValue::Integer(ref n) => {
- HeapCellValue::Integer(n.clone())
- }
+ &HeapCellValue::Addr(addr) => HeapCellValue::Addr(addr),
+ &HeapCellValue::Atom(ref name, ref op) => HeapCellValue::Atom(name.clone(), op.clone()),
+ &HeapCellValue::DBRef(ref db_ref) => HeapCellValue::DBRef(db_ref.clone()),
+ &HeapCellValue::Integer(ref n) => HeapCellValue::Integer(n.clone()),
&HeapCellValue::LoadStatePayload(_) => {
HeapCellValue::Atom(clause_name!("$live_term_stream"), None)
}
&HeapCellValue::NamedStr(arity, ref name, ref op) => {
HeapCellValue::NamedStr(arity, name.clone(), op.clone())
}
- &HeapCellValue::Rational(ref r) => {
- HeapCellValue::Rational(r.clone())
- }
+ &HeapCellValue::Rational(ref r) => HeapCellValue::Rational(r.clone()),
&HeapCellValue::PartialString(ref pstr, has_tail) => {
HeapCellValue::PartialString(pstr.clone(), has_tail)
}
- &HeapCellValue::Stream(ref stream) => {
- HeapCellValue::Stream(stream.clone())
- }
+ &HeapCellValue::Stream(ref stream) => HeapCellValue::Stream(stream.clone()),
&HeapCellValue::TcpListener(_) => {
HeapCellValue::Atom(clause_name!("$tcp_listener"), None)
}
impl CodeIndex {
#[inline]
- pub(super)
- fn new(ptr: IndexPtr) -> Self {
+ pub(super) fn new(ptr: IndexPtr) -> Self {
CodeIndex(Rc::new(Cell::new(ptr)))
}
pub fn is_undefined(&self) -> bool {
match self.0.get() {
IndexPtr::Undefined => true, // | &IndexPtr::DynamicUndefined => true,
- _ => false
+ _ => false,
}
}
CallN(usize, LocalCodePtr, bool), // arity, local, last call.
Local(LocalCodePtr),
// DynamicTransaction(DynamicTransactionType, LocalCodePtr), // the type of transaction, the return pointer.
- REPL(REPLCodePtr, LocalCodePtr), // the REPL code, the return pointer.
+ REPL(REPLCodePtr, LocalCodePtr), // the REPL code, the return pointer.
VerifyAttrInterrupt(usize), // location of the verify attribute interrupt code in the CodeDir.
}
pub fn local(&self) -> LocalCodePtr {
match self {
&CodePtr::BuiltInClause(_, ref local)
- | &CodePtr::CallN(_, ref local, _)
- | &CodePtr::Local(ref local) => local.clone(),
+ | &CodePtr::CallN(_, ref local, _)
+ | &CodePtr::Local(ref local) => local.clone(),
&CodePtr::VerifyAttrInterrupt(p) => LocalCodePtr::DirEntry(p),
- &CodePtr::REPL(_, p) => p // | &CodePtr::DynamicTransaction(_, p) => p,
+ &CodePtr::REPL(_, p) => p, // | &CodePtr::DynamicTransaction(_, p) => p,
}
}
DirEntry(usize), // offset
Halt,
IndexingBuf(usize, usize, usize), // DirEntry offset, first internal offset, second internal offset
- // TopLevel(usize, usize), // chunk_num, offset
+ // TopLevel(usize, usize), // chunk_num, offset
}
impl LocalCodePtr {
- pub(crate)
- fn assign_if_local(&mut self, cp: CodePtr) {
+ pub(crate) fn assign_if_local(&mut self, cp: CodePtr) {
match cp {
CodePtr::Local(local) => *self = local,
_ => {}
}
#[inline]
- pub(crate)
- fn abs_loc(&self) -> usize {
+ pub(crate) fn abs_loc(&self) -> usize {
match self {
LocalCodePtr::DirEntry(ref p) => *p,
LocalCodePtr::IndexingBuf(ref p, ..) => *p,
}
}
- pub(crate)
- fn is_reset_cont_marker(&self, code_repo: &CodeRepo, last_call: bool) -> bool {
+ pub(crate) fn is_reset_cont_marker(&self, code_repo: &CodeRepo, last_call: bool) -> bool {
match code_repo.lookup_instr(last_call, &CodePtr::Local(*self)) {
- Some(line) => {
- match line.as_ref() {
- Line::Control(ControlInstruction::CallClause(ref ct, ..)) => {
- if let ClauseType::System(SystemClauseType::ResetContinuationMarker) = *ct {
- return true;
- }
+ Some(line) => match line.as_ref() {
+ Line::Control(ControlInstruction::CallClause(ref ct, ..)) => {
+ if let ClauseType::System(SystemClauseType::ResetContinuationMarker) = *ct {
+ return true;
}
- _ => {}
}
- }
+ _ => {}
+ },
None => {}
}
false
}
- pub(crate)
- fn as_functor<T: RawBlockTraits>(&self, heap: &mut HeapTemplate<T>) -> Addr {
+ pub(crate) fn as_functor<T: RawBlockTraits>(&self, heap: &mut HeapTemplate<T>) -> Addr {
let addr = Addr::HeapCell(heap.h());
match self {
LocalCodePtr::DirEntry(p) => {
- heap.append(functor!(
- "dir_entry",
- [integer(*p)]
- ));
+ heap.append(functor!("dir_entry", [integer(*p)]));
}
LocalCodePtr::Halt => {
heap.append(functor!("halt"));
impl PartialOrd<LocalCodePtr> for LocalCodePtr {
fn partial_cmp(&self, other: &LocalCodePtr) -> Option<Ordering> {
match (self, other) {
- (&LocalCodePtr::DirEntry(p1), &LocalCodePtr::DirEntry(ref p2)) |
+ (&LocalCodePtr::DirEntry(p1), &LocalCodePtr::DirEntry(ref p2)) |
(&LocalCodePtr::TopLevel(_, p1), &LocalCodePtr::TopLevel(_, ref p2)) => {
p1.partial_cmp(p2)
}
#[inline]
fn add(self, rhs: usize) -> Self::Output {
match self {
- LocalCodePtr::DirEntry(p) =>
- LocalCodePtr::DirEntry(p + rhs),
- LocalCodePtr::Halt =>
- unreachable!(),
- LocalCodePtr::IndexingBuf(p, o, i) =>
- LocalCodePtr::IndexingBuf(p, o, i + rhs),
+ LocalCodePtr::DirEntry(p) => LocalCodePtr::DirEntry(p + rhs),
+ LocalCodePtr::Halt => unreachable!(),
+ LocalCodePtr::IndexingBuf(p, o, i) => LocalCodePtr::IndexingBuf(p, o, i + rhs),
}
}
}
#[inline]
fn sub(self, rhs: usize) -> Self::Output {
match self {
- LocalCodePtr::DirEntry(p) =>
- p.checked_sub(rhs).map(LocalCodePtr::DirEntry),
- LocalCodePtr::Halt =>
- unreachable!(),
- LocalCodePtr::IndexingBuf(p, o, i) =>
- i.checked_sub(rhs).map(|r| LocalCodePtr::IndexingBuf(p, o, r)),
+ LocalCodePtr::DirEntry(p) => p.checked_sub(rhs).map(LocalCodePtr::DirEntry),
+ LocalCodePtr::Halt => unreachable!(),
+ LocalCodePtr::IndexingBuf(p, o, i) => i
+ .checked_sub(rhs)
+ .map(|r| LocalCodePtr::IndexingBuf(p, o, r)),
}
}
}
#[inline]
fn sub_assign(&mut self, rhs: usize) {
match self {
- LocalCodePtr::DirEntry(ref mut p) =>
- *p -= rhs,
- LocalCodePtr::Halt | LocalCodePtr::IndexingBuf(..) =>
- unreachable!(),
+ LocalCodePtr::DirEntry(ref mut p) => *p -= rhs,
+ LocalCodePtr::Halt | LocalCodePtr::IndexingBuf(..) => unreachable!(),
}
}
}
-
impl AddAssign<usize> for LocalCodePtr {
#[inline]
fn add_assign(&mut self, rhs: usize) {
fn add(self, rhs: usize) -> Self::Output {
match self {
- p @ CodePtr::REPL(..) |
- p @ CodePtr::VerifyAttrInterrupt(_) => { // |
- // p @ CodePtr::DynamicTransaction(..) => {
+ p @ CodePtr::REPL(..) | p @ CodePtr::VerifyAttrInterrupt(_) => {
+ // |
+ // p @ CodePtr::DynamicTransaction(..) => {
p
}
- CodePtr::Local(local) => {
- CodePtr::Local(local + rhs)
- }
+ CodePtr::Local(local) => CodePtr::Local(local + rhs),
CodePtr::BuiltInClause(_, local) | CodePtr::CallN(_, local, _) => {
CodePtr::Local(local + rhs)
}
}
}
-
pub type HeapVarDict = IndexMap<Rc<Var>, Addr>;
pub type AllocVarDict = IndexMap<Rc<Var>, VarData>;
key: &PredicateKey,
) -> Option<&mut PredicateSkeleton> {
match (key.0.as_str(), key.1) {
- ("term_expansion", 2) => {
- self.extensible_predicates.get_mut(key)
- }
- _ => {
- match compilation_target {
- CompilationTarget::User => {
- self.extensible_predicates.get_mut(key)
- }
- CompilationTarget::Module(ref module_name) => {
- if let Some(module) = self.modules.get_mut(module_name) {
- module.extensible_predicates.get_mut(key)
- } else {
- None
- }
+ ("term_expansion", 2) => self.extensible_predicates.get_mut(key),
+ _ => match compilation_target {
+ CompilationTarget::User => self.extensible_predicates.get_mut(key),
+ CompilationTarget::Module(ref module_name) => {
+ if let Some(module) = self.modules.get_mut(module_name) {
+ module.extensible_predicates.get_mut(key)
+ } else {
+ None
}
}
- }
+ },
}
}
match (key.0.as_str(), key.1) {
("term_expansion", 2) => {
self.extensible_predicates.remove(key);
- },
- _ => {
- match compilation_target {
- CompilationTarget::User => {
- self.extensible_predicates.remove(key);
- }
- CompilationTarget::Module(ref module_name) => {
- if let Some(module) = self.modules.get_mut(module_name) {
- module.extensible_predicates.remove(key);
- }
+ }
+ _ => match compilation_target {
+ CompilationTarget::User => {
+ self.extensible_predicates.remove(key);
+ }
+ CompilationTarget::Module(ref module_name) => {
+ if let Some(module) = self.modules.get_mut(module_name) {
+ module.extensible_predicates.remove(key);
}
}
- }
+ },
}
}
) -> Option<CodeIndex> {
if module.as_str() == "user" {
match ClauseType::from(name, arity, op_spec) {
- ClauseType::Named(name, arity, _) => {
- self.code_dir.get(&(name, arity)).cloned()
- }
- ClauseType::Op(name, spec, ..) => {
- self.code_dir.get(&(name, spec.arity())).cloned()
- }
- _ => {
- None
- }
+ ClauseType::Named(name, arity, _) => self.code_dir.get(&(name, arity)).cloned(),
+ ClauseType::Op(name, spec, ..) => self.code_dir.get(&(name, spec.arity())).cloned(),
+ _ => None,
}
} else {
self.modules.get(&module).and_then(|module| {
ClauseType::Op(name, spec, ..) => {
module.code_dir.get(&(name, spec.arity())).cloned()
}
- _ => {
- None
- }
+ _ => None,
}
})
}
compilation_target: &CompilationTarget,
) -> Option<&Vec<MetaSpec>> {
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.meta_predicates.get(&(name.clone(), arity))
- .or_else(|| {
- self.meta_predicates.get(&(name, arity))
- })
- }
- None => {
- self.meta_predicates.get(&(name, arity))
- }
- }
- }
+ CompilationTarget::User => self.meta_predicates.get(&(name, arity)),
+ CompilationTarget::Module(ref module_name) => match self.modules.get(module_name) {
+ Some(ref module) => module
+ .meta_predicates
+ .get(&(name.clone(), arity))
+ .or_else(|| self.meta_predicates.get(&(name, arity))),
+ None => self.meta_predicates.get(&(name, arity)),
+ },
}
}
pub fn is_dynamic_predicate(&self, module_name: ClauseName, key: PredicateKey) -> bool {
match module_name.as_str() {
- "user" => {
- self.extensible_predicates.get(&key)
+ "user" => self
+ .extensible_predicates
+ .get(&key)
+ .map(|skeleton| skeleton.is_dynamic)
+ .unwrap_or(false),
+ _ => match self.modules.get(&module_name) {
+ Some(ref module) => module
+ .extensible_predicates
+ .get(&key)
.map(|skeleton| skeleton.is_dynamic)
- .unwrap_or(false)
- }
- _ => {
- match self.modules.get(&module_name) {
- Some(ref module) => {
- module.extensible_predicates.get(&key)
- .map(|skeleton| skeleton.is_dynamic)
- .unwrap_or(false)
- }
- None => {
- false
- }
- }
- }
+ .unwrap_or(false),
+ None => false,
+ },
}
}
IndexStore::default()
}
- pub(super)
- fn get_cleaner_sites(&self) -> (usize, usize) {
+ pub(super) fn get_cleaner_sites(&self) -> (usize, usize) {
let r_w_h = clause_name!("run_cleaners_with_handling");
let r_wo_h = clause_name!("run_cleaners_without_handling");
let iso_ext = clause_name!("iso_ext");
impl<'a, T: 'a + fmt::Debug> fmt::Debug for RefOrOwned<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
- &RefOrOwned::Borrowed(ref borrowed) =>
- write!(f, "Borrowed({:?})", borrowed),
- &RefOrOwned::Owned(ref owned) =>
- write!(f, "Owned({:?})", owned),
+ &RefOrOwned::Borrowed(ref borrowed) => write!(f, "Borrowed({:?})", borrowed),
+ &RefOrOwned::Owned(ref owned) => write!(f, "Owned({:?})", owned),
}
}
}
}
}
- pub fn to_owned(self) -> T where T: Clone
+ pub fn to_owned(self) -> T
+ where
+ T: Clone,
{
match self {
RefOrOwned::Borrowed(item) => item.clone(),
use crate::prolog_parser_rebis::ast::*;
use crate::prolog_parser_rebis::tabled_rc::*;
+use crate::prolog_parser_rebis::{clause_name, temp_v};
use crate::clause_types::*;
use crate::forms::*;
use crate::machine::streams::*;
use crate::rug::Integer;
-use crate::downcast::Any;
+use crate::downcast::{
+ downcast, downcast_methods, downcast_methods_core, downcast_methods_std, impl_downcast, Any,
+};
use crate::indexmap::IndexMap;
}
impl Ball {
- pub(super)
- fn new() -> Self {
+ pub(super) fn new() -> Self {
Ball {
boundary: 0,
stub: Heap::new(),
}
}
- pub(super)
- fn reset(&mut self) {
+ pub(super) fn reset(&mut self) {
self.boundary = 0;
self.stub.clear();
}
- pub(super)
- fn copy_and_align(&self, h: usize) -> Heap {
+ pub(super) fn copy_and_align(&self, h: usize) -> Heap {
let diff = self.boundary as i64 - h as i64;
let mut stub = Heap::new();
for heap_value in self.stub.iter_from(0) {
stub.push(match heap_value {
- &HeapCellValue::Addr(addr) => {
- HeapCellValue::Addr(addr - diff)
- }
- heap_value => {
- heap_value.context_free_clone()
- }
+ &HeapCellValue::Addr(addr) => HeapCellValue::Addr(addr - diff),
+ heap_value => heap_value.context_free_clone(),
});
}
}
impl<'a> CopyBallTerm<'a> {
- pub(super) fn new(
- stack: &'a mut Stack,
- heap: &'a mut Heap,
- stub: &'a mut Heap,
- ) -> Self {
+ pub(super) fn new(stack: &'a mut Stack, heap: &'a mut Heap, stub: &'a mut Heap) -> Self {
let hb = heap.h();
CopyBallTerm {
let index = h - self.heap_boundary;
self.stub[index].as_addr(h)
}
- Addr::StackCell(fr, sc) => {
- self.stack.index_and_frame(fr)[sc]
- }
- addr => {
- addr
- }
+ Addr::StackCell(fr, sc) => self.stack.index_and_frame(fr)[sc],
+ addr => addr,
}
}
impl IndexMut<RegType> for MachineState {
fn index_mut(&mut self, reg: RegType) -> &mut Self::Output {
match reg {
- RegType::Temp(temp) => {
- &mut self.registers[temp]
- }
+ RegType::Temp(temp) => &mut self.registers[temp],
RegType::Perm(perm) => {
let e = self.e;
impl HeapPtr {
#[inline]
- pub(super)
- fn read(&self, heap: &Heap) -> Addr {
+ pub(super) fn read(&self, heap: &Heap) -> Addr {
match self {
- &HeapPtr::HeapCell(h) => {
- Addr::HeapCell(h)
- }
+ &HeapPtr::HeapCell(h) => Addr::HeapCell(h),
&HeapPtr::PStrChar(h, n) => {
if let &HeapCellValue::PartialString(ref pstr, has_tail) = &heap[h] {
- if let Some(c) = pstr.range_from(n ..).next() {
+ if let Some(c) = pstr.range_from(n..).next() {
Addr::Char(c)
} else if has_tail {
Addr::HeapCell(h + 1)
unreachable!()
}
}
- &HeapPtr::PStrLocation(h, n) => {
- Addr::PStrLocation(h, n)
- }
+ &HeapPtr::PStrLocation(h, n) => Addr::PStrLocation(h, n),
}
}
}
pub(super) last_call: bool,
pub(crate) heap_locs: HeapVarDict,
pub(crate) flags: MachineFlags,
- pub(crate) at_end_of_expansion: bool
+ pub(crate) at_end_of_expansion: bool,
}
impl MachineState {
- pub(crate)
- fn read_term(
- &mut self,
- mut stream: Stream,
- indices: &mut IndexStore,
- ) -> CallResult {
+ pub(crate) fn read_term(&mut self, mut stream: Stream, indices: &mut IndexStore) -> CallResult {
self.check_stream_properties(
&mut stream,
StreamType::Text,
let mut orig_stream = stream.clone();
loop {
- match self.read(
- stream.clone(),
- self.atom_tbl.clone(),
- &indices.op_dir,
- ) {
+ match self.read(stream.clone(), self.atom_tbl.clone(), &indices.op_dir) {
Ok(term_write_result) => {
let term = self[temp_v!(2)];
self.unify(Addr::HeapCell(term_write_result.heap_loc), term);
let h = self.heap.h();
let spec = fetch_atom_op_spec(clause_name!("="), None, &indices.op_dir);
- self.heap.push(HeapCellValue::NamedStr(2, clause_name!("="), spec));
+ self.heap
+ .push(HeapCellValue::NamedStr(2, clause_name!("="), spec));
self.heap.push(HeapCellValue::Atom(var_atom, None));
self.heap.push(HeapCellValue::Addr(binding));
}
let vars_addr = self[temp_v!(4)];
- let vars_offset =
- Addr::HeapCell(self.heap.to_list(var_list.into_iter()));
+ let vars_offset = Addr::HeapCell(self.heap.to_list(var_list.into_iter()));
self.unify(vars_offset, vars_addr);
self[temp_v!(2)],
&mut orig_stream,
clause_name!("read_term"),
- 3
+ 3,
)?;
if orig_stream.options.eof_action == EOFAction::Reset {
}
}
- pub(crate)
- fn write_term<'a>(
+ pub(crate) fn write_term<'a>(
&'a self,
op_dir: &'a OpDir,
- ) -> Result<Option<HCPrinter<'a, PrinterOutputter>>, MachineStub>
- {
+ ) -> Result<Option<HCPrinter<'a, PrinterOutputter>>, MachineStub> {
let ignore_ops = self.store(self.deref(self[temp_v!(3)]));
let numbervars = self.store(self.deref(self[temp_v!(4)]));
let quoted = self.store(self.deref(self[temp_v!(5)]));
let mut printer = HCPrinter::new(&self, op_dir, PrinterOutputter::new());
if let &Addr::Con(h) = &ignore_ops {
- if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
+ if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
printer.ignore_ops = name.as_str() == "true";
} else {
unreachable!()
}
if let &Addr::Con(h) = &numbervars {
- if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
+ if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
printer.numbervars = name.as_str() == "true";
} else {
unreachable!()
}
if let &Addr::Con(h) = "ed {
- if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
+ if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
printer.quoted = name.as_str() == "true";
} else {
unreachable!()
for addr in addrs {
match addr {
Addr::Str(s) => match &self.heap[s] {
- &HeapCellValue::NamedStr(2, ref name, _)
- if name.as_str() == "=" =>
- {
+ &HeapCellValue::NamedStr(2, ref name, _) if name.as_str() == "=" => {
let atom = self.heap[s + 1].as_addr(s + 1);
let var = self.heap[s + 2].as_addr(s + 2);
var_names.insert(var, atom);
}
- _ => {
- }
+ _ => {}
},
- _ => {
- }
+ _ => {}
}
}
Ok(Some(printer))
}
- pub(super)
- fn throw_undefined_error(&mut self, name: ClauseName, arity: usize) -> MachineStub {
+ pub(super) fn throw_undefined_error(&mut self, name: ClauseName, arity: usize) -> MachineStub {
let stub = MachineError::functor_stub(name.clone(), arity);
let h = self.heap.h();
let key = ExistenceError::Procedure(name, arity);
}
#[inline]
- pub(crate)
- fn heap_pstr_iter<'a>(&'a self, focus: Addr) -> HeapPStrIter<'a> {
+ pub(crate) fn heap_pstr_iter<'a>(&'a self, focus: Addr) -> HeapPStrIter<'a> {
HeapPStrIter::new(self, focus)
}
- pub(super)
- fn try_char_list(&self, addrs: Vec<Addr>) -> Result<String, MachineError> {
+ pub(super) fn try_char_list(&self, addrs: Vec<Addr>) -> Result<String, MachineError> {
let mut chars = String::new();
let mut iter = addrs.iter();
}
}
}
- _ => {
- }
+ _ => {}
};
let h = self.heap.h();
- return Err(
- MachineError::type_error(h, ValidType::Character, addr)
- );
+ return Err(MachineError::type_error(h, ValidType::Character, addr));
}
Ok(chars)
}
- pub(super)
- fn read_predicate_key(&self, name: Addr, arity: Addr) -> (ClauseName, usize) {
+ pub(super) fn read_predicate_key(&self, name: Addr, arity: Addr) -> (ClauseName, usize) {
let predicate_name = atom_from!(self, self.store(self.deref(name)));
let arity = self.store(self.deref(arity));
- let arity =
- match Number::try_from((arity, &self.heap)) {
- Ok(Number::Integer(n)) if &*n >= &0 && &*n <= &MAX_ARITY =>
- n.to_usize().unwrap(),
- Ok(Number::Fixnum(n)) if n >= 0 && n <= MAX_ARITY as isize =>
- usize::try_from(n).unwrap(),
- _ =>
- unreachable!()
- };
+ let arity = match Number::try_from((arity, &self.heap)) {
+ Ok(Number::Integer(n)) if &*n >= &0 && &*n <= &MAX_ARITY => n.to_usize().unwrap(),
+ Ok(Number::Fixnum(n)) if n >= 0 && n <= MAX_ARITY as isize => {
+ usize::try_from(n).unwrap()
+ }
+ _ => unreachable!(),
+ };
(predicate_name, arity)
}
- pub(super)
- fn call_at_index(&mut self, arity: usize, p: LocalCodePtr) {
+ pub(super) fn call_at_index(&mut self, arity: usize, p: LocalCodePtr) {
self.cp.assign_if_local(self.p.clone() + 1);
self.num_of_args = arity;
self.b0 = self.b;
self.p = CodePtr::Local(p);
}
- pub(super)
- fn execute_at_index(&mut self, arity: usize, p: LocalCodePtr) {
+ pub(super) fn execute_at_index(&mut self, arity: usize, p: LocalCodePtr) {
self.num_of_args = arity;
self.b0 = self.b;
self.p = CodePtr::Local(p);
}
- pub(super)
- fn module_lookup(
+ pub(super) fn module_lookup(
&mut self,
indices: &IndexStore,
call_policy: &mut Box<dyn CallPolicy>,
pub(crate) trait CallPolicy: Any + fmt::Debug {
fn retry_me_else(&mut self, machine_st: &mut MachineState, offset: usize) -> CallResult {
let b = machine_st.b;
- let n = machine_st.stack.index_or_frame(b).prelude.univ_prelude.num_cells;
-
- for i in 1 .. n + 1 {
- machine_st.registers[i] = machine_st.stack.index_or_frame(b)[i-1];
+ let n = machine_st
+ .stack
+ .index_or_frame(b)
+ .prelude
+ .univ_prelude
+ .num_cells;
+
+ for i in 1..n + 1 {
+ machine_st.registers[i] = machine_st.stack.index_or_frame(b)[i - 1];
}
machine_st.num_of_args = n;
machine_st.tr = machine_st.stack.index_or_frame(b).prelude.tr;
machine_st.trail.truncate(machine_st.tr);
- machine_st.heap.truncate(machine_st.stack.index_or_frame(b).prelude.h);
-
- let attr_var_init_queue_b =
- machine_st.stack.index_or_frame(b).prelude.attr_var_init_queue_b;
- let attr_var_init_bindings_b =
- machine_st.stack.index_or_frame(b).prelude.attr_var_init_bindings_b;
-
- machine_st.attr_var_init.backtrack(
- attr_var_init_queue_b,
- attr_var_init_bindings_b,
- );
+ machine_st
+ .heap
+ .truncate(machine_st.stack.index_or_frame(b).prelude.h);
+
+ let attr_var_init_queue_b = machine_st
+ .stack
+ .index_or_frame(b)
+ .prelude
+ .attr_var_init_queue_b;
+ let attr_var_init_bindings_b = machine_st
+ .stack
+ .index_or_frame(b)
+ .prelude
+ .attr_var_init_bindings_b;
+
+ machine_st
+ .attr_var_init
+ .backtrack(attr_var_init_queue_b, attr_var_init_bindings_b);
machine_st.hb = machine_st.heap.h();
machine_st.p += 1;
fn retry(&mut self, machine_st: &mut MachineState, offset: usize) -> CallResult {
let b = machine_st.b;
- let n = machine_st.stack.index_or_frame(b).prelude.univ_prelude.num_cells;
-
- for i in 1 .. n + 1 {
- machine_st.registers[i] = machine_st.stack.index_or_frame(b)[i-1];
+ let n = machine_st
+ .stack
+ .index_or_frame(b)
+ .prelude
+ .univ_prelude
+ .num_cells;
+
+ for i in 1..n + 1 {
+ machine_st.registers[i] = machine_st.stack.index_or_frame(b)[i - 1];
}
machine_st.num_of_args = n;
machine_st.tr = machine_st.stack.index_or_frame(b).prelude.tr;
machine_st.trail.truncate(machine_st.tr);
- machine_st.heap.truncate(machine_st.stack.index_or_frame(b).prelude.h);
-
- let attr_var_init_queue_b =
- machine_st.stack.index_or_frame(b).prelude.attr_var_init_queue_b;
- let attr_var_init_bindings_b =
- machine_st.stack.index_or_frame(b).prelude.attr_var_init_bindings_b;
-
- machine_st.attr_var_init.backtrack(attr_var_init_queue_b, attr_var_init_bindings_b);
+ machine_st
+ .heap
+ .truncate(machine_st.stack.index_or_frame(b).prelude.h);
+
+ let attr_var_init_queue_b = machine_st
+ .stack
+ .index_or_frame(b)
+ .prelude
+ .attr_var_init_queue_b;
+ let attr_var_init_bindings_b = machine_st
+ .stack
+ .index_or_frame(b)
+ .prelude
+ .attr_var_init_bindings_b;
+
+ machine_st
+ .attr_var_init
+ .backtrack(attr_var_init_queue_b, attr_var_init_bindings_b);
machine_st.hb = machine_st.heap.h();
machine_st.p = CodePtr::Local(dir_entry!(machine_st.p.local().abs_loc() + offset));
fn trust(&mut self, machine_st: &mut MachineState, offset: usize) -> CallResult {
let b = machine_st.b;
- let n = machine_st.stack.index_or_frame(b).prelude.univ_prelude.num_cells;
-
- for i in 1 .. n + 1 {
- machine_st.registers[i] = machine_st.stack.index_or_frame(b)[i-1];
+ let n = machine_st
+ .stack
+ .index_or_frame(b)
+ .prelude
+ .univ_prelude
+ .num_cells;
+
+ for i in 1..n + 1 {
+ machine_st.registers[i] = machine_st.stack.index_or_frame(b)[i - 1];
}
machine_st.num_of_args = n;
machine_st.tr = machine_st.stack.index_or_frame(b).prelude.tr;
machine_st.trail.truncate(machine_st.tr);
- machine_st.heap.truncate(machine_st.stack.index_or_frame(b).prelude.h);
-
- let attr_var_init_queue_b =
- machine_st.stack.index_or_frame(b).prelude.attr_var_init_queue_b;
- let attr_var_init_bindings_b =
- machine_st.stack.index_or_frame(b).prelude.attr_var_init_bindings_b;
-
- machine_st.attr_var_init.backtrack(
- attr_var_init_queue_b,
- attr_var_init_bindings_b,
- );
+ machine_st
+ .heap
+ .truncate(machine_st.stack.index_or_frame(b).prelude.h);
+
+ let attr_var_init_queue_b = machine_st
+ .stack
+ .index_or_frame(b)
+ .prelude
+ .attr_var_init_queue_b;
+ let attr_var_init_bindings_b = machine_st
+ .stack
+ .index_or_frame(b)
+ .prelude
+ .attr_var_init_bindings_b;
+
+ machine_st
+ .attr_var_init
+ .backtrack(attr_var_init_queue_b, attr_var_init_bindings_b);
machine_st.b = machine_st.stack.index_or_frame(b).prelude.b;
machine_st.stack.truncate(b);
fn trust_me(&mut self, machine_st: &mut MachineState) -> CallResult {
let b = machine_st.b;
- let n = machine_st.stack.index_or_frame(b).prelude.univ_prelude.num_cells;
-
- for i in 1 .. n + 1 {
- machine_st.registers[i] = machine_st.stack.index_or_frame(b)[i-1];
+ let n = machine_st
+ .stack
+ .index_or_frame(b)
+ .prelude
+ .univ_prelude
+ .num_cells;
+
+ for i in 1..n + 1 {
+ machine_st.registers[i] = machine_st.stack.index_or_frame(b)[i - 1];
}
machine_st.num_of_args = n;
machine_st.tr = machine_st.stack.index_or_frame(b).prelude.tr;
machine_st.trail.truncate(machine_st.tr);
- machine_st.heap.truncate(machine_st.stack.index_or_frame(b).prelude.h);
-
- let attr_var_init_queue_b =
- machine_st.stack.index_or_frame(b).prelude.attr_var_init_queue_b;
- let attr_var_init_bindings_b =
- machine_st.stack.index_or_frame(b).prelude.attr_var_init_bindings_b;
-
- machine_st.attr_var_init.backtrack(
- attr_var_init_queue_b,
- attr_var_init_bindings_b,
- );
+ machine_st
+ .heap
+ .truncate(machine_st.stack.index_or_frame(b).prelude.h);
+
+ let attr_var_init_queue_b = machine_st
+ .stack
+ .index_or_frame(b)
+ .prelude
+ .attr_var_init_queue_b;
+ let attr_var_init_bindings_b = machine_st
+ .stack
+ .index_or_frame(b)
+ .prelude
+ .attr_var_init_bindings_b;
+
+ machine_st
+ .attr_var_init
+ .backtrack(attr_var_init_queue_b, attr_var_init_bindings_b);
machine_st.b = machine_st.stack.index_or_frame(b).prelude.b;
machine_st.stack.truncate(b);
Addr::Con(h) if machine_st.heap.atom_at(h) => {
if let HeapCellValue::Atom(ref atom, _) = &machine_st.heap[h] {
match atom.as_str() {
- ">" | "<" | "=" => {
- }
+ ">" | "<" | "=" => {}
_ => {
let stub =
MachineError::functor_stub(clause_name!("compare"), 3);
- let err = MachineError::domain_error(DomainErrorType::Order, a1);
+ let err =
+ MachineError::domain_error(DomainErrorType::Order, a1);
return Err(machine_st.error_form(err, stub));
}
}
let err = MachineError::type_error(h, ValidType::Atom, a1);
return Err(machine_st.error_form(err, stub));
}
- _ => {
- }
+ _ => {}
}
let atom = match machine_st.compare_term_test(&a2, &a3) {
let addr = machine_st[temp_v!(1)];
let eof = clause_name!("end_of_file".to_string(), machine_st.atom_tbl);
- let atom = machine_st.heap.to_unifiable(
- HeapCellValue::Atom(eof, None)
- );
+ let atom = machine_st.heap.to_unifiable(HeapCellValue::Atom(eof, None));
machine_st.unify(addr, atom);
}
let mut list = machine_st.try_from_list(temp_v!(1), stub)?;
list.sort_unstable_by(|a1, a2| {
- machine_st.compare_term_test(a1, a2).unwrap_or(Ordering::Less)
+ machine_st
+ .compare_term_test(a1, a2)
+ .unwrap_or(Ordering::Less)
});
machine_st.term_dedup(&mut list);
}
key_pairs.sort_by(|a1, a2| {
- machine_st.compare_term_test(&a1.0, &a2.0).unwrap_or(Ordering::Less)
+ machine_st
+ .compare_term_test(&a1.0, &a2.0)
+ .unwrap_or(Ordering::Less)
});
let key_pairs = key_pairs.into_iter().map(|kp| kp.1);
let stub = MachineError::functor_stub(clause_name!("call"), arity + 1);
return Err(machine_st.error_form(
- MachineError::type_error(
- machine_st.heap.h(),
- ValidType::Callable,
- name
- ),
+ MachineError::type_error(machine_st.heap.h(), ValidType::Callable, name),
stub,
));
}
arity: usize,
idx: &CodeIndex,
) -> CallResult {
- self.prev_policy.context_call(machine_st, name, arity, idx)?;//, indices)?;
+ self.prev_policy
+ .context_call(machine_st, name, arity, idx)?; //, indices)?;
self.increment(machine_st)
}
code_dir,
op_dir,
current_input_stream,
- current_output_stream
+ current_output_stream,
)?;
self.increment(machine_st)
}
impl CWILCallPolicy {
- pub(crate)
- fn new_in_place(policy: &mut Box<dyn CallPolicy>) {
+ pub(crate) fn new_in_place(policy: &mut Box<dyn CallPolicy>) {
let mut prev_policy: Box<dyn CallPolicy> = Box::new(DefaultCallPolicy {});
mem::swap(&mut prev_policy, policy);
Ok(())
}
- pub(crate)
- fn add_limit(&mut self, mut limit: Integer, b: usize) -> &Integer {
+ pub(crate) fn add_limit(&mut self, mut limit: Integer, b: usize) -> &Integer {
limit += &self.count;
match self.limits.last().cloned() {
&self.count
}
- pub(crate)
- fn remove_limit(&mut self, b: usize) -> &Integer {
+ pub(crate) fn remove_limit(&mut self, b: usize) -> &Integer {
if let Some((_, bp)) = self.limits.last().cloned() {
if bp == b {
self.limits.pop();
&self.count
}
- pub(crate)
- fn is_empty(&self) -> bool {
+ pub(crate) fn is_empty(&self) -> bool {
self.limits.is_empty()
}
- pub(crate)
- fn into_inner(&mut self) -> Box<dyn CallPolicy> {
+ pub(crate) fn into_inner(&mut self) -> Box<dyn CallPolicy> {
let mut new_inner: Box<dyn CallPolicy> = Box::new(DefaultCallPolicy {});
mem::swap(&mut self.prev_policy, &mut new_inner);
new_inner
use crate::prolog_parser_rebis::ast::*;
use crate::prolog_parser_rebis::tabled_rc::*;
+use crate::prolog_parser_rebis::{clause_name, perm_v, temp_v};
use crate::clause_types::*;
use crate::forms::*;
use crate::heap_iter::*;
use crate::indexing::*;
use crate::instructions::*;
-use crate::machine::INTERRUPT;
use crate::machine::attributed_variables::*;
use crate::machine::code_repo::CodeRepo;
use crate::machine::copier::*;
use crate::machine::partial_string::*;
use crate::machine::stack::*;
use crate::machine::streams::*;
+use crate::machine::INTERRUPT;
use crate::ordered_float::*;
use crate::rug::Integer;
use std::rc::Rc;
impl MachineState {
- pub(crate)
- fn new() -> Self {
+ pub(crate) fn new() -> Self {
MachineState {
atom_tbl: TabledData::new(Rc::new("".to_owned())),
s: HeapPtr::default(),
last_call: false,
heap_locs: HeapVarDict::new(),
flags: MachineFlags::default(),
- at_end_of_expansion: false
+ at_end_of_expansion: false,
}
}
self.flags
}
- pub(crate)
- fn store(&self, addr: Addr) -> Addr {
+ pub(crate) fn store(&self, addr: Addr) -> Addr {
match addr {
- Addr::AttrVar(h) | Addr::HeapCell(h) => {
- self.heap[h].as_addr(h)
- }
- Addr::StackCell(fr, sc) => {
- self.stack.index_and_frame(fr)[sc]
- }
+ Addr::AttrVar(h) | Addr::HeapCell(h) => self.heap[h].as_addr(h),
+ Addr::StackCell(fr, sc) => self.stack.index_and_frame(fr)[sc],
Addr::PStrLocation(h, n) => {
if let &HeapCellValue::PartialString(ref pstr, has_tail) = &self.heap[h] {
if !pstr.at_end(n) {
unreachable!()
}
}
- addr => {
- addr
- }
+ addr => addr,
}
}
- pub(crate)
- fn deref(&self, mut addr: Addr) -> Addr {
+ pub(crate) fn deref(&self, mut addr: Addr) -> Addr {
loop {
let value = self.store(addr);
}
}
- pub(super)
- fn bind(&mut self, r1: Ref, a2: Addr) {
+ pub(super) fn bind(&mut self, r1: Ref, a2: Addr) {
let t1 = self.store(r1.as_addr());
let t2 = self.store(a2);
Some(Ref::AttrVar(h)) => {
self.bind_attr_var(h, t1);
}
- None => {
- }
+ None => {}
}
}
}
self.bind(r, addr);
}
- pub(super)
- fn unify_with_occurs_check(&mut self, a1: Addr, a2: Addr) {
+ pub(super) fn unify_with_occurs_check(&mut self, a1: Addr, a2: Addr) {
let mut pdl = vec![a1, a2];
let mut tabu_list: IndexSet<(Addr, Addr)> = IndexSet::new();
self.fail = true;
}
- (Addr::PStrLocation(h, n), Addr::Lis(l)) |
- (Addr::Lis(l), Addr::PStrLocation(h, n)) => {
+ (Addr::PStrLocation(h, n), Addr::Lis(l))
+ | (Addr::Lis(l), Addr::PStrLocation(h, n)) => {
if let HeapCellValue::PartialString(ref pstr, _) = &self.heap[h] {
- if let Some(c) = pstr.range_from(n ..).next() {
+ if let Some(c) = pstr.range_from(n..).next() {
pdl.push(Addr::PStrLocation(h, n + c.len_utf8()));
pdl.push(Addr::HeapCell(l + 1));
}
}
(Addr::PStrLocation(h1, n1), Addr::PStrLocation(h2, n2)) => {
- if let &HeapCellValue::PartialString(ref pstr1, has_tail_1) = &self.heap[h1] {
- if let &HeapCellValue::PartialString(ref pstr2, has_tail_2) = &self.heap[h2] {
+ if let &HeapCellValue::PartialString(ref pstr1, has_tail_1) = &self.heap[h1]
+ {
+ if let &HeapCellValue::PartialString(ref pstr2, has_tail_2) =
+ &self.heap[h2]
+ {
let pstr1_s = pstr1.as_str_from(n1);
let pstr2_s = pstr2.as_str_from(n2);
- let m_len =
- if pstr1_s.starts_with(pstr2_s) {
- pstr2_s.len()
- } else if pstr2_s.starts_with(pstr1_s) {
- pstr1_s.len()
- } else {
- self.fail = true;
- return;
- };
+ let m_len = if pstr1_s.starts_with(pstr2_s) {
+ pstr2_s.len()
+ } else if pstr2_s.starts_with(pstr1_s) {
+ pstr1_s.len()
+ } else {
+ self.fail = true;
+ return;
+ };
if pstr1.at_end(n1 + m_len) {
if has_tail_1 {
self.fail = true;
}
- (Addr::Con(c1), Addr::Con(c2)) => {
- match (&self.heap[c1], &self.heap[c2]) {
- (
- &HeapCellValue::Atom(ref n1, _),
- &HeapCellValue::Atom(ref n2, _),
- ) if n1.as_str() == n2.as_str() => {
- }
- (
- &HeapCellValue::DBRef(ref db_ref_1),
- &HeapCellValue::DBRef(ref db_ref_2),
- ) if db_ref_1 == db_ref_2 => {
- }
- (
- v1,
- v2,
- ) => {
- if let Ok(n1) = Number::try_from(v1) {
- if let Ok(n2) = Number::try_from(v2) {
- if n1 == n2 {
- continue;
- }
+ (Addr::Con(c1), Addr::Con(c2)) => match (&self.heap[c1], &self.heap[c2]) {
+ (&HeapCellValue::Atom(ref n1, _), &HeapCellValue::Atom(ref n2, _))
+ if n1.as_str() == n2.as_str() => {}
+ (
+ &HeapCellValue::DBRef(ref db_ref_1),
+ &HeapCellValue::DBRef(ref db_ref_2),
+ ) if db_ref_1 == db_ref_2 => {}
+ (v1, v2) => {
+ if let Ok(n1) = Number::try_from(v1) {
+ if let Ok(n2) = Number::try_from(v2) {
+ if n1 == n2 {
+ continue;
}
}
-
- self.fail = true;
}
+
+ self.fail = true;
}
- }
+ },
(Addr::Con(h), Addr::Char(c)) | (Addr::Char(c), Addr::Con(h)) => {
match &self.heap[h] {
&HeapCellValue::Atom(ref name, _) if name.is_char() => {
}
}
- pub(super)
- fn unify(&mut self, a1: Addr, a2: Addr) {
+ pub(super) fn unify(&mut self, a1: Addr, a2: Addr) {
let mut pdl = vec![a1, a2];
let mut tabu_list: IndexSet<(Addr, Addr)> = IndexSet::new();
self.fail = true;
}
- (Addr::PStrLocation(h, n), Addr::Lis(l)) |
- (Addr::Lis(l), Addr::PStrLocation(h, n)) => {
- if let HeapCellValue::PartialString(ref pstr, _) = &self.heap[h] {
- if let Some(c) = pstr.range_from(n ..).next() {
- pdl.push(Addr::PStrLocation(h, n + c.len_utf8()));
- pdl.push(Addr::HeapCell(l + 1));
-
- pdl.push(Addr::Char(c));
- pdl.push(Addr::HeapCell(l));
- } else {
- unreachable!()
- }
- } else {
- unreachable!()
- }
+ (Addr::PStrLocation(h, n), Addr::Lis(l))
+ | (Addr::Lis(l), Addr::PStrLocation(h, n)) => {
+ if let HeapCellValue::PartialString(ref pstr, _) = &self.heap[h] {
+ if let Some(c) = pstr.range_from(n..).next() {
+ pdl.push(Addr::PStrLocation(h, n + c.len_utf8()));
+ pdl.push(Addr::HeapCell(l + 1));
+
+ pdl.push(Addr::Char(c));
+ pdl.push(Addr::HeapCell(l));
+ } else {
+ unreachable!()
+ }
+ } else {
+ unreachable!()
+ }
}
(Addr::PStrLocation(h1, n1), Addr::PStrLocation(h2, n2)) => {
- if let &HeapCellValue::PartialString(ref pstr1, has_tail_1) = &self.heap[h1] {
- if let &HeapCellValue::PartialString(ref pstr2, has_tail_2) = &self.heap[h2] {
+ if let &HeapCellValue::PartialString(ref pstr1, has_tail_1) = &self.heap[h1]
+ {
+ if let &HeapCellValue::PartialString(ref pstr2, has_tail_2) =
+ &self.heap[h2]
+ {
let pstr1_s = pstr1.as_str_from(n1);
let pstr2_s = pstr2.as_str_from(n2);
- let m_len =
- if pstr1_s.starts_with(pstr2_s) {
- pstr2_s.len()
- } else if pstr2_s.starts_with(pstr1_s) {
- pstr1_s.len()
- } else {
- self.fail = true;
- return;
- };
+ let m_len = if pstr1_s.starts_with(pstr2_s) {
+ pstr2_s.len()
+ } else if pstr2_s.starts_with(pstr1_s) {
+ pstr1_s.len()
+ } else {
+ self.fail = true;
+ return;
+ };
if pstr1.at_end(n1 + m_len) {
if has_tail_1 {
self.fail = true;
}
- (Addr::Con(c1), Addr::Con(c2)) => {
- match (&self.heap[c1], &self.heap[c2]) {
- (
- &HeapCellValue::Atom(ref n1, _),
- &HeapCellValue::Atom(ref n2, _),
- ) if n1.as_str() == n2.as_str() => {
- }
-(
- &HeapCellValue::DBRef(ref db_ref_1),
- &HeapCellValue::DBRef(ref db_ref_2),
- ) if db_ref_1 == db_ref_2 => {
- }
- (
- v1,
- v2,
- ) => {
- if let Ok(n1) = Number::try_from(v1) {
- if let Ok(n2) = Number::try_from(v2) {
- if n1 == n2 {
- continue;
- }
+ (Addr::Con(c1), Addr::Con(c2)) => match (&self.heap[c1], &self.heap[c2]) {
+ (&HeapCellValue::Atom(ref n1, _), &HeapCellValue::Atom(ref n2, _))
+ if n1.as_str() == n2.as_str() => {}
+ (
+ &HeapCellValue::DBRef(ref db_ref_1),
+ &HeapCellValue::DBRef(ref db_ref_2),
+ ) if db_ref_1 == db_ref_2 => {}
+ (v1, v2) => {
+ if let Ok(n1) = Number::try_from(v1) {
+ if let Ok(n2) = Number::try_from(v2) {
+ if n1 == n2 {
+ continue;
}
}
-
- self.fail = true;
}
+
+ self.fail = true;
}
- }
+ },
(Addr::Con(h), Addr::Char(c)) | (Addr::Char(c), Addr::Con(h)) => {
match &self.heap[h] {
&HeapCellValue::Atom(ref name, _) if name.is_char() => {
}
}
- pub(super)
- fn trail(&mut self, r: TrailRef) {
+ pub(super) fn trail(&mut self, r: TrailRef) {
match r {
TrailRef::Ref(Ref::HeapCell(h)) => {
if h < self.hb {
HeapPtr::HeapCell(ref mut h) => {
*h += rhs;
}
- &mut HeapPtr::PStrChar(h, ref mut n) |
- &mut HeapPtr::PStrLocation(h, ref mut n) => {
+ &mut HeapPtr::PStrChar(h, ref mut n) | &mut HeapPtr::PStrLocation(h, ref mut n) => {
match &self.heap[h] {
&HeapCellValue::PartialString(ref pstr, _) => {
- for c in pstr.range_from(*n ..).take(rhs) {
+ for c in pstr.range_from(*n..).take(rhs) {
*n += c.len_utf8();
}
self.s = HeapPtr::PStrLocation(h, *n);
}
- _ => {
- }
+ _ => {}
}
}
}
}
- pub(super)
- fn unwind_trail(&mut self, a1: usize, a2: usize) {
+ pub(super) fn unwind_trail(&mut self, a1: usize, a2: usize) {
// the sequence is reversed to respect the chronology of trail
// additions, now that deleted attributes can be undeleted by
// backtracking.
}
}
- pub(super)
- fn tidy_trail(&mut self) {
+ pub(super) fn tidy_trail(&mut self) {
if self.b == 0 {
return;
}
let hb = self.hb;
let mut offset = 0;
- for i in self.stack.index_or_frame(b).prelude.tr .. self.tr {
+ for i in self.stack.index_or_frame(b).prelude.tr..self.tr {
match self.trail[i] {
TrailRef::Ref(Ref::AttrVar(tr_i))
- | TrailRef::Ref(Ref::HeapCell(tr_i))
- | TrailRef::AttrVarHeapLink(tr_i)
- | TrailRef::AttrVarListLink(tr_i, _) => {
+ | TrailRef::Ref(Ref::HeapCell(tr_i))
+ | TrailRef::AttrVarHeapLink(tr_i)
+ | TrailRef::AttrVarListLink(tr_i, _) => {
if tr_i >= hb {
offset += 1;
} else {
self.trail.truncate(self.tr);
}
- pub(super)
- fn match_partial_string(&mut self, addr: Addr, string: &String, has_tail: bool) {
+ pub(super) fn match_partial_string(&mut self, addr: Addr, string: &String, has_tail: bool) {
let mut heap_pstr_iter = self.heap_pstr_iter(addr);
match compare_pstr_to_string(&mut heap_pstr_iter, string) {
}
}
}
- Some(prefix_len) => {
- match heap_pstr_iter.focus() {
- addr if addr.is_ref() => {
- let h = self.heap.h();
+ Some(prefix_len) => match heap_pstr_iter.focus() {
+ addr if addr.is_ref() => {
+ let h = self.heap.h();
- let pstr_addr =
- if has_tail {
- self.s = HeapPtr::HeapCell(h+1);
- self.mode = MachineMode::Read;
+ let pstr_addr = if has_tail {
+ self.s = HeapPtr::HeapCell(h + 1);
+ self.mode = MachineMode::Read;
- self.heap.allocate_pstr(&string[prefix_len ..])
- } else {
- self.heap.put_complete_string(&string[prefix_len ..])
- };
+ self.heap.allocate_pstr(&string[prefix_len..])
+ } else {
+ self.heap.put_complete_string(&string[prefix_len..])
+ };
- self.bind(addr.as_var().unwrap(), pstr_addr);
- }
- Addr::Lis(l) => {
- let h = self.heap.h();
+ self.bind(addr.as_var().unwrap(), pstr_addr);
+ }
+ Addr::Lis(l) => {
+ let h = self.heap.h();
- let pstr_addr =
- if has_tail {
- self.s = HeapPtr::HeapCell(h+1);
- self.mode = MachineMode::Read;
+ let pstr_addr = if has_tail {
+ self.s = HeapPtr::HeapCell(h + 1);
+ self.mode = MachineMode::Read;
- self.heap.allocate_pstr(&string[prefix_len ..])
- } else {
- self.heap.put_complete_string(&string[prefix_len ..])
- };
+ self.heap.allocate_pstr(&string[prefix_len..])
+ } else {
+ self.heap.put_complete_string(&string[prefix_len..])
+ };
- self.unify(Addr::Lis(l), pstr_addr);
- }
- _ => {
- self.fail = true;
- }
+ self.unify(Addr::Lis(l), pstr_addr);
}
- }
+ _ => {
+ self.fail = true;
+ }
+ },
None => {
self.fail = true;
}
}
}
- pub(super)
- fn write_constant_to_var(&mut self, addr: Addr, c: &Constant) {
+ pub(super) fn write_constant_to_var(&mut self, addr: Addr, c: &Constant) {
match self.store(self.deref(addr)) {
Addr::Con(c1) => {
match &self.heap[c1] {
HeapCellValue::Atom(ref n1, _) => {
self.fail = match c {
- Constant::Atom(ref n2, _) => {
- n1 != n2
- }
+ Constant::Atom(ref n2, _) => n1 != n2,
Constant::Char(c) if n1.is_char() => {
Some(*c) != n1.as_str().chars().next()
}
- _ => {
- true
- }
+ _ => true,
};
}
HeapCellValue::Integer(ref n1) => {
self.fail = match c {
- Constant::Fixnum(n2) => {
- n1.to_isize() != Some(*n2)
- }
- Constant::Integer(ref n2) => {
- n1 != n2
- }
- Constant::Usize(n2) => {
- n1.to_usize() != Some(*n2)
- }
- _ => {
- true
- }
+ Constant::Fixnum(n2) => n1.to_isize() != Some(*n2),
+ Constant::Integer(ref n2) => n1 != n2,
+ Constant::Usize(n2) => n1.to_usize() != Some(*n2),
+ _ => true,
};
}
HeapCellValue::Rational(ref r1) => {
}
HeapCellValue::PartialString(..) => {
if let Constant::String(ref s2) = c {
- self.match_partial_string(
- Addr::PStrLocation(c1, 0),
- &s2,
- false,
- );
+ self.match_partial_string(Addr::PStrLocation(c1, 0), &s2, false);
} else {
self.fail = true;
}
Constant::Atom(ref n2, _) if n2.is_char() => {
Some(ch) != n2.as_str().chars().next()
}
- Constant::Char(c) => {
- *c != ch
- }
- _ => {
- true
- }
+ Constant::Char(c) => *c != ch,
+ _ => true,
};
}
Addr::EmptyList => {
}
Addr::PStrLocation(h, n) => {
if let Constant::String(ref s2) = c {
- self.match_partial_string(
- Addr::PStrLocation(h, n),
- &s2,
- false,
- )
+ self.match_partial_string(Addr::PStrLocation(h, n), &s2, false)
} else {
self.fail = true;
};
};
}
- pub(super)
- fn execute_arith_instr(&mut self, instr: &ArithmeticInstruction) {
+ pub(super) fn execute_arith_instr(&mut self, instr: &ArithmeticInstruction) {
let stub = MachineError::functor_stub(clause_name!("is"), 2);
match instr {
let stub = MachineError::functor_stub(clause_name!("(rdiv)"), 2);
let (r1, stub) = try_or_fail!(self, self.get_rational(a1, stub));
- let (r2, _) = try_or_fail!(self, self.get_rational(a2, stub));
+ let (r2, _) = try_or_fail!(self, self.get_rational(a2, stub));
self.interms[t - 1] =
Number::Rational(Rc::new(try_or_fail!(self, self.rdiv(r1, r2))));
};
}
- pub(super)
- fn execute_fact_instr(&mut self, instr: &FactInstruction) {
+ pub(super) fn execute_fact_instr(&mut self, instr: &FactInstruction) {
match instr {
&FactInstruction::GetConstant(_, ref c, reg) => {
let addr = self[reg];
self.s = HeapPtr::PStrChar(h, n);
self.mode = MachineMode::Read;
}
- addr @ Addr::AttrVar(_) |
- addr @ Addr::StackCell(..) |
- addr @ Addr::HeapCell(_) => {
+ addr @ Addr::AttrVar(_)
+ | addr @ Addr::StackCell(..)
+ | addr @ Addr::HeapCell(_) => {
let h = self.heap.h();
self.heap.push(HeapCellValue::Addr(Addr::Lis(h + 1)));
let h = self.heap.h();
self.heap.push(HeapCellValue::Addr(Addr::Str(h + 1)));
- self.heap.push(HeapCellValue::NamedStr(arity, ct.name(), ct.spec()));
+ self.heap
+ .push(HeapCellValue::NamedStr(arity, ct.name(), ct.spec()));
self.bind(addr.as_var().unwrap(), Addr::HeapCell(h));
};
}
- pub(super)
- fn execute_indexing_instr(
+ pub(super) fn execute_indexing_instr(
&mut self,
indexing_lines: &Vec<IndexingLine>,
call_policy: &mut Box<dyn CallPolicy>,
) {
let mut index = 0;
- let addr =
- match &indexing_lines[0] {
- &IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(arg, ..)) => {
- self.store(self.deref(self[temp_v!(arg)]))
- }
- _ => {
- unreachable!()
- }
- };
+ let addr = match &indexing_lines[0] {
+ &IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(arg, ..)) => {
+ self.store(self.deref(self[temp_v!(arg)]))
+ }
+ _ => {
+ unreachable!()
+ }
+ };
loop {
match &indexing_lines[index] {
Addr::HeapCell(_) | Addr::StackCell(..) | Addr::AttrVar(..) => {
IndexingCodePtr::External(v)
}
- Addr::PStrLocation(..) => {
- l
- }
- Addr::Char(_) | Addr::Con(_) | Addr::CutPoint(_) |
- Addr::EmptyList | Addr::Fixnum(_) | Addr::Float(_) | Addr::Usize(_) => {
- c
- }
- Addr::Lis(_) => {
- l
- }
- Addr::Str(_) => {
- s
- }
+ Addr::PStrLocation(..) => l,
+ Addr::Char(_)
+ | Addr::Con(_)
+ | Addr::CutPoint(_)
+ | Addr::EmptyList
+ | Addr::Fixnum(_)
+ | Addr::Float(_)
+ | Addr::Usize(_) => c,
+ Addr::Lis(_) => l,
+ Addr::Str(_) => s,
};
match offset {
};
}
&IndexingLine::Indexing(IndexingInstruction::SwitchOnConstant(ref hm)) => {
- let offset =
- match addr.as_constant_index(&self) {
- Some(c) => {
- match hm.get(&c) {
- Some(offset) => *offset,
- _ => IndexingCodePtr::Fail,
- }
- }
- None => {
- IndexingCodePtr::Fail
- }
- };
+ let offset = match addr.as_constant_index(&self) {
+ Some(c) => match hm.get(&c) {
+ Some(offset) => *offset,
+ _ => IndexingCodePtr::Fail,
+ },
+ None => IndexingCodePtr::Fail,
+ };
match offset {
IndexingCodePtr::Fail => {
if let &HeapCellValue::NamedStr(arity, ref name, _) = &self.heap[s] {
match hm.get(&(name.clone(), arity)) {
Some(offset) => *offset,
- _ => IndexingCodePtr::Fail
+ _ => IndexingCodePtr::Fail,
}
} else {
IndexingCodePtr::Fail
}
}
- _ => {
- IndexingCodePtr::Fail
- }
+ _ => IndexingCodePtr::Fail,
};
match offset {
break;
}
}
- };
+ }
}
pub(super) fn execute_query_instr(&mut self, instr: &QueryInstruction) {
self[reg] = Addr::Lis(self.heap.h());
}
&QueryInstruction::PutPartialString(_, ref string, reg, has_tail) => {
- let pstr_addr =
- if has_tail {
- if !string.is_empty() {
- let pstr_addr = self.heap.allocate_pstr(&string);
- self.heap.pop(); // the tail will be added by the next instruction.
- pstr_addr
- } else {
- Addr::EmptyList
- }
+ let pstr_addr = if has_tail {
+ if !string.is_empty() {
+ let pstr_addr = self.heap.allocate_pstr(&string);
+ self.heap.pop(); // the tail will be added by the next instruction.
+ pstr_addr
} else {
- self.heap.put_complete_string(&string)
- };
+ Addr::EmptyList
+ }
+ } else {
+ self.heap.put_complete_string(&string)
+ };
self[reg] = pstr_addr;
}
&QueryInstruction::PutStructure(ref ct, arity, reg) => {
let h = self.heap.h();
- self.heap.push(HeapCellValue::NamedStr(arity, ct.name(), ct.spec()));
+ self.heap
+ .push(HeapCellValue::NamedStr(arity, ct.name(), ct.spec()));
self[reg] = Addr::Str(h);
}
&QueryInstruction::PutUnsafeValue(n, arg) => {
&QueryInstruction::SetVoid(n) => {
let h = self.heap.h();
- for i in h .. h + n {
+ for i in h..h + n {
self.heap.push(HeapCellValue::Addr(Addr::HeapCell(i)));
}
}
);
}
- pub(super)
- fn handle_internal_call_n(&mut self, arity: usize) {
+ pub(super) fn handle_internal_call_n(&mut self, arity: usize) {
let arity = arity + 1;
let pred = self.registers[1];
self.fail = true;
}
- pub(super)
- fn setup_call_n(&mut self, arity: usize) -> Option<PredicateKey> {
+ pub(super) fn setup_call_n(&mut self, arity: usize) -> Option<PredicateKey> {
let addr = self.store(self.deref(self.registers[arity]));
let (name, narity) = match addr {
return None;
}
- for i in (1 .. arity).rev() {
+ for i in (1..arity).rev() {
self.registers[i + narity] = self.registers[i];
}
- for i in 1 .. narity + 1 {
+ for i in 1..narity + 1 {
self.registers[i] = self.heap[a + i].as_addr(a + i);
}
return None;
}
}
- Addr::Con(h) =>
- match &self.heap[h] {
- HeapCellValue::Atom(ref name, _) => {
- (name.clone(), 0)
- }
- _ => {
- self.fail = true;
- return None;
- }
+ Addr::Con(h) => match &self.heap[h] {
+ HeapCellValue::Atom(ref name, _) => (name.clone(), 0),
+ _ => {
+ self.fail = true;
+ return None;
}
+ },
Addr::HeapCell(_) | Addr::StackCell(_, _) => {
let stub = MachineError::functor_stub(clause_name!("call"), arity + 1);
- let instantiation_error = self.error_form(
- MachineError::instantiation_error(),
- stub,
- );
+ let instantiation_error =
+ self.error_form(MachineError::instantiation_error(), stub);
self.throw_exception(instantiation_error);
return None;
Some((name, arity + narity - 1))
}
- pub(super)
- fn unwind_stack(&mut self) {
+ pub(super) fn unwind_stack(&mut self) {
self.b = self.block;
self.fail = true;
}
- pub(crate)
- fn is_cyclic_term(&self, addr: Addr) -> bool {
+ pub(crate) fn is_cyclic_term(&self, addr: Addr) -> bool {
let mut seen = IndexSet::new();
let mut fail = false;
let mut iter = self.pre_order_iter(addr);
- let is_composite = |addr: &Addr| {
- match *addr {
- Addr::Str(_) | Addr::Lis(_) | Addr::PStrLocation(..) => {
- true
- }
- _ => {
- false
- }
- }
+ let is_composite = |addr: &Addr| match *addr {
+ Addr::Str(_) | Addr::Lis(_) | Addr::PStrLocation(..) => true,
+ _ => false,
};
loop {
}
// arg(+N, +Term, ?Arg)
- pub(super)
- fn try_arg(&mut self) -> CallResult {
+ pub(super) fn try_arg(&mut self) -> CallResult {
let stub = MachineError::functor_stub(clause_name!("arg"), 3);
let n = self.store(self.deref(self[temp_v!(1)]));
match n {
- Addr::HeapCell(_) | Addr::StackCell(..) => { // 8.5.2.3 a)
- return Err(self.error_form(MachineError::instantiation_error(), stub))
+ Addr::HeapCell(_) | Addr::StackCell(..) => {
+ // 8.5.2.3 a)
+ return Err(self.error_form(MachineError::instantiation_error(), stub));
}
addr => {
- let n =
- match Number::try_from((addr, &self.heap)) {
- Ok(Number::Fixnum(n)) => Integer::from(n),
- Ok(Number::Integer(n)) => Integer::from(n.as_ref()),
- _ => {
- return Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- addr,
- ),
- stub,
- ));
- }
- };
+ let n = match Number::try_from((addr, &self.heap)) {
+ Ok(Number::Fixnum(n)) => Integer::from(n),
+ Ok(Number::Integer(n)) => Integer::from(n.as_ref()),
+ _ => {
+ return Err(self.error_form(
+ MachineError::type_error(self.heap.h(), ValidType::Integer, addr),
+ stub,
+ ));
+ }
+ };
- if n < 0 { // 8.5.2.3 e)
+ if n < 0 {
+ // 8.5.2.3 e)
let n = Number::from(n);
- let dom_err = MachineError::domain_error(
- DomainErrorType::NotLessThanZero,
- n,
- );
+ let dom_err = MachineError::domain_error(DomainErrorType::NotLessThanZero, n);
return Err(self.error_form(dom_err, stub));
}
- let n =
- match n.to_usize() {
- Some(n) => n,
- None => {
- self.fail = true;
- return Ok(());
- }
- };
+ let n = match n.to_usize() {
+ Some(n) => n,
+ None => {
+ self.fail = true;
+ return Ok(());
+ }
+ };
let term = self.store(self.deref(self[temp_v!(2)]));
match term {
- Addr::HeapCell(_) | Addr::StackCell(..) | Addr::AttrVar(_) => { // 8.5.2.3 b)
- return Err(self.error_form(MachineError::instantiation_error(), stub))
+ Addr::HeapCell(_) | Addr::StackCell(..) | Addr::AttrVar(_) => {
+ // 8.5.2.3 b)
+ return Err(self.error_form(MachineError::instantiation_error(), stub));
}
Addr::Str(o) => match self.heap.clone(o) {
HeapCellValue::NamedStr(arity, _, _) if 1 <= n && n <= arity => {
let a3 = self[temp_v!(3)];
let h_a =
if let HeapCellValue::PartialString(ref pstr, _) = &self.heap[h] {
- if let Some(c) = pstr.range_from(offset ..).next() {
+ if let Some(c) = pstr.range_from(offset..).next() {
if n == 1 {
Addr::Char(c)
} else {
self.fail = true;
}
}
- _ => { // 8.5.2.3 d)
+ _ => {
+ // 8.5.2.3 d)
return Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Compound,
- term,
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Compound, term),
stub,
- ))
+ ));
}
}
}
self.p += 1;
}
- pub(super)
- fn compare_term(&mut self, qt: CompareTermQT) {
+ pub(super) fn compare_term(&mut self, qt: CompareTermQT) {
let a1 = self[temp_v!(1)];
let a2 = self[temp_v!(2)];
}
// returns true on failure.
- pub(super)
- fn eq_test(&self, a1: Addr, a2: Addr) -> bool {
+ pub(super) fn eq_test(&self, a1: Addr, a2: Addr) -> bool {
let mut iter = self.zipped_acyclic_pre_order_iter(a1, a2);
while let Some((v1, v2)) = iter.next() {
unreachable!()
}
}
- (Addr::PStrLocation(..), Addr::Lis(_)) |
- (Addr::Lis(_), Addr::PStrLocation(..)) => {
+ (Addr::PStrLocation(..), Addr::Lis(_)) | (Addr::Lis(_), Addr::PStrLocation(..)) => {
continue;
}
(pstr1 @ Addr::PStrLocation(..), pstr2 @ Addr::PStrLocation(..)) => {
(Addr::Lis(_), Addr::Lis(_)) => {
continue;
}
- (Addr::Con(h1), Addr::Con(h2)) => {
- match (&self.heap[h1], &self.heap[h2]) {
- (
- &HeapCellValue::Atom(ref n1, ref spec_1),
- &HeapCellValue::Atom(ref n2, ref spec_2),
- ) => {
- if n1 != n2 || spec_1 != spec_2 {
- return true;
- }
+ (Addr::Con(h1), Addr::Con(h2)) => match (&self.heap[h1], &self.heap[h2]) {
+ (
+ &HeapCellValue::Atom(ref n1, ref spec_1),
+ &HeapCellValue::Atom(ref n2, ref spec_2),
+ ) => {
+ if n1 != n2 || spec_1 != spec_2 {
+ return true;
}
- (
- &HeapCellValue::DBRef(ref db_ref_1),
- &HeapCellValue::DBRef(ref db_ref_2),
- ) => {
- if db_ref_1 != db_ref_2 {
- return true;
- }
+ }
+ (&HeapCellValue::DBRef(ref db_ref_1), &HeapCellValue::DBRef(ref db_ref_2)) => {
+ if db_ref_1 != db_ref_2 {
+ return true;
}
- (
- v1,
- v2,
- ) => {
- if let Ok(n1) = Number::try_from(v1) {
- if let Ok(n2) = Number::try_from(v2) {
- if n1 == n2 {
- continue;
- }
+ }
+ (v1, v2) => {
+ if let Ok(n1) = Number::try_from(v1) {
+ if let Ok(n2) = Number::try_from(v2) {
+ if n1 == n2 {
+ continue;
}
}
-
- return true;
}
+
+ return true;
}
- }
+ },
(Addr::Con(h), Addr::Char(c)) | (Addr::Char(c), Addr::Con(h)) => {
match &self.heap[h] {
&HeapCellValue::Atom(ref name, _) if name.is_char() => {
iter.first_to_expire != Ordering::Equal
}
- pub(super)
- fn compare_term_test(&self, a1: &Addr, a2: &Addr) -> Option<Ordering> {
+ pub(super) fn compare_term_test(&self, a1: &Addr, a2: &Addr) -> Option<Ordering> {
let mut iter = self.zipped_acyclic_pre_order_iter(*a1, *a2);
while let Some((v1, v2)) = iter.next() {
unreachable!()
}
}
- Some(TermOrderCategory::Integer) => {
- match (v1, v2) {
- (
- Addr::Con(h1),
- Addr::Con(h2),
- ) => {
- if let Ok(n1) = Number::try_from(&self.heap[h1]) {
- if let Ok(n2) = Number::try_from(&self.heap[h2]) {
- if n1 != n2 {
- return Some(n1.cmp(&n2));
- }
- } else {
- unreachable!()
- }
- } else {
- unreachable!()
- }
- }
- (
- Addr::Con(h1),
- v2,
- ) => {
- if let Ok(n1) = Number::try_from(&self.heap[h1]) {
- if let Ok(n2) = Number::try_from(&HeapCellValue::Addr(v2)) {
- if n1 != n2 {
- return Some(n1.cmp(&n2));
- }
- } else {
- unreachable!()
+ Some(TermOrderCategory::Integer) => match (v1, v2) {
+ (Addr::Con(h1), Addr::Con(h2)) => {
+ if let Ok(n1) = Number::try_from(&self.heap[h1]) {
+ if let Ok(n2) = Number::try_from(&self.heap[h2]) {
+ if n1 != n2 {
+ return Some(n1.cmp(&n2));
}
} else {
unreachable!()
}
+ } else {
+ unreachable!()
}
- (
- v1,
- Addr::Con(h2),
- ) => {
- if let Ok(n1) = Number::try_from(&HeapCellValue::Addr(v1)) {
- if let Ok(n2) = Number::try_from(&self.heap[h2]) {
- if n1 != n2 {
- return Some(n1.cmp(&n2));
- }
- } else {
- unreachable!()
+ }
+ (Addr::Con(h1), v2) => {
+ if let Ok(n1) = Number::try_from(&self.heap[h1]) {
+ if let Ok(n2) = Number::try_from(&HeapCellValue::Addr(v2)) {
+ if n1 != n2 {
+ return Some(n1.cmp(&n2));
}
} else {
unreachable!()
}
+ } else {
+ unreachable!()
}
- (v1, v2) => {
- if let Ok(n1) = Number::try_from(&HeapCellValue::Addr(v1)) {
- if let Ok(n2) = Number::try_from(&HeapCellValue::Addr(v2)) {
- if n1 != n2 {
- return Some(n1.cmp(&n2));
- }
- } else {
- unreachable!()
+ }
+ (v1, Addr::Con(h2)) => {
+ if let Ok(n1) = Number::try_from(&HeapCellValue::Addr(v1)) {
+ if let Ok(n2) = Number::try_from(&self.heap[h2]) {
+ if n1 != n2 {
+ return Some(n1.cmp(&n2));
}
} else {
unreachable!()
}
+ } else {
+ unreachable!()
}
}
- }
- Some(TermOrderCategory::Atom) => {
- match (v1, v2) {
- (
- Addr::Con(h1),
- Addr::Con(h2),
- ) => {
- if let HeapCellValue::Atom(ref n1, _) = &self.heap[h1] {
- if let HeapCellValue::Atom(ref n2, _) = &self.heap[h2] {
- if n1 != n2 {
- return Some(n1.cmp(&n2));
- }
- } else {
- unreachable!()
+ (v1, v2) => {
+ if let Ok(n1) = Number::try_from(&HeapCellValue::Addr(v1)) {
+ if let Ok(n2) = Number::try_from(&HeapCellValue::Addr(v2)) {
+ if n1 != n2 {
+ return Some(n1.cmp(&n2));
}
} else {
unreachable!()
}
+ } else {
+ unreachable!()
}
- (
- Addr::Con(h1),
- Addr::Char(c),
- ) => {
- if let HeapCellValue::Atom(ref n1, _) = &self.heap[h1] {
- if n1.is_char() {
- if n1.as_str().chars().next() != Some(c) {
- return Some(n1.as_str().chars().next().cmp(&Some(c)));
- }
- } else {
- return Some(Ordering::Greater);
+ }
+ },
+ Some(TermOrderCategory::Atom) => match (v1, v2) {
+ (Addr::Con(h1), Addr::Con(h2)) => {
+ if let HeapCellValue::Atom(ref n1, _) = &self.heap[h1] {
+ if let HeapCellValue::Atom(ref n2, _) = &self.heap[h2] {
+ if n1 != n2 {
+ return Some(n1.cmp(&n2));
}
} else {
unreachable!()
}
+ } else {
+ unreachable!()
}
- (
- Addr::Char(c),
- Addr::Con(h1),
- ) => {
- if let HeapCellValue::Atom(ref n1, _) = &self.heap[h1] {
- if n1.is_char() {
- if n1.as_str().chars().next() != Some(c) {
- return Some(Some(c).cmp(&n1.as_str().chars().next()));
- }
- } else {
- return Some(Ordering::Less);
+ }
+ (Addr::Con(h1), Addr::Char(c)) => {
+ if let HeapCellValue::Atom(ref n1, _) = &self.heap[h1] {
+ if n1.is_char() {
+ if n1.as_str().chars().next() != Some(c) {
+ return Some(n1.as_str().chars().next().cmp(&Some(c)));
}
} else {
- unreachable!()
+ return Some(Ordering::Greater);
}
+ } else {
+ unreachable!()
}
- (
- Addr::EmptyList,
- Addr::Con(h),
- ) => {
- if let HeapCellValue::Atom(ref n1, _) = &self.heap[h] {
- if "[]" != n1.as_str() {
- return Some("[]".cmp(n1.as_str()));
+ }
+ (Addr::Char(c), Addr::Con(h1)) => {
+ if let HeapCellValue::Atom(ref n1, _) = &self.heap[h1] {
+ if n1.is_char() {
+ if n1.as_str().chars().next() != Some(c) {
+ return Some(Some(c).cmp(&n1.as_str().chars().next()));
}
} else {
- unreachable!()
+ return Some(Ordering::Less);
}
+ } else {
+ unreachable!()
}
- (
- Addr::Con(h),
- Addr::EmptyList,
- ) => {
- if let HeapCellValue::Atom(ref n1, _) = &self.heap[h] {
- if "[]" != n1.as_str() {
- return Some(n1.as_str().cmp("[]"));
- }
- } else {
- unreachable!()
+ }
+ (Addr::EmptyList, Addr::Con(h)) => {
+ if let HeapCellValue::Atom(ref n1, _) = &self.heap[h] {
+ if "[]" != n1.as_str() {
+ return Some("[]".cmp(n1.as_str()));
}
+ } else {
+ unreachable!()
}
- (
- Addr::Char(c1),
- Addr::Char(c2),
- ) => {
- if c1 != c2 {
- return Some(c1.cmp(&c2));
+ }
+ (Addr::Con(h), Addr::EmptyList) => {
+ if let HeapCellValue::Atom(ref n1, _) = &self.heap[h] {
+ if "[]" != n1.as_str() {
+ return Some(n1.as_str().cmp("[]"));
}
- }
- (
- Addr::Char(c),
- Addr::EmptyList,
- ) => {
- return if c == '[' {
- Some(Ordering::Less)
- } else {
- Some(c.cmp(&'['))
- };
- }
- (
- Addr::EmptyList,
- Addr::Char(c),
- ) => {
- return if c == '[' {
- Some(Ordering::Greater)
- } else {
- Some('['.cmp(&c))
- };
- }
- (
- Addr::EmptyList,
- Addr::EmptyList,
- ) => {
- }
- _ => {
- return None;
+ } else {
+ unreachable!()
}
}
- }
- Some(TermOrderCategory::Compound) => {
- match (v1, v2) {
- (
- Addr::Lis(_),
- Addr::Lis(_),
- ) => {
+ (Addr::Char(c1), Addr::Char(c2)) => {
+ if c1 != c2 {
+ return Some(c1.cmp(&c2));
}
- (
- pstr1 @ Addr::PStrLocation(..),
- pstr2 @ Addr::PStrLocation(..),
- ) => {
- let mut i1 = self.heap_pstr_iter(pstr1);
- let mut i2 = self.heap_pstr_iter(pstr2);
+ }
+ (Addr::Char(c), Addr::EmptyList) => {
+ return if c == '[' {
+ Some(Ordering::Less)
+ } else {
+ Some(c.cmp(&'['))
+ };
+ }
+ (Addr::EmptyList, Addr::Char(c)) => {
+ return if c == '[' {
+ Some(Ordering::Greater)
+ } else {
+ Some('['.cmp(&c))
+ };
+ }
+ (Addr::EmptyList, Addr::EmptyList) => {}
+ _ => {
+ return None;
+ }
+ },
+ Some(TermOrderCategory::Compound) => match (v1, v2) {
+ (Addr::Lis(_), Addr::Lis(_)) => {}
+ (pstr1 @ Addr::PStrLocation(..), pstr2 @ Addr::PStrLocation(..)) => {
+ let mut i1 = self.heap_pstr_iter(pstr1);
+ let mut i2 = self.heap_pstr_iter(pstr2);
- let ordering = compare_pstr_prefixes(&mut i1, &mut i2);
+ let ordering = compare_pstr_prefixes(&mut i1, &mut i2);
- if let Some(ordering) = ordering {
- if ordering != Ordering::Equal {
- return Some(ordering);
- }
- } else {
- let (lstack, rstack) = iter.stack();
+ if let Some(ordering) = ordering {
+ if ordering != Ordering::Equal {
+ return Some(ordering);
+ }
+ } else {
+ let (lstack, rstack) = iter.stack();
- lstack.pop();
- lstack.pop();
+ lstack.pop();
+ lstack.pop();
- rstack.pop();
- rstack.pop();
+ rstack.pop();
+ rstack.pop();
- lstack.push(i1.focus());
- rstack.push(i2.focus());
- }
+ lstack.push(i1.focus());
+ rstack.push(i2.focus());
}
- (
- Addr::Str(h1),
- Addr::Str(h2),
- ) => {
- if let HeapCellValue::NamedStr(a1, ref n1, _) = &self.heap[h1] {
- if let HeapCellValue::NamedStr(a2, ref n2, _) = &self.heap[h2] {
- if a1 != a2 || n1.as_str() != n2.as_str() {
- return Some(a1.cmp(&a2).then_with(|| n1.as_str().cmp(n2.as_str())));
- }
- } else {
- unreachable!()
+ }
+ (Addr::Str(h1), Addr::Str(h2)) => {
+ if let HeapCellValue::NamedStr(a1, ref n1, _) = &self.heap[h1] {
+ if let HeapCellValue::NamedStr(a2, ref n2, _) = &self.heap[h2] {
+ if a1 != a2 || n1.as_str() != n2.as_str() {
+ return Some(
+ a1.cmp(&a2).then_with(|| n1.as_str().cmp(n2.as_str())),
+ );
}
} else {
unreachable!()
}
+ } else {
+ unreachable!()
}
- (
- Addr::Lis(_),
- Addr::PStrLocation(..),
- ) |
- (
- Addr::PStrLocation(..),
- Addr::Lis(_),
- ) => {
- }
- (
- Addr::Lis(_),
- Addr::Str(s),
- ) => {
- if let &HeapCellValue::NamedStr(a1, ref n1, _) = &self.heap[s] {
- if a1 != 2 || n1.as_str() != "." {
- return Some(a1.cmp(&2).then_with(|| n1.as_str().cmp(".")));
- }
- } else {
- unreachable!()
+ }
+ (Addr::Lis(_), Addr::PStrLocation(..))
+ | (Addr::PStrLocation(..), Addr::Lis(_)) => {}
+ (Addr::Lis(_), Addr::Str(s)) => {
+ if let &HeapCellValue::NamedStr(a1, ref n1, _) = &self.heap[s] {
+ if a1 != 2 || n1.as_str() != "." {
+ return Some(a1.cmp(&2).then_with(|| n1.as_str().cmp(".")));
}
+ } else {
+ unreachable!()
}
- (
- Addr::Str(s),
- Addr::Lis(_),
- ) => {
- if let &HeapCellValue::NamedStr(a1, ref n1, _) = &self.heap[s] {
- if a1 != 2 || n1.as_str() != "." {
- return Some(2.cmp(&a1).then_with(|| ".".cmp(n1.as_str())));
- }
- } else {
- unreachable!()
+ }
+ (Addr::Str(s), Addr::Lis(_)) => {
+ if let &HeapCellValue::NamedStr(a1, ref n1, _) = &self.heap[s] {
+ if a1 != 2 || n1.as_str() != "." {
+ return Some(2.cmp(&a1).then_with(|| ".".cmp(n1.as_str())));
}
+ } else {
+ unreachable!()
}
- (
- Addr::PStrLocation(..),
- Addr::Str(s),
- ) => {
- if let &HeapCellValue::NamedStr(a1, ref n1, _) = &self.heap[s] {
- if a1 != 2 || n1.as_str() != "." {
- return Some(a1.cmp(&2).then_with(|| n1.as_str().cmp(".")));
- }
- } else {
- unreachable!()
+ }
+ (Addr::PStrLocation(..), Addr::Str(s)) => {
+ if let &HeapCellValue::NamedStr(a1, ref n1, _) = &self.heap[s] {
+ if a1 != 2 || n1.as_str() != "." {
+ return Some(a1.cmp(&2).then_with(|| n1.as_str().cmp(".")));
}
+ } else {
+ unreachable!()
}
- (
- Addr::Str(s),
- Addr::PStrLocation(..),
- ) => {
- if let &HeapCellValue::NamedStr(a1, ref n1, _) = &self.heap[s] {
- if a1 != 2 || n1.as_str() != "." {
- return Some(2.cmp(&a1).then_with(|| ".".cmp(n1.as_str())));
- }
- } else {
- unreachable!()
+ }
+ (Addr::Str(s), Addr::PStrLocation(..)) => {
+ if let &HeapCellValue::NamedStr(a1, ref n1, _) = &self.heap[s] {
+ if a1 != 2 || n1.as_str() != "." {
+ return Some(2.cmp(&a1).then_with(|| ".".cmp(n1.as_str())));
}
- }
- _ => {
- return None;
+ } else {
+ unreachable!()
}
}
- }
+ _ => {
+ return None;
+ }
+ },
None => {
return None;
}
Some(iter.first_to_expire)
}
- pub(super)
- fn reset_block(&mut self, addr: Addr) {
+ pub(super) fn reset_block(&mut self, addr: Addr) {
match self.store(addr) {
Addr::Usize(b) => self.block = b,
_ => self.fail = true,
};
}
- pub(super)
- fn execute_inlined(&mut self, inlined: &InlinedClauseType) {
+ pub(super) fn execute_inlined(&mut self, inlined: &InlinedClauseType) {
match inlined {
&InlinedClauseType::CompareNumber(cmp, ref at_1, ref at_2) => {
let n1 = try_or_fail!(self, self.get_number(at_1));
let d = self.store(self.deref(self[r1]));
match d {
- Addr::Con(h) =>
+ Addr::Con(h) => {
if let HeapCellValue::Atom(..) = &self.heap[h] {
self.p += 1;
} else {
self.fail = true;
- },
+ }
+ }
Addr::Char(_) => self.p += 1,
Addr::EmptyList => self.p += 1,
_ => self.fail = true,
let d = self.store(self.deref(self[r1]));
match d {
- Addr::Char(_) |
- Addr::Con(_) |
- Addr::EmptyList |
- Addr::Fixnum(_) |
- Addr::Float(_) |
- Addr::Usize(_) => self.p += 1,
+ Addr::Char(_)
+ | Addr::Con(_)
+ | Addr::EmptyList
+ | Addr::Fixnum(_)
+ | Addr::Float(_)
+ | Addr::Usize(_) => self.p += 1,
_ => self.fail = true,
};
}
_ => self.fail = true,
};
}
- &InlinedClauseType::IsNumber(r1) => {
- match self.store(self.deref(self[r1])) {
- Addr::Float(_) => self.p += 1,
- d => match Number::try_from((d, &self.heap)) {
- Ok(Number::Fixnum(_)) => {
- self.p += 1;
- }
- Ok(Number::Integer(_)) => {
+ &InlinedClauseType::IsNumber(r1) => match self.store(self.deref(self[r1])) {
+ Addr::Float(_) => self.p += 1,
+ d => match Number::try_from((d, &self.heap)) {
+ Ok(Number::Fixnum(_)) => {
+ self.p += 1;
+ }
+ Ok(Number::Integer(_)) => {
+ self.p += 1;
+ }
+ Ok(Number::Rational(n)) => {
+ if n.denom() == &1 {
self.p += 1;
- }
- Ok(Number::Rational(n)) => {
- if n.denom() == &1 {
- self.p += 1;
- } else {
- self.fail = true;
- }
- }
- _ => {
+ } else {
self.fail = true;
}
}
- }
- }
+ _ => {
+ self.fail = true;
+ }
+ },
+ },
&InlinedClauseType::IsRational(r1) => {
let d = self.store(self.deref(self[r1]));
self.try_functor_unify_components(name, arity);
}
- fn try_functor_unify_components(
- &mut self,
- name: Addr,
- arity: usize,
- ) {
+ fn try_functor_unify_components(&mut self, name: Addr, arity: usize) {
let a2 = self[temp_v!(2)];
let a3 = self[temp_v!(3)];
let f_a = if name.as_str() == "." && arity == 2 {
Addr::Lis(self.heap.h())
} else {
- self.heap.to_unifiable(HeapCellValue::NamedStr(arity, name, spec))
+ self.heap
+ .to_unifiable(HeapCellValue::NamedStr(arity, name, spec))
};
let h = self.heap.h();
- for i in 0 .. arity {
+ for i in 0..arity {
self.heap.push(HeapCellValue::Addr(Addr::HeapCell(h + i)));
}
self.bind(r, f_a);
}
- pub(super)
- fn try_functor(&mut self, op_dir: &OpDir) -> CallResult {
+ pub(super) fn try_functor(&mut self, op_dir: &OpDir) -> CallResult {
let stub = MachineError::functor_stub(clause_name!("functor"), 3);
let a1 = self.store(self.deref(self[temp_v!(1)]));
Addr::Stream(_) => {
self.fail = true;
}
- Addr::Char(_) | Addr::Con(_) | Addr::Fixnum(_) |
- Addr::Float(_) | Addr::EmptyList | Addr::Usize(_) => {
+ Addr::Char(_)
+ | Addr::Con(_)
+ | Addr::Fixnum(_)
+ | Addr::Float(_)
+ | Addr::EmptyList
+ | Addr::Usize(_) => {
self.try_functor_unify_components(a1, 0);
}
Addr::Str(o) => match self.heap.clone(o) {
HeapCellValue::NamedStr(arity, name, spec) => {
- let spec = fetch_op_spec_from_existing(
- name.clone(),
- arity,
- spec,
- &op_dir,
- );
+ let spec = fetch_op_spec_from_existing(name.clone(), arity, spec, &op_dir);
self.try_functor_compound_case(name, arity, spec)
}
}
},
Addr::Lis(_) | Addr::PStrLocation(..) => {
- let spec = fetch_op_spec_from_existing(
- clause_name!("."),
- 2,
- None,
- &op_dir,
- );
+ let spec = fetch_op_spec_from_existing(clause_name!("."), 2, None, &op_dir);
self.try_functor_compound_case(clause_name!("."), 2, spec)
}
Addr::AttrVar(..) | Addr::HeapCell(_) | Addr::StackCell(..) => {
- let name = self.store(self.deref(self[temp_v!(2)]));
+ let name = self.store(self.deref(self[temp_v!(2)]));
let arity = self.store(self.deref(self[temp_v!(3)]));
if name.is_ref() || arity.is_ref() {
return Err(self.error_form(MachineError::instantiation_error(), stub));
}
- let arity =
- match Number::try_from((arity, &self.heap)) {
- Ok(Number::Fixnum(n)) => Some(n),
- Ok(Number::Integer(n)) => n.to_isize(),
- Ok(Number::Rational(n))
- if n.denom() == &1 => {
- n.numer().to_isize()
- },
- _ =>
- match arity {
- arity => {
- return Err(
- self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- arity,
- ),
- stub,
- )
- );
- }
- }
- };
+ let arity = match Number::try_from((arity, &self.heap)) {
+ Ok(Number::Fixnum(n)) => Some(n),
+ Ok(Number::Integer(n)) => n.to_isize(),
+ Ok(Number::Rational(n)) if n.denom() == &1 => n.numer().to_isize(),
+ _ => match arity {
+ arity => {
+ return Err(self.error_form(
+ MachineError::type_error(self.heap.h(), ValidType::Integer, arity),
+ stub,
+ ));
+ }
+ },
+ };
let arity = match arity {
- Some(arity) => {
- arity
- }
+ Some(arity) => arity,
None => {
self.fail = true;
return Ok(());
} else if arity < 0 {
// 8.5.1.3 g)
let arity = Number::Integer(Rc::new(Integer::from(arity)));
- let dom_err = MachineError::domain_error(
- DomainErrorType::NotLessThanZero,
- arity,
- );
+ let dom_err =
+ MachineError::domain_error(DomainErrorType::NotLessThanZero, arity);
return Err(self.error_form(dom_err, stub));
}
match name {
- Addr::Char(_) | Addr::Con(_) | Addr::Fixnum(_) | Addr::Float(_) |
- Addr::EmptyList | Addr::PStrLocation(..) | Addr::Usize(_) if arity == 0 => {
+ Addr::Char(_)
+ | Addr::Con(_)
+ | Addr::Fixnum(_)
+ | Addr::Float(_)
+ | Addr::EmptyList
+ | Addr::PStrLocation(..)
+ | Addr::Usize(_)
+ if arity == 0 =>
+ {
self.unify(a1, name);
}
Addr::Con(h) => {
} else {
// 8.5.1.3 e)
return Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Atom,
- name,
- ),
+ MachineError::type_error(self.heap.h(), ValidType::Atom, name),
stub,
- ))
+ ));
}
}
Addr::Char(c) => {
Ok(())
}
- pub(super)
- fn term_dedup(&self, list: &mut Vec<Addr>) {
+ pub(super) fn term_dedup(&self, list: &mut Vec<Addr>) {
let mut result = vec![];
for a2 in list.iter() {
*list = result;
}
-
- pub(super)
- fn integers_to_bytevec(
- &self,
- r: RegType,
- caller: MachineStub,
- ) -> Vec<u8> {
-
+ pub(super) fn integers_to_bytevec(&self, r: RegType, caller: MachineStub) -> Vec<u8> {
let mut bytes: Vec<u8> = Vec::new();
match self.try_from_list(r, caller) {
- Err(_) => { unreachable!() }
+ Err(_) => {
+ unreachable!()
+ }
Ok(addrs) => {
-
for addr in addrs {
let addr = self.store(self.deref(addr));
Ok(b) => {
bytes.push(b);
}
- Err(_) => { }
+ Err(_) => {}
}
continue;
}
Ok(Number::Integer(n)) => {
if let Some(b) = n.to_u8() {
- bytes.push(b);
+ bytes.push(b);
}
continue;
}
- _ => {
- }
+ _ => {}
}
}
}
bytes
}
-
- pub(super)
- fn try_from_list(
+ pub(super) fn try_from_list(
&self,
r: RegType,
caller: MachineStub,
let a1 = self.store(self.deref(self[r]));
match a1 {
- Addr::Lis(l) => {
- self.try_from_inner_list(vec![], l, caller, a1)
- }
- Addr::PStrLocation(h, n) => {
- self.try_from_partial_string(vec![], h, n, caller, a1)
- }
+ Addr::Lis(l) => self.try_from_inner_list(vec![], l, caller, a1),
+ Addr::PStrLocation(h, n) => self.try_from_partial_string(vec![], h, n, caller, a1),
Addr::AttrVar(_) | Addr::HeapCell(_) | Addr::StackCell(..) => {
Err(self.error_form(MachineError::instantiation_error(), caller))
}
- Addr::EmptyList => {
- Ok(vec![])
- }
- _ => {
- Err(self.error_form(
- MachineError::type_error(self.heap.h(), ValidType::List, a1),
- caller,
- ))
- }
+ Addr::EmptyList => Ok(vec![]),
+ _ => Err(self.error_form(
+ MachineError::type_error(self.heap.h(), ValidType::List, a1),
+ caller,
+ )),
}
}
loop {
match &self.heap[l] {
- HeapCellValue::Addr(ref addr) =>
- match self.store(self.deref(*addr)) {
- Addr::Lis(hcp) => {
- result.push(self.heap[hcp].as_addr(hcp));
- l = hcp + 1;
- }
- Addr::PStrLocation(h, n) => {
- return self.try_from_partial_string(result, h, n, caller, a1);
- }
- Addr::EmptyList => {
- break;
- }
- Addr::AttrVar(_) | Addr::HeapCell(_) | Addr::StackCell(..) => {
- return Err(self.error_form(
- MachineError::instantiation_error(),
- caller,
- ))
- }
- _ => {
- return Err(self.error_form(
- MachineError::type_error(self.heap.h(), ValidType::List, a1),
- caller,
- ))
- }
- },
+ HeapCellValue::Addr(ref addr) => match self.store(self.deref(*addr)) {
+ Addr::Lis(hcp) => {
+ result.push(self.heap[hcp].as_addr(hcp));
+ l = hcp + 1;
+ }
+ Addr::PStrLocation(h, n) => {
+ return self.try_from_partial_string(result, h, n, caller, a1);
+ }
+ Addr::EmptyList => {
+ break;
+ }
+ Addr::AttrVar(_) | Addr::HeapCell(_) | Addr::StackCell(..) => {
+ return Err(self.error_form(MachineError::instantiation_error(), caller))
+ }
+ _ => {
+ return Err(self.error_form(
+ MachineError::type_error(self.heap.h(), ValidType::List, a1),
+ caller,
+ ))
+ }
+ },
_ => {
return Err(self.error_form(
MachineError::type_error(self.heap.h(), ValidType::List, a1),
) -> Result<Vec<Addr>, MachineStub> {
loop {
if let &HeapCellValue::PartialString(ref pstr, has_tail) = &self.heap[h] {
- chars.extend(pstr.range_from(n ..).map(Addr::Char));
+ chars.extend(pstr.range_from(n..).map(Addr::Char));
if !has_tail {
return Ok(chars);
Addr::HeapCell(_) | Addr::StackCell(..) => {
Err(self.error_form(MachineError::instantiation_error(), stub))
}
- Addr::Str(s) => {
- match self.heap.clone(s) {
- HeapCellValue::NamedStr(2, ref name, Some(_))
- if *name == clause_name!("-") => {
- Ok(Addr::HeapCell(s + 1))
- }
- _ => {
- Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Pair,
- self.heap[s].as_addr(s),
- ),
- stub,
- ))
- }
+ Addr::Str(s) => match self.heap.clone(s) {
+ HeapCellValue::NamedStr(2, ref name, Some(_)) if *name == clause_name!("-") => {
+ Ok(Addr::HeapCell(s + 1))
}
- }
- a => {
- Err(self.error_form(
+ _ => Err(self.error_form(
MachineError::type_error(
self.heap.h(),
ValidType::Pair,
- a,
+ self.heap[s].as_addr(s),
),
stub,
- ))
- }
+ )),
+ },
+ a => Err(self.error_form(
+ MachineError::type_error(self.heap.h(), ValidType::Pair, a),
+ stub,
+ )),
}
}
- pub(super)
- fn copy_term(&mut self, attr_var_policy: AttrVarPolicy) {
+ pub(super) fn copy_term(&mut self, attr_var_policy: AttrVarPolicy) {
let old_h = self.heap.h();
let a1 = self[temp_v!(1)];
}
// returns true on failure.
- pub(super)
- fn structural_eq_test(&self) -> bool {
+ pub(super) fn structural_eq_test(&self) -> bool {
let a1 = self[temp_v!(1)];
let a2 = self[temp_v!(2)];
| (
HeapCellValue::Addr(Addr::PStrLocation(..)),
HeapCellValue::Addr(Addr::Lis(_)),
- ) => {
- }
- (
- HeapCellValue::NamedStr(ar1, n1, _),
- HeapCellValue::NamedStr(ar2, n2, _),
- ) => {
+ ) => {}
+ (HeapCellValue::NamedStr(ar1, n1, _), HeapCellValue::NamedStr(ar2, n2, _)) => {
if ar1 != ar2 || n1 != n2 {
return true;
}
}
- (
- HeapCellValue::Addr(Addr::Lis(_)),
- HeapCellValue::Addr(Addr::Lis(_)),
- ) => {
- }
+ (HeapCellValue::Addr(Addr::Lis(_)), HeapCellValue::Addr(Addr::Lis(_))) => {}
(
&HeapCellValue::Addr(v1 @ Addr::HeapCell(_)),
&HeapCellValue::Addr(v2 @ Addr::AttrVar(_)),
| (
&HeapCellValue::Addr(v1 @ Addr::StackCell(..)),
&HeapCellValue::Addr(v2 @ Addr::HeapCell(_)),
- ) =>
- match (var_pairs.get(&v1), var_pairs.get(&v2)) {
- (Some(ref v2_p), Some(ref v1_p)) if **v1_p == v1 && **v2_p == v2 => {
- continue;
- }
- (Some(_), _) | (_, Some(_)) => {
- return true;
- }
- (None, None) => {
- var_pairs.insert(v1, v2);
- var_pairs.insert(v2, v1);
- }
- },
+ ) => match (var_pairs.get(&v1), var_pairs.get(&v2)) {
+ (Some(ref v2_p), Some(ref v1_p)) if **v1_p == v1 && **v2_p == v2 => {
+ continue;
+ }
+ (Some(_), _) | (_, Some(_)) => {
+ return true;
+ }
+ (None, None) => {
+ var_pairs.insert(v1, v2);
+ var_pairs.insert(v2, v1);
+ }
+ },
(
HeapCellValue::PartialString(ref pstr1, has_tail_1),
HeapCellValue::PartialString(ref pstr2, has_tail_2),
return true;
}
- let pstr1_iter = pstr1.range_from(0 ..);
- let pstr2_iter = pstr2.range_from(0 ..);
+ let pstr1_iter = pstr1.range_from(0..);
+ let pstr2_iter = pstr2.range_from(0..);
for (c1, c2) in pstr1_iter.zip(pstr2_iter) {
if c1 != c2 {
(
HeapCellValue::Addr(Addr::PStrLocation(..)),
HeapCellValue::Addr(Addr::PStrLocation(..)),
- ) => {
- }
+ ) => {}
(
HeapCellValue::Atom(ref n1, ref spec_1),
HeapCellValue::Atom(ref n2, ref spec_2),
return true;
}
}
- (
- HeapCellValue::DBRef(ref db_ref_1),
- HeapCellValue::DBRef(ref db_ref_2),
- ) => {
+ (HeapCellValue::DBRef(ref db_ref_1), HeapCellValue::DBRef(ref db_ref_2)) => {
if db_ref_1 != db_ref_2 {
return true;
}
}
- (
- v1,
- v2,
- ) => {
+ (v1, v2) => {
if let Ok(n1) = Number::try_from(v1) {
if let Ok(n2) = Number::try_from(v2) {
if n1 != n2 {
}
match (v1, v2) {
- (
- HeapCellValue::Addr(a1),
- HeapCellValue::Addr(a2),
- ) => {
+ (HeapCellValue::Addr(a1), HeapCellValue::Addr(a2)) => {
if a1 != a2 {
return true;
}
}
// returns true on failure.
- pub(super)
- fn ground_test(&self) -> bool {
+ pub(super) fn ground_test(&self) -> bool {
let a = self.store(self.deref(self[temp_v!(1)]));
for v in self.acyclic_pre_order_iter(a) {
false
}
- pub(super)
- fn setup_built_in_call(&mut self, ct: BuiltInClauseType) {
+ pub(super) fn setup_built_in_call(&mut self, ct: BuiltInClauseType) {
self.num_of_args = ct.arity();
self.b0 = self.b;
self.p = CodePtr::BuiltInClause(ct, self.p.local());
}
- pub(super)
- fn allocate(&mut self, num_cells: usize) {
+ pub(super) fn allocate(&mut self, num_cells: usize) {
let e = self.stack.allocate_and_frame(num_cells);
let and_frame = self.stack.index_and_frame_mut(e);
- and_frame.prelude.e = self.e;
+ and_frame.prelude.e = self.e;
and_frame.prelude.cp = self.cp;
self.e = e;
self.p += 1;
}
- pub(super)
- fn deallocate(&mut self) {
+ pub(super) fn deallocate(&mut self) {
let e = self.e;
let frame = self.stack.index_and_frame(e);
self.cp = frame.prelude.cp;
- self.e = frame.prelude.e;
+ self.e = frame.prelude.e;
if e > self.b {
self.stack.truncate(e);
lco: bool,
use_default_cp: bool,
) {
- let interrupted = INTERRUPT.load(std::sync::atomic::Ordering::Relaxed);
-
- match INTERRUPT.compare_exchange(interrupted, false, std::sync::atomic::Ordering::Relaxed, std::sync::atomic::Ordering::Relaxed) {
+ let interrupted = INTERRUPT.load(std::sync::atomic::Ordering::Relaxed);
+
+ match INTERRUPT.compare_exchange(
+ interrupted,
+ false,
+ std::sync::atomic::Ordering::Relaxed,
+ std::sync::atomic::Ordering::Relaxed,
+ ) {
Ok(interruption) => {
if interruption {
self.throw_interrupt_exception();
return;
}
- },
- Err(_) => unreachable!()
- }
+ }
+ Err(_) => unreachable!(),
+ }
let mut default_call_policy: Box<dyn CallPolicy> = Box::new(DefaultCallPolicy {});
self.last_call = false;
}
- pub(super)
- fn execute_ctrl_instr(
+ pub(super) fn execute_ctrl_instr(
&mut self,
indices: &mut IndexStore,
code_repo: &CodeRepo,
or_frame.prelude.b = self.b;
or_frame.prelude.bp = self.p.local() + 1;
or_frame.prelude.tr = self.tr;
- or_frame.prelude.h = self.heap.h();
+ or_frame.prelude.h = self.heap.h();
or_frame.prelude.b0 = self.b0;
- or_frame.prelude.attr_var_init_queue_b =
- self.attr_var_init.attr_var_queue.len();
- or_frame.prelude.attr_var_init_bindings_b =
- self.attr_var_init.bindings.len();
+ or_frame.prelude.attr_var_init_queue_b = self.attr_var_init.attr_var_queue.len();
+ or_frame.prelude.attr_var_init_bindings_b = self.attr_var_init.bindings.len();
self.b = b;
- for i in 1 .. n + 1 {
- self.stack.index_or_frame_mut(b)[i-1] = self.registers[i];
+ for i in 1..n + 1 {
+ self.stack.index_or_frame_mut(b)[i - 1] = self.registers[i];
}
self.hb = self.heap.h();
};
}
- pub(super)
- fn execute_choice_instr(
+ pub(super) fn execute_choice_instr(
&mut self,
instr: &ChoiceInstruction,
call_policy: &mut Box<dyn CallPolicy>,
or_frame.prelude.b = self.b;
or_frame.prelude.bp = self.p.local() + offset;
or_frame.prelude.tr = self.tr;
- or_frame.prelude.h = self.heap.h();
+ or_frame.prelude.h = self.heap.h();
or_frame.prelude.b0 = self.b0;
- or_frame.prelude.attr_var_init_queue_b =
- self.attr_var_init.attr_var_queue.len();
- or_frame.prelude.attr_var_init_bindings_b =
- self.attr_var_init.attr_var_queue.len();
+ or_frame.prelude.attr_var_init_queue_b = self.attr_var_init.attr_var_queue.len();
+ or_frame.prelude.attr_var_init_bindings_b = self.attr_var_init.attr_var_queue.len();
self.b = b;
- for i in 1 .. n + 1 {
- self.stack.index_or_frame_mut(b)[i-1] = self.registers[i];
+ for i in 1..n + 1 {
+ self.stack.index_or_frame_mut(b)[i - 1] = self.registers[i];
}
self.hb = self.heap.h();
use crate::prolog_parser_rebis::ast::*;
use crate::prolog_parser_rebis::tabled_rc::*;
+use crate::prolog_parser_rebis::{clause_name, temp_v};
+
+use crate::lazy_static::lazy_static;
use crate::clause_types::*;
use crate::forms::*;
mod system_calls;
//use crate::machine::attributed_variables::*;
-use crate::machine::compile::*;
use crate::machine::code_repo::*;
+use crate::machine::compile::*;
// use crate::machine::loader::*;
use crate::machine::machine_errors::*;
use crate::machine::machine_indices::*;
use crate::indexmap::IndexMap;
//use std::convert::TryFrom;
+use prolog_parser_rebis::ast::ClauseName;
use std::fs::File;
use std::mem;
use std::path::PathBuf;
}
fn load_file(&mut self, path: String, stream: Stream) {
- self.machine_st[temp_v!(1)] = Addr::Stream(
- self.machine_st.heap.push(HeapCellValue::Stream(
- stream,
- ))
- );
+ self.machine_st[temp_v!(1)] =
+ Addr::Stream(self.machine_st.heap.push(HeapCellValue::Stream(stream)));
- self.machine_st[temp_v!(2)] = Addr::Con(
- self.machine_st.heap.push(HeapCellValue::Atom(
- clause_name!(path, self.machine_st.atom_tbl),
- None,
- ))
- );
+ self.machine_st[temp_v!(2)] = Addr::Con(self.machine_st.heap.push(HeapCellValue::Atom(
+ clause_name!(path, self.machine_st.atom_tbl),
+ None,
+ )));
self.run_module_predicate(clause_name!("loader"), (clause_name!("file_load"), 2));
}
bootstrapping_compile(
Stream::from(include_str!("attributed_variables.pl")),
self,
- ListingSource::from_file_and_path(
- clause_name!("attributed_variables"),
- path_buf,
- ),
- ).unwrap();
+ ListingSource::from_file_and_path(clause_name!("attributed_variables"), path_buf),
+ )
+ .unwrap();
let mut path_buf = current_dir();
path_buf.push("machine/project_attributes.pl");
bootstrapping_compile(
Stream::from(include_str!("project_attributes.pl")),
self,
- ListingSource::from_file_and_path(
- clause_name!("project_attributes"),
- path_buf,
- ),
- ).unwrap();
+ ListingSource::from_file_and_path(clause_name!("project_attributes"), path_buf),
+ )
+ .unwrap();
if let Some(module) = self.indices.modules.get(&clause_name!("$atts")) {
if let Some(code_index) = module.code_dir.get(&(clause_name!("driver"), 2)) {
fn configure_modules(&mut self) {
fn update_call_n_indices(loader: &Module, target_module: &mut Module) {
- for arity in 1 .. 66 {
+ for arity in 1..66 {
let key = (clause_name!("call"), arity);
match loader.code_dir.get(&key) {
Some(src_code_index) => {
- let target_code_index = target_module.code_dir
+ let target_code_index = target_module
+ .code_dir
.entry(key.clone())
.or_insert_with(|| CodeIndex::new(IndexPtr::Undefined));
builtins.module_decl.exports.push(export.clone());
}
- for arity in 10 .. 66 {
- builtins.module_decl.exports.push(
- ModuleExport::PredicateKey((clause_name!("call"), arity)),
- );
+ for arity in 10..66 {
+ builtins
+ .module_decl
+ .exports
+ .push(ModuleExport::PredicateKey((clause_name!("call"), arity)));
}
}
}
}
- pub fn new(user_input: Stream, user_output: Stream) -> Self
- {
+ pub fn new(user_input: Stream, user_output: Stream) -> Self {
use crate::ref_thread_local::RefThreadLocal;
let mut wam = Machine {
clause_name!("ops_and_meta_predicates.pl"),
lib_path.clone(),
),
- ).unwrap();
+ )
+ .unwrap();
bootstrapping_compile(
Stream::from(LIBRARIES.borrow()["builtins"]),
&mut wam,
- ListingSource::from_file_and_path(
- clause_name!("builtins.pl"),
- lib_path.clone(),
- ),
- ).unwrap();
+ ListingSource::from_file_and_path(clause_name!("builtins.pl"), lib_path.clone()),
+ )
+ .unwrap();
if let Some(builtins) = wam.indices.modules.get(&clause_name!("builtins")) {
load_module(
bootstrapping_compile(
Stream::from(include_str!("../loader.pl")),
&mut wam,
- ListingSource::from_file_and_path(
- clause_name!("loader.pl"),
- lib_path.clone(),
- ),
- ).unwrap();
+ ListingSource::from_file_and_path(clause_name!("loader.pl"), lib_path.clone()),
+ )
+ .unwrap();
wam.configure_modules();
pub fn configure_streams(&mut self) {
self.user_input.options.alias = Some(clause_name!("user_input"));
- self.indices.stream_aliases.insert(
- clause_name!("user_input"),
- self.user_input.clone(),
- );
+ self.indices
+ .stream_aliases
+ .insert(clause_name!("user_input"), self.user_input.clone());
- self.indices.streams.insert(
- self.user_input.clone()
- );
+ self.indices.streams.insert(self.user_input.clone());
self.user_output.options.alias = Some(clause_name!("user_output"));
- self.indices.stream_aliases.insert(
- clause_name!("user_output"),
- self.user_output.clone(),
- );
+ self.indices
+ .stream_aliases
+ .insert(clause_name!("user_output"), self.user_output.clone());
- self.indices.streams.insert(
- self.user_output.clone()
- );
+ self.indices.streams.insert(self.user_output.clone());
}
fn throw_session_error(&mut self, err: SessionError, key: PredicateKey) {
self.machine_st.p = CodePtr::Local(p);
}
- pub(super)
- fn run_query(&mut self) {
+ pub(super) fn run_query(&mut self) {
while !self.machine_st.p.is_halt() {
self.machine_st.query_stepper(
&mut self.indices,
user_output: &mut Stream,
) {
match instr {
- &Line::Arithmetic(ref arith_instr) => {
- self.execute_arith_instr(arith_instr)
- }
+ &Line::Arithmetic(ref arith_instr) => self.execute_arith_instr(arith_instr),
&Line::Choice(ref choice_instr) => {
self.execute_choice_instr(choice_instr, &mut policies.call_policy)
}
&Line::Cut(ref cut_instr) => {
self.execute_cut_instr(cut_instr, &mut policies.cut_policy)
}
- &Line::Control(ref control_instr) => {
- self.execute_ctrl_instr(
- indices,
- code_repo,
- &mut policies.call_policy,
- &mut policies.cut_policy,
- user_input,
- user_output,
- control_instr,
- )
- }
+ &Line::Control(ref control_instr) => self.execute_ctrl_instr(
+ indices,
+ code_repo,
+ &mut policies.call_policy,
+ &mut policies.cut_policy,
+ user_input,
+ user_output,
+ control_instr,
+ ),
&Line::Fact(ref fact_instr) => {
self.execute_fact_instr(&fact_instr);
self.p += 1;
fn check_machine_index(&mut self, code_repo: &CodeRepo) -> bool {
match self.p {
- CodePtr::Local(LocalCodePtr::DirEntry(p)) |
- CodePtr::Local(LocalCodePtr::IndexingBuf(p, ..))
- if p < code_repo.code.len() => {
- }
+ CodePtr::Local(LocalCodePtr::DirEntry(p))
+ | CodePtr::Local(LocalCodePtr::IndexingBuf(p, ..))
+ if p < code_repo.code.len() => {}
CodePtr::Local(LocalCodePtr::Halt) | CodePtr::REPL(..) => {
return false;
}
- _ => {
- }
+ _ => {}
}
true
user_output: &mut Stream,
) {
loop {
- self.execute_instr(
- indices,
- policies,
- code_repo,
- user_input,
- user_output,
- );
+ self.execute_instr(indices, policies, code_repo, user_input, user_output);
if self.fail {
self.backtrack();
use crate::prolog_parser_rebis::ast::*;
use crate::prolog_parser_rebis::tabled_rc::*;
+use crate::prolog_parser_rebis::{atom, clause_name, rc_atom};
use crate::forms::*;
use crate::iterators::*;
-use crate::machine::*;
use crate::machine::load_state::*;
use crate::machine::machine_errors::*;
+use crate::machine::*;
use crate::indexmap::IndexSet;
to_op_decl(prec, spec.as_str(), name)
}
-fn setup_predicate_indicator(term: &mut Term) -> Result<PredicateKey, CompilationError>
-{
+fn setup_predicate_indicator(term: &mut Term) -> Result<PredicateKey, CompilationError> {
match term {
Term::Clause(_, ref slash, ref mut terms, Some(_))
if (slash.as_str() == "/" || slash.as_str() == "//") && terms.len() == 2 =>
{
let arity = *terms.pop().unwrap();
- let name = *terms.pop().unwrap();
+ let name = *terms.pop().unwrap();
let arity = arity
.to_constant()
- .and_then(|c| {
- match c {
- Constant::Integer(n) => n.to_usize(),
- Constant::Fixnum(n) => usize::try_from(n).ok(),
- _ => None
- }
+ .and_then(|c| match c {
+ Constant::Integer(n) => n.to_usize(),
+ Constant::Fixnum(n) => usize::try_from(n).ok(),
+ _ => None,
})
.ok_or(CompilationError::InvalidModuleExport)?;
- let name = name
+ let name = name
.to_constant()
.and_then(|c| c.to_atom())
.ok_or(CompilationError::InvalidModuleExport)?;
Ok((name, arity + 2))
}
}
- _ => {
- Err(CompilationError::InvalidModuleExport)
- }
+ _ => Err(CompilationError::InvalidModuleExport),
}
}
.or_else(|_| {
if let Term::Clause(_, name, terms, _) = term {
if terms.len() == 3 && name.as_str() == "op" {
- Ok(ModuleExport::OpDecl(setup_op_decl(
- terms,
- atom_tbl
- )?))
+ Ok(ModuleExport::OpDecl(setup_op_decl(terms, atom_tbl)?))
} else {
Err(CompilationError::InvalidModuleDecl)
}
})
}
-pub(super)
-fn setup_module_export_list(
+pub(super) fn setup_module_export_list(
mut export_list: Term,
atom_tbl: TabledData<Atom>,
) -> Result<Vec<ModuleExport>, CompilationError> {
.map(|c| ModuleSource::Library(c))
.ok_or(CompilationError::InvalidUseModuleDecl)
}
- Term::Constant(_, Constant::Atom(ref name, _)) =>
- Ok(ModuleSource::File(name.clone())),
+ Term::Constant(_, Constant::Atom(ref name, _)) => Ok(ModuleSource::File(name.clone())),
_ => Err(CompilationError::InvalidUseModuleDecl),
}
}
.map(|c| ModuleSource::Library(c))
.ok_or(CompilationError::InvalidUseModuleDecl)
}
- Term::Constant(_, Constant::Atom(ref name, _)) => {
- Ok(ModuleSource::File(name.clone()))
- }
- _ => {
- Err(CompilationError::InvalidUseModuleDecl)
- }
+ Term::Constant(_, Constant::Atom(ref name, _)) => Ok(ModuleSource::File(name.clone())),
+ _ => Err(CompilationError::InvalidUseModuleDecl),
}?;
let mut exports = IndexSet::new();
fn setup_meta_predicate<'a>(
mut terms: Vec<Box<Term>>,
load_state: &LoadState<'a>,
-) -> Result<(ClauseName, ClauseName, Vec<MetaSpec>), CompilationError>
-{
+) -> Result<(ClauseName, ClauseName, Vec<MetaSpec>), CompilationError> {
fn get_name_and_meta_specs(
name: ClauseName,
terms: &mut [Box<Term>],
for meta_spec in terms.into_iter() {
match &**meta_spec {
Term::Constant(_, Constant::Atom(meta_spec, _)) => {
- let meta_spec =
- match meta_spec.as_str() {
- "+" => MetaSpec::Plus,
- "-" => MetaSpec::Minus,
- "?" => MetaSpec::Either,
- _ => return Err(CompilationError::InvalidMetaPredicateDecl),
- };
+ let meta_spec = match meta_spec.as_str() {
+ "+" => MetaSpec::Plus,
+ "-" => MetaSpec::Minus,
+ "?" => MetaSpec::Either,
+ _ => return Err(CompilationError::InvalidMetaPredicateDecl),
+ };
meta_specs.push(meta_spec);
}
- Term::Constant(_, Constant::Fixnum(n)) => {
- match usize::try_from(*n) {
- Ok(n) if n <= MAX_ARITY => {
- meta_specs.push(MetaSpec::RequiresExpansionWithArgument(n));
- }
- _ => {
- return Err(CompilationError::InvalidMetaPredicateDecl);
- }
+ Term::Constant(_, Constant::Fixnum(n)) => match usize::try_from(*n) {
+ Ok(n) if n <= MAX_ARITY => {
+ meta_specs.push(MetaSpec::RequiresExpansionWithArgument(n));
}
- }
+ _ => {
+ return Err(CompilationError::InvalidMetaPredicateDecl);
+ }
+ },
_ => {
return Err(CompilationError::InvalidMetaPredicateDecl);
}
}
match *terms.pop().unwrap() {
- Term::Clause(_, name, mut terms, _)
- if name.as_str() == ":" && terms.len() == 2 => {
- let spec = *terms.pop().unwrap();
- let module_name = *terms.pop().unwrap();
-
- match module_name {
- Term::Constant(_, Constant::Atom(module_name, _)) => {
- match spec {
- Term::Clause(_, name, mut terms, _) => {
- let (name, meta_specs) =
- get_name_and_meta_specs(name, &mut terms)?;
-
- Ok((module_name, name, meta_specs))
- }
- _ => {
- Err(CompilationError::InvalidMetaPredicateDecl)
- }
- }
- }
- _ => {
- Err(CompilationError::InvalidMetaPredicateDecl)
+ Term::Clause(_, name, mut terms, _) if name.as_str() == ":" && terms.len() == 2 => {
+ let spec = *terms.pop().unwrap();
+ let module_name = *terms.pop().unwrap();
+
+ match module_name {
+ Term::Constant(_, Constant::Atom(module_name, _)) => match spec {
+ Term::Clause(_, name, mut terms, _) => {
+ let (name, meta_specs) = get_name_and_meta_specs(name, &mut terms)?;
+
+ Ok((module_name, name, meta_specs))
}
- }
+ _ => Err(CompilationError::InvalidMetaPredicateDecl),
+ },
+ _ => Err(CompilationError::InvalidMetaPredicateDecl),
}
+ }
Term::Clause(_, name, mut terms, _) => {
let (name, meta_specs) = get_name_and_meta_specs(name, &mut terms)?;
- Ok((load_state.compilation_target.module_name(), name, meta_specs))
- }
- _ => {
- Err(CompilationError::InvalidMetaPredicateDecl)
+ Ok((
+ load_state.compilation_target.module_name(),
+ name,
+ meta_specs,
+ ))
}
+ _ => Err(CompilationError::InvalidMetaPredicateDecl),
}
}
-fn merge_clauses(tls: &mut VecDeque<TopLevel>) -> Result<TopLevel, CompilationError>
-{
+fn merge_clauses(tls: &mut VecDeque<TopLevel>) -> Result<TopLevel, CompilationError> {
let mut clauses = vec![];
while let Some(tl) = tls.pop_front() {
let clause = PredicateClause::Rule(rule);
clauses.push(clause);
}
- TopLevel::Predicate(predicate) => {
- clauses.extend(predicate.into_iter())
- }
+ TopLevel::Predicate(predicate) => clauses.extend(predicate.into_iter()),
_ => {
tls.push_front(tl);
break;
conq_terms.push_front(Term::Constant(
Cell::default(),
- Constant::Atom(clause_name!("blocked_!"), None))
- );
+ Constant::Atom(clause_name!("blocked_!"), None),
+ ));
while let Some(term) = pre_cut_terms.pop_back() {
conq_terms.push_front(term);
let atom_tbl = load_state.wam.machine_st.atom_tbl.clone();
match term {
- Term::Clause(_, name, mut terms, _) =>
- match (name.as_str(), terms.len()) {
- ("dynamic", 1) => {
- let (name, arity) = setup_predicate_indicator(&mut *terms.pop().unwrap())?;
- Ok(Declaration::Dynamic(name, arity))
- }
- ("module", 2) =>
- Ok(Declaration::Module(setup_module_decl(terms, atom_tbl)?)),
- ("op", 3) =>
- Ok(Declaration::Op(setup_op_decl(terms, atom_tbl)?)),
- ("non_counted_backtracking", 1) => {
- let (name, arity) = setup_predicate_indicator(&mut *terms.pop().unwrap())?;
- Ok(Declaration::NonCountedBacktracking(name, arity))
- }
- ("use_module", 1) => {
- Ok(Declaration::UseModule(setup_use_module_decl(terms)?))
- }
- ("use_module", 2) => {
- let (name, exports) = setup_qualified_import(terms, atom_tbl)?;
- Ok(Declaration::UseQualifiedModule(name, exports))
- }
- ("meta_predicate", 1) => {
- let (module_name, name, meta_specs) = setup_meta_predicate(terms, load_state)?;
- Ok(Declaration::MetaPredicate(module_name, name, meta_specs))
- }
- _ => {
- Err(CompilationError::InconsistentEntry)
- }
- },
- _ => {
- Err(CompilationError::InconsistentEntry)
- }
+ Term::Clause(_, name, mut terms, _) => match (name.as_str(), terms.len()) {
+ ("dynamic", 1) => {
+ let (name, arity) = setup_predicate_indicator(&mut *terms.pop().unwrap())?;
+ Ok(Declaration::Dynamic(name, arity))
+ }
+ ("module", 2) => Ok(Declaration::Module(setup_module_decl(terms, atom_tbl)?)),
+ ("op", 3) => Ok(Declaration::Op(setup_op_decl(terms, atom_tbl)?)),
+ ("non_counted_backtracking", 1) => {
+ let (name, arity) = setup_predicate_indicator(&mut *terms.pop().unwrap())?;
+ Ok(Declaration::NonCountedBacktracking(name, arity))
+ }
+ ("use_module", 1) => Ok(Declaration::UseModule(setup_use_module_decl(terms)?)),
+ ("use_module", 2) => {
+ let (name, exports) = setup_qualified_import(terms, atom_tbl)?;
+ Ok(Declaration::UseQualifiedModule(name, exports))
+ }
+ ("meta_predicate", 1) => {
+ let (module_name, name, meta_specs) = setup_meta_predicate(terms, load_state)?;
+ Ok(Declaration::MetaPredicate(module_name, name, meta_specs))
+ }
+ _ => Err(CompilationError::InconsistentEntry),
+ },
+ _ => Err(CompilationError::InconsistentEntry),
}
}
}
impl Preprocessor {
- pub(super)
- fn new(flags: MachineFlags) -> Self {
+ pub(super) fn new(flags: MachineFlags) -> Self {
Preprocessor {
flags,
queue: VecDeque::new(),
fn setup_fact(&mut self, term: Term) -> Result<Term, CompilationError> {
match term {
- Term::Clause(..) | Term::Constant(_, Constant::Atom(..)) => {
- Ok(term)
- }
- _ => {
- Err(CompilationError::InadmissibleFact)
- }
+ Term::Clause(..) | Term::Constant(_, Constant::Atom(..)) => Ok(term),
+ _ => Err(CompilationError::InadmissibleFact),
}
}
Ok(clause_to_query_term(load_state, name, vec![], fixity))
}
}
- Term::Constant(_, Constant::Char('!')) => {
- Ok(QueryTerm::BlockedCut)
- }
+ Term::Constant(_, Constant::Char('!')) => Ok(QueryTerm::BlockedCut),
Term::Var(_, ref v) if v.as_str() == "!" => {
Ok(QueryTerm::UnblockedCut(Cell::default()))
}
- Term::Clause(r, name, mut terms, fixity) => {
- match (name.as_str(), terms.len()) {
- (";", 2) => {
- let term = Term::Clause(r, name.clone(), terms, fixity);
+ Term::Clause(r, name, mut terms, fixity) => match (name.as_str(), terms.len()) {
+ (";", 2) => {
+ let term = Term::Clause(r, name.clone(), terms, fixity);
- let (stub, clauses) = self.fabricate_disjunct(term);
- self.queue.push_back(clauses);
+ let (stub, clauses) = self.fabricate_disjunct(term);
+ self.queue.push_back(clauses);
- Ok(QueryTerm::Jump(stub))
- }
- ("->", 2) => {
- let conq = *terms.pop().unwrap();
- let prec = *terms.pop().unwrap();
+ Ok(QueryTerm::Jump(stub))
+ }
+ ("->", 2) => {
+ let conq = *terms.pop().unwrap();
+ let prec = *terms.pop().unwrap();
- let (stub, clauses) = self.fabricate_if_then(prec, conq);
- self.queue.push_back(clauses);
+ let (stub, clauses) = self.fabricate_if_then(prec, conq);
+ self.queue.push_back(clauses);
- Ok(QueryTerm::Jump(stub))
- }
- ("\\+", 1) => {
- terms.push(Box::new(Term::Constant(
- Cell::default(),
- Constant::Atom(clause_name!("$fail"), None)
- )));
+ Ok(QueryTerm::Jump(stub))
+ }
+ ("\\+", 1) => {
+ terms.push(Box::new(Term::Constant(
+ Cell::default(),
+ Constant::Atom(clause_name!("$fail"), None),
+ )));
- let conq = Term::Constant(
- Cell::default(),
- Constant::Atom(clause_name!("true"), None)
- );
+ let conq =
+ Term::Constant(Cell::default(), Constant::Atom(clause_name!("true"), None));
- let prec = Term::Clause(Cell::default(), clause_name!("->"), terms, None);
- let terms = vec![Box::new(prec), Box::new(conq)];
+ let prec = Term::Clause(Cell::default(), clause_name!("->"), terms, None);
+ let terms = vec![Box::new(prec), Box::new(conq)];
- let term = Term::Clause(Cell::default(), clause_name!(";"), terms, None);
- let (stub, clauses) = self.fabricate_disjunct(term);
+ let term = Term::Clause(Cell::default(), clause_name!(";"), terms, None);
+ let (stub, clauses) = self.fabricate_disjunct(term);
- debug_assert!(clauses.len() > 0);
- self.queue.push_back(clauses);
+ debug_assert!(clauses.len() > 0);
+ self.queue.push_back(clauses);
- Ok(QueryTerm::Jump(stub))
- }
- ("$get_level", 1) => {
- if let Term::Var(_, ref var) = *terms[0] {
- Ok(QueryTerm::GetLevelAndUnify(Cell::default(), var.clone()))
- } else {
- Err(CompilationError::InadmissibleQueryTerm)
- }
+ Ok(QueryTerm::Jump(stub))
+ }
+ ("$get_level", 1) => {
+ if let Term::Var(_, ref var) = *terms[0] {
+ Ok(QueryTerm::GetLevelAndUnify(Cell::default(), var.clone()))
+ } else {
+ Err(CompilationError::InadmissibleQueryTerm)
}
- (":", 2) => {
- let predicate_name = *terms.pop().unwrap();
- let module_name = *terms.pop().unwrap();
-
- match (module_name, predicate_name) {
- (Term::Constant(_, Constant::Atom(module_name, _)),
- Term::Constant(_, Constant::Atom(predicate_name, fixity))) => {
- Ok(qualified_clause_to_query_term(
- load_state,
- module_name,
- predicate_name,
- vec![],
- fixity,
- ))
- }
- (Term::Constant(_, Constant::Atom(module_name, _)),
- Term::Clause(_, name, terms, fixity)) => {
- Ok(qualified_clause_to_query_term(
- load_state,
- module_name,
- name,
- terms,
- fixity,
- ))
- }
- (module_name, predicate_name) => {
- terms.push(Box::new(module_name));
- terms.push(Box::new(predicate_name));
-
- Ok(clause_to_query_term(load_state, name, terms, fixity))
- }
+ }
+ (":", 2) => {
+ let predicate_name = *terms.pop().unwrap();
+ let module_name = *terms.pop().unwrap();
+
+ match (module_name, predicate_name) {
+ (
+ Term::Constant(_, Constant::Atom(module_name, _)),
+ Term::Constant(_, Constant::Atom(predicate_name, fixity)),
+ ) => Ok(qualified_clause_to_query_term(
+ load_state,
+ module_name,
+ predicate_name,
+ vec![],
+ fixity,
+ )),
+ (
+ Term::Constant(_, Constant::Atom(module_name, _)),
+ Term::Clause(_, name, terms, fixity),
+ ) => Ok(qualified_clause_to_query_term(
+ load_state,
+ module_name,
+ name,
+ terms,
+ fixity,
+ )),
+ (module_name, predicate_name) => {
+ terms.push(Box::new(module_name));
+ terms.push(Box::new(predicate_name));
+
+ Ok(clause_to_query_term(load_state, name, terms, fixity))
}
}
- _ => {
- Ok(clause_to_query_term(load_state, name, terms, fixity))
- }
}
- }
- Term::Var(..) => {
- Ok(QueryTerm::Clause(
- Cell::default(),
- ClauseType::CallN,
- vec![Box::new(term)],
- false,
- ))
- }
- _ => {
- Err(CompilationError::InadmissibleQueryTerm)
- }
+ _ => Ok(clause_to_query_term(load_state, name, terms, fixity)),
+ },
+ Term::Var(..) => Ok(QueryTerm::Clause(
+ Cell::default(),
+ ClauseType::CallN,
+ vec![Box::new(term)],
+ false,
+ )),
+ _ => Err(CompilationError::InadmissibleQueryTerm),
}
}
self.to_query_term(load_state, Term::Clause(r, name, subterms, fixity))
}
}
- _ => {
- self.to_query_term(load_state, term)
- }
+ _ => self.to_query_term(load_state, term),
}
}
mut terms: Vec<Box<Term>>,
cut_context: CutContext,
) -> Result<Rule, CompilationError> {
- let post_head_terms: Vec<_> = terms.drain(1 ..).collect();
+ let post_head_terms: Vec<_> = terms.drain(1..).collect();
- let mut query_terms =
- self.setup_query(load_state, post_head_terms, cut_context)?;
+ let mut query_terms = self.setup_query(load_state, post_head_terms, cut_context)?;
- let clauses = query_terms.drain(1 ..).collect();
+ let clauses = query_terms.drain(1..).collect();
let qt = query_terms.pop().unwrap();
match *terms.pop().unwrap() {
- Term::Clause(_, name, terms, _) => {
- Ok(Rule {
- head: (name, terms, qt),
- clauses,
- })
- }
- Term::Constant(_, Constant::Atom(name, _)) => {
- Ok(Rule {
- head: (name, vec![], qt),
- clauses,
- })
- }
- _ => {
- Err(CompilationError::InvalidRuleHead)
- }
+ Term::Clause(_, name, terms, _) => Ok(Rule {
+ head: (name, terms, qt),
+ clauses,
+ }),
+ Term::Constant(_, Constant::Atom(name, _)) => Ok(Rule {
+ head: (name, vec![], qt),
+ clauses,
+ }),
+ _ => Err(CompilationError::InvalidRuleHead),
}
}
terms: Vec<Box<Term>>,
cut_context: CutContext,
) -> Result<TopLevel, CompilationError> {
- Ok(TopLevel::Query(self.setup_query(load_state, terms, cut_context)?))
+ Ok(TopLevel::Query(self.setup_query(
+ load_state,
+ terms,
+ cut_context,
+ )?))
}
- pub(super)
- fn try_term_to_tl<'a>(
+ pub(super) fn try_term_to_tl<'a>(
&mut self,
load_state: &mut LoadState<'a>,
term: Term,
Ok(TopLevel::Fact(self.setup_fact(term)?))
}
}
- term => {
- Ok(TopLevel::Fact(self.setup_fact(term)?))
- }
+ term => Ok(TopLevel::Fact(self.setup_fact(term)?)),
}
}
Ok(results)
}
- pub(super)
- fn parse_queue<'a>(
+ pub(super) fn parse_queue<'a>(
&mut self,
load_state: &mut LoadState<'a>,
) -> Result<VecDeque<TopLevel>, CompilationError> {
let mut queue = VecDeque::new();
while let Some(terms) = self.queue.pop_front() {
- let clauses = merge_clauses(
- &mut self.try_terms_to_tls(
- load_state,
- terms,
- CutContext::HasCutVariable,
- )?
- )?;
+ let clauses = merge_clauses(&mut self.try_terms_to_tls(
+ load_state,
+ terms,
+ CutContext::HasCutVariable,
+ )?)?;
queue.push_back(clauses);
}
use crate::prolog_parser_rebis::ast::*;
+use crate::prolog_parser_rebis::clause_name;
-use crate::read::PrologStream;
-use crate::read::readline::*;
use crate::machine::machine_errors::*;
use crate::machine::machine_indices::*;
use crate::machine::machine_state::*;
+use crate::read::readline::*;
+use crate::read::PrologStream;
-use std::cmp::Ordering;
use std::cell::RefCell;
+use std::cmp::Ordering;
use std::error::Error;
use std::fmt;
use std::fs::File;
+use std::hash::{Hash, Hasher};
use std::io;
use std::io::{stdout, Cursor, ErrorKind, Read, Seek, SeekFrom, Write};
-use std::hash::{Hash, Hasher};
use std::mem;
use std::net::{Shutdown, TcpStream};
use std::ops::DerefMut;
impl StreamType {
#[inline]
- pub(crate)
- fn as_str(&self) -> &'static str {
+ pub(crate) fn as_str(&self) -> &'static str {
match self {
StreamType::Binary => "binary_stream",
StreamType::Text => "text_stream",
}
#[inline]
- pub(crate)
- fn as_property_str(&self) -> &'static str {
+ pub(crate) fn as_property_str(&self) -> &'static str {
match self {
StreamType::Binary => "binary",
StreamType::Text => "text",
}
#[inline]
- pub(crate)
- fn other(self) -> StreamType {
+ pub(crate) fn other(self) -> StreamType {
match self {
StreamType::Binary => StreamType::Text,
StreamType::Text => StreamType::Binary,
pub enum AtEndOfStream {
Not,
At,
- Past
+ Past,
}
impl AtEndOfStream {
#[inline]
- pub(crate)
- fn as_str(&self) -> &'static str {
+ pub(crate) fn as_str(&self) -> &'static str {
match self {
AtEndOfStream::Not => "not",
AtEndOfStream::Past => "past",
impl EOFAction {
#[inline]
- pub(crate)
- fn as_str(&self) -> &'static str {
+ pub(crate) fn as_str(&self) -> &'static str {
match self {
EOFAction::EOFCode => "eof_code",
EOFAction::Error => "error",
StaticStr(Cursor<&'static str>),
Stdout,
TcpStream(ClauseName, TcpStream),
- TlsStream(ClauseName, TlsStream<TcpStream>)
+ TlsStream(ClauseName, TlsStream<TcpStream>),
}
impl StreamInstance {
if index == buf.len() {
Ok(buf.len())
} else {
- stream.read(&mut buf[index ..])
- .map(|bytes_read| bytes_read + index)
+ stream
+ .read(&mut buf[index..])
+ .map(|bytes_read| bytes_read + index)
}
}
- StreamInstance::InputFile(_, ref mut file) => {
- file.read(buf)
- }
- StreamInstance::TcpStream(_, ref mut tcp_stream) => {
- tcp_stream.read(buf)
- }
- StreamInstance::TlsStream(_, ref mut tls_stream) => {
- tls_stream.read(buf)
- }
- StreamInstance::ReadlineStream(ref mut rl_stream) => {
- rl_stream.read(buf)
- }
- StreamInstance::StaticStr(ref mut src) => {
- src.read(buf)
- }
- StreamInstance::Bytes(ref mut cursor) => {
- cursor.read(buf)
- }
- StreamInstance::OutputFile(..) |
- StreamInstance::Stdout |
- StreamInstance::Null => {
+ StreamInstance::InputFile(_, ref mut file) => file.read(buf),
+ StreamInstance::TcpStream(_, ref mut tcp_stream) => tcp_stream.read(buf),
+ StreamInstance::TlsStream(_, ref mut tls_stream) => tls_stream.read(buf),
+ StreamInstance::ReadlineStream(ref mut rl_stream) => rl_stream.read(buf),
+ StreamInstance::StaticStr(ref mut src) => src.read(buf),
+ StreamInstance::Bytes(ref mut cursor) => cursor.read(buf),
+ StreamInstance::OutputFile(..) | StreamInstance::Stdout | StreamInstance::Null => {
Err(std::io::Error::new(
ErrorKind::PermissionDenied,
StreamError::ReadFromOutputStream,
StreamInstance::TlsStream(_, ref mut tls_stream) => {
tls_stream.shutdown().unwrap();
}
- _ => {
- }
+ _ => {}
}
}
}
impl fmt::Debug for StreamInstance {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
match self {
- &StreamInstance::Bytes(ref bytes) =>
- write!(fmt, "Bytes({:?})", bytes),
- &StreamInstance::StaticStr(_) =>
- write!(fmt, "StaticStr(_)"), // Hacky solution.
- &StreamInstance::InputFile(_, ref file) =>
- write!(fmt, "InputFile({:?})", file),
- &StreamInstance::OutputFile(_, ref file, _) =>
- write!(fmt, "OutputFile({:?})", file),
- &StreamInstance::Null =>
- write!(fmt, "Null"),
- &StreamInstance::PausedPrologStream(ref put_back, ref stream) =>
- write!(fmt, "PausedPrologStream({:?}, {:?})", put_back, stream),
- &StreamInstance::ReadlineStream(ref readline_stream) =>
- write!(fmt, "ReadlineStream({:?})", readline_stream),
- &StreamInstance::Stdout =>
- write!(fmt, "Stdout"),
- &StreamInstance::TcpStream(_, ref tcp_stream) =>
- write!(fmt, "TcpStream({:?})", tcp_stream),
- &StreamInstance::TlsStream(_, ref tls_stream) =>
- write!(fmt, "TlsStream({:?})", tls_stream),
+ &StreamInstance::Bytes(ref bytes) => write!(fmt, "Bytes({:?})", bytes),
+ &StreamInstance::StaticStr(_) => write!(fmt, "StaticStr(_)"), // Hacky solution.
+ &StreamInstance::InputFile(_, ref file) => write!(fmt, "InputFile({:?})", file),
+ &StreamInstance::OutputFile(_, ref file, _) => write!(fmt, "OutputFile({:?})", file),
+ &StreamInstance::Null => write!(fmt, "Null"),
+ &StreamInstance::PausedPrologStream(ref put_back, ref stream) => {
+ write!(fmt, "PausedPrologStream({:?}, {:?})", put_back, stream)
+ }
+ &StreamInstance::ReadlineStream(ref readline_stream) => {
+ write!(fmt, "ReadlineStream({:?})", readline_stream)
+ }
+ &StreamInstance::Stdout => write!(fmt, "Stdout"),
+ &StreamInstance::TcpStream(_, ref tcp_stream) => {
+ write!(fmt, "TcpStream({:?})", tcp_stream)
+ }
+ &StreamInstance::TlsStream(_, ref tls_stream) => {
+ write!(fmt, "TlsStream({:?})", tls_stream)
+ }
}
}
}
impl WrappedStreamInstance {
#[inline]
fn new(stream_inst: StreamInstance) -> Self {
- WrappedStreamInstance(
- Rc::new(RefCell::new((false, stream_inst)))
- )
+ WrappedStreamInstance(Rc::new(RefCell::new((false, stream_inst))))
}
}
impl Stream {
#[inline]
- pub(crate)
- fn as_ptr(&self) -> *const u8 {
+ pub(crate) fn as_ptr(&self) -> *const u8 {
let rc = self.stream_inst.0.clone();
let ptr = Rc::into_raw(rc);
}
#[inline]
- pub(crate)
- fn position(&mut self) -> Option<u64> {
+ pub(crate) fn position(&mut self) -> Option<u64> {
match self.stream_inst.0.borrow_mut().1 {
- StreamInstance::InputFile(_, ref mut file) => {
- file.seek(SeekFrom::Current(0)).ok()
- }
- _ => {
- None
- }
+ StreamInstance::InputFile(_, ref mut file) => file.seek(SeekFrom::Current(0)).ok(),
+ _ => None,
}
}
#[inline]
- pub(crate)
- fn set_position(&mut self, position: u64) {
+ pub(crate) fn set_position(&mut self, position: u64) {
match self.stream_inst.0.borrow_mut().deref_mut() {
(past_end_of_stream, StreamInstance::InputFile(_, ref mut file)) => {
file.seek(SeekFrom::Start(position)).unwrap();
*past_end_of_stream = position > metadata.len();
}
}
- _ => {
- }
+ _ => {}
}
}
#[inline]
- pub(crate)
- fn past_end_of_stream(&self) -> bool {
+ pub(crate) fn past_end_of_stream(&self) -> bool {
self.stream_inst.0.borrow_mut().0
}
#[inline]
- pub(crate)
- fn at_end_of_stream(&mut self) -> bool {
+ pub(crate) fn at_end_of_stream(&mut self) -> bool {
self.position_relative_to_end() == AtEndOfStream::At
}
#[inline]
- pub(crate)
- fn set_past_end_of_stream(&mut self) {
+ pub(crate) fn set_past_end_of_stream(&mut self) {
self.stream_inst.0.borrow_mut().0 = true;
}
#[inline]
- pub(crate)
- fn position_relative_to_end(&mut self) -> AtEndOfStream {
+ pub(crate) fn position_relative_to_end(&mut self) -> AtEndOfStream {
if self.past_end_of_stream() {
return AtEndOfStream::Past;
}
Ok(metadata) => {
if let Ok(position) = file.seek(SeekFrom::Current(0)) {
return match position.cmp(&metadata.len()) {
- Ordering::Equal => {
- AtEndOfStream::At
- }
- Ordering::Less => {
- AtEndOfStream::Not
- }
+ Ordering::Equal => AtEndOfStream::At,
+ Ordering::Less => AtEndOfStream::Not,
Ordering::Greater => {
*past_end_of_stream = true; //self.set_past_end_of_stream();
AtEndOfStream::Past
}
}
}
- _ => {
- AtEndOfStream::Not
- }
+ _ => AtEndOfStream::Not,
}
}
#[inline]
- pub(crate)
- fn file_name(&self) -> Option<ClauseName> {
+ pub(crate) fn file_name(&self) -> Option<ClauseName> {
match self.stream_inst.0.borrow().1 {
- StreamInstance::InputFile(ref name, _) => {
- Some(name.clone())
- }
- StreamInstance::OutputFile(ref name, ..) => {
- Some(name.clone())
- }
- StreamInstance::TcpStream(ref name, _) => {
- Some(name.clone())
- }
- _ => {
- None
- }
+ StreamInstance::InputFile(ref name, _) => Some(name.clone()),
+ StreamInstance::OutputFile(ref name, ..) => Some(name.clone()),
+ StreamInstance::TcpStream(ref name, _) => Some(name.clone()),
+ _ => None,
}
}
#[inline]
- pub(crate)
- fn mode(&self) -> &'static str {
+ pub(crate) fn mode(&self) -> &'static str {
match self.stream_inst.0.borrow().1 {
- StreamInstance::Bytes(_) |
- StreamInstance::PausedPrologStream(..) |
- StreamInstance::ReadlineStream(_) |
- StreamInstance::StaticStr(_) |
- StreamInstance::InputFile(..) => {
- "read"
- }
- StreamInstance::TcpStream(..) |
- StreamInstance::TlsStream(..) => {
- "read_append"
- }
- StreamInstance::OutputFile(_, _, true) => {
- "append"
- }
- StreamInstance::Stdout |
- StreamInstance::OutputFile(_, _, false) => {
- "write"
- }
- StreamInstance::Null => {
- ""
- }
+ StreamInstance::Bytes(_)
+ | StreamInstance::PausedPrologStream(..)
+ | StreamInstance::ReadlineStream(_)
+ | StreamInstance::StaticStr(_)
+ | StreamInstance::InputFile(..) => "read",
+ StreamInstance::TcpStream(..) | StreamInstance::TlsStream(..) => "read_append",
+ StreamInstance::OutputFile(_, _, true) => "append",
+ StreamInstance::Stdout | StreamInstance::OutputFile(_, _, false) => "write",
+ StreamInstance::Null => "",
}
}
fn from_inst(stream_inst: StreamInstance) -> Self {
Stream {
options: StreamOptions::default(),
- stream_inst: WrappedStreamInstance::new(stream_inst)
+ stream_inst: WrappedStreamInstance::new(stream_inst),
}
}
#[inline]
- pub(crate)
- fn stdout() -> Self {
+ pub(crate) fn stdout() -> Self {
Stream::from_inst(StreamInstance::Stdout)
}
#[inline]
- pub(crate)
- fn from_tcp_stream(address: ClauseName, tcp_stream: TcpStream) -> Self {
+ pub(crate) fn from_tcp_stream(address: ClauseName, tcp_stream: TcpStream) -> Self {
tcp_stream.set_read_timeout(None).unwrap();
tcp_stream.set_write_timeout(None).unwrap();
}
#[inline]
- pub(crate)
- fn from_tls_stream(address: ClauseName, tls_stream: TlsStream<TcpStream>) -> Self {
+ pub(crate) fn from_tls_stream(address: ClauseName, tls_stream: TlsStream<TcpStream>) -> Self {
Stream::from_inst(StreamInstance::TlsStream(address, tls_stream))
}
#[inline]
- pub(crate)
- fn from_file_as_output(name: ClauseName, file: File, in_append_mode: bool) -> Self {
+ pub(crate) fn from_file_as_output(name: ClauseName, file: File, in_append_mode: bool) -> Self {
Stream::from_inst(StreamInstance::OutputFile(name, file, in_append_mode))
}
#[inline]
- pub(crate)
- fn from_file_as_input(name: ClauseName, file: File) -> Self {
+ pub(crate) fn from_file_as_input(name: ClauseName, file: File) -> Self {
Stream::from_inst(StreamInstance::InputFile(name, file))
}
#[inline]
- pub(crate)
- fn is_stdout(&self) -> bool {
+ pub(crate) fn is_stdout(&self) -> bool {
match self.stream_inst.0.borrow().1 {
- StreamInstance::Stdout => {
- true
- }
- _ => {
- false
- }
+ StreamInstance::Stdout => true,
+ _ => false,
}
}
#[inline]
- pub(crate)
- fn is_stdin(&self) -> bool {
+ pub(crate) fn is_stdin(&self) -> bool {
match self.stream_inst.0.borrow().1 {
- StreamInstance::ReadlineStream(_) => {
- true
- }
- _ => {
- false
- }
+ StreamInstance::ReadlineStream(_) => true,
+ _ => false,
}
}
#[inline]
- pub(crate)
- fn close(&mut self) {
+ pub(crate) fn close(&mut self) {
self.stream_inst.0.borrow_mut().1 = StreamInstance::Null;
}
#[inline]
- pub(crate)
- fn is_null_stream(&self) -> bool {
+ pub(crate) fn is_null_stream(&self) -> bool {
if let StreamInstance::Null = self.stream_inst.0.borrow().1 {
true
} else {
}
#[inline]
- pub(crate)
- fn is_input_stream(&self) -> bool {
+ pub(crate) fn is_input_stream(&self) -> bool {
match self.stream_inst.0.borrow().1 {
- StreamInstance::TcpStream(..) |
- StreamInstance::TlsStream(..) |
- StreamInstance::Bytes(_) |
- StreamInstance::PausedPrologStream(..) |
- StreamInstance::ReadlineStream(_) |
- StreamInstance::StaticStr(_) |
- StreamInstance::InputFile(..) => {
- true
- }
- _ => {
- false
- }
+ StreamInstance::TcpStream(..)
+ | StreamInstance::TlsStream(..)
+ | StreamInstance::Bytes(_)
+ | StreamInstance::PausedPrologStream(..)
+ | StreamInstance::ReadlineStream(_)
+ | StreamInstance::StaticStr(_)
+ | StreamInstance::InputFile(..) => true,
+ _ => false,
}
}
#[inline]
- pub(crate)
- fn is_output_stream(&self) -> bool {
+ pub(crate) fn is_output_stream(&self) -> bool {
match self.stream_inst.0.borrow().1 {
StreamInstance::Stdout
- | StreamInstance::TcpStream(..)
- | StreamInstance::TlsStream(..)
- | StreamInstance::Bytes(_)
- | StreamInstance::OutputFile(..) => {
- true
- }
- _ => {
- false
- }
+ | StreamInstance::TcpStream(..)
+ | StreamInstance::TlsStream(..)
+ | StreamInstance::Bytes(_)
+ | StreamInstance::OutputFile(..) => true,
+ _ => false,
}
}
fn unpause_stream(&mut self) {
- let stream_inst =
- match self.stream_inst.0.borrow_mut().1 {
- StreamInstance::PausedPrologStream(ref put_back, ref mut stream_inst)
- if put_back.is_empty() => {
- mem::replace(&mut **stream_inst, StreamInstance::Null)
- }
- _ => {
- return;
- }
- };
+ let stream_inst = match self.stream_inst.0.borrow_mut().1 {
+ StreamInstance::PausedPrologStream(ref put_back, ref mut stream_inst)
+ if put_back.is_empty() =>
+ {
+ mem::replace(&mut **stream_inst, StreamInstance::Null)
+ }
+ _ => {
+ return;
+ }
+ };
self.stream_inst.0.borrow_mut().1 = stream_inst;
}
// returns true on success.
#[inline]
- pub(super)
- fn reset(&mut self) -> bool {
+ pub(super) fn reset(&mut self) -> bool {
self.stream_inst.0.borrow_mut().0 = false;
loop {
}
#[inline]
- pub(crate)
- fn peek_byte(&mut self) -> std::io::Result<u8> {
+ pub(crate) fn peek_byte(&mut self) -> std::io::Result<u8> {
match self.stream_inst.0.borrow_mut().1 {
StreamInstance::Bytes(ref mut cursor) => {
let mut b = [0u8; 1];
cursor.set_position(pos);
Ok(b[0])
}
- _ => {
- Err(std::io::Error::new(
- ErrorKind::UnexpectedEof,
- "end of file",
- ))
- }
+ _ => Err(std::io::Error::new(ErrorKind::UnexpectedEof, "end of file")),
}
}
StreamInstance::InputFile(_, ref mut file) => {
file.seek(SeekFrom::Current(-1))?;
Ok(b[0])
}
- _ => {
- Err(std::io::Error::new(
- ErrorKind::UnexpectedEof,
- StreamError::PeekByteFailed,
- ))
- }
+ _ => Err(std::io::Error::new(
+ ErrorKind::UnexpectedEof,
+ StreamError::PeekByteFailed,
+ )),
}
}
- StreamInstance::ReadlineStream(ref mut stream) => {
- stream.peek_byte()
- }
+ StreamInstance::ReadlineStream(ref mut stream) => stream.peek_byte(),
StreamInstance::TcpStream(_, ref mut tcp_stream) => {
let mut b = [0u8; 1];
tcp_stream.peek(&mut b)?;
Ok(b[0])
}
- _ => {
- Err(std::io::Error::new(
- ErrorKind::PermissionDenied,
- StreamError::PeekByteFromNonPeekableStream,
- ))
- }
+ _ => Err(std::io::Error::new(
+ ErrorKind::PermissionDenied,
+ StreamError::PeekByteFromNonPeekableStream,
+ )),
}
}
#[inline]
- pub(crate)
- fn peek_char(&mut self) -> std::io::Result<char> {
+ pub(crate) fn peek_char(&mut self) -> std::io::Result<char> {
use crate::unicode_reader::CodePoints;
match self.stream_inst.0.borrow_mut().1 {
} else {
return Err(std::io::Error::new(
ErrorKind::UnexpectedEof,
- StreamError::PeekCharFailed
+ StreamError::PeekCharFailed,
));
}
};
- file.seek(SeekFrom::Current(- (c.len_utf8() as i64)))?;
+ file.seek(SeekFrom::Current(-(c.len_utf8() as i64)))?;
Ok(c)
}
- StreamInstance::ReadlineStream(ref mut stream) => {
- stream.peek_char()
- }
+ StreamInstance::ReadlineStream(ref mut stream) => stream.peek_char(),
StreamInstance::TcpStream(_, ref tcp_stream) => {
let c = {
let mut buf = [0u8; 8];
} else {
return Err(std::io::Error::new(
ErrorKind::UnexpectedEof,
- StreamError::PeekCharFailed
+ StreamError::PeekCharFailed,
));
}
};
Ok(c)
}
- _ => {
- Err(std::io::Error::new(
- ErrorKind::PermissionDenied,
- StreamError::PeekCharFromNonPeekableStream,
- ))
- }
+ _ => Err(std::io::Error::new(
+ ErrorKind::PermissionDenied,
+ StreamError::PeekCharFromNonPeekableStream,
+ )),
}
}
#[inline]
- pub(crate)
- fn pause_stream(&mut self, buf: Vec<io::Result<char>>) -> io::Result<()> {
+ pub(crate) fn pause_stream(&mut self, buf: Vec<io::Result<char>>) -> io::Result<()> {
match self.stream_inst.0.borrow_mut().1 {
StreamInstance::PausedPrologStream(ref mut inner_buf, _) => {
inner_buf.extend(parser_top_to_bytes(buf)?.into_iter());
return Ok(());
}
- _ => {
- }
+ _ => {}
}
if !buf.is_empty() {
- let stream_inst = mem::replace(
- &mut self.stream_inst.0.borrow_mut().1,
- StreamInstance::Null,
- );
+ let stream_inst =
+ mem::replace(&mut self.stream_inst.0.borrow_mut().1, StreamInstance::Null);
- self.stream_inst.0.borrow_mut().1 =
- StreamInstance::PausedPrologStream(
- parser_top_to_bytes(buf)?,
- Box::new(stream_inst),
- );
+ self.stream_inst.0.borrow_mut().1 = StreamInstance::PausedPrologStream(
+ parser_top_to_bytes(buf)?,
+ Box::new(stream_inst),
+ );
}
Ok(())
impl MachineState {
#[inline]
- pub(crate)
- fn eof_action(
+ pub(crate) fn eof_action(
&mut self,
result: Addr,
stream: &mut Stream,
return Err(self.open_past_eos_error(stream.clone(), caller, arity));
}
EOFAction::EOFCode => {
- let end_of_stream =
- if stream.options.stream_type == StreamType::Binary {
- Addr::Fixnum(-1)
- } else {
- self.heap.to_unifiable(
- HeapCellValue::Atom(clause_name!("end_of_file"), None)
- )
- };
+ let end_of_stream = if stream.options.stream_type == StreamType::Binary {
+ Addr::Fixnum(-1)
+ } else {
+ self.heap
+ .to_unifiable(HeapCellValue::Atom(clause_name!("end_of_file"), None))
+ };
stream.set_past_end_of_stream();
Ok(self.unify(result, end_of_stream))
}
}
- pub(crate)
- fn to_stream_options(
+ pub(crate) fn to_stream_options(
&self,
alias: Addr,
eof_action: Addr,
reposition: Addr,
stream_type: Addr,
) -> StreamOptions {
- let alias =
- match self.store(self.deref(alias)) {
- Addr::Con(h) if self.heap.atom_at(h) => {
- if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
- Some(name.clone())
- } else {
- unreachable!()
- }
- }
- _ => {
- None
- }
- };
-
- let eof_action =
- match self.store(self.deref(eof_action)) {
- Addr::Con(h) if self.heap.atom_at(h) => {
- if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
- match name.as_str() {
- "eof_code" => EOFAction::EOFCode,
- "error" => EOFAction::Error,
- "reset" => EOFAction::Reset,
- _ => unreachable!(),
- }
- } else {
- unreachable!()
- }
- }
- _ => {
+ let alias = match self.store(self.deref(alias)) {
+ Addr::Con(h) if self.heap.atom_at(h) => {
+ if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
+ Some(name.clone())
+ } else {
unreachable!()
}
- };
+ }
+ _ => None,
+ };
- let reposition =
- match self.store(self.deref(reposition)) {
- Addr::Con(h) if self.heap.atom_at(h) => {
- if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
- name.as_str() == "true"
- } else {
- unreachable!()
+ let eof_action = match self.store(self.deref(eof_action)) {
+ Addr::Con(h) if self.heap.atom_at(h) => {
+ if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
+ match name.as_str() {
+ "eof_code" => EOFAction::EOFCode,
+ "error" => EOFAction::Error,
+ "reset" => EOFAction::Reset,
+ _ => unreachable!(),
}
+ } else {
+ unreachable!()
}
- _ => {
+ }
+ _ => {
+ unreachable!()
+ }
+ };
+
+ let reposition = match self.store(self.deref(reposition)) {
+ Addr::Con(h) if self.heap.atom_at(h) => {
+ if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
+ name.as_str() == "true"
+ } else {
unreachable!()
}
- };
-
- let stream_type =
- match self.store(self.deref(stream_type)) {
- Addr::Con(h) if self.heap.atom_at(h) => {
- if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
- match name.as_str() {
- "text" => StreamType::Text,
- "binary" => StreamType::Binary,
- _ => unreachable!()
- }
- } else {
- unreachable!()
+ }
+ _ => {
+ unreachable!()
+ }
+ };
+
+ let stream_type = match self.store(self.deref(stream_type)) {
+ Addr::Con(h) if self.heap.atom_at(h) => {
+ if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
+ match name.as_str() {
+ "text" => StreamType::Text,
+ "binary" => StreamType::Binary,
+ _ => unreachable!(),
}
- }
- _ => {
+ } else {
unreachable!()
}
- };
+ }
+ _ => {
+ unreachable!()
+ }
+ };
let mut options = StreamOptions::default();
options.stream_type = stream_type;
- options.reposition = reposition;
+ options.reposition = reposition;
options.alias = alias;
options.eof_action = eof_action;
options
}
- pub(crate)
- fn get_stream_or_alias(
+ pub(crate) fn get_stream_or_alias(
&mut self,
addr: Addr,
indices: &IndexStore,
caller: &'static str,
arity: usize,
- ) -> Result<Stream, MachineStub>
- {
+ ) -> Result<Stream, MachineStub> {
Ok(match self.store(self.deref(addr)) {
Addr::Con(h) if self.heap.atom_at(h) => {
- if let HeapCellValue::Atom(ref atom, ref spec) = self.heap.clone(h) {
+ if let HeapCellValue::Atom(ref atom, ref spec) = self.heap.clone(h) {
match indices.stream_aliases.get(atom) {
- Some(stream) if !stream.is_null_stream() => {
- stream.clone()
- }
+ Some(stream) if !stream.is_null_stream() => stream.clone(),
_ => {
let stub = MachineError::functor_stub(clause_name!(caller), arity);
- let addr = self.heap.to_unifiable(
- HeapCellValue::Atom(atom.clone(), spec.clone())
- );
+ let addr = self
+ .heap
+ .to_unifiable(HeapCellValue::Atom(atom.clone(), spec.clone()));
return Err(self.error_form(
- MachineError::existence_error(self.heap.h(), ExistenceError::Stream(addr)),
+ MachineError::existence_error(
+ self.heap.h(),
+ ExistenceError::Stream(addr),
+ ),
stub,
));
}
Addr::Stream(h) => {
if let HeapCellValue::Stream(ref stream) = &self.heap[h] {
if stream.is_null_stream() {
- return Err(self.open_permission_error(
- Addr::Stream(h),
- caller,
- arity,
- ));
+ return Err(self.open_permission_error(Addr::Stream(h), caller, arity));
} else {
stream.clone()
}
let stub = MachineError::functor_stub(clause_name!(caller), arity);
if addr.is_ref() {
- return Err(self.error_form(
- MachineError::instantiation_error(),
- stub,
- ));
+ return Err(self.error_form(MachineError::instantiation_error(), stub));
} else {
return Err(self.error_form(
MachineError::domain_error(DomainErrorType::StreamOrAlias, addr),
})
}
- pub(crate)
- fn open_parsing_stream(
+ pub(crate) fn open_parsing_stream(
&self,
stream: Stream,
stub_name: &'static str,
stub_arity: usize,
) -> Result<PrologStream, MachineStub> {
match parsing_stream(stream) {
- Ok(parsing_stream) => {
- Ok(parsing_stream)
- }
+ Ok(parsing_stream) => Ok(parsing_stream),
Err(e) => {
let stub = MachineError::functor_stub(clause_name!(stub_name), stub_arity);
- let err = MachineError::session_error(
- self.heap.h(),
- SessionError::from(e),
- );
+ let err = MachineError::session_error(self.heap.h(), SessionError::from(e));
Err(self.error_form(err, stub))
}
}
}
- pub(crate)
- fn stream_permission_error(
+ pub(crate) fn stream_permission_error(
&self,
perm: Permission,
err_string: &'static str,
arity: usize,
) -> MachineStub {
let stub = MachineError::functor_stub(caller, arity);
- let payload = vec![
- HeapCellValue::Stream(stream)
- ];
+ let payload = vec![HeapCellValue::Stream(stream)];
- let err = MachineError::permission_error(
- self.heap.h(),
- perm,
- err_string,
- payload,
- );
+ let err = MachineError::permission_error(self.heap.h(), perm, err_string, payload);
return self.error_form(err, stub);
}
#[inline]
- pub(crate)
- fn open_past_eos_error(
+ pub(crate) fn open_past_eos_error(
&self,
stream: Stream,
caller: ClauseName,
)
}
- pub(crate)
- fn open_permission_error<T: PermissionError>(
+ pub(crate) fn open_permission_error<T: PermissionError>(
&self,
culprit: T,
stub_name: &'static str,
stub_arity: usize,
) -> MachineStub {
let stub = MachineError::functor_stub(clause_name!(stub_name), stub_arity);
- let err = MachineError::permission_error(
- self.heap.h(),
- Permission::Open,
- "source_sink",
- culprit,
- );
+ let err =
+ MachineError::permission_error(self.heap.h(), Permission::Open, "source_sink", culprit);
return self.error_form(err, stub);
}
- pub(crate)
- fn occupied_alias_permission_error(
+ pub(crate) fn occupied_alias_permission_error(
&self,
alias: ClauseName,
stub_name: &'static str,
return self.error_form(err, stub);
}
- pub(crate)
- fn reposition_error(
+ pub(crate) fn reposition_error(
&self,
stub_name: &'static str,
stub_arity: usize,
return self.error_form(err, stub);
}
-
- pub(crate)
- fn check_stream_properties(
+ pub(crate) fn check_stream_properties(
&mut self,
stream: &mut Stream,
expected_type: StreamType,
caller: ClauseName,
arity: usize,
) -> CallResult {
- let opt_err =
- if input.is_some() && !stream.is_input_stream() {
- Some("stream") // 8.14.2.3 g)
- } else if input.is_none() && !stream.is_output_stream() {
- Some("stream") // 8.14.2.3 g)
- } else if stream.options.stream_type != expected_type {
- Some(expected_type.other().as_str()) // 8.14.2.3 h)
- } else {
- None
- };
-
- let permission =
- if input.is_some() { Permission::InputStream } else { Permission::OutputStream };
+ let opt_err = if input.is_some() && !stream.is_input_stream() {
+ Some("stream") // 8.14.2.3 g)
+ } else if input.is_none() && !stream.is_output_stream() {
+ Some("stream") // 8.14.2.3 g)
+ } else if stream.options.stream_type != expected_type {
+ Some(expected_type.other().as_str()) // 8.14.2.3 h)
+ } else {
+ None
+ };
+
+ let permission = if input.is_some() {
+ Permission::InputStream
+ } else {
+ Permission::OutputStream
+ };
if let Some(err_string) = opt_err {
return Err(self.stream_permission_error(
if let Some(input) = input {
if stream.past_end_of_stream() {
- self.eof_action(
- input,
- stream,
- caller,
- arity,
- )?;
+ self.eof_action(input, stream, caller, arity)?;
}
}
impl Write for Stream {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
match self.stream_inst.0.borrow_mut().1 {
- StreamInstance::OutputFile(_, ref mut file, _) => {
- file.write(buf)
- }
- StreamInstance::TcpStream(_, ref mut tcp_stream) => {
- tcp_stream.write(buf)
- }
- StreamInstance::TlsStream(_, ref mut tls_stream) => {
- tls_stream.write(buf)
- }
- StreamInstance::Bytes(ref mut cursor) => {
- cursor.write(buf)
- }
- StreamInstance::Stdout => {
- stdout().write(buf)
- }
- StreamInstance::PausedPrologStream(..) |
- StreamInstance::StaticStr(_) |
- StreamInstance::ReadlineStream(_) |
- StreamInstance::InputFile(..) |
- StreamInstance::Null => {
- Err(std::io::Error::new(
- ErrorKind::PermissionDenied,
- StreamError::WriteToInputStream,
- ))
- }
+ StreamInstance::OutputFile(_, ref mut file, _) => file.write(buf),
+ StreamInstance::TcpStream(_, ref mut tcp_stream) => tcp_stream.write(buf),
+ StreamInstance::TlsStream(_, ref mut tls_stream) => tls_stream.write(buf),
+ StreamInstance::Bytes(ref mut cursor) => cursor.write(buf),
+ StreamInstance::Stdout => stdout().write(buf),
+ StreamInstance::PausedPrologStream(..)
+ | StreamInstance::StaticStr(_)
+ | StreamInstance::ReadlineStream(_)
+ | StreamInstance::InputFile(..)
+ | StreamInstance::Null => Err(std::io::Error::new(
+ ErrorKind::PermissionDenied,
+ StreamError::WriteToInputStream,
+ )),
}
}
fn flush(&mut self) -> std::io::Result<()> {
match self.stream_inst.0.borrow_mut().1 {
- StreamInstance::OutputFile(_, ref mut file, _) => {
- file.flush()
- }
- StreamInstance::TcpStream(_, ref mut tcp_stream) => {
- tcp_stream.flush()
- }
- StreamInstance::TlsStream(_, ref mut tls_stream) => {
- tls_stream.flush()
- }
- StreamInstance::Bytes(ref mut cursor) => {
- cursor.flush()
- }
- StreamInstance::Stdout => {
- stdout().flush()
- }
- StreamInstance::PausedPrologStream(..) |
- StreamInstance::StaticStr(_) |
- StreamInstance::ReadlineStream(_) |
- StreamInstance::InputFile(..) |
- StreamInstance::Null => {
- Err(std::io::Error::new(
- ErrorKind::PermissionDenied,
- StreamError::FlushToInputStream,
- ))
- }
+ StreamInstance::OutputFile(_, ref mut file, _) => file.flush(),
+ StreamInstance::TcpStream(_, ref mut tcp_stream) => tcp_stream.flush(),
+ StreamInstance::TlsStream(_, ref mut tls_stream) => tls_stream.flush(),
+ StreamInstance::Bytes(ref mut cursor) => cursor.flush(),
+ StreamInstance::Stdout => stdout().flush(),
+ StreamInstance::PausedPrologStream(..)
+ | StreamInstance::StaticStr(_)
+ | StreamInstance::ReadlineStream(_)
+ | StreamInstance::InputFile(..)
+ | StreamInstance::Null => Err(std::io::Error::new(
+ ErrorKind::PermissionDenied,
+ StreamError::FlushToInputStream,
+ )),
}
}
}
use crate::prolog_parser_rebis::ast::*;
use crate::prolog_parser_rebis::parser::*;
use crate::prolog_parser_rebis::tabled_rc::*;
+use crate::prolog_parser_rebis::{
+ alpha_char, alpha_numeric_char, backslash_char, binary_digit_char, char_class, clause_name,
+ decimal_digit_char, exponent_char, graphic_char, graphic_token_char, hexadecimal_digit_char,
+ layout_char, meta_char, new_line_char, octal_digit_char, prolog_char, sign_char, solo_char,
+ symbolic_control_char, symbolic_hexadecimal_char, temp_v,
+};
+
+use crate::lazy_static::lazy_static;
use crate::clause_types::*;
use crate::forms::*;
use crate::instructions::*;
use crate::machine;
use crate::machine::code_repo::CodeRepo;
-use crate::machine::copier::*;
use crate::machine::code_walker::*;
+use crate::machine::copier::*;
use crate::machine::machine_errors::*;
use crate::machine::machine_indices::*;
use crate::machine::machine_state::*;
use crate::ref_thread_local::RefThreadLocal;
use std::cmp;
-use std::fs;
use std::collections::BTreeSet;
use std::convert::TryFrom;
+use std::env;
+use std::fs;
use std::io::{ErrorKind, Read, Write};
use std::iter::{once, FromIterator};
use std::net::{TcpListener, TcpStream};
+use std::num::NonZeroU32;
use std::ops::Sub;
use std::rc::Rc;
-use std::num::NonZeroU32;
-use std::env;
-use std::time::{Duration, SystemTime};
+use crate::chrono::{offset::Local, DateTime};
use crate::cpu_time::ProcessTime;
-use crate::chrono::{offset::Local,DateTime};
+use std::time::{Duration, SystemTime};
use crate::crossterm::event::{read, Event, KeyCode, KeyEvent, KeyModifiers};
-use crate::crossterm::terminal::{enable_raw_mode, disable_raw_mode};
+use crate::crossterm::terminal::{disable_raw_mode, enable_raw_mode};
+use crate::blake2::{Blake2b, Blake2s};
use crate::ring::rand::{SecureRandom, SystemRandom};
-use crate::ring::{digest,hkdf,pbkdf2,aead,signature::{self,KeyPair}};
-use crate::ripemd160::{Ripemd160, Digest};
+use crate::ring::{
+ aead, digest, hkdf, pbkdf2,
+ signature::{self, KeyPair},
+};
+use crate::ripemd160::{Digest, Ripemd160};
use crate::sha3::{Sha3_224, Sha3_256, Sha3_384, Sha3_512};
-use crate::blake2::{Blake2s, Blake2b};
-use crate::openssl::ec::{EcGroup, EcPoint};
use crate::openssl::bn::{BigNum, BigNumContext};
+use crate::openssl::ec::{EcGroup, EcPoint};
use crate::openssl::nid::Nid;
use sodiumoxide::crypto::scalarmult::curve25519::*;
use crate::native_tls::TlsConnector;
extern crate select;
-use roxmltree;
+
use base64;
+use roxmltree;
pub fn get_key() -> KeyEvent {
let key;
KeyCode::Char(_) | KeyCode::Enter | KeyCode::Tab => {
key = key_;
break;
- },
- _ => ()
+ }
+ _ => (),
}
}
}
addr @ Addr::HeapCell(_) | addr @ Addr::StackCell(..) | addr @ Addr::AttrVar(_) => {
CycleSearchResult::PartialList(self.steps, addr.as_var().unwrap())
}
- Addr::PStrLocation(h, n) => {
- CycleSearchResult::PStrLocation(self.steps, h, n)
- }
- Addr::EmptyList => {
- CycleSearchResult::ProperList(self.steps)
- }
- _ => {
- CycleSearchResult::NotList
- }
+ Addr::PStrLocation(h, n) => CycleSearchResult::PStrLocation(self.steps, h, n),
+ Addr::EmptyList => CycleSearchResult::ProperList(self.steps),
+ _ => CycleSearchResult::NotList,
}
}
}
// a step in Brent's algorithm.
fn brents_alg_step(&self, brent_st: &mut BrentAlgState) -> Option<CycleSearchResult> {
match self.store(self.deref(brent_st.hare)) {
- Addr::EmptyList => {
- Some(CycleSearchResult::ProperList(brent_st.steps))
- }
+ Addr::EmptyList => Some(CycleSearchResult::ProperList(brent_st.steps)),
addr @ Addr::HeapCell(_) | addr @ Addr::StackCell(..) | addr @ Addr::AttrVar(_) => {
Some(CycleSearchResult::PartialList(
brent_st.steps,
addr.as_var().unwrap(),
))
}
- Addr::PStrLocation(h, n) => {
- match &self.heap[h] {
- HeapCellValue::PartialString(ref pstr, _) => {
- if let Some(c) = pstr.range_from(n ..).next() {
- brent_st.step(Addr::PStrLocation(h, n + c.len_utf8()))
- } else {
- unreachable!()
- }
- }
- _ => {
+ Addr::PStrLocation(h, n) => match &self.heap[h] {
+ HeapCellValue::PartialString(ref pstr, _) => {
+ if let Some(c) = pstr.range_from(n..).next() {
+ brent_st.step(Addr::PStrLocation(h, n + c.len_utf8()))
+ } else {
unreachable!()
}
}
- }
- Addr::Lis(l) => {
- brent_st.step(Addr::HeapCell(l + 1))
- }
- _ => {
- Some(CycleSearchResult::NotList)
- }
+ _ => {
+ unreachable!()
+ }
+ },
+ Addr::Lis(l) => brent_st.step(Addr::HeapCell(l + 1)),
+ _ => Some(CycleSearchResult::NotList),
}
}
- pub(super)
- fn detect_cycles_with_max(&self, max_steps: usize, addr: Addr) -> CycleSearchResult {
+ pub(super) fn detect_cycles_with_max(&self, max_steps: usize, addr: Addr) -> CycleSearchResult {
let hare = match self.store(self.deref(addr)) {
- Addr::Lis(offset) if max_steps > 0 => {
- Addr::Lis(offset)
- }
+ Addr::Lis(offset) if max_steps > 0 => Addr::Lis(offset),
Addr::Lis(offset) => {
return CycleSearchResult::UntouchedList(offset);
}
- Addr::PStrLocation(h, n) if max_steps > 0 => {
- Addr::PStrLocation(h, n)
- }
+ Addr::PStrLocation(h, n) if max_steps > 0 => Addr::PStrLocation(h, n),
Addr::PStrLocation(h, _) => {
return CycleSearchResult::UntouchedList(h);
}
}
}
- pub(super)
- fn detect_cycles(&self, addr: Addr) -> CycleSearchResult {
+ pub(super) fn detect_cycles(&self, addr: Addr) -> CycleSearchResult {
let addr = self.store(self.deref(addr));
let hare = match addr {
- Addr::Lis(offset) => {
- Addr::Lis(offset)
- }
+ Addr::Lis(offset) => Addr::Lis(offset),
Addr::EmptyList => {
return CycleSearchResult::EmptyList;
}
- Addr::PStrLocation(h, n) => {
- Addr::PStrLocation(h, n)
- }
+ Addr::PStrLocation(h, n) => Addr::PStrLocation(h, n),
Addr::Con(h) => {
if let HeapCellValue::PartialString(..) = &self.heap[h] {
Addr::PStrLocation(h, 0)
}
fn skip_max_list_result(&mut self, max_steps: Option<isize>) {
- let search_result =
- if let Some(max_steps) = max_steps {
- if max_steps == -1 {
- self.detect_cycles(self[temp_v!(3)])
- } else {
- self.detect_cycles_with_max(
- max_steps as usize,
- self[temp_v!(3)],
- )
- }
- } else {
+ let search_result = if let Some(max_steps) = max_steps {
+ if max_steps == -1 {
self.detect_cycles(self[temp_v!(3)])
- };
+ } else {
+ self.detect_cycles_with_max(max_steps as usize, self[temp_v!(3)])
+ }
+ } else {
+ self.detect_cycles(self[temp_v!(3)])
+ };
match search_result {
CycleSearchResult::PStrLocation(steps, h, n) => {
self.finalize_skip_max_list(steps, Addr::PStrLocation(h, n));
}
- CycleSearchResult::UntouchedList(l) => {
- self.finalize_skip_max_list(0, Addr::Lis(l))
- }
- CycleSearchResult::EmptyList => {
- self.finalize_skip_max_list(0, Addr::EmptyList)
- }
- CycleSearchResult::PartialList(n, r) => {
- self.finalize_skip_max_list(n, r.as_addr())
- }
+ CycleSearchResult::UntouchedList(l) => self.finalize_skip_max_list(0, Addr::Lis(l)),
+ CycleSearchResult::EmptyList => self.finalize_skip_max_list(0, Addr::EmptyList),
+ CycleSearchResult::PartialList(n, r) => self.finalize_skip_max_list(n, r.as_addr()),
CycleSearchResult::ProperList(steps) => {
self.finalize_skip_max_list(steps, Addr::EmptyList)
}
};
}
- pub(super)
- fn skip_max_list(&mut self) -> CallResult {
+ pub(super) fn skip_max_list(&mut self) -> CallResult {
let max_steps = self.store(self.deref(self[temp_v!(2)]));
match max_steps {
return Err(self.error_form(MachineError::instantiation_error(), stub));
}
addr => {
- let max_steps_n =
- match Number::try_from((max_steps, &self.heap)) {
- Ok(Number::Integer(n)) => n.to_isize(),
- Ok(Number::Fixnum(n)) => Some(n),
- _ => None,
- };
+ let max_steps_n = match Number::try_from((max_steps, &self.heap)) {
+ Ok(Number::Integer(n)) => n.to_isize(),
+ Ok(Number::Fixnum(n)) => Some(n),
+ _ => None,
+ };
if max_steps_n.map(|i| i >= -1).unwrap_or(false) {
let n = self.store(self.deref(self[temp_v!(1)]));
Ok(Number::Integer(n)) => {
if n.as_ref() == &0 {
let xs0 = self[temp_v!(3)];
- let xs = self[temp_v!(4)];
+ let xs = self[temp_v!(4)];
self.unify(xs0, xs);
} else {
Ok(Number::Fixnum(n)) => {
if n == 0 {
let xs0 = self[temp_v!(3)];
- let xs = self[temp_v!(4)];
+ let xs = self[temp_v!(4)];
self.unify(xs0, xs);
} else {
}
} else {
let stub = MachineError::functor_stub(clause_name!("$skip_max_list"), 4);
- return Err(
- self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- addr
- ),
- stub,
- )
- );
+ return Err(self.error_form(
+ MachineError::type_error(self.heap.h(), ValidType::Integer, addr),
+ stub,
+ ));
}
}
}
) -> Result<Stream, MachineStub> {
if file_spec.as_str().is_empty() {
let stub = MachineError::functor_stub(clause_name!("open"), 4);
- let err = MachineError::domain_error(
- DomainErrorType::SourceSink,
- self[temp_v!(1)],
- );
+ let err = MachineError::domain_error(DomainErrorType::SourceSink, self[temp_v!(1)]);
return Err(self.error_form(err, stub));
}
// 8.11.5.3l)
if let Some(ref alias) = &options.alias {
if indices.stream_aliases.contains_key(alias) {
- return Err(self.occupied_alias_permission_error(
- alias.clone(),
- "open",
- 4,
- ));
+ return Err(self.occupied_alias_permission_error(alias.clone(), "open", 4));
}
}
let mode = atom_from!(self, self.store(self.deref(self[temp_v!(2)])));
let mut open_options = fs::OpenOptions::new();
- let (is_input_file, in_append_mode) =
- match mode.as_str() {
- "read" => {
- open_options.read(true).write(false).create(false);
- (true, false)
- }
- "write" => {
- open_options.read(false).write(true).truncate(true).create(true);
- (false, false)
- }
- "append" => {
- open_options.read(false).write(true).create(true).append(true);
- (false, true)
- }
- _ => {
- let stub = MachineError::functor_stub(clause_name!("open"), 4);
- let err = MachineError::domain_error(
- DomainErrorType::IOMode,
- self[temp_v!(2)],
- );
+ let (is_input_file, in_append_mode) = match mode.as_str() {
+ "read" => {
+ open_options.read(true).write(false).create(false);
+ (true, false)
+ }
+ "write" => {
+ open_options
+ .read(false)
+ .write(true)
+ .truncate(true)
+ .create(true);
+ (false, false)
+ }
+ "append" => {
+ open_options
+ .read(false)
+ .write(true)
+ .create(true)
+ .append(true);
+ (false, true)
+ }
+ _ => {
+ let stub = MachineError::functor_stub(clause_name!("open"), 4);
+ let err = MachineError::domain_error(DomainErrorType::IOMode, self[temp_v!(2)]);
- // 8.11.5.3h)
- return Err(self.error_form(err, stub));
- }
- };
+ // 8.11.5.3h)
+ return Err(self.error_form(err, stub));
+ }
+ };
- let file =
- match open_options.open(file_spec.as_str()) {
- Ok(file) => {
- file
- }
- Err(err) => {
- match err.kind() {
- ErrorKind::NotFound => {
- // 8.11.5.3j)
- let stub = MachineError::functor_stub(
- clause_name!("open"),
- 4,
- );
+ let file = match open_options.open(file_spec.as_str()) {
+ Ok(file) => file,
+ Err(err) => {
+ match err.kind() {
+ ErrorKind::NotFound => {
+ // 8.11.5.3j)
+ let stub = MachineError::functor_stub(clause_name!("open"), 4);
- let err = MachineError::existence_error(
- self.heap.h(),
- ExistenceError::SourceSink(self[temp_v!(1)]),
- );
+ let err = MachineError::existence_error(
+ self.heap.h(),
+ ExistenceError::SourceSink(self[temp_v!(1)]),
+ );
- return Err(self.error_form(err, stub));
- }
- ErrorKind::PermissionDenied => {
- // 8.11.5.3k)
- return Err(self.open_permission_error(self[temp_v!(1)], "open", 4));
- }
- _ => {
- let stub = MachineError::functor_stub(
- clause_name!("open"),
- 4,
- );
+ return Err(self.error_form(err, stub));
+ }
+ ErrorKind::PermissionDenied => {
+ // 8.11.5.3k)
+ return Err(self.open_permission_error(self[temp_v!(1)], "open", 4));
+ }
+ _ => {
+ let stub = MachineError::functor_stub(clause_name!("open"), 4);
- let err = MachineError::syntax_error(
- self.heap.h(),
- ParserError::IO(err),
- );
+ let err = MachineError::syntax_error(self.heap.h(), ParserError::IO(err));
- return Err(self.error_form(err, stub));
- }
+ return Err(self.error_form(err, stub));
}
}
- };
+ }
+ };
Ok(if is_input_file {
Stream::from_file_as_input(file_spec, file)
fn copy_findall_solution(&mut self, lh_offset: usize, copy_target: Addr) -> usize {
let threshold = self.lifted_heap.h() - lh_offset;
- let mut copy_ball_term = CopyBallTerm::new(
- &mut self.stack,
- &mut self.heap,
- &mut self.lifted_heap,
- );
+ let mut copy_ball_term =
+ CopyBallTerm::new(&mut self.stack, &mut self.heap, &mut self.lifted_heap);
copy_ball_term.push(HeapCellValue::Addr(Addr::Lis(threshold + 1)));
copy_ball_term.push(HeapCellValue::Addr(Addr::HeapCell(threshold + 3)));
self.lifted_heap.truncate(lh_offset);
} else {
let threshold = self.lifted_heap.h() - lh_offset;
- self.lifted_heap.push(HeapCellValue::Addr(addr_constr(threshold)));
+ self.lifted_heap
+ .push(HeapCellValue::Addr(addr_constr(threshold)));
}
}
_ => self.fail = true,
&CompositeOpDir::new(&indices.op_dir, None),
);
- let addr = self.heap.to_unifiable(HeapCellValue::DBRef(
- DBRef::NamedPred(
+ let addr = self
+ .heap
+ .to_unifiable(HeapCellValue::DBRef(DBRef::NamedPred(
name.clone(),
*arity,
spec,
- )
- ));
+ )));
self.bind(r, addr);
let a2 = self[temp_v!(2)];
if let Some(r) = a2.as_var() {
- let addr = self.heap.to_unifiable(
- HeapCellValue::DBRef(
- DBRef::Op(
- *priority,
- *spec,
- name.clone(),
- op_dir.clone(),
- SharedOpDesc::new(*priority, *spec)
- ),
- ),
- );
+ let addr = self.heap.to_unifiable(HeapCellValue::DBRef(DBRef::Op(
+ *priority,
+ *spec,
+ name.clone(),
+ op_dir.clone(),
+ SharedOpDesc::new(*priority, *spec),
+ )));
self.bind(r, addr);
} else {
n: &Integer,
stub: &'static str,
arity: usize,
- ) -> Result<char, MachineStub>
- {
+ ) -> Result<char, MachineStub> {
let c = n.to_u32().and_then(std::char::from_u32);
if let Some(c) = c {
string.push('.');
- let mut stream =
- match parsing_stream(std::io::Cursor::new(string)) {
- Ok(stream) => {
- stream
- }
- Err(e) => {
- let err = MachineError::session_error(
- self.heap.h(),
- SessionError::from(e),
- );
+ let mut stream = match parsing_stream(std::io::Cursor::new(string)) {
+ Ok(stream) => stream,
+ Err(e) => {
+ let err = MachineError::session_error(self.heap.h(), SessionError::from(e));
- return Err(self.error_form(err, stub));
- }
- };
+ return Err(self.error_form(err, stub));
+ }
+ };
- let mut parser = Parser::new(
- &mut stream,
- self.atom_tbl.clone(),
- self.machine_flags(),
- );
+ let mut parser = Parser::new(&mut stream, self.atom_tbl.clone(), self.machine_flags());
match parser.read_term(&CompositeOpDir::new(&indices.op_dir, None)) {
Err(err) => {
match &self.heap[s] {
HeapCellValue::NamedStr(arity, ..) => {
let num_cells = arity - 1;
- let p_functor = self.heap[s+1].as_addr(s+1);
+ let p_functor = self.heap[s + 1].as_addr(s + 1);
let cp = self.heap.to_local_code_ptr(&p_functor).unwrap();
let prev_e = self.e;
let e = self.stack.allocate_and_frame(num_cells);
let and_frame = self.stack.index_and_frame_mut(e);
- and_frame.prelude.e = prev_e;
+ and_frame.prelude.e = prev_e;
and_frame.prelude.cp = return_p;
self.p = CodePtr::Local(cp + 1);
// adjust cut point to occur after call_continuation.
if num_cells > 0 {
- if let Addr::CutPoint(_) = self.heap[s+2].as_addr(s+2) {
+ if let Addr::CutPoint(_) = self.heap[s + 2].as_addr(s + 2) {
and_frame[1] = Addr::CutPoint(self.b);
} else {
- and_frame[1] = self.heap[s+2].as_addr(s+2);
+ and_frame[1] = self.heap[s + 2].as_addr(s + 2);
}
}
- for index in s+3 .. s+2+num_cells {
- and_frame[index - (s+1)] = self.heap[index].as_addr(index);
+ for index in s + 3..s + 2 + num_cells {
+ and_frame[index - (s + 1)] = self.heap[index].as_addr(index);
}
self.e = e;
self.p.local()
}
- _ => unreachable!()
+ _ => unreachable!(),
}
}
- _ => unreachable!()
+ _ => unreachable!(),
}
}
- pub(super)
- fn system_call(
+ pub(super) fn system_call(
&mut self,
ct: &SystemClauseType,
code_repo: &CodeRepo,
match ct {
&SystemClauseType::BindFromRegister => {
let reg = self.store(self.deref(self[temp_v!(2)]));
- let n =
- match Number::try_from((reg, &self.heap)) {
- Ok(Number::Integer(n)) => {
- n.to_usize()
- }
- Ok(Number::Fixnum(n)) => {
- usize::try_from(n).ok()
- }
- _ => {
- unreachable!()
- }
- };
+ let n = match Number::try_from((reg, &self.heap)) {
+ Ok(Number::Integer(n)) => n.to_usize(),
+ Ok(Number::Fixnum(n)) => usize::try_from(n).ok(),
+ _ => {
+ unreachable!()
+ }
+ };
if let Some(n) = n {
if n <= MAX_ARITY {
let target = self[temp_v!(n)];
- let addr = self[temp_v!(1)];
+ let addr = self[temp_v!(1)];
self.unify(addr, target);
return return_from_clause!(self.last_call, self);
}
&SystemClauseType::CurrentHostname => {
match hostname::get().ok() {
- Some(host) => {
- match host.into_string().ok() {
- Some(host) => {
- let hostname = self.heap.to_unifiable(
- HeapCellValue::Atom(clause_name!(host, self.atom_tbl), None)
- );
+ Some(host) => match host.into_string().ok() {
+ Some(host) => {
+ let hostname = self.heap.to_unifiable(HeapCellValue::Atom(
+ clause_name!(host, self.atom_tbl),
+ None,
+ ));
- self.unify(self[temp_v!(1)], hostname);
- return return_from_clause!(self.last_call, self);
- }
- None => {
- }
+ self.unify(self[temp_v!(1)], hostname);
+ return return_from_clause!(self.last_call, self);
}
- }
- None => {
- }
+ None => {}
+ },
+ None => {}
}
self.fail = true;
}
}
addr => {
- let stub = MachineError::functor_stub(
- clause_name!("current_input"),
- 1,
- );
+ let stub = MachineError::functor_stub(clause_name!("current_input"), 1);
- let err = MachineError::domain_error(
- DomainErrorType::Stream,
- addr,
- );
+ let err = MachineError::domain_error(DomainErrorType::Stream, addr);
return Err(self.error_form(err, stub));
}
}
}
addr => {
- let stub = MachineError::functor_stub(
- clause_name!("current_input"),
- 1,
- );
+ let stub = MachineError::functor_stub(clause_name!("current_input"), 1);
- let err = MachineError::domain_error(
- DomainErrorType::Stream,
- addr,
- );
+ let err = MachineError::domain_error(DomainErrorType::Stream, addr);
return Err(self.error_form(err, stub));
}
for entry in entries {
if let Ok(entry) = entry {
match entry.file_name().into_string() {
- Ok(name) => { files.push(self.heap.put_complete_string(&name)); }
+ Ok(name) => {
+ files.push(self.heap.put_complete_string(&name));
+ }
_ => {
- let stub = MachineError::functor_stub(clause_name!("directory_files"), 2);
- let err = MachineError::representation_error(RepFlag::Character);
+ let stub = MachineError::functor_stub(
+ clause_name!("directory_files"),
+ 2,
+ );
+ let err =
+ MachineError::representation_error(RepFlag::Character);
let err = self.error_form(err, stub);
return Err(err);
}
&SystemClauseType::FileExists => {
let file = self.heap_pstr_iter(self[temp_v!(1)]).to_string();
- if !std::path::Path::new(&file).exists() || !fs::metadata(&file).unwrap().is_file() {
+ if !std::path::Path::new(&file).exists() || !fs::metadata(&file).unwrap().is_file()
+ {
self.fail = true;
return Ok(());
}
}
&SystemClauseType::DirectoryExists => {
let directory = self.heap_pstr_iter(self[temp_v!(1)]).to_string();
- if !std::path::Path::new(&directory).exists() || !fs::metadata(&directory).unwrap().is_dir() {
+ if !std::path::Path::new(&directory).exists()
+ || !fs::metadata(&directory).unwrap().is_dir()
+ {
self.fail = true;
return Ok(());
}
}
&SystemClauseType::DirectorySeparator => {
- let addr = self.heap.put_constant(Constant::Char(std::path::MAIN_SEPARATOR));
+ let addr = self
+ .heap
+ .put_constant(Constant::Char(std::path::MAIN_SEPARATOR));
self.unify(self[temp_v!(1)], addr);
}
&SystemClauseType::MakeDirectory => {
let directory = self.heap_pstr_iter(self[temp_v!(1)]).to_string();
match fs::create_dir(directory) {
- Ok(_) => { }
- _ => { self.fail = true;
- return Ok(());
+ Ok(_) => {}
+ _ => {
+ self.fail = true;
+ return Ok(());
}
}
}
let file = self.heap_pstr_iter(self[temp_v!(1)]).to_string();
match fs::remove_file(file) {
- Ok(_) => { }
- _ => { self.fail = true;
- return Ok(());
+ Ok(_) => {}
+ _ => {
+ self.fail = true;
+ return Ok(());
}
}
}
&SystemClauseType::WorkingDirectory => {
if let Ok(dir) = env::current_dir() {
- let current =
- match dir.to_str() {
- Some(d) => { d }
- _ => { let stub = MachineError::functor_stub(clause_name!("working_directory"), 2);
- let err = MachineError::representation_error(RepFlag::Character);
- let err = self.error_form(err, stub);
-
- return Err(err);
- }
- };
+ let current = match dir.to_str() {
+ Some(d) => d,
+ _ => {
+ let stub =
+ MachineError::functor_stub(clause_name!("working_directory"), 2);
+ let err = MachineError::representation_error(RepFlag::Character);
+ let err = self.error_form(err, stub);
+
+ return Err(err);
+ }
+ };
let chars = self.heap.put_complete_string(current);
self.unify(self[temp_v!(1)], chars);
let next = self.heap_pstr_iter(self[temp_v!(2)]).to_string();
match env::set_current_dir(std::path::Path::new(&next)) {
- Ok(_) => { }
- _ => { self.fail = true;
- return Ok(());
+ Ok(_) => {}
+ _ => {
+ self.fail = true;
+ return Ok(());
}
}
} else {
match fs::canonicalize(path) {
Ok(canonical) => {
- let cs =
- match canonical.to_str() {
- Some(s) => { s }
- _ => {
- let stub = MachineError::functor_stub(clause_name!("path_canonical"), 2);
- let err = MachineError::representation_error(RepFlag::Character);
- let err = self.error_form(err, stub);
+ let cs = match canonical.to_str() {
+ Some(s) => s,
+ _ => {
+ let stub =
+ MachineError::functor_stub(clause_name!("path_canonical"), 2);
+ let err = MachineError::representation_error(RepFlag::Character);
+ let err = self.error_form(err, stub);
- return Err(err);
- }
- };
+ return Err(err);
+ }
+ };
let chars = self.heap.put_complete_string(cs);
self.unify(self[temp_v!(2)], chars);
}
};
if let Ok(md) = fs::metadata(file) {
- if let Ok(time) =
- match which {
- "modification" => { md.modified() }
- "access" => { md.accessed() }
- "creation" => { md.created() }
- _ => { unreachable!() }
- } {
+ if let Ok(time) = match which {
+ "modification" => md.modified(),
+ "access" => md.accessed(),
+ "creation" => md.created(),
+ _ => {
+ unreachable!()
+ }
+ } {
let chars = self.systemtime_to_timestamp(time);
self.unify(self[temp_v!(3)], chars);
} else {
self.unify(a2, list_of_chars);
}
Addr::Con(h) if self.heap.atom_at(h) => {
- if let HeapCellValue::Atom(name, _) = self.heap.clone(h) {
- let s = self.heap.put_complete_string(name.as_str());
+ if let HeapCellValue::Atom(name, _) = self.heap.clone(h) {
+ let s = self.heap.put_complete_string(name.as_str());
let a2 = self[temp_v!(2)];
self.unify(s, a2);
}
Addr::EmptyList => {
let a2 = self[temp_v!(2)];
- let chars = vec![
- Addr::Char('['),
- Addr::Char(']'),
- ];
+ let chars = vec![Addr::Char('['), Addr::Char(']')];
- let list_of_chars =
- Addr::HeapCell(self.heap.to_list(chars.into_iter()));
+ let list_of_chars = Addr::HeapCell(self.heap.to_list(chars.into_iter()));
self.unify(a2, list_of_chars);
}
self.unify(addr, Addr::EmptyList);
} else {
let chars = clause_name!(string, self.atom_tbl);
- let atom = self.heap.to_unifiable(
- HeapCellValue::Atom(chars, None)
- );
+ let atom =
+ self.heap.to_unifiable(HeapCellValue::Atom(chars, None));
self.unify(addr, atom);
}
}
focus => {
if let Addr::Lis(l) = focus {
- let stub = MachineError::functor_stub(
- clause_name!("atom_chars"),
- 2,
- );
+ let stub =
+ MachineError::functor_stub(clause_name!("atom_chars"), 2);
let err = MachineError::type_error(
self.heap.h(),
self.unify(a2, list_of_codes);
}
Addr::Con(h) if self.heap.atom_at(h) => {
- if let HeapCellValue::Atom(name, _) = self.heap.clone(h) {
+ if let HeapCellValue::Atom(name, _) = self.heap.clone(h) {
let a2 = self.store(self.deref(self[temp_v!(2)]));
- let iter = name
- .as_str()
- .chars()
- .map(|c| Addr::Fixnum(c as isize));
+ let iter = name.as_str().chars().map(|c| Addr::Fixnum(c as isize));
let list_of_codes = Addr::HeapCell(self.heap.to_list(iter));
}
}
Addr::EmptyList => {
- let chars = vec![
- Addr::Fixnum('[' as isize),
- Addr::Fixnum(']' as isize),
- ];
+ let chars = vec![Addr::Fixnum('[' as isize), Addr::Fixnum(']' as isize)];
let list_of_codes = Addr::HeapCell(self.heap.to_list(chars.into_iter()));
let a2 = self[temp_v!(2)];
}
}
- let string = self.heap.to_unifiable(
- HeapCellValue::Atom(clause_name!(chars, self.atom_tbl), None)
- );
+ let string = self.heap.to_unifiable(HeapCellValue::Atom(
+ clause_name!(chars, self.atom_tbl),
+ None,
+ ));
self.bind(addr.as_var().unwrap(), string);
}
Err(e) => {
return Err(e);
}
- Ok(addrs) => {
- match self.try_char_list(addrs) {
- Ok(string) => {
- let stub = MachineError::functor_stub(clause_name!("number_chars"), 2);
- self.parse_number_from_string(string, indices, stub)?;
- }
- Err(err) => {
- let stub = MachineError::functor_stub(
- clause_name!("number_chars"),
- 2,
- );
+ Ok(addrs) => match self.try_char_list(addrs) {
+ Ok(string) => {
+ let stub = MachineError::functor_stub(clause_name!("number_chars"), 2);
+ self.parse_number_from_string(string, indices, stub)?;
+ }
+ Err(err) => {
+ let stub = MachineError::functor_stub(clause_name!("number_chars"), 2);
- return Err(self.error_form(err, stub));
- }
+ return Err(self.error_form(err, stub));
}
- }
+ },
}
}
&SystemClauseType::CreatePartialString => {
self.fail = true;
return Ok(());
}
- _ => {
- }
+ _ => {}
}
let mut heap_pstr_iter = self.heap_pstr_iter(addr);
while let Some(_) = heap_pstr_iter.next() {}
- self.fail =
- match heap_pstr_iter.focus() {
- Addr::AttrVar(_) | Addr::HeapCell(_) | Addr::StackCell(..) |
- Addr::EmptyList => {
- false
- }
- _ => {
- true
- }
- };
+ self.fail = match heap_pstr_iter.focus() {
+ Addr::AttrVar(_)
+ | Addr::HeapCell(_)
+ | Addr::StackCell(..)
+ | Addr::EmptyList => false,
+ _ => true,
+ };
}
&SystemClauseType::PartialStringTail => {
let pstr = self.store(self.deref(self[temp_v!(1)]));
return return_from_clause!(self.last_call, self);
}
- let addr =
- match self.store(self.deref(self[temp_v!(2)])) {
- addr if addr.is_ref() => {
- addr
+ let addr = match self.store(self.deref(self[temp_v!(2)])) {
+ addr if addr.is_ref() => addr,
+ addr => match Number::try_from((addr, &self.heap)) {
+ Ok(Number::Integer(n)) => {
+ if let Some(nb) = n.to_u8() {
+ Addr::Usize(nb as usize)
+ } else {
+ return Err(self.type_error(
+ ValidType::InByte,
+ addr,
+ clause_name!("peek_byte"),
+ 2,
+ ));
+ }
}
- addr => {
- match Number::try_from((addr, &self.heap)) {
- Ok(Number::Integer(n)) => {
- if let Some(nb) = n.to_u8() {
- Addr::Usize(nb as usize)
- } else {
- return Err(self.type_error(
- ValidType::InByte,
- addr,
- clause_name!("peek_byte"),
- 2,
- ));
- }
- }
- Ok(Number::Fixnum(n)) => {
- if let Ok(nb) = u8::try_from(n) {
- Addr::Usize(nb as usize)
- } else {
- return Err(self.type_error(
- ValidType::InByte,
- addr,
- clause_name!("peek_byte"),
- 2,
- ));
- }
- }
- _ => {
- return Err(self.type_error(
- ValidType::InByte,
- addr,
- clause_name!("peek_byte"),
- 2,
- ));
- }
+ Ok(Number::Fixnum(n)) => {
+ if let Ok(nb) = u8::try_from(n) {
+ Addr::Usize(nb as usize)
+ } else {
+ return Err(self.type_error(
+ ValidType::InByte,
+ addr,
+ clause_name!("peek_byte"),
+ 2,
+ ));
}
}
- };
+ _ => {
+ return Err(self.type_error(
+ ValidType::InByte,
+ addr,
+ clause_name!("peek_byte"),
+ 2,
+ ));
+ }
+ },
+ };
loop {
match stream.peek_byte().map_err(|e| e.kind()) {
if stream.at_end_of_stream() {
let end_of_file = clause_name!("end_of_file");
- let end_of_file = self.heap.to_unifiable(
- HeapCellValue::Atom(end_of_file, None),
- );
+ let end_of_file = self
+ .heap
+ .to_unifiable(HeapCellValue::Atom(end_of_file, None));
stream.set_past_end_of_stream();
return return_from_clause!(self.last_call, self);
}
- let addr =
- match self.store(self.deref(self[temp_v!(2)])) {
- addr if addr.is_ref() => {
- addr
- }
- Addr::Con(h) if self.heap.atom_at(h) => {
- match &self.heap[h] {
- HeapCellValue::Atom(ref atom, _) if atom.is_char() => {
- if let Some(c) = atom.as_str().chars().next() {
- Addr::Char(c)
- } else {
- unreachable!()
- }
- }
- culprit => {
- return Err(self.type_error(
- ValidType::InCharacter,
- culprit.as_addr(h),
- clause_name!("peek_char"),
- 2,
- ));
- }
+ let addr = match self.store(self.deref(self[temp_v!(2)])) {
+ addr if addr.is_ref() => addr,
+ Addr::Con(h) if self.heap.atom_at(h) => match &self.heap[h] {
+ HeapCellValue::Atom(ref atom, _) if atom.is_char() => {
+ if let Some(c) = atom.as_str().chars().next() {
+ Addr::Char(c)
+ } else {
+ unreachable!()
}
}
- Addr::Char(d) => {
- Addr::Char(d)
- }
culprit => {
return Err(self.type_error(
ValidType::InCharacter,
- culprit,
+ culprit.as_addr(h),
clause_name!("peek_char"),
2,
));
}
- };
-
- loop {
- match stream.peek_char().map_err(|e| e.kind()) {
- Ok(d) => {
- if let Some(var) = addr.as_var() {
- self.bind(var, Addr::Char(d));
- break;
+ },
+ Addr::Char(d) => Addr::Char(d),
+ culprit => {
+ return Err(self.type_error(
+ ValidType::InCharacter,
+ culprit,
+ clause_name!("peek_char"),
+ 2,
+ ));
+ }
+ };
+
+ loop {
+ match stream.peek_char().map_err(|e| e.kind()) {
+ Ok(d) => {
+ if let Some(var) = addr.as_var() {
+ self.bind(var, Addr::Char(d));
+ break;
} else if addr == Addr::Char(d) {
break;
} else {
} else if self.fail {
return Ok(());
}
- }/*
- _ => {
- let stub = MachineError::functor_stub(clause_name!("peek_char"), 2);
- let err = MachineError::representation_error(RepFlag::Character);
- let err = self.error_form(err, stub);
+ } /*
+ _ => {
+ let stub = MachineError::functor_stub(clause_name!("peek_char"), 2);
+ let err = MachineError::representation_error(RepFlag::Character);
+ let err = self.error_form(err, stub);
- return Err(err);
- }*/
+ return Err(err);
+ }*/
}
}
}
if stream.at_end_of_stream() {
let end_of_file = clause_name!("end_of_file");
- let end_of_file = self.heap.to_unifiable(
- HeapCellValue::Atom(end_of_file, None),
- );
+ let end_of_file = self
+ .heap
+ .to_unifiable(HeapCellValue::Atom(end_of_file, None));
stream.set_past_end_of_stream();
return return_from_clause!(self.last_call, self);
}
- let addr =
- match self.store(self.deref(self[temp_v!(2)])) {
- addr if addr.is_ref() => {
- addr
- }
- addr => {
- match Number::try_from((addr, &self.heap)) {
- Ok(Number::Integer(n)) => {
- let n = n.to_u32().and_then(|n| {
- std::char::from_u32(n).and_then(|_| Some(n))
- });
+ let addr = match self.store(self.deref(self[temp_v!(2)])) {
+ addr if addr.is_ref() => addr,
+ addr => match Number::try_from((addr, &self.heap)) {
+ Ok(Number::Integer(n)) => {
+ let n = n
+ .to_u32()
+ .and_then(|n| std::char::from_u32(n).and_then(|_| Some(n)));
- if let Some(n) = n {
- Addr::Fixnum(n as isize)
- } else {
- return Err(self.representation_error(
- RepFlag::InCharacterCode,
- clause_name!("peek_code"),
- 2,
- ));
- }
- }
- Ok(Number::Fixnum(n)) => {
- let n = u32::try_from(n).ok().and_then(|n| {
- std::char::from_u32(n).and_then(|_| Some(n))
- });
+ if let Some(n) = n {
+ Addr::Fixnum(n as isize)
+ } else {
+ return Err(self.representation_error(
+ RepFlag::InCharacterCode,
+ clause_name!("peek_code"),
+ 2,
+ ));
+ }
+ }
+ Ok(Number::Fixnum(n)) => {
+ let n = u32::try_from(n)
+ .ok()
+ .and_then(|n| std::char::from_u32(n).and_then(|_| Some(n)));
- if let Some(n) = n {
- Addr::Fixnum(n as isize)
- } else {
- return Err(self.representation_error(
- RepFlag::InCharacterCode,
- clause_name!("peek_code"),
- 2,
- ));
- }
- }
- _ => {
- return Err(self.type_error(
- ValidType::Integer,
- self[temp_v!(2)],
- clause_name!("peek_code"),
- 2,
- ));
- }
+ if let Some(n) = n {
+ Addr::Fixnum(n as isize)
+ } else {
+ return Err(self.representation_error(
+ RepFlag::InCharacterCode,
+ clause_name!("peek_code"),
+ 2,
+ ));
}
}
- };
+ _ => {
+ return Err(self.type_error(
+ ValidType::Integer,
+ self[temp_v!(2)],
+ clause_name!("peek_code"),
+ 2,
+ ));
+ }
+ },
+ };
loop {
let result = stream.peek_char();
} else if self.fail {
return Ok(());
}
- } }
+ }
+ }
}
}
&SystemClauseType::NumberToChars => {
let n = self.store(self.deref(n));
- let string =
- match Number::try_from((n, &self.heap)) {
- Ok(Number::Float(OrderedFloat(n))) => {
- format!("{0:<20?}", n)
- }
- Ok(Number::Fixnum(n)) => {
- n.to_string()
- }
- Ok(Number::Integer(n)) => {
- n.to_string()
- }
- Ok(Number::Rational(r)) => {
- // n has already been confirmed as an integer, and
- // internally, Rational is assumed reduced, so its denominator
- // must be 1.
- r.numer().to_string()
- }
- _ => {
- unreachable!()
- }
- };
+ let string = match Number::try_from((n, &self.heap)) {
+ Ok(Number::Float(OrderedFloat(n))) => {
+ format!("{0:<20?}", n)
+ }
+ Ok(Number::Fixnum(n)) => n.to_string(),
+ Ok(Number::Integer(n)) => n.to_string(),
+ Ok(Number::Rational(r)) => {
+ // n has already been confirmed as an integer, and
+ // internally, Rational is assumed reduced, so its denominator
+ // must be 1.
+ r.numer().to_string()
+ }
+ _ => {
+ unreachable!()
+ }
+ };
let chars = string.trim().chars().map(|c| Addr::Char(c));
let char_list = Addr::HeapCell(self.heap.to_list(chars));
let n = self[temp_v!(1)];
let chs = self[temp_v!(2)];
- let string =
- match Number::try_from((n, &self.heap)) {
- Ok(Number::Float(OrderedFloat(n))) => {
- format!("{0:<20?}", n)
- }
- Ok(Number::Fixnum(n)) => {
- n.to_string()
- }
- Ok(Number::Integer(n)) => {
- n.to_string()
- }
- Ok(Number::Rational(r)) => {
- // n has already been confirmed as an integer, and
- // internally, Rational is assumed reduced, so its
- // denominator must be 1.
- r.numer().to_string()
- }
- _ => {
- unreachable!()
- }
- };
+ let string = match Number::try_from((n, &self.heap)) {
+ Ok(Number::Float(OrderedFloat(n))) => {
+ format!("{0:<20?}", n)
+ }
+ Ok(Number::Fixnum(n)) => n.to_string(),
+ Ok(Number::Integer(n)) => n.to_string(),
+ Ok(Number::Rational(r)) => {
+ // n has already been confirmed as an integer, and
+ // internally, Rational is assumed reduced, so its
+ // denominator must be 1.
+ r.numer().to_string()
+ }
+ _ => {
+ unreachable!()
+ }
+ };
- let codes = string
- .trim()
- .chars()
- .map(|c| Addr::Fixnum(c as isize));
+ let codes = string.trim().chars().map(|c| Addr::Fixnum(c as isize));
let codes_list = Addr::HeapCell(self.heap.to_list(codes));
Err(e) => {
return Err(e);
}
- Ok(addrs) => {
- match self.try_char_list(addrs) {
- Ok(chars) => {
- let stub = MachineError::functor_stub(clause_name!("number_codes"), 2);
- self.parse_number_from_string(chars, indices, stub)?;
- }
- Err(err) => {
- let stub = MachineError::functor_stub(
- clause_name!("number_codes"),
- 2,
- );
+ Ok(addrs) => match self.try_char_list(addrs) {
+ Ok(chars) => {
+ let stub = MachineError::functor_stub(clause_name!("number_codes"), 2);
+ self.parse_number_from_string(chars, indices, stub)?;
+ }
+ Err(err) => {
+ let stub = MachineError::functor_stub(clause_name!("number_codes"), 2);
- return Err(self.error_form(err, stub));
- }
+ return Err(self.error_form(err, stub));
}
- }
+ },
}
}
&SystemClauseType::LiftedHeapLength => {
match self.store(self.deref(a1)) {
Addr::Con(h) if self.heap.atom_at(h) => {
- let c =
- if let HeapCellValue::Atom(name, _) = &self.heap[h] {
- if name.is_char() {
- name.as_str().chars().next().unwrap()
- } else {
- self.fail = true;
- return Ok(());
- }
+ let c = if let HeapCellValue::Atom(name, _) = &self.heap[h] {
+ if name.is_char() {
+ name.as_str().chars().next().unwrap()
} else {
- unreachable!()
- };
+ self.fail = true;
+ return Ok(());
+ }
+ } else {
+ unreachable!()
+ };
let a2 = self[temp_v!(2)];
self.unify(Addr::Fixnum(c as isize), a2);
let a2 = self.store(self.deref(a2));
let c = match Number::try_from((a2, &self.heap)) {
- Ok(Number::Integer(n)) => {
- self.int_to_char(&n, "char_code", 2)?
- }
+ Ok(Number::Integer(n)) => self.int_to_char(&n, "char_code", 2)?,
Ok(Number::Fixnum(n)) => {
self.int_to_char(&Integer::from(n), "char_code", 2)?
}
Addr::Con(h) if self.heap.atom_at(h) => {
if let HeapCellValue::Atom(name, _) = &self.heap[h] {
name.as_str().chars().next().unwrap()
- }
- else {
+ } else {
unreachable!()
}
}
- _ => unreachable!()
+ _ => unreachable!(),
};
let chars = match a2 {
Addr::Con(h) if self.heap.atom_at(h) => {
if let HeapCellValue::Atom(name, _) = &self.heap[h] {
name.as_str().to_string()
- }
- else {
+ } else {
unreachable!()
}
}
- Addr::Char(c) => {
- c.to_string()
- }
- _ => unreachable!()
+ Addr::Char(c) => c.to_string(),
+ _ => unreachable!(),
};
self.fail = true; // This predicate fails by default.
macro_rules! macro_check {
($id:ident, $name:tt) => {
- if $id!(c) && chars == $name {
- self.fail = false;
+ if $id!(c) && chars == $name {
+ self.fail = false;
- return return_from_clause!(self.last_call, self);
- }
- }
+ return return_from_clause!(self.last_call, self);
+ }
+ };
}
macro_rules! method_check {
($id:ident, $name:tt) => {
- if c.$id() && chars == $name {
- self.fail = false;
+ if c.$id() && chars == $name {
+ self.fail = false;
- return return_from_clause!(self.last_call, self);
- }
- }
+ return return_from_clause!(self.last_call, self);
+ }
+ };
}
macro_check!(symbolic_control_char, "symbolic_control");
// macro_check!(space_char, "space");
self.heap.extend(stub.into_iter());
self.unify(addr, Addr::HeapCell(h));
}
- Some((_, Some(h))) => {
- self.unify(addr, Addr::HeapCell(*h))
- }
+ Some((_, Some(h))) => self.unify(addr, Addr::HeapCell(*h)),
None => self.fail = true,
};
}
self.unify(addr, Addr::HeapCell(*h));
}
}
- None => {
- self.fail = true
- }
+ None => self.fail = true,
};
}
&SystemClauseType::PutCode => {
}
}
Ok(Number::Fixnum(n)) => {
- if let Some(c) = u32::try_from(n).ok().and_then(|c| char::try_from(c).ok()) {
+ if let Some(c) =
+ u32::try_from(n).ok().and_then(|c| char::try_from(c).ok())
+ {
write!(&mut stream, "{}", c).unwrap();
return return_from_clause!(self.last_call, self);
}
}
let stub = MachineError::functor_stub(clause_name!("put_code"), 2);
- let err = MachineError::representation_error(
- RepFlag::CharacterCode,
- );
+ let err = MachineError::representation_error(RepFlag::CharacterCode);
return Err(self.error_form(err, stub));
}
}
addr => {
match self.store(self.deref(self[temp_v!(2)])) {
- Addr::Con(h) if self.heap.atom_at(h) => {
- match &self.heap[h] {
- HeapCellValue::Atom(ref atom, _) if atom.is_char() => {
- if let Some(c) = atom.as_str().chars().next() {
- write!(&mut stream, "{}", c).unwrap();
- return return_from_clause!(self.last_call, self);
- } else {
- unreachable!()
- }
- }
- _ => {
+ Addr::Con(h) if self.heap.atom_at(h) => match &self.heap[h] {
+ HeapCellValue::Atom(ref atom, _) if atom.is_char() => {
+ if let Some(c) = atom.as_str().chars().next() {
+ write!(&mut stream, "{}", c).unwrap();
+ return return_from_clause!(self.last_call, self);
+ } else {
+ unreachable!()
}
}
- }
+ _ => {}
+ },
Addr::Char(c) => {
write!(&mut stream, "{}", c).unwrap();
return return_from_clause!(self.last_call, self);
}
- _ => {
- }
+ _ => {}
}
let stub = MachineError::functor_stub(clause_name!("put_char"), 2);
- let err = MachineError::type_error(
- self.heap.h(),
- ValidType::Character,
- addr,
- );
+ let err =
+ MachineError::type_error(self.heap.h(), ValidType::Character, addr);
return Err(self.error_form(err, stub));
}
if stream.options.stream_type == StreamType::Binary {
for c in string.chars() {
if c as u32 > 255 {
-
let stub = MachineError::functor_stub(clause_name!("$put_chars"), 2);
let err = MachineError::type_error(
return return_from_clause!(self.last_call, self);
}
_ => {
- let stub = MachineError::functor_stub(
- clause_name!("$put_chars"),
- 2,
- );
+ let stub = MachineError::functor_stub(clause_name!("$put_chars"), 2);
- let addr = self.heap.to_unifiable(
- HeapCellValue::Stream(stream.clone()),
- );
+ let addr = self
+ .heap
+ .to_unifiable(HeapCellValue::Stream(stream.clone()));
return Err(self.error_form(
MachineError::existence_error(
}
}
}
- _ => {
- }
+ _ => {}
}
let stub = MachineError::functor_stub(clause_name!("put_byte"), 2);
)?;
if stream.past_end_of_stream() {
- self.eof_action(
- self[temp_v!(2)],
- &mut stream,
- clause_name!("get_byte"),
- 2,
- )?;
+ self.eof_action(self[temp_v!(2)], &mut stream, clause_name!("get_byte"), 2)?;
if EOFAction::Reset != stream.options.eof_action {
return return_from_clause!(self.last_call, self);
}
}
- let addr =
- match self.store(self.deref(self[temp_v!(2)])) {
- addr if addr.is_ref() => {
- addr
+ let addr = match self.store(self.deref(self[temp_v!(2)])) {
+ addr if addr.is_ref() => addr,
+ addr => match Number::try_from((addr, &self.heap)) {
+ Ok(Number::Integer(n)) => {
+ if let Some(nb) = n.to_u8() {
+ Addr::Usize(nb as usize)
+ } else {
+ return Err(self.type_error(
+ ValidType::InByte,
+ addr,
+ clause_name!("get_byte"),
+ 2,
+ ));
+ }
}
- addr => {
- match Number::try_from((addr, &self.heap)) {
- Ok(Number::Integer(n)) => {
- if let Some(nb) = n.to_u8() {
- Addr::Usize(nb as usize)
- } else {
- return Err(self.type_error(
- ValidType::InByte,
- addr,
- clause_name!("get_byte"),
- 2,
- ));
- }
- }
- Ok(Number::Fixnum(n)) => {
- if let Ok(nb) = u8::try_from(n) {
- Addr::Usize(nb as usize)
- } else {
- return Err(self.type_error(
- ValidType::InByte,
- addr,
- clause_name!("get_byte"),
- 2,
- ));
- }
- }
- _ => {
- return Err(self.type_error(
- ValidType::InByte,
- addr,
- clause_name!("get_byte"),
- 2,
- ));
- }
+ Ok(Number::Fixnum(n)) => {
+ if let Ok(nb) = u8::try_from(n) {
+ Addr::Usize(nb as usize)
+ } else {
+ return Err(self.type_error(
+ ValidType::InByte,
+ addr,
+ clause_name!("get_byte"),
+ 2,
+ ));
}
}
- };
+ _ => {
+ return Err(self.type_error(
+ ValidType::InByte,
+ addr,
+ clause_name!("get_byte"),
+ 2,
+ ));
+ }
+ },
+ };
loop {
let mut b = [0u8; 1];
if stream.at_end_of_stream() {
let end_of_file = clause_name!("end_of_file");
- let end_of_file = self.heap.to_unifiable(
- HeapCellValue::Atom(end_of_file, None),
- );
+ let end_of_file = self
+ .heap
+ .to_unifiable(HeapCellValue::Atom(end_of_file, None));
stream.set_past_end_of_stream();
return return_from_clause!(self.last_call, self);
}
- let mut iter = self.open_parsing_stream(
- stream.clone(),
- "get_char",
- 2,
- )?;
+ let mut iter = self.open_parsing_stream(stream.clone(), "get_char", 2)?;
- let addr =
- match self.store(self.deref(self[temp_v!(2)])) {
- addr if addr.is_ref() => {
- addr
- }
- Addr::Con(h) if self.heap.atom_at(h) => {
- match &self.heap[h] {
- HeapCellValue::Atom(ref atom, _) if atom.is_char() => {
- if let Some(c) = atom.as_str().chars().next() {
- Addr::Char(c)
- } else {
- unreachable!()
- }
- }
- culprit => {
- return Err(self.type_error(
- ValidType::InCharacter,
- culprit.as_addr(h),
- clause_name!("get_char"),
- 2,
- ));
- }
+ let addr = match self.store(self.deref(self[temp_v!(2)])) {
+ addr if addr.is_ref() => addr,
+ Addr::Con(h) if self.heap.atom_at(h) => match &self.heap[h] {
+ HeapCellValue::Atom(ref atom, _) if atom.is_char() => {
+ if let Some(c) = atom.as_str().chars().next() {
+ Addr::Char(c)
+ } else {
+ unreachable!()
}
}
- Addr::Char(d) => {
- Addr::Char(d)
- }
culprit => {
return Err(self.type_error(
ValidType::InCharacter,
- culprit,
+ culprit.as_addr(h),
clause_name!("get_char"),
2,
));
}
- };
+ },
+ Addr::Char(d) => Addr::Char(d),
+ culprit => {
+ return Err(self.type_error(
+ ValidType::InCharacter,
+ culprit,
+ clause_name!("get_char"),
+ 2,
+ ));
+ }
+ };
loop {
let result = iter.next();
} else if self.fail {
return Ok(());
}
- }/*
- _ => {
- let stub = MachineError::functor_stub(clause_name!("get_char"), 2);
- let err = MachineError::representation_error(RepFlag::Character);
- let err = self.error_form(err, stub);
+ } /*
+ _ => {
+ let stub = MachineError::functor_stub(clause_name!("get_char"), 2);
+ let err = MachineError::representation_error(RepFlag::Character);
+ let err = self.error_form(err, stub);
- return Err(err);
- }*/
+ return Err(err);
+ }*/
}
}
}
let stream =
self.get_stream_or_alias(self[temp_v!(1)], indices, "get_n_chars", 3)?;
- let num =
- match Number::try_from((self[temp_v!(2)], &self.heap)) {
- Ok(Number::Fixnum(n)) => {
- usize::try_from(n).unwrap()
- }
- Ok(Number::Integer(n)) => {
- match n.to_usize() {
- Some(u) => { u }
- _ => { self.fail = true; return Ok(()); }
- }
+ let num = match Number::try_from((self[temp_v!(2)], &self.heap)) {
+ Ok(Number::Fixnum(n)) => usize::try_from(n).unwrap(),
+ Ok(Number::Integer(n)) => match n.to_usize() {
+ Some(u) => u,
+ _ => {
+ self.fail = true;
+ return Ok(());
}
- _ => { unreachable!() }
- };
+ },
+ _ => {
+ unreachable!()
+ }
+ };
let mut string = String::new();
string.push(c as char);
}
} else {
- let mut iter = self.open_parsing_stream(
- stream.clone(),
- "get_n_chars",
- 2,
- )?;
+ let mut iter = self.open_parsing_stream(stream.clone(), "get_n_chars", 2)?;
for _ in 0..num {
- let result = iter.next();
+ let result = iter.next();
- match result {
- Some(Ok(c)) => {
+ match result {
+ Some(Ok(c)) => {
string.push(c);
- }
- _ => { break;
- }
- }
- }
+ }
+ _ => {
+ break;
+ }
+ }
+ }
};
let string = self.heap.put_complete_string(&string);
self.unify(self[temp_v!(3)], string);
if stream.at_end_of_stream() {
let end_of_file = clause_name!("end_of_file");
- let end_of_file = self.heap.to_unifiable(
- HeapCellValue::Atom(end_of_file, None),
- );
+ let end_of_file = self
+ .heap
+ .to_unifiable(HeapCellValue::Atom(end_of_file, None));
stream.set_past_end_of_stream();
return return_from_clause!(self.last_call, self);
}
- let addr =
- match self.store(self.deref(self[temp_v!(2)])) {
- addr if addr.is_ref() => {
- addr
- }
- addr => {
- match Number::try_from((addr, &self.heap)) {
- Ok(Number::Integer(n)) => {
- let n = n.to_u32().and_then(|n| {
- std::char::from_u32(n).and_then(|_| Some(n))
- });
+ let addr = match self.store(self.deref(self[temp_v!(2)])) {
+ addr if addr.is_ref() => addr,
+ addr => match Number::try_from((addr, &self.heap)) {
+ Ok(Number::Integer(n)) => {
+ let n = n
+ .to_u32()
+ .and_then(|n| std::char::from_u32(n).and_then(|_| Some(n)));
- if let Some(n) = n {
- Addr::Fixnum(n as isize)
- } else {
- return Err(self.representation_error(
- RepFlag::InCharacterCode,
- clause_name!("get_code"),
- 2,
- ));
- }
- }
- Ok(Number::Fixnum(n)) => {
- let n = u32::try_from(n).ok().and_then(|n| {
- std::char::from_u32(n).and_then(|_| Some(n))
- });
+ if let Some(n) = n {
+ Addr::Fixnum(n as isize)
+ } else {
+ return Err(self.representation_error(
+ RepFlag::InCharacterCode,
+ clause_name!("get_code"),
+ 2,
+ ));
+ }
+ }
+ Ok(Number::Fixnum(n)) => {
+ let n = u32::try_from(n)
+ .ok()
+ .and_then(|n| std::char::from_u32(n).and_then(|_| Some(n)));
- if let Some(n) = n {
- Addr::Fixnum(n as isize)
- } else {
- return Err(self.representation_error(
- RepFlag::InCharacterCode,
- clause_name!("get_code"),
- 2,
- ));
- }
- }
- _ => {
- return Err(self.type_error(
- ValidType::Integer,
- self[temp_v!(2)],
- clause_name!("get_code"),
- 2,
- ));
- }
+ if let Some(n) = n {
+ Addr::Fixnum(n as isize)
+ } else {
+ return Err(self.representation_error(
+ RepFlag::InCharacterCode,
+ clause_name!("get_code"),
+ 2,
+ ));
}
}
- };
+ _ => {
+ return Err(self.type_error(
+ ValidType::Integer,
+ self[temp_v!(2)],
+ clause_name!("get_code"),
+ 2,
+ ));
+ }
+ },
+ };
- let mut iter = self.open_parsing_stream(
- stream.clone(),
- "get_code",
- 2,
- )?;
+ let mut iter = self.open_parsing_stream(stream.clone(), "get_code", 2)?;
loop {
let result = iter.next();
}
}
&SystemClauseType::NextStream => {
- let prev_stream =
- match self.store(self.deref(self[temp_v!(1)])) {
- Addr::Stream(h) => {
- if let HeapCellValue::Stream(ref stream) = &self.heap[h] {
- stream.clone()
- } else {
- unreachable!()
- }
- }
- _ => {
+ let prev_stream = match self.store(self.deref(self[temp_v!(1)])) {
+ Addr::Stream(h) => {
+ if let HeapCellValue::Stream(ref stream) = &self.heap[h] {
+ stream.clone()
+ } else {
unreachable!()
}
- };
+ }
+ _ => {
+ unreachable!()
+ }
+ };
- let mut next_stream = None;
+ let mut next_stream = None;
let mut null_streams = BTreeSet::new();
- for stream in indices.streams.range(prev_stream.clone() ..).skip(1).cloned() {
+ for stream in indices
+ .streams
+ .range(prev_stream.clone()..)
+ .skip(1)
+ .cloned()
+ {
if !stream.is_null_stream() {
next_stream = Some(stream);
break;
if !stream.is_output_stream() {
let stub = MachineError::functor_stub(clause_name!("flush_output"), 1);
- let addr = vec![
- HeapCellValue::Stream(stream)
- ];
+ let addr = vec![HeapCellValue::Stream(stream)];
let err = MachineError::permission_error(
self.heap.h(),
&SystemClauseType::GetSingleChar => {
let ctrl_c = KeyEvent {
code: KeyCode::Char('c'),
- modifiers: KeyModifiers::CONTROL
+ modifiers: KeyModifiers::CONTROL,
};
let key = get_key();
if key == ctrl_c {
- let stub = MachineError::functor_stub(
- clause_name!("get_single_char"),
- 1
- );
+ let stub = MachineError::functor_stub(clause_name!("get_single_char"), 1);
let err = MachineError::interrupt_error();
let err = self.error_form(err, stub);
KeyCode::Enter => '\n',
KeyCode::Tab => '\t',
KeyCode::Char(c) => c,
- _ => unreachable!()
+ _ => unreachable!(),
};
let a1 = self[temp_v!(1)];
self.unify(Addr::Char(c), a1);
}
&SystemClauseType::HeadIsDynamic => {
- let module_name = atom_from!(
- self,
- self.store(self.deref(
- self[temp_v!(1)]
- ))
- );
+ let module_name = atom_from!(self, self.store(self.deref(self[temp_v!(1)])));
self.fail = !match self.store(self.deref(self[temp_v!(2)])) {
Addr::Str(s) => match &self.heap[s] {
- &HeapCellValue::NamedStr(arity, ref name, ..) =>
- indices.is_dynamic_predicate(module_name, (name.clone(), arity)),
+ &HeapCellValue::NamedStr(arity, ref name, ..) => {
+ indices.is_dynamic_predicate(module_name, (name.clone(), arity))
+ }
_ => unreachable!(),
},
Addr::Con(h) if self.heap.atom_at(h) => {
- if let HeapCellValue::Atom(name, _) = &self.heap[h] {
+ if let HeapCellValue::Atom(name, _) = &self.heap[h] {
indices.is_dynamic_predicate(module_name, (name.clone(), 0))
} else {
unreachable!()
};
}
&SystemClauseType::Close => {
- let mut stream =
- self.get_stream_or_alias(self[temp_v!(1)], indices, "close", 2)?;
+ let mut stream = self.get_stream_or_alias(self[temp_v!(1)], indices, "close", 2)?;
if !stream.is_input_stream() {
stream.flush().unwrap(); // 8.11.6.1b)
indices.streams.remove(&stream);
if stream == *current_input_stream {
- *current_input_stream = indices.stream_aliases.get(
- &clause_name!("user_input")
- ).cloned().unwrap();
+ *current_input_stream = indices
+ .stream_aliases
+ .get(&clause_name!("user_input"))
+ .cloned()
+ .unwrap();
indices.streams.insert(current_input_stream.clone());
} else if stream == *current_output_stream {
- *current_output_stream = indices.stream_aliases.get(
- &clause_name!("user_output")
- ).cloned().unwrap();
+ *current_output_stream = indices
+ .stream_aliases
+ .get(&clause_name!("user_output"))
+ .cloned()
+ .unwrap();
indices.streams.insert(current_output_stream.clone());
}
}
}
}
- &SystemClauseType::CopyToLiftedHeap => {
- match self.store(self.deref(self[temp_v!(1)])) {
- Addr::Usize(lh_offset) => {
- let copy_target = self[temp_v!(2)];
+ &SystemClauseType::CopyToLiftedHeap => match self.store(self.deref(self[temp_v!(1)])) {
+ Addr::Usize(lh_offset) => {
+ let copy_target = self[temp_v!(2)];
- let old_threshold = self.copy_findall_solution(lh_offset, copy_target);
- let new_threshold = self.lifted_heap.h() - lh_offset;
+ let old_threshold = self.copy_findall_solution(lh_offset, copy_target);
+ let new_threshold = self.lifted_heap.h() - lh_offset;
- self.lifted_heap[old_threshold] =
- HeapCellValue::Addr(Addr::HeapCell(new_threshold));
+ self.lifted_heap[old_threshold] =
+ HeapCellValue::Addr(Addr::HeapCell(new_threshold));
- for addr in self.lifted_heap.iter_mut_from(old_threshold + 1) {
- match addr {
- HeapCellValue::Addr(ref mut addr) => {
- *addr -= self.heap.h() + lh_offset;
- }
- _ => {}
+ for addr in self.lifted_heap.iter_mut_from(old_threshold + 1) {
+ match addr {
+ HeapCellValue::Addr(ref mut addr) => {
+ *addr -= self.heap.h() + lh_offset;
}
+ _ => {}
}
}
- _ => {
- self.fail = true;
- }
}
- }
+ _ => {
+ self.fail = true;
+ }
+ },
&SystemClauseType::DeleteAttribute => {
let ls0 = self.store(self.deref(self[temp_v!(1)]));
let trail_ref = match old_addr {
Addr::HeapCell(h) => TrailRef::AttrVarHeapLink(h),
Addr::Lis(l) => TrailRef::AttrVarListLink(l1 + 1, l),
- _ => unreachable!()
+ _ => unreachable!(),
};
self.heap[l1 + 1] = HeapCellValue::Addr(tail);
match self.store(self.deref(self[temp_v!(2 + narity)])) {
Addr::Str(a) => {
if let HeapCellValue::NamedStr(arity, name, _) = self.heap.clone(a) {
- for i in (arity + 1 .. arity + narity + 1).rev() {
+ for i in (arity + 1..arity + narity + 1).rev() {
self.registers[i] = self.registers[i - arity];
}
- for i in 1 .. arity + 1 {
+ for i in 1..arity + 1 {
self.registers[i] = self.heap[a + i].as_addr(a + i);
}
}
}
Addr::Con(h) if self.heap.atom_at(h) => {
- if let HeapCellValue::Atom(name, _) = self.heap.clone(h) {
+ if let HeapCellValue::Atom(name, _) = self.heap.clone(h) {
return self.module_lookup(
indices,
call_policy,
addr => {
let stub = MachineError::functor_stub(clause_name!("(:)"), 2);
- let type_error = MachineError::type_error(
- self.heap.h(),
- ValidType::Callable,
- addr,
- );
+ let type_error =
+ MachineError::type_error(self.heap.h(), ValidType::Callable, addr);
let type_error = self.error_form(type_error, stub);
return Err(type_error);
Addr::AttrVar(h) => {
self.attr_var_init.attr_var_queue.push(h);
}
- _ => {
- }
+ _ => {}
}
}
/*
match self.store(self.deref(a1)) {
addr @ Addr::HeapCell(_)
- | addr @ Addr::StackCell(..)
- | addr @ Addr::AttrVar(_) => {
+ | addr @ Addr::StackCell(..)
+ | addr @ Addr::AttrVar(_) => {
let mut iter = indices.code_dir.iter();
while let Some(((name, arity), _)) = iter.next() {
let db_ref = DBRef::NamedPred(name.clone(), *arity, spec);
let r = addr.as_var().unwrap();
- let addr = self.heap.to_unifiable(
- HeapCellValue::DBRef(db_ref)
- );
+ let addr = self.heap.to_unifiable(HeapCellValue::DBRef(db_ref));
self.bind(r, addr);
self.fail = true;
}
- Addr::Con(h) => {
- match self.heap.clone(h) {
- HeapCellValue::DBRef(DBRef::Op(..)) => {
- self.fail = true;
- }
- HeapCellValue::DBRef(ref db_ref) => {
- self.get_next_db_ref(indices, db_ref);
- }
- _ => {
- self.fail = true;
- }
+ Addr::Con(h) => match self.heap.clone(h) {
+ HeapCellValue::DBRef(DBRef::Op(..)) => {
+ self.fail = true;
}
- }
+ HeapCellValue::DBRef(ref db_ref) => {
+ self.get_next_db_ref(indices, db_ref);
+ }
+ _ => {
+ self.fail = true;
+ }
+ },
_ => {
self.fail = true;
}
match self.store(self.deref(a1)) {
addr @ Addr::HeapCell(_)
- | addr @ Addr::StackCell(..)
- | addr @ Addr::AttrVar(_) => {
+ | addr @ Addr::StackCell(..)
+ | addr @ Addr::AttrVar(_) => {
let mut unossified_op_dir = OssifiedOpDir::new();
unossified_op_dir.extend(indices.op_dir.iter().filter_map(
);
let r = addr.as_var().unwrap();
- let addr = self.heap.to_unifiable(
- HeapCellValue::DBRef(db_ref)
- );
+ let addr = self.heap.to_unifiable(HeapCellValue::DBRef(db_ref));
self.bind(r, addr);
}
}
}
}
- Addr::Con(h) => {
- match self.heap.clone(h) {
- HeapCellValue::DBRef(DBRef::NamedPred(..)) => {
- self.fail = true;
- }
- HeapCellValue::DBRef(ref db_ref) => {
- self.get_next_db_ref(indices, db_ref);
- }
- _ => {
- self.fail = true;
- }
+ Addr::Con(h) => match self.heap.clone(h) {
+ HeapCellValue::DBRef(DBRef::NamedPred(..)) => {
+ self.fail = true;
}
- }
+ HeapCellValue::DBRef(ref db_ref) => {
+ self.get_next_db_ref(indices, db_ref);
+ }
+ _ => {
+ self.fail = true;
+ }
+ },
_ => {
self.fail = true;
}
let a1 = self[temp_v!(1)];
match self.store(self.deref(a1)) {
- Addr::Con(h) => {
- match self.heap.clone(h) {
- HeapCellValue::DBRef(DBRef::NamedPred(name, arity, spec)) => {
- let a2 = self[temp_v!(2)];
- let a3 = self[temp_v!(3)];
+ Addr::Con(h) => match self.heap.clone(h) {
+ HeapCellValue::DBRef(DBRef::NamedPred(name, arity, spec)) => {
+ let a2 = self[temp_v!(2)];
+ let a3 = self[temp_v!(3)];
- let atom = self.heap.to_unifiable(
- HeapCellValue::Atom(name, spec)
- );
+ let atom = self.heap.to_unifiable(HeapCellValue::Atom(name, spec));
- self.unify(a2, atom);
+ self.unify(a2, atom);
- if !self.fail {
- self.unify(a3, Addr::Usize(arity));
- }
- }
- _ => {
- self.fail = true;
+ if !self.fail {
+ self.unify(a3, Addr::Usize(arity));
}
}
- }
+ _ => {
+ self.fail = true;
+ }
+ },
_ => {
self.fail = true;
}
let a1 = self[temp_v!(1)];
match self.store(self.deref(a1)) {
- Addr::Con(h) => {
- match self.heap.clone(h) {
- HeapCellValue::DBRef(DBRef::Op(
- priority,
- spec,
- name,
- _,
- shared_op_desc,
- )) => {
- let prec = self[temp_v!(2)];
- let specifier = self[temp_v!(3)];
- let op = self[temp_v!(4)];
-
- let spec = match spec {
- FX => "fx",
- FY => "fy",
- XF => "xf",
- YF => "yf",
- XFX => "xfx",
- XFY => "xfy",
- YFX => "yfx",
- _ => {
- self.fail = true;
- return Ok(());
- }
- };
-
- let a3 = self.heap.to_unifiable(
- HeapCellValue::Atom(clause_name!(spec), None)
- );
+ Addr::Con(h) => match self.heap.clone(h) {
+ HeapCellValue::DBRef(DBRef::Op(
+ priority,
+ spec,
+ name,
+ _,
+ shared_op_desc,
+ )) => {
+ let prec = self[temp_v!(2)];
+ let specifier = self[temp_v!(3)];
+ let op = self[temp_v!(4)];
+
+ let spec = match spec {
+ FX => "fx",
+ FY => "fy",
+ XF => "xf",
+ YF => "yf",
+ XFX => "xfx",
+ XFY => "xfy",
+ YFX => "yfx",
+ _ => {
+ self.fail = true;
+ return Ok(());
+ }
+ };
- let a4 = self.heap.to_unifiable(
- HeapCellValue::Atom(name, Some(shared_op_desc))
- );
+ let a3 = self
+ .heap
+ .to_unifiable(HeapCellValue::Atom(clause_name!(spec), None));
- self.unify(Addr::Usize(priority), prec);
+ let a4 = self
+ .heap
+ .to_unifiable(HeapCellValue::Atom(name, Some(shared_op_desc)));
- if !self.fail {
- self.unify(a3, specifier);
- }
+ self.unify(Addr::Usize(priority), prec);
- if !self.fail {
- self.unify(a4, op);
- }
+ if !self.fail {
+ self.unify(a3, specifier);
}
- _ => {
- self.fail = true;
+
+ if !self.fail {
+ self.unify(a4, op);
}
}
- }
+ _ => {
+ self.fail = true;
+ }
+ },
_ => {
self.fail = true;
}
let priority = self.store(self.deref(priority));
- let priority =
- match Number::try_from((priority, &self.heap)) {
- Ok(Number::Integer(n)) => {
- n.to_usize().unwrap()
- }
- Ok(Number::Fixnum(n)) => {
- usize::try_from(n).unwrap()
- }
- _ => {
- unreachable!();
- }
- };
+ let priority = match Number::try_from((priority, &self.heap)) {
+ Ok(Number::Integer(n)) => n.to_usize().unwrap(),
+ Ok(Number::Fixnum(n)) => usize::try_from(n).unwrap(),
+ _ => {
+ unreachable!();
+ }
+ };
let specifier = match self.store(self.deref(specifier)) {
- Addr::Con(h) if self.heap.atom_at(h) =>
+ Addr::Con(h) if self.heap.atom_at(h) => {
if let HeapCellValue::Atom(ref specifier, _) = &self.heap[h] {
specifier.clone()
} else {
unreachable!()
- },
- _ =>
- unreachable!(),
+ }
+ }
+ _ => unreachable!(),
};
let op = match self.store(self.deref(op)) {
- Addr::Char(c) =>
- clause_name!(c.to_string(), self.atom_tbl),
- Addr::Con(h) if self.heap.atom_at(h) =>
+ Addr::Char(c) => clause_name!(c.to_string(), self.atom_tbl),
+ Addr::Con(h) if self.heap.atom_at(h) => {
if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
name.clone()
} else {
unreachable!()
- },
- _ =>
- unreachable!(),
+ }
+ }
+ _ => unreachable!(),
};
let result = to_op_decl(priority, specifier.as_str(), op)
});
match result {
- Ok(()) => {
- }
+ Ok(()) => {}
Err(e) => {
// 8.14.3.3 l)
let e = MachineError::session_error(self.heap.h(), e);
let reposition = self[temp_v!(6)];
let stream_type = self[temp_v!(7)];
- let options =
- self.to_stream_options(alias, eof_action, reposition, stream_type);
+ let options = self.to_stream_options(alias, eof_action, reposition, stream_type);
- let mut stream =
- match self.store(self.deref(self[temp_v!(1)])) {
- Addr::Con(h) if self.heap.atom_at(h) => {
- match &self.heap[h] {
- &HeapCellValue::Atom(ref atom, _) => {
- self.stream_from_file_spec(atom.clone(), indices, &options)?
- }
- _ => {
- unreachable!()
- }
- }
+ let mut stream = match self.store(self.deref(self[temp_v!(1)])) {
+ Addr::Con(h) if self.heap.atom_at(h) => match &self.heap[h] {
+ &HeapCellValue::Atom(ref atom, _) => {
+ self.stream_from_file_spec(atom.clone(), indices, &options)?
}
- Addr::Char(c) => {
- let atom = clause_name!(c.to_string(), self.atom_tbl);
- self.stream_from_file_spec(atom, indices, &options)?
+ _ => {
+ unreachable!()
}
- Addr::PStrLocation(h, n) => {
- match &self.heap[h] {
- &HeapCellValue::PartialString(_, true) => {
- let mut heap_pstr_iter =
- self.heap_pstr_iter(Addr::PStrLocation(h, n));
+ },
+ Addr::Char(c) => {
+ let atom = clause_name!(c.to_string(), self.atom_tbl);
+ self.stream_from_file_spec(atom, indices, &options)?
+ }
+ Addr::PStrLocation(h, n) => match &self.heap[h] {
+ &HeapCellValue::PartialString(_, true) => {
+ let mut heap_pstr_iter = self.heap_pstr_iter(Addr::PStrLocation(h, n));
- let file_spec =
- clause_name!(
- heap_pstr_iter.to_string(),
- self.atom_tbl
- );
+ let file_spec = clause_name!(heap_pstr_iter.to_string(), self.atom_tbl);
- self.stream_from_file_spec(file_spec, indices, &options)?
- }
- _ => {
- self.stream_from_file_spec(clause_name!(""), indices, &options)?
- }
- }
- }
- _ => {
- self.stream_from_file_spec(clause_name!(""), indices, &options)?
+ self.stream_from_file_spec(file_spec, indices, &options)?
}
- };
+ _ => self.stream_from_file_spec(clause_name!(""), indices, &options)?,
+ },
+ _ => self.stream_from_file_spec(clause_name!(""), indices, &options)?,
+ };
stream.options = options;
}
&SystemClauseType::GetAttributedVariableList => {
let attr_var = self.store(self.deref(self[temp_v!(1)]));
- let attr_var_list =
- match attr_var {
- Addr::AttrVar(h) => {
- h + 1
- }
- attr_var @ Addr::HeapCell(_) |
- attr_var @ Addr::StackCell(..) => {
- // create an AttrVar in the heap.
- let h = self.heap.h();
+ let attr_var_list = match attr_var {
+ Addr::AttrVar(h) => h + 1,
+ attr_var @ Addr::HeapCell(_) | attr_var @ Addr::StackCell(..) => {
+ // create an AttrVar in the heap.
+ let h = self.heap.h();
- self.heap.push(HeapCellValue::Addr(Addr::AttrVar(h)));
- self.heap.push(HeapCellValue::Addr(Addr::HeapCell(h + 1)));
+ self.heap.push(HeapCellValue::Addr(Addr::AttrVar(h)));
+ self.heap.push(HeapCellValue::Addr(Addr::HeapCell(h + 1)));
- self.bind(Ref::AttrVar(h), attr_var);
- h + 1
- }
- _ => {
- self.fail = true;
- return Ok(());
- }
- };
+ self.bind(Ref::AttrVar(h), attr_var);
+ h + 1
+ }
+ _ => {
+ self.fail = true;
+ return Ok(());
+ }
+ };
let list_addr = self[temp_v!(2)];
self.bind(Ref::HeapCell(attr_var_list), list_addr);
let addr = self[temp_v!(1)];
let addr = self.store(self.deref(addr));
- let b =
- match addr {
- Addr::Usize(b) => {
- Some(b)
- }
+ let b = match addr {
+ Addr::Usize(b) => Some(b),
+ _ => match Number::try_from((addr, &self.heap)) {
+ Ok(Number::Integer(n)) => n.to_usize(),
+ Ok(Number::Fixnum(n)) => usize::try_from(n).ok(),
_ => {
- match Number::try_from((addr, &self.heap)) {
- Ok(Number::Integer(n)) => {
- n.to_usize()
- }
- Ok(Number::Fixnum(n)) => {
- usize::try_from(n).ok()
- }
- _ => {
- self.fail = true;
- return Ok(());
- }
- }
+ self.fail = true;
+ return Ok(());
}
- };
+ },
+ };
if let Some(b) = b {
let iter = self.gather_attr_vars_created_since(b);
let p_functor = self.store(self.deref(self[temp_v!(2)]));
let p = self.heap.to_local_code_ptr(&p_functor).unwrap();
- let num_cells =
- match code_repo.lookup_instr(self.last_call, &CodePtr::Local(p)) {
- Some(line) => {
- let perm_vars = match line.as_ref() {
- Line::Control(ref ctrl_instr) => ctrl_instr.perm_vars(),
- _ => None
- };
+ let num_cells = match code_repo.lookup_instr(self.last_call, &CodePtr::Local(p)) {
+ Some(line) => {
+ let perm_vars = match line.as_ref() {
+ Line::Control(ref ctrl_instr) => ctrl_instr.perm_vars(),
+ _ => None,
+ };
- perm_vars.unwrap()
- }
- _ => unreachable!()
- };
+ perm_vars.unwrap()
+ }
+ _ => unreachable!(),
+ };
let mut addrs = vec![];
- for index in 1 .. num_cells + 1 {
+ for index in 1..num_cells + 1 {
addrs.push(self.stack.index_and_frame(e)[index]);
}
match self.flags.double_quotes {
DoubleQuotes::Chars => {
- let atom = self.heap.to_unifiable(
- HeapCellValue::Atom(clause_name!("chars"), None)
- );
+ let atom = self
+ .heap
+ .to_unifiable(HeapCellValue::Atom(clause_name!("chars"), None));
self.unify(a1, atom);
}
- DoubleQuotes::Atom => {
- let atom = self.heap.to_unifiable(
- HeapCellValue::Atom(clause_name!("atom"), None)
- );
+ DoubleQuotes::Atom => {
+ let atom = self
+ .heap
+ .to_unifiable(HeapCellValue::Atom(clause_name!("atom"), None));
self.unify(a1, atom);
}
DoubleQuotes::Codes => {
- let atom = self.heap.to_unifiable(
- HeapCellValue::Atom(clause_name!("codes"), None)
- );
+ let atom = self
+ .heap
+ .to_unifiable(HeapCellValue::Atom(clause_name!("codes"), None));
self.unify(a1, atom);
}
}
}
}
- None => {
- }
+ None => {}
};
self.fail = true;
// denominator must be 1.
r.numer().to_i32().unwrap()
}
- _ => { unreachable!() }
+ _ => {
+ unreachable!()
+ }
};
std::process::exit(code);
CWILCallPolicy::new_in_place(call_policy);
}
- let n =
- match Number::try_from((a2, &self.heap)) {
- Ok(Number::Integer(n)) => {
- Integer::from(&*n.clone())
- }
- Ok(Number::Fixnum(n)) => {
- Integer::from(n)
- }
- _ => {
- let stub = MachineError::functor_stub(
- clause_name!("call_with_inference_limit"),
- 3,
- );
+ let n = match Number::try_from((a2, &self.heap)) {
+ Ok(Number::Integer(n)) => Integer::from(&*n.clone()),
+ Ok(Number::Fixnum(n)) => Integer::from(n),
+ _ => {
+ let stub = MachineError::functor_stub(
+ clause_name!("call_with_inference_limit"),
+ 3,
+ );
- return Err(self.error_form(
- MachineError::type_error(
- self.heap.h(),
- ValidType::Integer,
- a2,
- ),
- stub,
- ));
- }
- };
+ return Err(self.error_form(
+ MachineError::type_error(self.heap.h(), ValidType::Integer, a2),
+ stub,
+ ));
+ }
+ };
match a1 {
Addr::Usize(bp) | Addr::CutPoint(bp) => {
match call_policy.downcast_mut::<CWILCallPolicy>().ok() {
Some(call_policy) => {
let count = call_policy.add_limit(n, bp).clone();
- let count = self.heap.to_unifiable(
- HeapCellValue::Integer(Rc::new(count))
- );
+ let count = self
+ .heap
+ .to_unifiable(HeapCellValue::Integer(Rc::new(count)));
let a3 = self[temp_v!(3)];
self.unify(a3, count);
match module {
Addr::Con(h) => {
- if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
+ if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
self.fail = !indices.modules.contains_key(name);
} else {
unreachable!()
self.fail = match self.store(self.deref(self[temp_v!(2)])) {
Addr::Str(s) => match &self.heap[s] {
- &HeapCellValue::NamedStr(arity, ref name, ref spec) => {
- indices.get_predicate_code_index(
+ &HeapCellValue::NamedStr(arity, ref name, ref spec) => indices
+ .get_predicate_code_index(
name.clone(),
arity,
module_name,
spec.clone(),
- ).is_some()
- }
+ )
+ .is_some(),
_ => {
unreachable!()
}
},
Addr::Con(h) if self.heap.atom_at(h) => {
- if let &HeapCellValue::Atom(ref name, ref spec) = &self.heap[h] {
- let spec = fetch_atom_op_spec(
- name.clone(),
- spec.clone(),
- &indices.op_dir,
- );
+ if let &HeapCellValue::Atom(ref name, ref spec) = &self.heap[h] {
+ let spec =
+ fetch_atom_op_spec(name.clone(), spec.clone(), &indices.op_dir);
- indices.get_predicate_code_index(name.clone(), 0, module_name, spec)
- .is_some()
+ indices
+ .get_predicate_code_index(name.clone(), 0, module_name, spec)
+ .is_some()
} else {
unreachable!()
}
}
head => {
- let err = MachineError::type_error(self.heap.h(), ValidType::Callable, head);
+ let err =
+ MachineError::type_error(self.heap.h(), ValidType::Callable, head);
let stub = MachineError::functor_stub(clause_name!("clause"), 2);
return Err(self.error_form(err, stub));
};
}
&SystemClauseType::RedoAttrVarBinding => {
- let var = self.store(self.deref(self[temp_v!(1)]));
+ let var = self.store(self.deref(self[temp_v!(1)]));
let value = self.store(self.deref(self[temp_v!(2)]));
match var {
indices.global_variables.insert(key, (ball, None));
}
}
- },
+ }
&SystemClauseType::ResetAttrVarState => {
self.attr_var_init.reset();
}
&SystemClauseType::RemoveCallPolicyCheck => {
- let restore_default =
- match call_policy.downcast_mut::<CWILCallPolicy>().ok() {
- Some(call_policy) => {
- let a1 = self.store(self.deref(self[temp_v!(1)]));
-
- match a1 {
- Addr::Usize(bp) | Addr::CutPoint(bp) => {
- if call_policy.is_empty() && bp == self.b {
- Some(call_policy.into_inner())
- } else {
- None
- }
- }
- _ => {
- panic!("remove_call_policy_check: expected Usize in A1.");
+ let restore_default = match call_policy.downcast_mut::<CWILCallPolicy>().ok() {
+ Some(call_policy) => {
+ let a1 = self.store(self.deref(self[temp_v!(1)]));
+
+ match a1 {
+ Addr::Usize(bp) | Addr::CutPoint(bp) => {
+ if call_policy.is_empty() && bp == self.b {
+ Some(call_policy.into_inner())
+ } else {
+ None
}
}
+ _ => {
+ panic!("remove_call_policy_check: expected Usize in A1.");
+ }
}
- None => panic!(
- "remove_call_policy_check: requires \\
+ }
+ None => panic!(
+ "remove_call_policy_check: requires \\
CWILCallPolicy."
- ),
- };
+ ),
+ };
if let Some(new_policy) = restore_default {
*call_policy = new_policy;
match a1 {
Addr::Usize(bp) | Addr::CutPoint(bp) => {
let count = call_policy.remove_limit(bp).clone();
- let count = self.heap.to_unifiable(
- HeapCellValue::Integer(Rc::new(count)),
- );
+ let count = self
+ .heap
+ .to_unifiable(HeapCellValue::Integer(Rc::new(count)));
let a2 = self[temp_v!(2)];
let e = self.e;
let frame_len = self.stack.index_and_frame(e).prelude.univ_prelude.num_cells;
- for i in 1 .. frame_len - 1 {
+ for i in 1..frame_len - 1 {
self[RegType::Temp(i)] = self.stack.index_and_frame(e)[i];
}
return Ok(());
}
}
- &SystemClauseType::SetCutPointByDefault(r) => {
- deref_cut(self, r)
- }
+ &SystemClauseType::SetCutPointByDefault(r) => deref_cut(self, r),
&SystemClauseType::SetInput => {
let addr = self.store(self.deref(self[temp_v!(1)]));
let stream = self.get_stream_or_alias(addr, indices, "set_input", 1)?;
if !stream.is_input_stream() {
- let stub = MachineError::functor_stub(
- clause_name!("set_input"),
- 1,
- );
+ let stub = MachineError::functor_stub(clause_name!("set_input"), 1);
- let user_alias = self.heap.to_unifiable(
- HeapCellValue::Atom(clause_name!("user"), None),
- );
+ let user_alias = self
+ .heap
+ .to_unifiable(HeapCellValue::Atom(clause_name!("user"), None));
let err = MachineError::permission_error(
self.heap.h(),
let stream = self.get_stream_or_alias(addr, indices, "set_output", 1)?;
if !stream.is_output_stream() {
- let stub = MachineError::functor_stub(
- clause_name!("set_input"),
- 1,
- );
+ let stub = MachineError::functor_stub(clause_name!("set_input"), 1);
- let user_alias = self.heap.to_unifiable(
- HeapCellValue::Atom(clause_name!("user"), None),
- );
+ let user_alias = self
+ .heap
+ .to_unifiable(HeapCellValue::Atom(clause_name!("user"), None));
let err = MachineError::permission_error(
self.heap.h(),
*current_output_stream = stream;
}
- &SystemClauseType::SetDoubleQuotes => {
- match self[temp_v!(1)] {
- Addr::Con(h) if self.heap.atom_at(h) => {
- if let HeapCellValue::Atom(ref atom, _) = &self.heap[h] {
- self.flags.double_quotes =
- match atom.as_str() {
- "atom" => DoubleQuotes::Atom,
- "chars" => DoubleQuotes::Chars,
- "codes" => DoubleQuotes::Codes,
- _ => {
- self.fail = true;
- return Ok(());
- }
- };
- } else {
- unreachable!()
- }
- }
- _ => {
- self.fail = true;
+ &SystemClauseType::SetDoubleQuotes => match self[temp_v!(1)] {
+ Addr::Con(h) if self.heap.atom_at(h) => {
+ if let HeapCellValue::Atom(ref atom, _) = &self.heap[h] {
+ self.flags.double_quotes = match atom.as_str() {
+ "atom" => DoubleQuotes::Atom,
+ "chars" => DoubleQuotes::Chars,
+ "codes" => DoubleQuotes::Codes,
+ _ => {
+ self.fail = true;
+ return Ok(());
+ }
+ };
+ } else {
+ unreachable!()
}
}
- }
+ _ => {
+ self.fail = true;
+ }
+ },
&SystemClauseType::InferenceLevel => {
let a1 = self[temp_v!(1)];
let a2 = self.store(self.deref(self[temp_v!(2)]));
let prev_b = self.stack.index_or_frame(self.b).prelude.b;
if prev_b <= bp {
- let a2 = self.heap.to_unifiable(
- HeapCellValue::Atom(clause_name!("!"), None)
- );
+ let a2 = self
+ .heap
+ .to_unifiable(HeapCellValue::Atom(clause_name!("!"), None));
self.unify(a1, a2);
} else {
- let a2 = self.heap.to_unifiable(
- HeapCellValue::Atom(clause_name!("true"), None)
- );
+ let a2 = self
+ .heap
+ .to_unifiable(HeapCellValue::Atom(clause_name!("true"), None));
self.unify(a1, a2);
}
self.unify(a1, a2);
}
-/*
- &SystemClauseType::GetClause => {
- let head = self[temp_v!(1)];
-
- let subsection = match self.store(self.deref(head)) {
- Addr::Str(s) => match &self.heap[s] {
- &HeapCellValue::NamedStr(arity, ref name, ..) => {
- indices.get_clause_subsection(
- name.owning_module(),
- name.clone(),
- arity,
- )
- }
- _ => {
+ /*
+ &SystemClauseType::GetClause => {
+ let head = self[temp_v!(1)];
+
+ let subsection = match self.store(self.deref(head)) {
+ Addr::Str(s) => match &self.heap[s] {
+ &HeapCellValue::NamedStr(arity, ref name, ..) => {
+ indices.get_clause_subsection(
+ name.owning_module(),
+ name.clone(),
+ arity,
+ )
+ }
+ _ => {
+ unreachable!()
+ }
+ },
+ Addr::Con(h) if self.heap.atom_at(h) => {
+ if let &HeapCellValue::Atom(ref name, _) = &self.heap[h] {
+ indices.get_clause_subsection(
+ name.owning_module(),
+ name.clone(),
+ 0,
+ )
+ } else {
unreachable!()
- }
- },
- Addr::Con(h) if self.heap.atom_at(h) => {
- if let &HeapCellValue::Atom(ref name, _) = &self.heap[h] {
- indices.get_clause_subsection(
- name.owning_module(),
- name.clone(),
- 0,
- )
- } else {
- unreachable!()
- }
- }
- _ => {
- unreachable!()
- }
- };
+ }
+ }
+ _ => {
+ unreachable!()
+ }
+ };
- match subsection {
- Some(dynamic_predicate_info) => {
- self.execute_at_index(
- 2,
- dir_entry!(dynamic_predicate_info.clauses_subsection_p),
- );
+ match subsection {
+ Some(dynamic_predicate_info) => {
+ self.execute_at_index(
+ 2,
+ dir_entry!(dynamic_predicate_info.clauses_subsection_p),
+ );
- return Ok(());
- }
- _ => {
- unreachable!()
- }
- }
- }
-*/
+ return Ok(());
+ }
+ _ => {
+ unreachable!()
+ }
+ }
+ }
+ */
&SystemClauseType::GetCutPoint => {
let a1 = self[temp_v!(1)];
let a2 = Addr::CutPoint(self.b0);
return Ok(());
}
- let cp = (self.stack.index_and_frame(self.e).prelude.cp - 1).unwrap();
+ let cp =
+ (self.stack.index_and_frame(self.e).prelude.cp - 1).unwrap();
let e = self.stack.index_and_frame(self.e).prelude.e;
let e = Addr::Usize(e);
let addr = self.store(self.deref(self[temp_v!(1)]));
let p = match self.heap.to_local_code_ptr(&addr) {
- Some(p) => {
- p + 1
- }
+ Some(p) => p + 1,
None => {
self.fail = true;
return Ok(());
let n = n.and_then(std::char::from_u32);
self.fail = match n {
- Some(c) => {
- non_quoted_token(once(c))
- }
- None => {
- true
- }
+ Some(c) => non_quoted_token(once(c)),
+ None => true,
};
}
Addr::Char(c) => {
self.fail = non_quoted_token(once(c));
}
Addr::Con(h) => {
- if let HeapCellValue::Atom(atom, _) = &self.heap[h] {
+ if let HeapCellValue::Atom(atom, _) = &self.heap[h] {
self.fail = non_quoted_token(atom.as_str().chars());
}
}
readline::set_prompt(false);
match result {
- Ok(()) => {
- }
+ Ok(()) => {}
Err(e) => {
*current_input_stream = readline::input_stream();
return Err(e);
&SystemClauseType::ReadTerm => {
readline::set_prompt(false);
- let stream = self.get_stream_or_alias(
- self[temp_v!(1)],
- indices,
- "read_term",
- 3,
- )?;
+ let stream = self.get_stream_or_alias(self[temp_v!(1)], indices, "read_term", 3)?;
self.read_term(stream, indices)?;
}
let chars = heap_pstr_iter.to_string();
if let Addr::EmptyList = heap_pstr_iter.focus() {
- let term_write_result =
- match self.read(
- Stream::from(chars),
- self.atom_tbl.clone(),
- &indices.op_dir,
- ) {
- Ok(term_write_result) => {
- term_write_result
- }
- Err(e) => {
- let stub = MachineError::functor_stub(
- clause_name!("read_term_from_chars"),
- 2,
- );
+ let term_write_result = match self.read(
+ Stream::from(chars),
+ self.atom_tbl.clone(),
+ &indices.op_dir,
+ ) {
+ Ok(term_write_result) => term_write_result,
+ Err(e) => {
+ let stub =
+ MachineError::functor_stub(clause_name!("read_term_from_chars"), 2);
- let h = self.heap.h();
- let e = MachineError::session_error(h, SessionError::from(e));
+ let h = self.heap.h();
+ let e = MachineError::session_error(h, SessionError::from(e));
- return Err(self.error_form(e, stub));
- }
- };
+ return Err(self.error_form(e, stub));
+ }
+ };
let result = Addr::HeapCell(term_write_result.heap_loc);
self.reset_block(addr);
}
&SystemClauseType::ResetContinuationMarker => {
- self[temp_v!(3)] = self.heap.to_unifiable(
- HeapCellValue::Atom(clause_name!("none"), None)
- );
+ self[temp_v!(3)] = self
+ .heap
+ .to_unifiable(HeapCellValue::Atom(clause_name!("none"), None));
let h = self.heap.h();
&SystemClauseType::SetSeed => {
let seed = self.store(self.deref(self[temp_v!(1)]));
- let seed =
- match Number::try_from((seed, &self.heap)) {
- Ok(Number::Fixnum(n)) => {
- Integer::from(n)
- }
- Ok(Number::Integer(n)) => {
- Integer::from(n.as_ref())
- }
- Ok(Number::Rational(n))
- if n.denom() == &1 => {
- n.numer().clone()
- }
- _ => {
- self.fail = true;
- return Ok(());
- }
- };
+ let seed = match Number::try_from((seed, &self.heap)) {
+ Ok(Number::Fixnum(n)) => Integer::from(n),
+ Ok(Number::Integer(n)) => Integer::from(n.as_ref()),
+ Ok(Number::Rational(n)) if n.denom() == &1 => n.numer().clone(),
+ _ => {
+ self.fail = true;
+ return Ok(());
+ }
+ };
let mut rand = RANDOM_STATE.borrow_mut();
rand.seed(&seed);
let addr = self.store(self.deref(self[temp_v!(1)]));
let port = self.store(self.deref(self[temp_v!(2)]));
- let socket_atom =
- match addr {
- Addr::Con(h) if self.heap.atom_at(h) => {
- if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
- name.clone()
- } else {
- unreachable!()
- }
- }
- _ => {
+ let socket_atom = match addr {
+ Addr::Con(h) if self.heap.atom_at(h) => {
+ if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
+ name.clone()
+ } else {
unreachable!()
}
- };
+ }
+ _ => {
+ unreachable!()
+ }
+ };
- let port =
- match port {
- Addr::Fixnum(n) => {
- n.to_string()
- }
- Addr::Usize(n) => {
- n.to_string()
- }
- Addr::Con(h) => {
- match &self.heap[h] {
- HeapCellValue::Atom(ref name, _) => {
- name.as_str().to_string()
- }
- HeapCellValue::Integer(ref n) => {
- n.to_string()
- }
- _ => {
- unreachable!()
- }
- }
- }
+ let port = match port {
+ Addr::Fixnum(n) => n.to_string(),
+ Addr::Usize(n) => n.to_string(),
+ Addr::Con(h) => match &self.heap[h] {
+ HeapCellValue::Atom(ref name, _) => name.as_str().to_string(),
+ HeapCellValue::Integer(ref n) => n.to_string(),
_ => {
unreachable!()
}
- };
+ },
+ _ => {
+ unreachable!()
+ }
+ };
- let socket_addr =
- format!(
- "{}:{}",
- if socket_atom.as_str() == "" {
- "127.0.0.1"
- } else {
- socket_atom.as_str()
- },
- port,
- );
+ let socket_addr = format!(
+ "{}:{}",
+ if socket_atom.as_str() == "" {
+ "127.0.0.1"
+ } else {
+ socket_atom.as_str()
+ },
+ port,
+ );
let alias = self[temp_v!(4)];
let eof_action = self[temp_v!(5)];
let reposition = self[temp_v!(6)];
let stream_type = self[temp_v!(7)];
- let options =
- self.to_stream_options(alias, eof_action, reposition, stream_type);
+ let options = self.to_stream_options(alias, eof_action, reposition, stream_type);
if options.reposition {
return Err(self.reposition_error("socket_client_open", 3));
}
}
- let stream =
- match TcpStream::connect(&socket_addr).map_err(|e| e.kind()) {
- Ok(tcp_stream) => {
- let socket_addr = clause_name!(socket_addr, self.atom_tbl);
-
- let mut stream = {
- let tls = match self.store(self.deref(self[temp_v!(8)])) {
- Addr::Con(h) if self.heap.atom_at(h) => {
- if let HeapCellValue::Atom(ref atom, _) = &self.heap[h] {
- atom.as_str()
- } else {
- unreachable!()
- }
- }
- _ => {
+ let stream = match TcpStream::connect(&socket_addr).map_err(|e| e.kind()) {
+ Ok(tcp_stream) => {
+ let socket_addr = clause_name!(socket_addr, self.atom_tbl);
+
+ let mut stream = {
+ let tls = match self.store(self.deref(self[temp_v!(8)])) {
+ Addr::Con(h) if self.heap.atom_at(h) => {
+ if let HeapCellValue::Atom(ref atom, _) = &self.heap[h] {
+ atom.as_str()
+ } else {
unreachable!()
}
- };
-
- match tls {
- "false" => { Stream::from_tcp_stream(socket_addr, tcp_stream) }
- "true" => { let connector = TlsConnector::new().unwrap();
- let stream = match connector.connect(socket_atom.as_str(), tcp_stream) {
- Ok(tls_stream) => { tls_stream }
- Err(_) => { return Err(self.open_permission_error(addr, "socket_client_open", 3)); }
- };
-
- Stream::from_tls_stream(socket_addr, stream)
- }
- _ => { unreachable!() }
}
- };
+ _ => {
+ unreachable!()
+ }
+ };
- stream.options = options;
+ match tls {
+ "false" => Stream::from_tcp_stream(socket_addr, tcp_stream),
+ "true" => {
+ let connector = TlsConnector::new().unwrap();
+ let stream =
+ match connector.connect(socket_atom.as_str(), tcp_stream) {
+ Ok(tls_stream) => tls_stream,
+ Err(_) => {
+ return Err(self.open_permission_error(
+ addr,
+ "socket_client_open",
+ 3,
+ ));
+ }
+ };
- if let Some(ref alias) = &stream.options.alias {
- indices.stream_aliases.insert(alias.clone(), stream.clone());
+ Stream::from_tls_stream(socket_addr, stream)
+ }
+ _ => {
+ unreachable!()
+ }
}
+ };
- indices.streams.insert(stream.clone());
+ stream.options = options;
- self.heap.to_unifiable(HeapCellValue::Stream(stream))
- }
- Err(ErrorKind::PermissionDenied) => {
- return Err(self.open_permission_error(addr, "socket_client_open", 3));
+ if let Some(ref alias) = &stream.options.alias {
+ indices.stream_aliases.insert(alias.clone(), stream.clone());
}
- Err(ErrorKind::NotFound) => {
- let stub = MachineError::functor_stub(
- clause_name!("socket_client_open"),
- 3,
- );
- let err = MachineError::existence_error(
- self.heap.h(),
- ExistenceError::SourceSink(addr),
- );
+ indices.streams.insert(stream.clone());
- return Err(self.error_form(err, stub));
- }
- Err(_) => {
- // for now, just fail. expand to meaningful error messages later.
- self.fail = true;
- return Ok(());
- }
- };
+ self.heap.to_unifiable(HeapCellValue::Stream(stream))
+ }
+ Err(ErrorKind::PermissionDenied) => {
+ return Err(self.open_permission_error(addr, "socket_client_open", 3));
+ }
+ Err(ErrorKind::NotFound) => {
+ let stub =
+ MachineError::functor_stub(clause_name!("socket_client_open"), 3);
+
+ let err = MachineError::existence_error(
+ self.heap.h(),
+ ExistenceError::SourceSink(addr),
+ );
+
+ return Err(self.error_form(err, stub));
+ }
+ Err(_) => {
+ // for now, just fail. expand to meaningful error messages later.
+ self.fail = true;
+ return Ok(());
+ }
+ };
let stream_addr = self.store(self.deref(self[temp_v!(3)]));
self.bind(stream_addr.as_var().unwrap(), stream);
}
&SystemClauseType::SocketServerOpen => {
let addr = self.store(self.deref(self[temp_v!(1)]));
- let socket_atom =
- match addr {
- Addr::EmptyList => {
- "127.0.0.1".to_string()
- }
- Addr::Con(h) if self.heap.atom_at(h) => {
- match &self.heap[h] {
- HeapCellValue::Atom(ref name, _) => {
- name.as_str().to_string()
- }
- _ => {
- unreachable!()
- }
- }
- }
+ let socket_atom = match addr {
+ Addr::EmptyList => "127.0.0.1".to_string(),
+ Addr::Con(h) if self.heap.atom_at(h) => match &self.heap[h] {
+ HeapCellValue::Atom(ref name, _) => name.as_str().to_string(),
_ => {
unreachable!()
}
- };
+ },
+ _ => {
+ unreachable!()
+ }
+ };
- let port =
- match self.store(self.deref(self[temp_v!(2)])) {
- Addr::Fixnum(n) => {
- n.to_string()
- }
- Addr::Usize(n) => {
- n.to_string()
- }
- Addr::Con(h) => {
- match &self.heap[h] {
- HeapCellValue::Integer(ref n) => {
- n.to_string()
- }
- _ => {
- unreachable!()
- }
- }
- }
- addr if addr.is_ref() => {
- "0".to_string()
- }
+ let port = match self.store(self.deref(self[temp_v!(2)])) {
+ Addr::Fixnum(n) => n.to_string(),
+ Addr::Usize(n) => n.to_string(),
+ Addr::Con(h) => match &self.heap[h] {
+ HeapCellValue::Integer(ref n) => n.to_string(),
_ => {
unreachable!()
}
- };
+ },
+ addr if addr.is_ref() => "0".to_string(),
+ _ => {
+ unreachable!()
+ }
+ };
let had_zero_port = &port == "0";
if let Some(port) = port {
(
- self.heap.to_unifiable(HeapCellValue::TcpListener(tcp_listener)),
+ self.heap
+ .to_unifiable(HeapCellValue::TcpListener(tcp_listener)),
port as usize,
)
} else {
let reposition = self[temp_v!(6)];
let stream_type = self[temp_v!(7)];
- let options =
- self.to_stream_options(alias, eof_action, reposition, stream_type);
+ let options = self.to_stream_options(alias, eof_action, reposition, stream_type);
if options.reposition {
return Err(self.reposition_error("socket_server_accept", 4));
}
match self.store(self.deref(self[temp_v!(1)])) {
- Addr::TcpListener(h) => {
- match &mut self.heap[h] {
- HeapCellValue::TcpListener(ref mut tcp_listener) => {
- match tcp_listener.accept().ok() {
- Some((tcp_stream, socket_addr)) => {
- let client =
- clause_name!(format!("{}", socket_addr), self.atom_tbl);
-
- let mut tcp_stream =
- Stream::from_tcp_stream(client.clone(), tcp_stream);
-
- tcp_stream.options = options;
-
- if let Some(ref alias) = &tcp_stream.options.alias {
- indices.stream_aliases.insert(
- alias.clone(),
- tcp_stream.clone(),
- );
- }
+ Addr::TcpListener(h) => match &mut self.heap[h] {
+ HeapCellValue::TcpListener(ref mut tcp_listener) => {
+ match tcp_listener.accept().ok() {
+ Some((tcp_stream, socket_addr)) => {
+ let client =
+ clause_name!(format!("{}", socket_addr), self.atom_tbl);
+
+ let mut tcp_stream =
+ Stream::from_tcp_stream(client.clone(), tcp_stream);
+
+ tcp_stream.options = options;
+
+ if let Some(ref alias) = &tcp_stream.options.alias {
+ indices
+ .stream_aliases
+ .insert(alias.clone(), tcp_stream.clone());
+ }
- indices.streams.insert(tcp_stream.clone());
+ indices.streams.insert(tcp_stream.clone());
- let tcp_stream =
- self.heap.to_unifiable(HeapCellValue::Stream(tcp_stream));
+ let tcp_stream =
+ self.heap.to_unifiable(HeapCellValue::Stream(tcp_stream));
- let client =
- self.heap.to_unifiable(HeapCellValue::Atom(client, None));
+ let client =
+ self.heap.to_unifiable(HeapCellValue::Atom(client, None));
- let client_addr = self.store(self.deref(self[temp_v!(2)]));
- let stream_addr = self.store(self.deref(self[temp_v!(3)]));
+ let client_addr = self.store(self.deref(self[temp_v!(2)]));
+ let stream_addr = self.store(self.deref(self[temp_v!(3)]));
- self.bind(client_addr.as_var().unwrap(), client);
- self.bind(stream_addr.as_var().unwrap(), tcp_stream);
- }
- None => {
- self.fail = true;
- return Ok(());
- }
+ self.bind(client_addr.as_var().unwrap(), client);
+ self.bind(stream_addr.as_var().unwrap(), tcp_stream);
+ }
+ None => {
+ self.fail = true;
+ return Ok(());
}
}
- culprit => {
- let culprit = culprit.as_addr(h);
+ }
+ culprit => {
+ let culprit = culprit.as_addr(h);
- return Err(self.type_error(
- ValidType::TcpListener,
- culprit,
- clause_name!("socket_server_accept"),
- 4,
- ));
- }
+ return Err(self.type_error(
+ ValidType::TcpListener,
+ culprit,
+ clause_name!("socket_server_accept"),
+ 4,
+ ));
}
- }
+ },
culprit => {
return Err(self.type_error(
ValidType::TcpListener,
}
}
&SystemClauseType::SetStreamPosition => {
- let mut stream = self.get_stream_or_alias(
- self[temp_v!(1)],
- indices,
- "set_stream_position",
- 2,
- )?;
+ let mut stream =
+ self.get_stream_or_alias(self[temp_v!(1)], indices, "set_stream_position", 2)?;
if !stream.options.reposition {
let stub = MachineError::functor_stub(clause_name!("set_stream_position"), 2);
let position = self.store(self.deref(self[temp_v!(2)]));
- let position =
- match Number::try_from((position, &self.heap)) {
- Ok(Number::Fixnum(n)) => {
- n as u64
- }
- Ok(Number::Integer(n)) => {
- if let Some(n) = n.to_u64() {
- n
- } else {
- self.fail = true;
- return Ok(());
- }
- }
- _ => {
- unreachable!()
+ let position = match Number::try_from((position, &self.heap)) {
+ Ok(Number::Fixnum(n)) => n as u64,
+ Ok(Number::Integer(n)) => {
+ if let Some(n) = n.to_u64() {
+ n
+ } else {
+ self.fail = true;
+ return Ok(());
}
- };
+ }
+ _ => {
+ unreachable!()
+ }
+ };
stream.set_position(position);
}
&SystemClauseType::StreamProperty => {
- let mut stream = self.get_stream_or_alias(
- self[temp_v!(1)],
- indices,
- "stream_property",
- 2,
- )?;
-
- let property =
- match self.store(self.deref(self[temp_v!(2)])) {
- Addr::Con(h) if self.heap.atom_at(h) => {
- match &self.heap[h] {
- HeapCellValue::Atom(ref name, _) => {
- match name.as_str() {
- "file_name" => {
- if let Some(file_name) = stream.file_name() {
- HeapCellValue::Atom(
- file_name,
- None,
- )
- } else {
- self.fail = true;
- return Ok(());
- }
- }
- "mode" => {
- HeapCellValue::Atom(
- clause_name!(stream.mode()),
- None,
- )
- }
- "direction" => {
- HeapCellValue::Atom(
- if stream.is_input_stream() && stream.is_output_stream() {
- clause_name!("input_output")
- } else if stream.is_input_stream() {
- clause_name!("input")
- } else {
- clause_name!("output")
- },
- None,
- )
- }
- "alias" => {
- if let Some(alias) = &stream.options.alias {
- HeapCellValue::Atom(
- alias.clone(),
- None,
- )
- } else {
- self.fail = true;
- return Ok(());
- }
- }
- "position" => {
- if let Some(position) = stream.position() {
- HeapCellValue::Addr(Addr::Usize(position as usize))
- } else {
- self.fail = true;
- return Ok(());
- }
- }
- "end_of_stream" => {
- let end_of_stream_pos = stream.position_relative_to_end();
-
- HeapCellValue::Atom(
- clause_name!(end_of_stream_pos.as_str()),
- None,
- )
- }
- "eof_action" => {
- HeapCellValue::Atom(
- clause_name!(stream.options.eof_action.as_str()),
- None,
- )
- }
- "reposition" => {
- HeapCellValue::Atom(
- clause_name!(if stream.options.reposition {
- "true"
- } else {
- "false"
- }),
- None,
- )
- }
- "type" => {
- HeapCellValue::Atom(
- clause_name!(stream.options.stream_type.as_property_str()),
- None,
- )
- }
- _ => {
- unreachable!()
- }
- }
+ let mut stream =
+ self.get_stream_or_alias(self[temp_v!(1)], indices, "stream_property", 2)?;
+
+ let property = match self.store(self.deref(self[temp_v!(2)])) {
+ Addr::Con(h) if self.heap.atom_at(h) => match &self.heap[h] {
+ HeapCellValue::Atom(ref name, _) => match name.as_str() {
+ "file_name" => {
+ if let Some(file_name) = stream.file_name() {
+ HeapCellValue::Atom(file_name, None)
+ } else {
+ self.fail = true;
+ return Ok(());
}
- _ => {
- unreachable!()
+ }
+ "mode" => HeapCellValue::Atom(clause_name!(stream.mode()), None),
+ "direction" => HeapCellValue::Atom(
+ if stream.is_input_stream() && stream.is_output_stream() {
+ clause_name!("input_output")
+ } else if stream.is_input_stream() {
+ clause_name!("input")
+ } else {
+ clause_name!("output")
+ },
+ None,
+ ),
+ "alias" => {
+ if let Some(alias) = &stream.options.alias {
+ HeapCellValue::Atom(alias.clone(), None)
+ } else {
+ self.fail = true;
+ return Ok(());
}
}
- }
+ "position" => {
+ if let Some(position) = stream.position() {
+ HeapCellValue::Addr(Addr::Usize(position as usize))
+ } else {
+ self.fail = true;
+ return Ok(());
+ }
+ }
+ "end_of_stream" => {
+ let end_of_stream_pos = stream.position_relative_to_end();
+
+ HeapCellValue::Atom(clause_name!(end_of_stream_pos.as_str()), None)
+ }
+ "eof_action" => HeapCellValue::Atom(
+ clause_name!(stream.options.eof_action.as_str()),
+ None,
+ ),
+ "reposition" => HeapCellValue::Atom(
+ clause_name!(if stream.options.reposition {
+ "true"
+ } else {
+ "false"
+ }),
+ None,
+ ),
+ "type" => HeapCellValue::Atom(
+ clause_name!(stream.options.stream_type.as_property_str()),
+ None,
+ ),
+ _ => {
+ unreachable!()
+ }
+ },
_ => {
unreachable!()
}
- };
+ },
+ _ => {
+ unreachable!()
+ }
+ };
let property = self.heap.to_unifiable(property);
self.unify(self[temp_v!(3)], property);
self.unify(value, Addr::HeapCell(h));
}
- &SystemClauseType::Succeed => {
- }
+ &SystemClauseType::Succeed => {}
&SystemClauseType::TermAttributedVariables => {
let seen_vars = self.attr_vars_of_term(self[temp_v!(1)]);
let outcome = Addr::HeapCell(self.heap.to_list(seen_vars.into_iter()));
}
&SystemClauseType::TermVariables => {
let a1 = self[temp_v!(1)];
- let mut seen_set = IndexSet::new();
+ let mut seen_set = IndexSet::new();
let mut seen_vars = vec![];
for addr in self.acyclic_pre_order_iter(a1) {
}
&SystemClauseType::TruncateLiftedHeapTo => {
match self.store(self.deref(self[temp_v!(1)])) {
- Addr::Usize(lh_offset) =>
- self.lifted_heap.truncate(lh_offset),
- _ =>
- self.fail = true,
+ Addr::Usize(lh_offset) => self.lifted_heap.truncate(lh_offset),
+ _ => self.fail = true,
}
}
&SystemClauseType::UnifyWithOccursCheck => {
self.fail = self.structural_eq_test();
}
&SystemClauseType::WAMInstructions => {
- let module_name = atom_from!(
- self,
- self.store(self.deref(self[temp_v!(1)]))
- );
+ let module_name = atom_from!(self, self.store(self.deref(self[temp_v!(1)])));
- let name = self[temp_v!(2)];
+ let name = self[temp_v!(2)];
let arity = self[temp_v!(3)];
let name = match self.store(self.deref(name)) {
let arity = self.store(self.deref(arity));
- let arity =
- match Number::try_from((arity, &self.heap)) {
- Ok(Number::Fixnum(n)) => {
- Integer::from(n)
- }
- Ok(Number::Integer(n)) => {
- Integer::from(n.as_ref())
- }
- _ => {
- unreachable!()
- }
- };
+ let arity = match Number::try_from((arity, &self.heap)) {
+ Ok(Number::Fixnum(n)) => Integer::from(n),
+ Ok(Number::Integer(n)) => Integer::from(n.as_ref()),
+ _ => {
+ unreachable!()
+ }
+ };
let key = (name.clone(), arity.to_usize().unwrap());
let err = MachineError::session_error(
h,
- SessionError::from(
- CompilationError::InvalidModuleResolution(
- module_name
- )
- ),
+ SessionError::from(CompilationError::InvalidModuleResolution(
+ module_name,
+ )),
);
let err = self.error_form(err, stub);
},
};
- let first_idx =
- match first_idx {
- Some(ref idx) if idx.local().is_some() => {
- if let Some(idx) = idx.local() {
- idx
- } else {
- unreachable!()
- }
+ let first_idx = match first_idx {
+ Some(ref idx) if idx.local().is_some() => {
+ if let Some(idx) = idx.local() {
+ idx
+ } else {
+ unreachable!()
}
- _ => {
- let arity = arity.to_usize().unwrap();
- let stub = MachineError::functor_stub(name.clone(), arity);
- let h = self.heap.h();
+ }
+ _ => {
+ let arity = arity.to_usize().unwrap();
+ let stub = MachineError::functor_stub(name.clone(), arity);
+ let h = self.heap.h();
- let err = MachineError::existence_error(
- h,
- ExistenceError::Procedure(name, arity),
- );
+ let err = MachineError::existence_error(
+ h,
+ ExistenceError::Procedure(name, arity),
+ );
- let err = self.error_form(err, stub);
+ let err = self.error_form(err, stub);
- self.throw_exception(err);
- return Ok(());
- }
- };
+ self.throw_exception(err);
+ return Ok(());
+ }
+ };
let mut h = self.heap.h();
let mut functors = vec![];
let mut functor_list = vec![];
- walk_code(
- &code_repo.code,
- first_idx,
- |instr| {
- let old_len = functors.len();
- instr.enqueue_functors(h, &mut functors);
- let new_len = functors.len();
+ walk_code(&code_repo.code, first_idx, |instr| {
+ let old_len = functors.len();
+ instr.enqueue_functors(h, &mut functors);
+ let new_len = functors.len();
- for index in old_len .. new_len {
- functor_list.push(Addr::HeapCell(h));
- h += functors[index].len();
- }
- },
- );
+ for index in old_len..new_len {
+ functor_list.push(Addr::HeapCell(h));
+ h += functors[index].len();
+ }
+ });
for functor in functors {
self.heap.extend(functor.into_iter());
self.unify(listing, listing_var);
}
&SystemClauseType::WriteTerm => {
- let mut stream = self.get_stream_or_alias(
- self[temp_v!(1)],
- indices,
- "write_term",
- 3,
- )?;
+ let mut stream =
+ self.get_stream_or_alias(self[temp_v!(1)], indices, "write_term", 3)?;
self.check_stream_properties(
&mut stream,
3,
)?;
- let opt_err =
- if !stream.is_output_stream() {
- Some("stream") // 8.14.2.3 g)
- } else if stream.options.stream_type == StreamType::Binary {
- Some("binary_stream") // 8.14.2.3 h)
- } else {
- None
- };
+ let opt_err = if !stream.is_output_stream() {
+ Some("stream") // 8.14.2.3 g)
+ } else if stream.options.stream_type == StreamType::Binary {
+ Some("binary_stream") // 8.14.2.3 h)
+ } else {
+ None
+ };
if let Some(err_string) = opt_err {
return Err(self.stream_permission_error(
let addr = self[temp_v!(2)];
- let printer =
- match self.write_term(&indices.op_dir)? {
- None => {
- self.fail = true;
- return Ok(());
- }
- Some(printer) => {
- printer
- }
- };
+ let printer = match self.write_term(&indices.op_dir)? {
+ None => {
+ self.fail = true;
+ return Ok(());
+ }
+ Some(printer) => printer,
+ };
let output = printer.print(addr);
match write!(&mut stream, "{}", output.result()) {
- Ok(_) => {
- }
+ Ok(_) => {}
Err(_) => {
let stub = MachineError::functor_stub(clause_name!("open"), 4);
let err = MachineError::existence_error(
&SystemClauseType::WriteTermToChars => {
let addr = self[temp_v!(2)];
- let printer =
- match self.write_term(&indices.op_dir)? {
- None => {
- self.fail = true;
- return Ok(());
- }
- Some(printer) => {
- printer
- }
- };
+ let printer = match self.write_term(&indices.op_dir)? {
+ None => {
+ self.fail = true;
+ return Ok(());
+ }
+ Some(printer) => printer,
+ };
let result = printer.print(addr).result();
let chars = self.heap.put_complete_string(&result);
&SystemClauseType::ScryerPrologVersion => {
use crate::git_version::git_version;
let version = self[temp_v!(1)];
- let buffer =
- git_version!(cargo_prefix = "cargo:", fallback = "unknown");
+ let buffer = git_version!(cargo_prefix = "cargo:", fallback = "unknown");
let chars = buffer.chars().map(|c| Addr::Char(c));
let result = Addr::HeapCell(self.heap.to_list(chars));
self.unify(version, result);
let mut bytes: [u8; 1] = [0];
match rng().fill(&mut bytes) {
- Ok(()) => {
- }
+ Ok(()) => {}
Err(_) => {
// the error payload here is of type 'Unspecified',
// which contains no information whatsoever. So, for now,
}
}
- let byte = self.heap.to_unifiable(
- HeapCellValue::Integer(Rc::new(Integer::from(bytes[0])))
- );
+ let byte = self
+ .heap
+ .to_unifiable(HeapCellValue::Integer(Rc::new(Integer::from(bytes[0]))));
self.unify(arg, byte);
}
let algorithm = self.atom_argument_to_string(4);
- let ints_list =
- match algorithm.as_str() {
- "sha3_224" => { let mut context = Sha3_224::new();
- context.input(&bytes);
- Addr::HeapCell(self.heap.to_list(context.result().as_ref().iter().map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))))) }
- "sha3_256" => { let mut context = Sha3_256::new();
- context.input(&bytes);
- Addr::HeapCell(self.heap.to_list(context.result().as_ref().iter().map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))))) }
- "sha3_384" => { let mut context = Sha3_384::new();
- context.input(&bytes);
- Addr::HeapCell(self.heap.to_list(context.result().as_ref().iter().map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))))) }
- "sha3_512" => { let mut context = Sha3_512::new();
- context.input(&bytes);
- Addr::HeapCell(self.heap.to_list(context.result().as_ref().iter().map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))))) }
- "blake2s256" => { let mut context = Blake2s::new();
- context.input(&bytes);
- Addr::HeapCell(self.heap.to_list(context.result().as_ref().iter().map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))))) }
- "blake2b512" => { let mut context = Blake2b::new();
- context.input(&bytes);
- Addr::HeapCell(self.heap.to_list(context.result().as_ref().iter().map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))))) }
- "ripemd160" => { let mut context = Ripemd160::new();
- context.input(&bytes);
- Addr::HeapCell(self.heap.to_list(context.result().as_ref().iter().map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))))) }
- _ => { let ints = digest::digest(
- match algorithm.as_str() {
- "sha256" => { &digest::SHA256 }
- "sha384" => { &digest::SHA384 }
- "sha512" => { &digest::SHA512 }
- "sha512_256" => { &digest::SHA512_256 }
- _ => { unreachable!() }
- },
- &bytes);
- Addr::HeapCell(self.heap.to_list(ints.as_ref().iter().map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize)))))
- }
- };
+ let ints_list = match algorithm.as_str() {
+ "sha3_224" => {
+ let mut context = Sha3_224::new();
+ context.input(&bytes);
+ Addr::HeapCell(
+ self.heap.to_list(
+ context
+ .result()
+ .as_ref()
+ .iter()
+ .map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))),
+ ),
+ )
+ }
+ "sha3_256" => {
+ let mut context = Sha3_256::new();
+ context.input(&bytes);
+ Addr::HeapCell(
+ self.heap.to_list(
+ context
+ .result()
+ .as_ref()
+ .iter()
+ .map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))),
+ ),
+ )
+ }
+ "sha3_384" => {
+ let mut context = Sha3_384::new();
+ context.input(&bytes);
+ Addr::HeapCell(
+ self.heap.to_list(
+ context
+ .result()
+ .as_ref()
+ .iter()
+ .map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))),
+ ),
+ )
+ }
+ "sha3_512" => {
+ let mut context = Sha3_512::new();
+ context.input(&bytes);
+ Addr::HeapCell(
+ self.heap.to_list(
+ context
+ .result()
+ .as_ref()
+ .iter()
+ .map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))),
+ ),
+ )
+ }
+ "blake2s256" => {
+ let mut context = Blake2s::new();
+ context.input(&bytes);
+ Addr::HeapCell(
+ self.heap.to_list(
+ context
+ .result()
+ .as_ref()
+ .iter()
+ .map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))),
+ ),
+ )
+ }
+ "blake2b512" => {
+ let mut context = Blake2b::new();
+ context.input(&bytes);
+ Addr::HeapCell(
+ self.heap.to_list(
+ context
+ .result()
+ .as_ref()
+ .iter()
+ .map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))),
+ ),
+ )
+ }
+ "ripemd160" => {
+ let mut context = Ripemd160::new();
+ context.input(&bytes);
+ Addr::HeapCell(
+ self.heap.to_list(
+ context
+ .result()
+ .as_ref()
+ .iter()
+ .map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))),
+ ),
+ )
+ }
+ _ => {
+ let ints = digest::digest(
+ match algorithm.as_str() {
+ "sha256" => &digest::SHA256,
+ "sha384" => &digest::SHA384,
+ "sha512" => &digest::SHA512,
+ "sha512_256" => &digest::SHA512_256,
+ _ => {
+ unreachable!()
+ }
+ },
+ &bytes,
+ );
+ Addr::HeapCell(
+ self.heap.to_list(
+ ints.as_ref()
+ .iter()
+ .map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))),
+ ),
+ )
+ }
+ };
self.unify(self[temp_v!(3)], ints_list);
}
let length = self.store(self.deref(self[temp_v!(6)]));
- let length =
- match Number::try_from((length, &self.heap)) {
- Ok(Number::Fixnum(n)) => {
- usize::try_from(n).unwrap()
+ let length = match Number::try_from((length, &self.heap)) {
+ Ok(Number::Fixnum(n)) => usize::try_from(n).unwrap(),
+ Ok(Number::Integer(n)) => match n.to_usize() {
+ Some(u) => u,
+ _ => {
+ self.fail = true;
+ return Ok(());
}
- Ok(Number::Integer(n)) => {
- match n.to_usize() {
- Some(u) => { u }
- _ => { self.fail = true; return Ok(()); }
- }
+ },
+ _ => {
+ unreachable!()
+ }
+ };
+
+ let ints_list = {
+ let digest_alg = match algorithm.as_str() {
+ "sha256" => hkdf::HKDF_SHA256,
+ "sha384" => hkdf::HKDF_SHA384,
+ "sha512" => hkdf::HKDF_SHA512,
+ _ => {
+ self.fail = true;
+ return Ok(());
}
- _ => { unreachable!() }
};
+ let salt = hkdf::Salt::new(digest_alg, &salt);
+ let mut bytes: Vec<u8> = Vec::new();
+ bytes.resize(length, 0);
+ match salt.extract(&data).expand(&[&info[..]], MyKey(length)) {
+ Ok(r) => {
+ r.fill(&mut bytes).unwrap();
+ }
+ _ => {
+ self.fail = true;
+ return Ok(());
+ }
+ }
- let ints_list =
- { let digest_alg =
- match algorithm.as_str() {
- "sha256" => { hkdf::HKDF_SHA256 }
- "sha384" => { hkdf::HKDF_SHA384 }
- "sha512" => { hkdf::HKDF_SHA512 }
- _ => { self.fail = true; return Ok(()); }
- };
- let salt = hkdf::Salt::new(digest_alg, &salt);
- let mut bytes : Vec<u8> = Vec::new();
- bytes.resize(length, 0);
- match salt.extract(&data).expand(&[&info[..]], MyKey(length)) {
- Ok(r) => { r.fill(&mut bytes).unwrap(); }
- _ => { self.fail = true; return Ok(()); }
- }
-
- Addr::HeapCell(self.heap.to_list(bytes.iter().map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize)))))
- };
+ Addr::HeapCell(
+ self.heap.to_list(
+ bytes
+ .iter()
+ .map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))),
+ ),
+ )
+ };
self.unify(self[temp_v!(7)], ints_list);
}
let iterations = self.store(self.deref(self[temp_v!(3)]));
- let iterations =
- match Number::try_from((iterations, &self.heap)) {
- Ok(Number::Fixnum(n)) => {
- u64::try_from(n).unwrap()
- }
- Ok(Number::Integer(n)) => {
- match n.to_u64() {
- Some(i) => { i }
- None => {
- self.fail = true;
- return Ok(());
- }
- }
- }
- _ => {
- unreachable!()
+ let iterations = match Number::try_from((iterations, &self.heap)) {
+ Ok(Number::Fixnum(n)) => u64::try_from(n).unwrap(),
+ Ok(Number::Integer(n)) => match n.to_u64() {
+ Some(i) => i,
+ None => {
+ self.fail = true;
+ return Ok(());
}
- };
+ },
+ _ => {
+ unreachable!()
+ }
+ };
- let ints_list =
- { let mut bytes = [0u8; digest::SHA512_OUTPUT_LEN];
- pbkdf2::derive(pbkdf2::PBKDF2_HMAC_SHA512,
- NonZeroU32::new(iterations as u32).unwrap(), &salt,
- &data, &mut bytes);
+ let ints_list = {
+ let mut bytes = [0u8; digest::SHA512_OUTPUT_LEN];
+ pbkdf2::derive(
+ pbkdf2::PBKDF2_HMAC_SHA512,
+ NonZeroU32::new(iterations as u32).unwrap(),
+ &salt,
+ &data,
+ &mut bytes,
+ );
- Addr::HeapCell(self.heap.to_list(bytes.iter().map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize)))))
- };
+ Addr::HeapCell(
+ self.heap.to_list(
+ bytes
+ .iter()
+ .map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))),
+ ),
+ )
+ };
self.unify(self[temp_v!(4)], ints_list);
}
let key = aead::LessSafeKey::new(unbound_key);
let mut in_out = data.clone();
- let tag =
- match key.seal_in_place_separate_tag(nonce, aead::Aad::from(aad), &mut in_out) {
- Ok(d) => { d }
- _ => { self.fail = true; return Ok(()); }
- };
+ let tag = match key.seal_in_place_separate_tag(
+ nonce,
+ aead::Aad::from(aad),
+ &mut in_out,
+ ) {
+ Ok(d) => d,
+ _ => {
+ self.fail = true;
+ return Ok(());
+ }
+ };
- let tag_list =
- Addr::HeapCell(self.heap.to_list(tag.as_ref().iter().map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize)))));
+ let tag_list = Addr::HeapCell(
+ self.heap.to_list(
+ tag.as_ref()
+ .iter()
+ .map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))),
+ ),
+ );
let complete_string = {
- let buffer = String::from_iter(in_out.iter().map(|b| *b as char));
- self.heap.put_complete_string(&buffer)
- };
+ let buffer = String::from_iter(in_out.iter().map(|b| *b as char));
+ self.heap.put_complete_string(&buffer)
+ };
self.unify(self[temp_v!(6)], tag_list);
self.unify(self[temp_v!(7)], complete_string);
let mut in_out = data.clone();
let complete_string = {
- let decrypted_data =
- match key.open_in_place(nonce, aead::Aad::from(aad), &mut in_out) {
- Ok(d) => { d }
- _ => { self.fail = true; return Ok(()); }
- };
-
- let buffer = match encoding.as_str() {
- "octet" => { String::from_iter(decrypted_data.iter().map(|b| *b as char)) }
- "utf8" => { match String::from_utf8(decrypted_data.to_vec()) {
- Ok(str) => { str }
- _ => { self.fail = true; return Ok(()); }
- }
- }
- _ => { unreachable!() }
- };
-
- self.heap.put_complete_string(&buffer)
- };
+ let decrypted_data =
+ match key.open_in_place(nonce, aead::Aad::from(aad), &mut in_out) {
+ Ok(d) => d,
+ _ => {
+ self.fail = true;
+ return Ok(());
+ }
+ };
+
+ let buffer = match encoding.as_str() {
+ "octet" => String::from_iter(decrypted_data.iter().map(|b| *b as char)),
+ "utf8" => match String::from_utf8(decrypted_data.to_vec()) {
+ Ok(str) => str,
+ _ => {
+ self.fail = true;
+ return Ok(());
+ }
+ },
+ _ => {
+ unreachable!()
+ }
+ };
+
+ self.heap.put_complete_string(&buffer)
+ };
self.unify(self[temp_v!(6)], complete_string);
}
&SystemClauseType::CryptoCurveScalarMult => {
let curve = self.atom_argument_to_string(1);
let curve_id = match curve.as_str() {
- "secp112r1" => { Nid::SECP112R1 }
- "secp256k1" => { Nid::SECP256K1 }
- _ => { unreachable!() }
- };
+ "secp112r1" => Nid::SECP112R1,
+ "secp256k1" => Nid::SECP256K1,
+ _ => {
+ unreachable!()
+ }
+ };
let scalar = self.store(self.deref(self[temp_v!(2)]));
- let scalar =
- match Number::try_from((scalar, &self.heap)) {
- Ok(Number::Fixnum(n)) => {
- Integer::from(n)
- }
- Ok(Number::Integer(n)) => {
- Integer::from(&*n.clone())
- }
- _ => { unreachable!() }
- };
+ let scalar = match Number::try_from((scalar, &self.heap)) {
+ Ok(Number::Fixnum(n)) => Integer::from(n),
+ Ok(Number::Integer(n)) => Integer::from(&*n.clone()),
+ _ => {
+ unreachable!()
+ }
+ };
let stub = MachineError::functor_stub(clause_name!("crypto_curve_scalar_mult"), 5);
let qbytes = self.integers_to_bytevec(temp_v!(3), stub);
let mut rx = BigNum::new().unwrap();
let mut ry = BigNum::new().unwrap();
- result.affine_coordinates_gfp(&group, &mut rx, &mut ry, &mut bnctx).ok();
- let sx = self.heap.put_complete_string(&rx.to_dec_str().unwrap().to_string());
- let sy = self.heap.put_complete_string(&ry.to_dec_str().unwrap().to_string());
+ result
+ .affine_coordinates_gfp(&group, &mut rx, &mut ry, &mut bnctx)
+ .ok();
+ let sx = self
+ .heap
+ .put_complete_string(&rx.to_dec_str().unwrap().to_string());
+ let sy = self
+ .heap
+ .put_complete_string(&ry.to_dec_str().unwrap().to_string());
self.unify(self[temp_v!(4)], sx);
self.unify(self[temp_v!(5)], sy);
&SystemClauseType::Ed25519NewKeyPair => {
let pkcs8_bytes = signature::Ed25519KeyPair::generate_pkcs8(rng()).unwrap();
let complete_string = {
- let buffer = String::from_iter(pkcs8_bytes.as_ref().iter().map(|b| *b as char));
- self.heap.put_complete_string(&buffer)
- };
+ let buffer = String::from_iter(pkcs8_bytes.as_ref().iter().map(|b| *b as char));
+ self.heap.put_complete_string(&buffer)
+ };
self.unify(self[temp_v!(1)], complete_string);
}
let bytes = self.string_encoding_bytes(1, "octet");
let key_pair = match signature::Ed25519KeyPair::from_pkcs8(&bytes) {
- Ok(kp) => { kp }
- _ => { self.fail = true; return Ok(()); }
- };
+ Ok(kp) => kp,
+ _ => {
+ self.fail = true;
+ return Ok(());
+ }
+ };
let complete_string = {
- let buffer = String::from_iter(key_pair.public_key().as_ref().iter().map(|b| *b as char));
- self.heap.put_complete_string(&buffer)
- };
+ let buffer = String::from_iter(
+ key_pair.public_key().as_ref().iter().map(|b| *b as char),
+ );
+ self.heap.put_complete_string(&buffer)
+ };
self.unify(self[temp_v!(2)], complete_string);
}
let data = self.string_encoding_bytes(2, &encoding);
let key_pair = match signature::Ed25519KeyPair::from_pkcs8(&key) {
- Ok(kp) => { kp }
- _ => { self.fail = true; return Ok(()); }
- };
+ Ok(kp) => kp,
+ _ => {
+ self.fail = true;
+ return Ok(());
+ }
+ };
let sig = key_pair.sign(&data);
- let sig_list =
- Addr::HeapCell(self.heap.to_list(sig.as_ref().iter().map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize)))));
+ let sig_list = Addr::HeapCell(
+ self.heap.to_list(
+ sig.as_ref()
+ .iter()
+ .map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize))),
+ ),
+ );
self.unify(self[temp_v!(4)], sig_list);
}
let peer_public_key = signature::UnparsedPublicKey::new(&signature::ED25519, &key);
match peer_public_key.verify(&data, &signature) {
- Ok(_) => { }
- _ => { self.fail = true; return Ok(()); }
+ Ok(_) => {}
+ _ => {
+ self.fail = true;
+ return Ok(());
+ }
}
}
&SystemClauseType::Curve25519ScalarMult => {
&SystemClauseType::LoadXML => {
let string = self.heap_pstr_iter(self[temp_v!(1)]).to_string();
match roxmltree::Document::parse(&string) {
- Ok(doc) => { let result = self.xml_node_to_term(indices, doc.root_element());
- self.unify(self[temp_v!(2)], result);
+ Ok(doc) => {
+ let result = self.xml_node_to_term(indices, doc.root_element());
+ self.unify(self[temp_v!(2)], result);
}
- _ => { self.fail = true;
- return Ok(());
+ _ => {
+ self.fail = true;
+ return Ok(());
}
}
}
let padding = self.atom_argument_to_string(3);
let charset = self.atom_argument_to_string(4);
- let config =
- if padding == "true" {
- if charset == "standard" {
- base64::STANDARD
- } else {
- base64::URL_SAFE
- }
+ let config = if padding == "true" {
+ if charset == "standard" {
+ base64::STANDARD
} else {
- if charset == "standard" {
- base64::STANDARD_NO_PAD
- } else {
- base64::URL_SAFE_NO_PAD
- }
- };
+ base64::URL_SAFE
+ }
+ } else {
+ if charset == "standard" {
+ base64::STANDARD_NO_PAD
+ } else {
+ base64::URL_SAFE_NO_PAD
+ }
+ };
if self.store(self.deref(self[temp_v!(1)])).is_ref() {
let b64 = self.heap_pstr_iter(self[temp_v!(2)]).to_string();
let mut bytes = vec![];
for c in self.heap_pstr_iter(self[temp_v!(1)]).to_string().chars() {
if c as u32 > 255 {
-
let stub = MachineError::functor_stub(clause_name!("chars_base64"), 3);
let err = MachineError::type_error(
}
}
&SystemClauseType::LoadLibraryAsStream => {
- let library_name =
- atom_from!(
- self,
- self.store(self.deref(self[temp_v!(1)]))
- );
+ let library_name = atom_from!(self, self.store(self.deref(self[temp_v!(1)])));
use crate::LIBRARIES;
match LIBRARIES.borrow().get(library_name.as_str()) {
Some(library) => {
- let var_ref = Ref::HeapCell(self.heap.push(
- HeapCellValue::Stream(Stream::from(*library))
- ));
+ let var_ref = Ref::HeapCell(
+ self.heap
+ .push(HeapCellValue::Stream(Stream::from(*library))),
+ );
self.bind(var_ref, self[temp_v!(2)]);
let library_path =
clause_name!(library_path_str.to_string(), self.atom_tbl);
- let library_path_ref = Ref::HeapCell(
- self.heap.push(HeapCellValue::Atom(library_path, None))
- );
+ let library_path_ref =
+ Ref::HeapCell(self.heap.push(HeapCellValue::Atom(library_path, None)));
self.bind(library_path_ref, self[temp_v!(3)]);
}
None => {
- return Err(
- self.error_form(
- MachineError::existence_error(
- self.heap.h(),
- ExistenceError::ModuleSource(
- ModuleSource::Library(library_name)
- ),
- ),
- MachineError::functor_stub(clause_name!("load"), 1),
- )
- );
+ return Err(self.error_form(
+ MachineError::existence_error(
+ self.heap.h(),
+ ExistenceError::ModuleSource(ModuleSource::Library(library_name)),
+ ),
+ MachineError::functor_stub(clause_name!("load"), 1),
+ ));
}
}
}
return_from_clause!(self.last_call, self)
}
- pub(super)
- fn systemtime_to_timestamp(
- &mut self,
- system_time: SystemTime
- ) -> Addr {
+ pub(super) fn systemtime_to_timestamp(&mut self, system_time: SystemTime) -> Addr {
let datetime: DateTime<Local> = system_time.into();
let mut fstr = "[".to_string();
- let specifiers = vec!["Y","m","d","H","M","S","y","b","B","a","A","w","u","U","W","j","D","x","v"];
+ let specifiers = vec![
+ "Y", "m", "d", "H", "M", "S", "y", "b", "B", "a", "A", "w", "u", "U", "W", "j", "D",
+ "x", "v",
+ ];
for spec in specifiers {
fstr.push_str(&format!("'{}'=\"%{}\", ", spec, spec).to_string());
}
self.heap.put_complete_string(&s)
}
- pub(super)
- fn atom_argument_to_string(
- &mut self,
- atom_arg: usize,
- ) -> String {
+ pub(super) fn atom_argument_to_string(&mut self, atom_arg: usize) -> String {
match self.store(self.deref(self[temp_v!(atom_arg)])) {
Addr::Con(h) if self.heap.atom_at(h) => {
if let HeapCellValue::Atom(ref atom, _) = &self.heap[h] {
}
}
- pub(super)
- fn string_encoding_bytes(
- &mut self,
- data_arg: usize,
- encoding: &str,
- ) -> Vec<u8> {
+ pub(super) fn string_encoding_bytes(&mut self, data_arg: usize, encoding: &str) -> Vec<u8> {
let data = self.heap_pstr_iter(self[temp_v!(data_arg)]).to_string();
match encoding {
- "utf8" => { data.into_bytes() }
+ "utf8" => data.into_bytes(),
"octet" => {
let mut buf = vec![];
- for c in data.chars() {
+ for c in data.chars() {
buf.push(c as u8);
}
buf
}
- _ => { unreachable!() }
+ _ => {
+ unreachable!()
+ }
}
}
- pub(super)
- fn xml_node_to_term(
+ pub(super) fn xml_node_to_term(
&mut self,
indices: &mut IndexStore,
node: roxmltree::Node,
let mut avec = Vec::new();
for attr in node.attributes() {
let chars = clause_name!(String::from(attr.name()), self.atom_tbl);
- let name = self.heap.to_unifiable(
- HeapCellValue::Atom(chars, None)
- );
+ let name = self.heap.to_unifiable(HeapCellValue::Atom(chars, None));
let value = self.heap.put_complete_string(&attr.value());
avec.push(HeapCellValue::Addr(Addr::HeapCell(self.heap.h())));
- self.heap.push(HeapCellValue::NamedStr(2, clause_name!("="), None));
+ self.heap
+ .push(HeapCellValue::NamedStr(2, clause_name!("="), None));
self.heap.push(HeapCellValue::Addr(name));
self.heap.push(HeapCellValue::Addr(value));
}
let children = Addr::HeapCell(self.heap.to_list(cvec.into_iter()));
let chars = clause_name!(String::from(node.tag_name().name()), self.atom_tbl);
- let tag = self.heap.to_unifiable(
- HeapCellValue::Atom(chars, None)
- );
+ let tag = self.heap.to_unifiable(HeapCellValue::Atom(chars, None));
let result = Addr::HeapCell(self.heap.h());
- self.heap.push(HeapCellValue::NamedStr(3, clause_name!("element"), None));
+ self.heap
+ .push(HeapCellValue::NamedStr(3, clause_name!("element"), None));
self.heap.push(HeapCellValue::Addr(tag));
self.heap.push(HeapCellValue::Addr(attrs));
self.heap.push(HeapCellValue::Addr(children));
}
}
- pub(super)
- fn html_node_to_term(
+ pub(super) fn html_node_to_term(
&mut self,
indices: &mut IndexStore,
node: select::node::Node,
) -> Addr {
match node.name() {
- None => { let string = String::from(node.text());
- self.heap.put_complete_string(&string)
+ None => {
+ let string = String::from(node.text());
+ self.heap.put_complete_string(&string)
}
Some(name) => {
let mut avec = Vec::new();
for attr in node.attrs() {
let chars = clause_name!(String::from(attr.0), self.atom_tbl);
- let name = self.heap.to_unifiable(
- HeapCellValue::Atom(chars, None)
- );
+ let name = self.heap.to_unifiable(HeapCellValue::Atom(chars, None));
let value = self.heap.put_complete_string(&String::from(attr.1));
avec.push(HeapCellValue::Addr(Addr::HeapCell(self.heap.h())));
- self.heap.push(HeapCellValue::NamedStr(2, clause_name!("="), None));
+ self.heap
+ .push(HeapCellValue::NamedStr(2, clause_name!("="), None));
self.heap.push(HeapCellValue::Addr(name));
self.heap.push(HeapCellValue::Addr(value));
}
let children = Addr::HeapCell(self.heap.to_list(cvec.into_iter()));
let chars = clause_name!(String::from(name), self.atom_tbl);
- let tag = self.heap.to_unifiable(
- HeapCellValue::Atom(chars, None)
- );
+ let tag = self.heap.to_unifiable(HeapCellValue::Atom(chars, None));
let result = Addr::HeapCell(self.heap.h());
- self.heap.push(HeapCellValue::NamedStr(3, clause_name!("element"), None));
+ self.heap
+ .push(HeapCellValue::NamedStr(3, clause_name!("element"), None));
self.heap.push(HeapCellValue::Addr(tag));
self.heap.push(HeapCellValue::Addr(attrs));
self.heap.push(HeapCellValue::Addr(children));
}
}
-
fn rng() -> &'static dyn SecureRandom {
use std::ops::Deref;
-extern crate blake2;
-extern crate chrono;
-extern crate cpu_time;
-extern crate crossterm;
-extern crate divrem;
-#[macro_use]
-extern crate downcast;
-extern crate git_version;
-extern crate hostname;
-extern crate indexmap;
-#[macro_use]
-extern crate lazy_static;
-extern crate libc;
-extern crate native_tls;
-extern crate nix;
-extern crate openssl;
-extern crate ordered_float;
-#[macro_use]
-extern crate prolog_parser_rebis;
-#[macro_use]
-extern crate ref_thread_local;
-extern crate ring;
-extern crate ripemd160;
-#[cfg(feature = "rug")]
-extern crate rug;
-#[cfg(feature = "num-rug-adapter")]
-extern crate num_rug_adapter as rug;
-extern crate rustyline;
-extern crate sha3;
-extern crate unicode_reader;
+use blake2;
+use chrono;
+use cpu_time;
+use crossterm;
+use divrem;
+use downcast;
+use git_version;
+use indexmap;
+use lazy_static;
+use native_tls;
+use nix::sys::signal;
+use openssl;
+use ordered_float;
+use prolog_parser_rebis;
+use ref_thread_local;
+use ring;
+use ripemd160;
+use rustyline;
+use sha3;
+use unicode_reader;
-use crate::nix::sys::signal;
+#[cfg(feature = "num-rug-adapter")]
+use num_rug_adapter as rug;
+#[cfg(feature = "rug")]
+use rug;
#[macro_use]
mod macros;
mod allocator;
mod arithmetic;
-mod machine;
-mod codegen;
mod clause_types;
+mod codegen;
mod debray_allocator;
mod fixtures;
mod forms;
mod indexing;
mod instructions;
mod iterators;
+mod machine;
mod read;
mod targets;
mod write;
-use machine::*;
use machine::streams::*;
+use machine::*;
use read::*;
use std::sync::atomic::Ordering;
-extern fn handle_sigint(signal: libc::c_int) {
+extern "C" fn handle_sigint(signal: libc::c_int) {
let signal = signal::Signal::from_c_int(signal).unwrap();
if signal == signal::Signal::SIGINT {
INTERRUPT.store(true, Ordering::Relaxed);
projects / scryer-prolog.git / commitdiff