use OffsetTableImpl without synchronization by default

src/parser/ast.rs

@@ -2,7 +2,6 @@
 
 use crate::arena::*;
 use crate::atom_table::*;
-use crate::machine::machine_indices::CodeIndex;
 use crate::offset_table::*;
 use crate::parser::char_reader::*;
 use crate::types::HeapCellValueTag;
@@ -698,17 +697,18 @@ impl Not for Fixnum {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Copy, Clone)]
 pub enum Literal {
     Atom(Atom),
-    CodeIndex(CodeIndex),
+    CodeIndexOffset(CodeIndexOffset),
     Fixnum(Fixnum),
     Integer(TypedArenaPtr<Integer>),
     Rational(TypedArenaPtr<Rational>),
-    Float(F64Offset),
+    F64Offset(F64Offset),
 }
 
-impl From<F64Ptr> for Literal {
+/*
+impl From<F64Ptr<'_>> for Literal {
     #[inline(always)]
     fn from(ptr: F64Ptr) -> Literal {
         Literal::Float(ptr.as_offset())
@@ -721,14 +721,15 @@ impl fmt::Display for Literal {
             Literal::Atom(ref atom) => {
                 write!(f, "{}", atom.flat_index())
             }
-            Literal::CodeIndex(i) => write!(f, "{:?}", *i.as_ptr()),
+            Literal::CodeIndexOffset(i) => write!(f, "{}", *i),
             Literal::Fixnum(n) => write!(f, "{}", n.get_num()),
             Literal::Integer(ref n) => write!(f, "{}", n),
             Literal::Rational(ref n) => write!(f, "{}", n),
-            Literal::Float(ref n) => write!(f, "{}", *n),
+            Literal::FloatOffset(ref n) => write!(f, "{}", *n),
         }
     }
 }
+*/
 
 impl Literal {
     pub fn as_atom(&self, atom_tbl: &Arc<AtomTable>) -> Option<Atom> {
@@ -874,7 +875,7 @@ impl Term {
 
 pub(crate) fn unfold_by_str_once(term: &mut Term, s: Atom) -> Option<(Term, Term)> {
     if let Term::Clause(_, ref name, ref mut subterms) = term {
-        if let Some(Term::Literal(_, Literal::CodeIndex(_))) = subterms.last() {
+        if let Some(Term::Literal(_, Literal::CodeIndexOffset(_))) = subterms.last() {
             subterms.pop();
         }
 

src/parser/lexer.rs

@@ -1,7 +1,7 @@
 use crate::arena::*;
 use crate::atom_table::*;
 pub use crate::machine::machine_state::*;
-use crate::offset_table::F64Ptr;
+use crate::offset_table::*;
 use crate::parser::ast::*;
 use crate::parser::char_reader::*;
 use crate::parser::dashu::Integer;
@@ -30,7 +30,7 @@ struct LayoutInfo {
     more: bool,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub enum Token {
     Literal(Literal),
     Var(String),
@@ -58,7 +58,7 @@ impl Token {
 enum Number {
     BigInt(TypedArenaPtr<Integer>),
     Fixnum(Fixnum),
-    Float(F64Ptr),
+    Float(F64Offset),
 }
 
 impl Number {
@@ -67,7 +67,7 @@ impl Number {
         match self {
             Number::BigInt(ibig) => Literal::Integer(ibig),
             Number::Fixnum(fixnum) => Literal::Fixnum(fixnum),
-            Number::Float(f) => Literal::Float(f.as_offset()),
+            Number::Float(f) => Literal::F64Offset(f),
         }
     }
 }
@@ -944,8 +944,8 @@ impl<'a, R: CharRead> Lexer<'a, R> {
                 Ok(n) => Ok(Token::Literal(n.to_literal())),
                 Err(_) => {
                     let n = parse_float_lossy(&token_string)?;
-                    Ok(Token::Literal(Literal::Float(
-                        float_alloc!(n, self.machine_st.arena).as_offset(),
+                    Ok(Token::Literal(Literal::F64Offset(
+                        float_alloc!(n, self.machine_st.arena),
                     )))
                 }
             },

src/parser/parser.rs

@@ -3,12 +3,11 @@ use dashu::Rational;
 
 use crate::arena::*;
 use crate::atom_table::*;
+use crate::offset_table::OffsetTable;
 use crate::parser::ast::*;
 use crate::parser::char_reader::*;
 use crate::parser::lexer::*;
 
-use ordered_float::OrderedFloat;
-
 use std::cell::Cell;
 use std::mem;
 use std::ops::Neg;
@@ -963,17 +962,21 @@ impl<'a, R: CharRead> Parser<'a, R> {
             Token::Literal(Literal::Rational(n)) => {
                 self.negate_number(n, negate_rat_rc, |r, _| Literal::Rational(r))
             }
-	    Token::Literal(Literal::Float(n)) if n.as_ptr().is_infinite() => {
+	    Token::Literal(Literal::F64Offset(n)) if self.lexer.machine_st.arena.f64_tbl.lookup(n).is_infinite() => {
 		return Err(ParserError::InfiniteFloat(
 		    self.lexer.line_num,
 		    self.lexer.col_num,
 		));
 	    }
-            Token::Literal(Literal::Float(n)) => self.negate_number(
-                **n.as_ptr(),
-                |n, _| -n,
-                |n, arena| Literal::from(float_alloc!(n, arena)),
-            ),
+            Token::Literal(Literal::F64Offset(n)) => {
+                let n = *self.lexer.machine_st.arena.f64_tbl.lookup(n);
+
+                self.negate_number(
+                    n,
+                    |n, _| -n,
+                    |n, arena| Literal::F64Offset(arena.f64_tbl.build_with(n)),
+                )
+            }
             Token::Literal(Literal::Fixnum(n)) => {
                 self.negate_number(n, |n, _| -n, |n, _| Literal::Fixnum(n))
             }