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

Resolve lints and format

Browse Source
This commit is contained in:
infogulch
2023-11-04 02:16:54 -05:00
parent dddffb01a6
commit 9444e62df9
58 changed files with 2521 additions and 2820 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
src/parser/ast.rs
View File

@@ -247,11 +247,7 @@ impl GenContext {
#[inline]
pub fn is_last(self) -> bool {
if let GenContext::Last(_) = self {
true
} else {
false
}
matches!(self, GenContext::Last(_))
}
}
@@ -303,24 +299,16 @@ impl OpDesc {
// name and fixity -> operator type and precedence.
pub type OpDir = IndexMap<(Atom, Fixity), OpDesc, FxBuildHasher>;
#[derive(Debug, Clone, Copy)]
#[derive(Debug, Default, Clone, Copy)]
pub struct MachineFlags {
pub double_quotes: DoubleQuotes,
pub unknown: Unknown,
}
impl Default for MachineFlags {
fn default() -> Self {
MachineFlags {
double_quotes: DoubleQuotes::default(),
unknown: Unknown::default(),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
#[derive(Debug, Default, Clone, Copy, PartialEq)]
pub enum DoubleQuotes {
Atom,
#[default]
Chars,
Codes,
}
@@ -339,12 +327,6 @@ impl DoubleQuotes {
}
}
impl Default for DoubleQuotes {
fn default() -> Self {
DoubleQuotes::Chars
}
}
#[derive(Debug, Clone, Copy)]
pub enum Unknown {
Error,
@@ -505,7 +487,7 @@ impl<'a, 'b> CompositeOpDir<'a, 'b> {
#[inline]
pub(crate) fn get(&self, name: Atom, fixity: Fixity) -> Option<OpDesc> {
let entry = if let Some(ref primary_op_dir) = &self.primary_op_dir {
let entry = if let Some(primary_op_dir) = &self.primary_op_dir {
primary_op_dir.get(&(name, fixity))
} else {
None
@@ -567,7 +549,7 @@ impl Fixnum {
const UPPER_BOUND: i64 = (1 << 55) - 1;
const LOWER_BOUND: i64 = -(1 << 55);
if LOWER_BOUND <= num && num <= UPPER_BOUND {
if (LOWER_BOUND..=UPPER_BOUND).contains(&num) {
Ok(Fixnum::new()
.with_m(false)
.with_f(false)
@@ -582,7 +564,7 @@ impl Fixnum {
pub fn get_num(self) -> i64 {
let n = self.num() as i64;
let (n, overflowed) = (n << 8).overflowing_shr(8);
debug_assert_eq!(overflowed, false);
debug_assert!(!overflowed);
n
}
}
@@ -730,11 +712,12 @@ impl Var {
#[inline(always)]
pub fn as_str(&self) -> Option<&str> {
match self {
Var::Named(value) => Some(&value),
Var::Named(value) => Some(value),
_ => None,
}
}
#[allow(clippy::inherent_to_string)]
#[inline(always)]
pub fn to_string(&self) -> String {
match self {
@@ -800,10 +783,8 @@ impl Term {
#[inline]
pub fn source_arity(terms: &[Term]) -> usize {
if let Some(last_arg) = terms.last() {
if let Term::Literal(_, Literal::CodeIndex(_)) = last_arg {
return terms.len() - 1;
}
if let Some(Term::Literal(_, Literal::CodeIndex(_))) = terms.last() {
return terms.len() - 1;
}
terms.len()
@@ -811,10 +792,8 @@ pub fn source_arity(terms: &[Term]) -> usize {
pub(crate) fn unfold_by_str_once(term: &mut Term, s: Atom) -> Option<(Term, Term)> {
if let Term::Clause(_, ref name, ref mut subterms) = term {
if let Some(last_arg) = subterms.last() {
if let Term::Literal(_, Literal::CodeIndex(_)) = last_arg {
subterms.pop();
}
if let Some(Term::Literal(_, Literal::CodeIndex(_))) = subterms.last() {
subterms.pop();
}
if name == &s && subterms.len() == 2 {

88
src/parser/char_reader.rs
View File

@@ -131,15 +131,9 @@ impl<R: Read> CharReader<R> {
pub fn peek_byte(&mut self) -> Option<io::Result<u8>> {
match self.refresh_buffer() {
Ok(_buf) => {}
Err(e) => return Some(Err(e)),
Ok(_buf) => _buf.first().cloned().map(Ok),
Err(e) => Some(Err(e)),
}
return if let Some(b) = self.buf.get(0).cloned() {
Some(Ok(b))
} else {
None
};
}
}
@@ -194,49 +188,47 @@ impl<R: Read> CharRead for CharReader<R> {
io::ErrorKind::InvalidData,
BadUtf8Error { bytes: badbytes },
)));
} else if self.pos >= self.buf.len() {
return None;
} else if self.buf.len() - self.pos >= 4 {
return match str::from_utf8(&self.buf[self.pos..e.valid_up_to()]) {
Ok(s) => {
let mut chars = s.chars();
let c = chars.next().unwrap();
Some(Ok(c))
}
Err(e) => {
let badbytes = self.buf[self.pos..e.valid_up_to()].to_vec();
Some(Err(io::Error::new(
io::ErrorKind::InvalidData,
BadUtf8Error { bytes: badbytes },
)))
}
};
} else {
if self.pos >= self.buf.len() {
return None;
} else if self.buf.len() - self.pos >= 4 {
return match str::from_utf8(&self.buf[self.pos..e.valid_up_to()]) {
Ok(s) => {
let mut chars = s.chars();
let c = chars.next().unwrap();
let buf_len = self.buf.len();
Some(Ok(c))
}
Err(e) => {
let badbytes = self.buf[self.pos..e.valid_up_to()].to_vec();
Some(Err(io::Error::new(
io::ErrorKind::InvalidData,
BadUtf8Error { bytes: badbytes },
)))
}
};
} else {
let buf_len = self.buf.len();
for (c, idx) in (self.pos..buf_len).enumerate() {
self.buf[c] = self.buf[idx];
}
self.buf.truncate(buf_len - self.pos);
let buf_len = self.buf.len();
let mut word = [0u8; 4];
let word_slice = &mut word[buf_len..4];
match self.inner.read(word_slice) {
Err(e) => return Some(Err(e)),
Ok(nread) => {
self.buf.extend_from_slice(&word_slice[0..nread]);
}
}
self.pos = 0;
for (c, idx) in (self.pos..buf_len).enumerate() {
self.buf[c] = self.buf[idx];
}
self.buf.truncate(buf_len - self.pos);
let buf_len = self.buf.len();
let mut word = [0u8; 4];
let word_slice = &mut word[buf_len..4];
match self.inner.read(word_slice) {
Err(e) => return Some(Err(e)),
Ok(nread) => {
self.buf.extend_from_slice(&word_slice[0..nread]);
}
}
self.pos = 0;
}
} else {
return None;

328
src/parser/lexer.rs
View File

@@ -48,11 +48,7 @@ pub enum Token {
impl Token {
#[inline]
pub(super) fn is_end(&self) -> bool {
if let Token::End = self {
true
} else {
false
}
matches!(self, Token::End)
}
}
@@ -604,10 +600,7 @@ impl<'a, R: CharRead> Lexer<'a, R> {
break;
}
}
} else if cut_char!(c) {
self.skip_char(c);
token.push(c);
} else if semicolon_char!(c) {
} else if cut_char!(c) || semicolon_char!(c) {
self.skip_char(c);
token.push(c);
} else if single_quote_char!(c) {
@@ -690,7 +683,8 @@ impl<'a, R: CharRead> Lexer<'a, R> {
if self.reader.peek_char().is_none() {
self.return_char('.');
i64::from_str_radix(&token, 10)
token
.parse::<i64>()
.map(|n| Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena)))
.or_else(|_| {
token
@@ -720,12 +714,12 @@ impl<'a, R: CharRead> Lexer<'a, R> {
token.push(c);
let c = match self.lookahead_char() {
Err(_) => return Ok(self.vacate_with_float(token)?),
Err(_) => return self.vacate_with_float(token),
Ok(c) => c,
};
if !sign_char!(c) && !decimal_digit_char!(c) {
return Ok(self.vacate_with_float(token)?);
return self.vacate_with_float(token);
}
if sign_char!(c) {
@@ -735,14 +729,14 @@ impl<'a, R: CharRead> Lexer<'a, R> {
let c = match self.lookahead_char() {
Err(_) => {
self.return_char(token.pop().unwrap());
return Ok(self.vacate_with_float(token)?);
return self.vacate_with_float(token);
}
Ok(c) => c,
};
if !decimal_digit_char!(c) {
self.return_char(token.pop().unwrap());
return Ok(self.vacate_with_float(token)?);
return self.vacate_with_float(token);
}
}
@@ -769,7 +763,7 @@ impl<'a, R: CharRead> Lexer<'a, R> {
self.machine_st.arena
))))
} else {
return Ok(self.vacate_with_float(token)?);
return self.vacate_with_float(token);
}
} else {
let n = parse_lossy::<f64, _>(token.as_bytes())?;
@@ -781,7 +775,147 @@ impl<'a, R: CharRead> Lexer<'a, R> {
} else {
self.return_char('.');
i64::from_str_radix(&token, 10)
token
.parse::<i64>()
.map(|n| Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena)))
.or_else(|_| {
token
.parse::<Integer>()
.map(|n| {
Token::Literal(Literal::Integer(arena_alloc!(
n,
&mut self.machine_st.arena
)))
})
.map_err(|_| ParserError::ParseBigInt(self.line_num, self.col_num))
})
}
} else if token.starts_with('0') && token.len() == 1 {
if c == 'x' {
self.hexadecimal_constant(c).or_else(|e| {
if let ParserError::ParseBigInt(..) = e {
token
.parse::<i64>()
.map(|n| {
Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
})
.or_else(|_| {
token
.parse::<Integer>()
.map(|n| {
Token::Literal(Literal::Integer(arena_alloc!(
n,
&mut self.machine_st.arena
)))
})
.map_err(|_| {
ParserError::ParseBigInt(self.line_num, self.col_num)
})
})
} else {
Err(e)
}
})
} else if c == 'o' {
self.octal_constant(c).or_else(|e| {
if let ParserError::ParseBigInt(..) = e {
token
.parse::<i64>()
.map(|n| {
Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
})
.or_else(|_| {
token
.parse::<Integer>()
.map(|n| {
Token::Literal(Literal::Integer(arena_alloc!(
n,
&mut self.machine_st.arena
)))
})
.map_err(|_| {
ParserError::ParseBigInt(self.line_num, self.col_num)
})
})
} else {
Err(e)
}
})
} else if c == 'b' {
self.binary_constant(c).or_else(|e| {
if let ParserError::ParseBigInt(..) = e {
token
.parse::<i64>()
.map(|n| {
Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
})
.or_else(|_| {
token
.parse::<Integer>()
.map(|n| {
Token::Literal(Literal::Integer(arena_alloc!(
n,
&mut self.machine_st.arena
)))
})
.map_err(|_| {
ParserError::ParseBigInt(self.line_num, self.col_num)
})
})
} else {
Err(e)
}
})
} else if single_quote_char!(c) {
self.skip_char(c);
let c = self.lookahead_char()?;
if backslash_char!(c) {
self.skip_char(c);
let c = self.lookahead_char()?;
if new_line_char!(c) {
self.skip_char(c);
self.return_char('\'');
return Ok(Token::Literal(Literal::Fixnum(Fixnum::build_with(0))));
} else {
self.return_char('\\');
}
}
self.get_single_quoted_char()
.map(|c| Token::Literal(Literal::Fixnum(Fixnum::build_with(c as i64))))
.or_else(|err| {
match err {
ParserError::UnexpectedChar('\'', ..) => {}
err => return Err(err),
}
self.return_char(c);
token
.parse::<i64>()
.map(|n| {
Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
})
.or_else(|_| {
token
.parse::<Integer>()
.map(|n| {
Token::Literal(Literal::Integer(arena_alloc!(
n,
&mut self.machine_st.arena
)))
})
.map_err(|_| {
ParserError::ParseBigInt(self.line_num, self.col_num)
})
})
})
} else {
token
.parse::<i64>()
.map(|n| Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena)))
.or_else(|_| {
token
@@ -796,155 +930,20 @@ impl<'a, R: CharRead> Lexer<'a, R> {
})
}
} else {
if token.starts_with('0') && token.len() == 1 {
if c == 'x' {
self.hexadecimal_constant(c).or_else(|e| {
if let ParserError::ParseBigInt(..) = e {
i64::from_str_radix(&token, 10)
.map(|n| {
Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
})
.or_else(|_| {
token
.parse::<Integer>()
.map(|n| {
Token::Literal(Literal::Integer(arena_alloc!(
n,
&mut self.machine_st.arena
)))
})
.map_err(|_| {
ParserError::ParseBigInt(self.line_num, self.col_num)
})
})
} else {
Err(e)
}
})
} else if c == 'o' {
self.octal_constant(c).or_else(|e| {
if let ParserError::ParseBigInt(..) = e {
i64::from_str_radix(&token, 10)
.map(|n| {
Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
})
.or_else(|_| {
token
.parse::<Integer>()
.map(|n| {
Token::Literal(Literal::Integer(arena_alloc!(
n,
&mut self.machine_st.arena
)))
})
.map_err(|_| {
ParserError::ParseBigInt(self.line_num, self.col_num)
})
})
} else {
Err(e)
}
})
} else if c == 'b' {
self.binary_constant(c).or_else(|e| {
if let ParserError::ParseBigInt(..) = e {
i64::from_str_radix(&token, 10)
.map(|n| {
Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
})
.or_else(|_| {
token
.parse::<Integer>()
.map(|n| {
Token::Literal(Literal::Integer(arena_alloc!(
n,
&mut self.machine_st.arena
)))
})
.map_err(|_| {
ParserError::ParseBigInt(self.line_num, self.col_num)
})
})
} else {
Err(e)
}
})
} else if single_quote_char!(c) {
self.skip_char(c);
let c = self.lookahead_char()?;
if backslash_char!(c) {
self.skip_char(c);
let c = self.lookahead_char()?;
if new_line_char!(c) {
self.skip_char(c);
self.return_char('\'');
return Ok(Token::Literal(Literal::Fixnum(Fixnum::build_with(0))));
} else {
self.return_char('\\');
}
}
self.get_single_quoted_char()
.map(|c| Token::Literal(Literal::Fixnum(Fixnum::build_with(c as i64))))
.or_else(|err| {
match err {
ParserError::UnexpectedChar('\'', ..) => {}
err => return Err(err),
}
self.return_char(c);
i64::from_str_radix(&token, 10)
.map(|n| {
Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena))
})
.or_else(|_| {
token
.parse::<Integer>()
.map(|n| {
Token::Literal(Literal::Integer(arena_alloc!(
n,
&mut self.machine_st.arena
)))
})
.map_err(|_| {
ParserError::ParseBigInt(self.line_num, self.col_num)
})
})
token
.parse::<i64>()
.map(|n| Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena)))
.or_else(|_| {
token
.parse::<Integer>()
.map(|n| {
Token::Literal(Literal::Integer(arena_alloc!(
n,
&mut self.machine_st.arena
)))
})
} else {
i64::from_str_radix(&token, 10)
.map(|n| Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena)))
.or_else(|_| {
token
.parse::<Integer>()
.map(|n| {
Token::Literal(Literal::Integer(arena_alloc!(
n,
&mut self.machine_st.arena
)))
})
.map_err(|_| ParserError::ParseBigInt(self.line_num, self.col_num))
})
}
} else {
i64::from_str_radix(&token, 10)
.map(|n| Token::Literal(fixnum!(Literal, n, &mut self.machine_st.arena)))
.or_else(|_| {
token
.parse::<Integer>()
.map(|n| {
Token::Literal(Literal::Integer(arena_alloc!(
n,
&mut self.machine_st.arena
)))
})
.map_err(|_| ParserError::ParseBigInt(self.line_num, self.col_num))
})
}
.map_err(|_| ParserError::ParseBigInt(self.line_num, self.col_num))
})
}
}
@@ -953,6 +952,7 @@ impl<'a, R: CharRead> Lexer<'a, R> {
c: Option<char>,
layout_info: &mut LayoutInfo,
) -> Result<(), ParserError> {
#[allow(clippy::redundant_guards)]
match c {
Some(c) if layout_char!(c) => {
self.skip_char(c);

4
src/parser/macros.rs
View File

@@ -77,7 +77,7 @@ macro_rules! cut_char {
#[macro_export]
macro_rules! decimal_digit_char {
($c: expr) => {
('0'..='9').contains(&$c)
$c.is_ascii_digit()
};
}
@@ -125,7 +125,7 @@ macro_rules! graphic_token_char {
#[macro_export]
macro_rules! hexadecimal_digit_char {
($c: expr) => {
('0'..='9').contains(&$c) || ('A'..='F').contains(&$c) || ('a'..='f').contains(&$c)
$c.is_ascii_digit() || ('A'..='F').contains(&$c) || ('a'..='f').contains(&$c)
};
}

1
src/parser/mod.rs
View File

@@ -11,4 +11,5 @@ pub mod ast;
#[macro_use]
pub mod macros;
pub mod lexer;
#[allow(clippy::module_inception)]
pub mod parser;

188
src/parser/parser.rs
View File

@@ -464,7 +464,12 @@ impl<'a, R: CharRead> Parser<'a, R> {
Token::End => TokenType::End,
};
self.stack.push(TokenDesc { tt, priority, spec, unfold_bounds: 0, });
self.stack.push(TokenDesc {
tt,
priority,
spec,
unfold_bounds: 0,
});
}
fn reduce_op(&mut self, priority: usize) {
@@ -472,10 +477,9 @@ impl<'a, R: CharRead> Parser<'a, R> {
if let Some(desc1) = self.stack.pop() {
if let Some(desc2) = self.stack.pop() {
if let Some(desc3) = self.stack.pop() {
if is_xfx!(desc2.spec) && affirm_xfx(priority, desc2, desc3, desc1) {
self.push_binary_op(desc2, LTERM);
continue;
} else if is_yfx!(desc2.spec) && affirm_yfx(priority, desc2, desc3, desc1) {
if is_xfx!(desc2.spec) && affirm_xfx(priority, desc2, desc3, desc1)
|| is_yfx!(desc2.spec) && affirm_yfx(priority, desc2, desc3, desc1)
{
self.push_binary_op(desc2, LTERM);
continue;
} else if is_xfy!(desc2.spec) && affirm_xfy(priority, desc2, desc3, desc1) {
@@ -555,10 +559,12 @@ impl<'a, R: CharRead> Parser<'a, R> {
if self.stack.len() > 2 * arity {
let idx = self.stack.len() - 2 * arity - 1;
if is_infix!(self.stack[idx].spec) && idx > 0 {
if !is_op!(self.stack[idx - 1].spec) && !self.stack[idx - 1].tt.is_sep() {
return false;
}
if is_infix!(self.stack[idx].spec)
&& idx > 0
&& !is_op!(self.stack[idx - 1].spec)
&& !self.stack[idx - 1].tt.is_sep()
{
return false;
}
} else {
return false;
@@ -571,59 +577,57 @@ impl<'a, R: CharRead> Parser<'a, R> {
let stack_len = self.stack.len() - 2 * arity - 1;
let idx = self.terms.len() - arity;
if TokenType::Term == self.stack[stack_len].tt {
if atomize_term(&self.lexer.machine_st.atom_tbl, &self.terms[idx - 1]).is_some() {
self.stack.truncate(stack_len + 1);
if TokenType::Term == self.stack[stack_len].tt
&& atomize_term(&self.lexer.machine_st.atom_tbl, &self.terms[idx - 1]).is_some()
{
self.stack.truncate(stack_len + 1);
let mut subterms: Vec<_> = self.terms.drain(idx..).collect();
let mut subterms: Vec<_> = self.terms.drain(idx..).collect();
if let Some(name) = self
.terms
.pop()
.and_then(|t| atomize_term(&self.lexer.machine_st.atom_tbl, &t))
{
// reduce the '.' functor to a cons cell if it applies.
if name == atom!(".") && subterms.len() == 2 {
let tail = subterms.pop().unwrap();
let head = subterms.pop().unwrap();
if let Some(name) = self
.terms
.pop()
.and_then(|t| atomize_term(&self.lexer.machine_st.atom_tbl, &t))
{
// reduce the '.' functor to a cons cell if it applies.
if name == atom!(".") && subterms.len() == 2 {
let tail = subterms.pop().unwrap();
let head = subterms.pop().unwrap();
self.terms.push(match as_partial_string(head, tail) {
Ok((string_buf, Some(tail))) => {
Term::PartialString(Cell::default(), string_buf, tail)
}
Ok((string_buf, None)) => {
let atom = AtomTable::build_with(
&self.lexer.machine_st.atom_tbl,
&string_buf,
);
Term::CompleteString(Cell::default(), atom)
}
Err(term) => term,
});
} else {
self.terms
.push(Term::Clause(Cell::default(), name, subterms));
}
if let Some(&mut TokenDesc {
ref mut tt,
ref mut priority,
ref mut spec,
ref mut unfold_bounds,
}) = self.stack.last_mut()
{
if *spec == BTERM {
return false;
self.terms.push(match as_partial_string(head, tail) {
Ok((string_buf, Some(tail))) => {
Term::PartialString(Cell::default(), string_buf, tail)
}
Ok((string_buf, None)) => {
let atom =
AtomTable::build_with(&self.lexer.machine_st.atom_tbl, &string_buf);
Term::CompleteString(Cell::default(), atom)
}
Err(term) => term,
});
} else {
self.terms
.push(Term::Clause(Cell::default(), name, subterms));
}
*tt = TokenType::Term;
*priority = 0;
*spec = TERM;
*unfold_bounds = 0;
if let Some(&mut TokenDesc {
ref mut tt,
ref mut priority,
ref mut spec,
ref mut unfold_bounds,
}) = self.stack.last_mut()
{
if *spec == BTERM {
return false;
}
return true;
*tt = TokenType::Term;
*priority = 0;
*spec = TERM;
*unfold_bounds = 0;
}
return true;
}
}
@@ -642,34 +646,31 @@ impl<'a, R: CharRead> Parser<'a, R> {
/* '|' is a head-tail separator here, not
* an operator, so expand the
* terms it compacted out again. */
match (term.name(), term.arity()) {
(Some(name), 2) if name == atom!(",") => {
let terms = if op_desc.unfold_bounds == 0 {
unfold_by_str(term, atom!(","))
} else {
let mut terms = vec![];
if let (Some(atom!(",")), 2) = (term.name(), term.arity()) {
let terms = if op_desc.unfold_bounds == 0 {
unfold_by_str(term, atom!(","))
} else {
let mut terms = vec![];
while let Some((fst, snd)) = unfold_by_str_once(&mut term, atom!(",")) {
terms.push(fst);
term = snd;
while let Some((fst, snd)) = unfold_by_str_once(&mut term, atom!(",")) {
terms.push(fst);
term = snd;
op_desc.unfold_bounds -= 2;
op_desc.unfold_bounds -= 2;
if op_desc.unfold_bounds == 0 {
break;
}
if op_desc.unfold_bounds == 0 {
break;
}
}
terms.push(term);
terms
};
terms.push(term);
terms
};
let arity = terms.len() - 1;
let arity = terms.len() - 1;
self.terms.extend(terms.into_iter());
return arity;
}
_ => {}
self.terms.extend(terms);
return arity;
}
}
@@ -692,18 +693,15 @@ impl<'a, R: CharRead> Parser<'a, R> {
} else {
return None;
}
} else {
if desc.tt == TokenType::HeadTailSeparator {
if arity == 1 {
continue;
}
return None;
} else if desc.tt == TokenType::OpenList {
return Some(arity);
} else if desc.tt != TokenType::Comma {
return None;
} else if desc.tt == TokenType::HeadTailSeparator {
if arity == 1 {
continue;
}
return None;
} else if desc.tt == TokenType::OpenList {
return Some(arity);
} else if desc.tt != TokenType::Comma {
return None;
}
}
@@ -882,7 +880,11 @@ impl<'a, R: CharRead> Parser<'a, R> {
.push(Term::Literal(Cell::default(), Literal::Atom(atom)));
}
self.stack[idx].spec = if self.stack[idx].priority > 0 { TERM } else { BTERM };
self.stack[idx].spec = if self.stack[idx].priority > 0 {
TERM
} else {
BTERM
};
self.stack[idx].tt = TokenType::Term;
self.stack[idx].priority = 0;
@@ -1018,13 +1020,11 @@ impl<'a, R: CharRead> Parser<'a, R> {
Token::Open => self.shift(Token::Open, 1300, DELIMITER),
Token::OpenCT => self.shift(Token::OpenCT, 1300, DELIMITER),
Token::Close => {
if !self.reduce_term() {
if !self.reduce_brackets() {
return Err(ParserError::IncompleteReduction(
self.lexer.line_num,
self.lexer.col_num,
));
}
if !self.reduce_term() && !self.reduce_brackets() {
return Err(ParserError::IncompleteReduction(
self.lexer.line_num,
self.lexer.col_num,
));
}
}
Token::OpenList => self.shift(Token::OpenList, 1300, DELIMITER),