From 7661ed3b57a24df050a80e7bd49457b795544175 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Bj=C3=B6rn=20Lindqvist?= Date: Wed, 23 Nov 2016 03:25:07 +0100 Subject: [PATCH] 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. --- vm/arrays.cpp | 19 ++++++++++++------- vm/arrays.hpp | 1 + vm/bignum.cpp | 10 +++++----- vm/byte_arrays.cpp | 21 ++++++++++++++------- vm/byte_arrays.hpp | 1 + vm/data_roots.hpp | 9 --------- vm/quotations.cpp | 2 +- vm/tagged.hpp | 17 ++++++++--------- 8 files changed, 42 insertions(+), 38 deletions(-) diff --git a/vm/arrays.cpp b/vm/arrays.cpp index 9a32c13913..b3d8e698fe 100644 --- a/vm/arrays.cpp +++ b/vm/arrays.cpp @@ -57,13 +57,20 @@ cell factor_vm::std_vector_to_array(std::vector& 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 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 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 d1c0df1363..6be877b63d 100644 --- 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 34b7dd5a84..45024ba45b 100644 --- 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 e(bignum_trim(a.untagged()), this); data_root 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 794bd64eec..4c83a9de74 100644 --- a/vm/byte_arrays.cpp +++ b/vm/byte_arrays.cpp @@ -29,11 +29,19 @@ void factor_vm::primitive_resize_byte_array() { ctx->push(tag(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()[count], byte_array->data(), 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 00c94c0d24..2978d94de1 100644 --- 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 a7c702408c..c0e4ce68f3 100644 --- a/vm/data_roots.hpp +++ b/vm/data_roots.hpp @@ -18,15 +18,6 @@ template struct data_root : public tagged { push(); } - const data_root& operator=(const Type* x) { - tagged::operator=(x); - return *this; - } - const data_root& operator=(const cell& x) { - tagged::operator=(x); - return *this; - } - ~data_root() { parent->data_roots.pop_back(); } diff --git a/vm/quotations.cpp b/vm/quotations.cpp index f9317fb4f3..d4c9965566 100644 --- 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(quot)->array; + elements.set_value(untag(quot)->array); } bool quotation_jit::fast_if_p(cell i, cell length) { diff --git a/vm/tagged.hpp b/vm/tagged.hpp index c9a77da676..7d86ba73cc 100644 --- a/vm/tagged.hpp +++ b/vm/tagged.hpp @@ -32,18 +32,17 @@ template 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& operator=(const Type* x) { - value_ = tag(x); - return *this; + void set_value(const cell ptr) { + value_ = ptr; } - const tagged& 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& x) { return value_ == x.value_; } bool operator!=(const tagged& x) { return value_ != x.value_; } -- 2.34.1