VM: replacing the copy assignment operators of the smart pointers

Little more to write, but much easier to see what is going on with
methods rather than assignment operator overloading.

diff --git a/vm/arrays.cpp b/vm/arrays.cpp
index 9a32c13913b488e5e0977fca384debf41dfa0b60..b3d8e698fedcd3b0de1a434d1cce4708da2eb76f 100644 (file)
--- a/vm/arrays.cpp
+++ b/vm/arrays.cpp
@@ -57,13 +57,20 @@ cell factor_vm::std_vector_to_array(std::vector<cell>& elements) {
   return objects.value();
 }
 
+// Allocates memory
+void growable_array::reallot_array(cell count) {
+  array *a_old = elements.untagged();
+  array *a_new = elements.parent->reallot_array(a_old, count);
+  elements.set_untagged(a_new);
+}
+
 // Allocates memory
 void growable_array::add(cell elt_) {
   factor_vm* parent = elements.parent;
   data_root<object> elt(elt_, parent);
-  if (count == array_capacity(elements.untagged()))
-    elements = parent->reallot_array(elements.untagged(), count * 2);
-
+  if (count == array_capacity(elements.untagged())) {
+    reallot_array(2 * count);
+  }
   parent->set_array_nth(elements.untagged(), count++, elt.value());
 }
 
@@ -73,8 +80,7 @@ void growable_array::append(array* elts_) {
   data_root<array> elts(elts_, parent);
   cell capacity = array_capacity(elts.untagged());
   if (count + capacity > array_capacity(elements.untagged())) {
-    elements =
-        parent->reallot_array(elements.untagged(), (count + capacity) * 2);
+    reallot_array(2 * (count + capacity));
   }
 
   for (cell index = 0; index < capacity; index++)
@@ -84,8 +90,7 @@ void growable_array::append(array* elts_) {
 
 // Allocates memory
 void growable_array::trim() {
-  factor_vm* parent = elements.parent;
-  elements = parent->reallot_array(elements.untagged(), count);
+  reallot_array(count);
 }
 
 }

diff --git a/vm/arrays.hpp b/vm/arrays.hpp
index d1c0df1363cdc91e7abdaa49ace0126972edc6ad..6be877b63d412cb45f3878c487904286d22f88eb 100644 (file)
--- a/vm/arrays.hpp
+++ b/vm/arrays.hpp
@@ -23,6 +23,7 @@ struct growable_array {
       : count(0),
         elements(parent->allot_array(capacity, false_object), parent) {}
 
+  void reallot_array(cell count);
   void add(cell elt);
   void append(array* elts);
   void trim();

diff --git a/vm/bignum.cpp b/vm/bignum.cpp
index 34b7dd5a8429318c2028bb93494e439fd4145d17..45024ba45ba37c495d9c480bae8162cabc4a01f1 100644 (file)
--- a/vm/bignum.cpp
+++ b/vm/bignum.cpp
@@ -797,7 +797,7 @@ void factor_vm::bignum_divide_unsigned_large_denominator(
         bignum_destructive_unnormalization(u.untagged(), shift);
     }
 
-    q = bignum_trim(q.untagged());
+    q.set_untagged(bignum_trim(q.untagged()));
     *quotient = q.untagged();
   } else {
 
@@ -821,7 +821,7 @@ void factor_vm::bignum_divide_unsigned_large_denominator(
       }
   }
 
-  u = bignum_trim(u.untagged());
+  u.set_untagged(bignum_trim(u.untagged()));
   if (remainder != NULL)
     *remainder = u.untagged();
 }
@@ -996,7 +996,7 @@ void factor_vm::bignum_divide_unsigned_medium_denominator(
       (*scan) = qj;
     }
 
-    q = bignum_trim(q.untagged());
+    q.set_untagged(bignum_trim(q.untagged()));
 
     if (remainder != ((bignum**)0)) {
       if (shift != 0)
@@ -1179,7 +1179,7 @@ void factor_vm::bignum_divide_unsigned_small_denominator(
 
   bignum_digit_type r = bignum_destructive_scale_down(q.untagged(), denominator);
 
-  q = bignum_trim(q.untagged());
+  q.set_untagged(bignum_trim(q.untagged()));
 
   if (remainder != ((bignum**)0))
     (*remainder) = bignum_digit_to_bignum(r, r_negative_p);
@@ -1797,7 +1797,7 @@ bignum* factor_vm::bignum_gcd(bignum* a_, bignum* b_) {
       }
       data_root<bignum> e(bignum_trim(a.untagged()), this);
       data_root<bignum> f(bignum_trim(b.untagged()), this);
-      c = bignum_remainder(e.untagged(), f.untagged());
+      c.set_untagged(bignum_remainder(e.untagged(), f.untagged()));
       if (c.untagged() == BIGNUM_OUT_OF_BAND) {
         return c.untagged();
       }

diff --git a/vm/byte_arrays.cpp b/vm/byte_arrays.cpp
index 794bd64eec01f66b2d28fe5164cb709c286d05e8..4c83a9de7464ee8feb9d52f8d975da9ee0d44902 100644 (file)
--- a/vm/byte_arrays.cpp
+++ b/vm/byte_arrays.cpp
@@ -29,11 +29,19 @@ void factor_vm::primitive_resize_byte_array() {
   ctx->push(tag<byte_array>(reallot_array(array.untagged(), capacity)));
 }
 
+// Allocates memory
+void growable_byte_array::reallot_array(cell count) {
+  byte_array *ba_old = elements.untagged();
+  byte_array *ba_new = elements.parent->reallot_array(ba_old, count);
+  elements.set_untagged(ba_new);
+}
+
 // Allocates memory
 void growable_byte_array::grow_bytes(cell len) {
   count += len;
-  if (count >= array_capacity(elements.untagged()))
-    elements = elements.parent->reallot_array(elements.untagged(), count * 2);
+  if (count >= array_capacity(elements.untagged())) {
+    reallot_array(2 * count);
+  }
 }
 
 // Allocates memory
@@ -49,9 +57,9 @@ void growable_byte_array::append_byte_array(cell byte_array_) {
 
   cell len = array_capacity(byte_array.untagged());
   cell new_size = count + len;
-  factor_vm* parent = elements.parent;
-  if (new_size >= array_capacity(elements.untagged()))
-    elements = parent->reallot_array(elements.untagged(), new_size * 2);
+  if (new_size >= array_capacity(elements.untagged())) {
+    reallot_array(2 * new_size);
+  }
 
   memcpy(&elements->data<uint8_t>()[count], byte_array->data<uint8_t>(), len);
 
@@ -60,8 +68,7 @@ void growable_byte_array::append_byte_array(cell byte_array_) {
 
 // Allocates memory
 void growable_byte_array::trim() {
-  factor_vm* parent = elements.parent;
-  elements = parent->reallot_array(elements.untagged(), count);
+  reallot_array(count);
 }
 
 }

diff --git a/vm/byte_arrays.hpp b/vm/byte_arrays.hpp
index 00c94c0d2450e1fb12fd2d3ddad3eadc76826c9b..2978d94de1f4c22cc61b88431351684e686daa6a 100644 (file)
--- a/vm/byte_arrays.hpp
+++ b/vm/byte_arrays.hpp
@@ -8,6 +8,7 @@ struct growable_byte_array {
   growable_byte_array(factor_vm* parent, cell capacity = 40)
       : count(0), elements(parent->allot_byte_array(capacity), parent) {}
 
+  void reallot_array(cell count);
   void grow_bytes(cell len);
   void append_bytes(void* elts, cell len);
   void append_byte_array(cell elts);

diff --git a/vm/data_roots.hpp b/vm/data_roots.hpp
index a7c702408c4e7b92931e4d294de08acb987a9d10..c0e4ce68f36fdfb018547ef8e73fdf01480f2d59 100644 (file)
--- a/vm/data_roots.hpp
+++ b/vm/data_roots.hpp
@@ -18,15 +18,6 @@ template <typename Type> struct data_root : public tagged<Type> {
     push();
   }
 
-  const data_root<Type>& operator=(const Type* x) {
-    tagged<Type>::operator=(x);
-    return *this;
-  }
-  const data_root<Type>& operator=(const cell& x) {
-    tagged<Type>::operator=(x);
-    return *this;
-  }
-
   ~data_root() {
     parent->data_roots.pop_back();
   }

diff --git a/vm/quotations.cpp b/vm/quotations.cpp
index f9317fb4f39ddbec6298fb12c15a7b95fd3b3b3b..d4c99655661ce12d8cc0cf2dc44cfd8bdb5d0317 100644 (file)
--- a/vm/quotations.cpp
+++ b/vm/quotations.cpp
@@ -43,7 +43,7 @@ inline cell quotation_jit::nth(cell index) {
 }
 
 void quotation_jit::init_quotation(cell quot) {
-  elements = untag<quotation>(quot)->array;
+  elements.set_value(untag<quotation>(quot)->array);
 }
 
 bool quotation_jit::fast_if_p(cell i, cell length) {

diff --git a/vm/tagged.hpp b/vm/tagged.hpp
index c9a77da67640a17199ff42b6deb739dc80445a0b..7d86ba73cca04df2be4c011c962ff5e82fa52807 100644 (file)
--- a/vm/tagged.hpp
+++ b/vm/tagged.hpp
@@ -32,18 +32,17 @@ template <typename Type> struct tagged {
   explicit tagged(cell tagged) : value_(tagged) {}
   explicit tagged(Type* untagged) : value_(factor::tag(untagged)) {}
 
-  Type* operator->() const { return untagged(); }
-  cell* operator&() const { return &value_; }
-
-  const tagged<Type>& operator=(const Type* x) {
-    value_ = tag(x);
-    return *this;
+  void set_value(const cell ptr) {
+    value_ = ptr;
   }
-  const tagged<Type>& operator=(const cell& x) {
-    value_ = x;
-    return *this;
+
+  void set_untagged(const Type *untagged) {
+    set_value(tag(untagged));
   }
 
+  Type* operator->() const { return untagged(); }
+  cell* operator&() const { return &value_; }
+
   bool operator==(const tagged<Type>& x) { return value_ == x.value_; }
   bool operator!=(const tagged<Type>& x) { return value_ != x.value_; }