WordSetU* HG_(newWordSetU) ( void* (*alloc_nofail)( HChar*, SizeT ),
HChar* cc,
void (*dealloc)(void*),
Word cacheSize )
{
WordSetU* wsu;
WordVec* empty;
wsu = alloc_nofail( cc, sizeof(WordSetU) );
VG_(memset)( wsu, 0, sizeof(WordSetU) );
wsu->alloc = alloc_nofail;
wsu->cc = cc;
wsu->dealloc = dealloc;
wsu->vec2ix = VG_(newFM)( alloc_nofail, cc,
dealloc, cmp_WordVecs_for_FM );
wsu->ix2vec_used = 0;
wsu->ix2vec_size = 0;
wsu->ix2vec = NULL;
wsu->ix2vec_free = NULL;
WCache_INIT(wsu->cache_addTo, cacheSize);
WCache_INIT(wsu->cache_delFrom, cacheSize);
WCache_INIT(wsu->cache_intersect, cacheSize);
WCache_INIT(wsu->cache_minus, cacheSize);
empty = new_WV_of_size( wsu, 0 );
wsu->empty = add_or_dealloc_WordVec( wsu, empty );
return wsu;
}
WordBag* TC_(newBag) ( void* (*alloc_nofail)( SizeT ),
void (*dealloc)(void*) )
{
WordBag* bag = alloc_nofail(sizeof(WordBag));
bag->fm = TC_(newFM)( alloc_nofail, dealloc, NULL );
return bag;
}
WordBag* VG_(newBag) ( void* (*alloc_nofail)( const HChar*, SizeT ),
const HChar* cc,
void (*dealloc)(void*) )
{
WordBag* bag = alloc_nofail(cc, sizeof(WordBag));
bag->fm = VG_(newFM)( alloc_nofail, cc, dealloc, NULL );
return bag;
}
/* Allocate and Initialise a WordFM. */
WordFM* newFM( void* (*alloc_nofail)( SizeT ),
void (*dealloc)(void*),
Word (*kCmp)(Word,Word) )
{
WordFM* fm = alloc_nofail(sizeof(WordFM));
assert(fm);
initFM(fm, alloc_nofail, dealloc, kCmp);
return fm;
}
/* Allocate and initialise a WordFM. If kCmp is non-NULL, elements in
the set are ordered according to the ordering specified by kCmp,
which becomes obvious if you use VG_(initIterFM),
VG_(initIterAtFM), VG_(nextIterFM), VG_(doneIterFM) to iterate over
sections of the map, or the whole thing. If kCmp is NULL then the
ordering used is unsigned word ordering (UWord) on the key
values. */
WordFM* VG_(newFM) ( void* (*alloc_nofail)( const HChar*, SizeT ),
const HChar* cc,
void (*dealloc)(void*),
Word (*kCmp)(UWord,UWord) )
{
WordFM* fm = alloc_nofail(cc, sizeof(WordFM));
tl_assert(fm);
initFM(fm, alloc_nofail, cc, dealloc, kCmp);
return fm;
}
static
AvlNode* avl_dopy ( AvlNode* nd,
UWord(*dopyK)(UWord),
UWord(*dopyV)(UWord),
void*(alloc_nofail)(const HChar*,SizeT),
const HChar* cc )
{
AvlNode* nyu;
if (! nd)
return NULL;
nyu = alloc_nofail(cc, sizeof(AvlNode));
tl_assert(nyu);
nyu->child[0] = nd->child[0];
nyu->child[1] = nd->child[1];
nyu->balance = nd->balance;
/* Copy key */
if (dopyK) {
nyu->key = dopyK( nd->key );
if (nd->key != 0 && nyu->key == 0)
return NULL; /* oom in key dcopy */
} else {
/* copying assumedly unboxed keys */
nyu->key = nd->key;
}
/* Copy val */
if (dopyV) {
nyu->val = dopyV( nd->val );
if (nd->val != 0 && nyu->val == 0)
return NULL; /* oom in val dcopy */
} else {
/* copying assumedly unboxed vals */
nyu->val = nd->val;
}
/* Copy subtrees */
if (nyu->child[0]) {
nyu->child[0] = avl_dopy( nyu->child[0], dopyK, dopyV,
alloc_nofail, cc );
if (! nyu->child[0])
return NULL;
}
if (nyu->child[1]) {
nyu->child[1] = avl_dopy( nyu->child[1], dopyK, dopyV,
alloc_nofail, cc );
if (! nyu->child[1])
return NULL;
}
return nyu;
}
static
AvlNode* avl_dopy ( AvlNode* nd,
Word(*dopyK)(Word),
Word(*dopyV)(Word),
void*(alloc_nofail)(SizeT) )
{
AvlNode* nyu;
if (! nd)
return NULL;
nyu = alloc_nofail(sizeof(AvlNode));
assert(nyu);
nyu->left = nd->left;
nyu->right = nd->right;
nyu->balance = nd->balance;
/* Copy key */
if (dopyK) {
nyu->key = dopyK( nd->key );
if (nd->key != 0 && nyu->key == 0)
return NULL; /* oom in key dcopy */
} else {
/* copying assumedly unboxed keys */
nyu->key = nd->key;
}
/* Copy val */
if (dopyV) {
nyu->val = dopyV( nd->val );
if (nd->val != 0 && nyu->val == 0)
return NULL; /* oom in val dcopy */
} else {
/* copying assumedly unboxed vals */
nyu->val = nd->val;
}
/* Copy subtrees */
if (nyu->left) {
nyu->left = avl_dopy( nyu->left, dopyK, dopyV, alloc_nofail );
if (! nyu->left)
return NULL;
}
if (nyu->right) {
nyu->right = avl_dopy( nyu->right, dopyK, dopyV, alloc_nofail );
if (! nyu->right)
return NULL;
}
return nyu;
}
