#include "master.hpp"
-namespace factor
-{
+namespace factor {
-/* make a new array with an initial element */
-array *factor_vm::allot_array(cell capacity, cell fill_)
-{
- gc_root<object> fill(fill_,this);
- gc_root<array> new_array(allot_array_internal<array>(capacity),this);
- memset_cell(new_array->data(),fill.value(),capacity * sizeof(cell));
- return new_array.untagged();
+// 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;
}
-/* push a new array on the stack */
-void factor_vm::primitive_array()
-{
- cell initial = dpop();
- cell size = unbox_array_size();
- dpush(tag<array>(allot_array(size,initial)));
+// Allocates memory
+void factor_vm::primitive_array() {
+ cell fill = ctx->pop();
+ cell capacity = unbox_array_size();
+ array* new_array = allot_array(capacity, fill);
+ ctx->push(tag<array>(new_array));
}
-cell factor_vm::allot_array_1(cell obj_)
-{
- gc_root<object> obj(obj_,this);
- gc_root<array> a(allot_array_internal<array>(1),this);
- set_array_nth(a.untagged(),0,obj.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);
+ array *a = allot_uninitialized_array<array>(4);
+ set_array_nth(a, 0, v1.value());
+ set_array_nth(a, 1, v2.value());
+ set_array_nth(a, 2, v3.value());
+ set_array_nth(a, 3, v4.value());
+ return tag<array>(a);
}
-cell factor_vm::allot_array_2(cell v1_, cell v2_)
-{
- gc_root<object> v1(v1_,this);
- gc_root<object> v2(v2_,this);
- gc_root<array> a(allot_array_internal<array>(2),this);
- set_array_nth(a.untagged(),0,v1.value());
- set_array_nth(a.untagged(),1,v2.value());
- return a.value();
+// Allocates memory
+void factor_vm::primitive_resize_array() {
+ data_root<array> a(ctx->pop(), this);
+ check_tagged(a);
+ cell capacity = unbox_array_size();
+ ctx->push(tag<array>(reallot_array(a.untagged(), capacity)));
}
-cell factor_vm::allot_array_4(cell v1_, cell v2_, cell v3_, cell v4_)
-{
- gc_root<object> v1(v1_,this);
- gc_root<object> v2(v2_,this);
- gc_root<object> v3(v3_,this);
- gc_root<object> v4(v4_,this);
- gc_root<array> a(allot_array_internal<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
+cell factor_vm::std_vector_to_array(std::vector<cell>& elements) {
+
+ cell element_count = elements.size();
+ cell orig_size = data_roots.size();
+ data_roots.reserve(orig_size + element_count);
-void factor_vm::primitive_resize_array()
-{
- array *a = untag_check<array>(dpop());
- cell capacity = unbox_array_size();
- dpush(tag<array>(reallot_array(a,capacity)));
+ for (cell n = 0; n < element_count; n++) {
+ data_roots.push_back(&elements[n]);
+ }
+
+ tagged<array> objects(allot_uninitialized_array<array>(element_count));
+ memcpy(objects->data(), &elements[0], element_count * sizeof(cell));
+ data_roots.resize(orig_size);
+ return objects.value();
}
-void growable_array::add(cell elt_)
-{
- factor_vm *parent = elements.parent;
- gc_root<object> elt(elt_,parent);
- if(count == array_capacity(elements.untagged()))
- elements = parent->reallot_array(elements.untagged(),count * 2);
+// 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);
+}
- parent->set_array_nth(elements.untagged(),count++,elt.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())) {
+ reallot_array(2 * count);
+ }
+ parent->set_array_nth(elements.untagged(), count++, elt.value());
}
-void growable_array::append(array *elts_)
-{
- factor_vm *parent = elements.parent;
- gc_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);
- }
+// 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())) {
+ reallot_array(2 * (count + capacity));
+ }
- for(cell index = 0; index < capacity; index++)
- parent->set_array_nth(elements.untagged(),count++,array_nth(elts.untagged(),index));
+ for (cell index = 0; index < capacity; index++)
+ parent->set_array_nth(elements.untagged(), count++,
+ array_nth(elts.untagged(), index));
}
-void growable_array::trim()
-{
- factor_vm *parent = elements.parent;
- elements = parent->reallot_array(elements.untagged(),count);
+// Allocates memory
+void growable_array::trim() {
+ reallot_array(count);
}
}