rishi/scryer-prolog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

eliminate Addr::CharCode (#519), fix atom_code panic (#521), fix failure involving lists of character codes (#520), bump version number

Browse Source
This commit is contained in:
Mark Thom
2020-05-17 15:19:27 -06:00
parent 9f3351469d
commit 5720b7b94c
12 changed files with 75 additions and 243 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Cargo.lock generated
View File

@@ -606,9 +606,7 @@ dependencies = [
[[package]] [[package]]
name = "prolog_parser" name = "prolog_parser"
version = "0.8.57" version = "0.8.58"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d2283b7263459418cff68af1923406bd9e4b5b9d2830df665a0fbe22e27a628d"
dependencies = [ dependencies = [
"lexical", "lexical",
"num-rug-adapter", "num-rug-adapter",
@@ -740,7 +738,7 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
[[package]] [[package]]
name = "scryer-prolog" name = "scryer-prolog"
version = "0.8.121" version = "0.8.122"
dependencies = [ dependencies = [
"cpu-time", "cpu-time",
"crossterm", "crossterm",

4
Cargo.toml
View File

@@ -1,6 +1,6 @@
[package] [package]
name = "scryer-prolog" name = "scryer-prolog"
version = "0.8.121" version = "0.8.122"
authors = ["Mark Thom <markjordanthom@gmail.com>"] authors = ["Mark Thom <markjordanthom@gmail.com>"]
build = "build.rs" build = "build.rs"
repository = "https://github.com/mthom/scryer-prolog" repository = "https://github.com/mthom/scryer-prolog"
@@ -29,7 +29,7 @@ libc = "0.2.62"
nix = "0.15.0" nix = "0.15.0"
num-rug-adapter = { optional = true, version = "0.1.3" } num-rug-adapter = { optional = true, version = "0.1.3" }
ordered-float = "0.5.0" ordered-float = "0.5.0"
prolog_parser = { version = "0.8.57", default-features = false } prolog_parser = { version = "0.8.58", default-features = false }
ref_thread_local = "0.0.0" ref_thread_local = "0.0.0"
rug = { version = "1.4.0", optional = true } rug = { version = "1.4.0", optional = true }
rustyline = "6.0.0" rustyline = "6.0.0"

6
src/prolog/arithmetic.rs
View File

@@ -722,9 +722,6 @@ impl<'a> TryFrom<(Addr, &'a Heap)> for Number {
fn try_from((addr, heap): (Addr, &'a Heap)) -> Result<Number, Self::Error> { fn try_from((addr, heap): (Addr, &'a Heap)) -> Result<Number, Self::Error> {
match addr { match addr {
Addr::CharCode(c) => {
Ok(Number::from(c as isize))
}
Addr::Fixnum(n) => { Addr::Fixnum(n) => {
Ok(Number::from(n)) Ok(Number::from(n))
} }
@@ -755,9 +752,6 @@ impl<'a> TryFrom<&'a HeapCellValue> for Number {
match value { match value {
HeapCellValue::Addr(addr) => { HeapCellValue::Addr(addr) => {
match addr { match addr {
&Addr::CharCode(c) => {
Ok(Number::from(c as isize))
}
&Addr::Fixnum(n) => { &Addr::Fixnum(n) => {
Ok(Number::from(n)) Ok(Number::from(n))
} }

16
src/prolog/forms.rs
View File

@@ -12,7 +12,6 @@ use indexmap::IndexMap;
use std::cell::Cell; use std::cell::Cell;
use std::collections::VecDeque; use std::collections::VecDeque;
use std::convert::TryFrom;
use std::path::PathBuf; use std::path::PathBuf;
use std::rc::Rc; use std::rc::Rc;
@@ -649,21 +648,6 @@ impl Into<HeapCellValue> for Number {
impl Number { impl Number {
#[inline]
pub fn to_u32(&self) -> Option<u32> {
match self {
&Number::Fixnum(n) => u32::try_from(n).ok(),
&Number::Integer(ref n) => n.to_u32(),
&Number::Float(_) => None,
&Number::Rational(ref r) =>
if r.denom() == &1 {
r.numer().to_u32()
} else {
None
}
}
}
#[inline] #[inline]
pub fn is_positive(&self) -> bool { pub fn is_positive(&self) -> bool {
match self { match self {

3
src/prolog/heap_print.rs
View File

@@ -1469,9 +1469,6 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
}); });
} }
} }
&HeapCellValue::Addr(Addr::CharCode(c)) => {
self.append_str(&format!("{}", c as u32));
}
&HeapCellValue::Addr(Addr::Char(c)) => { &HeapCellValue::Addr(Addr::Char(c)) => {
self.print_char(self.quoted, c); self.print_char(self.quoted, c);
} }

3
src/prolog/machine/arithmetic_ops.rs
View File

@@ -223,9 +223,6 @@ impl MachineState {
} }
} }
} }
&HeapCellValue::Addr(Addr::CharCode(n)) => {
interms.push(Number::Integer(Rc::new(Integer::from(n))));
}
&HeapCellValue::Addr(Addr::Fixnum(n)) => { &HeapCellValue::Addr(Addr::Fixnum(n)) => {
interms.push(Number::Fixnum(n)); interms.push(Number::Fixnum(n));
} }

3
src/prolog/machine/heap.rs
View File

@@ -216,9 +216,6 @@ impl<T: RawBlockTraits> HeapTemplate<T> {
Constant::Char(c) => { Constant::Char(c) => {
Addr::Char(c) Addr::Char(c)
} }
Constant::CharCode(c) => {
Addr::CharCode(c)
}
Constant::EmptyList => { Constant::EmptyList => {
Addr::EmptyList Addr::EmptyList
} }

8
src/prolog/machine/machine_indices.rs
View File

@@ -58,7 +58,6 @@ pub enum TermOrderCategory {
pub enum Addr { pub enum Addr {
AttrVar(usize), AttrVar(usize),
Char(char), Char(char),
CharCode(u32),
Con(usize), Con(usize),
CutPoint(usize), CutPoint(usize),
EmptyList, EmptyList,
@@ -160,7 +159,7 @@ impl Addr {
#[inline] #[inline]
pub fn is_heap_bound(&self) -> bool { pub fn is_heap_bound(&self) -> bool {
match self { match self {
Addr::Char(_) | Addr::CharCode(_) | Addr::EmptyList | Addr::Char(_) | Addr::EmptyList |
Addr::CutPoint(_) | Addr::Usize(_) | Addr::Fixnum(_) | Addr::CutPoint(_) | Addr::Usize(_) | Addr::Fixnum(_) |
Addr::Float(_) => { Addr::Float(_) => {
false false
@@ -226,7 +225,7 @@ impl Addr {
Addr::Char(_) | Addr::EmptyList => { Addr::Char(_) | Addr::EmptyList => {
Some(TermOrderCategory::Atom) Some(TermOrderCategory::Atom)
} }
Addr::CharCode(_) | Addr::Fixnum(_) | Addr::Usize(_) => { Addr::Fixnum(_) | Addr::Usize(_) => {
Some(TermOrderCategory::Integer) Some(TermOrderCategory::Integer)
} }
Addr::Lis(_) | Addr::PStrLocation(..) | Addr::Str(_) => { Addr::Lis(_) | Addr::PStrLocation(..) | Addr::Str(_) => {
@@ -245,9 +244,6 @@ impl Addr {
&Addr::Char(c) => { &Addr::Char(c) => {
Some(Constant::Char(c)) Some(Constant::Char(c))
} }
&Addr::CharCode(c) => {
Some(Constant::CharCode(c))
}
&Addr::Con(h) => { &Addr::Con(h) => {
match &machine_st.heap[h] { match &machine_st.heap[h] {
&HeapCellValue::Atom(ref name, _) if name.is_char() => { &HeapCellValue::Atom(ref name, _) if name.is_char() => {

112
src/prolog/machine/machine_state_impl.rs
View File

@@ -1411,7 +1411,7 @@ impl MachineState {
c c
} }
} }
Addr::Char(_) | Addr::CharCode(_) | Addr::Con(_) | Addr::CutPoint(_) | Addr::Char(_) | Addr::Con(_) | Addr::CutPoint(_) |
Addr::EmptyList | Addr::Fixnum(_) | Addr::Float(_) | Addr::Usize(_) => { Addr::EmptyList | Addr::Fixnum(_) | Addr::Float(_) | Addr::Usize(_) => {
c c
} }
@@ -1956,17 +1956,6 @@ impl MachineState {
} }
} }
} }
(Addr::CharCode(n1), v2) | (v2, Addr::CharCode(n1)) => {
if let Ok(n2) = Number::try_from((v2, &self.heap)) {
if let Some(n2) = n2.to_u32() {
if n1 == n2 {
continue;
}
}
}
return true;
}
(a1, a2) => { (a1, a2) => {
if let Ok(n1) = Number::try_from((a1, &self.heap)) { if let Ok(n1) = Number::try_from((a1, &self.heap)) {
if let Ok(n2) = Number::try_from((a2, &self.heap)) { if let Ok(n2) = Number::try_from((a2, &self.heap)) {
@@ -2136,42 +2125,6 @@ impl MachineState {
unreachable!() unreachable!()
} }
} }
(
Addr::Con(h),
Addr::CharCode(c),
) => {
let c = std::char::from_u32(c).unwrap();
if let HeapCellValue::Atom(ref n1, _) = &self.heap[h] {
if n1.is_char() {
if n1.as_str().chars().next() != Some(c) {
return Some(n1.as_str().chars().next().cmp(&Some(c)));
}
} else {
return Some(Ordering::Greater);
}
} else {
unreachable!()
}
}
(
Addr::CharCode(c),
Addr::Con(h),
) => {
let c = std::char::from_u32(c).unwrap();
if let HeapCellValue::Atom(ref n1, _) = &self.heap[h] {
if n1.is_char() {
if n1.as_str().chars().next() != Some(c) {
return Some(Some(c).cmp(&n1.as_str().chars().next()));
}
} else {
return Some(Ordering::Less);
}
} else {
unreachable!()
}
}
( (
Addr::EmptyList, Addr::EmptyList,
Addr::Con(h), Addr::Con(h),
@@ -2204,34 +2157,6 @@ impl MachineState {
return Some(c1.cmp(&c2)); return Some(c1.cmp(&c2));
} }
} }
(
Addr::CharCode(c1),
Addr::CharCode(c2),
) => {
if c1 != c2 {
return Some(c1.cmp(&c2));
}
}
(
Addr::Char(c1),
Addr::CharCode(c2),
) => {
let c2 = std::char::from_u32(c2).unwrap();
if c1 != c2 {
return Some(c1.cmp(&c2));
}
}
(
Addr::CharCode(c1),
Addr::Char(c2),
) => {
let c1 = std::char::from_u32(c1).unwrap();
if c1 != c2 {
return Some(c1.cmp(&c2));
}
}
( (
Addr::Char(c), Addr::Char(c),
Addr::EmptyList, Addr::EmptyList,
@@ -2252,30 +2177,6 @@ impl MachineState {
Some('['.cmp(&c)) Some('['.cmp(&c))
}; };
} }
(
Addr::CharCode(c),
Addr::EmptyList,
) => {
let c = std::char::from_u32(c).unwrap();
return if c == '[' {
Some(Ordering::Less)
} else {
Some(c.cmp(&'['))
};
}
(
Addr::EmptyList,
Addr::CharCode(c),
) => {
let c = std::char::from_u32(c).unwrap();
return if c == '[' {
Some(Ordering::Greater)
} else {
Some('['.cmp(&c))
};
}
( (
Addr::EmptyList, Addr::EmptyList,
Addr::EmptyList, Addr::EmptyList,
@@ -2443,7 +2344,6 @@ impl MachineState {
match d { match d {
Addr::Char(_) | Addr::Char(_) |
Addr::CharCode(_) |
Addr::Con(_) | Addr::Con(_) |
Addr::EmptyList | Addr::EmptyList |
Addr::Fixnum(_) | Addr::Fixnum(_) |
@@ -2471,9 +2371,6 @@ impl MachineState {
} }
_ => { _ => {
match d { match d {
Addr::CharCode(_) => {
self.p += 1;
}
Addr::Char(_) if self.flags.double_quotes.is_codes() => { Addr::Char(_) if self.flags.double_quotes.is_codes() => {
self.p += 1; self.p += 1;
} }
@@ -2601,7 +2498,7 @@ impl MachineState {
Addr::Stream(_) => { Addr::Stream(_) => {
self.fail = true; self.fail = true;
} }
Addr::Char(_) | Addr::CharCode(_) | Addr::Con(_) | Addr::Fixnum(_) | Addr::Char(_) | Addr::Con(_) | Addr::Fixnum(_) |
Addr::Float(_) | Addr::EmptyList | Addr::Usize(_) => { Addr::Float(_) | Addr::EmptyList | Addr::Usize(_) => {
self.try_functor_unify_components(a1, 0); self.try_functor_unify_components(a1, 0);
} }
@@ -2637,9 +2534,6 @@ impl MachineState {
}, },
_ => _ =>
match arity { match arity {
Addr::CharCode(c) => {
Some(c as isize)
}
arity => { arity => {
return Err( return Err(
self.error_form( self.error_form(
@@ -2681,7 +2575,7 @@ impl MachineState {
} }
match name { match name {
Addr::Char(_) | Addr::CharCode(_) | Addr::Con(_) | Addr::Fixnum(_) | Addr::Float(_) | Addr::Char(_) | Addr::Con(_) | Addr::Fixnum(_) | Addr::Float(_) |
Addr::EmptyList | Addr::PStrLocation(..) | Addr::Usize(_) if arity == 0 => { Addr::EmptyList | Addr::PStrLocation(..) | Addr::Usize(_) if arity == 0 => {
self.unify(a1, name); self.unify(a1, name);
} }

117
src/prolog/machine/system_calls.rs
View File

@@ -508,8 +508,11 @@ impl MachineState {
n: &Integer, n: &Integer,
stub: &'static str, stub: &'static str,
arity: usize, arity: usize,
) -> Result<u32, MachineStub> { ) -> Result<char, MachineStub>
if let Some(c) = n.to_u32() { {
let c = n.to_u32().and_then(std::char::from_u32);
if let Some(c) = c {
Ok(c) Ok(c)
} else { } else {
let stub = MachineError::functor_stub(clause_name!(stub), arity); let stub = MachineError::functor_stub(clause_name!(stub), arity);
@@ -592,9 +595,6 @@ impl MachineState {
let addr = self.heap.put_constant(Constant::Fixnum(n)); let addr = self.heap.put_constant(Constant::Fixnum(n));
self.unify(nx, addr); self.unify(nx, addr);
} }
Ok(Term::Constant(_, Constant::CharCode(c))) => {
self.unify(nx, Addr::CharCode(c))
}
_ => { _ => {
let err = ParserError::ParseBigInt(0, 0); let err = ParserError::ParseBigInt(0, 0);
@@ -909,7 +909,7 @@ impl MachineState {
match self.store(self.deref(a1)) { match self.store(self.deref(a1)) {
Addr::Char(c) => { Addr::Char(c) => {
let iter = once(Addr::CharCode(c as u32)); let iter = once(Addr::Fixnum(c as isize));
let list_of_codes = Addr::HeapCell(self.heap.to_list(iter)); let list_of_codes = Addr::HeapCell(self.heap.to_list(iter));
let a2 = self[temp_v!(2)]; let a2 = self[temp_v!(2)];
@@ -938,7 +938,7 @@ impl MachineState {
let iter = name let iter = name
.as_str() .as_str()
.chars() .chars()
.map(|c| Addr::CharCode(c as u32)); .map(|c| Addr::Fixnum(c as isize));
let list_of_codes = Addr::HeapCell(self.heap.to_list(iter)); let list_of_codes = Addr::HeapCell(self.heap.to_list(iter));
@@ -951,8 +951,8 @@ impl MachineState {
} }
Addr::EmptyList => { Addr::EmptyList => {
let chars = vec![ let chars = vec![
Addr::CharCode('[' as u32), Addr::Fixnum('[' as isize),
Addr::CharCode(']' as u32), Addr::Fixnum(']' as isize),
]; ];
let list_of_codes = Addr::HeapCell(self.heap.to_list(chars.into_iter())); let list_of_codes = Addr::HeapCell(self.heap.to_list(chars.into_iter()));
@@ -984,7 +984,7 @@ impl MachineState {
2, 2,
)?; )?;
chars.push(std::char::from_u32(c).unwrap()); chars.push(c);
} }
} }
@@ -992,18 +992,10 @@ impl MachineState {
} }
Ok(Number::Integer(n)) => { Ok(Number::Integer(n)) => {
let c = self.int_to_char_code(&n, "atom_codes", 2)?; let c = self.int_to_char_code(&n, "atom_codes", 2)?;
chars.push(std::char::from_u32(c).unwrap()); chars.push(c);
continue; continue;
} }
_ => {
}
}
match addr {
Addr::CharCode(c) => {
chars.push(std::char::from_u32(c).unwrap());
}
_ => { _ => {
let stub = MachineError::functor_stub( let stub = MachineError::functor_stub(
clause_name!("atom_codes"), clause_name!("atom_codes"),
@@ -1020,11 +1012,6 @@ impl MachineState {
} }
} }
} }
let chars = clause_name!(chars, indices.atom_tbl);
let chars = self.heap.to_unifiable(HeapCellValue::Atom(chars, None));
self.unify(addr, chars);
} }
} }
} }
@@ -1429,14 +1416,15 @@ impl MachineState {
addr if addr.is_ref() => { addr if addr.is_ref() => {
addr addr
} }
Addr::CharCode(d) => {
Addr::CharCode(d)
}
addr => { addr => {
match Number::try_from((addr, &self.heap)) { match Number::try_from((addr, &self.heap)) {
Ok(Number::Integer(n)) => { Ok(Number::Integer(n)) => {
if let Some(c) = n.to_u32().and_then(|c| char::try_from(c).ok()) { let n = n.to_u32().and_then(|n| {
Addr::CharCode(c as u32) std::char::from_u32(n).and_then(|_| Some(n))
});
if let Some(n) = n {
Addr::Fixnum(n as isize)
} else { } else {
return Err(self.representation_error( return Err(self.representation_error(
RepFlag::InCharacterCode, RepFlag::InCharacterCode,
@@ -1446,8 +1434,12 @@ impl MachineState {
} }
} }
Ok(Number::Fixnum(n)) => { Ok(Number::Fixnum(n)) => {
if let Some(c) = u32::try_from(n).ok().and_then(|c| char::try_from(c).ok()) { let n = u32::try_from(n).ok().and_then(|n| {
Addr::CharCode(c as u32) std::char::from_u32(n).and_then(|_| Some(n))
});
if let Some(n) = n {
Addr::Fixnum(n as isize)
} else { } else {
return Err(self.representation_error( return Err(self.representation_error(
RepFlag::InCharacterCode, RepFlag::InCharacterCode,
@@ -1474,9 +1466,9 @@ impl MachineState {
match result.map_err(|e| e.kind()) { match result.map_err(|e| e.kind()) {
Ok(c) => { Ok(c) => {
if let Some(var) = addr.as_var() { if let Some(var) = addr.as_var() {
self.bind(var, Addr::CharCode(c as u32)); self.bind(var, Addr::Fixnum(c as isize));
break; break;
} else if addr == Addr::CharCode(c as u32) { } else if addr == Addr::Fixnum(c as isize) {
break; break;
} else { } else {
self.fail = true; self.fail = true;
@@ -1561,7 +1553,7 @@ impl MachineState {
let codes = string let codes = string
.trim() .trim()
.chars() .chars()
.map(|c| Addr::CharCode(c as u32)); .map(|c| Addr::Fixnum(c as isize));
let codes_list = Addr::HeapCell(self.heap.to_list(codes)); let codes_list = Addr::HeapCell(self.heap.to_list(codes));
@@ -1630,11 +1622,11 @@ impl MachineState {
}; };
let a2 = self[temp_v!(2)]; let a2 = self[temp_v!(2)];
self.unify(Addr::CharCode(c as u32), a2); self.unify(Addr::Fixnum(c as isize), a2);
} }
Addr::Char(c) => { Addr::Char(c) => {
let a2 = self[temp_v!(2)]; let a2 = self[temp_v!(2)];
self.unify(Addr::CharCode(c as u32), a2); self.unify(Addr::Fixnum(c as isize), a2);
} }
addr if addr.is_ref() => { addr if addr.is_ref() => {
let a2 = self[temp_v!(2)]; let a2 = self[temp_v!(2)];
@@ -1647,24 +1639,13 @@ impl MachineState {
Ok(Number::Fixnum(n)) => { Ok(Number::Fixnum(n)) => {
self.int_to_char_code(&Integer::from(n), "char_code", 2)? self.int_to_char_code(&Integer::from(n), "char_code", 2)?
} }
_ => {
match addr {
Addr::CharCode(c) => {
c
}
_ => { _ => {
self.fail = true; self.fail = true;
return Ok(()); return Ok(());
} }
}
}
}; };
if let Some(c) = std::char::from_u32(c) {
self.unify(Addr::Char(c), addr); self.unify(Addr::Char(c), addr);
} else {
self.fail = true;
}
} }
_ => { _ => {
unreachable!(); unreachable!();
@@ -1953,10 +1934,6 @@ impl MachineState {
return Err(self.error_form(err, stub)); return Err(self.error_form(err, stub));
} }
Addr::CharCode(c) => {
let c = char::try_from(c).unwrap();
write!(&mut stream, "{}", c).unwrap();
}
addr => { addr => {
match Number::try_from((addr, &self.heap)) { match Number::try_from((addr, &self.heap)) {
Ok(Number::Integer(n)) => { Ok(Number::Integer(n)) => {
@@ -2389,14 +2366,15 @@ impl MachineState {
addr if addr.is_ref() => { addr if addr.is_ref() => {
addr addr
} }
Addr::CharCode(d) => {
Addr::CharCode(d)
}
addr => { addr => {
match Number::try_from((addr, &self.heap)) { match Number::try_from((addr, &self.heap)) {
Ok(Number::Integer(n)) => { Ok(Number::Integer(n)) => {
if let Some(c) = n.to_u32().and_then(|c| char::try_from(c).ok()) { let n = n.to_u32().and_then(|n| {
Addr::CharCode(c as u32) std::char::from_u32(n).and_then(|_| Some(n))
});
if let Some(n) = n {
Addr::Fixnum(n as isize)
} else { } else {
return Err(self.representation_error( return Err(self.representation_error(
RepFlag::InCharacterCode, RepFlag::InCharacterCode,
@@ -2406,8 +2384,12 @@ impl MachineState {
} }
} }
Ok(Number::Fixnum(n)) => { Ok(Number::Fixnum(n)) => {
if let Some(c) = u32::try_from(n).ok().and_then(|c| char::try_from(c).ok()) { let n = u32::try_from(n).ok().and_then(|n| {
Addr::CharCode(c as u32) std::char::from_u32(n).and_then(|_| Some(n))
});
if let Some(n) = n {
Addr::Fixnum(n as isize)
} else { } else {
return Err(self.representation_error( return Err(self.representation_error(
RepFlag::InCharacterCode, RepFlag::InCharacterCode,
@@ -2440,9 +2422,9 @@ impl MachineState {
match result { match result {
Some(Ok(c)) => { Some(Ok(c)) => {
if let Some(var) = addr.as_var() { if let Some(var) = addr.as_var() {
self.bind(var, Addr::CharCode(c as u32)); self.bind(var, Addr::Fixnum(c as isize));
break; break;
} else if addr == Addr::CharCode(c as u32) { } else if addr == Addr::Fixnum(c as isize) {
break; break;
} else { } else {
self.fail = true; self.fail = true;
@@ -4258,8 +4240,11 @@ impl MachineState {
let addr = self.store(self.deref(self[temp_v!(1)])); let addr = self.store(self.deref(self[temp_v!(1)]));
match addr { match addr {
Addr::CharCode(c) => { Addr::Fixnum(n) => {
self.fail = match std::char::from_u32(c) { let n = u32::try_from(n).ok();
let n = n.and_then(std::char::from_u32);
self.fail = match n {
Some(c) => { Some(c) => {
non_quoted_token(once(c)) non_quoted_token(once(c))
} }
@@ -4373,11 +4358,7 @@ impl MachineState {
&SystemClauseType::SetSeed => { &SystemClauseType::SetSeed => {
let seed = self.store(self.deref(self[temp_v!(1)])); let seed = self.store(self.deref(self[temp_v!(1)]));
let seed = match seed { let seed =
Addr::CharCode(c) => {
Integer::from(c)
}
_ => {
match Number::try_from((seed, &self.heap)) { match Number::try_from((seed, &self.heap)) {
Ok(Number::Fixnum(n)) => { Ok(Number::Fixnum(n)) => {
Integer::from(n) Integer::from(n)
@@ -4393,8 +4374,6 @@ impl MachineState {
self.fail = true; self.fail = true;
return Ok(()); return Ok(());
} }
}
}
}; };
let mut rand = RANDOM_STATE.borrow_mut(); let mut rand = RANDOM_STATE.borrow_mut();

3
src/prolog/macros.rs
View File

@@ -150,9 +150,6 @@ macro_rules! from_constant {
&Constant::Char(c) => { &Constant::Char(c) => {
HeapCellValue::Addr(Addr::Char(c)) HeapCellValue::Addr(Addr::Char(c))
} }
&Constant::CharCode(c) => {
HeapCellValue::Addr(Addr::CharCode(c))
}
&Constant::Fixnum(n) => { &Constant::Fixnum(n) => {
HeapCellValue::Addr(Addr::Fixnum(n)) HeapCellValue::Addr(Addr::Fixnum(n))
} }

1
src/prolog/write.rs
View File

@@ -203,7 +203,6 @@ impl fmt::Display for Addr {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
&Addr::Char(c) => write!(f, "Addr::Char({})", c), &Addr::Char(c) => write!(f, "Addr::Char({})", c),
&Addr::CharCode(c) => write!(f, "Addr::CharCode({})", c),
&Addr::EmptyList => write!(f, "Addr::EmptyList"), &Addr::EmptyList => write!(f, "Addr::EmptyList"),
&Addr::Fixnum(n) => write!(f, "Addr::Fixnum({})", n), &Addr::Fixnum(n) => write!(f, "Addr::Fixnum({})", n),
&Addr::Float(fl) => write!(f, "Addr::Float({})", fl), &Addr::Float(fl) => write!(f, "Addr::Float({})", fl),