[package]
name = "scryer-prolog"
-version = "0.8.73"
+version = "0.8.74"
repository = "https://github.com/mthom/scryer-prolog"
description = "A modern Prolog implementation written mostly in Rust."
downcast = "0.10.0"
num = "0.2"
ordered-float = "0.5.0"
-prolog_parser = "0.8.23"
+prolog_parser = "0.8.24"
readline_rs_compat = { version = "0.1.9", optional = true }
ref_thread_local = "0.0.0"
; throw(error(type_error(atom, Atom), atom_length/2)) % 8.16.1.3 b)
).
-no_var_in_list([]).
-no_var_in_list([X|Xs]) :- var(X), !, '$fail'.
-no_var_in_list([_|Xs]) :- nonvar(Xs), no_var_in_list(Xs).
-
atom_chars(Atom, List) :-
+ '$skip_max_list'(_, -1, List, Tail),
+ ( ( Tail == [] ; var(Tail) ) -> true
+ ; throw(error(type_error(list, List), atom_chars/2))
+ ),
( var(Atom) ->
- ( var(List) -> throw(error(instantiation_error, atom_chars/2))
- ; can_be_list(List, atom_chars/3), no_var_in_list(List) -> '$atom_chars'(Atom, List)
+ ( var(Tail) -> throw(error(instantiation_error, atom_chars/2))
+ ; ground(List), Tail == [] -> '$atom_chars'(Atom, List)
; throw(error(instantiation_error, atom_chars/2))
)
- ; atom(Atom) -> '$atom_chars'(Atom, List)
+ ; atom(Atom) -> can_be_chars_or_vars(List, atom_chars/2), '$atom_chars'(Atom, List)
; throw(error(type_error(atom, Atom), atom_chars/2))
).
atom_codes(Atom, List) :-
+ '$skip_max_list'(_, -1, List, Tail),
+ ( ( Tail == [] ; var(Tail) ) -> true
+ ; throw(error(type_error(list, List), atom_codes/2))
+ ),
( var(Atom) ->
- ( var(List) -> throw(error(instantiation_error, atom_codes/2))
- ; can_be_list(List, atom_codes/3), no_var_in_list(List) -> '$atom_codes'(Atom, List)
+ ( var(Tail) -> throw(error(instantiation_error, atom_codes/2))
+ ; ground(List), Tail == [] -> '$atom_codes'(Atom, List)
; throw(error(instantiation_error, atom_codes/2))
)
- ; atom(Atom) -> '$atom_codes'(Atom, List)
+ ; atom(Atom) -> can_be_codes_or_vars(List, atom_codes/2), '$atom_codes'(Atom, List)
; throw(error(type_error(atom, Atom), atom_codes/2))
).
; throw(error(instantiation_error, PI))
).
-must_be_chars([], _).
-must_be_chars([C|Cs], PI) :-
+can_be_chars_or_vars(Cs, _) :- var(Cs), !.
+can_be_chars_or_vars(Cs, PI) :- chars_or_vars(Cs, PI).
+
+chars_or_vars([], _).
+chars_or_vars([C|Cs], PI) :-
( nonvar(C) ->
- ( atom_length(C, 1) ->
- ( nonvar(Cs) -> must_be_chars(Cs, PI)
- ; false %% throw(error(type_error(list, Cs), PI))
+ ( catch(atom_length(C, 1), _, false) ->
+ ( nonvar(Cs) -> chars_or_vars(Cs, PI)
+ ; false
)
; throw(error(type_error(character, C), PI))
)
- ; must_be_chars(Cs, PI)
+ ; chars_or_vars(Cs, PI)
+ ).
+
+can_be_codes_or_vars(Cs, _) :- var(Cs), !.
+can_be_codes_or_vars(Cs, PI) :- codes_or_vars(Cs, PI).
+
+codes_or_vars([], _).
+codes_or_vars([C|Cs], PI) :-
+ ( nonvar(C) ->
+ ( catch(char_code(_, C), _, false) ->
+ ( nonvar(Cs) -> codes_or_vars(Cs, PI)
+ ; false
+ )
+ ; integer(C) -> throw(error(representation_error(character_code), PI))
+ ; throw(error(type_error(integer, C), PI))
+ )
+ ; codes_or_vars(Cs, PI)
).
number_chars(N, Chs) :-
; must_be_number(N, number_chars/2),
( var(Chs) -> true
; can_be_list(Chs, number_chars/2)
- , must_be_chars(Chs, number_chars/2)
+ , chars_or_vars(Chs, number_chars/2)
),
'$number_to_chars'(N, Chsx),
Chsx = Chs
use prolog_parser::ast::*;
+use prolog_parser::string_list::*;
use prolog::machine::machine_indices::*;
use prolog::machine::machine_state::*;
NotList,
PartialList(usize, usize), // the list length (up to max), and an offset into the heap.
ProperList(usize), // the list length.
+ String(usize, StringList), // the number of elements iterated, the string tail.
UntouchedList(usize) // the address of an uniterated Addr::Lis(address).
}
}
impl MachineState {
+ pub(super)
+ fn try_char_list(&self, addrs: Vec<Addr>) -> Result<String, MachineError>
+ {
+ let mut chars = String::new();
+ let mut iter = addrs.iter();
+
+ while let Some(addr) = iter.next() {
+ match addr {
+ &Addr::Con(Constant::String(ref s))
+ if self.flags.double_quotes.is_chars() => {
+ chars += s.borrow().as_str();
+
+ if iter.next().is_some() {
+ return Err(MachineError::type_error(ValidType::Character, addr.clone()));
+ }
+ },
+ &Addr::Con(Constant::Char(c)) =>
+ chars.push(c),
+ &Addr::Con(Constant::Atom(ref name, _))
+ if name.as_str().len() == 1 => {
+ chars += name.as_str();
+ },
+ _ =>
+ return Err(MachineError::type_error(ValidType::Character, addr.clone()))
+ }
+ }
+
+ Ok(chars)
+ }
+
fn call_at_index(&mut self, arity: usize, p: usize)
{
self.cp.assign_if_local(self.p.clone() + 1);
}
}
-pub(super)
-fn try_char_list(addrs: Vec<Addr>) -> Result<String, MachineError>
-{
- let mut chars = String::new();
-
- for addr in addrs.iter() {
- match addr {
- &Addr::Con(Constant::Char(c)) =>
- chars.push(c),
- &Addr::Con(Constant::Atom(ref name, _))
- if name.as_str().len() == 1 => {
- chars += name.as_str();
- },
- _ =>
- return Err(MachineError::type_error(ValidType::Character, addr.clone()))
- }
- }
-
- Ok(chars)
-}
-
pub(crate) type CallResult = Result<(), Vec<HeapCellValue>>;
pub(crate) trait CallPolicy: Any {
} else {
self.fail = true;
},
+ Addr::Con(Constant::String(ref s))
+ if self.flags.double_quotes.is_chars() && !s.is_empty() => {
+ if n == 1 || n == 2 {
+ let a3 = self[temp_v!(3)].clone();
+ let h_a = if n == 1 {
+ Addr::Con(Constant::Char(s.head().unwrap()))
+ } else {
+ Addr::Con(Constant::String(s.tail()))
+ };
+
+ self.unify(a3, h_a);
+ } else {
+ self.fail = true;
+ }
+ },
_ => // 8.5.2.3 d)
return Err(self.error_form(MachineError::type_error(ValidType::Compound, term),
stub))
match a1.clone() {
Addr::DBRef(_) =>
self.fail = true,
+ Addr::Con(Constant::String(ref s))
+ if self.flags.double_quotes.is_chars() && !s.is_empty() => {
+ let shared_op_desc = fetch_op_spec(clause_name!("."), 2, None, &indices.op_dir);
+ self.try_functor_compound_case(clause_name!("."), 2, shared_op_desc)
+ },
Addr::Con(_) =>
self.try_functor_unify_components(a1, Addr::Con(integer!(0))),
Addr::Str(o) =>
match self.try_from_list(r, stub.clone()) {
Ok(addrs) =>
- Ok(StringList::new(match try_char_list(addrs) {
+ Ok(StringList::new(match self.try_char_list(addrs) {
Ok(string) => string,
Err(err) => {
return Err(self.error_form(err, stub));
result.push(self.heap[hcp].as_addr(hcp));
l = hcp + 1;
},
+ Addr::Con(Constant::String(ref s))
+ if self.flags.double_quotes.is_chars() => {
+ result.push(Addr::Con(Constant::String(s.clone())));
+ break;
+ },
Addr::Con(Constant::EmptyList) =>
break,
Addr::HeapCell(_) | Addr::StackCell(..) =>
_ =>
return Err(self.error_form(MachineError::type_error(ValidType::List, a1),
caller))
- };
+ }
}
Ok(result)
},
+ Addr::Con(Constant::String(ref s)) if self.flags.double_quotes.is_chars() =>
+ Ok(vec![Addr::Con(Constant::String(s.clone()))]),
Addr::HeapCell(_) | Addr::StackCell(..) =>
Err(self.error_form(MachineError::instantiation_error(), caller)),
Addr::Con(Constant::EmptyList) =>
use prolog_parser::ast::*;
use prolog_parser::parser::*;
+use prolog_parser::string_list::*;
use prolog_parser::tabled_rc::*;
use prolog::clause_types::*;
Some(CycleSearchResult::ProperList(brent_st.steps)),
Addr::HeapCell(_) | Addr::StackCell(..) =>
Some(CycleSearchResult::PartialList(brent_st.steps, brent_st.hare)),
+ Addr::Con(Constant::String(ref s))
+ if self.flags.double_quotes.is_chars() =>
+ Some(CycleSearchResult::String(brent_st.steps, s.clone())),
Addr::Lis(l) => {
brent_st.hare = l + 1;
brent_st.steps += 1;
Addr::Lis(offset) if max_steps > 0 => offset + 1,
Addr::Lis(offset) => return CycleSearchResult::UntouchedList(offset),
Addr::Con(Constant::EmptyList) => return CycleSearchResult::EmptyList,
+ Addr::Con(Constant::String(ref s))
+ if self.flags.double_quotes.is_chars() =>
+ return CycleSearchResult::String(0, s.clone()),
_ => return CycleSearchResult::NotList
};
let hare = match addr {
Addr::Lis(offset) => offset + 1,
Addr::Con(Constant::EmptyList) => return CycleSearchResult::EmptyList,
+ Addr::Con(Constant::String(ref s))
+ if self.flags.double_quotes.is_chars() =>
+ return CycleSearchResult::String(0, s.clone()),
_ => return CycleSearchResult::NotList
};
self.unify(xs0, xs);
},
_ => {
- let search_result = if let Some(max_steps) = max_steps.to_isize() {
- if max_steps == -1 {
- self.detect_cycles(self[temp_v!(3)].clone())
+ let (max_steps, search_result) =
+ if let Some(max_steps) = max_steps.to_isize() {
+ (max_steps, if max_steps == -1 {
+ self.detect_cycles(self[temp_v!(3)].clone())
+ } else {
+ self.detect_cycles_with_max(max_steps as usize,
+ self[temp_v!(3)].clone())
+ })
} else {
- self.detect_cycles_with_max(max_steps as usize,
- self[temp_v!(3)].clone())
- }
- } else {
- self.detect_cycles(self[temp_v!(3)].clone())
- };
+ (-1, self.detect_cycles(self[temp_v!(3)].clone()))
+ };
match search_result {
+ CycleSearchResult::String(n, s) =>
+ if max_steps == -1 {
+ self.finalize_skip_max_list(n + s.len(),
+ Addr::Con(Constant::EmptyList))
+ } else {
+ let i = max_steps.to_usize().unwrap() - n;
+
+ if s.len() < i {
+ self.finalize_skip_max_list(n + s.len(),
+ Addr::Con(Constant::EmptyList))
+ } else {
+ let s = StringList::new(s.char_span(i), s.is_expandable());
+ self.finalize_skip_max_list(i + n,
+ Addr::Con(Constant::String(s)))
+ }
+ },
CycleSearchResult::UntouchedList(l) =>
self.finalize_skip_max_list(0, Addr::Lis(l)),
CycleSearchResult::EmptyList =>
match self.try_from_list(temp_v!(2), stub.clone()) {
Err(e) => return Err(e),
Ok(addrs) =>
- match try_char_list(addrs) {
+ match self.try_char_list(addrs) {
Ok(string) => {
let chars = clause_name!(string, indices.atom_tbl);
self.unify(addr.clone(), Addr::Con(Constant::Atom(chars, None)));
&Addr::Con(Constant::CharCode(c)) =>
chars.push(c as char),
_ => {
- let err = MachineError::representation_error(RepFlag::CharacterCode);
+ let err = MachineError::type_error(ValidType::Integer, addr.clone());
return Err(self.error_form(err, stub));
}
}
match self.try_from_list(temp_v!(1), stub.clone()) {
Err(e) => return Err(e),
Ok(addrs) =>
- match try_char_list(addrs) {
+ match self.try_char_list(addrs) {
Ok(mut string) => {
if let Some(c) = string.chars().last() {
if layout_char!(c) {
let err = ParserError::UnexpectedChar(c);
-
+
let h = self.heap.h;
let err = MachineError::syntax_error(h, err);
return Err(self.error_form(err, stub));
}
}
-
+
string.push('.');
let mut stream = parsing_stream(std::io::Cursor::new(string));
self.unify(nx, Addr::Con(Constant::CharCode(c))),
_ => {
let err = ParserError::ParseBigInt;
-
+
let h = self.heap.h;
let err = MachineError::syntax_error(h, err);
projects / scryer-prolog.git / commitdiff