1013 lines
32 KiB
Rust
1013 lines
32 KiB
Rust
use crate::ast::*;
|
|
use crate::lexer::*;
|
|
use crate::tabled_rc::*;
|
|
|
|
use ordered_float::OrderedFloat;
|
|
|
|
use crate::rug::ops::NegAssign;
|
|
|
|
use std::cell::Cell;
|
|
use std::io::Read;
|
|
use std::mem::swap;
|
|
use std::rc::Rc;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
enum TokenType {
|
|
Term,
|
|
Open,
|
|
OpenCT,
|
|
OpenList, // '['
|
|
OpenCurly, // '{'
|
|
HeadTailSeparator, // '|'
|
|
Comma, // ','
|
|
Close,
|
|
CloseList, // ']'
|
|
CloseCurly, // '}'
|
|
End,
|
|
}
|
|
|
|
impl TokenType {
|
|
fn is_sep(self) -> bool {
|
|
matches!(
|
|
self,
|
|
TokenType::HeadTailSeparator
|
|
| TokenType::OpenCT
|
|
| TokenType::Open
|
|
| TokenType::Close
|
|
| TokenType::OpenList
|
|
| TokenType::CloseList
|
|
| TokenType::OpenCurly
|
|
| TokenType::CloseCurly
|
|
| TokenType::Comma
|
|
)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
struct TokenDesc {
|
|
tt: TokenType,
|
|
priority: usize,
|
|
spec: u32,
|
|
}
|
|
|
|
pub fn get_clause_spec(
|
|
name: ClauseName,
|
|
arity: usize,
|
|
op_dir: &CompositeOpDir,
|
|
) -> Option<SharedOpDesc> {
|
|
match arity {
|
|
1 => {
|
|
/* This is a clause with an operator principal functor. Prefix operators
|
|
are supposed over post.
|
|
*/
|
|
if let Some(OpDirValue(cell)) = op_dir.get(name.clone(), Fixity::Pre) {
|
|
return Some(cell.clone());
|
|
}
|
|
|
|
if let Some(OpDirValue(cell)) = op_dir.get(name, Fixity::Post) {
|
|
return Some(cell.clone());
|
|
}
|
|
}
|
|
2 => {
|
|
if let Some(OpDirValue(cell)) = op_dir.get(name, Fixity::In) {
|
|
return Some(cell.clone());
|
|
}
|
|
}
|
|
_ => {}
|
|
};
|
|
|
|
None
|
|
}
|
|
|
|
pub fn get_op_desc(name: ClauseName, op_dir: &CompositeOpDir) -> Option<OpDesc> {
|
|
let mut op_desc = OpDesc {
|
|
pre: 0,
|
|
inf: 0,
|
|
post: 0,
|
|
spec: 0,
|
|
};
|
|
|
|
if let Some(OpDirValue(cell)) = op_dir.get(name.clone(), Fixity::Pre) {
|
|
let (pri, spec) = cell.get();
|
|
|
|
if pri > 0 {
|
|
op_desc.pre = pri;
|
|
op_desc.spec |= spec;
|
|
} else if name.as_str() == "-" {
|
|
op_desc.spec |= NEGATIVE_SIGN;
|
|
}
|
|
}
|
|
|
|
if let Some(OpDirValue(cell)) = op_dir.get(name.clone(), Fixity::Post) {
|
|
let (pri, spec) = cell.get();
|
|
|
|
if pri > 0 {
|
|
op_desc.post = pri;
|
|
op_desc.spec |= spec;
|
|
}
|
|
}
|
|
|
|
if let Some(OpDirValue(cell)) = op_dir.get(name.clone(), Fixity::In) {
|
|
let (pri, spec) = cell.get();
|
|
|
|
if pri > 0 {
|
|
op_desc.inf = pri;
|
|
op_desc.spec |= spec;
|
|
}
|
|
}
|
|
|
|
if op_desc.pre + op_desc.post + op_desc.inf == 0 && !is_negate!(op_desc.spec) {
|
|
None
|
|
} else {
|
|
Some(op_desc)
|
|
}
|
|
}
|
|
|
|
fn affirm_xfx(priority: usize, d2: TokenDesc, d3: TokenDesc, d1: TokenDesc) -> bool {
|
|
d2.priority <= priority
|
|
&& is_term!(d3.spec)
|
|
&& is_term!(d1.spec)
|
|
&& d3.priority < d2.priority
|
|
&& d1.priority < d2.priority
|
|
}
|
|
|
|
fn affirm_yfx(priority: usize, d2: TokenDesc, d3: TokenDesc, d1: TokenDesc) -> bool {
|
|
d2.priority <= priority
|
|
&& ((is_term!(d3.spec) && d3.priority < d2.priority)
|
|
|| (is_lterm!(d3.spec) && d3.priority == d2.priority))
|
|
&& is_term!(d1.spec)
|
|
&& d1.priority < d2.priority
|
|
}
|
|
|
|
fn affirm_xfy(priority: usize, d2: TokenDesc, d3: TokenDesc, d1: TokenDesc) -> bool {
|
|
d2.priority < priority
|
|
&& is_term!(d3.spec)
|
|
&& d3.priority < d2.priority
|
|
&& is_term!(d1.spec)
|
|
&& d1.priority <= d2.priority
|
|
}
|
|
|
|
fn affirm_yf(d1: TokenDesc, d2: TokenDesc) -> bool {
|
|
let is_valid_lterm = is_lterm!(d2.spec) && d2.priority == d1.priority;
|
|
(is_term!(d2.spec) && d2.priority < d1.priority) || is_valid_lterm
|
|
}
|
|
|
|
fn affirm_xf(d1: TokenDesc, d2: TokenDesc) -> bool {
|
|
is_term!(d2.spec) && d2.priority < d1.priority
|
|
}
|
|
|
|
fn affirm_fy(priority: usize, d1: TokenDesc, d2: TokenDesc) -> bool {
|
|
d2.priority < priority && is_term!(d1.spec) && d1.priority <= d2.priority
|
|
}
|
|
|
|
fn affirm_fx(priority: usize, d1: TokenDesc, d2: TokenDesc) -> bool {
|
|
d2.priority <= priority && is_term!(d1.spec) && d1.priority < d2.priority
|
|
}
|
|
|
|
fn sep_to_atom(tt: TokenType) -> Option<ClauseName> {
|
|
match tt {
|
|
TokenType::Open | TokenType::OpenCT => Some(clause_name!("(")),
|
|
TokenType::Close => Some(clause_name!(")")),
|
|
TokenType::OpenList => Some(clause_name!("[")),
|
|
TokenType::CloseList => Some(clause_name!("]")),
|
|
TokenType::OpenCurly => Some(clause_name!("{")),
|
|
TokenType::CloseCurly => Some(clause_name!("}")),
|
|
TokenType::HeadTailSeparator => Some(clause_name!("|")),
|
|
TokenType::Comma => Some(clause_name!(",")),
|
|
TokenType::End => Some(clause_name!(".")),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub struct OpDesc {
|
|
pub pre: usize,
|
|
pub inf: usize,
|
|
pub post: usize,
|
|
pub spec: Specifier,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct Parser<'a, R: Read> {
|
|
lexer: Lexer<'a, R>,
|
|
tokens: Vec<Token>,
|
|
stack: Vec<TokenDesc>,
|
|
terms: Vec<Term>,
|
|
}
|
|
|
|
fn read_tokens<R: Read>(lexer: &mut Lexer<R>) -> Result<Vec<Token>, ParserError> {
|
|
let mut tokens = vec![];
|
|
|
|
loop {
|
|
let token = lexer.next_token()?;
|
|
let at_end = token.is_end();
|
|
|
|
tokens.push(token);
|
|
|
|
if at_end {
|
|
break;
|
|
}
|
|
}
|
|
|
|
tokens.reverse();
|
|
|
|
Ok(tokens)
|
|
}
|
|
|
|
impl<'a, R: Read> Parser<'a, R> {
|
|
pub fn new(
|
|
stream: &'a mut ParsingStream<R>,
|
|
atom_tbl: TabledData<Atom>,
|
|
flags: MachineFlags,
|
|
) -> Self {
|
|
Parser {
|
|
lexer: Lexer::new(atom_tbl, flags, stream),
|
|
tokens: vec![],
|
|
stack: Vec::new(),
|
|
terms: Vec::new(),
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn line_num(&self) -> usize {
|
|
self.lexer.line_num
|
|
}
|
|
|
|
#[inline]
|
|
pub fn col_num(&self) -> usize {
|
|
self.lexer.col_num
|
|
}
|
|
|
|
#[inline]
|
|
pub fn get_atom_tbl(&self) -> TabledData<Atom> {
|
|
self.lexer.atom_tbl.clone()
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_atom_tbl(&mut self, atom_tbl: TabledData<Atom>) {
|
|
self.lexer.atom_tbl = atom_tbl;
|
|
}
|
|
|
|
fn get_term_name(&mut self, td: TokenDesc) -> Option<(ClauseName, Option<SharedOpDesc>)> {
|
|
match td.tt {
|
|
TokenType::HeadTailSeparator => Some((
|
|
clause_name!("|"),
|
|
Some(SharedOpDesc::new(td.priority, td.spec)),
|
|
)),
|
|
TokenType::Comma => Some((clause_name!(","), Some(SharedOpDesc::new(1000, XFY)))),
|
|
TokenType::Term => match self.terms.pop() {
|
|
Some(Term::Constant(_, Constant::Atom(atom, spec))) => Some((atom, spec)),
|
|
Some(term) => {
|
|
self.terms.push(term);
|
|
None
|
|
}
|
|
_ => None,
|
|
},
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn push_binary_op(&mut self, td: TokenDesc, spec: Specifier) {
|
|
if let Some(arg2) = self.terms.pop() {
|
|
if let Some((name, shared_op_desc)) = self.get_term_name(td) {
|
|
if let Some(arg1) = self.terms.pop() {
|
|
let term = Term::Clause(
|
|
Cell::default(),
|
|
name,
|
|
vec![Box::new(arg1), Box::new(arg2)],
|
|
shared_op_desc,
|
|
);
|
|
|
|
self.terms.push(term);
|
|
self.stack.push(TokenDesc {
|
|
tt: TokenType::Term,
|
|
priority: td.priority,
|
|
spec,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn push_unary_op(&mut self, td: TokenDesc, spec: Specifier, assoc: u32) {
|
|
if let Some(mut arg1) = self.terms.pop() {
|
|
if let Some(mut name) = self.terms.pop() {
|
|
if is_postfix!(assoc) {
|
|
swap(&mut arg1, &mut name);
|
|
}
|
|
|
|
if let Term::Constant(_, Constant::Atom(name, shared_op_desc)) = name {
|
|
let term =
|
|
Term::Clause(Cell::default(), name, vec![Box::new(arg1)], shared_op_desc);
|
|
|
|
self.terms.push(term);
|
|
self.stack.push(TokenDesc {
|
|
tt: TokenType::Term,
|
|
priority: td.priority,
|
|
spec,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn promote_atom_op(
|
|
&mut self,
|
|
atom: ClauseName,
|
|
priority: usize,
|
|
assoc: u32,
|
|
op_dir_val: Option<&OpDirValue>,
|
|
) {
|
|
let spec = op_dir_val.map(|op_dir_val| op_dir_val.shared_op_desc());
|
|
|
|
self.terms
|
|
.push(Term::Constant(Cell::default(), Constant::Atom(atom, spec)));
|
|
self.stack.push(TokenDesc {
|
|
tt: TokenType::Term,
|
|
priority,
|
|
spec: assoc,
|
|
});
|
|
}
|
|
|
|
fn shift(&mut self, token: Token, priority: usize, spec: Specifier) {
|
|
let tt = match token {
|
|
Token::Constant(Constant::String(s)) if self.lexer.flags.double_quotes.is_codes() => {
|
|
let mut list = Term::Constant(Cell::default(), Constant::EmptyList);
|
|
|
|
for c in s.chars().rev() {
|
|
list = Term::Cons(
|
|
Cell::default(),
|
|
Box::new(Term::Constant(
|
|
Cell::default(),
|
|
Constant::Fixnum(c as isize),
|
|
)),
|
|
Box::new(list),
|
|
);
|
|
}
|
|
|
|
self.terms.push(list);
|
|
TokenType::Term
|
|
}
|
|
Token::Constant(c) => {
|
|
self.terms.push(Term::Constant(Cell::default(), c));
|
|
TokenType::Term
|
|
}
|
|
Token::Var(v) => {
|
|
if v.trim() == "_" {
|
|
self.terms.push(Term::AnonVar);
|
|
} else {
|
|
self.terms.push(Term::Var(Cell::default(), v));
|
|
}
|
|
|
|
TokenType::Term
|
|
}
|
|
Token::Comma => TokenType::Comma,
|
|
Token::Open => TokenType::Open,
|
|
Token::Close => TokenType::Close,
|
|
Token::OpenCT => TokenType::OpenCT,
|
|
Token::HeadTailSeparator => TokenType::HeadTailSeparator,
|
|
Token::OpenList => TokenType::OpenList,
|
|
Token::CloseList => TokenType::CloseList,
|
|
Token::OpenCurly => TokenType::OpenCurly,
|
|
Token::CloseCurly => TokenType::CloseCurly,
|
|
Token::End => TokenType::End,
|
|
};
|
|
|
|
self.stack.push(TokenDesc { tt, priority, spec });
|
|
}
|
|
|
|
fn reduce_op(&mut self, priority: usize) {
|
|
loop {
|
|
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) {
|
|
self.push_binary_op(desc2, LTERM);
|
|
continue;
|
|
} else if is_xfy!(desc2.spec) && affirm_xfy(priority, desc2, desc3, desc1) {
|
|
self.push_binary_op(desc2, TERM);
|
|
continue;
|
|
} else {
|
|
self.stack.push(desc3);
|
|
}
|
|
}
|
|
|
|
if is_yf!(desc1.spec) && affirm_yf(desc1, desc2) {
|
|
self.push_unary_op(desc1, LTERM, YF);
|
|
continue;
|
|
} else if is_xf!(desc1.spec) && affirm_xf(desc1, desc2) {
|
|
self.push_unary_op(desc1, LTERM, XF);
|
|
continue;
|
|
} else if is_fy!(desc2.spec) && affirm_fy(priority, desc1, desc2) {
|
|
self.push_unary_op(desc2, TERM, FY);
|
|
continue;
|
|
} else if is_fx!(desc2.spec) && affirm_fx(priority, desc1, desc2) {
|
|
self.push_unary_op(desc2, TERM, FX);
|
|
continue;
|
|
} else {
|
|
self.stack.push(desc2);
|
|
self.stack.push(desc1);
|
|
}
|
|
} else {
|
|
self.stack.push(desc1);
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
fn compute_arity_in_brackets(&self) -> Option<usize> {
|
|
let mut arity = 0;
|
|
|
|
for (i, desc) in self.stack.iter().rev().enumerate() {
|
|
if i % 2 == 0 {
|
|
// expect a term or non-comma operator.
|
|
if let TokenType::Comma = desc.tt {
|
|
return None;
|
|
} else if is_term!(desc.spec) || is_op!(desc.spec) || is_negate!(desc.spec) {
|
|
arity += 1;
|
|
} else {
|
|
return None;
|
|
}
|
|
} else {
|
|
if desc.tt == TokenType::OpenCT {
|
|
return Some(arity);
|
|
}
|
|
|
|
if let TokenType::Comma = desc.tt {
|
|
continue;
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
fn reduce_term(&mut self, op_dir: &CompositeOpDir) -> bool {
|
|
if self.stack.is_empty() {
|
|
return false;
|
|
}
|
|
|
|
self.reduce_op(999);
|
|
|
|
let arity = match self.compute_arity_in_brackets() {
|
|
Some(arity) => arity,
|
|
None => return false,
|
|
};
|
|
|
|
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;
|
|
}
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
let stack_len = self.stack.len() - 2 * arity - 1;
|
|
let idx = self.terms.len() - arity;
|
|
|
|
if TokenType::Term == self.stack[stack_len].tt {
|
|
if self.atomize_term(&self.terms[idx - 1]).is_some() {
|
|
self.stack.truncate(stack_len + 1);
|
|
|
|
let mut subterms: Vec<_> = self.terms.drain(idx..).map(Box::new).collect();
|
|
|
|
if let Some(name) = self.terms.pop().and_then(|t| self.atomize_term(&t)) {
|
|
// reduce the '.' functor to a cons cell if it applies.
|
|
if name.as_str() == "." && subterms.len() == 2 {
|
|
let tail = subterms.pop().unwrap();
|
|
let head = subterms.pop().unwrap();
|
|
|
|
self.terms.push(Term::Cons(Cell::default(), head, tail));
|
|
} else {
|
|
let spec = get_clause_spec(name.clone(), subterms.len(), op_dir);
|
|
self.terms
|
|
.push(Term::Clause(Cell::default(), name, subterms, spec));
|
|
}
|
|
|
|
if let Some(&mut TokenDesc {
|
|
ref mut priority,
|
|
ref mut spec,
|
|
ref mut tt,
|
|
}) = self.stack.last_mut()
|
|
{
|
|
*tt = TokenType::Term;
|
|
*priority = 0;
|
|
*spec = TERM;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
false
|
|
}
|
|
|
|
pub fn devour_whitespace(&mut self) -> Result<(), ParserError> {
|
|
self.lexer.scan_for_layout()?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn reset(&mut self) {
|
|
self.stack.clear()
|
|
}
|
|
|
|
fn expand_comma_compacted_terms(&mut self, index: usize) -> usize {
|
|
if let Some(term) = self.terms.pop() {
|
|
let op_desc = self.stack[index - 1];
|
|
|
|
if 0 < op_desc.priority && op_desc.priority < self.stack[index].priority {
|
|
/* '|' 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.as_str() == "," => {
|
|
let terms = unfold_by_str(term, ",");
|
|
let arity = terms.len() - 1;
|
|
|
|
self.terms.extend(terms.into_iter());
|
|
return arity;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
self.terms.push(term);
|
|
}
|
|
|
|
0
|
|
}
|
|
|
|
fn compute_arity_in_list(&self) -> Option<usize> {
|
|
let mut arity = 0;
|
|
|
|
for (i, desc) in self.stack.iter().rev().enumerate() {
|
|
if i % 2 == 0 {
|
|
// expect a term or non-comma operator.
|
|
if let TokenType::Comma = desc.tt {
|
|
return None;
|
|
} else if is_term!(desc.spec) || is_op!(desc.spec) {
|
|
arity += 1;
|
|
} 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;
|
|
}
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
fn reduce_list(&mut self) -> Result<bool, ParserError> {
|
|
if self.stack.is_empty() {
|
|
return Ok(false);
|
|
}
|
|
|
|
if let Some(ref mut td) = self.stack.last_mut() {
|
|
if td.tt == TokenType::OpenList {
|
|
td.spec = TERM;
|
|
td.tt = TokenType::Term;
|
|
td.priority = 0;
|
|
|
|
self.terms
|
|
.push(Term::Constant(Cell::default(), Constant::EmptyList));
|
|
return Ok(true);
|
|
}
|
|
}
|
|
|
|
self.reduce_op(1000);
|
|
|
|
let mut arity = match self.compute_arity_in_list() {
|
|
Some(arity) => arity,
|
|
None => return Ok(false),
|
|
};
|
|
|
|
// we know that self.stack.len() >= 2 by this point.
|
|
let idx = self.stack.len() - 2;
|
|
let list_len = self.stack.len() - 2 * arity;
|
|
|
|
let end_term = if self.stack[idx].tt != TokenType::HeadTailSeparator {
|
|
Term::Constant(Cell::default(), Constant::EmptyList)
|
|
} else {
|
|
let term = match self.terms.pop() {
|
|
Some(term) => term,
|
|
_ => {
|
|
return Err(ParserError::IncompleteReduction(
|
|
self.lexer.line_num,
|
|
self.lexer.col_num,
|
|
))
|
|
}
|
|
};
|
|
|
|
if self.stack[idx].priority > 1000 {
|
|
arity += self.expand_comma_compacted_terms(idx);
|
|
}
|
|
|
|
arity -= 1;
|
|
|
|
term
|
|
};
|
|
|
|
let idx = self.terms.len() - arity;
|
|
|
|
let list = self.terms.drain(idx..).rev().fold(end_term, |acc, t| {
|
|
Term::Cons(Cell::default(), Box::new(t), Box::new(acc))
|
|
});
|
|
|
|
self.stack.truncate(list_len);
|
|
|
|
self.stack.push(TokenDesc {
|
|
tt: TokenType::Term,
|
|
priority: 0,
|
|
spec: TERM,
|
|
});
|
|
self.terms.push(list);
|
|
|
|
Ok(true)
|
|
}
|
|
|
|
fn reduce_curly(&mut self) -> Result<bool, ParserError> {
|
|
if self.stack.is_empty() {
|
|
return Ok(false);
|
|
}
|
|
|
|
if let Some(ref mut td) = self.stack.last_mut() {
|
|
if td.tt == TokenType::OpenCurly {
|
|
td.tt = TokenType::Term;
|
|
td.priority = 0;
|
|
td.spec = TERM;
|
|
|
|
let term = Term::Constant(Cell::default(), atom!("{}", self.lexer.atom_tbl));
|
|
self.terms.push(term);
|
|
return Ok(true);
|
|
}
|
|
}
|
|
|
|
self.reduce_op(1201);
|
|
|
|
if self.stack.len() > 1 {
|
|
if let Some(td) = self.stack.pop() {
|
|
if let Some(ref mut oc) = self.stack.last_mut() {
|
|
if td.tt != TokenType::Term {
|
|
return Ok(false);
|
|
}
|
|
|
|
if oc.tt == TokenType::OpenCurly {
|
|
oc.tt = TokenType::Term;
|
|
oc.priority = 0;
|
|
oc.spec = TERM;
|
|
|
|
let term = match self.terms.pop() {
|
|
Some(term) => term,
|
|
_ => {
|
|
return Err(ParserError::IncompleteReduction(
|
|
self.lexer.line_num,
|
|
self.lexer.col_num,
|
|
))
|
|
}
|
|
};
|
|
|
|
self.terms.push(Term::Clause(
|
|
Cell::default(),
|
|
clause_name!("{}"),
|
|
vec![Box::new(term)],
|
|
None,
|
|
));
|
|
|
|
return Ok(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(false)
|
|
}
|
|
|
|
fn reduce_brackets(&mut self) -> bool {
|
|
if self.stack.is_empty() {
|
|
return false;
|
|
}
|
|
|
|
self.reduce_op(1400);
|
|
|
|
if self.stack.len() == 1 {
|
|
return false;
|
|
}
|
|
|
|
let idx = self.stack.len() - 2;
|
|
|
|
let td = self.stack.remove(idx);
|
|
match td.tt {
|
|
TokenType::Open | TokenType::OpenCT => {
|
|
if self.stack[idx].tt == TokenType::Comma {
|
|
return false;
|
|
}
|
|
|
|
if let Some(atom) = sep_to_atom(self.stack[idx].tt) {
|
|
self.terms
|
|
.push(Term::Constant(Cell::default(), Constant::Atom(atom, None)));
|
|
}
|
|
|
|
self.stack[idx].spec = TERM;
|
|
self.stack[idx].tt = TokenType::Term;
|
|
self.stack[idx].priority = 0;
|
|
true
|
|
}
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
fn shift_op(&mut self, name: ClauseName, op_dir: &CompositeOpDir) -> Result<bool, ParserError> {
|
|
if let Some(OpDesc {
|
|
pre,
|
|
inf,
|
|
post,
|
|
spec,
|
|
}) = get_op_desc(name.clone(), op_dir)
|
|
{
|
|
if (pre > 0 && inf + post > 0) || is_negate!(spec) {
|
|
match self.tokens.last().ok_or(ParserError::UnexpectedEOF)? {
|
|
// do this when layout hasn't been inserted,
|
|
// ie. why we don't match on Token::Open.
|
|
Token::OpenCT => {
|
|
// can't be prefix, so either inf == 0
|
|
// or post == 0.
|
|
self.reduce_op(inf + post);
|
|
|
|
let fixity = if inf > 0 { Fixity::In } else { Fixity::Post };
|
|
let op_dir_val = op_dir.get(name.clone(), fixity);
|
|
|
|
self.promote_atom_op(
|
|
name,
|
|
inf + post,
|
|
spec & (XFX | XFY | YFX | YF | XF),
|
|
op_dir_val,
|
|
);
|
|
}
|
|
_ => {
|
|
self.reduce_op(inf + post);
|
|
|
|
if let Some(TokenDesc { spec: pspec, .. }) = self.stack.last().cloned() {
|
|
// rterm.c: 412
|
|
if is_term!(pspec) {
|
|
let fixity = if inf > 0 { Fixity::In } else { Fixity::Post };
|
|
let op_dir_val = op_dir.get(name.clone(), fixity);
|
|
|
|
self.promote_atom_op(
|
|
name,
|
|
inf + post,
|
|
spec & (XFX | XFY | YFX | XF | YF),
|
|
op_dir_val,
|
|
);
|
|
} else {
|
|
let op_dir_val = op_dir.get(name.clone(), Fixity::Pre);
|
|
self.promote_atom_op(
|
|
name,
|
|
pre,
|
|
spec & (FX | FY | NEGATIVE_SIGN),
|
|
op_dir_val,
|
|
);
|
|
}
|
|
} else {
|
|
let op_dir_val = op_dir.get(name.clone(), Fixity::Pre);
|
|
self.promote_atom_op(
|
|
name,
|
|
pre,
|
|
spec & (FX | FY | NEGATIVE_SIGN),
|
|
op_dir_val,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
let op_dir_val = op_dir.get(
|
|
name.clone(),
|
|
if pre + inf == 0 {
|
|
Fixity::Post
|
|
} else if post + pre == 0 {
|
|
Fixity::In
|
|
} else {
|
|
Fixity::Pre
|
|
},
|
|
);
|
|
|
|
self.reduce_op(pre + inf + post); // only one non-zero priority among these.
|
|
self.promote_atom_op(name, pre + inf + post, spec, op_dir_val);
|
|
}
|
|
|
|
Ok(true)
|
|
} else {
|
|
// not an operator.
|
|
Ok(false)
|
|
}
|
|
}
|
|
|
|
fn atomize_term(&self, term: &Term) -> Option<ClauseName> {
|
|
match term {
|
|
Term::Constant(_, ref c) => self.atomize_constant(c),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn atomize_constant(&self, c: &Constant) -> Option<ClauseName> {
|
|
match c {
|
|
Constant::Atom(ref name, _) => Some(name.clone()),
|
|
Constant::Char(c) => Some(clause_name!(c.to_string(), self.lexer.atom_tbl)),
|
|
Constant::EmptyList => Some(clause_name!(c.to_string(), self.lexer.atom_tbl)),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn negate_number<N, Negator, ToConstant>(&mut self, n: N, negator: Negator, constr: ToConstant)
|
|
where
|
|
Negator: Fn(N) -> N,
|
|
ToConstant: Fn(N) -> Constant,
|
|
{
|
|
if let Some(desc) = self.stack.last().cloned() {
|
|
if let Some(term) = self.terms.last().cloned() {
|
|
match term {
|
|
Term::Constant(_, Constant::Atom(ref name, _))
|
|
if name.as_str() == "-"
|
|
&& (is_prefix!(desc.spec) || is_negate!(desc.spec)) =>
|
|
{
|
|
self.stack.pop();
|
|
self.terms.pop();
|
|
|
|
self.shift(Token::Constant(constr(negator(n))), 0, TERM);
|
|
return;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
self.shift(Token::Constant(constr(n)), 0, TERM);
|
|
}
|
|
|
|
fn shift_token(&mut self, token: Token, op_dir: &CompositeOpDir) -> Result<(), ParserError> {
|
|
fn negate_rc<T: NegAssign>(mut t: Rc<T>) -> Rc<T> {
|
|
if let Some(t) = Rc::get_mut(&mut t) {
|
|
t.neg_assign();
|
|
};
|
|
|
|
t
|
|
}
|
|
|
|
match token {
|
|
Token::Constant(Constant::Fixnum(n)) => self.negate_number(n, |n| -n, Constant::Fixnum),
|
|
Token::Constant(Constant::Integer(n)) => {
|
|
self.negate_number(n, negate_rc, Constant::Integer)
|
|
}
|
|
Token::Constant(Constant::Rational(n)) => {
|
|
self.negate_number(n, negate_rc, Constant::Rational)
|
|
}
|
|
Token::Constant(Constant::Float(n)) => {
|
|
self.negate_number(n, |n| OrderedFloat(-n.into_inner()), Constant::Float)
|
|
}
|
|
Token::Constant(c) => {
|
|
if let Some(name) = self.atomize_constant(&c) {
|
|
if !self.shift_op(name, op_dir)? {
|
|
self.shift(Token::Constant(c), 0, TERM);
|
|
}
|
|
} else {
|
|
self.shift(Token::Constant(c), 0, TERM);
|
|
}
|
|
}
|
|
Token::Var(v) => self.shift(Token::Var(v), 0, TERM),
|
|
Token::Open => self.shift(Token::Open, 1300, DELIMITER),
|
|
Token::OpenCT => self.shift(Token::OpenCT, 1300, DELIMITER),
|
|
Token::Close => {
|
|
if !self.reduce_term(op_dir) {
|
|
if !self.reduce_brackets() {
|
|
return Err(ParserError::IncompleteReduction(
|
|
self.lexer.line_num,
|
|
self.lexer.col_num,
|
|
));
|
|
}
|
|
}
|
|
}
|
|
Token::OpenList => self.shift(Token::OpenList, 1300, DELIMITER),
|
|
Token::CloseList => {
|
|
if !self.reduce_list()? {
|
|
return Err(ParserError::IncompleteReduction(
|
|
self.lexer.line_num,
|
|
self.lexer.col_num,
|
|
));
|
|
}
|
|
}
|
|
Token::OpenCurly => self.shift(Token::OpenCurly, 1300, DELIMITER),
|
|
Token::CloseCurly => {
|
|
if !self.reduce_curly()? {
|
|
return Err(ParserError::IncompleteReduction(
|
|
self.lexer.line_num,
|
|
self.lexer.col_num,
|
|
));
|
|
}
|
|
}
|
|
Token::HeadTailSeparator => {
|
|
/* '|' as an operator must have priority > 1000 and can only be infix.
|
|
* See: http://www.complang.tuwien.ac.at/ulrich/iso-prolog/dtc2#Res_A78
|
|
*/
|
|
let (priority, spec) = get_op_desc(clause_name!("|"), op_dir)
|
|
.map(|OpDesc { inf, spec, .. }| (inf, spec))
|
|
.unwrap_or((1000, DELIMITER));
|
|
|
|
self.reduce_op(priority);
|
|
self.shift(Token::HeadTailSeparator, priority, spec);
|
|
}
|
|
Token::Comma => {
|
|
self.reduce_op(1000);
|
|
self.shift(Token::Comma, 1000, XFY);
|
|
}
|
|
Token::End => match self.stack.last().map(|t| t.tt) {
|
|
Some(TokenType::Open)
|
|
| Some(TokenType::OpenCT)
|
|
| Some(TokenType::OpenList)
|
|
| Some(TokenType::OpenCurly)
|
|
| Some(TokenType::HeadTailSeparator)
|
|
| Some(TokenType::Comma) => {
|
|
return Err(ParserError::IncompleteReduction(
|
|
self.lexer.line_num,
|
|
self.lexer.col_num,
|
|
))
|
|
}
|
|
_ => {}
|
|
},
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[inline]
|
|
pub fn eof(&mut self) -> Result<bool, ParserError> {
|
|
self.lexer.eof()
|
|
}
|
|
|
|
#[inline]
|
|
pub fn add_lines_read(&mut self, lines_read: usize) {
|
|
self.lexer.line_num += lines_read;
|
|
}
|
|
|
|
#[inline]
|
|
pub fn num_lines_read(&self) -> usize {
|
|
self.lexer.line_num
|
|
}
|
|
|
|
// on success, returns the parsed term and the number of lines read.
|
|
pub fn read_term(&mut self, op_dir: &CompositeOpDir) -> Result<Term, ParserError> {
|
|
self.tokens = read_tokens(&mut self.lexer)?;
|
|
|
|
while let Some(token) = self.tokens.pop() {
|
|
self.shift_token(token, op_dir)?;
|
|
}
|
|
|
|
self.reduce_op(1400);
|
|
|
|
if self.terms.len() > 1 || self.stack.len() > 1 {
|
|
return Err(ParserError::IncompleteReduction(
|
|
self.lexer.line_num,
|
|
self.lexer.col_num,
|
|
));
|
|
}
|
|
|
|
match self.terms.pop() {
|
|
Some(term) => {
|
|
if self.terms.is_empty() {
|
|
Ok(term)
|
|
} else {
|
|
Err(ParserError::IncompleteReduction(
|
|
self.lexer.line_num,
|
|
self.lexer.col_num,
|
|
))
|
|
}
|
|
}
|
|
_ => Err(ParserError::IncompleteReduction(
|
|
self.lexer.line_num,
|
|
self.lexer.col_num,
|
|
)),
|
|
}
|
|
}
|
|
}
|