route_t *file_create_route(FILE *fp) {
route_t *route = (route_t*)vp_os_malloc(sizeof(route_t));
INIT_ROUTE(route);
distance_t x, y, z;
NODE_T *p = NULL;
while (1) {
if(-1 == fscanf(fp, "%f %f %f", &x, &y, &z))
break;
if (route->head == NULL) {
route->head = (NODE_T*)vp_os_malloc(sizeof(NODE_T));
p = route->head;
INIT_NODE(p, x, y, z);
printw("x %f, y %f, z %f\n", x, y, z);
}
else {
p->next = (NODE_T*)vp_os_malloc(sizeof(NODE_T));
p = p->next;
INIT_NODE(p, x, y, z);
printw("x %f, y %f, z %f\n", x, y, z);
}
}
printw("\n");
if (route->head == NULL) {
vp_os_free(route);
return NULL;
}
return route;
}
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;
}
quadtree_t*
alloc_node(int x1, int y1,
int x2, int y2) {
quadtree_t *node = &nodes[tot++];
INIT_NODE(node, x1, y1, x2, y2);
return node;
}
void InitializeTestData()
{
INIT_NODE(NODE_ID_A, NodeA , {&NodeC, 3}, {&NodeE, 1});
INIT_NODE(NODE_ID_B, NodeB , {&NodeD, 3}, {&NodeE, 1}, {&NodeF, 8});
INIT_NODE(NODE_ID_C, NodeC , {&NodeA, 3}, {&NodeD, 4}, {&NodeF, 5});
INIT_NODE(NODE_ID_D, NodeD , {&NodeB, 3}, {&NodeC, 4}, {&NodeE, 2}, {&NodeF, 6});
INIT_NODE(NODE_ID_E, NodeE , {&NodeA, 1}, {&NodeB, 1}, {&NodeD, 2});
INIT_NODE(NODE_ID_F, NodeF , {&NodeB, 8}, {&NodeC, 5}, {&NodeD, 6});
}
struct usbdev *
create_device(struct usbmgr_device_descriptor desc)
{
struct usbdev *dev;
dev = (struct usbdev *)Malloc(sizeof(struct usbdev));
if (dev == NULL)
return NULL;
INIT_NODE(&(dev->link));
dev->desc = desc;
dev->status = USBMGR_ST_UNKNOWN;
dev->type = USBMGR_TYPE_NONE;
link_node(&device_ring,&(dev->link));
return dev;
}
/*---------------------------------------------------------------------------*/
void csr_list_insert_head(csr_list* list, csr_list_memory_ownership ownership, csr_list_node* node, void* value)
{
require(TR_CSR_LIST, list != NULL);
require(TR_CSR_LIST, node != NULL);
require(TR_CSR_LIST, value != NULL);
require(TR_CSR_LIST, isInList(list, node) == NULL); /*lint !e666 */
INIT_NODE(node, list->head, ownership, value);
if (list->head == NULL)
{
list->tail = node;
}
list->head = node;
list->count++;
}
/*---------------------------------------------------------------------------*/
void csr_list_insert_after(csr_list* list, csr_list_memory_ownership ownership, csr_list_node* existingnode, csr_list_node* node, void* value)
{
require(TR_CSR_LIST, list != NULL);
require(TR_CSR_LIST, existingnode != NULL);
require(TR_CSR_LIST, node != NULL);
require(TR_CSR_LIST, value != NULL);
require(TR_CSR_LIST, isInList(list, existingnode) != NULL); /*lint !e666 */
INIT_NODE(node, existingnode->next, ownership, value);
existingnode->next = node;
if (list->tail == existingnode)
{
list->tail = node;
}
list->count++;
}
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;
}
static int bdd_noderesize2(int doRehash, int oldsize, int newsize)
{
int n;
newsize = bdd_prime_lte(newsize);
if (oldsize > newsize) {
return 0;
}
bddnodesize = newsize;
if (resize_handler != NULL)
resize_handler(oldsize, bddnodesize);
if (bddnodesize > MAX_ALLOC_NODES) {
alloced = (BddNode*)realloc(alloced, sizeof(BddNode)*bddnodesize);
if (alloced == NULL)
return bdd_error(BDD_MEMORY);
bddnodes = alloced;
MAX_ALLOC_NODES = bddnodesize;
} else {
bddnodes = alloced;
}
if (doRehash)
for (n=0 ; n<oldsize ; n++)
SETHASH(n, 0);
for (n=oldsize ; n<bddnodesize ; n++)
{
INIT_NODE(n);
}
SETNEXT(bddnodesize-1, bddfreepos);
bddfreepos = oldsize;
bddfreenum += bddnodesize - oldsize;
if (doRehash)
bdd_gbc_rehash();
bddresized = 1;
return 0;
}
/*---------------------------------------------------------------------------*/
void csr_list_insert_tail(csr_list* list, csr_list_memory_ownership ownership, csr_list_node* node, void* value)
{
require(TR_CSR_LIST, list != NULL);
require(TR_CSR_LIST, node != NULL);
require(TR_CSR_LIST, value != NULL);
INIT_NODE(node, NULL, ownership, value);
if ( list->head == NULL)
{
list->head = node;
}
else
{
list->tail->next = node;
}
list->tail = node;
list->count++;
}
void bstree_remove(struct bstree_node *node, struct bstree *tree)
{
struct bstree_node *left, *right, *next;
struct bstree_node fake_parent, *parent;
int is_left;
do_lookup(node, tree, &parent, &is_left);
if (!parent) {
INIT_NODE(&fake_parent);
parent = &fake_parent;
is_left = 0;
}
left = get_left(node);
right = get_right(node);
if (!left && !right) {
if (is_left)
set_prev(get_prev(node), parent);
else
set_next(get_next(node), parent);
next = parent;
goto update_first_last;
}
if (!left) {
next = get_first(right);
set_prev(get_prev(node), next);
set_child(right, parent, is_left);
goto update_first_last;
}
if (!right) {
next = get_last(left);
set_next(get_next(node), next);
set_child(left, parent, is_left);
goto update_first_last;
}
next = get_first(right);
if (next != right) {
/* 'm' is the parent of 'next' */
struct bstree_node *m = get_next(get_last(next));
if (get_right(next))
set_left(get_right(next), m);
else
set_prev(next, m);
set_right(right, next);
}
set_child(next, parent, is_left);
set_left(left, next);
set_next(next, get_last(left));
out:
if (parent == &fake_parent)
tree->root = get_right(parent);
return;
update_first_last:
if (node == tree->first)
tree->first = next;
if (node == tree->last)
tree->last = next;
goto out;
}
/*
NAME {* bdd\_init *}
SECTION {* kernel *}
SHORT {* initializes the BDD package *}
PROTO {* int bdd_init(int nodesize, int cachesize) *}
DESCR {* This function initiates the bdd package and {\em must} be called
before any bdd operations are done. The argument {\tt nodesize}
is the initial number of nodes in the nodetable and {\tt cachesize}
is the fixed size of the internal caches. Typical values for
{\tt nodesize} are 10000 nodes for small test examples and up to
1000000 nodes for large examples. A cache size of 10000 seems to
work good even for large examples, but lesser values should do it
for smaller examples.
The number of cache entries can also be set to depend on the size
of the nodetable using a call to {\tt bdd\_setcacheratio}.
The initial number of nodes is not critical for any bdd operation
as the table will be resized whenever there are to few nodes left
after a garbage collection. But it does have some impact on the
efficency of the operations. *}
RETURN {* If no errors occur then 0 is returned, otherwise
a negative error code. *}
ALSO {* bdd\_done, bdd\_resize\_hook *}
*/
int bdd_init(int initnodesize, int cs)
{
/* Check to see if tracing is enabled */
char * str;
if( (str = getenv("BUDDY_TRACE_FILE")) != NULL) {
trace_enable = 1;
trace_init(str);
}
{
int n, err;
BUDDY_PROLOGUE;
ADD_ARG1(T_INT,initnodesize);
ADD_ARG1(T_INT,cs);
srand48( SRAND48SEED ) ;
if (bddrunning)
RETURN(bdd_error(BDD_RUNNING));
bddnodesize = bdd_prime_gte(initnodesize);
if ((MAX_ALLOC_NODES == 0) ||
(alloced=(BddNode*)malloc(sizeof(BddNode)*MAX_ALLOC_NODES)) == NULL) {
if ((alloced=(BddNode*)malloc(sizeof(BddNode)*bddnodesize)) == NULL) {
RETURN(bdd_error(BDD_MEMORY));
}
MAX_ALLOC_NODES = bddnodesize;
}
bddnodes = alloced;
bddresized = 0;
for (n=0 ; n<bddnodesize ; n++) {
INIT_NODE(n);
}
SETNEXT(bddnodesize-1, 0);
SETMAXREF(0);
SETMAXREF(1);
SETLOW(0,0); SETHIGH(0,0);
SETLOW(1,1); SETHIGH(1,1);
if ((err=bdd_operator_init(cs)) < 0) {
bdd_done();
RETURN(err);
}
bddfreepos = 2;
bddfreenum = bddnodesize-2;
bddrunning = 1;
bddvarnum = 0;
gbcollectnum = 0;
gbcclock = 0;
cachesize = cs;
usednodes_nextreorder = bddnodesize;
bddmaxnodeincrease = DEFAULTMAXNODEINC;
bddincreasefactor = 2;
bdderrorcond = 0;
bddcachestats.uniqueAccess = 0;
bddcachestats.uniqueChain = 0;
bddcachestats.uniqueHit = 0;
bddcachestats.uniqueMiss = 0;
bddcachestats.opHit = 0;
bddcachestats.opMiss = 0;
bddcachestats.swapCount = 0;
bdd_gbc_hook(bdd_default_gbchandler);
bdd_error_hook(bdd_default_errhandler);
bdd_resize_hook(NULL);
bdd_pairs_init();
bdd_reorder_init();
bdd_fdd_init();
if (setjmp(bddexception) != 0)
assert(0);
RETURN(0);
}
}
/* Insertion never needs more than 2 rotations */
struct avltree_node *avltree_insert(struct avltree_node *node, struct avltree *tree)
{
struct avltree_node *key, *parent, *unbalanced;
int is_left;
key = do_lookup(node, tree, &parent, &unbalanced, &is_left);
if (key)
return key;
INIT_NODE(node);
if (!parent) {
tree->root = node;
tree->first = tree->last = node;
tree->height++;
return NULL;
}
if (is_left) {
if (parent == tree->first)
tree->first = node;
} else {
if (parent == tree->last)
tree->last = node;
}
set_parent(parent, node);
set_child(node, parent, is_left);
for (;;) {
if (parent->left == node)
dec_balance(parent);
else
inc_balance(parent);
if (parent == unbalanced)
break;
node = parent;
parent = get_parent(parent);
}
switch (get_balance(unbalanced)) {
case 1: case -1:
tree->height++;
/* fall through */
case 0:
break;
case 2: {
struct avltree_node *right = unbalanced->right;
if (get_balance(right) == 1) {
set_balance(0, unbalanced);
set_balance(0, right);
} else {
switch (get_balance(right->left)) {
case 1:
set_balance(-1, unbalanced);
set_balance( 0, right);
break;
case 0:
set_balance(0, unbalanced);
set_balance(0, right);
break;
case -1:
set_balance(0, unbalanced);
set_balance(1, right);
break;
}
set_balance(0, right->left);
rotate_right(right, tree);
}
rotate_left(unbalanced, tree);
break;
}
case -2: {
struct avltree_node *left = unbalanced->left;
if (get_balance(left) == -1) {
set_balance(0, unbalanced);
set_balance(0, left);
} else {
switch (get_balance(left->right)) {
case 1:
set_balance( 0, unbalanced);
set_balance(-1, left);
break;
case 0:
set_balance(0, unbalanced);
set_balance(0, left);
break;
case -1:
set_balance(1, unbalanced);
set_balance(0, left);
break;
}
set_balance(0, left->right);
rotate_left(left, tree);
}
rotate_right(unbalanced, tree);
break;
}
}
return NULL;
}
/* Insertion never needs more than 2 rotations */
struct avltree_node *avltree_insert(struct avltree_node *node, struct avltree *tree) {
struct avltree_node *parent = 0, *unbalanced = tree->root;
bool is_left;
// Find a suitable parent.
for (struct avltree_node *next_parent = tree->root; next_parent != 0;) {
parent = next_parent;
if (get_balance(parent) != 0)
unbalanced = parent;
int cmp_r = tree->cmp_fn(parent, node);
if (cmp_r == 0) {
if (tree->unique_index)
return parent;
// For non unique indexes any insert direction is acceptable.
if (parent->left == 0) {
is_left = true;
break;
} else if (parent->right == 0) {
is_left = false;
break;
} else {
// Be smart and travel to the least balanced subtree to minimize balancing overhead.
next_parent = (get_balance(parent) <= 0)? parent->left: parent->right;
}
} else {
is_left = (cmp_r > 0);
next_parent = is_left? parent->left: parent->right;
}
}
INIT_NODE(node);
if (!parent) {
tree->root = node;
tree->first = tree->last = node;
tree->height++;
return 0;
}
if (is_left) {
if (parent == tree->first)
tree->first = node;
} else {
if (parent == tree->last)
tree->last = node;
}
set_parent(parent, node);
set_child(node, parent, is_left);
for (;;) {
if (parent->left == node)
dec_balance(parent);
else
inc_balance(parent);
if (parent == unbalanced) {
for (;;) {
node = parent;
node->count++;
if (is_root(node))
break;
parent = get_parent(parent);
}
break;
}
node = parent;
node->count++;
parent = get_parent(parent);
}
switch (get_balance(unbalanced)) {
case 1: case -1:
tree->height++;
/* fall through */
case 0:
break;
case 2:
{
struct avltree_node *right = unbalanced->right;
if (get_balance(right) == 1) {
set_balance(0, unbalanced);
set_balance(0, right);
} else {
switch (get_balance(right->left)) {
case 1:
set_balance(-1, unbalanced);
set_balance(0, right);
break;
case 0:
set_balance(0, unbalanced);
set_balance(0, right);
break;
case -1:
set_balance(0, unbalanced);
set_balance(1, right);
break;
}
set_balance(0, right->left);
rotate_right(right, tree);
}
rotate_left(unbalanced, tree);
break;
}
case -2:
{
struct avltree_node *left = unbalanced->left;
if (get_balance(left) == -1) {
set_balance(0, unbalanced);
set_balance(0, left);
} else {
switch (get_balance(left->right)) {
case 1:
set_balance(0, unbalanced);
set_balance(-1, left);
break;
case 0:
set_balance(0, unbalanced);
set_balance(0, left);
break;
case -1:
set_balance(1, unbalanced);
set_balance(0, left);
break;
}
set_balance(0, left->right);
rotate_left(left, tree);
}
rotate_right(unbalanced, tree);
break;
}
}
return 0;
}
