Add prolog_parser to scryer_prolog

Cargo.toml

@@ -11,6 +11,9 @@ keywords = ["prolog", "prolog-interpreter", "prolog-system"]
 categories = ["command-line-utilities"]
 build = "build.rs"
 
+[workspace]
+members = ["prolog_parser"]
+
 [build-dependencies]
 indexmap = "1.0.2"
 
@@ -32,7 +35,7 @@ libc = "0.2.62"
 nix = "0.15.0"
 num-rug-adapter = { optional = true, version = "0.1.4" }
 ordered-float = "0.5.0"
-prolog_parser = { version = "0.8.68", default-features = false }
+prolog_parser = { path = "./prolog_parser", default-features = false }
 ref_thread_local = "0.0.0"
 rug = { version = "1.4.0", optional = true }
 rustyline = "7.0.0"

prolog_parser/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "prolog_parser"
+version = "0.8.68"
+authors = ["Mark Thom <markjordanthom@gmail.com>"]
+repository = "https://github.com/mthom/prolog_parser"
+description = " An operator precedence parser for rusty-wam, an up and coming ISO Prolog implementation."
+license = "BSD-3-Clause"
+
+[dependencies]
+lexical = "2.1.0"
+ordered-float = "0.5.0"
+rug = { optional = true, version = "1.4.0" }
+num-rug-adapter = { optional = true, version = "0.1.3" }
+unicode_reader = "1.0.0"
+
+[lib]
+path = "src/lib.rs"
+
+[features]
+num = ["num-rug-adapter"]
+default = ["rug"]

prolog_parser/src/ast.rs

@@ -0,0 +1,876 @@
+use rug::{Integer, Rational};
+use ordered_float::*;
+use tabled_rc::*;
+
+use put_back_n::*;
+
+use std::cell::Cell;
+use std::cmp::Ordering;
+use std::collections::HashMap;
+use std::fmt;
+use std::hash::{Hash, Hasher};
+use std::io::{Bytes, Error as IOError, Read};
+use std::rc::Rc;
+use std::vec::Vec;
+
+use unicode_reader::CodePoints;
+
+pub type Atom = String;
+
+pub type Var = String;
+
+pub type Specifier = u32;
+
+pub const MAX_ARITY: usize = 1023;
+
+pub const XFX: u32 = 0x0001;
+pub const XFY: u32 = 0x0002;
+pub const YFX: u32 = 0x0004;
+pub const XF: u32  = 0x0010;
+pub const YF: u32  = 0x0020;
+pub const FX: u32  = 0x0040;
+pub const FY: u32  = 0x0080;
+pub const DELIMITER: u32 = 0x0100;
+pub const TERM: u32  = 0x1000;
+pub const LTERM: u32 = 0x3000;
+
+pub const NEGATIVE_SIGN: u32 = 0x0200;
+
+#[macro_export]
+macro_rules! clause_name {
+    ($name: expr, $tbl: expr) => (
+        ClauseName::User(TabledRc::new($name, $tbl.clone()))
+    ) ;
+    ($name: expr) => (
+        ClauseName::BuiltIn($name)
+    )
+}
+
+#[macro_export]
+macro_rules! atom {
+    ($e:expr, $tbl:expr) => (
+        Constant::Atom(ClauseName::User(tabled_rc!($e, $tbl)), None)
+    );
+    ($e:expr) => (
+        Constant::Atom(clause_name!($e), None)
+    )
+}
+
+#[macro_export]
+macro_rules! rc_atom {
+    ($e:expr) => (
+        Rc::new(String::from($e))
+    )
+}
+macro_rules! is_term {
+    ($x:expr) => ( ($x & TERM) != 0 )
+}
+
+macro_rules! is_lterm {
+    ($x:expr) => ( ($x & LTERM) != 0 )
+}
+
+macro_rules! is_op {
+    ($x:expr) => ( $x & (XF | YF | FX | FY | XFX | XFY | YFX) != 0 )
+}
+
+macro_rules! is_negate {
+    ($x:expr) => ( ($x & NEGATIVE_SIGN) != 0 )
+}
+
+#[macro_export]
+macro_rules! is_prefix {
+    ($x:expr) => ( $x & (FX | FY) != 0 )
+}
+
+#[macro_export]
+macro_rules! is_postfix {
+    ($x:expr) => ( $x & (XF | YF) != 0 )
+}
+
+#[macro_export]
+macro_rules! is_infix {
+    ($x:expr) => ( ($x & (XFX | XFY | YFX)) != 0 )
+}
+
+#[macro_export]
+macro_rules! is_xfx {
+    ($x:expr) => ( ($x & XFX) != 0 )
+}
+
+#[macro_export]
+macro_rules! is_xfy {
+    ($x:expr) => ( ($x & XFY) != 0 )
+}
+
+#[macro_export]
+macro_rules! is_yfx {
+    ($x:expr) => ( ($x & YFX) != 0 )
+}
+
+#[macro_export]
+macro_rules! is_yf {
+    ($x:expr) => ( ($x & YF) != 0 )
+}
+
+#[macro_export]
+macro_rules! is_xf {
+    ($x:expr) => ( ($x & XF) != 0 )
+}
+
+#[macro_export]
+macro_rules! is_fx {
+    ($x:expr) => ( ($x & FX) != 0 )
+}
+
+#[macro_export]
+macro_rules! is_fy {
+    ($x:expr) => ( ($x & FY) != 0 )
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum RegType {
+    Perm(usize),
+    Temp(usize)
+}
+
+impl Default for RegType {
+    fn default() -> Self {
+        RegType::Temp(0)
+    }
+}
+
+impl RegType {
+    pub fn reg_num(self) -> usize {
+        match self {
+            RegType::Perm(reg_num) | RegType::Temp(reg_num) => reg_num
+        }
+    }
+
+    pub fn is_perm(self) -> bool {
+        match self {
+            RegType::Perm(_) => true,
+            _ => false
+        }
+    }
+}
+
+impl fmt::Display for RegType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            &RegType::Perm(val) => write!(f, "Y{}", val),
+            &RegType::Temp(val) => write!(f, "X{}", val)
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum VarReg {
+    ArgAndNorm(RegType, usize),
+    Norm(RegType)
+}
+
+impl VarReg {
+    pub fn norm(self) -> RegType {
+        match self {
+            VarReg::ArgAndNorm(reg, _) | VarReg::Norm(reg) => reg
+        }
+    }
+}
+
+impl fmt::Display for VarReg {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            &VarReg::Norm(RegType::Perm(reg)) => write!(f, "Y{}", reg),
+            &VarReg::Norm(RegType::Temp(reg)) => write!(f, "X{}", reg),
+            &VarReg::ArgAndNorm(RegType::Perm(reg), arg) =>
+                write!(f, "Y{} A{}", reg, arg),
+            &VarReg::ArgAndNorm(RegType::Temp(reg), arg) =>
+                write!(f, "X{} A{}", reg, arg)
+        }
+    }
+}
+
+impl Default for VarReg {
+    fn default() -> Self {
+        VarReg::Norm(RegType::default())
+    }
+}
+
+#[macro_export]
+macro_rules! temp_v {
+    ($x:expr) => (
+        RegType::Temp($x)
+    )
+}
+
+#[macro_export]
+macro_rules! perm_v {
+    ($x:expr) => (
+        RegType::Perm($x)
+    )
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum GenContext {
+    Head, Mid(usize), Last(usize) // Mid & Last: chunk_num
+}
+
+impl GenContext {
+    pub fn chunk_num(self) -> usize {
+        match self {
+            GenContext::Head => 0,
+            GenContext::Mid(cn) | GenContext::Last(cn) => cn
+        }
+    }
+}
+
+pub type OpDirKey = (ClauseName, Fixity);
+
+#[derive(Debug, Clone)]
+pub struct OpDirValue(pub SharedOpDesc, pub ClauseName);
+
+impl OpDirValue {
+    pub fn new(spec: Specifier, priority: usize, module_name: ClauseName) -> Self {
+        OpDirValue(SharedOpDesc::new(priority, spec), module_name)
+    }
+
+    #[inline]
+    pub fn shared_op_desc(&self) -> SharedOpDesc {
+        self.0.clone()
+    }
+
+    #[inline]
+    pub fn owning_module(&self) -> ClauseName {
+        self.1.clone()
+    }
+}
+
+// name and fixity -> operator type and precedence.
+pub type OpDir = HashMap<OpDirKey, OpDirValue>;
+
+#[derive(Debug, Clone, Copy)]
+pub struct MachineFlags {
+    pub double_quotes: DoubleQuotes
+}
+
+impl Default for MachineFlags {
+    fn default() -> Self {
+        MachineFlags { double_quotes: DoubleQuotes::default() }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum DoubleQuotes {
+    Atom, Chars, Codes
+}
+
+impl DoubleQuotes {
+    pub fn is_chars(self) -> bool {
+        if let DoubleQuotes::Chars = self {
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn is_atom(self) -> bool {
+        if let DoubleQuotes::Atom = self {
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn is_codes(self) -> bool {
+        if let DoubleQuotes::Codes = self {
+            true
+        } else {
+            false
+        }
+    }
+}
+
+impl Default for DoubleQuotes {
+    fn default() -> Self {
+        DoubleQuotes::Chars
+    }
+}
+
+pub fn default_op_dir() -> OpDir {
+    let module_name = clause_name!("builtins");
+    let mut op_dir = OpDir::new();
+
+    op_dir.insert((clause_name!(":-"), Fixity::In),  OpDirValue::new(XFX, 1200, module_name.clone()));
+    op_dir.insert((clause_name!(":-"), Fixity::Pre), OpDirValue::new(FX,  1200, module_name.clone()));
+    op_dir.insert((clause_name!("?-"), Fixity::Pre), OpDirValue::new(FX,  1200, module_name.clone()));
+    op_dir.insert((clause_name!(","), Fixity::In),   OpDirValue::new(XFY, 1000, module_name.clone()));
+
+    op_dir
+}
+
+#[derive(Debug, Clone)]
+pub enum ArithmeticError {
+    NonEvaluableFunctor(Constant, usize),
+    UninstantiatedVar
+}
+
+#[derive(Debug)]
+pub enum ParserError {
+    Arithmetic(ArithmeticError),
+    BackQuotedString(usize, usize),
+    BadPendingByte,
+    CannotParseCyclicTerm,
+    UnexpectedChar(char, usize, usize),
+    UnexpectedEOF,
+    IO(IOError),
+    ExpectedRel,
+    ExpectedTopLevelTerm,
+    InadmissibleFact,
+    InadmissibleQueryTerm,
+    IncompleteReduction(usize, usize),
+    InconsistentEntry,
+    InvalidDoubleQuotesDecl,
+    InvalidHook,
+    InvalidModuleDecl,
+    InvalidModuleExport,
+    InvalidRuleHead,
+    InvalidUseModuleDecl,
+    InvalidModuleResolution,
+    InvalidSingleQuotedCharacter(char),
+    MissingQuote(usize, usize),
+    NonPrologChar(usize, usize),
+    ParseBigInt(usize, usize),
+    ParseFloat(usize, usize),
+    Utf8Error(usize, usize)
+}
+
+impl ParserError {
+    pub fn line_and_col_num(&self) -> Option<(usize, usize)> {
+        match self {
+            &ParserError::BackQuotedString(line_num, col_num)
+          | &ParserError::UnexpectedChar(_, line_num, col_num)
+          | &ParserError::IncompleteReduction(line_num, col_num)
+          | &ParserError::MissingQuote(line_num, col_num)
+          | &ParserError::NonPrologChar(line_num, col_num)
+          | &ParserError::ParseBigInt(line_num, col_num)
+          | &ParserError::ParseFloat(line_num, col_num)
+          | &ParserError::Utf8Error(line_num, col_num) =>
+                Some((line_num, col_num)),
+            _ =>
+                None
+        }
+    }
+
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            &ParserError::Arithmetic(..) =>
+                "arithmetic_error",
+            &ParserError::BackQuotedString(..) =>
+                "back_quoted_string",
+            &ParserError::BadPendingByte =>
+                "bad_pending_byte",
+            &ParserError::UnexpectedChar(..) =>
+                "unexpected_char",
+            &ParserError::UnexpectedEOF =>
+                "unexpected_end_of_file",
+            &ParserError::ExpectedRel =>
+                "expected_relation",
+            &ParserError::ExpectedTopLevelTerm =>
+                "expected_atom_or_cons_or_clause",
+            &ParserError::InadmissibleFact =>
+                "inadmissible_fact",
+            &ParserError::InadmissibleQueryTerm =>
+                "inadmissible_query_term",
+            &ParserError::IncompleteReduction(..) =>
+                "incomplete_reduction",
+            &ParserError::InconsistentEntry =>
+                "inconsistent_entry",
+            &ParserError::InvalidDoubleQuotesDecl =>
+                "invalid_double_quotes_declaration",
+            &ParserError::InvalidHook =>
+                "invalid_hook",
+            &ParserError::InvalidModuleDecl =>
+                "invalid_module_declaration",
+            &ParserError::InvalidModuleExport =>
+                "invalid_module_export",
+            &ParserError::InvalidModuleResolution =>
+                "invalid_module_resolution",
+            &ParserError::InvalidRuleHead =>
+                "invalid_head_of_rule",
+            &ParserError::InvalidUseModuleDecl =>
+                "invalid_use_module_declaration",
+            &ParserError::InvalidSingleQuotedCharacter(..) =>
+                "invalid_single_quoted_character",
+            &ParserError::IO(_) =>
+                "input_output_error",
+            &ParserError::MissingQuote(..) =>
+                "missing_quote",
+            &ParserError::NonPrologChar(..) =>
+                "non_prolog_character",
+            &ParserError::ParseBigInt(..) =>
+                "cannot_parse_big_int",
+            &ParserError::ParseFloat(..) =>
+                "cannot_parse_float",
+            &ParserError::Utf8Error(..) =>
+                "utf8_conversion_error",
+            &ParserError::CannotParseCyclicTerm =>
+                "cannot_parse_cyclic_term"
+        }
+    }
+}
+
+impl From<ArithmeticError> for ParserError {
+    fn from(err: ArithmeticError) -> ParserError {
+        ParserError::Arithmetic(err)
+    }
+}
+
+impl From<IOError> for ParserError {
+    fn from(err: IOError) -> ParserError {
+        ParserError::IO(err)
+    }
+}
+
+impl From<&IOError> for ParserError {
+    fn from(error: &IOError) -> ParserError {
+        if error.get_ref().filter(|e| e.is::<BadUtf8Error>()).is_some() {
+            ParserError::Utf8Error(0, 0)
+        } else {
+            ParserError::IO(error.kind().into())
+        }
+    }
+}
+
+
+#[derive(Debug, Clone, Copy, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub enum Fixity {
+    In, Post, Pre
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct SharedOpDesc(Rc<Cell<(usize, Specifier)>>);
+
+impl SharedOpDesc {
+    #[inline]
+    pub fn new(priority: usize, spec: Specifier) -> Self {
+        SharedOpDesc(Rc::new(Cell::new((priority, spec))))
+    }
+
+    #[inline]
+    pub fn ptr_eq(lop_desc: &SharedOpDesc, rop_desc: &SharedOpDesc) -> bool {
+        Rc::ptr_eq(&lop_desc.0, &rop_desc.0)
+    }
+
+    #[inline]
+    pub fn arity(&self) -> usize {
+        if self.get().1 & (XFX | XFY | YFX) == 0 {
+            1
+        } else {
+            2
+        }
+    }
+
+    #[inline]
+    pub fn get(&self) -> (usize, Specifier) {
+        self.0.get()
+    }
+
+    #[inline]
+    pub fn set(&self, prec: usize, spec: Specifier) {
+        self.0.set((prec, spec));
+    }
+
+    #[inline]
+    pub fn prec(&self) -> usize {
+        self.0.get().0
+    }
+
+    #[inline]
+    pub fn assoc(&self) -> Specifier {
+        self.0.get().1
+    }
+}
+
+// this ensures that SharedOpDesc (which is not consistently placed in
+// every atom!) doesn't affect the value of an atom hash. If
+// SharedOpDesc values are to be indexed, a BTreeMap or BTreeSet
+// should be used, obviously.
+impl Hash for SharedOpDesc {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        0.hash(state)
+    }
+}
+
+#[derive(Debug, Clone, Hash)]
+pub enum Constant {
+    Atom(ClauseName, Option<SharedOpDesc>),
+    Char(char),
+    EmptyList,
+    Fixnum(isize),
+    Integer(Rc<Integer>),
+    Rational(Rc<Rational>),
+    Float(OrderedFloat<f64>),
+    String(Rc<String>),
+    Usize(usize),
+}
+
+impl fmt::Display for Constant {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            &Constant::Atom(ref atom, _) =>
+                if atom.as_str().chars().any(|c| "`.$'\" ".contains(c)) {
+                    write!(f, "'{}'", atom.as_str())
+                } else {
+                    write!(f, "{}", atom.as_str())
+                },
+            &Constant::Char(c) =>
+                write!(f, "'{}'", c as u32),
+            &Constant::EmptyList =>
+                write!(f, "[]"),
+            &Constant::Fixnum(n) =>
+                write!(f, "{}", n),
+            &Constant::Integer(ref n) =>
+                write!(f, "{}", n),
+            &Constant::Rational(ref n) =>
+                write!(f, "{}", n),
+            &Constant::Float(ref n) =>
+                write!(f, "{}", n),
+            &Constant::String(ref s) =>
+                write!(f, "\"{}\"", &s),
+            &Constant::Usize(integer) =>
+                write!(f, "u{}", integer),
+        }
+    }
+}
+
+impl PartialEq for Constant {
+    fn eq(&self, other: &Constant) -> bool {
+        match (self, other) {
+            (&Constant::Atom(ref atom, _), &Constant::Char(c))
+          | (&Constant::Char(c), &Constant::Atom(ref atom, _)) => {
+              atom.is_char() && Some(c) == atom.as_str().chars().next()
+            },
+            (&Constant::Atom(ref a1, _), &Constant::Atom(ref a2, _)) =>
+                a1.as_str() == a2.as_str(),
+            (&Constant::Char(c1), &Constant::Char(c2)) =>
+                c1 == c2,
+            (&Constant::Fixnum(n1), &Constant::Fixnum(n2)) =>
+                n1 == n2,
+            (&Constant::Fixnum(n1), &Constant::Integer(ref n2)) |
+            (&Constant::Integer(ref n2), &Constant::Fixnum(n1)) => {
+                if let Some(n2) = n2.to_isize() {
+                    n1 == n2
+                } else {
+                    false
+                }
+            }
+            (&Constant::Integer(ref n1), &Constant::Integer(ref n2)) =>
+                n1 == n2,
+            (&Constant::Rational(ref n1), &Constant::Rational(ref n2)) =>
+                n1 == n2,
+            (&Constant::Float(ref n1), &Constant::Float(ref n2)) =>
+                n1 == n2,
+            (&Constant::String(ref s1), &Constant::String(ref s2)) => {
+                &s1 == &s2
+            }
+            (&Constant::EmptyList, &Constant::EmptyList) =>
+                true,
+            (&Constant::Usize(u1), &Constant::Usize(u2)) =>
+                u1 == u2,
+            _ => false
+        }
+    }
+}
+
+impl Eq for Constant {}
+
+impl Constant {
+    pub fn to_atom(self) -> Option<ClauseName> {
+        match self {
+            Constant::Atom(a, _) => Some(a.defrock_brackets()),
+            _ => None
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum ClauseName {
+    BuiltIn(&'static str),
+    User(TabledRc<Atom>)
+}
+
+impl fmt::Display for ClauseName {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl Hash for ClauseName {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        (*self.as_str()).hash(state)
+    }
+}
+
+impl PartialEq for ClauseName {
+    fn eq(&self, other: &ClauseName) -> bool {
+        *self.as_str() == *other.as_str()
+    }
+}
+
+impl Eq for ClauseName {}
+
+impl Ord for ClauseName {
+    fn cmp(&self, other: &ClauseName) -> Ordering {
+        (*self.as_str()).cmp(other.as_str())
+    }
+}
+
+impl PartialOrd for ClauseName {
+    fn partial_cmp(&self, other: &ClauseName) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl<'a> From<&'a TabledRc<Atom>> for ClauseName {
+    fn from(name: &'a TabledRc<Atom>) -> ClauseName {
+        ClauseName::User(name.clone())
+    }
+}
+
+impl ClauseName {
+    #[inline]
+    pub fn owning_module(&self) -> Self {
+        match self {
+            &ClauseName::User(ref name) => {
+                let module = name.owning_module();
+                ClauseName::User(TabledRc { atom: module.clone(),
+                                            table: TabledData::new(module) })
+            },
+            _ => clause_name!("user")
+        }
+    }
+
+    #[inline]
+    pub fn to_rc(&self) -> Rc<String> {
+        match self {
+            &ClauseName::BuiltIn(s) => Rc::new(s.to_string()),
+            &ClauseName::User(ref rc) => rc.inner()
+        }
+    }
+
+    #[inline]
+    pub fn with_table(self, atom_tbl: TabledData<Atom>) -> Self {
+        match self {
+            ClauseName::BuiltIn(_) => self,
+            ClauseName::User(mut name) => {
+                name.table = atom_tbl;
+                ClauseName::User(name)
+            }
+        }
+    }
+
+    #[inline]
+    pub fn has_table(&self, atom_tbl: &TabledData<Atom>) -> bool {
+        match self {
+            ClauseName::BuiltIn(_) => false,
+            ClauseName::User(ref name) => &name.table == atom_tbl,
+        }
+    }
+
+    #[inline]
+    pub fn has_table_of(&self, other: &ClauseName) -> bool {
+        match self {
+            ClauseName::BuiltIn(_) => {
+                if let ClauseName::BuiltIn(_) = other {
+                    true
+                } else {
+                    false
+                }
+            }
+            ClauseName::User(ref name) => {
+                other.has_table(&name.table)
+            }
+        }
+    }
+
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        match self {
+            &ClauseName::BuiltIn(s) => s,
+            &ClauseName::User(ref name) => name.as_ref()
+        }
+    }
+
+    #[inline]
+    pub fn is_char(&self) -> bool {
+        !self.as_str().is_empty() && self.as_str().chars().skip(1).next().is_none()
+    }
+
+    pub fn defrock_brackets(self) -> Self {
+        fn defrock_brackets(s: &str) -> &str {
+            if s.starts_with('(') && s.ends_with(')') {
+                &s[1 .. s.len() - 1]
+            } else {
+                s
+            }
+        }
+
+        match self {
+            ClauseName::BuiltIn(s) =>
+                ClauseName::BuiltIn(defrock_brackets(s)),
+            ClauseName::User(s) =>
+                ClauseName::User(tabled_rc!(defrock_brackets(s.as_str()).to_owned(), s.table))
+        }
+    }
+}
+
+impl AsRef<str> for ClauseName {
+    #[inline]
+    fn as_ref(self: &Self) -> &str {
+        self.as_str()
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum Term {
+    AnonVar,
+    Clause(Cell<RegType>, ClauseName, Vec<Box<Term>>, Option<SharedOpDesc>),
+    Cons(Cell<RegType>, Box<Term>, Box<Term>),
+    Constant(Cell<RegType>, Constant),
+    Var(Cell<VarReg>, Rc<Var>)
+}
+
+impl Term {
+    pub fn shared_op_desc(&self) -> Option<SharedOpDesc> {
+        match self {
+            &Term::Clause(_, _, _, ref spec) => spec.clone(),
+            &Term::Constant(_, Constant::Atom(_, ref spec)) => spec.clone(),
+            _ => None
+        }
+    }
+
+    pub fn to_constant(self) -> Option<Constant> {
+        match self {
+            Term::Constant(_, c) => Some(c),
+            _ => None
+        }
+    }
+
+    pub fn first_arg(&self) -> Option<&Term> {
+        match self {
+            &Term::Clause(_, _, ref terms, _) =>
+                terms.first().map(|bt| bt.as_ref()),
+            _ => None
+        }
+    }
+
+    pub fn set_name(&mut self, new_name: ClauseName) {
+        match self {
+            Term::Constant(_, Constant::Atom(ref mut atom, _))
+          | Term::Clause(_, ref mut atom, ..) => {
+              *atom = new_name;
+            }
+            _ => {}
+        }
+    }
+
+    pub fn name(&self) -> Option<ClauseName> {
+        match self {
+            &Term::Constant(_, Constant::Atom(ref atom, _))
+          | &Term::Clause(_, ref atom, ..) => Some(atom.clone()),
+            _ => None
+        }
+    }
+
+    pub fn arity(&self) -> usize {
+        match self {
+            &Term::Clause(_, _, ref child_terms, ..) => child_terms.len(),
+            _ => 0
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct CompositeOp<'a, 'b> {
+    pub op_dir: &'a OpDir,
+    pub static_op_dir: Option<&'b OpDir>
+}
+
+#[macro_export]
+macro_rules! composite_op {
+    ($include_machine_p:expr, $op_dir:expr, $machine_op_dir:expr) => (
+        CompositeOp { op_dir: $op_dir,
+                      static_op_dir: if !$include_machine_p {
+                          Some($machine_op_dir)
+                      } else {
+                          None
+                      }}
+    );
+    ($op_dir:expr) => (
+        CompositeOp { op_dir: $op_dir, static_op_dir: None }
+    )
+}
+
+impl<'a, 'b> CompositeOp<'a, 'b>
+{
+    #[inline]
+    pub(crate)
+    fn get(&self, name: ClauseName, fixity: Fixity) -> Option<OpDirValue>
+    {
+        let entry =
+            if let Some(ref static_op_dir) = &self.static_op_dir {
+                static_op_dir.get(&(name.clone(), fixity))
+            } else {
+                None
+            };
+
+        entry.or_else(move || self.op_dir.get(&(name, fixity)))
+             .cloned()
+    }
+}
+
+fn unfold_by_str_once(term: &mut Term, s: &str) -> Option<(Term, Term)> {
+    if let &mut Term::Clause(_, ref name, ref mut subterms, _) = term {
+        if name.as_str() == s && subterms.len() == 2 {
+            let snd = *subterms.pop().unwrap();
+            let fst = *subterms.pop().unwrap();
+
+            return Some((fst, snd));
+        }
+    }
+
+    None
+}
+
+pub fn unfold_by_str(mut term: Term, s: &str) -> Vec<Term> {
+    let mut terms = vec![];
+
+    while let Some((fst, snd)) = unfold_by_str_once(&mut term, s) {
+        terms.push(fst);
+        term = snd;
+    }
+
+    terms.push(term);
+    terms
+}
+
+pub type ParsingStream<R> = PutBackN<CodePoints<Bytes<R>>>;
+
+use unicode_reader::BadUtf8Error;
+
+#[inline]
+pub fn parsing_stream<R: Read>(src: R) -> Result<ParsingStream<R>, ParserError> {
+    let mut stream = put_back_n(CodePoints::from(src.bytes()));
+    match stream.peek() {
+        None => Ok(stream), // empty stream is handled gracefully by Lexer::eof
+        Some(Err(error)) => Err(ParserError::from(error)),
+        Some(Ok(c)) => {
+            if *c == '\u{feff}' {
+                // skip UTF-8 BOM
+                stream.next();
+            }
+            Ok(stream)
+        }
+    }
+}

prolog_parser/src/lexer.rs

@@ -0,0 +1,898 @@
+use crate::lexical::parse_lossy;
+use crate::ordered_float::*;
+use crate::rug::Integer;
+
+use ast::*;
+use tabled_rc::*;
+
+use std::convert::TryFrom;
+use std::fmt;
+use std::io::Read;
+use std::rc::Rc;
+
+macro_rules! is_not_eof {
+    ($c:expr) => (
+        match $c {
+            Ok(c) => c,
+            Err(ParserError::UnexpectedEOF) => return Ok(true),
+            Err(e) => return Err(e)
+        }
+    )
+}
+
+macro_rules! consume_chars_with {
+    ($token:expr, $e:expr) => {
+        loop {
+            match $e {
+                Ok(Some(c)) => $token.push(c),
+                Ok(None) => continue,
+                Err(ParserError::UnexpectedChar(..)) => break,
+                Err(e) => return Err(e)
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Token {
+    Constant(Constant),
+    Var(Rc<Atom>),
+    Open,           // '('
+    OpenCT,         // '('
+    Close,          // ')'
+    OpenList,       // '['
+    CloseList,      // ']'
+    OpenCurly,      // '{'
+    CloseCurly,     // '}'
+    HeadTailSeparator, // '|'
+    Comma,          // ','
+    End
+}
+
+pub struct Lexer<'a, R: Read> {
+    pub(crate) atom_tbl: TabledData<Atom>,
+    pub(crate) reader: &'a mut ParsingStream<R>,
+    pub(crate) flags: MachineFlags,
+    pub(crate) line_num: usize,
+    pub(crate) col_num: usize
+}
+
+impl<'a, R: Read + fmt::Debug> fmt::Debug for Lexer<'a, R> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Lexer")
+         .field("atom_tbl", &self.atom_tbl)
+         .field("reader", &"&'a mut ParsingStream<R>")  // Hacky solution.
+         .field("line_num", &self.line_num)
+         .field("col_num", &self.col_num)
+         .finish()
+    }
+}
+
+impl<'a, R: Read> Lexer<'a, R> {
+    pub fn new(
+        atom_tbl: TabledData<Atom>,
+        flags: MachineFlags,
+        src: &'a mut ParsingStream<R>,
+    ) -> Self {
+        Lexer { atom_tbl, flags, reader: src, line_num: 0, col_num: 0 }
+    }
+
+    fn return_char(&mut self, c: char) {
+        if new_line_char!(c) {
+            self.line_num -= 1;
+            self.col_num = 0;
+        }
+
+        self.reader.put_back(Ok(c));
+    }
+
+    fn skip_char(&mut self) -> Result<char, ParserError> {
+        if let Some(Ok(c)) = self.reader.next() {
+            self.col_num += 1;
+
+            if new_line_char!(c) {
+                self.line_num += 1;
+                self.col_num = 0;
+            }
+
+            Ok(c)
+        } else {
+            Err(ParserError::UnexpectedEOF)
+        }
+    }
+
+    pub fn eof(&mut self) -> Result<bool, ParserError> {
+        if self.reader.peek().is_none() {
+            return Ok(true);
+        }
+
+        let mut c = is_not_eof!(self.lookahead_char());
+
+        while layout_char!(c) {
+            self.skip_char()?;
+
+            if self.reader.peek().is_none() {
+                return Ok(true);
+            }
+
+            c = is_not_eof!(self.lookahead_char());
+        }
+
+        Ok(false)
+    }
+
+    pub fn lookahead_char(&mut self) -> Result<char, ParserError> {
+        match self.reader.peek() {
+            Some(&Ok(c)) => Ok(c),
+            _ => Err(ParserError::UnexpectedEOF),
+        }
+    }
+
+    fn single_line_comment(&mut self) -> Result<(), ParserError>
+    {
+        loop {
+            if self.reader.peek().is_none() || new_line_char!(self.skip_char()?) {
+                break;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn bracketed_comment(&mut self) -> Result<bool, ParserError> {
+        // we have already checked that the current lookahead_char is comment_1_char, just skip it
+        let c = self.skip_char()?;
+
+        if comment_2_char!(self.lookahead_char()?) {
+            self.skip_char()?;
+
+            // Keep reading until we find characters '*' and '/'
+            // Deliberately skip checks for prolog_char to allow comments to contain any characters,
+            // including so-called "extended characters", without having to explicitly add them to a character class.
+            let mut c = self.lookahead_char()?;
+            loop {
+                while !comment_2_char!(c) {
+                    self.skip_char()?;
+                    c = self.lookahead_char()?;
+                }
+
+                self.skip_char()?;
+
+                c = self.lookahead_char()?;
+                if comment_1_char!(c) {
+                    break;
+                }
+            }
+
+            if prolog_char!(c) {
+                self.skip_char()?;
+                Ok(true)
+            } else {
+                Err(ParserError::NonPrologChar(self.line_num, self.col_num))
+            }
+        } else {
+            self.return_char(c);
+            Ok(false)
+        }
+    }
+
+    fn get_back_quoted_char(&mut self) -> Result<char, ParserError> {
+        if back_quote_char!(self.lookahead_char()?) {
+            let c = self.skip_char()?;
+
+            if !back_quote_char!(self.lookahead_char()?) {
+                self.return_char(c);
+                Err(ParserError::UnexpectedChar(c, self.line_num, self.col_num))
+            } else {
+                self.skip_char()
+            }
+        } else if single_quote_char!(self.lookahead_char()?) {
+            self.skip_char()
+        } else {
+            self.get_non_quote_char()
+        }
+    }
+
+    fn get_back_quoted_item(&mut self) -> Result<Option<char>, ParserError> {
+        if backslash_char!(self.lookahead_char()?) {
+            let c = self.skip_char()?;
+
+            if new_line_char!(self.lookahead_char()?) {
+                self.skip_char()?;
+                Ok(None)
+            } else {
+                self.return_char(c);
+                Err(ParserError::UnexpectedChar(c, self.line_num, self.col_num))
+            }
+        } else {
+            self.get_back_quoted_char().map(Some)
+        }
+    }
+
+    fn get_back_quoted_string(&mut self) -> Result<String, ParserError> {
+        let c = self.lookahead_char()?;
+
+        if back_quote_char!(c) {
+            self.skip_char()?;
+
+            let mut token = String::new();
+            consume_chars_with!(token, self.get_back_quoted_item());
+
+            if back_quote_char!(self.lookahead_char()?) {
+                self.skip_char()?;
+                Ok(token)
+            } else {
+                Err(ParserError::MissingQuote(self.line_num, self.col_num))
+            }
+        } else {
+            Err(ParserError::UnexpectedChar(c, self.line_num, self.col_num))
+        }
+    }
+
+    fn get_single_quoted_item(&mut self) -> Result<Option<char>, ParserError>
+    {
+        if backslash_char!(self.lookahead_char()?) {
+            let c = self.skip_char()?;
+
+            if new_line_char!(self.lookahead_char()?) {
+                self.skip_char()?;
+                return Ok(None);
+            } else {
+                self.return_char(c);
+            }
+        }
+
+        self.get_single_quoted_char().map(Some)
+    }
+
+    fn get_single_quoted_char(&mut self) -> Result<char, ParserError> {
+        let c = self.lookahead_char()?;
+
+        if single_quote_char!(c) {
+            self.skip_char()?;
+
+            if !single_quote_char!(self.lookahead_char()?) {
+                self.return_char(c);
+                Err(ParserError::UnexpectedChar(c, self.line_num, self.col_num))
+            } else {
+                self.skip_char()
+            }
+        } else if double_quote_char!(c) || back_quote_char!(c) {
+            self.skip_char()
+        } else {
+            self.get_non_quote_char()
+        }
+    }
+
+    fn get_double_quoted_item(&mut self) -> Result<Option<char>, ParserError>
+    {
+        if backslash_char!(self.lookahead_char()?) {
+            let c = self.skip_char()?;
+
+            if new_line_char!(self.lookahead_char()?) {
+                self.skip_char()?;
+                return Ok(None)
+            } else {
+                self.return_char(c);
+            }
+        }
+
+        self.get_double_quoted_char().map(Some)
+    }
+
+    fn get_double_quoted_char(&mut self) -> Result<char, ParserError> {
+        if double_quote_char!(self.lookahead_char()?) {
+            let c = self.skip_char()?;
+
+            if !double_quote_char!(self.lookahead_char()?) {
+                self.return_char(c);
+                Err(ParserError::UnexpectedChar(c, self.line_num, self.col_num))
+            } else {
+                self.skip_char()
+            }
+        } else if single_quote_char!(self.lookahead_char()?) {
+            self.skip_char()
+        } else if back_quote_char!(self.lookahead_char()?) {
+            self.skip_char()
+        } else {
+            self.get_non_quote_char()
+        }
+    }
+
+    fn get_control_escape_sequence(&mut self) -> Result<char, ParserError>
+    {
+        let escaped = match self.lookahead_char()? {
+            'a' => '\u{07}', // UTF-8 alert
+            'b' => '\u{08}', // UTF-8 backspace
+            'v' => '\u{0b}', // UTF-8 vertical tab
+            'f' => '\u{0c}', // UTF-8 form feed
+            't' => '\t',
+            'n' => '\n',
+            'r' => '\r',
+            c   => return Err(ParserError::UnexpectedChar(c, self.line_num, self.col_num))
+        };
+
+        self.skip_char()?;
+        return Ok(escaped);
+    }
+
+    fn get_octal_escape_sequence(&mut self) -> Result<char, ParserError>
+    {
+        self.escape_sequence_to_char(|c| octal_digit_char!(c), 8)
+    }
+
+    fn get_hexadecimal_escape_sequence(&mut self) -> Result<char, ParserError>
+    {
+        self.skip_char()?;
+        let c = self.lookahead_char()?;
+
+        if hexadecimal_digit_char!(c) {
+            self.escape_sequence_to_char(|c| hexadecimal_digit_char!(c), 16)
+        } else {
+            Err(ParserError::UnexpectedChar(c, self.line_num, self.col_num))
+        }
+    }
+
+    fn escape_sequence_to_char(
+        &mut self,
+        accept_char: impl Fn(char) -> bool,
+        radix: u32,
+    ) -> Result<char, ParserError> {
+        let mut c = self.lookahead_char()?;
+        let mut token = String::new();
+
+        loop {
+            token.push(c);
+
+            self.skip_char()?;
+            c = self.lookahead_char()?;
+
+            if !accept_char(c) {
+                break;
+            }
+        }
+
+        if backslash_char!(c) {
+            self.skip_char()?;
+            u32::from_str_radix(&token, radix)
+                .map_or_else(
+                    |_| Err(ParserError::ParseBigInt(self.line_num, self.col_num)),
+                    |n| char::try_from(n)
+                        .map_err(|_| ParserError::Utf8Error(self.line_num, self.col_num))
+                )
+        } else {
+            // on failure, restore the token characters and backslash.
+            self.reader.put_back_all(token.chars().map(Ok));
+            self.reader.put_back(Ok('\\'));
+
+            Err(ParserError::UnexpectedChar(c, self.line_num, self.col_num))
+        }
+    }
+
+    fn get_non_quote_char(&mut self) -> Result<char, ParserError> {
+        let c = self.lookahead_char()?;
+
+        if graphic_char!(c) || alpha_numeric_char!(c) || solo_char!(c) || space_char!(c) {
+            self.skip_char()
+        } else {
+            if !backslash_char!(c) {
+                return Err(ParserError::UnexpectedChar(c, self.line_num, self.col_num));
+            }
+
+            self.skip_char()?;
+
+            let c = self.lookahead_char()?;
+
+            if meta_char!(c) {
+                self.skip_char()
+            } else if octal_digit_char!(c) {
+                self.get_octal_escape_sequence()
+            } else if symbolic_hexadecimal_char!(c) {
+                self.get_hexadecimal_escape_sequence()
+            } else {
+                self.get_control_escape_sequence()
+            }
+        }
+    }
+
+    fn char_code_list_token(&mut self) -> Result<String, ParserError> {
+        let mut token = String::new();
+
+        self.skip_char()?;
+        consume_chars_with!(token, self.get_double_quoted_item());
+
+        if double_quote_char!(self.lookahead_char()?) {
+            self.skip_char()?;
+            Ok(token)
+        } else {
+            Err(ParserError::MissingQuote(self.line_num, self.col_num))
+        }
+    }
+
+    fn hexadecimal_constant(&mut self) -> Result<Token, ParserError> {
+        self.skip_char()?;
+
+        if hexadecimal_digit_char!(self.lookahead_char()?) {
+            let mut token = String::new();
+
+            while hexadecimal_digit_char!(self.lookahead_char()?) {
+                token.push(self.skip_char()?);
+            }
+
+            isize::from_str_radix(&token, 16)
+                .map(|n| Token::Constant(Constant::Fixnum(n)))
+                .or_else(|_| {
+                    Integer::from_str_radix(&token, 16)
+                         .map(|n| Token::Constant(Constant::Integer(Rc::new(n))))
+                         .map_err(|_| ParserError::ParseBigInt(
+                             self.line_num,
+                             self.col_num,
+                         ))
+                })
+        } else {
+            self.return_char('x');
+            Err(ParserError::ParseBigInt(self.line_num, self.col_num))
+        }
+    }
+
+    fn octal_constant(&mut self) -> Result<Token, ParserError> {
+        self.skip_char()?;
+
+        if octal_digit_char!(self.lookahead_char()?) {
+            let mut token = String::new();
+
+            while octal_digit_char!(self.lookahead_char()?) {
+                token.push(self.skip_char()?);
+            }
+
+            isize::from_str_radix(&token, 8)
+                .map(|n| Token::Constant(Constant::Fixnum(n)))
+                .or_else(|_| {
+                    Integer::from_str_radix(&token, 8)
+                         .map(|n| Token::Constant(Constant::Integer(Rc::new(n))))
+                         .map_err(|_| ParserError::ParseBigInt(
+                             self.line_num,
+                             self.col_num,
+                         ))
+                })
+        } else {
+            self.return_char('o');
+            Err(ParserError::ParseBigInt(self.line_num, self.col_num))
+        }
+    }
+
+    fn binary_constant(&mut self) -> Result<Token, ParserError> {
+        self.skip_char()?;
+
+        if binary_digit_char!(self.lookahead_char()?) {
+            let mut token = String::new();
+
+            while binary_digit_char!(self.lookahead_char()?) {
+                token.push(self.skip_char()?);
+            }
+
+            isize::from_str_radix(&token, 2)
+                .map(|n| Token::Constant(Constant::Fixnum(n)))
+                .or_else(|_| {
+                    Integer::from_str_radix(&token, 2)
+                         .map(|n| Token::Constant(Constant::Integer(Rc::new(n))))
+                         .map_err(|_| ParserError::ParseBigInt(
+                             self.line_num,
+                             self.col_num,
+                         ))
+                })
+        } else {
+            self.return_char('b');
+            Err(ParserError::ParseBigInt(self.line_num, self.col_num))
+        }
+    }
+
+    fn variable_token(&mut self) -> Result<Token, ParserError> {
+        let mut s = String::new();
+        s.push(self.skip_char()?);
+
+        while alpha_numeric_char!(self.lookahead_char()?) {
+            s.push(self.skip_char()?);
+        }
+
+        Ok(Token::Var(rc_atom!(s)))
+    }
+
+    fn name_token(&mut self, c: char) -> Result<Token, ParserError> {
+        let mut token = String::new();
+
+        if small_letter_char!(c) {
+            token.push(self.skip_char()?);
+
+            while alpha_numeric_char!(self.lookahead_char()?) {
+                token.push(self.skip_char()?);
+            }
+        } else if graphic_token_char!(c) {
+            token.push(self.skip_char()?);
+
+            while graphic_token_char!(self.lookahead_char()?) {
+                token.push(self.skip_char()?);
+            }
+        } else if cut_char!(c) {
+            token.push(self.skip_char()?);
+        } else if semicolon_char!(c) {
+            token.push(self.skip_char()?);
+        } else if single_quote_char!(c) {
+            self.skip_char()?;
+
+            consume_chars_with!(token, self.get_single_quoted_item());
+
+            if single_quote_char!(self.lookahead_char()?) {
+                self.skip_char()?;
+
+                if !token.is_empty() && token.chars().skip(1).next().is_none() {
+                    if let Some(c) = token.chars().next() {
+                        return Ok(Token::Constant(Constant::Char(c)));
+                    }
+                }
+            } else {
+                return Err(ParserError::InvalidSingleQuotedCharacter(self.lookahead_char()?))
+            }
+        } else {
+            match self.get_back_quoted_string() {
+                Ok(_)  => return Err(ParserError::BackQuotedString(self.line_num, self.col_num)),
+                Err(e) => return Err(e)
+            }
+        }
+
+        if token.as_str() == "[]" {
+            Ok(Token::Constant(Constant::EmptyList))
+        } else {
+            Ok(Token::Constant(atom!(token, self.atom_tbl)))
+        }
+    }
+
+    fn vacate_with_float(&mut self, mut token: String) -> Token {
+        self.return_char(token.pop().unwrap());
+
+        let result = OrderedFloat(parse_lossy::<f64, _>(token.as_bytes()));
+        Token::Constant(Constant::Float(result))
+    }
+
+    pub fn number_token(&mut self) -> Result<Token, ParserError> {
+        let mut token = String::new();
+
+        token.push(self.skip_char()?);
+        let mut c = self.lookahead_char()?;
+
+        while decimal_digit_char!(c) {
+            token.push(c);
+            self.skip_char()?;
+            c = self.lookahead_char()?;
+        }
+
+        if decimal_point_char!(c) {
+            self.skip_char()?;
+
+            if self.reader.peek().is_none() {
+                self.return_char('.');
+
+                isize::from_str_radix(&token, 10)
+                    .map(|n| Token::Constant(Constant::Fixnum(n)))
+                    .or_else(|_| {
+                        token.parse::<Integer>()
+                             .map(|n| Token::Constant(Constant::Integer(Rc::new(n))))
+                             .map_err(|_| ParserError::ParseBigInt(
+                                 self.line_num,
+                                 self.col_num,
+                             ))
+                    })
+            } else if decimal_digit_char!(self.lookahead_char()?) {
+                token.push('.');
+                token.push(self.skip_char()?);
+
+                let mut c = self.lookahead_char()?;
+
+                while decimal_digit_char!(c) {
+                    token.push(c);
+                    self.skip_char()?;
+                    c = self.lookahead_char()?;
+                }
+
+                if exponent_char!(self.lookahead_char()?) {
+                    token.push(self.skip_char()?);
+
+                    let c = match self.lookahead_char() {
+                        Err(_) => return Ok(self.vacate_with_float(token)),
+                        Ok(c) => c
+                    };
+
+                    if !sign_char!(c) && !decimal_digit_char!(c) {
+                        return Ok(self.vacate_with_float(token));
+                    }
+
+                    if sign_char!(c) {
+                        token.push(self.skip_char()?);
+
+                        let c = match self.lookahead_char() {
+                            Err(_) => {
+                                self.return_char(token.pop().unwrap());
+                                return Ok(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));
+                        }
+                    }
+
+                    if decimal_digit_char!(self.lookahead_char()?) {
+                        token.push(self.skip_char()?);
+
+                        while decimal_digit_char!(self.lookahead_char()?) {
+                            token.push(self.skip_char()?);
+                        }
+
+                        let n = OrderedFloat(parse_lossy::<f64, _>(token.as_bytes()));
+                        Ok(Token::Constant(Constant::Float(n)))
+                    } else {
+                        return Ok(self.vacate_with_float(token));
+                    }
+                } else {
+                    let n = OrderedFloat(parse_lossy::<f64, _>(token.as_bytes()));
+                    Ok(Token::Constant(Constant::Float(n)))
+                }
+            } else {
+                self.return_char('.');
+
+                isize::from_str_radix(&token, 10)
+                    .map(|n| Token::Constant(Constant::Fixnum(n)))
+                    .or_else(|_| {
+                        token.parse::<Integer>()
+                             .map(|n| Token::Constant(Constant::Integer(Rc::new(n))))
+                             .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()
+                        .or_else(|e| {
+                            if let ParserError::ParseBigInt(..) = e {
+                                isize::from_str_radix(&token, 10)
+                                    .map(|n| Token::Constant(Constant::Fixnum(n)))
+                                    .or_else(|_| {
+                                        token.parse::<Integer>()
+                                             .map(|n| Token::Constant(Constant::Integer(Rc::new(n))))
+                                             .map_err(|_| ParserError::ParseBigInt(
+                                                 self.line_num,
+                                                 self.col_num,
+                                             ))
+                                    })
+                            } else {
+                                Err(e)
+                            }
+                        })
+                } else if c == 'o' {
+                    self.octal_constant()
+                        .or_else(|e| {
+                            if let ParserError::ParseBigInt(..) = e {
+                                isize::from_str_radix(&token, 10)
+                                    .map(|n| Token::Constant(Constant::Fixnum(n)))
+                                    .or_else(|_| {
+                                        token.parse::<Integer>()
+                                            .map(|n| Token::Constant(Constant::Integer(Rc::new(n))))
+                                            .map_err(|_| ParserError::ParseBigInt(
+                                                self.line_num,
+                                                self.col_num,
+                                            ))
+                                    })
+                            } else {
+                                Err(e)
+                            }
+                        })
+                } else if c == 'b' {
+                    self.binary_constant()
+                        .or_else(|e| {
+                            if let ParserError::ParseBigInt(..) = e {
+                                isize::from_str_radix(&token, 10)
+                                    .map(|n| Token::Constant(Constant::Fixnum(n)))
+                                    .or_else(|_| {
+                                        token.parse::<Integer>()
+                                             .map(|n| Token::Constant(Constant::Integer(Rc::new(n))))
+                                             .map_err(|_| ParserError::ParseBigInt(
+                                                 self.line_num,
+                                                 self.col_num,
+                                             ))
+                                    })
+                            } else {
+                                Err(e)
+                            }
+                        })
+                } else if single_quote_char!(c) {
+                    self.skip_char()?;
+
+                    if backslash_char!(self.lookahead_char()?) {
+                        self.skip_char()?;
+
+                        if new_line_char!(self.lookahead_char()?) {
+                            self.return_char('\\');
+                            self.return_char('\'');
+
+                            return Ok(Token::Constant(Constant::Fixnum(0)));
+                        } else {
+                            self.return_char('\\');
+                        }
+                    }
+
+                    self.get_single_quoted_char()
+                        .and_then(|c| {
+                            Ok(Token::Constant(Constant::Fixnum(c as isize)))
+                        })
+                        .or_else(|_| {
+                            self.return_char(c);
+
+                            isize::from_str_radix(&token, 10)
+                                .map(|n| Token::Constant(Constant::Fixnum(n)))
+                                .or_else(|_| {
+                                    token.parse::<Integer>()
+                                         .map(|n| Token::Constant(Constant::Integer(Rc::new(n))))
+                                         .map_err(|_| ParserError::ParseBigInt(
+                                             self.line_num,
+                                             self.col_num,
+                                         ))
+                                })
+                        })
+                } else {
+                    isize::from_str_radix(&token, 10)
+                        .map(|n| Token::Constant(Constant::Fixnum(n)))
+                        .or_else(|_| {
+                            token.parse::<Integer>()
+                                 .map(|n| Token::Constant(Constant::Integer(Rc::new(n))))
+                                 .map_err(|_| ParserError::ParseBigInt(
+                                     self.line_num,
+                                     self.col_num,
+                                 ))
+                        })
+                }
+            } else {
+                isize::from_str_radix(&token, 10)
+                    .map(|n| Token::Constant(Constant::Fixnum(n)))
+                    .or_else(|_| {
+                        token.parse::<Integer>()
+                             .map(|n| Token::Constant(Constant::Integer(Rc::new(n))))
+                             .map_err(|_| ParserError::ParseBigInt(
+                                 self.line_num,
+                                 self.col_num,
+                             ))
+                    })
+            }
+        }
+    }
+
+    pub fn scan_for_layout(&mut self) -> Result<bool, ParserError> {
+        let mut layout_inserted = false;
+        let mut more_layout = true;
+
+        loop {
+            let cr = self.lookahead_char();
+
+            match cr {
+                Ok(c) if layout_char!(c) || new_line_char!(c) => {
+                    self.skip_char()?;
+                    layout_inserted = true;
+                },
+                Ok(c) if end_line_comment_char!(c) => {
+                    self.single_line_comment()?;
+                    layout_inserted = true;
+                },
+                Ok(c) if comment_1_char!(c) =>
+                    if self.bracketed_comment()? {
+                        layout_inserted = true;
+                    } else {
+                        more_layout = false;
+                    },
+                _ => more_layout = false
+            };
+
+            if !more_layout {
+                break;
+            }
+        }
+
+        Ok(layout_inserted)
+    }
+
+    pub fn next_token(&mut self) -> Result<Token, ParserError> {
+        let layout_inserted = self.scan_for_layout()?;
+        let cr = self.lookahead_char();
+
+        match cr {
+            Ok(c) => {
+                if capital_letter_char!(c) || variable_indicator_char!(c) {
+                    return self.variable_token();
+                }
+
+                if c == ',' {
+                    self.skip_char()?;
+                    return Ok(Token::Comma);
+                }
+
+                if c == ')' {
+                    self.skip_char()?;
+                    return Ok(Token::Close);
+                }
+
+                if c == '(' {
+                    self.skip_char()?;
+                    return Ok(if layout_inserted { Token::Open }
+                              else { Token::OpenCT });
+                }
+
+                if c == '.' {
+                    self.skip_char()?;
+
+                    match self.lookahead_char() {
+                        Ok(c) if layout_char!(c) || c == '%' => {
+                            if new_line_char!(c) {
+                                self.skip_char()?;
+                            }
+
+                            return Ok(Token::End);
+                        },
+                        Err(ParserError::UnexpectedEOF) => {
+                            return Ok(Token::End);
+                        }
+                        _ => {
+                            self.return_char('.');
+                        }
+                    };
+                }
+
+                if decimal_digit_char!(c) {
+                    return self.number_token();
+                }
+
+                if c == ']' {
+                    self.skip_char()?;
+                    return Ok(Token::CloseList);
+                }
+
+                if c == '[' {
+                    self.skip_char()?;
+                    return Ok(Token::OpenList);
+                }
+
+                if c == '|' {
+                    self.skip_char()?;
+                    return Ok(Token::HeadTailSeparator);
+                }
+
+                if c == '{' {
+                    self.skip_char()?;
+                    return Ok(Token::OpenCurly);
+                }
+
+                if c == '}' {
+                    self.skip_char()?;
+                    return Ok(Token::CloseCurly);
+                }
+
+                if c == '"' {
+                    let s = self.char_code_list_token()?;
+
+                    if let DoubleQuotes::Atom = self.flags.double_quotes {
+                        let s = clause_name!(s, self.atom_tbl);
+                        return Ok(Token::Constant(Constant::Atom(s, None)));
+                    } else {
+                        let s = Rc::new(s);
+                        return Ok(Token::Constant(Constant::String(s)));
+                    }
+                }
+
+                self.name_token(c)
+            },
+            Err(e) => Err(e)
+        }
+    }
+}

prolog_parser/src/lib.rs

@@ -0,0 +1,15 @@
+extern crate lexical;
+extern crate ordered_float;
+#[cfg(feature = "rug")]
+extern crate rug;
+#[cfg(feature = "num-rug-adapter")]
+extern crate num_rug_adapter as rug;
+extern crate unicode_reader;
+
+#[macro_use] pub mod tabled_rc;
+#[macro_use] pub mod ast;
+#[macro_use] pub mod macros;
+pub mod parser;
+pub mod put_back_n;
+
+pub mod lexer;

prolog_parser/src/macros.rs

@@ -0,0 +1,187 @@
+#[macro_export]
+macro_rules! char_class {
+    ($c: expr, [$head:expr]) => ($c == $head);
+    ($c: expr, [$head:expr $(, $cs:expr)+]) => ($c == $head || char_class!($c, [$($cs),*]));
+}
+
+#[macro_export]
+macro_rules! symbolic_control_char {
+    ($c: expr) => (char_class!($c, ['a', 'b', 'f', 'n', 'r', 't', 'v', '0']))
+}
+
+#[macro_export]
+macro_rules! space_char {
+    ($c: expr) => ($c == ' ')
+}
+
+#[macro_export]
+macro_rules! layout_char {
+    ($c: expr) => (char_class!($c, [' ', '\n', '\t', '\u{0B}', '\u{0C}']))
+}
+
+#[macro_export]
+macro_rules! symbolic_hexadecimal_char {
+    ($c: expr) => ($c == 'x')
+}
+
+#[macro_export]
+macro_rules! octal_digit_char {
+    ($c: expr) => ($c >= '0' && $c <= '7')
+}
+
+#[macro_export]
+macro_rules! binary_digit_char {
+    ($c: expr) => ($c >= '0' && $c <= '1')
+}
+
+#[macro_export]
+macro_rules! hexadecimal_digit_char {
+    ($c: expr) => ($c >= '0' && $c <= '9' ||
+                   $c >= 'A' && $c <= 'F' ||
+                   $c >= 'a' && $c <= 'f')
+}
+
+#[macro_export]
+macro_rules! exponent_char {
+    ($c: expr) => ($c == 'e' || $c == 'E')
+}
+
+#[macro_export]
+macro_rules! sign_char {
+    ($c: expr) => ($c == '-' || $c == '+')
+}
+
+#[macro_export]
+macro_rules! new_line_char {
+    ($c: expr) => ($c == '\n')
+}
+
+#[macro_export]
+macro_rules! end_line_comment_char {
+    ($c: expr) => ($c == '%')
+}
+
+#[macro_export]
+macro_rules! comment_1_char {
+    ($c: expr) => ($c == '/')
+}
+
+#[macro_export]
+macro_rules! comment_2_char {
+    ($c: expr) => ($c == '*')
+}
+
+#[macro_export]
+macro_rules! capital_letter_char {
+    ($c: expr) => ($c >= 'A' && $c <= 'Z')
+}
+
+#[macro_export]
+macro_rules! small_letter_char {
+    ($c: expr) => ($c >= 'a' && $c <= 'z')
+}
+
+#[macro_export]
+macro_rules! variable_indicator_char {
+    ($c: expr) => ($c == '_')
+}
+
+#[macro_export]
+macro_rules! graphic_char {
+    ($c: expr) => (char_class!($c, ['#', '$', '&', '*', '+', '-', '.', '/', ':',
+                                    '<', '=', '>', '?', '@', '^', '~']))
+}
+
+#[macro_export]
+macro_rules! graphic_token_char {
+    ($c: expr) => (graphic_char!($c) || backslash_char!($c))
+}
+
+#[macro_export]
+macro_rules! alpha_char {
+    ($c: expr) =>
+        (match $c {
+            'a' ..= 'z' => true,
+            'A' ..= 'Z' => true,
+            '_' => true,
+            '\u{00A0}' ..= '\u{00BF}' => true,
+            '\u{00C0}' ..= '\u{00D6}' => true,
+            '\u{00D8}' ..= '\u{00F6}' => true,
+            '\u{00F8}' ..= '\u{00FF}' => true,
+            '\u{0100}' ..= '\u{017F}' => true, // Latin Extended-A
+            '\u{0180}' ..= '\u{024F}' => true, // Latin Extended-B
+            '\u{0250}' ..= '\u{02AF}' => true, // IPA Extensions
+            '\u{02B0}' ..= '\u{02FF}' => true, // Spacing Modifier Letters
+            '\u{0300}' ..= '\u{036F}' => true, // Combining Diacritical Marks
+            '\u{0370}' ..= '\u{03FF}' => true, // Greek/Coptic
+            '\u{0400}' ..= '\u{04FF}' => true, // Cyrillic
+            '\u{0500}' ..= '\u{052F}' => true, // Cyrillic Supplement
+            '\u{0530}' ..= '\u{058F}' => true, // Armenian
+            '\u{0590}' ..= '\u{05FF}' => true, // Hebrew
+            '\u{0600}' ..= '\u{06FF}' => true, // Arabic
+            '\u{0700}' ..= '\u{074F}' => true, // Syriac
+            _ => false
+        })
+}
+
+#[macro_export]
+macro_rules! decimal_digit_char {
+    ($c: expr) => ($c >= '0' && $c <= '9')
+}
+
+#[macro_export]
+macro_rules! decimal_point_char {
+    ($c: expr) => ($c == '.')
+}
+
+#[macro_export]
+macro_rules! alpha_numeric_char {
+    ($c: expr) => (alpha_char!($c) || decimal_digit_char!($c))
+}
+
+#[macro_export]
+macro_rules! cut_char {
+    ($c: expr) => ($c == '!')
+}
+
+#[macro_export]
+macro_rules! semicolon_char {
+    ($c: expr) => ($c == ';')
+}
+
+#[macro_export]
+macro_rules! backslash_char {
+    ($c: expr) => ($c == '\\')
+}
+
+#[macro_export]
+macro_rules! single_quote_char {
+    ($c: expr) => ($c == '\'')
+}
+
+#[macro_export]
+macro_rules! double_quote_char {
+    ($c: expr) => ($c == '"')
+}
+
+#[macro_export]
+macro_rules! back_quote_char {
+    ($c: expr) => ($c == '`')
+}
+
+#[macro_export]
+macro_rules! meta_char {
+    ($c: expr) => ( char_class!($c, ['\\', '\'', '"', '`']) )
+}
+
+#[macro_export]
+macro_rules! solo_char {
+    ($c: expr) => ( char_class!($c, ['!', '(', ')', ',', ';', '[', ']',
+                                     '{', '}', '|', '%']) )
+}
+
+#[macro_export]
+macro_rules! prolog_char {
+    ($c: expr) => (graphic_char!($c) || alpha_numeric_char!($c) || solo_char!($c) ||
+                   layout_char!($c) || meta_char!($c))
+}

prolog_parser/src/parser.rs

@@ -0,0 +1,983 @@
+use ast::*;
+use lexer::*;
+use tabled_rc::*;
+
+use ordered_float::OrderedFloat;
+
+use 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 {
+        match self {
+            TokenType::HeadTailSeparator | TokenType::OpenCT | TokenType::Open |
+            TokenType::Close | TokenType::OpenList | TokenType::CloseList |
+            TokenType::OpenCurly | TokenType::CloseCurly | TokenType::Comma
+                => true,
+            _   => false
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+struct TokenDesc {
+    tt: TokenType,
+    priority: usize,
+    spec: u32
+}
+
+pub
+fn get_clause_spec(name: ClauseName, arity: usize, op_dir: CompositeOp) -> 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);
+            }
+
+            if let Some(OpDirValue(cell, _)) = op_dir.get(name, Fixity::Post) {
+                return Some(cell);
+            }
+        },
+        2 =>
+            if let Some(OpDirValue(cell, _)) = op_dir.get(name, Fixity::In) {
+                return Some(cell);
+            },
+        _ => {}
+    };
+
+    None
+}
+
+pub fn get_desc(name: ClauseName, op_dir: CompositeOp) -> 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<'a, R: Read>(lexer: &mut Lexer<'a, R>) -> Result<Vec<Token>, ParserError>
+{
+    let mut tokens = vec![];
+
+    loop {
+        let token = lexer.next_token()?;
+        let at_end = Token::End == token;
+
+        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: CompositeOp) -> 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;
+                }
+            }
+
+            if arity >= 2 && is_prefix!(self.stack[idx].spec) && self.stack[idx].priority > 0 {
+                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(|t| Box::new(t))
+                    .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;
+
+        match self.stack.remove(idx) {
+            td =>
+                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: CompositeOp) -> Result<bool, ParserError> {
+        if let Some(OpDesc { pre, inf, post, spec }) = get_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: CompositeOp) -> Result<(), ParserError> {
+        fn negate_rc<T: NegAssign>(mut t: Rc<T>) -> Rc<T> {
+            match Rc::get_mut(&mut t) {
+                Some(t) => {
+                    t.neg_assign();
+                }
+                None => {
+                }
+            };
+
+            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()),
+                    |n| Constant::Float(n)
+                ),
+            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_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()
+    }
+
+    pub fn read_term(&mut self, op_dir: CompositeOp) -> 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))
+        }
+    }
+
+    pub fn read(&mut self, op_dir: CompositeOp) -> Result<Vec<Term>, ParserError>
+    {
+        let mut terms = Vec::new();
+
+        loop {
+            terms.push(self.read_term(op_dir)?);
+
+            if self.lexer.eof()? {
+                break;
+            }
+        }
+
+        Ok(terms)
+    }
+}

prolog_parser/src/put_back_n.rs

@@ -0,0 +1,71 @@
+use std::iter::Peekable;
+
+#[derive(Debug, Clone)]
+pub struct PutBackN<I: Iterator> {
+    top: Vec<I::Item>,
+    iter: Peekable<I>,
+}
+
+pub fn put_back_n<I>(iterable: I) -> PutBackN<I::IntoIter>
+    where I: IntoIterator
+{
+    PutBackN {
+        top: Vec::new(),
+        iter: iterable.into_iter().peekable(),
+    }
+}
+
+impl<I: Iterator> PutBackN<I> {
+    #[inline]
+    pub(crate)
+    fn put_back(&mut self, item: I::Item) {
+        self.top.push(item);
+    }
+
+    #[inline]
+    pub fn take_buf(&mut self) -> Vec<I::Item> {
+        std::mem::replace(&mut self.top, vec![])
+    }
+
+    #[inline]
+    pub(crate)
+    fn peek(&mut self) -> Option<&I::Item> {
+        if self.top.is_empty() {
+            /* This is a kludge for Ctrl-D not being
+             * handled properly if self.iter().peek() isn't called
+             * first. */
+            match self.iter.peek() {
+                Some(_) => {
+                    self.iter.next().and_then(move |item| {
+                        self.top.push(item);
+                        self.top.last()
+                    })
+                }
+                None => {
+                    None
+                }
+            }
+        } else {
+            self.top.last()
+        }
+    }
+
+    #[inline]
+    pub(crate)
+    fn put_back_all<DEI: DoubleEndedIterator<Item = I::Item>>(&mut self, iter: DEI) {
+        self.top.extend(iter.rev());
+    }
+}
+
+impl<I: Iterator> Iterator for PutBackN<I> {
+    type Item = I::Item;
+
+    #[inline]
+    fn next(&mut self) -> Option<I::Item> {
+        if self.top.is_empty() {
+            self.iter.next()
+        } else {
+            self.top.pop()
+        }
+    }
+}

prolog_parser/src/tabled_rc.rs

@@ -0,0 +1,153 @@
+use std::cell::{RefCell, RefMut};
+use std::cmp::Ordering;
+use std::collections::HashSet;
+use std::fmt;
+use std::hash::{Hash, Hasher};
+use std::ops::Deref;
+use std::rc::{Rc};
+
+pub struct TabledData<T> {
+    table: Rc<RefCell<HashSet<Rc<T>>>>,
+    pub(crate) module_name: Rc<String>
+}
+
+impl<T: Hash + Eq + fmt::Debug> fmt::Debug for TabledData<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TabledData")
+            .field("table", &self.table)
+            .field("module_name", &self.table)
+            .finish()
+    }
+}
+
+impl<T> Clone for TabledData<T> {
+    fn clone(&self) -> Self {
+        TabledData { table: self.table.clone(),
+                     module_name: self.module_name.clone() }
+    }
+}
+
+impl<T: PartialEq> PartialEq for TabledData<T> {
+    fn eq(&self, other: &TabledData<T>) -> bool
+    {
+        Rc::ptr_eq(&self.table, &other.table) && self.module_name == other.module_name
+    }
+}
+
+impl<T: Hash + Eq> TabledData<T> {
+    #[inline]
+    pub fn new(module_name: Rc<String>) -> Self {
+        TabledData {
+            table: Rc::new(RefCell::new(HashSet::new())),
+            module_name
+        }
+    }
+
+    #[inline]
+    pub fn borrow_mut(&self) -> RefMut<HashSet<Rc<T>>> {
+        self.table.borrow_mut()
+    }
+}
+
+pub struct TabledRc<T: Hash + Eq> {
+    pub(crate) atom: Rc<T>,
+    pub table: TabledData<T>
+}
+
+impl<T: Hash + Eq + fmt::Debug> fmt::Debug for TabledRc<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TabledRc")
+            .field("atom", &self.atom)
+            .field("table", &self.table)
+            .finish()
+    }
+}
+
+// this Clone instance is manually defined to prevent the compiler
+// from complaining when deriving Clone for StringList.
+impl<T: Hash + Eq> Clone for TabledRc<T> {
+    fn clone(&self) -> Self {
+        TabledRc { atom: self.atom.clone(), table: self.table.clone() }
+    }
+}
+
+impl<T: Ord + Hash + Eq> PartialOrd for TabledRc<T> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering>
+    {
+        Some(self.atom.cmp(&other.atom))
+    }
+}
+
+impl<T: Ord + Hash + Eq> Ord for TabledRc<T> {
+    fn cmp(&self, other: &Self) -> Ordering
+    {
+        self.atom.cmp(&other.atom)
+    }
+}
+
+impl<T: Hash + Eq> PartialEq for TabledRc<T> {
+    fn eq(&self, other: &TabledRc<T>) -> bool
+    {
+        self.atom == other.atom
+    }
+}
+
+impl<T: Hash + Eq> Eq for TabledRc<T> {}
+
+impl<T: Hash + Eq> Hash for TabledRc<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.atom.hash(state)
+    }
+}
+
+impl<T: Hash + Eq + ToString> TabledRc<T> {
+    pub fn new(atom: T, table: TabledData<T>) -> Self {
+        let atom = match table.borrow_mut().take(&atom) {
+            Some(atom) => atom.clone(),
+            None => Rc::new(atom)
+        };
+
+        table.borrow_mut().insert(atom.clone());
+
+        TabledRc { atom, table }
+    }
+
+    #[inline]
+    pub fn inner(&self) -> Rc<T> {
+        self.atom.clone()
+    }
+
+    #[inline]
+    pub(crate) fn owning_module(&self) -> Rc<String> {
+        self.table.module_name.clone()
+    }
+}
+
+impl<T: Hash + Eq> Drop for TabledRc<T> {
+    fn drop(&mut self) {
+        if Rc::strong_count(&self.atom) == 2 {
+            self.table.borrow_mut().remove(&self.atom);
+        }
+    }
+}
+
+impl<T: Hash + Eq> Deref for TabledRc<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &*self.atom
+    }
+}
+
+impl<T: Hash + Eq + fmt::Display> fmt::Display for TabledRc<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", &*self.atom)
+    }
+}
+
+#[macro_export]
+macro_rules! tabled_rc {
+    ($e:expr, $tbl:expr) => (
+        TabledRc::new(String::from($e), $tbl.clone())
+    )
+}

prolog_parser/tests/bom.rs

@@ -0,0 +1,43 @@
+extern crate prolog_parser;
+
+use prolog_parser::ast::*;
+use prolog_parser::lexer::{Lexer, Token};
+use prolog_parser::tabled_rc::TabledData;
+
+use std::rc::Rc;
+
+#[test]
+fn valid_token() {
+    let stream = parsing_stream("valid text".as_bytes());
+    assert!(stream.is_ok());
+}
+
+#[test]
+fn empty_stream() {
+    let bytes: &[u8] = &[];
+    assert!(parsing_stream(bytes).is_ok());
+}
+
+#[test]
+fn skip_utf8_bom() {
+    let atom_tbl = TabledData::new(Rc::new("my_module".to_string()));
+    let flags = MachineFlags::default();
+    let bytes: &[u8] = &[0xEF, 0xBB, 0xBF, '4' as u8, '\n' as u8];
+    let mut stream = parsing_stream(bytes).expect("valid stream");
+    let mut lexer = Lexer::new(atom_tbl, flags, &mut stream);
+    match lexer.next_token() {
+        Ok(Token::Constant(Constant::Fixnum(4))) => (),
+        _ => assert!(false)
+    }
+}
+
+#[test]
+fn invalid_utf16_bom() {
+    let bytes: &[u8] = &[0xFF, 0xFE, 'a' as u8, '\n' as u8];
+    let stream = parsing_stream(bytes);
+    match stream {
+        Err(ParserError::Utf8Error(0, 0)) => (),
+        _ => assert!(false)
+    }
+}
+

prolog_parser/tests/parse_tokens.rs

@@ -0,0 +1,107 @@
+extern crate prolog_parser;
+
+use prolog_parser::ast::*;
+use prolog_parser::lexer::{Lexer, Token};
+use prolog_parser::tabled_rc::TabledData;
+
+use std::rc::Rc;
+
+fn read_all_tokens(text: &str) -> Result<Vec<Token>, ParserError> {
+    let atom_tbl = TabledData::new(Rc::new("my_module".to_string()));
+    let flags = MachineFlags::default();
+    let mut stream = parsing_stream(text.as_bytes())?;
+    let mut lexer = Lexer::new(atom_tbl, flags, &mut stream);
+
+    let mut tokens = Vec::new();
+    while !lexer.eof()? {
+        let token = lexer.next_token()?;
+        tokens.push(token);
+    }
+    Ok(tokens)
+}
+
+#[test]
+fn empty_multiline_comment() -> Result<(), ParserError> {
+    let tokens = read_all_tokens("/**/ 4\n")?;
+    assert_eq!(tokens, [Token::Constant(Constant::Fixnum(4))]);
+    Ok(())
+}
+
+#[test]
+fn any_char_multiline_comment() -> Result<(), ParserError> {
+    let tokens = read_all_tokens("/* █╗╚═══╝ © */ 4\n")?;
+    assert_eq!(tokens, [Token::Constant(Constant::Fixnum(4))]);
+    Ok(())
+}
+
+#[test]
+fn simple_char() -> Result<(), ParserError> {
+    let tokens = read_all_tokens("'a'\n")?;
+    assert_eq!(tokens, [Token::Constant(Constant::Char('a'))]);
+    Ok(())
+}
+
+#[test]
+fn char_with_meta_seq() -> Result<(), ParserError> {
+    let tokens = read_all_tokens(r#"'\\' '\'' '\"' '\`' "#)?; // use literal string so \ are escaped
+    assert_eq!(tokens, [Token::Constant(Constant::Char('\\')),
+    Token::Constant(Constant::Char('\'')),
+    Token::Constant(Constant::Char('"')),
+    Token::Constant(Constant::Char('`'))]);
+    Ok(())
+}
+
+#[test]
+fn char_with_control_seq() -> Result<(), ParserError> {
+    let tokens = read_all_tokens(r"'\a' '\b' '\r' '\f' '\t' '\n' '\v' ")?;
+    assert_eq!(tokens, [
+        Token::Constant(Constant::Char('\u{07}')),
+        Token::Constant(Constant::Char('\u{08}')),
+        Token::Constant(Constant::Char('\r')),
+        Token::Constant(Constant::Char('\u{0c}')),
+        Token::Constant(Constant::Char('\t')),
+        Token::Constant(Constant::Char('\n')),
+        Token::Constant(Constant::Char('\u{0b}')),
+    ]);
+    Ok(())
+}
+
+#[test]
+fn char_with_octseq() -> Result<(), ParserError> {
+    let tokens = read_all_tokens(r"'\60433\' ")?;
+    assert_eq!(tokens, [Token::Constant(Constant::Char('愛'))]); // Japanese character
+    Ok(())
+}
+
+#[test]
+fn char_with_octseq_0() -> Result<(), ParserError> {
+    let tokens = read_all_tokens(r"'\0\' ")?;
+    assert_eq!(tokens, [Token::Constant(Constant::Char('\u{0000}'))]);
+    Ok(())
+}
+
+#[test]
+fn char_with_hexseq() -> Result<(), ParserError> {
+    let tokens = read_all_tokens(r"'\x2124\' ")?;
+    assert_eq!(tokens, [Token::Constant(Constant::Char('ℤ'))]); // Z math symbol
+    Ok(())
+}
+
+#[test]
+fn char_with_hexseq_invalid() {
+    assert!(read_all_tokens(r"'\x\' ").is_err());
+}
+
+#[test]
+fn empty() -> Result<(), ParserError> {
+    let tokens = read_all_tokens("")?;
+    assert!(tokens.is_empty());
+    Ok(())
+}
+
+#[test]
+fn comment_then_eof() -> Result<(), ParserError> {
+    let tokens = read_all_tokens("% only a comment")?;
+    assert_eq!(tokens, [Token::End]);
+    Ok(())
+}