void* linkedlist_remove(linkedlist _list, void* data)
{
linkedlist_t* list = (linkedlist_t*) _list;
node* n = find_by_data(list, data);
if(NULL == n)
return NULL;
if(is_first(list, n)) // at the first
{
if(is_last(list, n)) // only one exists
{
set_head(list, NULL);
set_tail(list, NULL);
}
else // one or more exist
{
set_head(list, get_next(n));
set_prev(n, NULL);
}
}
else if(is_last((linkedlist_t*)_list, n))
{
set_next(get_prev(n), NULL);
set_tail(list, get_prev(n));
}
else
{
set_prev(get_next(n), get_prev(n));
set_next(get_prev(n), get_next(n));
}
list->size--;
free(n);
return data;
}
void dlist::remove(void *item)
{
void *xitem;
dlink *ilink = get_link(item); /* item's link */
if (item == head) {
head = ilink->next;
if (head) {
set_prev(head, NULL);
}
if (item == tail) {
tail = ilink->prev;
}
} else if (item == tail) {
tail = ilink->prev;
if (tail) {
set_next(tail, NULL);
}
} else {
xitem = ilink->next;
set_prev(xitem, ilink->prev);
xitem = ilink->prev;
set_next(xitem, ilink->next);
}
num_items--;
if (num_items == 0) {
head = tail = NULL;
}
}
void push(node_base* p)
{
set_next(p, NULL);
exclusive_lock_guard< mutex_type > _(m_Tail.mutex);
set_next(m_Tail.node, p);
m_Tail.node = p;
}
void* fixed_size_allocator::_alloc( size_t ) {
refs++;
#ifdef DEBUG_POOL_ALLOCATOR
allocs++;current++;
if(current>max)max=current;
#endif
void* p = head_of_free_list;
if(p) {
head_of_free_list = get_next(p);
} else {
char* new_block = new char[sizeof(block_head) + num_objects * object_size];
((block_head*)new_block)->next = head;
head = (block_head*)new_block;
new_block += sizeof(block_head);
for(std::size_t i = object_size; i < (num_objects - 1) * object_size; i += object_size) {
set_next(&new_block[i], &new_block[i + object_size]);
}
set_next(&new_block[(num_objects - 1) * object_size], 0);
p = new_block;
head_of_free_list = &new_block[object_size];
#ifdef DEBUG_POOL_ALLOCATOR
blocks++;
#endif
}
return p;
}
static void append_and_clear( los_list_t *left, los_list_t *right )
{
word *left_first = next( left->header );
word *left_last = prev( left->header );
word *right_first = next( right->header );
word *right_last = prev( right->header );
if (right_first == right->header) return; /* Right is empty */
/* Splice in the right list */
if (left_first != left->header) { /* Left is nonempty */
set_next( left_last, right_first ); /* Join lists */
set_prev( right_first, left_last );
}
else { /* Left is empty */
set_next( left->header, right_first ); /* Move right to left */
set_prev( right_first, left->header );
}
/* Complete circle */
set_next( right_last, left->header );
set_prev( left->header, right_last );
left->bytes += right->bytes;
clear_list( right );
}
/*@
set_union - find the union of two sets
Input arguments:
+ s - The first set
- t - The second set
Output arguments:
None
Returns:
A new set that is the union of the two input sets if successful,
NULL otherwise.
Notes:
s and t must contain the same types of elements
@*/
struct set *set_union(struct set *s, struct set *t)
{
void * e;
struct set *tmp, *u, *v;
/* Try to make sure that these two sets contain the same types */
if (s->cmp != t->cmp || s->elemsize != t->elemsize)
return NULL;
/* Whichever set we iterate over should be smaller because iteration is O(n) */
/* while bsearch is O(log n) */
if (s->size < t->size)
u = s, v = t;
else
u = t, v = s;
tmp = set_copy(v);
if (tmp == NULL)
return NULL;
/* Insert all the elements of u not in v */
for (set_reset(u), e = set_next(u); e != NULL; e = set_next(u)){
if (!set_exists(v, e))
set_insert(tmp, e);
}
return tmp;
}
struct bstree_node *bstree_insert(struct bstree_node *node, struct bstree *tree)
{
struct bstree_node *key, *parent;
int is_left;
key = do_lookup(node, tree, &parent, &is_left);
if (key)
return key;
if (!parent) {
INIT_NODE(node);
tree->root = tree->first = tree->last = node;
return NULL;
}
if (is_left) {
if (parent == tree->first)
tree->first = node;
set_prev(get_prev(parent), node);
set_next(parent, node);
set_left(node, parent);
} else {
if (parent == tree->last)
tree->last = node;
set_prev(parent, node);
set_next(get_next(parent), node);
set_right(node, parent);
}
return NULL;
}
int add_at_first(linkedlist_t* _list, void* data)
{
linkedlist_t* list = (linkedlist_t*) _list;
node* n, *slider;
if(list->size == 0)
{
return add_at_last(list, data);
}
else if(list->size == 1)
{
n = node_new(data);
set_head(list, n);
set_prev(get_tail(list), n);
set_next(n, get_tail(list));
list->size++;
}
else // list->size > 1
{
slider = get_head(list);
n = node_new(data);
set_next(n, slider);
set_prev(slider, n);
set_head(list, n);
list->size++;
}
return list->size;
}
static int
lru_load(const br_ssl_session_cache_class **ctx,
br_ssl_server_context *server_ctx,
br_ssl_session_parameters *params)
{
br_ssl_session_cache_lru *cc;
unsigned char id[SESSION_ID_LEN];
uint32_t x;
(void)server_ctx;
cc = (br_ssl_session_cache_lru *)ctx;
if (!cc->init_done) {
return 0;
}
mask_id(cc, params->session_id, id);
x = find_node(cc, id, NULL);
if (x != ADDR_NULL) {
unsigned version;
version = br_dec16be(cc->store + x + VERSION_OFF);
if (version == 0) {
/*
* Entry is disabled, we pretend we did not find it.
* Notably, we don't move it to the front of the
* LRU list.
*/
return 0;
}
params->version = version;
params->cipher_suite = br_dec16be(
cc->store + x + CIPHER_SUITE_OFF);
memcpy(params->master_secret,
cc->store + x + MASTER_SECRET_OFF,
MASTER_SECRET_LEN);
if (x != cc->head) {
/*
* Found node is not at list head, so move
* it to the head.
*/
uint32_t p, n;
p = get_prev(cc, x);
n = get_next(cc, x);
set_next(cc, p, n);
if (n == ADDR_NULL) {
cc->tail = p;
} else {
set_prev(cc, n, p);
}
set_prev(cc, cc->head, x);
set_next(cc, x, cc->head);
set_prev(cc, x, ADDR_NULL);
cc->head = x;
}
return 1;
}
return 0;
}
static void
flow_uninit_scan_statements (flownode_t *node, set_t *defs, set_t *uninit)
{
set_t *stuse;
set_t *stdef;
statement_t *st;
set_iter_t *var_i;
flowvar_t *var;
operand_t *op;
// defs holds only reaching definitions. make it hold only reaching
// uninitialized definitions
set_intersection (defs, uninit);
stuse = set_new ();
stdef = set_new ();
for (st = node->sblock->statements; st; st = st->next) {
flow_analyze_statement (st, stuse, stdef, 0, 0);
for (var_i = set_first (stuse); var_i; var_i = set_next (var_i)) {
var = node->graph->func->vars[var_i->element];
if (set_is_intersecting (defs, var->define)) {
def_t *def = flowvar_get_def (var);
if (def) {
if (options.warnings.uninited_variable) {
warning (st->expr, "%s may be used uninitialized",
def->name);
}
} else {
bug (st->expr, "st %d, uninitialized temp %s",
st->number, operand_string (var->op));
}
}
// avoid repeat warnings in this node
set_difference (defs, var->define);
}
for (var_i = set_first (stdef); var_i; var_i = set_next (var_i)) {
var = node->graph->func->vars[var_i->element];
// kill any reaching uninitialized definitions for this variable
set_difference (defs, var->define);
if (var->op->op_type == op_temp) {
op = var->op;
if (op->o.tempop.alias) {
var = op->o.tempop.alias->o.tempop.flowvar;
if (var)
set_difference (defs, var->define);
}
for (op = op->o.tempop.alias_ops; op; op = op->next) {
var = op->o.tempop.flowvar;
if (var)
set_difference (defs, var->define);
}
}
}
}
set_delete (stuse);
set_delete (stdef);
}
void show_tile (void)
{
set_grid(current_tile[5]);
set_next(next_tile[5]);
show_grid();
set_grid(0);
set_next(0);
}
static void remove( word *w )
{
word *n = next( w );
word *p = prev( w );
set_next( p, n );
set_prev( n, p );
set_next( w, 0 );
set_prev( w, 0 );
}
bool
et_below (struct et_node *down, struct et_node *up)
{
struct et_occ *u = up->rightmost_occ, *d = down->rightmost_occ;
struct et_occ *l, *r;
if (up == down)
return true;
et_splay (u);
l = u->prev;
r = u->next;
if (!l)
return false;
l->parent = NULL;
if (r)
r->parent = NULL;
et_splay (d);
if (l == d || l->parent != NULL)
{
if (r)
r->parent = u;
set_prev (u, d);
#ifdef DEBUG_ET
et_check_tree_sanity (u);
#endif
}
else
{
l->parent = u;
/* In case O1 and O2 are in two different trees, we must just restore the
original state. */
if (r && r->parent != NULL)
set_next (u, d);
else
set_next (u, r);
#ifdef DEBUG_ET
et_check_tree_sanity (u);
#endif
return false;
}
if (0 >= d->depth)
return false;
return !d->next || d->next->min + d->depth >= 0;
}
static void insert_at_end( word *w, los_list_t *list )
{
word *h, *last;
h = list->header;
last = prev( h );
set_next( last, w ); /* add links from last end */
set_prev( w, last );
set_next( w, h ); /* add links from header */
set_prev( h, w );
list->bytes += size( w );
}
/*
* Append an item to the list
*/
void dlist::append(void *item)
{
set_next(item, NULL);
set_prev(item, tail);
if (tail) {
set_next(tail, item);
}
tail = item;
if (head == NULL) { /* if empty list, */
head = item; /* item is head as well */
}
num_items++;
}
int main(int argc, char *argv[])
{
int i, size = 100, *x;
struct set *s, *t, *u;
if (argc > 1)
size = atoi(argv[1]);
srand(time(NULL));
s = set_create(size, sizeof(int), cmpint);
t = set_create(size, sizeof(int), cmpint);
if (s == NULL || t == NULL){
printf("Unable to create the test set\n");
return 1;
}
printf("Inserting into first set...\n");
for (i = 0; i < size; i++){
int y = rand() % size;
printf("%d ", y);
set_insert(s, &y);
}
printf("\n\n");
printf("The set contains:\n");
for (set_reset(s), x = set_next(s); x != NULL; x = set_next(s))
printf("%d ", *x);
printf("\n\n");
printf("Inserting into second set...\n");
for (i = 0; i < size; i++){
int y = rand() % size;
printf("%d ", y);
set_insert(t, &y);
}
printf("\n\n");
printf("The set contains:\n");
for (set_reset(t), x = set_next(t); x != NULL; x = set_next(t))
printf("%d ", *x);
printf("\n\n");
u = set_union(s, t);
printf("The union of the two sets is:\n");
for (set_reset(u), x = set_next(u); x != NULL; x = set_next(u))
printf("%d ", *x);
printf("\n\n");
set_destroy(u);
u = set_diff(s, t);
printf("The difference of the two sets is:\n");
for (set_reset(u), x = set_next(u); x != NULL; x = set_next(u))
printf("%d ", *x);
printf("\n\n");
return 0;
}
int kmp(char* s,char* t,unsigned pos)
{
int j=0;
int s_len=strlen(s);
int t_len=strlen(t);
int * next;
if(t_len==0) return -1;
next=(int*)malloc(sizeof(int)*t_len);
set_next(t,next,t_len);
while(s_len-pos>=t_len)
{
while(j<t_len&&s[pos]==t[j])
{
++pos;
++j;
}
if(j==t_len)
{
free(next);
return pos-t_len;
}
j=next[j];
if(j==-1)
{
++pos;
j=0;
}
}
free(next);
return -1;
}
void dlist::insert_before(void *item, void *where)
{
dlink *where_link = get_link(where);
set_next(item, where);
set_prev(item, where_link->prev);
if (where_link->prev) {
set_next(where_link->prev, item);
}
where_link->prev = item;
if (head == where) {
head = item;
}
num_items++;
}
static bool
coalesce_blocks(void *ptr1, void *ptr2)
{
void *tmpptr = Min(ptr1, ptr2);
Size new_size;
void *next;
ptr2 = Max(ptr1, ptr2);
ptr1 = tmpptr;
if (get_end(ptr1) != get_header(ptr2))
return false;
Assert(get_next(ptr1) == ptr2);
Assert(!is_allocated(ptr1));
Assert(!is_allocated(ptr2));
new_size = get_size(ptr1) + BLOCK_SIZE(get_size(ptr2));
get_header(ptr1)->size = new_size;
/* Mark ptr2 as no longer an ICE BOODA. */
get_header(ptr2)->magic = 0;
next = get_next(ptr2);
set_next(ptr1, next);
if (next)
set_prev(next, ptr1);
return true;
}
/* Deze methode zet het blok op index op vrij, indien mogelijk fuseert het
* met omringende vrije blokken. */
void free_block(long index){
long prev = get_prev(index);
long next = get_next(index);
if(!get_free(index)){
/* Zet het blok op vrij. */
set_free(index, 1);
mem[0] -= get_length(index);
}
/* Voeg vorige blok samen met het huidige als deze vrij is als een groot
* vrij blok. */
if(prev != 0 && get_free(prev)){
set_length(prev, get_length(prev) + get_length(index) + ADMIN_SIZE);
set_next(prev, next);
if(next != 0){
set_prev(next, prev);
}
mem[1] -= ADMIN_SIZE;
}
/* Voeg volgende blok samen met het huidige als deze vrij is als een
* groot vrij blok. */
if(next != 0 && get_free(next)){
free_block(next);
}
}
static void
flow_find_loops (flowgraph_t *graph)
{
flownode_t *node;
set_iter_t *succ;
flowloop_t *loop, *l;
flowloop_t *loop_list = 0;
int i;
for (i = 0; i < graph->num_nodes; i++) {
node = graph->nodes[i];
for (succ = set_first (node->successors); succ;
succ = set_next (succ)) {
if (set_is_member (node->dom, succ->element)) {
loop = make_loop (graph, node->id, succ->element);
for (l = loop_list; l; l = l->next) {
if (l->head == loop->head
&& !set_is_subset (l->nodes, loop->nodes)
&& !set_is_subset (loop->nodes, l->nodes)) {
set_union (l->nodes, loop->nodes);
delete_loop (loop);
loop = 0;
break;
}
}
if (loop) {
loop->next = loop_list;
loop_list = loop;
}
}
}
}
graph->loops = loop_list;
}
int
client_addr_init(struct ntp_peer *p)
{
struct sockaddr_in *sa_in;
struct sockaddr_in6 *sa_in6;
struct ntp_addr *h;
for (h = p->addr; h != NULL; h = h->next) {
switch (h->ss.ss_family) {
case AF_INET:
sa_in = (struct sockaddr_in *)&h->ss;
if (ntohs(sa_in->sin_port) == 0)
sa_in->sin_port = htons(123);
p->state = STATE_DNS_DONE;
break;
case AF_INET6:
sa_in6 = (struct sockaddr_in6 *)&h->ss;
if (ntohs(sa_in6->sin6_port) == 0)
sa_in6->sin6_port = htons(123);
p->state = STATE_DNS_DONE;
break;
default:
fatalx("king bula sez: wrong AF in client_addr_init");
/* not reached */
}
}
p->query->fd = -1;
set_next(p, 0);
return (0);
}
/* Deze methode wijst length woorden toe aan een proces. De overgebleven
* woorden worden gezien als nieuw vrij blok. */
int split_block(long index, long length){
long blockleng = get_length(index);
long newidx = index + length + ADMIN_SIZE;
long newleng = blockleng - length - ADMIN_SIZE;
if(blockleng < length + ADMIN_SIZE + 1){
/* Geen ruimte voor een nieuw blok van minimaal 1 woord. */
return -1;
}
/* Maak het nieuwe blok. Plaats deze na 'length' woorden. */
new_block(newidx, newleng, index, get_next(index));
/* Als het huidige blok een volgende blok heeft moet de pointer van
* dat blok welke naar zijn vorige blok wijst naar het nieuwe blok
* gezet worden.*/
if(get_next(index) != 0){
set_prev(get_next(index), newidx);
}
/* Zet het volgende blok van het huidige blok naar het nieuwe blok. */
set_next(index, newidx);
/* Zet de length van het huidige blok en zet hem op toegewezen. */
set_length(index, length);
set_free(index, 0);
/* Verhoog het aantal loze woorden. */
mem[1] += ADMIN_SIZE;
/* Verhoog het aantal toegewezen woorden. */
mem[0] += length;
/* De index waar begonnen mag worden met schrijven is het blok index
* plus de lengte van de administratie. */
return index + ADMIN_SIZE;
}
/*
* Threaded_Fork constructor
*/
Threaded_Fork::Threaded_Fork(Filter* f1, Filter* f2, Filter* f3, Filter* f4) :
Fork(nullptr, static_cast<size_t>(0)),
m_thread_data(new Threaded_Fork_Data)
{
Filter* filters[4] = { f1, f2, f3, f4 };
set_next(filters, 4);
}
node* node_new(void* data)
{
node* n = (node*) malloc(sizeof(node));
set_next(n, NULL);
set_prev(n, NULL);
n->data = data;
return n;
}
void RegionList::insert_before_head(HeapRegion* r) {
assert(well_formed(), "Inv");
set_next(r, hd());
_hd = r;
_sz++;
if (tl() == NULL) _tl = r;
assert(well_formed(), "Inv");
}
inline void Linked<C>::insert_after(Linked<C>& x) {
// *p -> *this -> x -> *n
x.set_prev(*this);
x.set_next(this->next());
next().set_prev(x);
set_next(x);
}
ThreadPiece::ThreadPiece(const Vector3d& vertex, const double angle_twist, ThreadPiece* prev, ThreadPiece* next, Thread* my_thread)
: _vertex(vertex), _angle_twist(angle_twist), rot(Matrix3d::Zero()), _my_thread(my_thread)
{
grad_offsets[0] = Vector3d(grad_eps, 0.0, 0.0);
grad_offsets[1] = Vector3d(0.0, grad_eps, 0.0);
grad_offsets[2] = Vector3d(0.0, 0.0, grad_eps);
set_prev(prev);
set_next(next);
}
struct et_node *
et_nca (struct et_node *n1, struct et_node *n2)
{
struct et_occ *o1 = n1->rightmost_occ, *o2 = n2->rightmost_occ, *om;
struct et_occ *l, *r, *ret;
int mn;
if (n1 == n2)
return n1;
et_splay (o1);
l = o1->prev;
r = o1->next;
if (l)
l->parent = NULL;
if (r)
r->parent = NULL;
et_splay (o2);
if (l == o2 || (l && l->parent != NULL))
{
ret = o2->next;
set_prev (o1, o2);
if (r)
r->parent = o1;
}
else
{
ret = o2->prev;
set_next (o1, o2);
if (l)
l->parent = o1;
}
if (0 < o2->depth)
{
om = o1;
mn = o1->depth;
}
else
{
om = o2;
mn = o2->depth + o1->depth;
}
#ifdef DEBUG_ET
et_check_tree_sanity (o2);
#endif
if (ret && ret->min + o1->depth + o2->depth < mn)
return ret->min_occ->of;
else
return om->of;
}
struct splaytree_node *splaytree_insert(struct splaytree_node *node,
struct splaytree *tree)
{
struct splaytree_node *root = tree->root;
int res;
if (!root) {
INIT_NODE(node);
tree->root = node;
tree->first = node;
tree->last = node;
return NULL;
}
res = do_splay(node, tree);
if (res == 0)
return tree->root;
root = tree->root;
if (res < 0) {
struct splaytree_node *left = get_left(root);
set_left(left, node);
set_right(root, node);
if (left)
set_next(node, get_last(left));
else
tree->first = node;
set_prev(node, root);
} else {
struct splaytree_node *right = get_right(root);
set_right(right, node);
set_left(root, node);
if (right)
set_prev(node, get_first(right));
else
tree->last = node;
set_next(node, root);
}
tree->root = node;
return NULL;
}
