scryer-prolog 0.8.34

A modern Prolog implementation written mostly in Rust.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use prolog_parser::ast::*;

use prolog::fixtures::*;
use prolog::forms::*;
use prolog::machine::machine_indices::*;
use prolog::targets::*;

use std::cell::Cell;
use std::rc::Rc;

pub trait Allocator<'a>
{
    fn new() -> Self;

    fn mark_anon_var<Target>(&mut self, Level, GenContext, &mut Vec<Target>)
        where Target: CompilationTarget<'a>;
    fn mark_non_var<Target>(&mut self, Level, GenContext, &'a Cell<RegType>, &mut Vec<Target>)
        where Target: CompilationTarget<'a>;
    fn mark_reserved_var<Target>(&mut self, 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>)
        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 advance_arg(&mut self);

    fn bindings(&self) -> &AllocVarDict;
    fn bindings_mut(&mut self) -> &mut AllocVarDict;

    fn take_bindings(self) -> AllocVarDict;

    fn drain_var_data(&mut self, vs: VariableFixtures<'a>) -> VariableFixtures<'a>
    {
        let mut perm_vs = VariableFixtures::new();

        for (var, (var_status, cells)) in vs.into_iter() {
            match var_status {
                VarStatus::Temp(chunk_num, tvd) => {
                    self.bindings_mut().insert(var.clone(), VarData::Temp(chunk_num, 0, tvd));
                },
                VarStatus::Perm(_) => {
                    self.bindings_mut().insert(var.clone(), VarData::Perm(0));
                    perm_vs.insert(var, (var_status, cells));
                }
            };
        }

        perm_vs
    }

    fn get(&self, var: Rc<Var>) -> RegType {
        self.bindings().get(&var).map_or(temp_v!(0), |v| v.as_reg_type())
    }

    fn is_unbound(&self, var: Rc<Var>) -> bool {
        self.get(var).reg_num() == 0
    }

    fn record_register(&mut self, var: Rc<Var>, r: RegType) {
        match self.bindings_mut().get_mut(&var).unwrap() {
            &mut VarData::Temp(_, ref mut s, _) => *s = r.reg_num(),
            &mut VarData::Perm(ref mut s) => *s = r.reg_num()
        }
    }
}