factor/vm/byte_arrays.cpp

#include "master.hpp"

namespace factor
{

byte_array *factor_vm::allot_byte_array(cell size)
{
	byte_array *array = allot_array_internal<byte_array>(size);
	memset(array + 1,0,size);
	return array;
}

inline void factor_vm::primitive_byte_array()
{
	cell size = unbox_array_size();
	dpush(tag<byte_array>(allot_byte_array(size)));
}

PRIMITIVE_FORWARD(byte_array)

inline void factor_vm::primitive_uninitialized_byte_array()
{
	cell size = unbox_array_size();
	dpush(tag<byte_array>(allot_array_internal<byte_array>(size)));
}

PRIMITIVE_FORWARD(uninitialized_byte_array)

inline void factor_vm::primitive_resize_byte_array()
{
	byte_array *array = untag_check<byte_array>(dpop());
	cell capacity = unbox_array_size();
	dpush(tag<byte_array>(reallot_array(array,capacity)));
}

PRIMITIVE_FORWARD(resize_byte_array)

void growable_byte_array::append_bytes(void *elts, cell len)
{
	cell new_size = count + len;
	factor_vm *parent_vm = elements.parent_vm;
	if(new_size >= array_capacity(elements.untagged()))
		elements = parent_vm->reallot_array(elements.untagged(),new_size * 2);

	memcpy(&elements->data<u8>()[count],elts,len);

	count += len;
}

void growable_byte_array::append_byte_array(cell byte_array_)
{
	gc_root<byte_array> byte_array(byte_array_,elements.parent_vm);

	cell len = array_capacity(byte_array.untagged());
	cell new_size = count + len;
	factor_vm *parent_vm = elements.parent_vm;
	if(new_size >= array_capacity(elements.untagged()))
		elements = parent_vm->reallot_array(elements.untagged(),new_size * 2);

	memcpy(&elements->data<u8>()[count],byte_array->data<u8>(),len);

	count += len;
}

void growable_byte_array::trim()
{
	factor_vm *parent_vm = elements.parent_vm;
	elements = parent_vm->reallot_array(elements.untagged(),count);
}

}