steve
/
factor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

VM: Refactor arrays.cpp/hpp to Factor style

db4
Erik Charlebois 2013-05-11 21:41:14 -04:00
parent a437576dc9
commit 76375afd1c
2 changed files with 86 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

117
vm/arrays.cpp
View File

@ -1,79 +1,71 @@
#include "master.hpp" #include "master.hpp"
namespace factor namespace factor {
{
/* Allocates memory */ /* Allocates memory */
array *factor_vm::allot_array(cell capacity, cell fill_) array* factor_vm::allot_array(cell capacity, cell fill_) {
{ data_root<object> fill(fill_, this);
data_root<object> fill(fill_,this); array* new_array = allot_uninitialized_array<array>(capacity);
array *new_array = allot_uninitialized_array<array>(capacity); memset_cell(new_array->data(), fill.value(), capacity * sizeof(cell));
memset_cell(new_array->data(),fill.value(),capacity * sizeof(cell));
return new_array; return new_array;
} }
/* Allocates memory */ /* Allocates memory */
void factor_vm::primitive_array() void factor_vm::primitive_array() {
{ data_root<object> fill(ctx->pop(), this);
data_root<object> fill(ctx->pop(),this);
cell capacity = unbox_array_size(); cell capacity = unbox_array_size();
array *new_array = allot_uninitialized_array<array>(capacity); array* new_array = allot_uninitialized_array<array>(capacity);
memset_cell(new_array->data(),fill.value(),capacity * sizeof(cell)); memset_cell(new_array->data(), fill.value(), capacity * sizeof(cell));
ctx->push(tag<array>(new_array)); ctx->push(tag<array>(new_array));
} }
/* Allocates memory */ /* Allocates memory */
cell factor_vm::allot_array_1(cell obj_) cell factor_vm::allot_array_1(cell obj_) {
{ data_root<object> obj(obj_, this);
data_root<object> obj(obj_,this); data_root<array> a(allot_uninitialized_array<array>(1), this);
data_root<array> a(allot_uninitialized_array<array>(1),this); set_array_nth(a.untagged(), 0, obj.value());
set_array_nth(a.untagged(),0,obj.value());
return a.value(); return a.value();
} }
/* Allocates memory */ /* Allocates memory */
cell factor_vm::allot_array_2(cell v1_, cell v2_) cell factor_vm::allot_array_2(cell v1_, cell v2_) {
{ data_root<object> v1(v1_, this);
data_root<object> v1(v1_,this); data_root<object> v2(v2_, this);
data_root<object> v2(v2_,this); data_root<array> a(allot_uninitialized_array<array>(2), this);
data_root<array> a(allot_uninitialized_array<array>(2),this); set_array_nth(a.untagged(), 0, v1.value());
set_array_nth(a.untagged(),0,v1.value()); set_array_nth(a.untagged(), 1, v2.value());
set_array_nth(a.untagged(),1,v2.value());
return a.value(); return a.value();
} }
/* Allocates memory */ /* Allocates memory */
cell factor_vm::allot_array_4(cell v1_, cell v2_, cell v3_, cell v4_) cell factor_vm::allot_array_4(cell v1_, cell v2_, cell v3_, cell v4_) {
{ data_root<object> v1(v1_, this);
data_root<object> v1(v1_,this); data_root<object> v2(v2_, this);
data_root<object> v2(v2_,this); data_root<object> v3(v3_, this);
data_root<object> v3(v3_,this); data_root<object> v4(v4_, this);
data_root<object> v4(v4_,this); data_root<array> a(allot_uninitialized_array<array>(4), this);
data_root<array> a(allot_uninitialized_array<array>(4),this); set_array_nth(a.untagged(), 0, v1.value());
set_array_nth(a.untagged(),0,v1.value()); set_array_nth(a.untagged(), 1, v2.value());
set_array_nth(a.untagged(),1,v2.value()); set_array_nth(a.untagged(), 2, v3.value());
set_array_nth(a.untagged(),2,v3.value()); set_array_nth(a.untagged(), 3, v4.value());
set_array_nth(a.untagged(),3,v4.value());
return a.value(); return a.value();
} }
/* Allocates memory */ /* Allocates memory */
void factor_vm::primitive_resize_array() void factor_vm::primitive_resize_array() {
{ data_root<array> a(ctx->pop(), this);
data_root<array> a(ctx->pop(),this);
a.untag_check(this); a.untag_check(this);
cell capacity = unbox_array_size(); cell capacity = unbox_array_size();
ctx->push(tag<array>(reallot_array(a.untagged(),capacity))); ctx->push(tag<array>(reallot_array(a.untagged(), capacity)));
} }
/* Allocates memory */ /* Allocates memory */
cell factor_vm::std_vector_to_array(std::vector<cell> &elements) cell factor_vm::std_vector_to_array(std::vector<cell>& elements) {
{
cell element_count = elements.size(); cell element_count = elements.size();
data_roots.push_back(data_root_range(&elements[0],element_count)); data_roots.push_back(data_root_range(&elements[0], element_count));
tagged<array> objects(allot_uninitialized_array<array>(element_count)); tagged<array> objects(allot_uninitialized_array<array>(element_count));
memcpy(objects->data(),&elements[0],element_count * sizeof(cell)); memcpy(objects->data(), &elements[0], element_count * sizeof(cell));
data_roots.pop_back(); data_roots.pop_back();
@ -81,37 +73,34 @@ cell factor_vm::std_vector_to_array(std::vector<cell> &elements)
} }
/* Allocates memory */ /* Allocates memory */
void growable_array::add(cell elt_) void growable_array::add(cell elt_) {
{ factor_vm* parent = elements.parent;
factor_vm *parent = elements.parent; data_root<object> elt(elt_, parent);
data_root<object> elt(elt_,parent); if (count == array_capacity(elements.untagged()))
if(count == array_capacity(elements.untagged())) elements = parent->reallot_array(elements.untagged(), count * 2);
elements = parent->reallot_array(elements.untagged(),count * 2);
parent->set_array_nth(elements.untagged(),count++,elt.value()); parent->set_array_nth(elements.untagged(), count++, elt.value());
} }
/* Allocates memory */ /* Allocates memory */
void growable_array::append(array *elts_) void growable_array::append(array* elts_) {
{ factor_vm* parent = elements.parent;
factor_vm *parent = elements.parent; data_root<array> elts(elts_, parent);
data_root<array> elts(elts_,parent);
cell capacity = array_capacity(elts.untagged()); cell capacity = array_capacity(elts.untagged());
if(count + capacity > array_capacity(elements.untagged())) if (count + capacity > array_capacity(elements.untagged())) {
{ elements =
elements = parent->reallot_array(elements.untagged(), parent->reallot_array(elements.untagged(), (count + capacity) * 2);
(count + capacity) * 2);
} }
for(cell index = 0; index < capacity; index++) for (cell index = 0; index < capacity; index++)
parent->set_array_nth(elements.untagged(),count++,array_nth(elts.untagged(),index)); parent->set_array_nth(elements.untagged(), count++,
array_nth(elts.untagged(), index));
} }
/* Allocates memory */ /* Allocates memory */
void growable_array::trim() void growable_array::trim() {
{ factor_vm* parent = elements.parent;
factor_vm *parent = elements.parent; elements = parent->reallot_array(elements.untagged(), count);
elements = parent->reallot_array(elements.untagged(),count);
} }
} }

18
vm/arrays.hpp
View File

@ -1,8 +1,6 @@
namespace factor namespace factor {
{
inline cell array_nth(array *array, cell slot) inline cell array_nth(array* array, cell slot) {
{
#ifdef FACTOR_DEBUG #ifdef FACTOR_DEBUG
FACTOR_ASSERT(slot < array_capacity(array)); FACTOR_ASSERT(slot < array_capacity(array));
FACTOR_ASSERT(array->type() == ARRAY_TYPE); FACTOR_ASSERT(array->type() == ARRAY_TYPE);
@ -10,13 +8,12 @@ inline cell array_nth(array *array, cell slot)
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 #ifdef FACTOR_DEBUG
FACTOR_ASSERT(slot < array_capacity(array)); FACTOR_ASSERT(slot < array_capacity(array));
FACTOR_ASSERT(array->type() == ARRAY_TYPE); FACTOR_ASSERT(array->type() == ARRAY_TYPE);
#endif #endif
cell *slot_ptr = &array->data()[slot]; cell* slot_ptr = &array->data()[slot];
*slot_ptr = value; *slot_ptr = value;
write_barrier(slot_ptr); write_barrier(slot_ptr);
} }
@ -25,11 +22,12 @@ struct growable_array {
cell count; cell count;
data_root<array> elements; data_root<array> elements;
explicit growable_array(factor_vm *parent, cell capacity = 10) : explicit growable_array(factor_vm* parent, cell capacity = 10)
count(0), elements(parent->allot_array(capacity,false_object),parent) {} : count(0),
elements(parent->allot_array(capacity, false_object), parent) {}
void add(cell elt); void add(cell elt);
void append(array *elts); void append(array* elts);
void trim(); void trim();
}; };