use crate::codegen::*;
use crate::debray_allocator::*;
-use crate::indexing::{IndexingCodePtr, merge_clause_index, remove_index};
+use crate::indexing::{merge_clause_index, remove_index, IndexingCodePtr};
use crate::machine::load_state::*;
use crate::machine::loader::*;
use crate::machine::preprocessor::*;
retraction_info.push_record(RetractionRecord::ReplacedDynamicElseOffset(index, *o));
Some(mem::replace(o, 0))
}
- Line::Choice(ChoiceInstruction::DynamicElse(_, _, NextOrFail::Fail(_))) |
- Line::Choice(ChoiceInstruction::DynamicInternalElse(_, _, NextOrFail::Fail(_))) => None,
+ Line::Choice(ChoiceInstruction::DynamicElse(_, _, NextOrFail::Fail(_)))
+ | Line::Choice(ChoiceInstruction::DynamicInternalElse(_, _, NextOrFail::Fail(_))) => None,
Line::Choice(ChoiceInstruction::TryMeElse(0)) => None,
Line::Choice(ChoiceInstruction::TryMeElse(ref mut o)) => {
retraction_info.push_record(RetractionRecord::ModifiedTryMeElse(index, *o));
}
}
-fn find_outer_choice_instr(
- code: &Code,
- mut index: usize,
-) -> usize {
+fn find_outer_choice_instr(code: &Code, mut index: usize) -> usize {
loop {
match &code[index] {
- Line::Choice(ChoiceInstruction::DynamicElse(_, _, NextOrFail::Next(i))) |
- Line::Choice(ChoiceInstruction::DynamicInternalElse(_, _, NextOrFail::Next(i)))
+ Line::Choice(ChoiceInstruction::DynamicElse(_, _, NextOrFail::Next(i)))
+ | Line::Choice(ChoiceInstruction::DynamicInternalElse(_, _, NextOrFail::Next(i)))
if *i > 0 =>
{
index += i;
}
}
-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 {
index = index_loc;
}
}
- &Line::Choice(ChoiceInstruction::DynamicElse(_, _, next_or_fail)) |
- &Line::Choice(ChoiceInstruction::DynamicInternalElse(_, _, next_or_fail)) => {
+ &Line::Choice(ChoiceInstruction::DynamicElse(_, _, next_or_fail))
+ | &Line::Choice(ChoiceInstruction::DynamicInternalElse(_, _, next_or_fail)) => {
match next_or_fail {
NextOrFail::Next(i) => {
if i == 0 {
return index;
}
Line::IndexingCode(indexing_code) => match &indexing_code[0] {
- IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, v, ..)) => {
- match v {
- IndexingCodePtr::External(v) => {
- index += v;
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, v, ..)) => match v {
+ IndexingCodePtr::External(v) => {
+ index += v;
+ }
+ IndexingCodePtr::DynamicExternal(v) => match &code[index + v] {
+ &Line::Choice(ChoiceInstruction::DynamicInternalElse(
+ _,
+ _,
+ NextOrFail::Next(0),
+ )) => {
+ return index + v;
}
- IndexingCodePtr::DynamicExternal(v) => {
- match &code[index + v] {
- &Line::Choice(ChoiceInstruction::DynamicInternalElse(
- _,
- _,
- NextOrFail::Next(0),
- )) => {
- return index + v;
- }
- _ => {
- index += v;
- }
- }
+ _ => {
+ index += v;
}
- _ => unreachable!()
- }
- }
+ },
+ _ => unreachable!(),
+ },
_ => {
unreachable!();
}
retraction_info: &mut RetractionInfo,
) -> usize {
let clause_index_info = skeleton.clauses.remove(target_pos);
- let clause_clause_loc = skeleton.clause_clause_locs.remove(target_pos);
+ let clause_clause_loc = skeleton.core.clause_clause_locs.remove(target_pos);
- if target_pos < skeleton.clause_assert_margin {
- skeleton.clause_assert_margin -= 1;
+ if target_pos < skeleton.core.clause_assert_margin {
+ skeleton.core.clause_assert_margin -= 1;
}
retraction_info.push_record(RetractionRecord::RemovedSkeletonClause(
return instr_loc;
}
- Line::Choice(ChoiceInstruction::DynamicElse(_, _, NextOrFail::Next(_))) |
- Line::Choice(ChoiceInstruction::DynamicInternalElse(_, _, NextOrFail::Next(_))) => {
+ Line::Choice(ChoiceInstruction::DynamicElse(_, _, NextOrFail::Next(_)))
+ | Line::Choice(ChoiceInstruction::DynamicInternalElse(_, _, NextOrFail::Next(_))) => {
return instr_loc;
}
&mut Line::Choice(ChoiceInstruction::DynamicElse(b, d, NextOrFail::Fail(o))) => {
- retraction_info.push_record(
- RetractionRecord::AppendedNextOrFail(instr_loc, NextOrFail::Fail(o)),
- );
+ retraction_info.push_record(RetractionRecord::AppendedNextOrFail(
+ instr_loc,
+ NextOrFail::Fail(o),
+ ));
- code[instr_loc] = Line::Choice(
- ChoiceInstruction::DynamicElse(b, d, NextOrFail::Next(0)),
- );
+ code[instr_loc] =
+ Line::Choice(ChoiceInstruction::DynamicElse(b, d, NextOrFail::Next(0)));
return instr_loc;
}
- &mut Line::Choice(ChoiceInstruction::DynamicInternalElse(b, d, NextOrFail::Fail(o))) => {
- retraction_info.push_record(
- RetractionRecord::AppendedNextOrFail(instr_loc, NextOrFail::Fail(o)),
- );
+ &mut Line::Choice(ChoiceInstruction::DynamicInternalElse(
+ b,
+ d,
+ NextOrFail::Fail(o),
+ )) => {
+ retraction_info.push_record(RetractionRecord::AppendedNextOrFail(
+ instr_loc,
+ NextOrFail::Fail(o),
+ ));
- code[instr_loc] = Line::Choice(
- ChoiceInstruction::DynamicInternalElse(b, d, NextOrFail::Next(0)),
- );
+ code[instr_loc] = Line::Choice(ChoiceInstruction::DynamicInternalElse(
+ b,
+ d,
+ NextOrFail::Next(0),
+ ));
return instr_loc;
}
let target_indexing_line = to_indexing_line_mut(&mut code[index_loc]).unwrap();
let v = match &target_indexing_line[0] {
- &IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, v, ..)) => {
- match v {
- IndexingCodePtr::External(v) | IndexingCodePtr::DynamicExternal(v) => v,
- _ => unreachable!()
- }
- }
+ &IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, v, ..)) => match v {
+ IndexingCodePtr::External(v) | IndexingCodePtr::DynamicExternal(v) => v,
+ _ => unreachable!(),
+ },
_ => {
unreachable!();
}
};
match &code[index_loc + v] {
- Line::Choice(ChoiceInstruction::TryMeElse(_)) |
- Line::Choice(ChoiceInstruction::DynamicElse(..)) |
- Line::Choice(ChoiceInstruction::DynamicInternalElse(..)) => {}
+ Line::Choice(ChoiceInstruction::TryMeElse(_))
+ | Line::Choice(ChoiceInstruction::DynamicElse(..))
+ | Line::Choice(ChoiceInstruction::DynamicInternalElse(..)) => {}
_ => {
set_switch_var_offset(code, index_loc, offset, retraction_info);
}
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, ..)) => {
- match *v {
- IndexingCodePtr::DynamicExternal(_) => {
- mem::replace(v, IndexingCodePtr::DynamicExternal(offset))
- }
- IndexingCodePtr::External(_) => {
- mem::replace(v, IndexingCodePtr::External(offset))
- }
- _ => unreachable!()
+ IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, ref mut v, ..)) => match *v {
+ IndexingCodePtr::DynamicExternal(_) => {
+ mem::replace(v, IndexingCodePtr::DynamicExternal(offset))
}
- }
+ IndexingCodePtr::External(_) => mem::replace(v, IndexingCodePtr::External(offset)),
+ _ => unreachable!(),
+ },
_ => {
unreachable!()
}
retraction_info: &mut RetractionInfo,
) {
match &mut code[instr_loc] {
- Line::Choice(ChoiceInstruction::DynamicElse(_, _, NextOrFail::Fail(_))) |
- Line::Choice(ChoiceInstruction::DynamicInternalElse(_, _, NextOrFail::Fail(_))) => {
- }
+ Line::Choice(ChoiceInstruction::DynamicElse(_, _, NextOrFail::Fail(_)))
+ | Line::Choice(ChoiceInstruction::DynamicInternalElse(_, _, NextOrFail::Fail(_))) => {}
Line::Choice(ChoiceInstruction::DynamicElse(_, _, ref mut o @ NextOrFail::Next(0))) => {
retraction_info.push_record(RetractionRecord::ReplacedDynamicElseOffset(instr_loc, 0));
*o = NextOrFail::Fail(0);
}
&mut Line::Choice(ChoiceInstruction::DynamicElse(b, d, NextOrFail::Next(o))) => {
- retraction_info.push_record(
- RetractionRecord::AppendedNextOrFail(instr_loc, NextOrFail::Next(o)),
- );
+ retraction_info.push_record(RetractionRecord::AppendedNextOrFail(
+ instr_loc,
+ NextOrFail::Next(o),
+ ));
match &mut code[instr_loc + o] {
Line::Control(ControlInstruction::RevJmpBy(p)) if *p == 0 => {
- code[instr_loc] = Line::Choice(
- ChoiceInstruction::DynamicElse(b, d, NextOrFail::Fail(o)),
- );
+ code[instr_loc] =
+ Line::Choice(ChoiceInstruction::DynamicElse(b, d, NextOrFail::Fail(o)));
}
_ => {
- code[instr_loc] = Line::Choice(
- ChoiceInstruction::DynamicElse(b, d, NextOrFail::Next(o)),
- );
+ code[instr_loc] =
+ Line::Choice(ChoiceInstruction::DynamicElse(b, d, NextOrFail::Next(o)));
}
}
}
Line::Choice(ChoiceInstruction::DynamicInternalElse(
- _, _, ref mut o @ NextOrFail::Next(0),
+ _,
+ _,
+ ref mut o @ NextOrFail::Next(0),
)) => {
retraction_info.push_record(RetractionRecord::ReplacedDynamicElseOffset(instr_loc, 0));
*o = NextOrFail::Fail(0);
match &mut code[instr_loc + o] {
Line::Control(ControlInstruction::RevJmpBy(p)) if *p == 0 => {
- code[instr_loc] = Line::Choice(
- ChoiceInstruction::DynamicInternalElse(b, d, NextOrFail::Fail(o)),
- );
+ code[instr_loc] = Line::Choice(ChoiceInstruction::DynamicInternalElse(
+ b,
+ d,
+ NextOrFail::Fail(o),
+ ));
}
_ => {
- code[instr_loc] = Line::Choice(
- ChoiceInstruction::DynamicInternalElse(b, d, NextOrFail::Next(o)),
- );
+ code[instr_loc] = Line::Choice(ChoiceInstruction::DynamicInternalElse(
+ b,
+ d,
+ NextOrFail::Next(o),
+ ));
}
}
}
) {
loop {
match &mut code[instr_loc] {
- 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::DynamicElse(_, _, NextOrFail::Next(ref mut o))) |
- Line::Choice(ChoiceInstruction::DynamicInternalElse(_, _, NextOrFail::Next(ref mut o)))
- if target_loc >= instr_loc =>
- {
- retraction_info.push_record(RetractionRecord::ReplacedDynamicElseOffset(instr_loc, *o));
+ Line::Choice(ChoiceInstruction::DynamicElse(_, _, NextOrFail::Next(ref mut o)))
+ | Line::Choice(ChoiceInstruction::DynamicInternalElse(
+ _,
+ _,
+ NextOrFail::Next(ref mut o),
+ )) if target_loc >= instr_loc => {
+ retraction_info
+ .push_record(RetractionRecord::ReplacedDynamicElseOffset(instr_loc, *o));
*o = target_loc - instr_loc;
return;
}
- Line::Choice(ChoiceInstruction::DynamicElse(_, _, NextOrFail::Next(ref mut o))) |
- Line::Choice(ChoiceInstruction::DynamicInternalElse(_, _, NextOrFail::Next(ref mut o))) => {
+ Line::Choice(ChoiceInstruction::DynamicElse(_, _, NextOrFail::Next(ref mut o)))
+ | Line::Choice(ChoiceInstruction::DynamicInternalElse(
+ _,
+ _,
+ NextOrFail::Next(ref mut o),
+ )) => {
instr_loc += *o;
}
- 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)) => {
instr_loc += *o;
}
Line::Control(ControlInstruction::RevJmpBy(ref mut o)) if instr_loc >= target_loc => {
&mut Line::Choice(ChoiceInstruction::DynamicElse(birth, death, ref mut fail))
if target_loc >= instr_loc =>
{
- retraction_info.push_record(
- RetractionRecord::AppendedNextOrFail(instr_loc, *fail),
- );
+ retraction_info.push_record(RetractionRecord::AppendedNextOrFail(instr_loc, *fail));
- code[instr_loc] =
- Line::Choice(ChoiceInstruction::DynamicElse(
- birth, death, NextOrFail::Next(target_loc - instr_loc),
- ));
+ code[instr_loc] = Line::Choice(ChoiceInstruction::DynamicElse(
+ birth,
+ death,
+ NextOrFail::Next(target_loc - instr_loc),
+ ));
return;
}
- Line::Choice(ChoiceInstruction::DynamicElse(_, _, NextOrFail::Fail(o)))
- if *o > 0 =>
- {
+ Line::Choice(ChoiceInstruction::DynamicElse(_, _, NextOrFail::Fail(o))) if *o > 0 => {
instr_loc += *o;
}
- &mut Line::Choice(ChoiceInstruction::DynamicInternalElse(birth, death, ref mut fail))
- if target_loc >= instr_loc =>
- {
- retraction_info.push_record(
- RetractionRecord::AppendedNextOrFail(instr_loc, *fail),
- );
-
- code[instr_loc] =
- Line::Choice(ChoiceInstruction::DynamicInternalElse(
- birth, death, NextOrFail::Next(target_loc - instr_loc),
- ));
+ &mut Line::Choice(ChoiceInstruction::DynamicInternalElse(
+ birth,
+ death,
+ ref mut fail,
+ )) if target_loc >= instr_loc => {
+ retraction_info.push_record(RetractionRecord::AppendedNextOrFail(instr_loc, *fail));
+
+ code[instr_loc] = Line::Choice(ChoiceInstruction::DynamicInternalElse(
+ birth,
+ death,
+ NextOrFail::Next(target_loc - instr_loc),
+ ));
return;
}
}
}
-fn find_dynamic_outer_choice_instr(
- code: &Code,
- index_loc: usize,
-) -> usize {
+fn find_dynamic_outer_choice_instr(code: &Code, index_loc: usize) -> usize {
match &code[index_loc] {
- Line::IndexingCode(indexing_code) => {
- match &indexing_code[0] {
- &IndexingLine::Indexing(
- IndexingInstruction::SwitchOnTerm(
- _,
- IndexingCodePtr::DynamicExternal(v),
- ..,
- )
- ) => {
- index_loc + v - 2
- }
- _ => unreachable!()
- }
- }
- _ => unreachable!()
+ Line::IndexingCode(indexing_code) => match &indexing_code[0] {
+ &IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(
+ _,
+ IndexingCodePtr::DynamicExternal(v),
+ ..,
+ )) => index_loc + v - 2,
+ _ => unreachable!(),
+ },
+ _ => unreachable!(),
}
}
let head_arg_num = skeleton.clauses[1].opt_arg_index_key.arg_num();
let settings = CodeGenSettings {
- global_clock_tick: if skeleton.is_dynamic {
+ global_clock_tick: if skeleton.core.is_dynamic {
Some(global_clock_tick)
} else {
None
skeleton.clauses[0].clause_start,
));
- let outer_thread_choice_loc = if skeleton.is_dynamic {
+ let outer_thread_choice_loc = if skeleton.core.is_dynamic {
find_dynamic_outer_choice_instr(code, index_loc)
} else {
skeleton.clauses[1].clause_start - 2
code.extend(prepend_queue.into_iter());
- if skeleton.is_dynamic {
+ if skeleton.core.is_dynamic {
clause_loc
} else {
clause_loc + (outer_thread_choice_offset == 0) as usize
let old_clause_start =
match skeleton.clauses[1].opt_arg_index_key.switch_on_term_loc() {
- Some(index_loc) if skeleton.is_dynamic => {
+ Some(index_loc) if skeleton.core.is_dynamic => {
find_dynamic_outer_choice_instr(code, index_loc)
}
- Some(_) => {
- skeleton.clauses[1].clause_start - 2
- }
- None => {
- skeleton.clauses[1].clause_start
- }
+ Some(_) => skeleton.clauses[1].clause_start - 2,
+ None => skeleton.clauses[1].clause_start,
};
let inner_thread_rev_offset =
*o = prepend_queue_len - 2;
}
Line::Choice(ChoiceInstruction::DynamicInternalElse(
- _, _, ref mut o @ NextOrFail::Next(0),
+ _,
+ _,
+ ref mut o @ NextOrFail::Next(0),
)) => {
*o = NextOrFail::Fail(prepend_queue_len - 2);
}
inner_thread_rev_offset,
)));
- prepend_queue.push_front(Line::Choice(
- settings.try_me_else(prepend_queue.len()),
- ));
+ prepend_queue.push_front(Line::Choice(settings.try_me_else(prepend_queue.len())));
// prepend_queue is now:
// | TryMeElse(N_2)
Some(index_loc) => {
prepend_queue.extend(clause_code.drain(1..));
- let old_clause_start = if skeleton.is_dynamic {
+ let old_clause_start = if skeleton.core.is_dynamic {
find_dynamic_outer_choice_instr(code, index_loc)
} else {
skeleton.clauses[1].clause_start - 2
inner_thread_rev_offset,
)));
- prepend_queue.push_front(Line::Choice(
- settings.try_me_else(prepend_queue.len()),
- ));
+ prepend_queue.push_front(Line::Choice(settings.try_me_else(prepend_queue.len())));
// prepend_queue is now:
// | TryMeElse(N_2)
inner_thread_rev_offset,
)));
- prepend_queue.push_front(Line::Choice(
- settings.try_me_else(prepend_queue.len()),
- ));
+ prepend_queue.push_front(Line::Choice(settings.try_me_else(prepend_queue.len())));
// prepend_queue is now:
// | TryMeElse(N_2)
}
};
- if skeleton.is_dynamic {
+ if skeleton.core.is_dynamic {
IndexPtr::DynamicIndex(clause_loc)
} else {
IndexPtr::Index(clause_loc)
let lower_bound = lower_bound_of_target_clause(skeleton, target_pos);
let settings = CodeGenSettings {
- global_clock_tick: if skeleton.is_dynamic {
+ global_clock_tick: if skeleton.core.is_dynamic {
Some(global_clock_tick)
} else {
None
index_loc,
);
- let target_pos_clause_start = find_outer_choice_instr(
- code,
- target_pos_clause_start,
- );
+ let target_pos_clause_start = find_outer_choice_instr(code, target_pos_clause_start);
if lower_bound + 1 == target_pos {
set_switch_var_offset_to_choice_instr(
target_pos_clause_start - index_loc,
retraction_info,
);
+
+ if lower_bound == 0 {
+ code_ptr_opt = Some(target_pos_clause_start);
+ }
}
target_pos_clause_start // skeleton.clauses[target_pos - 1].clause_start
// its variable offset.
skeleton.clauses[target_pos].clause_start += 2;
- if !skeleton.is_dynamic {
+ if !skeleton.core.is_dynamic {
set_switch_var_offset(code, index_loc, 2, retraction_info);
}
}
thread_choice_instr_at_to(code, threaded_choice_instr_loc, clause_loc, retraction_info);
code_ptr_opt.map(|p| {
- if skeleton.is_dynamic {
+ if skeleton.core.is_dynamic {
IndexPtr::DynamicIndex(p)
} else {
IndexPtr::Index(p)
if let Some(path_str) = load_context.path.to_str() {
if !path_str.is_empty() {
- return Some(clause_name!(path_str.to_string(), self.wam.machine_st.atom_tbl));
+ return Some(clause_name!(
+ path_str.to_string(),
+ self.wam.machine_st.atom_tbl
+ ));
}
}
}
predicates: &mut PredicateQueue,
settings: CodeGenSettings,
) -> Result<CodeIndex, SessionError> {
- let code_index = self.get_or_insert_code_index(
- key.clone(),
- predicates.compilation_target.clone(),
- );
+ let code_index =
+ self.get_or_insert_code_index(key.clone(), predicates.compilation_target.clone());
let code_len = self.wam.code_repo.code.len();
let mut code_ptr = code_len;
let mut clauses = vec![];
let mut preprocessor = Preprocessor::new(self.wam.machine_st.flags);
- for term in predicates.predicates.drain(0 ..) {
+ for term in predicates.predicates.drain(0..) {
clauses.push(self.try_term_to_tl(term, &mut preprocessor)?);
}
));
skeleton.clauses.extend(cg.skeleton.clauses.into_iter());
- skeleton.clause_clause_locs.extend_from_slice(
- &clause_clause_locs[0 ..]
- );
+ skeleton
+ .core
+ .clause_clause_locs
+ .extend_from_slice(&clause_clause_locs[0..]);
}
None => {
- cg.skeleton.clause_clause_locs.extend_from_slice(
- &clause_clause_locs[0 ..]
- );
+ cg.skeleton
+ .core
+ .clause_clause_locs
+ .extend_from_slice(&clause_clause_locs[0..]);
self.add_extensible_predicate(
key.clone(),
}
};
- if let Some(filename) = self.listing_src_file_name() {
- if let CompilationTarget::User = &predicates.compilation_target {
- let compilation_target = mem::replace(
- &mut self.compilation_target,
- CompilationTarget::Module(filename),
- );
-
- self.extend_local_predicate_skeleton(
- &CompilationTarget::User,
- &key,
- clause_clause_locs.clone(),
- );
-
- self.compilation_target = compilation_target;
- }
- }
-
self.extend_local_predicate_skeleton(
&predicates.compilation_target,
&key,
key: &PredicateKey,
clause_clause_locs: SliceDeque<usize>,
) {
- match self
- .wam
- .indices
- .get_local_predicate_skeleton_mut(
- &self.compilation_target,
- compilation_target.clone(),
- key.clone(),
- )
- {
+ match self.wam.indices.get_local_predicate_skeleton_mut(
+ self.compilation_target.clone(),
+ compilation_target.clone(),
+ self.listing_src_file_name(),
+ key.clone(),
+ ) {
Some(skeleton) => {
- self.retraction_info
- .push_record(RetractionRecord::SkeletonLocalClauseTruncateBack(
+ self.retraction_info.push_record(
+ RetractionRecord::SkeletonLocalClauseTruncateBack(
self.compilation_target.clone(),
compilation_target.clone(),
key.clone(),
skeleton.clause_clause_locs.len(),
- ));
-
- skeleton.clause_clause_locs.extend_from_slice(
- &clause_clause_locs[0 ..]
+ ),
);
+
+ skeleton
+ .clause_clause_locs
+ .extend_from_slice(&clause_clause_locs[0..]);
}
None => {
- let mut skeleton = PredicateSkeleton::new();
+ let mut skeleton = LocalPredicateSkeleton::new();
skeleton.clause_clause_locs = clause_clause_locs;
self.add_local_extensible_predicate(
key: &PredicateKey,
code_len: usize,
) {
- match self
- .wam
- .indices
- .get_local_predicate_skeleton_mut(
- &self.compilation_target,
- compilation_target.clone(),
- key.clone(),
- )
- {
+ match self.wam.indices.get_local_predicate_skeleton_mut(
+ self.compilation_target.clone(),
+ compilation_target.clone(),
+ self.listing_src_file_name(),
+ key.clone(),
+ ) {
Some(skeleton) => {
self.retraction_info.push_record(
RetractionRecord::SkeletonLocalClauseClausePopFront(
skeleton.clause_clause_locs.push_front(code_len);
}
None => {
- let mut skeleton = PredicateSkeleton::new();
+ let mut skeleton = LocalPredicateSkeleton::new();
skeleton.clause_clause_locs.push_front(code_len);
self.add_local_extensible_predicate(
key: &PredicateKey,
code_len: usize,
) {
- match self
- .wam
- .indices
- .get_local_predicate_skeleton_mut(
- &self.compilation_target,
- compilation_target.clone(),
- key.clone(),
- )
- {
+ match self.wam.indices.get_local_predicate_skeleton_mut(
+ self.compilation_target.clone(),
+ compilation_target.clone(),
+ self.listing_src_file_name(),
+ key.clone(),
+ ) {
Some(skeleton) => {
self.retraction_info.push_record(
RetractionRecord::SkeletonLocalClauseClausePopBack(
skeleton.clause_clause_locs.push_back(code_len);
}
None => {
- let mut skeleton = PredicateSkeleton::new();
+ let mut skeleton = LocalPredicateSkeleton::new();
skeleton.clause_clause_locs.push_back(code_len);
self.add_local_extensible_predicate(
.indices
.get_predicate_skeleton_mut(&compilation_target, &key)
{
- Some(skeleton) if !skeleton.clauses.is_empty() => {
- CodeGenSettings {
- global_clock_tick: if skeleton.is_dynamic {
- Some(self.wam.machine_st.global_clock)
- } else {
- None
- },
- is_extensible: true,
- non_counted_bt,
- }
+ Some(skeleton) if !skeleton.clauses.is_empty() => CodeGenSettings {
+ global_clock_tick: if skeleton.core.is_dynamic {
+ Some(self.wam.machine_st.global_clock)
+ } else {
+ None
+ },
+ is_extensible: true,
+ non_counted_bt,
},
skeleton_opt => {
let settings = CodeGenSettings {
global_clock_tick: if let Some(skeleton) = skeleton_opt {
- if skeleton.is_dynamic {
+ if skeleton.core.is_dynamic {
Some(self.wam.machine_st.global_clock)
} else {
None
.get_predicate_skeleton_mut(&compilation_target, &key)
{
Some(skeleton) if !skeleton.clauses.is_empty() => skeleton,
- _ => unreachable!()
+ _ => unreachable!(),
};
match append_or_prepend {
let clause_index_info = standalone_skeleton.clauses.pop_back().unwrap();
skeleton.clauses.push_back(clause_index_info);
- skeleton.clause_clause_locs.push_back(code_len);
+ skeleton.core.clause_clause_locs.push_back(code_len);
self.retraction_info
.push_record(RetractionRecord::SkeletonClausePopBack(
self.wam.machine_st.global_clock,
);
- self.push_back_to_local_predicate_skeleton(
- &compilation_target,
- &key,
- code_len,
- );
-
- if let Some(filename) = self.listing_src_file_name() {
- if let CompilationTarget::User = &compilation_target {
- let compilation_target = mem::replace(
- &mut self.compilation_target,
- CompilationTarget::Module(filename),
- );
-
- self.push_back_to_local_predicate_skeleton(
- &CompilationTarget::User,
- &key,
- code_len,
- );
-
- self.compilation_target = compilation_target;
- }
- }
+ self.push_back_to_local_predicate_skeleton(&compilation_target, &key, code_len);
- let code_index = self.get_or_insert_code_index(
- key.clone(),
- compilation_target.clone(),
- );
+ let code_index =
+ self.get_or_insert_code_index(key.clone(), compilation_target.clone());
if let Some(new_code_ptr) = result {
set_code_index(
let clause_index_info = standalone_skeleton.clauses.pop_back().unwrap();
skeleton.clauses.push_front(clause_index_info);
- skeleton.clause_clause_locs.push_front(code_len);
- skeleton.clause_assert_margin += 1;
+ skeleton.core.clause_clause_locs.push_front(code_len);
+ skeleton.core.clause_assert_margin += 1;
self.retraction_info
.push_record(RetractionRecord::SkeletonClausePopFront(
self.wam.machine_st.global_clock,
);
- if let Some(filename) = self.listing_src_file_name() {
- if let CompilationTarget::User = &compilation_target {
- let compilation_target = mem::replace(
- &mut self.compilation_target,
- CompilationTarget::Module(filename),
- );
-
- self.push_front_to_local_predicate_skeleton(
- &CompilationTarget::User,
- &key,
- code_len,
- );
-
- self.compilation_target = compilation_target;
- }
- }
-
- self.push_front_to_local_predicate_skeleton(
- &compilation_target,
- &key,
- code_len,
- );
+ self.push_front_to_local_predicate_skeleton(&compilation_target, &key, code_len);
- let code_index = self.get_or_insert_code_index(
- key.clone(),
- compilation_target.clone(),
- );
+ let code_index =
+ self.get_or_insert_code_index(key.clone(), compilation_target.clone());
set_code_index(
&mut self.retraction_info,
.opt_arg_index_key
.switch_on_term_loc()
{
- Some(index_loc) => {
- find_inner_choice_instr(
- &self.wam.code_repo.code,
- skeleton.clauses[target_pos].clause_start,
- index_loc,
- )
- }
- None => {
- skeleton.clauses[target_pos].clause_start
- }
+ Some(index_loc) => find_inner_choice_instr(
+ &self.wam.code_repo.code,
+ skeleton.clauses[target_pos].clause_start,
+ index_loc,
+ ),
+ None => skeleton.clauses[target_pos].clause_start,
};
match &mut self.wam.code_repo.code[clause_loc] {
- Line::Choice(ChoiceInstruction::DynamicElse(_, ref mut d, _)) |
- Line::Choice(ChoiceInstruction::DynamicInternalElse(_, ref mut d, _)) => {
+ Line::Choice(ChoiceInstruction::DynamicElse(_, ref mut d, _))
+ | Line::Choice(ChoiceInstruction::DynamicInternalElse(_, ref mut d, _)) => {
*d = Death::Finite(self.wam.machine_st.global_clock);
}
- _ => unreachable!()
+ _ => unreachable!(),
}
delete_from_skeleton(
}
pub(super) fn retract_clause(&mut self, key: PredicateKey, target_pos: usize) -> usize {
- let code_index = self.get_or_insert_code_index(
- key.clone(),
- self.compilation_target.clone(),
- );
+ let code_index =
+ self.get_or_insert_code_index(key.clone(), self.compilation_target.clone());
let skeleton = match self
.wam
skeleton.clauses[target_pos + 1].clause_start =
skeleton.clauses[target_pos].clause_start;
- return delete_from_skeleton(
- self.compilation_target.clone(),
+ let index_ptr_opt = if target_pos == 0 {
+ Some(IndexPtr::Index(clause_loc))
+ } else {
+ None
+ };
+
+ return finalize_retract(
key,
+ self.compilation_target.clone(),
skeleton,
+ code_index,
target_pos,
+ index_ptr_opt,
&mut self.retraction_info,
);
}
.get_predicate_skeleton_mut(&compilation_target, &key)
{
Some(skeleton) if append_or_prepend.is_append() => {
- let tail_num = skeleton.clause_clause_locs.len() - num_clause_predicates;
- skeleton.clause_clause_locs[tail_num ..]
- .iter()
- .cloned()
- .collect()
- }
- Some(skeleton) => {
- skeleton.clause_clause_locs[0 .. num_clause_predicates]
+ let tail_num = skeleton.core.clause_clause_locs.len() - num_clause_predicates;
+ skeleton.core.clause_clause_locs[tail_num..]
.iter()
.cloned()
.collect()
}
+ Some(skeleton) => skeleton.core.clause_clause_locs[0..num_clause_predicates]
+ .iter()
+ .cloned()
+ .collect(),
None => {
unreachable!()
}
&(clause_name!("$clause"), 2),
) {
Some(skeleton) if append_or_prepend.is_append() => {
- for _ in 0 .. num_clause_predicates {
- skeleton.clause_clause_locs.pop_back();
+ for _ in 0..num_clause_predicates {
+ skeleton.core.clause_clause_locs.pop_back();
}
for loc in locs_vec {
- skeleton.clause_clause_locs.push_back(loc);
+ skeleton.core.clause_clause_locs.push_back(loc);
}
}
Some(skeleton) => {
- for _ in 0 .. num_clause_predicates {
- skeleton.clause_clause_locs.pop_front();
+ for _ in 0..num_clause_predicates {
+ skeleton.core.clause_clause_locs.pop_front();
}
for loc in locs_vec.into_iter().rev() {
- skeleton.clause_clause_locs.push_front(loc);
+ skeleton.core.clause_clause_locs.push_front(loc);
}
}
None => {
.wam
.indices
.get_local_predicate_skeleton(
- &self.load_state.compilation_target,
+ self.load_state.compilation_target.clone(),
self.predicates.compilation_target.clone(),
+ self.load_state.listing_src_file_name(),
key.clone(),
)
.map(|skeleton| skeleton.predicate_info())
let non_counted_bt = self.non_counted_bt_preds.contains(&key);
if do_incremental_compile {
- for term in self.predicates.predicates.drain(0 ..) {
+ for term in self.predicates.predicates.drain(0..) {
self.load_state.incremental_compile_clause(
key.clone(),
term,
if self.load_state.compilation_target != self.predicates.compilation_target {
if !local_predicate_info.is_extensible {
if predicate_info.is_multifile {
- println!("Warning: overwriting multifile predicate {}:{}/{} because \
+ println!(
+ "Warning: overwriting multifile predicate {}:{}/{} because \
it was not locally declared multifile.",
- self.predicates.compilation_target, key.0, key.1);
+ self.predicates.compilation_target, key.0, key.1
+ );
}
- if let Some(skeleton) = self.load_state
+ if let Some(skeleton) = self
+ .load_state
.wam
.indices
- .remove_predicate_skeleton(
- &self.predicates.compilation_target,
- &key,
- )
+ .remove_predicate_skeleton(&self.predicates.compilation_target, &key)
{
if predicate_info.is_dynamic {
let clause_clause_compilation_target =
CompilationTarget::User => {
CompilationTarget::Module(clause_name!("builtins"))
}
- module => {
- module.clone()
- }
+ module => module.clone(),
};
self.load_state.retract_local_clauses_by_locs(
clause_clause_compilation_target,
(clause_name!("$clause"), 2),
- (0 .. skeleton.clauses.len()).map(Some).collect(),
+ (0..skeleton.clauses.len()).map(Some).collect(),
false, // the builtin M:'$clause'/2 is never dynamic.
);
non_counted_bt,
};
- let code_index
- = self.load_state.compile(key.clone(), &mut self.predicates, settings)?;
+ let code_index =
+ self.load_state
+ .compile(key.clone(), &mut self.predicates, settings)?;
if let Some(filename) = self.load_state.listing_src_file_name() {
- if let CompilationTarget::User = &self.predicates.compilation_target {
- match self.load_state.wam.indices.modules.get_mut(&filename) {
- Some(ref mut module) => {
- let index_ptr = code_index.get();
- let code_index = module.code_dir.entry(key.clone())
- .or_insert(code_index);
-
- set_code_index(
- &mut self.load_state.retraction_info,
- &CompilationTarget::Module(filename),
- key.clone(),
- &code_index,
- index_ptr,
- );
- }
- None => {
- }
+ match self.load_state.wam.indices.modules.get_mut(&filename) {
+ Some(ref mut module) => {
+ let index_ptr = code_index.get();
+ let code_index = module.code_dir.entry(key.clone()).or_insert(code_index);
+
+ set_code_index(
+ &mut self.load_state.retraction_info,
+ &CompilationTarget::Module(filename),
+ key.clone(),
+ &code_index,
+ index_ptr,
+ );
}
+ None => {}
}
}
}
if predicate_info.is_dynamic {
self.load_state.wam.machine_st.global_clock += 1;
- let clauses_vec: Vec<_> = self.clause_clauses
- .drain(0 .. predicates_len)
- .collect();
+ let clauses_vec: Vec<_> = self.clause_clauses.drain(0..predicates_len).collect();
self.compile_clause_clauses(
key,
use crate::machine::machine_indices::*;
use crate::machine::preprocessor::*;
-use crate::machine::*;
use crate::machine::term_stream::*;
+use crate::machine::*;
use prolog_parser::clause_name;
.indices
.get_predicate_skeleton(&compilation_target, &key)
.map(|skeleton| {
- (clause_locs
- .iter()
- .map(|clause_clause_loc| {
- skeleton.target_pos_of_clause_clause_loc(
- *clause_clause_loc,
- )
- })
- .collect(),
- skeleton.is_dynamic)
+ (
+ clause_locs
+ .iter()
+ .map(|clause_clause_loc| {
+ skeleton.target_pos_of_clause_clause_loc(*clause_clause_loc)
+ })
+ .collect(),
+ skeleton.core.is_dynamic,
+ )
});
if let Some((clause_target_poses, is_dynamic)) = result_opt {
mut clause_target_poses: Vec<Option<usize>>,
is_dynamic: bool,
) {
- let old_compilation_target = mem::replace(
- &mut self.compilation_target,
- compilation_target,
- );
+ let old_compilation_target = mem::replace(&mut self.compilation_target, compilation_target);
while let Some(target_pos_opt) = clause_target_poses.pop() {
match target_pos_opt {
) {
let key = (clause_name!("$clause"), 2);
- match self
- .wam
- .indices
- .get_local_predicate_skeleton_mut(
- &self.compilation_target,
- clause_clause_compilation_target.clone(),
- key.clone(),
- )
- {
+ match self.wam.indices.get_local_predicate_skeleton_mut(
+ self.compilation_target.clone(),
+ clause_clause_compilation_target.clone(),
+ self.listing_src_file_name(),
+ key.clone(),
+ ) {
Some(skeleton) => {
self.retraction_info.push_record(
RetractionRecord::RemovedLocalSkeletonClauseLocations(
}
};
- self.retract_local_clauses(
- clause_clause_compilation_target,
- key,
- &clause_locs,
- );
+ self.retract_local_clauses(clause_clause_compilation_target, key, &clause_locs);
}
pub(super) fn try_term_to_tl(
term: Term,
preprocessor: &mut Preprocessor,
) -> Result<PredicateClause, SessionError> {
- let tl = preprocessor.try_term_to_tl(
- self,
- term,
- CutContext::BlocksCuts,
- )?;
+ let tl = preprocessor.try_term_to_tl(self, term, CutContext::BlocksCuts)?;
Ok(match tl {
TopLevel::Fact(fact) => PredicateClause::Fact(fact),
if code_index.get() != IndexPtr::Undefined {
let old_index_ptr = code_index.replace(IndexPtr::Undefined);
- self.retraction_info.push_record(
- RetractionRecord::ReplacedModulePredicate(
- module_name.clone(), key.clone(), old_index_ptr,
- ),
- );
+ self.retraction_info
+ .push_record(RetractionRecord::ReplacedModulePredicate(
+ module_name.clone(),
+ key.clone(),
+ old_index_ptr,
+ ));
}
}
ModuleExport::PredicateKey(ref key) => {
match (removed_module.code_dir.get(key), code_dir.get(key)) {
(Some(module_code_index), Some(target_code_index))
- if module_code_index.get() == target_code_index.get() => {
- let old_index_ptr = target_code_index.replace(IndexPtr::Undefined);
+ if module_code_index.get() == target_code_index.get() =>
+ {
+ let old_index_ptr = target_code_index.replace(IndexPtr::Undefined);
- retraction_info.push_record(
- predicate_retractor(key.clone(), old_index_ptr),
- );
- }
+ retraction_info
+ .push_record(predicate_retractor(key.clone(), old_index_ptr));
+ }
_ => {}
}
}
ModuleExport::OpDecl(op_decl) => {
- let op_dir_value_opt = op_dir.remove(&(op_decl.name.clone(), op_decl.fixity()));
+ let op_dir_value_opt =
+ op_dir.remove(&(op_decl.name.clone(), op_decl.fixity()));
if let Some(op_dir_value) = op_dir_value_opt {
let (prec, spec) = op_dir_value.shared_op_desc().get();
- retraction_info.push_record(
- op_retractor(op_decl.clone(), prec, spec),
- );
+ retraction_info.push_record(op_retractor(op_decl.clone(), prec, spec));
}
}
}
);
}
CompilationTarget::Module(ref target_module_name)
- if target_module_name.as_str() != module_name.as_str() => {
- let predicate_retractor = |key, index_ptr| {
- RetractionRecord::ReplacedModulePredicate(
- module_name.clone(), key, index_ptr,
- )
- };
-
- let op_retractor = |op_decl, prec, spec| {
- RetractionRecord::ReplacedModuleOp(
- module_name.clone(), op_decl, prec, spec,
- )
- };
-
- if let Some(module) = self.wam.indices.modules.get_mut(target_module_name) {
- remove_module_exports(
- &removed_module,
- &mut module.code_dir,
- &mut module.op_dir,
- &mut self.retraction_info,
- predicate_retractor,
- op_retractor,
- );
- } else {
- unreachable!()
- }
+ if target_module_name.as_str() != module_name.as_str() =>
+ {
+ let predicate_retractor = |key, index_ptr| {
+ RetractionRecord::ReplacedModulePredicate(module_name.clone(), key, index_ptr)
+ };
+
+ let op_retractor = |op_decl, prec, spec| {
+ RetractionRecord::ReplacedModuleOp(module_name.clone(), op_decl, prec, spec)
+ };
+
+ if let Some(module) = self.wam.indices.modules.get_mut(target_module_name) {
+ remove_module_exports(
+ &removed_module,
+ &mut module.code_dir,
+ &mut module.op_dir,
+ &mut self.retraction_info,
+ predicate_retractor,
+ op_retractor,
+ );
+ } else {
+ unreachable!()
}
- CompilationTarget::Module(_) => {},
+ }
+ CompilationTarget::Module(_) => {}
};
self.wam.indices.modules.insert(module_name, removed_module);
self.add_dynamically_generated_module(&module_name);
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 => {
unreachable!()
}
.extensible_predicates
.insert(key.clone(), skeleton);
- let record = RetractionRecord::AddedExtensiblePredicate(
- CompilationTarget::User,
- key,
- );
+ let record =
+ RetractionRecord::AddedExtensiblePredicate(CompilationTarget::User, key);
self.retraction_info.push_record(record);
}
CompilationTarget::Module(module_name) => {
if let Some(module) = self.wam.indices.modules.get_mut(&module_name) {
- module
- .extensible_predicates
- .insert(key.clone(), skeleton);
+ module.extensible_predicates.insert(key.clone(), skeleton);
let record = RetractionRecord::AddedExtensiblePredicate(
CompilationTarget::Module(module_name),
&mut self,
local_compilation_target: CompilationTarget,
key: PredicateKey,
- skeleton: PredicateSkeleton,
+ skeleton: LocalPredicateSkeleton,
) {
- match self.compilation_target.clone() {
+ let src_compilation_target = match self.listing_src_file_name() {
+ Some(filename) => CompilationTarget::Module(filename),
+ None => self.compilation_target.clone(),
+ };
+
+ match src_compilation_target {
CompilationTarget::User => {
self.wam
.indices
Some(ref mut module) => {
op_decl.insert_into_op_dir(&mut module.op_dir);
}
- None => {
- }
+ None => {}
}
}
code_dir,
op_dir,
meta_predicates,
- ).unwrap();
+ )
+ .unwrap();
}
}
- pub(crate) fn reset_in_situ_module(&mut self, module_decl: ModuleDecl, listing_src: &ListingSource) {
+ pub(crate) fn reset_in_situ_module(
+ &mut self,
+ module_decl: ModuleDecl,
+ listing_src: &ListingSource,
+ ) {
let module_name = module_decl.name.clone();
self.remove_module_exports(module_name.clone());
let is_dynamic = self
.wam
.indices
- .get_predicate_skeleton(&compilation_target, &key)
- .map(|skeleton| skeleton.is_dynamic)
+ .get_predicate_skeleton(compilation_target, key)
+ .map(|skeleton| skeleton.core.is_dynamic)
.unwrap_or(false);
if is_dynamic {
CompilationTarget::User => {
CompilationTarget::Module(clause_name!("builtins"))
}
- module => {
- module.clone()
- }
+ module => module.clone(),
};
self.retract_local_clause_clauses(
&skeleton.clause_clause_locs,
);
}
-
- if &self.compilation_target == compilation_target {
- if let CompilationTarget::User = &self.compilation_target {
- match (key.0.as_str(), key.1) {
- ("term_expansion", 2) | ("goal_expansion", 2) => {
- continue;
- }
- _ => {}
- }
- }
-
- let skeleton_opt = self.wam.indices.remove_predicate_skeleton(
- compilation_target,
- &key,
- );
-
- if let Some(skeleton) = skeleton_opt {
- self.retraction_info.push_record(RetractionRecord::RemovedSkeleton(
- compilation_target.clone(),
- key.clone(),
- skeleton,
- ));
- }
- }
}
- self.retraction_info.push_record(RetractionRecord::ReplacedModule(
- old_module_decl,
- listing_src.clone(),
- local_extensible_predicates,
- ));
+ self.retraction_info
+ .push_record(RetractionRecord::ReplacedModule(
+ old_module_decl,
+ listing_src.clone(),
+ local_extensible_predicates,
+ ));
}
None => {}
}
.extensible_predicates
.get_mut(&key)
.map(|skeleton| {
- skeleton.is_discontiguous = false;
+ skeleton.core.is_discontiguous = false;
});
}
CompilationTarget::Module(module_name) => {
match self.wam.indices.modules.get_mut(&module_name) {
Some(ref mut module) => {
module.extensible_predicates.get_mut(&key).map(|skeleton| {
- skeleton.is_discontiguous = false;
+ skeleton.core.is_discontiguous = false;
});
}
None => {}
.extensible_predicates
.get_mut(&key)
.map(|skeleton| {
- skeleton.is_dynamic = false;
+ skeleton.core.is_dynamic = false;
});
}
CompilationTarget::Module(module_name) => {
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;
+ skeleton.core.is_dynamic = false;
});
}
None => {}
.extensible_predicates
.get_mut(&key)
.map(|skeleton| {
- skeleton.is_multifile = false;
+ skeleton.core.is_multifile = false;
});
}
CompilationTarget::Module(module_name) => {
match self.wam.indices.modules.get_mut(&module_name) {
Some(ref mut module) => {
module.extensible_predicates.get_mut(&key).map(|skeleton| {
- skeleton.is_multifile = false;
+ skeleton.core.is_multifile = false;
});
}
None => {}
{
Some(skeleton) => {
skeleton.clauses.pop_back();
- skeleton.clause_clause_locs.pop_back();
+ skeleton.core.clause_clause_locs.pop_back();
}
None => {}
}
{
Some(skeleton) => {
skeleton.clauses.pop_front();
- skeleton.clause_clause_locs.pop_front();
- skeleton.clause_assert_margin -= 1;
+ skeleton.core.clause_clause_locs.pop_front();
+ skeleton.core.clause_assert_margin -= 1;
}
None => {}
}
key,
) => {
match self.wam.indices.get_local_predicate_skeleton_mut(
- &src_compilation_target,
+ src_compilation_target,
local_compilation_target,
+ self.listing_src_file_name(),
key,
) {
Some(skeleton) => {
key,
) => {
match self.wam.indices.get_local_predicate_skeleton_mut(
- &src_compilation_target,
+ src_compilation_target,
local_compilation_target,
+ self.listing_src_file_name(),
key,
) {
Some(skeleton) => {
len,
) => {
match self.wam.indices.get_local_predicate_skeleton_mut(
- &src_compilation_target,
+ src_compilation_target,
local_compilation_target,
+ self.listing_src_file_name(),
key,
) {
Some(skeleton) => {
{
Some(skeleton) => {
skeleton.clauses.truncate_back(len);
- skeleton.clause_clause_locs.truncate_back(len);
+ skeleton.core.clause_clause_locs.truncate_back(len);
}
None => {}
}
{
Some(skeleton) => {
skeleton
+ .core
.clause_clause_locs
.insert(target_pos, clause_clause_loc);
skeleton.clauses.insert(target_pos, clause_index_info);
clause_locs,
) => {
match self.wam.indices.get_local_predicate_skeleton_mut(
- &compilation_target,
+ compilation_target,
local_compilation_target,
+ self.listing_src_file_name(),
key,
) {
Some(skeleton) => skeleton.clause_clause_locs = clause_locs,
RetractionRecord::ReplacedDynamicElseOffset(instr_loc, next) => {
match &mut self.wam.code_repo.code[instr_loc] {
Line::Choice(ChoiceInstruction::DynamicElse(
- _, _, NextOrFail::Next(ref mut o),
- )) |
- Line::Choice(ChoiceInstruction::DynamicInternalElse(
- _, _, NextOrFail::Next(ref mut o),
+ _,
+ _,
+ NextOrFail::Next(ref mut o),
+ ))
+ | Line::Choice(ChoiceInstruction::DynamicInternalElse(
+ _,
+ _,
+ NextOrFail::Next(ref mut o),
)) => {
*o = next;
}
RetractionRecord::AppendedNextOrFail(instr_loc, fail) => {
match &mut self.wam.code_repo.code[instr_loc] {
Line::Choice(ChoiceInstruction::DynamicElse(
- _, _, ref mut next_or_fail,
- )) |
- Line::Choice(ChoiceInstruction::DynamicInternalElse(
- _, _, ref mut next_or_fail,
+ _,
+ _,
+ ref mut next_or_fail,
+ ))
+ | Line::Choice(ChoiceInstruction::DynamicInternalElse(
+ _,
+ _,
+ ref mut next_or_fail,
)) => {
*next_or_fail = fail;
}
}
let term = match term {
- Term::Clause(_, name, terms, _)
- if name.as_str() == ":-" && terms.len() == 1 => {
- return Ok(Some(setup_declaration(&self.load_state, terms)?));
- }
+ Term::Clause(_, name, terms, _) if name.as_str() == ":-" && terms.len() == 1 => {
+ return Ok(Some(setup_declaration(&self.load_state, terms)?));
+ }
term => term,
};
compilation_target: CompilationTarget,
name: ClauseName,
arity: usize,
- flag_accessor: impl Fn(&mut PredicateSkeleton) -> &mut bool,
+ flag_accessor: impl Fn(&mut LocalPredicateSkeleton) -> &mut bool,
retraction_fn: impl Fn(CompilationTarget, PredicateKey) -> RetractionRecord,
) -> Result<(), SessionError> {
let key = (name, arity);
.extensible_predicates
.get_mut(&key)
{
- Some(ref mut skeleton) => {
- if !*flag_accessor(skeleton) {
- *flag_accessor(skeleton) = true;
+ Some(skeleton) => {
+ if !*flag_accessor(&mut skeleton.core) {
+ *flag_accessor(&mut skeleton.core) = true;
self.load_state.retraction_info.push_record(retraction_fn(
compilation_target.clone(),
None => {
if self.load_state.compilation_target == compilation_target {
let mut skeleton = PredicateSkeleton::new();
- *flag_accessor(&mut skeleton) = true;
+ *flag_accessor(&mut skeleton.core) = true;
self.load_state.add_extensible_predicate(
key.clone(),
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 !*flag_accessor(skeleton) {
- *flag_accessor(skeleton) = true;
+ if !*flag_accessor(&mut skeleton.core) {
+ *flag_accessor(&mut skeleton.core) = true;
self.load_state.retraction_info.push_record(retraction_fn(
compilation_target.clone(),
None => {
if self.load_state.compilation_target == compilation_target {
let mut skeleton = PredicateSkeleton::new();
- *flag_accessor(&mut skeleton) = true;
+ *flag_accessor(&mut skeleton.core) = true;
self.load_state.add_extensible_predicate(
key.clone(),
.add_dynamically_generated_module(module_name);
let mut skeleton = PredicateSkeleton::new();
- *flag_accessor(&mut skeleton) = true;
+ *flag_accessor(&mut skeleton.core) = true;
self.load_state.add_extensible_predicate(
key.clone(),
.load_state
.wam
.indices
- .local_extensible_predicates
- .get_mut(&(compilation_target.clone(), key.clone()))
- {
- Some(ref mut skeleton) => {
+ .get_local_predicate_skeleton_mut(
+ self.load_state.compilation_target.clone(),
+ compilation_target.clone(),
+ self.load_state.listing_src_file_name(),
+ key.clone(),
+ ) {
+ Some(skeleton) => {
if !*flag_accessor(skeleton) {
*flag_accessor(skeleton) = true;
}
}
None => {
- let mut skeleton = PredicateSkeleton::new();
+ let mut skeleton = LocalPredicateSkeleton::new();
*flag_accessor(&mut skeleton) = true;
self.load_state.add_local_extensible_predicate(
}
CompilationTarget::Module(ref module_name) => {
match self.load_state.wam.indices.modules.get_mut(module_name) {
- Some(ref mut module) => match module
+ Some(module) => match module
.local_extensible_predicates
.get_mut(&(compilation_target.clone(), key.clone()))
{
- Some(ref mut skeleton) => {
+ Some(skeleton) => {
if !*flag_accessor(skeleton) {
*flag_accessor(skeleton) = true;
}
}
None => {
- let mut skeleton = PredicateSkeleton::new();
+ let mut skeleton = LocalPredicateSkeleton::new();
*flag_accessor(&mut skeleton) = true;
self.load_state.add_local_extensible_predicate(
self.load_state
.add_dynamically_generated_module(module_name);
- let mut skeleton = PredicateSkeleton::new();
+ let mut skeleton = LocalPredicateSkeleton::new();
*flag_accessor(&mut skeleton) = true;
self.load_state.add_local_extensible_predicate(
&self.predicates.compilation_target,
&(predicate_name, arity),
)
- .map(|skeleton| skeleton.is_dynamic)
+ .map(|skeleton| skeleton.core.is_dynamic)
.unwrap_or(false);
if is_dynamic {
.wam
.indices
.get_local_predicate_skeleton_mut(
- &self.load_state.compilation_target,
+ self.load_state.compilation_target.clone(),
self.predicates.compilation_target.clone(),
+ self.load_state.listing_src_file_name(),
key.clone(),
) {
Some(skeleton) if !skeleton.clause_clause_locs.is_empty() => {
let module_name = module_decl.name.clone();
- if !loader.load_state.wam.indices.modules.contains_key(&module_decl.name) {
+ if !loader
+ .load_state
+ .wam
+ .indices
+ .modules
+ .contains_key(&module_decl.name)
+ {
let module = Module::new_in_situ(module_decl);
- loader.load_state.wam.indices.modules.insert(module_name, module);
+ loader
+ .load_state
+ .wam
+ .indices
+ .modules
+ .insert(module_name, module);
} else {
loader.load_state.reset_in_situ_module(
module_decl.clone(),
match loader.load_state.wam.indices.modules.get_mut(&module_name) {
Some(module) => {
- for (key, value) in module.op_dir.drain(0 ..) {
+ for (key, value) in module.op_dir.drain(0..) {
let (prec, spec) = value.shared_op_desc().get();
let mut op_decl = OpDecl::new(prec, spec, key.0);
op_decl.remove(&mut loader.load_state.wam.indices.op_dir);
}
}
- None => {
- }
+ None => {}
}
}
}
.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;
}
.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;
}
_ => {
.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;
}
}
.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;
}
.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;
}
);
// if a new predicate was just created, make it dynamic.
- loader.add_dynamic_predicate(
- compilation_target.clone(),
- key.0.clone(),
- key.1,
- )?;
+ loader.add_dynamic_predicate(compilation_target.clone(), key.0.clone(), key.1)?;
loader.load_state.incremental_compile_clause(
key.clone(),
)
.map(|clause_clause_skeleton| {
skeleton
+ .core
.clause_clause_locs
.iter()
.map(|clause_clause_loc| {
.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
+ .unify(Addr::HeapCell(heap_loc), self.machine_st[temp_v!(4)]);
}
None => {
self.machine_st.fail = true;
.get_predicate_skeleton(&compilation_target, &key)
{
Some(skeleton) => {
- self.machine_st.fail = !skeleton.is_dynamic;
+ self.machine_st.fail = !skeleton.core.is_dynamic;
}
None => {
self.machine_st.fail = true;
.get_predicate_skeleton(&compilation_target, &key)
{
Some(skeleton) => {
- self.machine_st.fail = !skeleton.is_multifile;
+ self.machine_st.fail = !skeleton.core.is_multifile;
}
None => {
self.machine_st.fail = true;
.get_predicate_skeleton(&compilation_target, &key)
{
Some(skeleton) => {
- self.machine_st.fail = !skeleton.is_discontiguous;
+ self.machine_st.fail = !skeleton.core.is_discontiguous;
}
None => {
self.machine_st.fail = true;
projects / scryer-prolog.git / commitdiff