size_t
co_response_get_bin(co_obj_t *response, char **output, const char *key, const size_t klen)
{
co_obj_t *obj = co_response_get(response, key, klen);
CHECK(obj != NULL, "Response value %s does not exist.", key);
CHECK(IS_BIN(obj), "Value %s is not a binary.", key);
return co_obj_data(output, obj);
error:
return -1;
}
void omtTestAlloc(omMemCell cell, unsigned long spec)
{
size_t size = GET_SIZE(spec);
void* addr;
omBin bin = NULL;
omBin orig_bin = NULL;
if (IS_BIN(spec) && (size <= OM_MAX_BLOCK_SIZE || IS_SPEC_BIN(spec)))
{
if (IS_SPEC_BIN(spec))
{
if (IS_ALIGNED(spec))
bin = omGetAlignedSpecBin(size);
else
bin = omGetSpecBin(size);
}
else
{
if (IS_ALIGNED(spec))
bin = omSmallSize2AlignedBin(size);
else
bin = omSmallSize2Bin(size);
}
if (IS_STICKY_BIN(spec))
{
orig_bin = bin;
bin = omtGetStickyBin(bin);
}
if (IS_INLINE(spec))
{
if (IS_ZERO(spec))
addr = omAlloc0Bin(bin);
else
addr = omAllocBin(bin);
}
else
{
if (IS_ZERO(spec))
omTypeAlloc0Bin(void*, addr, bin);
else
omTypeAllocBin(void*, addr, bin);
}
}
else
{
if (IS_INLINE(spec))
{
if (IS_ZERO(spec))
{
if (IS_ALIGNED(spec))
{
if (IS_SLOPPY(spec))
addr = omalloc0(size);
else
addr = omAlloc0Aligned(size);
}
else
addr = omAlloc0(size);
}
else
{
if (IS_ALIGNED(spec))
{
if (IS_SLOPPY(spec))
addr = omalloc(size);
else
addr = omAllocAligned(size);
}
else
addr = omAlloc(size);
}
}
else
{
if (IS_ZERO(spec))
{
if (IS_ALIGNED(spec))
omTypeAlloc0Aligned(void*, addr, size);
else
omTypeAlloc0(void*, addr, size);
}
else
{
if (IS_ALIGNED(spec))
omTypeAllocAligned(void*, addr, size);
else
omTypeAlloc(void*, addr, size);
}
}
}
cell->addr = addr;
cell->bin = bin;
cell->orig_bin = orig_bin;
cell->spec = spec;
InitCellAddrContent(cell);
omtTestDebug(cell);
}
void omtTestRealloc(omMemCell cell, unsigned long new_spec)
{
void* old_addr = cell->addr;
unsigned long old_spec = cell->spec;
omBin old_bin = cell->bin;
omBin old_orig_bin = cell->orig_bin;
size_t old_size = GET_SIZE(old_spec);
void* new_addr;
omBin new_bin = NULL;
omBin new_orig_bin = NULL;
size_t new_size = GET_SIZE(new_spec);
size_t real_old_size = omSizeOfAddr(old_addr);
size_t min_size;
omtTestDebug(cell);
if (old_bin != NULL && IS_FREE_BIN(old_spec) &&
IS_BIN(new_spec) && ((new_size <= OM_MAX_BLOCK_SIZE) || IS_SPEC_BIN(new_spec)))
{
if (IS_SPEC_BIN(new_spec))
{
if (IS_ALIGNED(new_spec))
new_bin = omGetAlignedSpecBin(new_size);
else
new_bin = omGetSpecBin(new_size);
}
else
{
if (IS_ALIGNED(new_spec))
new_bin = omSmallSize2AlignedBin(new_size);
else
new_bin = omSmallSize2Bin(new_size);
}
if (IS_STICKY_BIN(new_spec))
{
new_orig_bin = new_bin;
new_bin = omtGetStickyBin(new_bin);
}
if (IS_INLINE(new_spec))
{
if (IS_ZERO(new_spec)) new_addr = omRealloc0Bin(old_addr, old_bin, new_bin);
else new_addr = omReallocBin(old_addr, old_bin, new_bin);
}
else
{
if (IS_ZERO(new_spec)) omTypeRealloc0Bin(old_addr, old_bin, void*, new_addr, new_bin);
else omTypeReallocBin(old_addr, old_bin, void*, new_addr, new_bin);
}
}
else
{
if (IS_FREE_SIZE(old_spec))
{
if (IS_INLINE(new_spec))
{
if (IS_ZERO(new_spec))
{
if (IS_ALIGNED(new_spec))
{
if (IS_SLOPPY(new_spec))
new_addr = omrealloc0Size(old_addr, old_size, new_size);
else
new_addr = omRealloc0AlignedSize(old_addr, old_size, new_size);
}
else
new_addr = omRealloc0Size(old_addr, old_size, new_size);
}
else
{
if (IS_ALIGNED(new_spec))
{
if (IS_SLOPPY(new_spec))
new_addr = omreallocSize(old_addr, old_size, new_size);
else
new_addr = omReallocAlignedSize(old_addr, old_size, new_size);
}
else new_addr = omReallocSize(old_addr, old_size, new_size);
}
}
else
{
if (IS_ZERO(new_spec))
{
if (IS_ALIGNED(new_spec)) omTypeRealloc0AlignedSize(old_addr, old_size, void*, new_addr, new_size);
else omTypeRealloc0Size(old_addr, old_size, void*, new_addr, new_size);
}
else
{
if (IS_ALIGNED(new_spec)) omTypeReallocAlignedSize(old_addr, old_size, void*, new_addr, new_size);
else omTypeReallocSize(old_addr, old_size, void*, new_addr, new_size);
}
}
}
else
{
if (IS_INLINE(new_spec))
{
if (IS_ZERO(new_spec))
{
if (IS_ALIGNED(new_spec))
{
if (IS_SLOPPY(new_spec))
new_addr = omrealloc0(old_addr, new_size);
else
new_addr = omRealloc0Aligned(old_addr, new_size);
}
else new_addr = omRealloc0(old_addr, new_size);
}
else
{
if (IS_ALIGNED(new_spec))
{
if (IS_SLOPPY(new_spec))
new_addr = omrealloc(old_addr, new_size);
else
new_addr = omReallocAligned(old_addr, new_size);
}
else new_addr = omRealloc(old_addr, new_size);
}
}
else
{
if (IS_ZERO(new_spec))
{
if (IS_ALIGNED(new_spec)) omTypeRealloc0Aligned(old_addr, void*, new_addr, new_size);
else omTypeRealloc0(old_addr, void*, new_addr, new_size);
}
else
{
if (IS_ALIGNED(new_spec)) omTypeReallocAligned(old_addr, void*, new_addr, new_size);
else omTypeRealloc(old_addr, void*, new_addr, new_size);
}
}
}
}
if (old_bin != NULL && IS_SPEC_BIN(old_spec))
{
if (old_orig_bin != NULL)
omUnGetSpecBin(&old_orig_bin);
else
omUnGetSpecBin(&old_bin);
}
new_size = omSizeOfAddr(new_addr);
old_size = real_old_size;
min_size = (new_size < old_size ? new_size : old_size);
if (IS_ZERO(old_spec) && IS_ZERO(new_spec))
TestAddrContent(new_addr, 0, new_size);
else
{
TestAddrContent(new_addr, (IS_ZERO(old_spec) ? 0 : old_spec), min_size);
if (IS_ZERO(new_spec) && old_size < new_size)
TestAddrContent((char *)new_addr + old_size, 0, new_size - old_size);
}
cell->addr = new_addr;
cell->spec = new_spec;
cell->bin = new_bin;
cell->orig_bin = new_orig_bin;
InitCellAddrContent(cell);
omtTestDebug(cell);
}
