Upgrade to edition. Bump up edition in Cargo.toml

src/prolog/allocator.rs

@@ -1,9 +1,9 @@
 use prolog_parser::ast::*;
 
-use prolog::fixtures::*;
-use prolog::forms::*;
-use prolog::machine::machine_indices::*;
-use prolog::targets::*;
+use crate::prolog::fixtures::*;
+use crate::prolog::forms::*;
+use crate::prolog::machine::machine_indices::*;
+use crate::prolog::targets::*;
 
 use std::cell::Cell;
 use std::rc::Rc;
@@ -11,31 +11,31 @@ use std::rc::Rc;
 pub trait Allocator<'a> {
     fn new() -> Self;
 
-    fn mark_anon_var<Target>(&mut self, Level, GenContext, &mut Vec<Target>)
+    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>)
+    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,
-        Rc<Var>,
-        Level,
-        &'a Cell<VarReg>,
-        GenContext,
-        &mut Vec<Target>,
-        RegType,
-        bool,
+        _: Rc<Var>,
+        _: Level,
+        _: &'a Cell<VarReg>,
+        _: GenContext,
+        _: &mut Vec<Target>,
+        _: RegType,
+        _: bool,
     ) where
         Target: CompilationTarget<'a>;
-    fn mark_var<Target>(&mut self, Rc<Var>, Level, &'a Cell<VarReg>, GenContext, &mut Vec<Target>)
+    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 reset_contents(&mut self) {}
-    fn reset_arg(&mut self, usize);
-    fn reset_at_head(&mut self, &Vec<Box<Term>>);
+    fn reset_arg(&mut self, _: usize);
+    fn reset_at_head(&mut self, _: &Vec<Box<Term>>);
 
     fn advance_arg(&mut self);
 

src/prolog/arithmetic.rs

@@ -1,17 +1,17 @@
 use prolog_parser::ast::*;
 
-use prolog::clause_types::*;
-use prolog::fixtures::*;
-use prolog::forms::*;
-use prolog::instructions::*;
-use prolog::iterators::*;
+use crate::prolog::clause_types::*;
+use crate::prolog::fixtures::*;
+use crate::prolog::forms::*;
+use crate::prolog::instructions::*;
+use crate::prolog::iterators::*;
 
-use prolog::machine::machine_errors::*;
-use prolog::machine::machine_indices::*;
+use crate::prolog::machine::machine_errors::*;
+use crate::prolog::machine::machine_indices::*;
 
-use prolog::ordered_float::*;
-use prolog::rug::ops::PowAssign;
-use prolog::rug::{Assign, Integer, Rational};
+use crate::prolog::ordered_float::*;
+use crate::prolog::rug::ops::PowAssign;
+use crate::prolog::rug::{Assign, Integer, Rational};
 
 use std::cell::Cell;
 use std::cmp::{max, min, Ordering};

src/prolog/clause_types.rs

@@ -1,7 +1,7 @@
 use prolog_parser::ast::*;
 
-use prolog::forms::Number;
-use prolog::machine::machine_indices::*;
+use crate::prolog::forms::Number;
+use crate::prolog::machine::machine_indices::*;
 
 use ref_thread_local::RefThreadLocal;
 

src/prolog/codegen.rs

@@ -1,15 +1,15 @@
 use prolog_parser::ast::*;
 
-use prolog::allocator::*;
-use prolog::arithmetic::*;
-use prolog::clause_types::*;
-use prolog::fixtures::*;
-use prolog::forms::*;
-use prolog::indexing::*;
-use prolog::instructions::*;
-use prolog::iterators::*;
-use prolog::machine::machine_indices::*;
-use prolog::targets::*;
+use crate::prolog::allocator::*;
+use crate::prolog::arithmetic::*;
+use crate::prolog::clause_types::*;
+use crate::prolog::fixtures::*;
+use crate::prolog::forms::*;
+use crate::prolog::indexing::*;
+use crate::prolog::instructions::*;
+use crate::prolog::iterators::*;
+use crate::prolog::machine::machine_indices::*;
+use crate::prolog::targets::*;
 
 use indexmap::IndexMap;
 
@@ -701,7 +701,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
         }
 
         let iter = ChunkedIterator::from_rule_body(p1, clauses);
-        try!(self.compile_seq(iter, &conjunct_info, &mut code, false));
+        self.compile_seq(iter, &conjunct_info, &mut code, false)?;
 
         if conjunct_info.allocates() {
             conjunct_info.mark_unsafe_vars(unsafe_var_marker, &mut code);
@@ -800,7 +800,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
         self.compile_seq_prelude(&conjunct_info, &mut code);
 
         let iter = ChunkedIterator::from_term_sequence(query);
-        try!(self.compile_seq(iter, &conjunct_info, &mut code, true));
+        self.compile_seq(iter, &conjunct_info, &mut code, true)?;
 
         if conjunct_info.allocates() {
             conjunct_info.mark_unsafe_vars(UnsafeVarMarker::new(), &mut code);
@@ -904,7 +904,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<TermMarker> {
         let multi_seq = split_pred.len() > 1;
 
         for (l, r) in split_pred {
-            let mut code_segment = try!(self.compile_pred_subseq(&clauses[l..r]));
+            let mut code_segment = self.compile_pred_subseq(&clauses[l..r])?;
 
             if multi_seq {
                 let choice = match l {

src/prolog/debray_allocator.rs

@@ -2,11 +2,11 @@ use indexmap::IndexMap;
 
 use prolog_parser::ast::*;
 
-use prolog::allocator::*;
-use prolog::fixtures::*;
-use prolog::forms::*;
-use prolog::machine::machine_indices::*;
-use prolog::targets::*;
+use crate::prolog::allocator::*;
+use crate::prolog::fixtures::*;
+use crate::prolog::forms::*;
+use crate::prolog::machine::machine_indices::*;
+use crate::prolog::targets::*;
 
 use std::cell::Cell;
 use std::collections::BTreeSet;

src/prolog/fixtures.rs

@@ -1,8 +1,8 @@
 use prolog_parser::ast::*;
 
-use prolog::forms::*;
-use prolog::instructions::*;
-use prolog::iterators::*;
+use crate::prolog::forms::*;
+use crate::prolog::instructions::*;
+use crate::prolog::iterators::*;
 
 use indexmap::IndexMap;
 

src/prolog/forms.rs

@@ -2,11 +2,11 @@ use prolog_parser::ast::*;
 use prolog_parser::parser::OpDesc;
 use prolog_parser::tabled_rc::*;
 
-use prolog::clause_types::*;
-use prolog::machine::machine_errors::*;
-use prolog::machine::machine_indices::*;
-use prolog::ordered_float::OrderedFloat;
-use prolog::rug::{Integer, Rational};
+use crate::prolog::clause_types::*;
+use crate::prolog::machine::machine_errors::*;
+use crate::prolog::machine::machine_indices::*;
+use crate::prolog::ordered_float::OrderedFloat;
+use crate::prolog::rug::{Integer, Rational};
 
 use indexmap::IndexMap;
 

src/prolog/heap_iter.rs

@@ -1,7 +1,7 @@
 use prolog_parser::ast::*;
 
-use prolog::machine::machine_indices::*;
-use prolog::machine::machine_state::*;
+use crate::prolog::machine::machine_indices::*;
+use crate::prolog::machine::machine_state::*;
 
 use indexmap::IndexSet;
 

src/prolog/heap_print.rs

@@ -1,13 +1,13 @@
 use prolog_parser::ast::*;
 use prolog_parser::string_list::*;
 
-use prolog::clause_types::*;
-use prolog::forms::*;
-use prolog::heap_iter::*;
-use prolog::machine::machine_indices::*;
-use prolog::machine::machine_state::*;
-use prolog::ordered_float::OrderedFloat;
-use prolog::rug::Integer;
+use crate::prolog::clause_types::*;
+use crate::prolog::forms::*;
+use crate::prolog::heap_iter::*;
+use crate::prolog::machine::machine_indices::*;
+use crate::prolog::machine::machine_state::*;
+use crate::prolog::ordered_float::OrderedFloat;
+use crate::prolog::rug::Integer;
 
 use indexmap::{IndexMap, IndexSet};
 
@@ -174,16 +174,16 @@ pub trait HCValueOutputter {
     type Output;
 
     fn new() -> Self;
-    fn push_char(&mut self, char);
-    fn append(&mut self, &str);
+    fn push_char(&mut self, _: char);
+    fn append(&mut self, _: &str);
     fn begin_new_var(&mut self);
-    fn insert(&mut self, usize, char);
+    fn insert(&mut self, _: usize, _: char);
     fn result(self) -> Self::Output;
-    fn ends_with(&self, &str) -> bool;
+    fn ends_with(&self, _: &str) -> bool;
     fn len(&self) -> usize;
-    fn truncate(&mut self, usize);
-    fn range(&self, Range<usize>) -> &str;
-    fn range_from(&self, RangeFrom<usize>) -> &str;
+    fn truncate(&mut self, _: usize);
+    fn range(&self, _: Range<usize>) -> &str;
+    fn range_from(&self, _: RangeFrom<usize>) -> &str;
 }
 
 pub struct PrinterOutputter {

src/prolog/indexing.rs

@@ -1,6 +1,6 @@
 use prolog_parser::ast::*;
 
-use prolog::instructions::*;
+use crate::prolog::instructions::*;
 
 use indexmap::IndexMap;
 

src/prolog/instructions.rs

@@ -1,11 +1,11 @@
 use prolog_parser::ast::*;
 
-use prolog::clause_types::*;
-use prolog::forms::*;
-use prolog::machine::machine_errors::MachineStub;
-use prolog::machine::machine_indices::*;
+use crate::prolog::clause_types::*;
+use crate::prolog::forms::*;
+use crate::prolog::machine::machine_errors::MachineStub;
+use crate::prolog::machine::machine_indices::*;
 
-use prolog::rug::Integer;
+use crate::prolog::rug::Integer;
 
 use indexmap::IndexMap;
 

src/prolog/iterators.rs

@@ -1,8 +1,8 @@
 use prolog_parser::ast::*;
 
-use prolog::clause_types::*;
-use prolog::forms::*;
-use prolog::machine::machine_indices::*;
+use crate::prolog::clause_types::*;
+use crate::prolog::forms::*;
+use crate::prolog::machine::machine_indices::*;
 
 use std::cell::Cell;
 use std::collections::VecDeque;

src/prolog/machine/and_stack.rs

@@ -1,4 +1,4 @@
-use prolog::machine::machine_indices::*;
+use crate::prolog::machine::machine_indices::*;
 
 use std::mem;
 use std::ops::{Index, IndexMut};

src/prolog/machine/attributed_variables.rs

@@ -1,4 +1,4 @@
-use prolog::machine::*;
+use crate::prolog::machine::*;
 
 use indexmap::IndexSet;
 

src/prolog/machine/code_repo.rs

@@ -1,13 +1,13 @@
 use prolog_parser::ast::MachineFlags;
 
-use prolog::clause_types::*;
-use prolog::codegen::*;
-use prolog::debray_allocator::*;
-use prolog::forms::*;
-use prolog::instructions::*;
-use prolog::machine::compile::*;
-use prolog::machine::machine_errors::*;
-use prolog::machine::machine_indices::*;
+use crate::prolog::clause_types::*;
+use crate::prolog::codegen::*;
+use crate::prolog::debray_allocator::*;
+use crate::prolog::forms::*;
+use crate::prolog::instructions::*;
+use crate::prolog::machine::compile::*;
+use crate::prolog::machine::machine_errors::*;
+use crate::prolog::machine::machine_indices::*;
 
 use std::collections::VecDeque;
 

src/prolog/machine/compile.rs

@@ -2,16 +2,16 @@ use prolog_parser::ast::*;
 use prolog_parser::parser::get_desc;
 use prolog_parser::tabled_rc::TabledData;
 
-use prolog::codegen::*;
-use prolog::debray_allocator::*;
-use prolog::forms::*;
-use prolog::instructions::*;
-use prolog::iterators::*;
-use prolog::machine::machine_errors::*;
-use prolog::machine::machine_indices::*;
-use prolog::machine::term_expansion::ExpansionAdditionResult;
-use prolog::machine::toplevel::*;
-use prolog::machine::*;
+use crate::prolog::codegen::*;
+use crate::prolog::debray_allocator::*;
+use crate::prolog::forms::*;
+use crate::prolog::instructions::*;
+use crate::prolog::iterators::*;
+use crate::prolog::machine::machine_errors::*;
+use crate::prolog::machine::machine_indices::*;
+use crate::prolog::machine::term_expansion::ExpansionAdditionResult;
+use crate::prolog::machine::toplevel::*;
+use crate::prolog::machine::*;
 
 use indexmap::{IndexMap, IndexSet};
 
@@ -228,7 +228,7 @@ fn compile_query(
 ) -> Result<(Code, AllocVarDict), ParserError> {
     // count backtracking inferences.
     let mut cg = CodeGenerator::<DebrayAllocator>::new(false, flags);
-    let mut code = try!(cg.compile_query(&terms));
+    let mut code = cg.compile_query(&terms)?;
 
     compile_appendix(&mut code, &queue, false, flags)?;
     Ok((code, cg.take_vars()))

src/prolog/machine/copier.rs

@@ -1,5 +1,5 @@
-use prolog::machine::and_stack::*;
-use prolog::machine::machine_indices::*;
+use crate::prolog::machine::and_stack::*;
+use crate::prolog::machine::machine_indices::*;
 
 use std::ops::IndexMut;
 
@@ -7,9 +7,9 @@ type Trail = Vec<(Ref, HeapCellValue)>;
 
 pub(crate) trait CopierTarget: IndexMut<usize, Output = HeapCellValue> {
     fn threshold(&self) -> usize;
-    fn push(&mut self, HeapCellValue);
-    fn store(&self, Addr) -> Addr;
-    fn deref(&self, Addr) -> Addr;
+    fn push(&mut self, _: HeapCellValue);
+    fn store(&self, _: Addr) -> Addr;
+    fn deref(&self, _: Addr) -> Addr;
     fn stack(&mut self) -> &mut AndStack;
 }
 

src/prolog/machine/dynamic_database.rs

@@ -1,9 +1,9 @@
 use prolog_parser::ast::*;
 
-use prolog::heap_print::*;
-use prolog::machine::compile::*;
-use prolog::machine::machine_errors::*;
-use prolog::machine::*;
+use crate::prolog::heap_print::*;
+use crate::prolog::machine::compile::*;
+use crate::prolog::machine::machine_errors::*;
+use crate::prolog::machine::*;
 
 use std::io::Read;
 

src/prolog/machine/heap.rs

@@ -1,6 +1,6 @@
 use prolog_parser::ast::*;
 
-use prolog::machine::machine_indices::*;
+use crate::prolog::machine::machine_indices::*;
 
 use std::mem;
 use std::ops::{Index, IndexMut};

src/prolog/machine/machine_errors.rs

@@ -1,9 +1,9 @@
 use prolog_parser::ast::*;
 use prolog_parser::string_list::*;
 
-use prolog::machine::machine_indices::*;
-use prolog::machine::machine_state::*;
-use prolog::rug::Integer;
+use crate::prolog::machine::machine_indices::*;
+use crate::prolog::machine::machine_state::*;
+use crate::prolog::rug::Integer;
 
 pub(crate) type MachineStub = Vec<HeapCellValue>;
 

src/prolog/machine/machine_indices.rs

@@ -1,10 +1,10 @@
 use prolog_parser::ast::*;
 use prolog_parser::tabled_rc::*;
 
-use prolog::clause_types::*;
-use prolog::fixtures::*;
-use prolog::forms::*;
-use prolog::machine::Ball;
+use crate::prolog::clause_types::*;
+use crate::prolog::fixtures::*;
+use crate::prolog::forms::*;
+use crate::prolog::machine::Ball;
 
 use indexmap::IndexMap;
 

src/prolog/machine/machine_state.rs

@@ -1,18 +1,18 @@
 use prolog_parser::ast::*;
 use prolog_parser::string_list::*;
 
-use prolog::clause_types::*;
-use prolog::forms::*;
-use prolog::machine::and_stack::*;
-use prolog::machine::attributed_variables::*;
-use prolog::machine::copier::*;
-use prolog::machine::heap::*;
-use prolog::machine::machine_errors::*;
-use prolog::machine::machine_indices::*;
-use prolog::machine::modules::*;
-use prolog::machine::or_stack::*;
-use prolog::read::PrologStream;
-use prolog::rug::Integer;
+use crate::prolog::clause_types::*;
+use crate::prolog::forms::*;
+use crate::prolog::machine::and_stack::*;
+use crate::prolog::machine::attributed_variables::*;
+use crate::prolog::machine::copier::*;
+use crate::prolog::machine::heap::*;
+use crate::prolog::machine::machine_errors::*;
+use crate::prolog::machine::machine_indices::*;
+use crate::prolog::machine::modules::*;
+use crate::prolog::machine::or_stack::*;
+use crate::prolog::read::PrologStream;
+use crate::prolog::rug::Integer;
 
 use downcast::Any;
 
@@ -1025,7 +1025,7 @@ impl CWILCallPolicy {
 
 pub(crate) trait CutPolicy: Any {
     // returns true iff we fail or cut redirected the MachineState's p itself
-    fn cut(&mut self, &mut MachineState, RegType) -> bool;
+    fn cut(&mut self, _: &mut MachineState, _: RegType) -> bool;
 }
 
 downcast!(dyn CutPolicy);

src/prolog/machine/machine_state_impl.rs

@@ -2,25 +2,25 @@ use prolog_parser::ast::*;
 use prolog_parser::string_list::StringList;
 use prolog_parser::tabled_rc::*;
 
-use prolog::arithmetic::*;
-use prolog::clause_types::*;
-use prolog::forms::*;
-use prolog::heap_iter::*;
-use prolog::heap_print::*;
-use prolog::instructions::*;
-use prolog::machine::INTERRUPT;
-use prolog::machine::and_stack::*;
-use prolog::machine::attributed_variables::*;
-use prolog::machine::code_repo::CodeRepo;
-use prolog::machine::copier::*;
-use prolog::machine::heap::*;
-use prolog::machine::machine_errors::*;
-use prolog::machine::machine_indices::*;
-use prolog::machine::machine_state::*;
-use prolog::machine::or_stack::*;
-use prolog::ordered_float::*;
-use prolog::read::PrologStream;
-use prolog::rug::{Integer, Rational};
+use crate::prolog::arithmetic::*;
+use crate::prolog::clause_types::*;
+use crate::prolog::forms::*;
+use crate::prolog::heap_iter::*;
+use crate::prolog::heap_print::*;
+use crate::prolog::instructions::*;
+use crate::prolog::machine::INTERRUPT;
+use crate::prolog::machine::and_stack::*;
+use crate::prolog::machine::attributed_variables::*;
+use crate::prolog::machine::code_repo::CodeRepo;
+use crate::prolog::machine::copier::*;
+use crate::prolog::machine::heap::*;
+use crate::prolog::machine::machine_errors::*;
+use crate::prolog::machine::machine_indices::*;
+use crate::prolog::machine::machine_state::*;
+use crate::prolog::machine::or_stack::*;
+use crate::prolog::ordered_float::*;
+use crate::prolog::read::PrologStream;
+use crate::prolog::rug::{Integer, Rational};
 
 use indexmap::{IndexMap, IndexSet};
 

src/prolog/machine/mod.rs

@@ -1,13 +1,13 @@
 use prolog_parser::ast::*;
 use prolog_parser::tabled_rc::*;
 
-use prolog::clause_types::*;
-use prolog::fixtures::*;
-use prolog::forms::*;
-use prolog::heap_print::*;
-use prolog::instructions::*;
-use prolog::read::*;
-use prolog::write::{next_keypress, ContinueResult};
+use crate::prolog::clause_types::*;
+use crate::prolog::fixtures::*;
+use crate::prolog::forms::*;
+use crate::prolog::heap_print::*;
+use crate::prolog::instructions::*;
+use crate::prolog::read::*;
+use crate::prolog::write::{next_keypress, ContinueResult};
 
 mod and_stack;
 mod attributed_variables;
@@ -28,15 +28,15 @@ pub mod toplevel;
 mod machine_state_impl;
 mod system_calls;
 
-use prolog::machine::attributed_variables::*;
-use prolog::machine::code_repo::*;
-use prolog::machine::compile::*;
-use prolog::machine::machine_errors::*;
-use prolog::machine::machine_indices::*;
-use prolog::machine::machine_state::*;
-use prolog::machine::modules::*;
-use prolog::machine::toplevel::stream_to_toplevel;
-use prolog::read::PrologStream;
+use crate::prolog::machine::attributed_variables::*;
+use crate::prolog::machine::code_repo::*;
+use crate::prolog::machine::compile::*;
+use crate::prolog::machine::machine_errors::*;
+use crate::prolog::machine::machine_indices::*;
+use crate::prolog::machine::machine_state::*;
+use crate::prolog::machine::modules::*;
+use crate::prolog::machine::toplevel::stream_to_toplevel;
+use crate::prolog::read::PrologStream;
 
 use indexmap::IndexMap;
 

src/prolog/machine/modules.rs

@@ -1,10 +1,10 @@
 use prolog_parser::ast::*;
 use prolog_parser::tabled_rc::*;
 
-use prolog::forms::*;
-use prolog::machine::code_repo::*;
-use prolog::machine::machine_errors::*;
-use prolog::machine::machine_indices::*;
+use crate::prolog::forms::*;
+use crate::prolog::machine::code_repo::*;
+use crate::prolog::machine::machine_errors::*;
+use crate::prolog::machine::machine_indices::*;
 
 use std::collections::VecDeque;
 
@@ -82,10 +82,10 @@ impl Module {
 pub trait SubModuleUser {
     fn atom_tbl(&self) -> TabledData<Atom>;
     fn op_dir(&mut self) -> &mut OpDir;
-    fn remove_code_index(&mut self, PredicateKey);
-    fn get_code_index(&self, PredicateKey, ClauseName) -> Option<CodeIndex>;
+    fn remove_code_index(&mut self, _: PredicateKey);
+    fn get_code_index(&self, _: PredicateKey, _: ClauseName) -> Option<CodeIndex>;
 
-    fn insert_dir_entry(&mut self, ClauseName, usize, CodeIndex);
+    fn insert_dir_entry(&mut self, _: ClauseName, _: usize, _: CodeIndex);
 
     fn get_op_module_name(&mut self, name: ClauseName, fixity: Fixity) -> Option<ClauseName> {
         self.op_dir()
@@ -168,12 +168,12 @@ pub trait SubModuleUser {
 
     fn use_qualified_module(
         &mut self,
-        &mut CodeRepo,
-        MachineFlags,
-        &Module,
-        &Vec<PredicateKey>,
+        _: &mut CodeRepo,
+        _: MachineFlags,
+        _: &Module,
+        _: &Vec<PredicateKey>,
     ) -> Result<(), SessionError>;
-    fn use_module(&mut self, &mut CodeRepo, MachineFlags, &Module) -> Result<(), SessionError>;
+    fn use_module(&mut self, _: &mut CodeRepo, _: MachineFlags, _: &Module) -> Result<(), SessionError>;
 }
 
 pub fn use_qualified_module<User>(

src/prolog/machine/or_stack.rs

@@ -1,4 +1,4 @@
-use prolog::machine::machine_indices::*;
+use crate::prolog::machine::machine_indices::*;
 
 use std::mem;
 use std::ops::{Index, IndexMut};

src/prolog/machine/system_calls.rs

@@ -3,19 +3,19 @@ use prolog_parser::parser::*;
 use prolog_parser::string_list::*;
 use prolog_parser::tabled_rc::*;
 
-use prolog::clause_types::*;
-use prolog::forms::*;
-use prolog::heap_print::*;
-use prolog::instructions::*;
-use prolog::machine::code_repo::CodeRepo;
-use prolog::machine::copier::*;
-use prolog::machine::machine_errors::*;
-use prolog::machine::machine_indices::*;
-use prolog::machine::machine_state::*;
-use prolog::machine::toplevel::to_op_decl;
-use prolog::ordered_float::OrderedFloat;
-use prolog::read::{readline, PrologStream};
-use prolog::rug::Integer;
+use crate::prolog::clause_types::*;
+use crate::prolog::forms::*;
+use crate::prolog::heap_print::*;
+use crate::prolog::instructions::*;
+use crate::prolog::machine::code_repo::CodeRepo;
+use crate::prolog::machine::copier::*;
+use crate::prolog::machine::machine_errors::*;
+use crate::prolog::machine::machine_indices::*;
+use crate::prolog::machine::machine_state::*;
+use crate::prolog::machine::toplevel::to_op_decl;
+use crate::prolog::ordered_float::OrderedFloat;
+use crate::prolog::read::{readline, PrologStream};
+use crate::prolog::rug::Integer;
 
 use indexmap::{IndexMap, IndexSet};
 

src/prolog/machine/term_expansion.rs

@@ -1,10 +1,10 @@
 use prolog_parser::ast::*;
 use prolog_parser::parser::*;
 
-use prolog::machine::machine_indices::HeapCellValue;
-use prolog::machine::*;
-use prolog::rug::ops::Pow;
-use prolog::rug::Integer;
+use crate::prolog::machine::machine_indices::HeapCellValue;
+use crate::prolog::machine::*;
+use crate::prolog::rug::ops::Pow;
+use crate::prolog::rug::Integer;
 
 use std::cell::Cell;
 use std::collections::VecDeque;

src/prolog/machine/toplevel.rs

@@ -1,12 +1,12 @@
 use prolog_parser::ast::*;
 use prolog_parser::tabled_rc::*;
 
-use prolog::forms::*;
-use prolog::iterators::*;
-use prolog::machine::machine_errors::*;
-use prolog::machine::machine_indices::*;
-use prolog::machine::term_expansion::*;
-use prolog::machine::*;
+use crate::prolog::forms::*;
+use crate::prolog::iterators::*;
+use crate::prolog::machine::machine_errors::*;
+use crate::prolog::machine::machine_indices::*;
+use crate::prolog::machine::term_expansion::*;
+use crate::prolog::machine::*;
 
 use indexmap::{IndexMap, IndexSet};
 

src/prolog/read.rs

@@ -2,10 +2,10 @@ use prolog_parser::ast::*;
 use prolog_parser::parser::*;
 use prolog_parser::tabled_rc::TabledData;
 
-use prolog::forms::*;
-use prolog::iterators::*;
-use prolog::machine::machine_indices::*;
-use prolog::machine::machine_state::MachineState;
+use crate::prolog::forms::*;
+use crate::prolog::iterators::*;
+use crate::prolog::machine::machine_indices::*;
+use crate::prolog::machine::machine_state::MachineState;
 
 use std::collections::VecDeque;
 use std::io::Read;
@@ -27,8 +27,8 @@ pub type PrologStream = ParsingStream<Box<dyn Read>>;
 
 pub mod readline {
     use prolog_parser::ast::*;
-    use prolog::rustyline::error::ReadlineError;
-    use prolog::rustyline::{Cmd, Editor, KeyPress};
+    use crate::prolog::rustyline::error::ReadlineError;
+    use crate::prolog::rustyline::{Cmd, Editor, KeyPress};
     use std::io::Read;
 
     static mut PROMPT: bool = false;
@@ -115,7 +115,7 @@ pub mod readline {
     }
 
     #[inline]
-    pub fn input_stream() -> ::PrologStream {
+    pub fn input_stream() -> crate::PrologStream {
         let reader: Box<dyn Read> = Box::new(ReadlineStream::input_stream(String::from("")));
         parsing_stream(reader)
     }

src/prolog/targets.rs

@@ -1,35 +1,35 @@
 use prolog_parser::ast::*;
 
-use prolog::clause_types::*;
-use prolog::forms::*;
-use prolog::instructions::*;
-use prolog::iterators::*;
+use crate::prolog::clause_types::*;
+use crate::prolog::forms::*;
+use crate::prolog::instructions::*;
+use crate::prolog::iterators::*;
 
 pub trait CompilationTarget<'a> {
     type Iterator: Iterator<Item = TermRef<'a>>;
 
-    fn iter(&'a Term) -> Self::Iterator;
+    fn iter(_: &'a Term) -> Self::Iterator;
 
-    fn to_constant(Level, Constant, RegType) -> Self;
-    fn to_list(Level, RegType) -> Self;
-    fn to_structure(ClauseType, usize, RegType) -> Self;
+    fn to_constant(_: Level, _: Constant, _: RegType) -> Self;
+    fn to_list(_: Level, _: RegType) -> Self;
+    fn to_structure(_: ClauseType, _: usize, _: RegType) -> Self;
 
-    fn to_void(usize) -> Self;
+    fn to_void(_: usize) -> Self;
     fn is_void_instr(&self) -> bool;
 
     fn incr_void_instr(&mut self);
 
-    fn constant_subterm(Constant) -> Self;
+    fn constant_subterm(_: Constant) -> Self;
 
-    fn argument_to_variable(RegType, usize) -> Self;
-    fn argument_to_value(RegType, usize) -> Self;
+    fn argument_to_variable(_: RegType, _: usize) -> Self;
+    fn argument_to_value(_: RegType, _: usize) -> Self;
 
-    fn move_to_register(RegType, usize) -> Self;
+    fn move_to_register(_: RegType, _: usize) -> Self;
 
-    fn subterm_to_variable(RegType) -> Self;
-    fn subterm_to_value(RegType) -> Self;
+    fn subterm_to_variable(_: RegType) -> Self;
+    fn subterm_to_value(_: RegType) -> Self;
 
-    fn clause_arg_to_instr(RegType) -> Self;
+    fn clause_arg_to_instr(_: RegType) -> Self;
 }
 
 impl<'a> CompilationTarget<'a> for FactInstruction {

src/prolog/write.rs

@@ -1,8 +1,8 @@
-use prolog::clause_types::*;
-use prolog::forms::*;
-use prolog::instructions::*;
-use prolog::machine::machine_errors::*;
-use prolog::machine::machine_indices::*;
+use crate::prolog::clause_types::*;
+use crate::prolog::forms::*;
+use crate::prolog::instructions::*;
+use crate::prolog::machine::machine_errors::*;
+use crate::prolog::machine::machine_indices::*;
 
 use termion::event::Key;
 use termion::input::TermRead;