[package]
name = "scryer-prolog"
-version = "0.8.91"
+version = "0.8.92"
repository = "https://github.com/mthom/scryer-prolog"
description = "A modern Prolog implementation written mostly in Rust."
use prolog::machine::machine_indices::*;
use prolog::targets::*;
+use indexmap::IndexMap;
+
use std::cell::Cell;
-use std::collections::{HashMap};
use std::rc::Rc;
use std::vec::Vec;
pub struct CodeGenerator<TermMarker> {
flags: MachineFlags,
marker: TermMarker,
- var_count: HashMap<Rc<Var>, usize>,
+ var_count: IndexMap<Rc<Var>, usize>,
non_counted_bt: bool
}
{
pub fn new(non_counted_bt: bool, flags: MachineFlags) -> Self {
CodeGenerator { marker: Allocator::new(),
- var_count: HashMap::new(),
+ var_count: IndexMap::new(),
non_counted_bt,
flags }
}
fn mark_unsafe_fact_vars(&self, fact: &mut CompiledFact) -> UnsafeVarMarker
{
- let mut unsafe_vars = HashMap::new();
+ let mut unsafe_vars = IndexMap::new();
for var_status in self.marker.bindings().values() {
unsafe_vars.insert(var_status.as_reg_type(), false);
use prolog::targets::*;
use std::cell::Cell;
-use std::collections::{BTreeSet, HashMap};
+use std::collections::BTreeSet;
use std::rc::Rc;
pub struct DebrayAllocator {
arg_c: usize,
temp_lb: usize,
arity: usize, // 0 if not at head.
- contents: HashMap<usize, Rc<Var>>,
+ contents: IndexMap<usize, Rc<Var>>,
in_use: BTreeSet<usize>,
}
arg_c: 1,
temp_lb: 1,
bindings: IndexMap::new(),
- contents: HashMap::new(),
+ contents: IndexMap::new(),
in_use: BTreeSet::new()
}
}
use prolog::instructions::*;
use prolog::iterators::*;
+use indexmap::IndexMap;
+
use std::cell::Cell;
-use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::collections::{BTreeMap, BTreeSet};
use std::collections::btree_map::{IntoIter, IterMut, Values};
use std::mem::swap;
use std::rc::Rc;
pub fn populate_restricting_sets(&mut self)
{
// three stages:
- // 1. move the use sets of each variable to a local HashMap, use_set
+ // 1. move the use sets of each variable to a local IndexMap, use_set
// (iterate mutably, swap mutable refs).
// 2. drain use_set. For each use set of U, add into the
// no-use sets of appropriate variables T =/= U.
// Compute the conflict set of u.
// 1.
- let mut use_sets: HashMap<Rc<Var>, OccurrenceSet> = HashMap::new();
+ let mut use_sets: IndexMap<Rc<Var>, OccurrenceSet> = IndexMap::new();
for (var, &mut (ref mut var_status, _)) in self.iter_mut() {
if let &mut VarStatus::Temp(_, ref mut var_data) = var_status {
}
}
- for (u, use_set) in use_sets.drain() {
+ for (u, use_set) in use_sets.drain(..) {
// 2.
for &(term_loc, reg) in use_set.iter() {
if let GenContext::Last(cn_u) = term_loc {
}
pub struct UnsafeVarMarker {
- pub unsafe_vars: HashMap<RegType, bool>
+ pub unsafe_vars: IndexMap<RegType, bool>
}
impl UnsafeVarMarker {
pub fn new() -> Self {
UnsafeVarMarker {
- unsafe_vars: HashMap::new()
+ unsafe_vars: IndexMap::new()
}
}
use prolog::ordered_float::OrderedFloat;
use prolog::rug::{Integer, Rational};
+use indexmap::IndexMap;
+
use std::cell::Cell;
-use std::collections::{HashMap, VecDeque};
+use std::collections::VecDeque;
use std::rc::Rc;
pub type PredicateKey = (ClauseName, usize); // name, arity.
})
}
-pub type ModuleDir = HashMap<ClauseName, Module>;
+pub type ModuleDir = IndexMap<ClauseName, Module>;
#[derive(Clone)]
pub struct ModuleDecl {
use prolog::machine::machine_indices::*;
use prolog::machine::machine_state::*;
+use indexmap::IndexSet;
+
use std::cmp::Ordering;
-use std::collections::HashSet;
use std::ops::Deref;
use std::vec::Vec;
pub struct HCAcyclicIterator<HCIter> {
iter: HCIter,
}
impl<HCIter: MutStackHCIterator> HCAcyclicIterator<HCIter>
{
pub fn new(iter: HCIter) -> Self {
- HCAcyclicIterator { iter, seen: HashSet::new() }
+ HCAcyclicIterator { iter, seen: IndexSet::new() }
}
}
pub struct HCZippedAcyclicIterator<HCIter> {
i1: HCIter,
i2: HCIter,
- seen: HashSet<(Addr, Addr)>,
+ seen: IndexSet<(Addr, Addr)>,
pub first_to_expire: Ordering
}
impl<HCIter: MutStackHCIterator> HCZippedAcyclicIterator<HCIter>
{
pub fn new(i1: HCIter, i2: HCIter) -> Self {
- HCZippedAcyclicIterator { i1, i2, seen: HashSet::new(),
+ HCZippedAcyclicIterator { i1, i2, seen: IndexSet::new(),
first_to_expire: Ordering::Equal }
}
}
use prolog::ordered_float::OrderedFloat;
use prolog::rug::{Integer};
+use indexmap::{IndexMap, IndexSet};
+
use std::cell::Cell;
-use std::collections::{HashMap, HashSet};
use std::iter::once;
use std::ops::{Range, RangeFrom};
use std::rc::Rc;
}
}
-type ReverseHeapVarDict =
HashMap<Addr, Rc<Var>>;
+type ReverseHeapVarDict =
IndexMap<Addr, Rc<Var>>;
pub struct HCPrinter<'a, Outputter> {
outputter: Outputter,
state_stack: Vec<TokenOrRedirect>,
toplevel_spec: Option<DirectedOp>,
heap_locs: ReverseHeapVarDict,
- printed_vars:
HashSet<Addr>,
+ printed_vars:
IndexSet<Addr>,
last_item_idx: usize,
- cyclic_terms:
HashMap<Addr, usize>,
- pub(crate) var_names:
HashMap<Addr, String>,
+ cyclic_terms:
IndexMap<Addr, usize>,
+ pub(crate) var_names:
IndexMap<Addr, String>,
pub(crate) numbervars_offset: Integer,
pub(crate) numbervars: bool,
pub(crate) quoted: bool,
state_stack: vec![],
heap_locs: ReverseHeapVarDict::new(),
toplevel_spec: None,
- printed_vars: HashSet::new(),
+ printed_vars: IndexSet::new(),
last_item_idx: 0,
numbervars: false,
numbervars_offset: Integer::from(0),
quoted: false,
ignore_ops: false,
- cyclic_terms: HashMap::new(),
- var_names: HashMap::new() }
+ cyclic_terms: IndexMap::new(),
+ var_names: IndexMap::new() }
}
pub fn from_heap_locs(machine_st: &'a MachineState, op_dir: &'a OpDir, output: Outputter)
use prolog_parser::ast::*;
use prolog::instructions::*;
-use std::collections::{HashMap, VecDeque};
+
+use indexmap::IndexMap;
+
+use std::collections::VecDeque;
use std::hash::Hash;
#[derive(Clone, Copy)]
pub struct CodeOffsets {
flags: MachineFlags,
- pub constants: HashMap<Constant, ThirdLevelIndex>,
+ pub constants: IndexMap<Constant, ThirdLevelIndex>,
pub lists: ThirdLevelIndex,
- pub structures: HashMap<(ClauseName, usize), ThirdLevelIndex>
+ pub structures: IndexMap<(ClauseName, usize), ThirdLevelIndex>
}
impl CodeOffsets {
pub fn new(flags: MachineFlags) -> Self {
CodeOffsets {
flags,
- constants: HashMap::new(),
+ constants: IndexMap::new(),
lists: Vec::new(),
- structures: HashMap::new()
+ structures: IndexMap::new()
}
}
};
}
- fn second_level_index<Index>(indices: HashMap<Index, ThirdLevelIndex>, prelude: &mut CodeDeque)
- -> HashMap<Index, IntIndex>
+ fn second_level_index<Index>(indices: IndexMap<Index, ThirdLevelIndex>, prelude: &mut CodeDeque)
+ -> IndexMap<Index, IntIndex>
where Index: Eq + Hash
{
- let mut index_locs = HashMap::new();
+ let mut index_locs = IndexMap::new();
for (key, mut code) in indices.into_iter() {
if code.len() > 1 {
no_constants && no_structures && no_lists
}
- fn flatten_index<Index>(index: HashMap<Index, IntIndex>, len: usize)
- -> HashMap<Index, usize>
+ fn flatten_index<Index>(index: IndexMap<Index, IntIndex>, len: usize)
+ -> IndexMap<Index, usize>
where Index: Eq + Hash
{
- let mut flattened_index = HashMap::new();
+ let mut flattened_index = IndexMap::new();
for (key, int_index) in index.into_iter() {
match int_index {
}
}
- fn switch_on_constant(con_ind: HashMap<Constant, ThirdLevelIndex>, prelude: &mut CodeDeque)
+ fn switch_on_constant(con_ind: IndexMap<Constant, ThirdLevelIndex>, prelude: &mut CodeDeque)
-> IntIndex
{
let con_ind = Self::second_level_index(con_ind, prelude);
}
}
- fn switch_on_structure(str_ind: HashMap<(ClauseName, usize), ThirdLevelIndex>,
+ fn switch_on_structure(str_ind: IndexMap<(ClauseName, usize), ThirdLevelIndex>,
prelude: &mut CodeDeque)
-> IntIndex
{
use prolog::rug::Integer;
-use std::collections::{HashMap, VecDeque};
+use indexmap::IndexMap;
+
+use std::collections::VecDeque;
fn reg_type_into_functor(r: RegType) -> MachineStub {
match r {
pub enum IndexingInstruction {
SwitchOnTerm(usize, usize, usize, usize),
- SwitchOnConstant(usize, HashMap<Constant, usize>),
- SwitchOnStructure(usize, HashMap<(ClauseName, usize), usize>)
+ SwitchOnConstant(usize, IndexMap<Constant, usize>),
+ SwitchOnStructure(usize, IndexMap<(ClauseName, usize), usize>)
}
impl From<IndexingInstruction> for Line {
use prolog::machine::*;
-use std::collections::HashSet;
+use indexmap::IndexSet;
+
use std::vec::IntoIter;
pub static VERIFY_ATTRS: &str = include_str!("attributed_variables.pl");
fn populate_project_attr_lists(&mut self) -> (Addr, Addr)
{
- let mut query_vars = HashSet::new();
+ let mut query_vars = IndexSet::new();
let attr_vars = self.gather_attr_vars_created_since(0);
for (_, addr) in self.heap_locs.iter() {
use prolog::machine::term_expansion::{ExpansionAdditionResult};
use prolog::machine::toplevel::*;
+use indexmap::{IndexMap, IndexSet};
+
use std::cell::Cell;
-use std::collections::{HashMap, HashSet, VecDeque};
+use std::collections::VecDeque;
use std::fs::File;
use std::io::Read;
use std::mem;
pub struct ClauseCodeGenerator {
len_offset: usize,
code: Code,
- pi_to_loc:
HashMap<PredicateKey, usize>
+ pi_to_loc:
IndexMap<PredicateKey, usize>
}
impl ClauseCodeGenerator {
#[inline]
fn new(len_offset: usize) -> Self {
- ClauseCodeGenerator { len_offset, code: vec![], pi_to_loc: HashMap::new() }
+ ClauseCodeGenerator { len_offset, code: vec![], pi_to_loc: IndexMap::new() }
}
fn generate_clause_code(&mut self, dynamic_clause_map: DynamicClauseMap, wam: &Machine)
}
pub struct ListingCompiler {
- non_counted_bt_preds:
HashSet<PredicateKey>,
+ non_counted_bt_preds:
IndexSet<PredicateKey>,
module: Option<Module>,
user_term_dir: TermDir,
orig_term_expansion_lens: (usize, usize),
#[inline]
pub fn new(code_repo: &CodeRepo) -> Self {
ListingCompiler {
- non_counted_bt_preds: HashSet::new(),
+ non_counted_bt_preds: IndexSet::new(),
module: None,
user_term_dir: TermDir::new(),
orig_term_expansion_lens: code_repo.term_dir_entry_len((clause_name!("term_expansion"), 2)),
-use indexmap::IndexMap;
-
use prolog_parser::ast::*;
use prolog_parser::tabled_rc::*;
use prolog::fixtures::*;
use prolog::forms::*;
+use indexmap::IndexMap;
+
use std::cell::RefCell;
use std::cmp::Ordering;
-use std::collections::{BTreeMap, HashMap, VecDeque};
+use std::collections::{BTreeMap, VecDeque};
use std::mem;
use std::ops::{Add, AddAssign, Sub, SubAssign};
use std::rc::Rc;
}
}
-pub type InSituCodeDir =
HashMap<PredicateKey, usize>;
+pub type InSituCodeDir =
IndexMap<PredicateKey, usize>;
// key type: module name, predicate indicator.
-pub type DynamicCodeDir = HashMap<(ClauseName, ClauseName, usize), DynamicPredicateInfo>;
+pub type DynamicCodeDir = IndexMap<(ClauseName, ClauseName, usize), DynamicPredicateInfo>;
-pub type GlobalVarDir = HashMap<ClauseName, Addr>;
+pub type GlobalVarDir = IndexMap<ClauseName, Addr>;
pub struct IndexStore {
pub(super) atom_tbl: TabledData<Atom>,
}
pub type CodeDir = BTreeMap<PredicateKey, CodeIndex>;
-pub type TermDir =
HashMap<PredicateKey, (Predicate, VecDeque<TopLevel>)>;
+pub type TermDir =
IndexMap<PredicateKey, (Predicate, VecDeque<TopLevel>)>;
#[derive(Clone, Copy, PartialEq, Eq, Ord, PartialOrd)]
pub enum CompileTimeHook {
use prolog::rug::{Integer, Rational};
use prolog::read::PrologStream;
+use indexmap::{IndexMap, IndexSet};
+
use std::cmp::{min, max, Ordering};
-use std::collections::{HashMap, HashSet};
use std::f64;
use std::mem;
use std::rc::Rc;
pub(super) fn unify_with_occurs_check(&mut self, a1: Addr, a2: Addr) {
let mut pdl = vec![a1, a2];
- let mut tabu_list: HashSet<(Addr, Addr)> = HashSet::new();
+ let mut tabu_list: IndexSet<(Addr, Addr)> = IndexSet::new();
self.fail = false;
pub(super) fn unify(&mut self, a1: Addr, a2: Addr) {
let mut pdl = vec![a1, a2];
- let mut tabu_list: HashSet<(Addr, Addr)> = HashSet::new();
+ let mut tabu_list: IndexSet<(Addr, Addr)> = IndexSet::new();
self.fail = false;
}
pub(crate) fn is_cyclic_term(&self, addr: Addr) -> bool {
- let mut seen = HashSet::new();
+ let mut seen = IndexSet::new();
let mut fail = false;
let mut iter = self.pre_order_iter(addr);
let a1 = self[temp_v!(1)].clone();
let a2 = self[temp_v!(2)].clone();
- let mut var_pairs = HashMap::new();
+ let mut var_pairs = IndexMap::new();
let iter = self.zipped_acyclic_pre_order_iter(a1, a2);
use prolog::machine::toplevel::stream_to_toplevel;
use prolog::read::PrologStream;
-use std::collections::{HashMap, VecDeque};
+use indexmap::IndexMap;
+
+use std::collections::VecDeque;
use std::io::{Read, Write, stdout};
use std::fs::File;
use std::mem;
use prolog::read::{PrologStream, readline};
use prolog::rug::Integer;
-use std::collections::{HashMap, HashSet, VecDeque};
+use indexmap::{IndexMap, IndexSet};
+
+use std::collections::VecDeque;
use std::io::{stdout, Write};
use std::iter::once;
use std::mem;
&SystemClauseType::Succeed => {},
&SystemClauseType::TermVariables => {
let a1 = self[temp_v!(1)].clone();
- let mut seen_vars = HashSet::new();
+ let mut seen_vars = IndexSet::new();
for item in self.acyclic_pre_order_iter(a1) {
match item {
match self.try_from_list(temp_v!(5), stub.clone()) {
Ok(addrs) => {
- let mut var_names: HashMap<Addr, String> = HashMap::new();
+ let mut var_names: IndexMap<Addr, String> = IndexMap::new();
for addr in addrs {
match addr {
use prolog::machine::machine_state::MachineState;
use prolog::machine::term_expansion::*;
+use indexmap::{IndexMap, IndexSet};
+
use std::borrow::BorrowMut;
-use std::collections::{HashMap, HashSet, VecDeque};
+use std::collections::VecDeque;
use std::cell::Cell;
use std::io::Read;
use std::mem;
fn compute_head(&self, term: &Term) -> Vec<Term>
{
- let mut vars = HashSet::new();
+ let mut vars = IndexSet::new();
for term in post_order_iter(term) {
if let TermRef::Var(_, _, v) = term {
Ok(deque_to_packet(tl, queue))
}
-pub type DynamicClauseMap = HashMap<(ClauseName, usize), Vec<(Term, Term)>>;
+pub type DynamicClauseMap = IndexMap<(ClauseName, usize), Vec<(Term, Term)>>;
pub struct TopLevelBatchWorker<'a, R: Read> {
pub(crate) term_stream: TermStream<'a, R>,
TopLevelBatchWorker { term_stream,
rel_worker: RelationWorker::new(flags),
results: vec![],
- dynamic_clause_map: HashMap::new(),
+ dynamic_clause_map: IndexMap::new(),
in_module: false }
}
macro_rules! default_index_store {
($atom_tbl:expr) => (
- index_store!($atom_tbl, CodeDir::new(), default_op_dir(), HashMap::new())
+ index_store!($atom_tbl, CodeDir::new(), default_op_dir(), IndexMap::new())
)
}
use prolog::machine::toplevel::*;
use prolog::read::readline;
-use std::collections::HashSet;
+use indexmap::IndexSet;
+
use std::mem::swap;
use std::ops::{Range, RangeFrom};
pub struct TestOutputter {
- results: Vec<HashSet<String>>,
- contents: HashSet<String>,
+ results: Vec<IndexSet<String>>,
+ contents: IndexSet<String>,
focus: String
}
fn cache(&mut self) {
self.begin_new_var();
- let mut contents = HashSet::new();
+ let mut contents = IndexSet::new();
swap(&mut contents, &mut self.contents);
self.results.push(contents);
}
impl HCValueOutputter for TestOutputter {
- type Output = Vec<HashSet<String>>;
+ type Output = Vec<IndexSet<String>>;
fn new() -> Self {
TestOutputter { results: vec![],
- contents: HashSet::new(),
+ contents: IndexSet::new(),
focus: String::new() }
}
}
}
-pub fn collect_test_output(wam: &mut Machine, alloc_locs: AllocVarDict) -> Vec<HashSet<String>>
+pub fn collect_test_output(wam: &mut Machine, alloc_locs: AllocVarDict) -> Vec<IndexSet<String>>
{
let mut output = TestOutputter::new();
}
pub fn collect_test_output_with_limit(wam: &mut Machine, alloc_locs: AllocVarDict, limit: usize)
- -> Vec<HashSet<String>>
+ -> Vec<IndexSet<String>>
{
let mut output = TestOutputter::new();
}
#[allow(dead_code)]
-pub fn submit_query(wam: &mut Machine, buffer: &str, result: Vec<HashSet<String>>) -> bool
+pub fn submit_query(wam: &mut Machine, buffer: &str, result: Vec<IndexSet<String>>) -> bool
{
wam.reset();
#[allow(dead_code)]
pub fn submit_query_with_limit(wam: &mut Machine, buffer: &str,
- result: Vec<HashSet<String>>, limit: usize)
+ result: Vec<IndexSet<String>>, limit: usize)
-> bool
{
wam.reset();
projects / scryer-prolog.git / commitdiff