VM: Refactor arrays.cpp/hpp to Factor style

diff --git a/vm/arrays.cpp b/vm/arrays.cpp
index 5896325bbc56118e2a36aa75920054c6220375ea..45c5196158a35c7717a512495189fad524b1627b 100644 (file)
--- a/vm/arrays.cpp
+++ b/vm/arrays.cpp
@@ -1,117 +1,106 @@
 #include "master.hpp"
 
-namespace factor
-{
+namespace factor {
 
 /* Allocates memory */
-array *factor_vm::allot_array(cell capacity, cell fill_)
-{
-       data_root<object> fill(fill_,this);
-       array *new_array = allot_uninitialized_array<array>(capacity);
-       memset_cell(new_array->data(),fill.value(),capacity * sizeof(cell));
-       return new_array;
+array* factor_vm::allot_array(cell capacity, cell fill_) {
+  data_root<object> fill(fill_, this);
+  array* new_array = allot_uninitialized_array<array>(capacity);
+  memset_cell(new_array->data(), fill.value(), capacity * sizeof(cell));
+  return new_array;
 }
 
 /* Allocates memory */
-void factor_vm::primitive_array()
-{
-       data_root<object> fill(ctx->pop(),this);
-       cell capacity = unbox_array_size();
-       array *new_array = allot_uninitialized_array<array>(capacity);
-       memset_cell(new_array->data(),fill.value(),capacity * sizeof(cell));
-       ctx->push(tag<array>(new_array));
+void factor_vm::primitive_array() {
+  data_root<object> fill(ctx->pop(), this);
+  cell capacity = unbox_array_size();
+  array* new_array = allot_uninitialized_array<array>(capacity);
+  memset_cell(new_array->data(), fill.value(), capacity * sizeof(cell));
+  ctx->push(tag<array>(new_array));
 }
 
 /* Allocates memory */
-cell factor_vm::allot_array_1(cell obj_)
-{
-       data_root<object> obj(obj_,this);
-       data_root<array> a(allot_uninitialized_array<array>(1),this);
-       set_array_nth(a.untagged(),0,obj.value());
-       return a.value();
+cell factor_vm::allot_array_1(cell obj_) {
+  data_root<object> obj(obj_, this);
+  data_root<array> a(allot_uninitialized_array<array>(1), this);
+  set_array_nth(a.untagged(), 0, obj.value());
+  return a.value();
 }
 
 /* Allocates memory */
-cell factor_vm::allot_array_2(cell v1_, cell v2_)
-{
-       data_root<object> v1(v1_,this);
-       data_root<object> v2(v2_,this);
-       data_root<array> a(allot_uninitialized_array<array>(2),this);
-       set_array_nth(a.untagged(),0,v1.value());
-       set_array_nth(a.untagged(),1,v2.value());
-       return a.value();
+cell factor_vm::allot_array_2(cell v1_, cell v2_) {
+  data_root<object> v1(v1_, this);
+  data_root<object> v2(v2_, this);
+  data_root<array> a(allot_uninitialized_array<array>(2), this);
+  set_array_nth(a.untagged(), 0, v1.value());
+  set_array_nth(a.untagged(), 1, v2.value());
+  return a.value();
 }
 
 /* Allocates memory */
-cell factor_vm::allot_array_4(cell v1_, cell v2_, cell v3_, cell v4_)
-{
-       data_root<object> v1(v1_,this);
-       data_root<object> v2(v2_,this);
-       data_root<object> v3(v3_,this);
-       data_root<object> v4(v4_,this);
-       data_root<array> a(allot_uninitialized_array<array>(4),this);
-       set_array_nth(a.untagged(),0,v1.value());
-       set_array_nth(a.untagged(),1,v2.value());
-       set_array_nth(a.untagged(),2,v3.value());
-       set_array_nth(a.untagged(),3,v4.value());
-       return a.value();
+cell factor_vm::allot_array_4(cell v1_, cell v2_, cell v3_, cell v4_) {
+  data_root<object> v1(v1_, this);
+  data_root<object> v2(v2_, this);
+  data_root<object> v3(v3_, this);
+  data_root<object> v4(v4_, this);
+  data_root<array> a(allot_uninitialized_array<array>(4), this);
+  set_array_nth(a.untagged(), 0, v1.value());
+  set_array_nth(a.untagged(), 1, v2.value());
+  set_array_nth(a.untagged(), 2, v3.value());
+  set_array_nth(a.untagged(), 3, v4.value());
+  return a.value();
 }
 
 /* Allocates memory */
-void factor_vm::primitive_resize_array()
-{
-       data_root<array> a(ctx->pop(),this);
-       a.untag_check(this);
-       cell capacity = unbox_array_size();
-       ctx->push(tag<array>(reallot_array(a.untagged(),capacity)));
+void factor_vm::primitive_resize_array() {
+  data_root<array> a(ctx->pop(), this);
+  a.untag_check(this);
+  cell capacity = unbox_array_size();
+  ctx->push(tag<array>(reallot_array(a.untagged(), capacity)));
 }
 
 /* Allocates memory */
-cell factor_vm::std_vector_to_array(std::vector<cell> &elements)
-{
-       cell element_count = elements.size();
-       data_roots.push_back(data_root_range(&elements[0],element_count));
+cell factor_vm::std_vector_to_array(std::vector<cell>& elements) {
+  cell element_count = elements.size();
+  data_roots.push_back(data_root_range(&elements[0], element_count));
 
-       tagged<array> objects(allot_uninitialized_array<array>(element_count));
-       memcpy(objects->data(),&elements[0],element_count * sizeof(cell));
+  tagged<array> objects(allot_uninitialized_array<array>(element_count));
+  memcpy(objects->data(), &elements[0], element_count * sizeof(cell));
 
-       data_roots.pop_back();
+  data_roots.pop_back();
 
-       return objects.value();
+  return objects.value();
 }
 
 /* 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);
-
-       parent->set_array_nth(elements.untagged(),count++,elt.value());
+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);
+
+  parent->set_array_nth(elements.untagged(), count++, elt.value());
 }
 
 /* Allocates memory */
-void growable_array::append(array *elts_)
-{
-       factor_vm *parent = elements.parent;
-       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);
-       }
-
-       for(cell index = 0; index < capacity; index++)
-               parent->set_array_nth(elements.untagged(),count++,array_nth(elts.untagged(),index));
+void growable_array::append(array* elts_) {
+  factor_vm* parent = elements.parent;
+  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);
+  }
+
+  for (cell index = 0; index < capacity; index++)
+    parent->set_array_nth(elements.untagged(), count++,
+                          array_nth(elts.untagged(), index));
 }
 
 /* Allocates memory */
-void growable_array::trim()
-{
-       factor_vm *parent = elements.parent;
-       elements = parent->reallot_array(elements.untagged(),count);
+void growable_array::trim() {
+  factor_vm* parent = elements.parent;
+  elements = parent->reallot_array(elements.untagged(), count);
 }
 
 }

diff --git a/vm/arrays.hpp b/vm/arrays.hpp
index e374b97659dde9bce5bb03208c372f81183d747d..e863b5504f55a2234cc338fba8971fb214914bdc 100644 (file)
--- a/vm/arrays.hpp
+++ b/vm/arrays.hpp
@@ -1,36 +1,34 @@
-namespace factor
-{
+namespace factor {
 
-inline cell array_nth(array *array, cell slot)
-{
+inline cell array_nth(array* array, cell slot) {
 #ifdef FACTOR_DEBUG
-       FACTOR_ASSERT(slot < array_capacity(array));
-       FACTOR_ASSERT(array->type() == ARRAY_TYPE);
+  FACTOR_ASSERT(slot < array_capacity(array));
+  FACTOR_ASSERT(array->type() == ARRAY_TYPE);
 #endif
-       return array->data()[slot];
+  return array->data()[slot];
 }
 
-inline void factor_vm::set_array_nth(array *array, cell slot, cell value)
-{
+inline void factor_vm::set_array_nth(array* array, cell slot, cell value) {
 #ifdef FACTOR_DEBUG
-       FACTOR_ASSERT(slot < array_capacity(array));
-       FACTOR_ASSERT(array->type() == ARRAY_TYPE);
+  FACTOR_ASSERT(slot < array_capacity(array));
+  FACTOR_ASSERT(array->type() == ARRAY_TYPE);
 #endif
-       cell *slot_ptr = &array->data()[slot];
-       *slot_ptr = value;
-       write_barrier(slot_ptr);
+  cell* slot_ptr = &array->data()[slot];
+  *slot_ptr = value;
+  write_barrier(slot_ptr);
 }
 
 struct growable_array {
-       cell count;
-       data_root<array> elements;
+  cell count;
+  data_root<array> elements;
 
-       explicit growable_array(factor_vm *parent, cell capacity = 10) :
-               count(0), elements(parent->allot_array(capacity,false_object),parent) {}
+  explicit growable_array(factor_vm* parent, cell capacity = 10)
+      : count(0),
+        elements(parent->allot_array(capacity, false_object), parent) {}
 
-       void add(cell elt);
-       void append(array *elts);
-       void trim();
+  void add(cell elt);
+  void append(array* elts);
+  void trim();
 };
 
 }