vm/arrays.cpp

   1 #include "master.hpp"
   2
   3 namespace factor {
   4
   5 /* Allocates memory */
   6 array* factor_vm::allot_array(cell capacity, cell fill_) {
   7   data_root<object> fill(fill_, this);
   8   array* new_array = allot_uninitialized_array<array>(capacity);
   9   memset_cell(new_array->data(), fill.value(), capacity * sizeof(cell));
  10   return new_array;
  11 }
  12
  13 /* Allocates memory */
  14 void factor_vm::primitive_array() {
  15   cell fill = ctx->pop();
  16   cell capacity = unbox_array_size();
  17   array* new_array = allot_array(capacity, fill);
  18   ctx->push(tag<array>(new_array));
  19 }
  20
  21 /* Allocates memory */
  22 cell factor_vm::allot_array_4(cell v1_, cell v2_, cell v3_, cell v4_) {
  23   data_root<object> v1(v1_, this);
  24   data_root<object> v2(v2_, this);
  25   data_root<object> v3(v3_, this);
  26   data_root<object> v4(v4_, this);
  27   data_root<array> a(allot_uninitialized_array<array>(4), this);
  28   set_array_nth(a.untagged(), 0, v1.value());
  29   set_array_nth(a.untagged(), 1, v2.value());
  30   set_array_nth(a.untagged(), 2, v3.value());
  31   set_array_nth(a.untagged(), 3, v4.value());
  32   return a.value();
  33 }
  34
  35 /* Allocates memory */
  36 void factor_vm::primitive_resize_array() {
  37   data_root<array> a(ctx->pop(), this);
  38   a.untag_check(this);
  39   cell capacity = unbox_array_size();
  40   ctx->push(tag<array>(reallot_array(a.untagged(), capacity)));
  41 }
  42
  43 /* Allocates memory */
  44 cell factor_vm::std_vector_to_array(std::vector<cell>& elements) {
  45   cell element_count = elements.size();
  46   data_roots.push_back(data_root_range(&elements[0], element_count));
  47
  48   tagged<array> objects(allot_uninitialized_array<array>(element_count));
  49   memcpy(objects->data(), &elements[0], element_count * sizeof(cell));
  50
  51   data_roots.pop_back();
  52
  53   return objects.value();
  54 }
  55
  56 /* Allocates memory */
  57 void growable_array::add(cell elt_) {
  58   factor_vm* parent = elements.parent;
  59   data_root<object> elt(elt_, parent);
  60   if (count == array_capacity(elements.untagged()))
  61     elements = parent->reallot_array(elements.untagged(), count * 2);
  62
  63   parent->set_array_nth(elements.untagged(), count++, elt.value());
  64 }
  65
  66 /* Allocates memory */
  67 void growable_array::append(array* elts_) {
  68   factor_vm* parent = elements.parent;
  69   data_root<array> elts(elts_, parent);
  70   cell capacity = array_capacity(elts.untagged());
  71   if (count + capacity > array_capacity(elements.untagged())) {
  72     elements =
  73         parent->reallot_array(elements.untagged(), (count + capacity) * 2);
  74   }
  75
  76   for (cell index = 0; index < capacity; index++)
  77     parent->set_array_nth(elements.untagged(), count++,
  78                           array_nth(elts.untagged(), index));
  79 }
  80
  81 /* Allocates memory */
  82 void growable_array::trim() {
  83   factor_vm* parent = elements.parent;
  84   elements = parent->reallot_array(elements.untagged(), count);
  85 }
  86
  87 }