update/extension to lexer, bug fixes to module importing

src/main.rs

@@ -1,4 +1,3 @@
-#[macro_use] extern crate lazy_static;
 #[macro_use] extern crate downcast;
 extern crate termion;
 

src/prolog/ast.rs

@@ -10,14 +10,11 @@ use std::collections::{BTreeSet, HashMap, VecDeque};
 use std::fmt;
 use std::hash::{Hash, Hasher};
 use std::io::Error as IOError;
-use std::num::{ParseFloatError};
 use std::ops::{Add, AddAssign, Div, Index, IndexMut, Sub, Mul, Neg};
 use std::rc::Rc;
 use std::str::Utf8Error;
 use std::vec::Vec;
 
-pub const LEXER_BUF_SIZE: usize = 4096;
-
 pub type Atom = String;
 
 pub type Var = String;
@@ -461,17 +458,13 @@ pub enum ArithmeticError {
     UninstantiatedVar
 }
 
-/* 'TokenTooLong' is hard to detect reliably if we don't process the
-input one character at a time. It would be easy to detect if the regex
-library supported matching on iterator inputs, but it currently does
-not. This is fine, mostly; the typical Prolog program will not contain
-tokens exceeding 4096 chars in length. */
-
 #[derive(Debug)]
 pub enum ParserError
 {
     Arithmetic(ArithmeticError),
+    BackQuotedString,
     BuiltInArityMismatch(&'static str),
+    UnexpectedChar(char),
     UnexpectedEOF,
     FailedMatch(String),
     IO(IOError),
@@ -479,14 +472,14 @@ pub enum ParserError
     InadmissibleFact,
     InadmissibleQueryTerm,
     IncompleteReduction,
-    InconsistentEntry, // was InconsistentDeclaration.
+    InconsistentEntry,
     InvalidModuleDecl,
     InvalidModuleExport,
     InvalidRuleHead,
     InvalidUseModuleDecl,
+    MissingQuote,
     ParseBigInt,
-    ParseFloat(ParseFloatError),
-    // TokenTooLong,
+    ParseFloat,
     Utf8Conversion(Utf8Error)
 }
 
@@ -508,12 +501,6 @@ impl From<Utf8Error> for ParserError {
     }
 }
 
-impl From<ParseFloatError> for ParserError {
-    fn from(err: ParseFloatError) -> ParserError {
-        ParserError::ParseFloat(err)
-    }
-}
-
 #[derive(Clone, Copy, Eq, Hash, PartialEq)]
 pub enum Fixity {
     In, Post, Pre
@@ -522,6 +509,7 @@ pub enum Fixity {
 #[derive(Clone, Eq, Hash, PartialEq)]
 pub enum Constant {
     Atom(ClauseName),
+    Char(char),
     Number(Number),
     String(Rc<String>),
     Usize(usize),
@@ -549,12 +537,14 @@ impl fmt::Display for Constant {
         match self {
             &Constant::Atom(ref atom) =>
                 write!(f, "{}", atom),
+            &Constant::Char(c) =>
+                write!(f, "#\\{}", c),
             &Constant::EmptyList =>
                 write!(f, "[]"),
             &Constant::Number(ref n) =>
                 write!(f, "{}", n),
             &Constant::String(ref s) =>
-                write!(f, "{}", s),
+                write!(f, "\"{}\"", s),
             &Constant::Usize(integer) =>
                 write!(f, "u{}", integer)
         }

src/prolog/io.rs

@@ -4,7 +4,7 @@ use prolog::codegen::*;
 use prolog::debray_allocator::*;
 use prolog::heap_print::*;
 use prolog::machine::*;
-use prolog::parser::toplevel::*;
+use prolog::toplevel::*;
 
 use termion::raw::IntoRawMode;
 use termion::input::TermRead;
@@ -13,7 +13,6 @@ use termion::event::Key;
 use std::io::{Write, stdin, stdout};
 use std::fmt;
 
-
 impl fmt::Display for IndexPtr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
@@ -472,8 +471,7 @@ impl TLInfo for DeclInfo {
         let (name, arity) = (self.name.clone(), self.arity);
 
         if entry.0.get() == IndexPtr::Undefined {
-            if &name == n1 && arity == a1 {
-                // *entry = default(); // implement logical view update semantics.
+            if &name == n1 && arity == a1 {                
                 entry.0.set(IndexPtr::Index(code_size));
             }
         }
@@ -673,14 +671,18 @@ pub fn compile_listing(wam: &mut Machine, src_str: &str) -> EvalSession
                 });
 
                 let module_name = get_module_name(&module);
+                let decl_info = DeclInfo { name, arity: decl.arity(),
+                                           module_name: module_name.clone() };
 
-                let decl_info = DeclInfo { name, arity: decl.arity(), module_name };
+                {
+                    let index = code_dir.entry((decl_info.name.clone(), decl_info.arity))
+                        .or_insert(CodeIndex::default());
+
+                    index.0.set(IndexPtr::Index(p));
+                }
+                
                 decl_info.label_clauses(p, &mut code_dir, &mut decl_code);
-
                 code.extend(decl_code.into_iter());
-
-                let index = CodeIndex::default();
-                code_dir.insert((decl_info.name.clone(), decl_info.arity), index);
             }
         }
     }

src/prolog/mod.rs

@@ -8,6 +8,7 @@ pub mod macros;
 pub mod ast;
 #[macro_use]
 pub mod allocator;
+pub mod toplevel;
 pub mod arithmetic;
 pub mod builtins;
 pub mod codegen;

src/prolog/toplevel.rs

@@ -0,0 +1,629 @@
+use prolog::ast::*;
+use prolog::num::*;
+use prolog::parser::parser::*;
+use prolog::tabled_rc::*;
+
+use std::collections::{HashSet, VecDeque};
+use std::cell::Cell;
+use std::io::Read;
+use std::mem;
+use std::rc::Rc;
+
+fn setup_fact(term: Term) -> Result<Term, ParserError>
+{
+    match term {
+        Term::Clause(..) | Term::Constant(_, Constant::Atom(_)) =>
+            Ok(term),
+        _ =>
+            Err(ParserError::InadmissibleFact)
+    }
+}
+
+fn setup_op_decl(mut terms: Vec<Box<Term>>) -> Result<OpDecl, ParserError>
+{
+    let name = match *terms.pop().unwrap() {
+        Term::Constant(_, Constant::Atom(name)) => name,
+        _ => return Err(ParserError::InconsistentEntry)
+    };
+
+    let spec = match *terms.pop().unwrap() {
+        Term::Constant(_, Constant::Atom(name)) => name,
+        _ => return Err(ParserError::InconsistentEntry)
+    };
+
+    let prec = match *terms.pop().unwrap() {
+        Term::Constant(_, Constant::Number(Number::Integer(bi))) =>
+            match bi.to_usize() {
+                Some(n) if n <= 1200 => n,
+                _ => return Err(ParserError::InconsistentEntry)
+            },
+        _ => return Err(ParserError::InconsistentEntry)
+    };
+
+    match spec.as_str() {
+        "xfx" => Ok(OpDecl(prec, XFX, name)),
+        "xfy" => Ok(OpDecl(prec, XFY, name)),
+        "yfx" => Ok(OpDecl(prec, YFX, name)),
+        "fx"  => Ok(OpDecl(prec, FX, name)),
+        "fy"  => Ok(OpDecl(prec, FY, name)),
+        "xf"  => Ok(OpDecl(prec, XF, name)),
+        "yf"  => Ok(OpDecl(prec, YF, name)),
+        _     => Err(ParserError::InconsistentEntry)
+    }
+}
+
+fn setup_predicate_export(mut term: Term) -> Result<PredicateKey, ParserError>
+{
+    match term {
+        Term::Clause(_, ref name, ref mut terms, Some(Fixity::In))
+            if name.as_str() == "/" && terms.len() == 2 => {
+                let arity = *terms.pop().unwrap();
+                let name  = *terms.pop().unwrap();
+
+                let arity = arity.to_constant().and_then(|c| c.to_integer())
+                    .and_then(|n| if !n.is_negative() { n.to_usize() } else { None })
+                    .ok_or(ParserError::InvalidModuleExport)?;
+
+                let name = name.to_constant().and_then(|c| c.to_atom())
+                    .ok_or(ParserError::InvalidModuleExport)?;
+
+                Ok((name, arity))
+            },
+        _ => Err(ParserError::InvalidModuleExport)
+    }
+}
+
+fn setup_module_decl(mut terms: Vec<Box<Term>>) -> Result<ModuleDecl, ParserError>
+{
+    let mut export_list = *terms.pop().unwrap();
+    let name = terms.pop().unwrap().to_constant().and_then(|c| c.to_atom())
+        .ok_or(ParserError::InvalidModuleDecl)?;
+
+    let mut exports = Vec::new();
+
+    while let Term::Cons(_, t1, t2) = export_list {
+        exports.push(setup_predicate_export(*t1)?);
+        export_list = *t2;
+    }
+
+    if export_list.to_constant() != Some(Constant::EmptyList) {
+        Err(ParserError::InvalidModuleDecl)
+    } else {
+        Ok(ModuleDecl { name, exports })
+    }
+}
+
+fn setup_use_module_decl(mut terms: Vec<Box<Term>>) -> Result<ClauseName, ParserError>
+{
+    match *terms.pop().unwrap() {
+        Term::Clause(_, ref name, ref mut terms, None)
+            if name.as_str() == "library" && terms.len() == 1 => {
+                terms.pop().unwrap().to_constant()
+                    .and_then(|c| c.to_atom())
+                    .ok_or(ParserError::InvalidUseModuleDecl)
+            },
+        _ => Err(ParserError::InvalidUseModuleDecl)
+    }
+}
+
+type UseModuleExport = (ClauseName, Vec<PredicateKey>);
+
+fn setup_qualified_import(mut terms: Vec<Box<Term>>) -> Result<UseModuleExport, ParserError>
+{
+    let mut export_list = *terms.pop().unwrap();
+    let name = match *terms.pop().unwrap() {
+        Term::Clause(_, ref name, ref mut terms, None)
+            if name.as_str() == "library" && terms.len() == 1 => {
+                terms.pop().unwrap().to_constant()
+                    .and_then(|c| c.to_atom())
+                    .ok_or(ParserError::InvalidUseModuleDecl)
+            },
+        _ => Err(ParserError::InvalidUseModuleDecl)
+    }?;
+
+    let mut exports = Vec::new();
+
+    while let Term::Cons(_, t1, t2) = export_list {
+        exports.push(setup_predicate_export(*t1)?);
+        export_list = *t2;
+    }
+
+    if export_list.to_constant() != Some(Constant::EmptyList) {
+        Err(ParserError::InvalidModuleDecl)
+    } else {
+        Ok((name, exports))
+    }
+}
+
+fn setup_declaration(term: Term) -> Result<Declaration, ParserError>
+{
+    match term {
+        Term::Clause(_, name, terms, _) =>
+            if name.as_str() == "op" && terms.len() == 3 {
+                Ok(Declaration::Op(setup_op_decl(terms)?))
+            } else if name.as_str() == "module" && terms.len() == 2 {
+                Ok(Declaration::Module(setup_module_decl(terms)?))
+            } else if name.as_str() == "use_module" && terms.len() == 1 {
+                Ok(Declaration::UseModule(setup_use_module_decl(terms)?))
+            } else if name.as_str() == "use_module" && terms.len() == 2 {
+                let (name, exports) = setup_qualified_import(terms)?;
+                Ok(Declaration::UseQualifiedModule(name, exports))
+            } else {
+                Err(ParserError::InconsistentEntry)
+            },
+        _ => return Err(ParserError::InconsistentEntry)
+    }
+}
+
+fn is_consistent(tl: &TopLevel, clauses: &Vec<PredicateClause>) -> bool
+{
+    match clauses.first() {
+        Some(ref cl) => tl.name() == cl.name() && tl.arity() == cl.arity(),
+        None => true
+    }
+}
+
+pub fn deque_to_packet(head: TopLevel, deque: VecDeque<TopLevel>) -> TopLevelPacket
+{
+    match head {
+        TopLevel::Query(query) => TopLevelPacket::Query(query, Vec::from(deque)),
+        tl => TopLevelPacket::Decl(tl, Vec::from(deque))
+    }
+}
+
+pub fn merge_clauses(tls: &mut VecDeque<TopLevel>) -> Result<TopLevel, ParserError>
+{
+    let mut clauses: Vec<PredicateClause> = vec![];
+
+    while let Some(tl) = tls.pop_front() {
+        match tl {
+            TopLevel::Query(_) if clauses.is_empty() && tls.is_empty() =>
+                return Ok(tl),
+            TopLevel::Declaration(_) if clauses.is_empty() =>
+                return Ok(tl),
+            TopLevel::Query(_) =>
+                return Err(ParserError::InconsistentEntry),
+            TopLevel::Fact(_) if is_consistent(&tl, &clauses) =>
+                if let TopLevel::Fact(fact) = tl {
+                    let clause = PredicateClause::Fact(fact);
+                    clauses.push(clause);
+                },
+            TopLevel::Rule(_) if is_consistent(&tl, &clauses) =>
+                if let TopLevel::Rule(rule) = tl {
+                    let clause = PredicateClause::Rule(rule);
+                    clauses.push(clause);
+                },
+            TopLevel::Predicate(_) if is_consistent(&tl, &clauses) =>
+                if let TopLevel::Predicate(pred) = tl {
+                    clauses.extend(pred.clauses().into_iter())
+                },
+            _ => {
+                tls.push_front(tl);
+                break;
+            }
+        }
+    }
+
+    if clauses.is_empty() {
+        Err(ParserError::InconsistentEntry)
+    } else {
+        Ok(TopLevel::Predicate(Predicate(clauses)))
+    }
+}
+
+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
+}
+
+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
+}
+
+fn fold_by_str(mut terms: Vec<Term>, mut term: Term, sym: ClauseName) -> Term
+{
+    while let Some(prec) = terms.pop() {
+        term = Term::Clause(Cell::default(), sym.clone(),
+                            vec![Box::new(prec), Box::new(term)],
+                            None);
+    }
+
+    term
+}
+
+fn mark_cut_variables_as(terms: &mut Vec<Term>, name: ClauseName) {
+    for term in terms.iter_mut() {
+        match term {
+            &mut Term::Constant(_, Constant::Atom(ref mut var)) if var.as_str() == "!" =>
+                *var = name.clone(),
+            _ => {}
+        }
+    }
+}
+
+fn mark_cut_variable(term: &mut Term) -> bool {
+    let cut_var_found = match term {
+        &mut Term::Constant(_, Constant::Atom(ref var)) if var.as_str() == "!" => true,
+        _ => false
+    };
+
+    if cut_var_found {
+        *term = Term::Var(Cell::default(), rc_atom!("!"));
+        true
+    } else {
+        false
+    }
+}
+
+fn mark_cut_variables(terms: &mut Vec<Term>) -> bool {
+    let mut found_cut_var = false;
+
+    for item in terms.iter_mut() {
+        found_cut_var = mark_cut_variable(item);
+    }
+
+    found_cut_var
+}
+
+pub enum TopLevelPacket {
+    Query(Vec<QueryTerm>, Vec<TopLevel>),
+    Decl(TopLevel, Vec<TopLevel>)
+}
+
+struct RelationWorker {
+    queue: VecDeque<VecDeque<Term>>
+}
+
+impl RelationWorker {
+    fn new() -> Self {
+        RelationWorker { queue: VecDeque::new() }
+    }
+
+    fn compute_head(&self, term: &Term) -> Vec<Term>
+    {
+        let mut vars = HashSet::new();
+
+        for term in term.post_order_iter() {
+            if let TermRef::Var(_, _, v) = term {
+                vars.insert(v.clone());
+            }
+        }
+
+        vars.insert(rc_atom!("!"));
+        vars.into_iter()
+            .map(|v| Term::Var(Cell::default(), v))
+            .collect()
+    }
+
+    fn fabricate_rule_body(&self, vars: &Vec<Term>, body_term: Term) -> Term
+    {
+        let vars_of_head = vars.iter().cloned().map(Box::new).collect();
+        let head_term = Term::Clause(Cell::default(), clause_name!(""), vars_of_head, None);
+
+        let rule = vec![Box::new(head_term), Box::new(body_term)];
+        let turnstile = clause_name!(":-");
+
+        Term::Clause(Cell::default(), turnstile, rule, None)
+    }
+
+    // the terms form the body of the rule. We create a head, by
+    // gathering variables from the body of terms and recording them
+    // in the head clause.
+    fn fabricate_rule(&self, body_term: Term) -> (JumpStub, VecDeque<Term>)
+    {
+        // collect the vars of body_term into a head, return the num_vars
+        // (the arity) as well.
+        let vars = self.compute_head(&body_term);
+        let rule = self.fabricate_rule_body(&vars, body_term);
+
+        (vars, VecDeque::from(vec![rule]))
+    }
+
+    fn fabricate_disjunct(&self, body_term: Term) -> (JumpStub, VecDeque<Term>)
+    {
+        let mut cut_var_found = false;
+
+        let mut vars = self.compute_head(&body_term);
+        let clauses: Vec<_> = unfold_by_str(body_term, ";").into_iter()
+            .map(|term| {
+                let mut subterms = unfold_by_str(term, ",");
+                cut_var_found = mark_cut_variables(&mut subterms);
+
+                let term = subterms.pop().unwrap();
+                fold_by_str(subterms, term, clause_name!(","))
+            }).collect();
+
+        if cut_var_found {
+            vars.push(Term::Var(Cell::default(), rc_atom!("!")));
+        }
+
+        let results = clauses.into_iter()
+            .map(|clause| self.fabricate_rule_body(&vars, clause))
+            .collect();
+
+        (vars, results)
+    }
+
+    fn fabricate_if_then(&self, prec: Term, conq: Term) -> (JumpStub, VecDeque<Term>)
+    {
+        let mut prec_seq = unfold_by_str(prec, ",");
+        let comma_sym    = clause_name!(",");
+        let cut_sym      = atom!("!");
+
+        prec_seq.push(Term::Constant(Cell::default(), cut_sym));
+
+        mark_cut_variables_as(&mut prec_seq, clause_name!("blocked_!"));
+
+        let mut conq_seq = unfold_by_str(conq, ",");
+
+        mark_cut_variables(&mut conq_seq);
+        prec_seq.extend(conq_seq.into_iter());
+
+        let back_term  = Box::new(prec_seq.pop().unwrap());
+        let front_term = Box::new(prec_seq.pop().unwrap());
+
+        let body_term  = Term::Clause(Cell::default(), comma_sym.clone(),
+                                      vec![front_term, back_term], None);
+
+        self.fabricate_rule(fold_by_str(prec_seq, body_term, comma_sym))
+    }
+
+    fn to_query_term(&mut self, term: Term) -> Result<QueryTerm, ParserError>
+    {
+        match term {
+            Term::Constant(r, Constant::Atom(name)) =>
+                if name.as_str() == "!" || name.as_str() == "blocked_!" {
+                    Ok(QueryTerm::BlockedCut)
+                } else {
+                    Ok(QueryTerm::Clause(r, ClauseType::Named(name, CodeIndex::default()),
+                                         vec![]))
+                },
+            Term::Var(_, ref v) if v.as_str() == "!" =>
+                Ok(QueryTerm::UnblockedCut(Cell::default())),
+            Term::Clause(r, name, mut terms, fixity) =>
+                if let Some(inlined_ct) = InlinedClauseType::from(name.as_str(), terms.len()) {
+                    Ok(QueryTerm::Clause(r, ClauseType::Inlined(inlined_ct), terms))
+                } else if name.as_str() == ";" {
+                    if terms.len() == 2 {
+                        let term = Term::Clause(r, name.clone(), terms, fixity);
+                        let (stub, clauses) = self.fabricate_disjunct(term);
+
+                        self.queue.push_back(clauses);
+                        Ok(QueryTerm::Jump(stub))
+                    } else {
+                        Err(ParserError::BuiltInArityMismatch(";"))
+                    }
+                } else if name.as_str() == "->" && terms.len() == 2 {
+                    if terms.len() == 2 {
+                        let conq = *terms.pop().unwrap();
+                        let prec = *terms.pop().unwrap();
+                        let (stub, clauses) = self.fabricate_if_then(prec, conq);
+
+                        self.queue.push_back(clauses);
+                        Ok(QueryTerm::Jump(stub))
+                    } else {
+                        Err(ParserError::BuiltInArityMismatch("->"))
+                    }
+                } else {
+                    Ok(QueryTerm::Clause(Cell::default(),
+                                         ClauseType::from(name, terms.len(), fixity),
+                                         terms))
+                },
+            Term::Var(_, _) =>
+                Ok(QueryTerm::Clause(Cell::default(), ClauseType::CallN, vec![Box::new(term)])),
+            _ =>
+                Err(ParserError::InadmissibleQueryTerm)
+        }
+    }
+
+    // never blocks cuts in the consequent.
+    fn prepend_if_then(&self, prec: Term, conq: Term, queue: &mut VecDeque<Box<Term>>,
+                       blocks_cuts: bool)
+    {
+        let cut_symb = atom!("blocked_!");
+        let mut terms_seq = unfold_by_str(prec, ",");
+
+        terms_seq.push(Term::Constant(Cell::default(), cut_symb));
+
+        let mut conq_seq = unfold_by_str(conq, ",");
+
+        if !blocks_cuts {
+            for item in conq_seq.iter_mut() {
+                mark_cut_variable(item);
+            }
+        }
+
+        terms_seq.append(&mut conq_seq);
+
+        while let Some(term) = terms_seq.pop() {
+            queue.push_front(Box::new(term));
+        }
+    }
+
+    fn setup_query(&mut self, terms: Vec<Box<Term>>, blocks_cuts: bool)
+                   -> Result<Vec<QueryTerm>, ParserError>
+    {
+        let mut query_terms = vec![];
+        let mut work_queue  = VecDeque::from(terms);
+
+        while let Some(term) = work_queue.pop_front() {
+            let mut term = *term;
+
+            // a (->) clause makes up the entire query. That's what the test confirms.
+            if query_terms.is_empty() && work_queue.is_empty() {
+                // check for ->, inline it if found.
+                if let &mut Term::Clause(_, ref name, ref mut subterms, _) = &mut term {
+                    if name.as_str() == "->" && subterms.len() == 2 {
+                        let conq = *subterms.pop().unwrap();
+                        let prec = *subterms.pop().unwrap();
+
+                        self.prepend_if_then(prec, conq, &mut work_queue, blocks_cuts);
+                        continue;
+                    }
+                }
+            }
+
+            for mut subterm in unfold_by_str(term, ",") {
+                if !blocks_cuts {
+                    mark_cut_variable(&mut subterm);
+                }
+
+                query_terms.push(try!(self.to_query_term(subterm)));
+            }
+        }
+
+        Ok(query_terms)
+    }
+
+    fn setup_rule(&mut self, mut terms: Vec<Box<Term>>, blocks_cuts: bool)
+                  -> Result<Rule, ParserError>
+    {
+        let post_head_terms = terms.drain(1..).collect();
+        let mut query_terms = try!(self.setup_query(post_head_terms, blocks_cuts));
+        let clauses = query_terms.drain(1 ..).collect();
+        let qt = query_terms.pop().unwrap();
+
+        match *terms.pop().unwrap() {
+            Term::Clause(_, name, terms, _) =>
+                Ok(Rule { head: (name, terms, qt), clauses }),
+            Term::Constant(_, Constant::Atom(name)) =>
+                Ok(Rule { head: (name, vec![], qt), clauses }),
+            _ => Err(ParserError::InvalidRuleHead)
+        }
+    }
+
+
+    pub fn try_term_to_tl(&mut self, term: Term, blocks_cuts: bool) -> Result<TopLevel, ParserError>
+    {
+        match term {
+            Term::Clause(r, name, mut terms, fixity) =>
+                if name.as_str() == "?-" {
+                    Ok(TopLevel::Query(try!(self.setup_query(terms, blocks_cuts))))
+                } else if name.as_str() == ":-" && terms.len() > 1 {
+                    Ok(TopLevel::Rule(try!(self.setup_rule(terms, blocks_cuts))))
+                } else if name.as_str() == ":-" && terms.len() == 1 {
+                    let term = *terms.pop().unwrap();
+                    Ok(TopLevel::Declaration(try!(setup_declaration(term))))
+                } else {
+                    Ok(TopLevel::Fact(try!(setup_fact(Term::Clause(r, name, terms, fixity)))))
+                },
+            term => Ok(TopLevel::Fact(try!(setup_fact(term))))
+        }
+    }
+
+    fn try_terms_to_tls<Iter>(&mut self, terms: Iter, blocks_cuts: bool)
+                              -> Result<VecDeque<TopLevel>, ParserError>
+        where Iter: IntoIterator<Item=Term>
+    {
+        let mut results = VecDeque::new();
+
+        for term in terms.into_iter() {
+            results.push_back(self.try_term_to_tl(term, blocks_cuts)?);
+        }
+
+        Ok(results)
+    }
+
+    fn parse_queue(&mut self) -> Result<VecDeque<TopLevel>, ParserError>
+    {
+        let mut queue = VecDeque::new();
+
+        while let Some(terms) = self.queue.pop_front() {
+            let clauses = merge_clauses(&mut self.try_terms_to_tls(terms, false)?)?;
+            queue.push_back(clauses);
+        }
+
+        Ok(queue)
+    }
+
+    fn absorb(&mut self, other: RelationWorker) {
+        self.queue.extend(other.queue.into_iter());
+    }
+}
+
+pub struct TopLevelWorker<R> where R: Read {
+    pub parser: Parser<R>
+}
+
+impl<R: Read> TopLevelWorker<R> {
+    pub fn new(inner: R, atom_tbl: TabledData<Atom>) -> Self {
+        TopLevelWorker { parser: Parser::new(inner, atom_tbl) }
+    }
+
+    pub fn parse_batch(&mut self, op_dir: &mut OpDir) -> Result<Vec<TopLevelPacket>, EvalError>
+    {
+        let mut preds = vec![]; 
+        let mut mod_name = clause_name!("user");
+        let mut results = vec![];
+        let mut rel_worker = RelationWorker::new();
+
+        fn append_preds(preds: &mut Vec<PredicateClause>) -> TopLevel {
+            let preds = mem::replace(preds, vec![]);
+            TopLevel::Predicate(Predicate(preds))
+        }
+
+        while !self.parser.eof() {
+            self.parser.reset(); // empty the parser stack of token descriptions.
+            let term = self.parser.read_term(&op_dir)?;
+
+            let mut new_rel_worker = RelationWorker::new();
+            let tl = new_rel_worker.try_term_to_tl(term, true)?;
+
+            if !is_consistent(&tl, &preds) {
+                results.push(deque_to_packet(append_preds(&mut preds), rel_worker.parse_queue()?));
+            }
+
+            rel_worker.absorb(new_rel_worker);
+
+            match tl {
+                TopLevel::Declaration(Declaration::Op(op_decl)) => {
+                    op_decl.submit(mod_name.clone(), op_dir)?;
+                },
+                TopLevel::Declaration(Declaration::Module(actual_mod)) => {
+                    mod_name = actual_mod.name.clone();
+                    let tl = TopLevel::Declaration(Declaration::Module(actual_mod));
+                    results.push(TopLevelPacket::Decl(tl, vec![]));
+                },
+                tl => preds.extend(tl.as_predicate().ok().unwrap().clauses().into_iter())
+            };
+        }
+
+        results.push(deque_to_packet(append_preds(&mut preds), rel_worker.parse_queue()?));
+        Ok(results)
+    }
+
+    pub fn parse_code(&mut self, op_dir: &OpDir) -> Result<TopLevelPacket, ParserError>
+    {
+        let mut rel_worker = RelationWorker::new();
+
+        let terms   = self.parser.read(op_dir)?;
+        let mut tls = rel_worker.try_terms_to_tls(terms, true)?;
+        let results = rel_worker.parse_queue()?;
+
+        let tl = merge_clauses(&mut tls)?;
+
+        if tls.is_empty() {
+            Ok(deque_to_packet(tl, results))
+        } else {
+            Err(ParserError::InconsistentEntry)
+        }
+    }
+}