725 lines
21 KiB
Rust
725 lines
21 KiB
Rust
use crate::parser::ast::*;
|
|
|
|
use crate::arena::*;
|
|
use crate::atom_table::*;
|
|
use crate::clause_types::*;
|
|
use crate::fixtures::*;
|
|
use crate::forms::*;
|
|
use crate::instructions::*;
|
|
|
|
use crate::machine::code_repo::CodeRepo;
|
|
use crate::machine::heap::*;
|
|
use crate::machine::loader::*;
|
|
use crate::machine::machine_errors::MachineStub;
|
|
use crate::machine::machine_state::*;
|
|
use crate::machine::streams::Stream;
|
|
|
|
use indexmap::IndexMap;
|
|
|
|
use std::cell::Cell;
|
|
use std::cmp::Ordering;
|
|
use std::collections::BTreeSet;
|
|
use std::fmt;
|
|
use std::ops::{Add, AddAssign, Deref, Sub, SubAssign};
|
|
use std::rc::Rc;
|
|
|
|
use crate::types::*;
|
|
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub(crate) struct OrderedOpDirKey(pub(crate) Atom, pub(crate) Fixity);
|
|
|
|
pub(crate) type OssifiedOpDir = IndexMap<(Atom, Fixity), (usize, Specifier)>;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum DBRef {
|
|
NamedPred(Atom, usize),
|
|
Op(Atom, Fixity, TypedArenaPtr<OssifiedOpDir>),
|
|
}
|
|
|
|
// 7.2
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
|
pub enum TermOrderCategory {
|
|
Variable,
|
|
FloatingPoint,
|
|
Integer,
|
|
Atom,
|
|
Compound,
|
|
}
|
|
|
|
impl PartialEq<Ref> for HeapCellValue {
|
|
fn eq(&self, r: &Ref) -> bool {
|
|
self.as_var() == Some(*r)
|
|
}
|
|
}
|
|
|
|
impl PartialOrd<Ref> for HeapCellValue {
|
|
fn partial_cmp(&self, r: &Ref) -> Option<Ordering> {
|
|
read_heap_cell!(*self,
|
|
(HeapCellValueTag::StackVar, s1) => {
|
|
match r.get_tag() {
|
|
RefTag::StackCell => {
|
|
let s2 = r.get_value() as usize;
|
|
s1.partial_cmp(&s2)
|
|
}
|
|
_ => Some(Ordering::Greater),
|
|
}
|
|
}
|
|
(HeapCellValueTag::AttrVar | HeapCellValueTag::Var, h1) => {
|
|
// _ if self.is_ref() => {
|
|
// let h1 = self.get_value();
|
|
|
|
match r.get_tag() {
|
|
RefTag::StackCell => Some(Ordering::Less),
|
|
_ => {
|
|
let h2 = r.get_value() as usize;
|
|
h1.partial_cmp(&h2)
|
|
}
|
|
}
|
|
}
|
|
_ => {
|
|
None
|
|
}
|
|
)
|
|
}
|
|
}
|
|
/*
|
|
impl HeapCellValue {
|
|
#[inline]
|
|
pub fn as_constant_index(self, machine_st: &MachineState) -> Option<Literal> {
|
|
read_heap_cell!(self,
|
|
(HeapCellValueTag::Char, c) => Some(Literal::Char(c)),
|
|
(HeapCellValueTag::Atom, (name, arity)) => {
|
|
if arity == 0 {
|
|
Some(Literal::Atom(name))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
(HeapCellValueTag::Fixnum, n) => {
|
|
Some(Literal::Fixnum(n))
|
|
}
|
|
(HeapCellValueTag::F64, f) => {
|
|
Some(Literal::Float(f))
|
|
}
|
|
(HeapCellValueTag::Cons, ptr) => {
|
|
match_untyped_arena_ptr!(ptr,
|
|
(ArenaHeaderTag::Integer, n) => {
|
|
Some(Literal::Integer(n))
|
|
}
|
|
(ArenaHeaderTag::Rational, r) => {
|
|
Some(Literal::Rational(r))
|
|
}
|
|
_ => {
|
|
None
|
|
}
|
|
)
|
|
}
|
|
)
|
|
}
|
|
}
|
|
*/
|
|
/*
|
|
impl Ord for Ref {
|
|
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::StackCell(fr1, sc1), Ref::StackCell(fr2, sc2)) => {
|
|
fr1.cmp(&fr2).then_with(|| sc1.cmp(&sc2))
|
|
}
|
|
(Ref::StackCell(..), _) => Ordering::Greater,
|
|
(_, Ref::StackCell(..)) => Ordering::Less,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PartialEq<Ref> for Addr {
|
|
fn eq(&self, r: &Ref) -> bool {
|
|
self.as_var() == Some(*r)
|
|
}
|
|
}
|
|
|
|
impl Addr {
|
|
#[inline]
|
|
pub(crate) fn is_heap_bound(&self) -> bool {
|
|
match self {
|
|
Addr::Char(_)
|
|
| Addr::EmptyList
|
|
| Addr::CutPoint(_)
|
|
| Addr::Usize(_)
|
|
| Addr::Fixnum(_)
|
|
| Addr::Float(_) => false,
|
|
_ => true,
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn is_ref(&self) -> bool {
|
|
match self {
|
|
Addr::HeapCell(_) | Addr::StackCell(_, _) | Addr::AttrVar(_) => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn as_var(&self) -> Option<Ref> {
|
|
match self {
|
|
&Addr::AttrVar(h) => Some(Ref::AttrVar(h)),
|
|
&Addr::HeapCell(h) => Some(Ref::HeapCell(h)),
|
|
&Addr::StackCell(fr, sc) => Some(Ref::StackCell(fr, sc)),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn is_protected(&self, e: usize) -> bool {
|
|
match self {
|
|
&Addr::StackCell(addr, _) if addr >= e => false,
|
|
_ => true,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SubAssign<usize> for Addr {
|
|
fn sub_assign(&mut self, rhs: usize) {
|
|
*self = self.clone() - rhs;
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub(crate) enum TrailRef {
|
|
Ref(Ref),
|
|
AttrVarHeapLink(usize),
|
|
AttrVarListLink(usize, usize),
|
|
BlackboardEntry(usize),
|
|
BlackboardOffset(usize, usize), // key atom heap location, key value heap location
|
|
}
|
|
|
|
impl From<Ref> for TrailRef {
|
|
fn from(r: Ref) -> Self {
|
|
TrailRef::Ref(r)
|
|
}
|
|
}
|
|
*/
|
|
#[derive(Debug, Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
|
pub enum IndexPtr {
|
|
DynamicUndefined, // a predicate, declared as dynamic, whose location in code is as yet undefined.
|
|
DynamicIndex(usize),
|
|
Index(usize),
|
|
Undefined,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
|
|
pub struct CodeIndex(pub(crate) Rc<Cell<IndexPtr>>);
|
|
|
|
impl Deref for CodeIndex {
|
|
type Target = Cell<IndexPtr>;
|
|
|
|
#[inline]
|
|
fn deref(&self) -> &Self::Target {
|
|
self.0.deref()
|
|
}
|
|
}
|
|
|
|
impl CodeIndex {
|
|
#[inline]
|
|
pub(super) fn new(ptr: IndexPtr) -> Self {
|
|
CodeIndex(Rc::new(Cell::new(ptr)))
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn is_undefined(&self) -> bool {
|
|
match self.0.get() {
|
|
IndexPtr::Undefined => true, // | &IndexPtr::DynamicUndefined => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn local(&self) -> Option<usize> {
|
|
match self.0.get() {
|
|
IndexPtr::Index(i) => Some(i),
|
|
IndexPtr::DynamicIndex(i) => Some(i),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Default for CodeIndex {
|
|
fn default() -> Self {
|
|
CodeIndex(Rc::new(Cell::new(IndexPtr::Undefined)))
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq)]
|
|
pub enum REPLCodePtr {
|
|
AddDiscontiguousPredicate,
|
|
AddDynamicPredicate,
|
|
AddMultifilePredicate,
|
|
AddGoalExpansionClause,
|
|
AddTermExpansionClause,
|
|
AddInSituFilenameModule,
|
|
ClauseToEvacuable,
|
|
ScopedClauseToEvacuable,
|
|
ConcludeLoad,
|
|
DeclareModule,
|
|
LoadCompiledLibrary,
|
|
LoadContextSource,
|
|
LoadContextFile,
|
|
LoadContextDirectory,
|
|
LoadContextModule,
|
|
LoadContextStream,
|
|
PopLoadContext,
|
|
PopLoadStatePayload,
|
|
PushLoadContext,
|
|
PushLoadStatePayload,
|
|
UseModule,
|
|
BuiltInProperty,
|
|
MetaPredicateProperty,
|
|
MultifileProperty,
|
|
DiscontiguousProperty,
|
|
DynamicProperty,
|
|
AbolishClause,
|
|
Asserta,
|
|
Assertz,
|
|
Retract,
|
|
IsConsistentWithTermQueue,
|
|
FlushTermQueue,
|
|
RemoveModuleExports,
|
|
AddNonCountedBacktracking,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
pub enum CodePtr {
|
|
BuiltInClause(BuiltInClauseType, LocalCodePtr), // local is the successor call.
|
|
CallN(usize, LocalCodePtr, bool), // arity, local, last call.
|
|
Local(LocalCodePtr),
|
|
REPL(REPLCodePtr, LocalCodePtr), // the REPL code, the return pointer.
|
|
VerifyAttrInterrupt(usize), // location of the verify attribute interrupt code in the CodeDir.
|
|
}
|
|
|
|
impl CodePtr {
|
|
pub(crate) fn local(&self) -> LocalCodePtr {
|
|
match self {
|
|
&CodePtr::BuiltInClause(_, ref local)
|
|
| &CodePtr::CallN(_, ref local, _)
|
|
| &CodePtr::Local(ref local) => local.clone(),
|
|
&CodePtr::VerifyAttrInterrupt(p) => LocalCodePtr::DirEntry(p),
|
|
&CodePtr::REPL(_, p) => p, // | &CodePtr::DynamicTransaction(_, p) => p,
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn is_halt(&self) -> bool {
|
|
if let CodePtr::Local(LocalCodePtr::Halt) = self {
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, Debug, PartialEq)]
|
|
pub enum LocalCodePtr {
|
|
DirEntry(usize), // offset
|
|
Halt,
|
|
IndexingBuf(usize, usize, usize), // DirEntry offset, first internal offset, second internal offset
|
|
// TopLevel(usize, usize), // chunk_num, offset
|
|
}
|
|
|
|
impl LocalCodePtr {
|
|
pub fn assign_if_local(&mut self, cp: CodePtr) {
|
|
match cp {
|
|
CodePtr::Local(local) => *self = local,
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn abs_loc(&self) -> usize {
|
|
match self {
|
|
LocalCodePtr::DirEntry(ref p) => *p,
|
|
LocalCodePtr::IndexingBuf(ref p, ..) => *p,
|
|
LocalCodePtr::Halt => unreachable!(),
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
_ => {}
|
|
},
|
|
None => {}
|
|
}
|
|
|
|
false
|
|
}
|
|
|
|
pub(crate) fn as_functor(&self) -> MachineStub {
|
|
match self {
|
|
LocalCodePtr::DirEntry(p) => {
|
|
functor!(atom!("dir_entry"), [fixnum(*p)])
|
|
}
|
|
LocalCodePtr::Halt => {
|
|
functor!(atom!("halt"))
|
|
}
|
|
LocalCodePtr::IndexingBuf(p, o, i) => {
|
|
functor!(
|
|
atom!("indexed_buf"),
|
|
[fixnum(*p), fixnum(*o), fixnum(*i)]
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Default for CodePtr {
|
|
#[inline]
|
|
fn default() -> Self {
|
|
CodePtr::Local(LocalCodePtr::default())
|
|
}
|
|
}
|
|
|
|
impl Default for LocalCodePtr {
|
|
#[inline]
|
|
fn default() -> Self {
|
|
LocalCodePtr::DirEntry(0)
|
|
}
|
|
}
|
|
|
|
impl Add<usize> for LocalCodePtr {
|
|
type Output = LocalCodePtr;
|
|
|
|
#[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),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Sub<usize> for LocalCodePtr {
|
|
type Output = Option<LocalCodePtr>;
|
|
|
|
#[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)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SubAssign<usize> for LocalCodePtr {
|
|
#[inline]
|
|
fn sub_assign(&mut self, rhs: usize) {
|
|
match self {
|
|
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) {
|
|
match self {
|
|
&mut LocalCodePtr::DirEntry(ref mut i)
|
|
| &mut LocalCodePtr::IndexingBuf(_, _, ref mut i) => *i += rhs,
|
|
&mut LocalCodePtr::Halt => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Add<usize> for CodePtr {
|
|
type Output = CodePtr;
|
|
|
|
fn add(self, rhs: usize) -> Self::Output {
|
|
match self {
|
|
p @ CodePtr::REPL(..) | p @ CodePtr::VerifyAttrInterrupt(_) => p,
|
|
CodePtr::Local(local) => CodePtr::Local(local + rhs),
|
|
CodePtr::BuiltInClause(_, local) | CodePtr::CallN(_, local, _) => {
|
|
CodePtr::Local(local + rhs)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl AddAssign<usize> for CodePtr {
|
|
fn add_assign(&mut self, rhs: usize) {
|
|
match self {
|
|
&mut CodePtr::VerifyAttrInterrupt(_) => {}
|
|
&mut CodePtr::Local(ref mut local) => *local += rhs,
|
|
_ => *self = CodePtr::Local(self.local() + rhs),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SubAssign<usize> for CodePtr {
|
|
#[inline]
|
|
fn sub_assign(&mut self, rhs: usize) {
|
|
match self {
|
|
CodePtr::Local(ref mut local) => *local -= rhs,
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) type HeapVarDict = IndexMap<Rc<String>, HeapCellValue>;
|
|
pub(crate) type AllocVarDict = IndexMap<Rc<String>, VarData>;
|
|
|
|
pub(crate) type GlobalVarDir = IndexMap<Atom, (Ball, Option<HeapCellValue>)>;
|
|
|
|
pub(crate) type StreamAliasDir = IndexMap<Atom, Stream>;
|
|
pub(crate) type StreamDir = BTreeSet<Stream>;
|
|
|
|
pub(crate) type MetaPredicateDir = IndexMap<PredicateKey, Vec<MetaSpec>>;
|
|
|
|
pub(crate) type ExtensiblePredicates = IndexMap<PredicateKey, PredicateSkeleton>;
|
|
|
|
pub(crate) type LocalExtensiblePredicates =
|
|
IndexMap<(CompilationTarget, PredicateKey), LocalPredicateSkeleton>;
|
|
|
|
#[derive(Debug)]
|
|
pub struct IndexStore {
|
|
pub(super) code_dir: CodeDir,
|
|
pub(super) extensible_predicates: ExtensiblePredicates,
|
|
pub(super) local_extensible_predicates: LocalExtensiblePredicates,
|
|
pub(super) global_variables: GlobalVarDir,
|
|
pub(super) meta_predicates: MetaPredicateDir,
|
|
pub(super) modules: ModuleDir,
|
|
pub(super) op_dir: OpDir,
|
|
pub(super) streams: StreamDir,
|
|
pub(super) stream_aliases: StreamAliasDir,
|
|
}
|
|
|
|
impl IndexStore {
|
|
pub(crate) fn get_predicate_skeleton_mut(
|
|
&mut self,
|
|
compilation_target: &CompilationTarget,
|
|
key: &PredicateKey,
|
|
) -> Option<&mut PredicateSkeleton> {
|
|
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
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn get_predicate_skeleton(
|
|
&self,
|
|
compilation_target: &CompilationTarget,
|
|
key: &PredicateKey,
|
|
) -> Option<&PredicateSkeleton> {
|
|
match compilation_target {
|
|
CompilationTarget::User => self.extensible_predicates.get(key),
|
|
CompilationTarget::Module(ref module_name) => {
|
|
if let Some(module) = self.modules.get(module_name) {
|
|
module.extensible_predicates.get(key)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn get_local_predicate_skeleton_mut(
|
|
&mut self,
|
|
mut src_compilation_target: CompilationTarget,
|
|
local_compilation_target: CompilationTarget,
|
|
listing_src_file_name: Option<Atom>,
|
|
key: PredicateKey,
|
|
) -> Option<&mut LocalPredicateSkeleton> {
|
|
if let Some(filename) = listing_src_file_name {
|
|
src_compilation_target = CompilationTarget::Module(filename);
|
|
}
|
|
|
|
match src_compilation_target {
|
|
CompilationTarget::User => self
|
|
.local_extensible_predicates
|
|
.get_mut(&(local_compilation_target, key)),
|
|
CompilationTarget::Module(module_name) => {
|
|
if let Some(module) = self.modules.get_mut(&module_name) {
|
|
module
|
|
.local_extensible_predicates
|
|
.get_mut(&(local_compilation_target, key))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn get_local_predicate_skeleton(
|
|
&self,
|
|
mut src_compilation_target: CompilationTarget,
|
|
local_compilation_target: CompilationTarget,
|
|
listing_src_file_name: Option<Atom>,
|
|
key: PredicateKey,
|
|
) -> Option<&LocalPredicateSkeleton> {
|
|
if let Some(filename) = listing_src_file_name {
|
|
src_compilation_target = CompilationTarget::Module(filename);
|
|
}
|
|
|
|
match src_compilation_target {
|
|
CompilationTarget::User => self
|
|
.local_extensible_predicates
|
|
.get(&(local_compilation_target, key)),
|
|
CompilationTarget::Module(module_name) => {
|
|
if let Some(module) = self.modules.get(&module_name) {
|
|
module
|
|
.local_extensible_predicates
|
|
.get(&(local_compilation_target, key))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn remove_predicate_skeleton(
|
|
&mut self,
|
|
compilation_target: &CompilationTarget,
|
|
key: &PredicateKey,
|
|
) -> Option<PredicateSkeleton> {
|
|
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)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn get_predicate_code_index(
|
|
&self,
|
|
name: Atom,
|
|
arity: usize,
|
|
module: Atom,
|
|
) -> Option<CodeIndex> {
|
|
if module == atom!("user") {
|
|
match ClauseType::from(name, arity) {
|
|
ClauseType::Named(name, arity, _) => self.code_dir.get(&(name, arity)).cloned(),
|
|
_ => None,
|
|
}
|
|
} else {
|
|
self.modules
|
|
.get(&module)
|
|
.and_then(|module| match ClauseType::from(name, arity) {
|
|
ClauseType::Named(name, arity, _) => {
|
|
module.code_dir.get(&(name, arity)).cloned()
|
|
}
|
|
_ => None,
|
|
})
|
|
}
|
|
}
|
|
|
|
pub(crate) fn get_meta_predicate_spec(
|
|
&self,
|
|
name: Atom,
|
|
arity: usize,
|
|
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)),
|
|
},
|
|
}
|
|
}
|
|
|
|
pub(crate) fn is_dynamic_predicate(
|
|
&self,
|
|
module_name: Atom,
|
|
key: PredicateKey,
|
|
) -> bool {
|
|
match module_name {
|
|
atom!("user") => self
|
|
.extensible_predicates
|
|
.get(&key)
|
|
.map(|skeleton| skeleton.core.is_dynamic)
|
|
.unwrap_or(false),
|
|
_ => match self.modules.get(&module_name) {
|
|
Some(ref module) => module
|
|
.extensible_predicates
|
|
.get(&key)
|
|
.map(|skeleton| skeleton.core.is_dynamic)
|
|
.unwrap_or(false),
|
|
None => false,
|
|
},
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub(super) fn new() -> Self {
|
|
index_store!(CodeDir::new(), default_op_dir(), ModuleDir::new())
|
|
}
|
|
|
|
pub(super) fn get_cleaner_sites(&self) -> (usize, usize) {
|
|
let r_w_h = atom!("run_cleaners_with_handling");
|
|
let r_wo_h = atom!("run_cleaners_without_handling");
|
|
let iso_ext = atom!("iso_ext");
|
|
|
|
let r_w_h = self
|
|
.get_predicate_code_index(r_w_h, 0, iso_ext)
|
|
.and_then(|item| item.local());
|
|
let r_wo_h = self
|
|
.get_predicate_code_index(r_wo_h, 1, iso_ext)
|
|
.and_then(|item| item.local());
|
|
|
|
if let Some(r_w_h) = r_w_h {
|
|
if let Some(r_wo_h) = r_wo_h {
|
|
return (r_w_h, r_wo_h);
|
|
}
|
|
}
|
|
|
|
return (0, 0);
|
|
}
|
|
}
|
|
|
|
pub(crate) type CodeDir = IndexMap<PredicateKey, CodeIndex>;
|
|
|
|
pub(crate) enum RefOrOwned<'a, T: 'a> {
|
|
Borrowed(&'a T),
|
|
Owned(T),
|
|
}
|
|
|
|
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),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a, T> RefOrOwned<'a, T> {
|
|
pub(crate) fn as_ref(&'a self) -> &'a T {
|
|
match self {
|
|
&RefOrOwned::Borrowed(r) => r,
|
|
&RefOrOwned::Owned(ref r) => r,
|
|
}
|
|
}
|
|
}
|