audio.engine.test: cleanup using

[factor.git] / vm / generic_arrays.hpp

diff --git a/vm/generic_arrays.hpp b/vm/generic_arrays.hpp
index ac5a353d839f43bbd159f8a861429927c255a5b7..49ba31370c4542478434c6bb22053d44b8500b48 100644 (file)
--- a/vm/generic_arrays.hpp
+++ b/vm/generic_arrays.hpp
@@ -1,77 +1,55 @@
-template<typename T> CELL array_capacity(T *array)
-{
-#ifdef FACTOR_DEBUG
-       CELL header = untag_header(array->header);
-       assert(header == T::type_number);
-#endif
-       return array->capacity >> TAG_BITS;
-}
-
-#define AREF(array,index) ((CELL)(array) + sizeof(F_ARRAY) + (index) * CELLS)
-#define UNAREF(array,ptr) (((CELL)(ptr)-(CELL)(array)-sizeof(F_ARRAY)) / CELLS)
+namespace factor {
 
-template <typename T> CELL array_nth(T *array, CELL slot)
-{
-#ifdef FACTOR_DEBUG
-       assert(slot < array_capacity<T>(array));
-       assert(untag_header(array->header) == T::type_number);
-#endif
-       return get(AREF(array,slot));
+template <typename Array> cell array_capacity(const Array* array) {
+  FACTOR_ASSERT(array->type() == Array::type_number);
+  return array->capacity >> TAG_BITS;
 }
 
-template <typename T> void set_array_nth(T *array, CELL slot, CELL value)
-{
-#ifdef FACTOR_DEBUG
-       assert(slot < array_capacity<T>(array));
-       assert(untag_header(array->header) == T::type_number);
-#endif
-       put(AREF(array,slot),value);
-       write_barrier((CELL)array);
+template <typename Array> cell array_size(cell capacity) {
+  return sizeof(Array) + capacity * Array::element_size;
 }
 
-template <typename T> CELL array_size(CELL capacity)
-{
-       return sizeof(T) + capacity * T::element_size;
+template <typename Array> cell array_size(Array* array) {
+  return array_size<Array>(array_capacity(array));
 }
 
-template <typename T> CELL array_size(T *array)
-{
-       return array_size<T>(array_capacity(array));
+// Allocates memory
+template <typename Array>
+Array* factor_vm::allot_uninitialized_array(cell capacity) {
+  Array* array = allot<Array>(array_size<Array>(capacity));
+  array->capacity = tag_fixnum(capacity);
+  return array;
 }
 
-template <typename T> T *allot_array_internal(CELL capacity)
-{
-       T *array = allot<T>(array_size<T>(capacity));
-       array->capacity = tag_fixnum(capacity);
-       return array;
+template <typename Array>
+bool factor_vm::reallot_array_in_place_p(Array* array, cell capacity) {
+  return data->nursery->contains_p(array) &&
+      capacity <= array_capacity(array);
 }
 
-template <typename T> bool reallot_array_in_place_p(T *array, CELL capacity)
-{
-       return in_zone(&nursery,(CELL)array) && capacity <= array_capacity(array);
-}
+// Allocates memory (sometimes)
+template <typename Array>
+Array* factor_vm::reallot_array(Array* array_, cell capacity) {
+  data_root<Array> array(array_, this);
 
-template <typename T> T *reallot_array(T *array_, CELL capacity)
-{
-       gc_root<T> array(array_);
+  if (array_capacity(array.untagged()) == capacity)
+    return array.untagged();
 
-       if(reallot_array_in_place_p(array.untagged(),capacity))
-       {
-               array->capacity = tag_fixnum(capacity);
-               return array.untagged();
-       }
-       else
-       {
-               CELL to_copy = array_capacity(array.untagged());
-               if(capacity < to_copy)
-                       to_copy = capacity;
+  if (reallot_array_in_place_p(array.untagged(), capacity)) {
+    array->capacity = tag_fixnum(capacity);
+    return array.untagged();
+  }
+  cell to_copy = array_capacity(array.untagged());
+  if (capacity < to_copy)
+    to_copy = capacity;
 
-               T *new_array = allot_array_internal<T>(capacity);
-       
-               memcpy(new_array + 1,array.untagged() + 1,to_copy * T::element_size);
-               memset((char *)(new_array + 1) + to_copy * T::element_size,
-                       0,(capacity - to_copy) * T::element_size);
+  Array* new_array = allot_uninitialized_array<Array>(capacity);
+
+  memcpy(new_array + 1, array.untagged() + 1, to_copy * Array::element_size);
+  memset((char*)(new_array + 1) + to_copy * Array::element_size, 0,
+         (capacity - to_copy) * Array::element_size);
+
+  return new_array;
+}
 
-               return new_array;
-       }
 }