Esempio n. 1
0
void lnode_return(lnodepool_t *pool, lnode_t *node)
{
    assert (lnode_pool_isfrom(pool, node));
    assert (!lnode_is_in_a_list(node));

    node->next = pool->fre;
    node->prev = node;
    pool->fre = node;
}
Esempio n. 2
0
void list_ins_before(list_t *list, lnode_t *node, lnode_t *succ)
{
    lnode_t *pred = succ->prev;

    assert (node != NULL);
    assert (!list_contains(list, node));
    assert (!lnode_is_in_a_list(node));
    assert (succ == list_nil(list) || list_contains(list, succ));
    assert (list->nodecount + 1 > list->nodecount);

    node->next = succ;
    node->prev = pred;
    pred->next = node;
    succ->prev = node;
    list->nodecount++;

    assert (list->nodecount <= list->maxcount);
}
Esempio n. 3
0
void list_ins_after(list_t *list, lnode_t *node, lnode_t *pred)
{
    lnode_t *succ = pred->next;

    assert (node != NULL);
    assert (!list_contains(list, node));
    assert (!lnode_is_in_a_list(node));
    assert (pred == list_nil(list) || list_contains(list, pred));
    assert (list->nodecount + 1 > list->nodecount);

    node->prev = pred;
    node->next = succ;
    succ->prev = node;
    pred->next = node;
    list->nodecount++;

    assert (list->nodecount <= list->maxcount);
}
Esempio n. 4
0
void
list_ins_before (list_t * list, lnode_t * newnode, lnode_t * thisnode)
{
	lnode_t *that = thisnode->prev;

	nassert (newnode != NULL);
	nassert (!list_contains (list, newnode));
	nassert (!lnode_is_in_a_list (newnode));
	nassert (thisnode == list_nil (list) || list_contains (list, thisnode));
	nassert (list->nodecount + 1 > list->nodecount);

	newnode->next = thisnode;
	newnode->prev = that;
	that->next = newnode;
	thisnode->prev = newnode;
	list->nodecount++;

	nassert (list->nodecount <= list->maxcount);
}
Esempio n. 5
0
void
lnode_destroy (lnode_t * lnode)
{
	nassert (!lnode_is_in_a_list (lnode));
	ns_free (lnode);
}