vm/arrays.cpp

   1 #include "master.hpp"
   2
   3 namespace factor
   4 {
   5
   6 /* make a new array with an initial element */
   7 array *factor_vm::allot_array(cell capacity, cell fill_)
   8 {
   9         gc_root<object> fill(fill_,this);
  10         gc_root<array> new_array(allot_array_internal<array>(capacity),this);
  11         memset_cell(new_array->data(),fill.value(),capacity * sizeof(cell));
  12         return new_array.untagged();
  13 }
  14
  15 /* push a new array on the stack */
  16 void factor_vm::primitive_array()
  17 {
  18         cell initial = dpop();
  19         cell size = unbox_array_size();
  20         dpush(tag<array>(allot_array(size,initial)));
  21 }
  22
  23 cell factor_vm::allot_array_1(cell obj_)
  24 {
  25         gc_root<object> obj(obj_,this);
  26         gc_root<array> a(allot_array_internal<array>(1),this);
  27         set_array_nth(a.untagged(),0,obj.value());
  28         return a.value();
  29 }
  30
  31 cell factor_vm::allot_array_2(cell v1_, cell v2_)
  32 {
  33         gc_root<object> v1(v1_,this);
  34         gc_root<object> v2(v2_,this);
  35         gc_root<array> a(allot_array_internal<array>(2),this);
  36         set_array_nth(a.untagged(),0,v1.value());
  37         set_array_nth(a.untagged(),1,v2.value());
  38         return a.value();
  39 }
  40
  41 cell factor_vm::allot_array_4(cell v1_, cell v2_, cell v3_, cell v4_)
  42 {
  43         gc_root<object> v1(v1_,this);
  44         gc_root<object> v2(v2_,this);
  45         gc_root<object> v3(v3_,this);
  46         gc_root<object> v4(v4_,this);
  47         gc_root<array> a(allot_array_internal<array>(4),this);
  48         set_array_nth(a.untagged(),0,v1.value());
  49         set_array_nth(a.untagged(),1,v2.value());
  50         set_array_nth(a.untagged(),2,v3.value());
  51         set_array_nth(a.untagged(),3,v4.value());
  52         return a.value();
  53 }
  54
  55 void factor_vm::primitive_resize_array()
  56 {
  57         array *a = untag_check<array>(dpop());
  58         cell capacity = unbox_array_size();
  59         dpush(tag<array>(reallot_array(a,capacity)));
  60 }
  61
  62 void growable_array::add(cell elt_)
  63 {
  64         factor_vm *parent = elements.parent;
  65         gc_root<object> elt(elt_,parent);
  66         if(count == array_capacity(elements.untagged()))
  67                 elements = parent->reallot_array(elements.untagged(),count * 2);
  68
  69         parent->set_array_nth(elements.untagged(),count++,elt.value());
  70 }
  71
  72 void growable_array::append(array *elts_)
  73 {
  74         factor_vm *parent = elements.parent;
  75         gc_root<array> elts(elts_,parent);
  76         cell capacity = array_capacity(elts.untagged());
  77         if(count + capacity > array_capacity(elements.untagged()))
  78         {
  79                 elements = parent->reallot_array(elements.untagged(),
  80                         (count + capacity) * 2);
  81         }
  82
  83         for(cell index = 0; index < capacity; index++)
  84                 parent->set_array_nth(elements.untagged(),count++,array_nth(elts.untagged(),index));
  85 }
  86
  87 void growable_array::trim()
  88 {
  89         factor_vm *parent = elements.parent;
  90         elements = parent->reallot_array(elements.untagged(),count);
  91 }
  92
  93 }