/* 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); }