Merge branch 'dashu' of https://github.com/coasys/scryer-prolog into coasys-dashu

src/parser/ast.rs

@@ -12,7 +12,7 @@ use std::ops::{Deref, Neg};
 use std::rc::Rc;
 use std::vec::Vec;
 
-use crate::parser::rug::{Integer, Rational};
+use crate::parser::dashu::{Integer, Rational};
 
 use fxhash::FxBuildHasher;
 use indexmap::IndexMap;

src/parser/lexer.rs

@@ -5,7 +5,7 @@ use crate::atom_table::*;
 pub use crate::machine::machine_state::*;
 use crate::parser::ast::*;
 use crate::parser::char_reader::*;
-use crate::parser::rug::Integer;
+use crate::parser::dashu::Integer;
 
 use std::convert::TryFrom;
 use std::fmt;

src/parser/mod.rs

@@ -1,8 +1,4 @@
-#[cfg(feature = "num-rug-adapter")]
-pub use num_rug_adapter as rug;
-
-#[cfg(feature = "rug")]
-pub use rug;
+pub use dashu;
 
 // #[macro_use]
 // extern crate lazy_static;

src/parser/parser.rs

@@ -1,13 +1,16 @@
+use dashu::Integer;
+use dashu::Rational;
+
 use crate::arena::*;
 use crate::atom_table::*;
 use crate::parser::ast::*;
 use crate::parser::char_reader::*;
 use crate::parser::lexer::*;
 
-use crate::parser::rug::ops::NegAssign;
 
 use std::cell::Cell;
 use std::mem;
+use std::ops::Neg;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 enum TokenType {
@@ -950,9 +953,16 @@ impl<'a, R: CharRead> Parser<'a, R> {
     }
 
     fn shift_token(&mut self, token: Token, op_dir: &CompositeOpDir) -> Result<(), ParserError> {
-        fn negate_rc<T: NegAssign>(mut t: TypedArenaPtr<T>) -> TypedArenaPtr<T> {
-            (&mut t).neg_assign();
-            t
+        fn negate_int_rc(t: TypedArenaPtr<Integer>) -> TypedArenaPtr<Integer> {
+            let i: Integer = (*t).clone();
+            let mut data = i.neg();
+            TypedArenaPtr::new(&mut data)
+        }
+
+        fn negate_rat_rc(t: TypedArenaPtr<Rational>) -> TypedArenaPtr<Rational> {
+            let r: Rational = (*t).clone();
+            let mut data = r.neg();
+            TypedArenaPtr::new(&mut data)
         }
 
         match token {
@@ -960,10 +970,10 @@ impl<'a, R: CharRead> Parser<'a, R> {
                 self.negate_number(n, |n| -n, |n, _| Literal::Fixnum(n))
             }
             Token::Literal(Literal::Integer(n)) => {
-                self.negate_number(n, negate_rc, |n, _| Literal::Integer(n))
+                self.negate_number(n, negate_int_rc, |n, _| Literal::Integer(n))
             }
             Token::Literal(Literal::Rational(n)) => {
-                self.negate_number(n, negate_rc, |r, _| Literal::Rational(r))
+                self.negate_number(n, negate_rat_rc, |r, _| Literal::Rational(r))
             }
             Token::Literal(Literal::Float(n)) => self.negate_number(
                 **n.as_ptr(),