799 lines
29 KiB
Rust
799 lines
29 KiB
Rust
//! A macro to construct functor terms ready to be written to the WAM
|
|
//! heap.
|
|
|
|
use crate::atom_table::*;
|
|
use crate::instructions::IndexingCodePtr;
|
|
use crate::machine::heap::Heap;
|
|
use crate::parser::ast::Fixnum;
|
|
use crate::types::*;
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub(crate) enum FunctorElement {
|
|
AbsoluteCell(HeapCellValue),
|
|
Cell(HeapCellValue),
|
|
InnerFunctor(u64, Vec<FunctorElement>),
|
|
String(u64, String),
|
|
}
|
|
|
|
// helper macros
|
|
macro_rules! count {
|
|
() => (0);
|
|
( $x:tt $($xs:tt)* ) => (1 + count!($($xs)*));
|
|
}
|
|
|
|
// core macros
|
|
|
|
/*
|
|
* functor! is more declarative now, with fewer effects and more
|
|
* work done at compile time using const functions. With these
|
|
* advantages come new quirks: expressions must generally be wrapped
|
|
* in round parentheses for rustc to parse them. See the tests module
|
|
* below for examples, especially those involving atom!
|
|
* subexpressions.
|
|
*/
|
|
|
|
macro_rules! functor {
|
|
($name:expr) => ({
|
|
vec![FunctorElement::Cell(atom_as_cell!($name))]
|
|
});
|
|
($name:expr, [$($dt:ident($($value:tt),*)),+]) => ({
|
|
build_functor!([$($dt($($value),*)),*],
|
|
[FunctorElement::Cell(atom_as_cell!($name, count!($($dt) *)))],
|
|
1,
|
|
[])
|
|
});
|
|
}
|
|
|
|
macro_rules! inner_functor {
|
|
($name:expr, $res_len:expr, [$($dt:ident($($value:tt),*)),+]) => ({
|
|
build_functor!([$($dt($($value),*)),*],
|
|
[FunctorElement::Cell(atom_as_cell!($name, count!($($dt) *)))],
|
|
1 + $res_len,
|
|
[])
|
|
});
|
|
}
|
|
|
|
macro_rules! build_functor {
|
|
([], [$($res:expr),*], $res_len:expr, [$($subfunctor:expr),*]) => ({
|
|
vec![$($res,)* $($subfunctor),*]
|
|
});
|
|
([indexing_code_ptr($e:expr) $(, $dt:ident($($value:tt),*))*],
|
|
[$($res:expr),*],
|
|
$res_len:expr,
|
|
[$($subfunctor:expr),*]) => ({
|
|
let (inner_functor, cell_size) = indexing_code_ptr($e);
|
|
let referent = if cell_size == 1 {
|
|
heap_loc_as_cell!(1u64 + count!($($dt)*) + $res_len)
|
|
} else {
|
|
str_loc_as_cell!(1u64 + count!($($dt)*) + $res_len)
|
|
};
|
|
|
|
build_functor!([$($dt($($value),*)),*],
|
|
[$($res, )* FunctorElement::Cell(referent)],
|
|
1 + cell_size + $res_len,
|
|
[$($subfunctor, )* FunctorElement::InnerFunctor(cell_size, inner_functor)])
|
|
});
|
|
([fixnum($e:expr) $(, $dt:ident($($value:tt),*))*],
|
|
[$($res:expr),*],
|
|
$res_len:expr,
|
|
[$($subfunctor:expr),*]) => ({
|
|
build_functor!([$($dt($($value),*)),*],
|
|
[$($res, )* FunctorElement::Cell(fixnum_as_cell!(/*FIXME this is not safe*/ unsafe{Fixnum::build_with_unchecked($e as i64)}))],
|
|
1 + $res_len,
|
|
[$($subfunctor),*])
|
|
});
|
|
([cell($e:expr) $(, $dt:ident($($value:tt),*))*],
|
|
[$($res:expr),*],
|
|
$res_len:expr,
|
|
[$($subfunctor:expr),*]) => ({
|
|
build_functor!([$($dt($($value),*)),*],
|
|
[$($res, )* FunctorElement::AbsoluteCell($e)],
|
|
1 + $res_len,
|
|
[$($subfunctor),*])
|
|
});
|
|
([literal($e:expr) $(, $dt:ident($($value:tt),*))*],
|
|
[$($res:expr),*],
|
|
$res_len:expr,
|
|
[$($subfunctor:expr),*]) => ({
|
|
build_functor!([$($dt($($value),*)),*],
|
|
[$($res, )* FunctorElement::AbsoluteCell(HeapCellValue::from($e))],
|
|
1 + $res_len,
|
|
[$($subfunctor),*])
|
|
});
|
|
([number($n:expr, $arena:expr) $(, $dt:ident($($value:tt),*))*],
|
|
[$($res:expr),*],
|
|
$res_len:expr,
|
|
[$($subfunctor:expr),*]) => ({
|
|
let number_cell = HeapCellValue::arena_from($n, $arena);
|
|
|
|
build_functor!([$($dt($($value),*)),*],
|
|
[$($res, )* FunctorElement::Cell(number_cell)],
|
|
1 + $res_len,
|
|
[$($subfunctor),*])
|
|
});
|
|
([list([]) $(, $dt:ident($($value:tt),*))*],
|
|
[$($res:expr),*],
|
|
$res_len:expr,
|
|
[$($subfunctor:expr),*]) => ({
|
|
build_functor!([$($dt($($value),*)),*],
|
|
[$($res, )* FunctorElement::Cell(empty_list_as_cell!())],
|
|
1 + $res_len,
|
|
[$($subfunctor),*])
|
|
});
|
|
([list([$id:ident($($id_value:tt),*) $(, $in_dt:ident($($in_value:tt),*))*]) $(, $dt:ident($($value:tt),*))*],
|
|
[$($res:expr),*],
|
|
$res_len:expr,
|
|
[$($subfunctor:expr),*]) => ({
|
|
build_functor!([functor((atom!(".")), [$id($($id_value),*), list([$($in_dt($($in_value),*)),*])])
|
|
$(, $dt($($value),*))*],
|
|
[$($res),*],
|
|
$res_len,
|
|
[$($subfunctor),*])
|
|
});
|
|
([string($s:expr) $(, $dt:ident($($value:tt),*))*], [$($res:expr),*], $res_len:expr, [$($subfunctor:expr),*]) => ({
|
|
#[allow(unused_parens)]
|
|
let string = $s;
|
|
let pstr_len = cell_index!(Heap::compute_pstr_size(&string)) as u64;
|
|
let result_len = 1 + count!($($dt)*) + $res_len;
|
|
|
|
build_functor!([$($dt($($value),*)),*],
|
|
[$($res, )* FunctorElement::Cell(pstr_loc_as_cell!(heap_index!(result_len as usize) as u64))],
|
|
1 + $res_len + pstr_len,
|
|
[$($subfunctor, )* FunctorElement::String(pstr_len, string)])
|
|
});
|
|
([atom_as_cell($n:expr) $(, $dt:ident($($value:tt),*))*], [$($res:expr),*], $res_len:expr, [$($subfunctor:expr),*]) => ({
|
|
build_functor!([$($dt($($value),*)),*],
|
|
[$($res, )* FunctorElement::Cell(atom_as_cell!($n))],
|
|
1 + $res_len,
|
|
[$($subfunctor),*])
|
|
});
|
|
([functor($stub:expr) $(, $dt:ident($($value:tt),*))*], [$($res:expr),*], $res_len:expr, [$($subfunctor:expr),*]) => ({
|
|
let result_len = 1u64 + count!($($dt)*) + $res_len;
|
|
let inner_functor_size = cell_index!(Heap::compute_functor_byte_size(&$stub)) as u64;
|
|
|
|
build_functor!([$($dt($($value),*)),*],
|
|
[$($res, )* FunctorElement::Cell(str_loc_as_cell!(result_len))],
|
|
1 + $res_len + inner_functor_size,
|
|
[$($subfunctor, )*
|
|
FunctorElement::InnerFunctor(inner_functor_size, $stub)])
|
|
});
|
|
([$id:ident($n:expr) $(, $dt:ident($($value:tt),*))*], [$($res:expr),*], $res_len:expr, [$($subfunctor:expr),*]) => ({
|
|
build_functor!([$($dt($($value),*)),*],
|
|
[$($res, )* FunctorElement::Cell($id!($n))],
|
|
1 + $res_len,
|
|
[$($subfunctor),*])
|
|
});
|
|
([functor($name:expr, [$($in_dt:ident($($in_value:tt),*)),+]) $(, $dt:ident($($value:tt),*))*],
|
|
[$($res:expr),*],
|
|
$res_len:expr,
|
|
[$($subfunctor:expr),*]) => ({
|
|
let result_len = 1u64 + count!($($dt)*) + $res_len;
|
|
let inner_functor = inner_functor!($name, 0, [$($in_dt($($in_value),*)),*]);
|
|
let inner_functor_size = cell_index!(Heap::compute_functor_byte_size(&inner_functor)) as u64;
|
|
|
|
build_functor!([$($dt($($value),*)),*],
|
|
[$($res, )* FunctorElement::Cell(str_loc_as_cell!(result_len))],
|
|
1 + $res_len + inner_functor_size,
|
|
[$($subfunctor, )*
|
|
FunctorElement::InnerFunctor(inner_functor_size, inner_functor)])
|
|
});
|
|
}
|
|
|
|
pub(crate) fn indexing_code_ptr(code_ptr: IndexingCodePtr) -> (Vec<FunctorElement>, u64) {
|
|
match code_ptr {
|
|
IndexingCodePtr::DynamicExternal(o) => {
|
|
(functor!(atom!("dynamic_external"), [fixnum(o)]), 2)
|
|
}
|
|
IndexingCodePtr::External(o) => (functor!(atom!("external"), [fixnum(o)]), 2),
|
|
IndexingCodePtr::Internal(o) => (functor!(atom!("internal"), [fixnum(o)]), 2),
|
|
IndexingCodePtr::Fail => (vec![FunctorElement::Cell(atom_as_cell!(atom!("fail")))], 1),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn variadic_functor(
|
|
name: Atom,
|
|
arity: usize,
|
|
iter: impl Iterator<Item = Vec<FunctorElement>>,
|
|
) -> Vec<FunctorElement> {
|
|
let mut arg_vec = vec![
|
|
FunctorElement::Cell(atom_as_cell!(name, arity)),
|
|
FunctorElement::Cell(list_loc_as_cell!(2)),
|
|
];
|
|
|
|
let key_value_pairs: Vec<_> = iter.collect();
|
|
let num_items = key_value_pairs.len();
|
|
let mut functor_offset = 0;
|
|
|
|
for (idx, kv_func) in key_value_pairs.iter().enumerate() {
|
|
let functor_size = cell_index!(Heap::compute_functor_byte_size(kv_func));
|
|
|
|
arg_vec.push(FunctorElement::Cell(str_loc_as_cell!(
|
|
2 + num_items * 2 + functor_offset
|
|
)));
|
|
arg_vec.push(FunctorElement::Cell(list_loc_as_cell!(4 + 2 * idx)));
|
|
|
|
functor_offset += functor_size;
|
|
}
|
|
|
|
arg_vec.pop();
|
|
arg_vec.push(FunctorElement::Cell(empty_list_as_cell!()));
|
|
|
|
arg_vec.extend(key_value_pairs.into_iter().map(|kv_func| {
|
|
let inner_functor_size = cell_index!(Heap::compute_functor_byte_size(&kv_func));
|
|
FunctorElement::InnerFunctor(inner_functor_size as u64, kv_func)
|
|
}));
|
|
|
|
arg_vec
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[allow(unused_parens)]
|
|
mod tests {
|
|
use super::*;
|
|
use indexmap::indexmap;
|
|
use std::string::String;
|
|
use FunctorElement::*;
|
|
|
|
#[test]
|
|
fn basic_terms() {
|
|
let functor = functor!(
|
|
atom!("first"),
|
|
[atom_as_cell((atom!("a"))), char_as_cell('c')]
|
|
);
|
|
|
|
assert_eq!(functor.len(), 3);
|
|
|
|
assert_eq!(functor[0], Cell(atom_as_cell!(atom!("first"), 2)));
|
|
assert_eq!(functor[1], Cell(atom_as_cell!(atom!("a"))));
|
|
assert_eq!(functor[2], Cell(char_as_cell!('c')));
|
|
|
|
let functor = functor!(
|
|
atom!("second"),
|
|
[
|
|
atom_as_cell((atom!("a"))),
|
|
functor((atom!("b")), [fixnum(1), fixnum(2)]),
|
|
char_as_cell('c')
|
|
]
|
|
);
|
|
|
|
assert_eq!(functor.len(), 5);
|
|
|
|
assert_eq!(functor[0], Cell(atom_as_cell!(atom!("second"), 3)));
|
|
assert_eq!(functor[1], Cell(atom_as_cell!(atom!("a"))));
|
|
assert_eq!(functor[2], Cell(str_loc_as_cell!(4)));
|
|
assert_eq!(functor[3], Cell(char_as_cell!('c')));
|
|
assert_eq!(
|
|
functor[4],
|
|
InnerFunctor(3, functor!(atom!("b"), [fixnum(1), fixnum(2)]))
|
|
);
|
|
|
|
let functor = functor!(
|
|
atom!("third"),
|
|
[
|
|
atom_as_cell((atom!("a"))),
|
|
functor((atom!("b")), [fixnum(1), fixnum(2)]),
|
|
functor((atom!("c")), [fixnum(1), fixnum(2)]),
|
|
char_as_cell('c')
|
|
]
|
|
);
|
|
|
|
assert_eq!(functor.len(), 7);
|
|
|
|
assert_eq!(functor[0], Cell(atom_as_cell!(atom!("third"), 4)));
|
|
assert_eq!(functor[1], Cell(atom_as_cell!(atom!("a"))));
|
|
assert_eq!(functor[2], Cell(str_loc_as_cell!(5)));
|
|
assert_eq!(functor[3], Cell(str_loc_as_cell!(8)));
|
|
assert_eq!(functor[4], Cell(char_as_cell!('c')));
|
|
assert_eq!(
|
|
functor[5],
|
|
InnerFunctor(3, functor!(atom!("b"), [fixnum(1), fixnum(2)]))
|
|
);
|
|
assert_eq!(
|
|
functor[6],
|
|
InnerFunctor(3, functor!(atom!("c"), [fixnum(1), fixnum(2)]))
|
|
);
|
|
|
|
let functor = functor!(
|
|
atom!("fourth"),
|
|
[
|
|
atom_as_cell((atom!("a"))),
|
|
functor((atom!("b")), [fixnum(1), fixnum(2)]),
|
|
functor((atom!("c")), [fixnum(1)]),
|
|
functor((atom!("d")), [fixnum(453), fixnum(2)]),
|
|
char_as_cell('c')
|
|
]
|
|
);
|
|
|
|
assert_eq!(functor.len(), 9);
|
|
|
|
assert_eq!(functor[0], Cell(atom_as_cell!(atom!("fourth"), 5)));
|
|
assert_eq!(functor[1], Cell(atom_as_cell!(atom!("a"))));
|
|
assert_eq!(functor[2], Cell(str_loc_as_cell!(6)));
|
|
assert_eq!(functor[3], Cell(str_loc_as_cell!(9)));
|
|
assert_eq!(functor[4], Cell(str_loc_as_cell!(11)));
|
|
assert_eq!(functor[5], Cell(char_as_cell!('c')));
|
|
assert_eq!(
|
|
functor[6],
|
|
InnerFunctor(3, functor!(atom!("b"), [fixnum(1), fixnum(2)]))
|
|
);
|
|
assert_eq!(
|
|
functor[7],
|
|
InnerFunctor(2, functor!(atom!("c"), [fixnum(1)]))
|
|
);
|
|
assert_eq!(
|
|
functor[8],
|
|
InnerFunctor(3, functor!(atom!("d"), [fixnum(453), fixnum(2)]))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn basic_terms_in_heap() {
|
|
let functor = functor!(
|
|
atom!("first"),
|
|
[atom_as_cell((atom!("a"))), char_as_cell('b')]
|
|
);
|
|
|
|
assert_eq!(functor.len(), 3);
|
|
|
|
let mut heap = Heap::new();
|
|
let mut functor_writer = Heap::functor_writer(functor);
|
|
let loc = functor_writer(&mut heap).unwrap();
|
|
|
|
assert_eq!(loc, str_loc_as_cell!(0));
|
|
|
|
assert_eq!(heap[0], atom_as_cell!(atom!("first"), 2));
|
|
assert_eq!(heap[1], atom_as_cell!(atom!("a")));
|
|
assert_eq!(heap[2], char_as_cell!('b'));
|
|
|
|
heap.truncate(2);
|
|
|
|
let functor = functor!(
|
|
atom!("second"),
|
|
[
|
|
atom_as_cell((atom!("a"))),
|
|
functor((atom!("b")), [fixnum(1), fixnum(2)]),
|
|
functor((atom!("c")), [fixnum(1), fixnum(2)]),
|
|
char_as_cell('b')
|
|
]
|
|
);
|
|
|
|
assert_eq!(functor.len(), 7);
|
|
|
|
let mut functor_writer = Heap::functor_writer(functor);
|
|
let loc = functor_writer(&mut heap).unwrap();
|
|
|
|
assert_eq!(loc, str_loc_as_cell!(2));
|
|
|
|
assert_eq!(heap[2], atom_as_cell!(atom!("second"), 4));
|
|
assert_eq!(heap[3], atom_as_cell!(atom!("a")));
|
|
assert_eq!(heap[4], str_loc_as_cell!(7));
|
|
assert_eq!(heap[5], str_loc_as_cell!(10));
|
|
assert_eq!(heap[6], char_as_cell!('b'));
|
|
assert_eq!(heap[7], atom_as_cell!(atom!("b"), 2));
|
|
assert_eq!(heap[8], fixnum_as_cell!(Fixnum::build_with(1)));
|
|
assert_eq!(heap[9], fixnum_as_cell!(Fixnum::build_with(2)));
|
|
assert_eq!(heap[10], atom_as_cell!(atom!("c"), 2));
|
|
assert_eq!(heap[11], fixnum_as_cell!(Fixnum::build_with(1)));
|
|
assert_eq!(heap[12], fixnum_as_cell!(Fixnum::build_with(2)));
|
|
}
|
|
|
|
#[test]
|
|
fn nested_functors() {
|
|
let functor = functor!(
|
|
atom!("first"),
|
|
[
|
|
atom_as_cell((atom!("a"))),
|
|
functor(
|
|
(atom!("d")),
|
|
[
|
|
fixnum(1),
|
|
functor(
|
|
(atom!("b")),
|
|
[atom_as_cell((atom!("c"))), char_as_cell('c')]
|
|
)
|
|
]
|
|
),
|
|
functor((atom!("e")), [fixnum(453), fixnum(2)]),
|
|
char_as_cell('b')
|
|
]
|
|
);
|
|
|
|
assert_eq!(functor.len(), 7);
|
|
|
|
assert_eq!(functor[0], Cell(atom_as_cell!(atom!("first"), 4)));
|
|
assert_eq!(functor[1], Cell(atom_as_cell!(atom!("a"))));
|
|
assert_eq!(functor[2], Cell(str_loc_as_cell!(5)));
|
|
assert_eq!(functor[3], Cell(str_loc_as_cell!(11)));
|
|
assert_eq!(functor[4], Cell(char_as_cell!('b')));
|
|
assert_eq!(
|
|
functor[5],
|
|
InnerFunctor(
|
|
6,
|
|
vec![
|
|
Cell(atom_as_cell!(atom!("d"), 2)),
|
|
Cell(fixnum_as_cell!(Fixnum::build_with(1))),
|
|
Cell(str_loc_as_cell!(3)),
|
|
InnerFunctor(
|
|
3,
|
|
functor!(atom!("b"), [atom_as_cell((atom!("c"))), char_as_cell('c')])
|
|
)
|
|
]
|
|
)
|
|
);
|
|
assert_eq!(
|
|
functor[6],
|
|
InnerFunctor(3, functor!(atom!("e"), [fixnum(453), fixnum(2)]))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn nested_functors_in_heap() {
|
|
let functor = functor!(
|
|
atom!("first"),
|
|
[
|
|
atom_as_cell((atom!("a"))),
|
|
functor(
|
|
(atom!("second")),
|
|
[
|
|
fixnum(1),
|
|
functor(
|
|
(atom!("third")),
|
|
[atom_as_cell((atom!("b"))), char_as_cell('c')]
|
|
)
|
|
]
|
|
),
|
|
functor((atom!("fourth")), [fixnum(453), fixnum(2)]),
|
|
char_as_cell('b')
|
|
]
|
|
);
|
|
|
|
let mut heap = Heap::new();
|
|
let mut functor_writer = Heap::functor_writer(functor);
|
|
let loc = functor_writer(&mut heap).unwrap();
|
|
|
|
assert_eq!(loc, str_loc_as_cell!(0));
|
|
|
|
assert_eq!(heap.cell_len(), 14);
|
|
|
|
assert_eq!(heap[0], atom_as_cell!(atom!("first"), 4));
|
|
assert_eq!(heap[1], atom_as_cell!(atom!("a")));
|
|
assert_eq!(heap[2], str_loc_as_cell!(5));
|
|
assert_eq!(heap[3], str_loc_as_cell!(11));
|
|
assert_eq!(heap[4], char_as_cell!('b'));
|
|
assert_eq!(heap[5], atom_as_cell!(atom!("second"), 2));
|
|
assert_eq!(heap[6], fixnum_as_cell!(Fixnum::build_with(1)));
|
|
assert_eq!(heap[7], str_loc_as_cell!(8));
|
|
assert_eq!(heap[8], atom_as_cell!(atom!("third"), 2));
|
|
assert_eq!(heap[9], atom_as_cell!(atom!("b")));
|
|
assert_eq!(heap[10], char_as_cell!('c'));
|
|
assert_eq!(heap[11], atom_as_cell!(atom!("fourth"), 2));
|
|
assert_eq!(heap[12], fixnum_as_cell!(Fixnum::build_with(453)));
|
|
assert_eq!(heap[13], fixnum_as_cell!(Fixnum::build_with(2)));
|
|
}
|
|
|
|
#[test]
|
|
fn functors_with_strings_in_heap() {
|
|
let functor = functor!(atom!("first"), [string((String::from("a string")))]);
|
|
|
|
assert_eq!(functor.len(), 3);
|
|
|
|
let mut heap = Heap::new();
|
|
let mut functor_writer = Heap::functor_writer(functor);
|
|
let loc = functor_writer(&mut heap).unwrap();
|
|
|
|
assert_eq!(loc, str_loc_as_cell!(0));
|
|
assert_eq!(heap.cell_len(), 5);
|
|
|
|
assert_eq!(heap[0], atom_as_cell!(atom!("first"), 1));
|
|
assert_eq!(heap[1], pstr_loc_as_cell!(heap_index!(2)));
|
|
assert_eq!(
|
|
heap.slice_to_str(heap_index!(2), "a string".len()),
|
|
"a string"
|
|
);
|
|
assert_eq!(heap[4], empty_list_as_cell!());
|
|
|
|
heap.truncate(0);
|
|
|
|
let functor = functor!(
|
|
atom!("second"),
|
|
[string((String::from("a stuttered\0 string")))]
|
|
);
|
|
|
|
let mut functor_writer = Heap::functor_writer(functor);
|
|
functor_writer(&mut heap).unwrap();
|
|
|
|
assert_eq!(heap.cell_len(), 10);
|
|
|
|
assert_eq!(heap[0], atom_as_cell!(atom!("second"), 1));
|
|
assert_eq!(heap[1], pstr_loc_as_cell!(heap_index!(2)));
|
|
assert_eq!(
|
|
heap.slice_to_str(heap_index!(2), "a stuttered".len()),
|
|
"a stuttered"
|
|
);
|
|
assert_eq!(heap[4], list_loc_as_cell!(5));
|
|
assert_eq!(heap[5], char_as_cell!('\u{0}'));
|
|
assert_eq!(heap[6], pstr_loc_as_cell!(heap_index!(7)));
|
|
assert_eq!(
|
|
heap.slice_to_str(heap_index!(7), " string".len()),
|
|
" string"
|
|
);
|
|
assert_eq!(heap[9], empty_list_as_cell!());
|
|
}
|
|
|
|
#[test]
|
|
fn functors_with_lists_in_heap() {
|
|
let functor = functor!(
|
|
atom!("first"),
|
|
[list([fixnum(1), atom_as_cell((atom!("a"))), fixnum(2)])]
|
|
);
|
|
|
|
assert_eq!(functor.len(), 3);
|
|
|
|
let mut heap = Heap::new();
|
|
let mut functor_writer = Heap::functor_writer(functor);
|
|
|
|
functor_writer(&mut heap).unwrap();
|
|
|
|
assert_eq!(heap.cell_len(), 11);
|
|
|
|
assert_eq!(heap[0], atom_as_cell!(atom!("first"), 1));
|
|
assert_eq!(heap[1], str_loc_as_cell!(2));
|
|
assert_eq!(heap[2], atom_as_cell!(atom!("."), 2));
|
|
assert_eq!(heap[3], fixnum_as_cell!(Fixnum::build_with(1)));
|
|
assert_eq!(heap[4], str_loc_as_cell!(5));
|
|
assert_eq!(heap[5], atom_as_cell!(atom!("."), 2));
|
|
assert_eq!(heap[6], atom_as_cell!(atom!("a")));
|
|
assert_eq!(heap[7], str_loc_as_cell!(8));
|
|
assert_eq!(heap[8], atom_as_cell!(atom!("."), 2));
|
|
assert_eq!(heap[9], fixnum_as_cell!(Fixnum::build_with(2)));
|
|
assert_eq!(heap[10], empty_list_as_cell!());
|
|
}
|
|
|
|
#[test]
|
|
fn inlined_atoms() {
|
|
let atom_table = AtomTable::new();
|
|
let inlined = AtomTable::build_with(&atom_table, "inline");
|
|
|
|
assert!(inlined.is_inlined());
|
|
assert_eq!(&*inlined.as_str(), "inline");
|
|
|
|
let non_inlined = AtomTable::build_with(&atom_table, "longer non-inlined atom");
|
|
|
|
assert!(!non_inlined.is_inlined());
|
|
assert_eq!(&*non_inlined.as_str(), "longer non-inlined atom");
|
|
}
|
|
|
|
#[test]
|
|
fn functors_with_indexing_code_ptr() {
|
|
let code_ptr = IndexingCodePtr::Internal(0);
|
|
let functor = functor!(
|
|
atom!("first"),
|
|
[
|
|
string((String::from("a string"))),
|
|
indexing_code_ptr(code_ptr)
|
|
]
|
|
);
|
|
|
|
let mut heap = Heap::new();
|
|
let mut functor_writer = Heap::functor_writer(functor);
|
|
|
|
functor_writer(&mut heap).unwrap();
|
|
|
|
assert_eq!(heap.cell_len(), 8);
|
|
|
|
assert_eq!(heap[0], atom_as_cell!(atom!("first"), 2));
|
|
assert_eq!(heap[1], pstr_loc_as_cell!(heap_index!(3)));
|
|
assert_eq!(heap[2], str_loc_as_cell!(6));
|
|
assert_eq!(
|
|
heap.slice_to_str(heap_index!(3), "a string".len()),
|
|
"a string"
|
|
);
|
|
assert_eq!(heap[5], empty_list_as_cell!());
|
|
assert_eq!(heap[6], atom_as_cell!(atom!("internal"), 1));
|
|
assert_eq!(heap[7], fixnum_as_cell!(Fixnum::build_with(0)));
|
|
|
|
heap.truncate(0);
|
|
|
|
let functor = functor!(
|
|
atom!("second"),
|
|
[
|
|
string((String::from("a string"))),
|
|
functor(
|
|
(atom!("third")),
|
|
[
|
|
atom_as_cell((atom!("a"))),
|
|
string((String::from("another string"))),
|
|
indexing_code_ptr(code_ptr)
|
|
]
|
|
)
|
|
]
|
|
);
|
|
|
|
let mut functor_writer = Heap::functor_writer(functor);
|
|
functor_writer(&mut heap).unwrap();
|
|
|
|
assert_eq!(heap.cell_len(), 15);
|
|
|
|
assert_eq!(heap[0], atom_as_cell!(atom!("second"), 2));
|
|
assert_eq!(heap[1], pstr_loc_as_cell!(heap_index!(3)));
|
|
assert_eq!(heap[2], str_loc_as_cell!(6));
|
|
assert_eq!(
|
|
heap.slice_to_str(heap_index!(3), "a string".len()),
|
|
"a string"
|
|
);
|
|
assert_eq!(heap[5], empty_list_as_cell!());
|
|
assert_eq!(heap[6], atom_as_cell!(atom!("third"), 3));
|
|
assert_eq!(heap[7], atom_as_cell!(atom!("a")));
|
|
assert_eq!(heap[8], pstr_loc_as_cell!(heap_index!(10)));
|
|
assert_eq!(heap[9], str_loc_as_cell!(13));
|
|
assert_eq!(
|
|
heap.slice_to_str(heap_index!(10), "another string".len()),
|
|
"another string"
|
|
);
|
|
assert_eq!(heap[12], empty_list_as_cell!());
|
|
assert_eq!(heap[13], atom_as_cell!(atom!("internal"), 1));
|
|
assert_eq!(heap[14], fixnum_as_cell!(Fixnum::build_with(0)));
|
|
|
|
let functor = functor!(
|
|
atom!("fourth"),
|
|
[
|
|
string((String::from("a string"))),
|
|
functor(
|
|
(atom!("a")),
|
|
[
|
|
functor(
|
|
(atom!("fifth")),
|
|
[
|
|
fixnum(5),
|
|
string((String::from("another string"))),
|
|
indexing_code_ptr(code_ptr)
|
|
]
|
|
),
|
|
string((String::from("and another")))
|
|
]
|
|
)
|
|
]
|
|
);
|
|
|
|
heap.truncate(0);
|
|
|
|
let mut functor_writer = Heap::functor_writer(functor);
|
|
functor_writer(&mut heap).unwrap();
|
|
|
|
assert_eq!(heap.cell_len(), 21);
|
|
|
|
assert_eq!(heap[0], atom_as_cell!(atom!("fourth"), 2));
|
|
assert_eq!(heap[1], pstr_loc_as_cell!(heap_index!(3)));
|
|
assert_eq!(heap[2], str_loc_as_cell!(6));
|
|
assert_eq!(
|
|
heap.slice_to_str(heap_index!(3), "a string".len()),
|
|
"a string"
|
|
);
|
|
assert_eq!(heap[5], empty_list_as_cell!());
|
|
assert_eq!(heap[6], atom_as_cell!(atom!("a"), 2));
|
|
assert_eq!(heap[7], str_loc_as_cell!(9));
|
|
assert_eq!(heap[8], pstr_loc_as_cell!(heap_index!(18))); // <-- wrong!
|
|
assert_eq!(heap[9], atom_as_cell!(atom!("fifth"), 3));
|
|
assert_eq!(heap[10], fixnum_as_cell!(Fixnum::build_with(5)));
|
|
assert_eq!(heap[11], pstr_loc_as_cell!(heap_index!(13)));
|
|
assert_eq!(heap[12], str_loc_as_cell!(16));
|
|
assert_eq!(
|
|
heap.slice_to_str(heap_index!(13), "another string".len()),
|
|
"another string"
|
|
);
|
|
assert_eq!(heap[15], empty_list_as_cell!());
|
|
assert_eq!(heap[16], atom_as_cell!(atom!("internal"), 1));
|
|
assert_eq!(heap[17], fixnum_as_cell!(Fixnum::build_with(0)));
|
|
assert_eq!(
|
|
heap.slice_to_str(heap_index!(18), "and another".len()),
|
|
"and another"
|
|
);
|
|
assert_eq!(heap[20], empty_list_as_cell!());
|
|
|
|
let constants = indexmap![
|
|
atom_as_cell!(atom!("a")) => IndexingCodePtr::External(2),
|
|
atom_as_cell!(atom!("d")) => IndexingCodePtr::External(7),
|
|
];
|
|
|
|
let functor = variadic_functor(
|
|
atom!("switch_on_constants"),
|
|
1,
|
|
constants
|
|
.iter()
|
|
.map(|(c, ptr)| functor!(atom!(":"), [cell((*c)), indexing_code_ptr((*ptr))])),
|
|
);
|
|
|
|
heap.truncate(0);
|
|
|
|
let mut functor_writer = Heap::functor_writer(functor);
|
|
functor_writer(&mut heap).unwrap();
|
|
|
|
assert_eq!(heap[0], atom_as_cell!(atom!("switch_on_constants"), 1));
|
|
assert_eq!(heap[1], list_loc_as_cell!(2));
|
|
assert_eq!(heap[2], str_loc_as_cell!(6));
|
|
assert_eq!(heap[3], list_loc_as_cell!(4));
|
|
assert_eq!(heap[4], str_loc_as_cell!(11));
|
|
assert_eq!(heap[5], empty_list_as_cell!());
|
|
assert_eq!(heap[6], atom_as_cell!(atom!(":"), 2));
|
|
assert_eq!(heap[7], atom_as_cell!(atom!("a")));
|
|
assert_eq!(heap[8], str_loc_as_cell!(9));
|
|
assert_eq!(heap[9], atom_as_cell!(atom!("external"), 1));
|
|
assert_eq!(heap[10], fixnum_as_cell!(Fixnum::build_with(2)));
|
|
assert_eq!(heap[11], atom_as_cell!(atom!(":"), 2));
|
|
assert_eq!(heap[12], atom_as_cell!(atom!("d")));
|
|
assert_eq!(heap[13], str_loc_as_cell!(14));
|
|
assert_eq!(heap[14], atom_as_cell!(atom!("external"), 1));
|
|
assert_eq!(heap[15], fixnum_as_cell!(Fixnum::build_with(7)));
|
|
}
|
|
|
|
#[test]
|
|
fn undefined_procedure_functor() {
|
|
// existence_error
|
|
let culprit = functor!(atom!("/"), [atom_as_cell((atom!("a"))), fixnum(1)]);
|
|
|
|
let stub = functor!(
|
|
atom!("existence_error"),
|
|
[
|
|
atom_as_cell((atom!("procedure"))),
|
|
functor((culprit.clone()))
|
|
]
|
|
);
|
|
|
|
println!("{stub:?}");
|
|
|
|
// now the error form
|
|
let lineless_error_form = functor!(atom!("error"), [functor(stub), functor(culprit)]);
|
|
|
|
println!("{lineless_error_form:?}");
|
|
|
|
let mut heap = Heap::new();
|
|
let mut functor_writer = Heap::functor_writer(lineless_error_form);
|
|
|
|
functor_writer(&mut heap).unwrap();
|
|
|
|
assert_eq!(heap[0], atom_as_cell!(atom!("error"), 2));
|
|
assert_eq!(heap[1], str_loc_as_cell!(3));
|
|
assert_eq!(heap[2], str_loc_as_cell!(9));
|
|
assert_eq!(heap[3], atom_as_cell!(atom!("existence_error"), 2));
|
|
assert_eq!(heap[4], atom_as_cell!(atom!("procedure")));
|
|
assert_eq!(heap[5], str_loc_as_cell!(6)); // is str_loc_as_cell!(3)
|
|
assert_eq!(heap[6], atom_as_cell!(atom!("/"), 2));
|
|
assert_eq!(heap[7], atom_as_cell!(atom!("a")));
|
|
assert_eq!(heap[8], fixnum_as_cell!(Fixnum::build_with(1)));
|
|
assert_eq!(heap[9], atom_as_cell!(atom!("/"), 2));
|
|
assert_eq!(heap[10], atom_as_cell!(atom!("a")));
|
|
assert_eq!(heap[11], fixnum_as_cell!(Fixnum::build_with(1)));
|
|
}
|
|
|
|
#[test]
|
|
fn argless_functor() {
|
|
let name = functor!(atom!("[]"));
|
|
|
|
assert_eq!(name.len(), 1);
|
|
|
|
let mut heap = Heap::new();
|
|
let mut functor_writer = Heap::functor_writer(name);
|
|
let loc = functor_writer(&mut heap).unwrap();
|
|
|
|
assert_eq!(loc, heap_loc_as_cell!(0));
|
|
}
|
|
|
|
#[test]
|
|
fn predefined_subfunctors() {
|
|
let stub = functor!(atom!("sub"), [atom_as_cell((atom!("[]")))]);
|
|
let name = functor!(atom!("super"), [functor(stub)]);
|
|
|
|
let mut heap = Heap::new();
|
|
let mut functor_writer = Heap::functor_writer(name);
|
|
|
|
functor_writer(&mut heap).unwrap();
|
|
|
|
assert_eq!(heap.cell_len(), 4);
|
|
|
|
assert_eq!(heap[0], atom_as_cell!(atom!("super"), 1));
|
|
assert_eq!(heap[1], str_loc_as_cell!(2));
|
|
assert_eq!(heap[2], atom_as_cell!(atom!("sub"), 1));
|
|
assert_eq!(heap[3], empty_list_as_cell!());
|
|
}
|
|
}
|