c
}
}
- Addr::Char(_) | Addr::CharCode(_) | Addr::Con(_) | Addr::CutPoint(_) |
+ Addr::Char(_) | Addr::Con(_) | Addr::CutPoint(_) |
Addr::EmptyList | Addr::Fixnum(_) | Addr::Float(_) | Addr::Usize(_) => {
c
}
}
}
}
- (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) => {
if let Ok(n1) = Number::try_from((a1, &self.heap)) {
if let Ok(n2) = Number::try_from((a2, &self.heap)) {
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::Con(h),
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::EmptyList,
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,
match d {
Addr::Char(_) |
- Addr::CharCode(_) |
Addr::Con(_) |
Addr::EmptyList |
Addr::Fixnum(_) |
}
_ => {
match d {
- Addr::CharCode(_) => {
- self.p += 1;
- }
Addr::Char(_) if self.flags.double_quotes.is_codes() => {
self.p += 1;
}
Addr::Stream(_) => {
self.fail = true;
}
- Addr::Char(_) | Addr::CharCode(_) | Addr::Con(_) | Addr::Fixnum(_) |
+ Addr::Char(_) | Addr::Con(_) | Addr::Fixnum(_) |
Addr::Float(_) | Addr::EmptyList | Addr::Usize(_) => {
self.try_functor_unify_components(a1, 0);
}
},
_ =>
match arity {
- Addr::CharCode(c) => {
- Some(c as isize)
- }
arity => {
return Err(
self.error_form(
}
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 => {
self.unify(a1, name);
}
n: &Integer,
stub: &'static str,
arity: usize,
- ) -> Result<u32, MachineStub> {
- if let Some(c) = n.to_u32() {
+ ) -> Result<char, MachineStub>
+ {
+ let c = n.to_u32().and_then(std::char::from_u32);
+
+ if let Some(c) = c {
Ok(c)
} else {
let stub = MachineError::functor_stub(clause_name!(stub), arity);
let addr = self.heap.put_constant(Constant::Fixnum(n));
self.unify(nx, addr);
}
- Ok(Term::Constant(_, Constant::CharCode(c))) => {
- self.unify(nx, Addr::CharCode(c))
- }
_ => {
let err = ParserError::ParseBigInt(0, 0);
match self.store(self.deref(a1)) {
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 a2 = self[temp_v!(2)];
let iter = name
.as_str()
.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));
}
Addr::EmptyList => {
let chars = vec![
- Addr::CharCode('[' as u32),
- Addr::CharCode(']' as u32),
+ Addr::Fixnum('[' as isize),
+ Addr::Fixnum(']' as isize),
];
let list_of_codes = Addr::HeapCell(self.heap.to_list(chars.into_iter()));
2,
)?;
- chars.push(std::char::from_u32(c).unwrap());
+ chars.push(c);
}
}
}
Ok(Number::Integer(n)) => {
let c = self.int_to_char_code(&n, "atom_codes", 2)?;
- chars.push(std::char::from_u32(c).unwrap());
+ chars.push(c);
continue;
}
- _ => {
- }
- }
-
- match addr {
- Addr::CharCode(c) => {
- chars.push(std::char::from_u32(c).unwrap());
- }
_ => {
let stub = MachineError::functor_stub(
clause_name!("atom_codes"),
}
}
}
-
- let chars = clause_name!(chars, indices.atom_tbl);
- let chars = self.heap.to_unifiable(HeapCellValue::Atom(chars, None));
-
- self.unify(addr, chars);
}
}
}
addr if addr.is_ref() => {
addr
}
- Addr::CharCode(d) => {
- Addr::CharCode(d)
- }
addr => {
match Number::try_from((addr, &self.heap)) {
Ok(Number::Integer(n)) => {
- if let Some(c) = n.to_u32().and_then(|c| char::try_from(c).ok()) {
- Addr::CharCode(c as u32)
+ let n = n.to_u32().and_then(|n| {
+ std::char::from_u32(n).and_then(|_| Some(n))
+ });
+
+ if let Some(n) = n {
+ Addr::Fixnum(n as isize)
} else {
return Err(self.representation_error(
RepFlag::InCharacterCode,
}
}
Ok(Number::Fixnum(n)) => {
- if let Some(c) = u32::try_from(n).ok().and_then(|c| char::try_from(c).ok()) {
- Addr::CharCode(c as u32)
+ let n = u32::try_from(n).ok().and_then(|n| {
+ std::char::from_u32(n).and_then(|_| Some(n))
+ });
+
+ if let Some(n) = n {
+ Addr::Fixnum(n as isize)
} else {
return Err(self.representation_error(
RepFlag::InCharacterCode,
match result.map_err(|e| e.kind()) {
Ok(c) => {
if let Some(var) = addr.as_var() {
- self.bind(var, Addr::CharCode(c as u32));
+ self.bind(var, Addr::Fixnum(c as isize));
break;
- } else if addr == Addr::CharCode(c as u32) {
+ } else if addr == Addr::Fixnum(c as isize) {
break;
} else {
self.fail = true;
let codes = string
.trim()
.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 a2 = self[temp_v!(2)];
- self.unify(Addr::CharCode(c as u32), a2);
+ self.unify(Addr::Fixnum(c as isize), a2);
}
Addr::Char(c) => {
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() => {
let a2 = self[temp_v!(2)];
self.int_to_char_code(&Integer::from(n), "char_code", 2)?
}
_ => {
- match addr {
- Addr::CharCode(c) => {
- c
- }
- _ => {
- self.fail = true;
- return Ok(());
- }
- }
+ self.fail = true;
+ return Ok(());
}
};
- if let Some(c) = std::char::from_u32(c) {
- self.unify(Addr::Char(c), addr);
- } else {
- self.fail = true;
- }
+ self.unify(Addr::Char(c), addr);
}
_ => {
unreachable!();
return Err(self.error_form(err, stub));
}
- Addr::CharCode(c) => {
- let c = char::try_from(c).unwrap();
- write!(&mut stream, "{}", c).unwrap();
- }
addr => {
match Number::try_from((addr, &self.heap)) {
Ok(Number::Integer(n)) => {
addr if addr.is_ref() => {
addr
}
- Addr::CharCode(d) => {
- Addr::CharCode(d)
- }
addr => {
match Number::try_from((addr, &self.heap)) {
Ok(Number::Integer(n)) => {
- if let Some(c) = n.to_u32().and_then(|c| char::try_from(c).ok()) {
- Addr::CharCode(c as u32)
+ let n = n.to_u32().and_then(|n| {
+ std::char::from_u32(n).and_then(|_| Some(n))
+ });
+
+ if let Some(n) = n {
+ Addr::Fixnum(n as isize)
} else {
return Err(self.representation_error(
RepFlag::InCharacterCode,
}
}
Ok(Number::Fixnum(n)) => {
- if let Some(c) = u32::try_from(n).ok().and_then(|c| char::try_from(c).ok()) {
- Addr::CharCode(c as u32)
+ let n = u32::try_from(n).ok().and_then(|n| {
+ std::char::from_u32(n).and_then(|_| Some(n))
+ });
+
+ if let Some(n) = n {
+ Addr::Fixnum(n as isize)
} else {
return Err(self.representation_error(
RepFlag::InCharacterCode,
match result {
Some(Ok(c)) => {
if let Some(var) = addr.as_var() {
- self.bind(var, Addr::CharCode(c as u32));
+ self.bind(var, Addr::Fixnum(c as isize));
break;
- } else if addr == Addr::CharCode(c as u32) {
+ } else if addr == Addr::Fixnum(c as isize) {
break;
} else {
self.fail = true;
let addr = self.store(self.deref(self[temp_v!(1)]));
match addr {
- Addr::CharCode(c) => {
- self.fail = match std::char::from_u32(c) {
+ Addr::Fixnum(n) => {
+ let n = u32::try_from(n).ok();
+ let n = n.and_then(std::char::from_u32);
+
+ self.fail = match n {
Some(c) => {
non_quoted_token(once(c))
}
&SystemClauseType::SetSeed => {
let seed = self.store(self.deref(self[temp_v!(1)]));
- let seed = match seed {
- Addr::CharCode(c) => {
- Integer::from(c)
- }
- _ => {
- match Number::try_from((seed, &self.heap)) {
- Ok(Number::Fixnum(n)) => {
- Integer::from(n)
- }
- Ok(Number::Integer(n)) => {
- Integer::from(n.as_ref())
- }
- Ok(Number::Rational(n))
- if n.denom() == &1 => {
- n.numer().clone()
- }
- _ => {
- self.fail = true;
- return Ok(());
+ let seed =
+ match Number::try_from((seed, &self.heap)) {
+ Ok(Number::Fixnum(n)) => {
+ Integer::from(n)
+ }
+ Ok(Number::Integer(n)) => {
+ Integer::from(n.as_ref())
+ }
+ Ok(Number::Rational(n))
+ if n.denom() == &1 => {
+ n.numer().clone()
}
+ _ => {
+ self.fail = true;
+ return Ok(());
}
- }
- };
+ };
let mut rand = RANDOM_STATE.borrow_mut();
rand.seed(&seed);
projects / scryer-prolog.git / commitdiff