/* Allocates memory */
string* factor_vm::reallot_string(string* str_, cell capacity) {
data_root<string> str(str_, this);
if (reallot_string_in_place_p(str.untagged(), capacity)) {
str->length = tag_fixnum(capacity);
if (to_boolean(str->aux)) {
byte_array* aux = untag<byte_array>(str->aux);
aux->capacity = tag_fixnum(capacity * 2);
}
return str.untagged();
} else {
cell to_copy = string_capacity(str.untagged());
if (capacity < to_copy)
to_copy = capacity;
data_root<string> new_str(allot_string_internal(capacity), this);
memcpy(new_str->data(), str->data(), to_copy);
if (to_boolean(str->aux)) {
byte_array* new_aux = allot_uninitialized_array<byte_array>(capacity * 2);
new_str->aux = tag<byte_array>(new_aux);
write_barrier(&new_str->aux);
byte_array* aux = untag<byte_array>(str->aux);
memcpy(new_aux->data<uint16_t>(), aux->data<uint16_t>(),
to_copy * sizeof(uint16_t));
}
fill_string(new_str.untagged(), to_copy, capacity, '\0');
return new_str.untagged();
}
}
/* Size of the data area of an object pointed to by an untagged pointer */
cell factor_vm::unaligned_object_size(object *pointer)
{
switch(pointer->h.hi_tag())
{
case ARRAY_TYPE:
return array_size((array*)pointer);
case BIGNUM_TYPE:
return array_size((bignum*)pointer);
case BYTE_ARRAY_TYPE:
return array_size((byte_array*)pointer);
case STRING_TYPE:
return string_size(string_capacity((string*)pointer));
case TUPLE_TYPE:
return tuple_size(untag<tuple_layout>(((tuple *)pointer)->layout));
case QUOTATION_TYPE:
return sizeof(quotation);
case WORD_TYPE:
return sizeof(word);
case FLOAT_TYPE:
return sizeof(boxed_float);
case DLL_TYPE:
return sizeof(dll);
case ALIEN_TYPE:
return sizeof(alien);
case WRAPPER_TYPE:
return sizeof(wrapper);
case CALLSTACK_TYPE:
return callstack_size(untag_fixnum(((callstack *)pointer)->length));
default:
critical_error("Invalid header",(cell)pointer);
return 0; /* can't happen */
}
}
/* Size of the object pointed to by an untagged pointer */
template <typename Fixup> cell object::size(Fixup fixup) const {
if (free_p())
return ((free_heap_block*)this)->size();
switch (type()) {
case ARRAY_TYPE:
return align(array_size((array*)this), data_alignment);
case BIGNUM_TYPE:
return align(array_size((bignum*)this), data_alignment);
case BYTE_ARRAY_TYPE:
return align(array_size((byte_array*)this), data_alignment);
case STRING_TYPE:
return align(string_size(string_capacity((string*)this)), data_alignment);
case TUPLE_TYPE: {
tuple_layout* layout = (tuple_layout*)fixup.translate_data(
untag<object>(((tuple*)this)->layout));
return align(tuple_size(layout), data_alignment);
}
case QUOTATION_TYPE:
return align(sizeof(quotation), data_alignment);
case WORD_TYPE:
return align(sizeof(word), data_alignment);
case FLOAT_TYPE:
return align(sizeof(boxed_float), data_alignment);
case DLL_TYPE:
return align(sizeof(dll), data_alignment);
case ALIEN_TYPE:
return align(sizeof(alien), data_alignment);
case WRAPPER_TYPE:
return align(sizeof(wrapper), data_alignment);
case CALLSTACK_TYPE:
return align(
callstack_object_size(untag_fixnum(((callstack*)this)->length)),
data_alignment);
default:
critical_error("Invalid header in size", (cell)this);
return 0; /* can't happen */
}
}
bool factor_vm::reallot_string_in_place_p(string *str, cell capacity)
{
return nursery.contains_p(str)
&& (!to_boolean(str->aux) || nursery.contains_p(untag<byte_array>(str->aux)))
&& capacity <= string_capacity(str);
}
