typename tree< T , A >::iterator
tree< T , A >::
insert( iterator it , const value_type & copy /*= value_type()*/ )
{
NodePtr_t node_ptr;
if ( get_node_ptr( it ) != root_) {
NodePtr_t _S = get_node_ptr( it );
node_ptr = alloc_node( _S->left , _S , 0 );
allocator_.construct( & node_ptr->value , copy );
if ( _S == _S->left->child )
node_ptr->left->child = node_ptr;
else if ( _S == _S->left->right )
node_ptr->left->right = node_ptr;
_S->left = node_ptr;
} else if ( root_->child != root_ ) {
NodePtr_t _S = root_->child;
while ( _S->right != 0 )
_S = _S->right;
node_ptr = alloc_node( _S , _S->right , 0 );
allocator_.construct( & node_ptr->value , copy );
_S->right = node_ptr;
if ( node_ptr->right != 0 )
node_ptr->right->left = node_ptr;
} else {
node_ptr = alloc_node( root_ );
allocator_.construct( & node_ptr->value , copy );
root_->child = node_ptr;
} // if
++size_;
return iterator( node_ptr );
} // insert
static void
pet_test(void)
{
#define NODES 1000000
node_t *pool, *root;
struct timeval tv, tv2;
time_t sec;
suseconds_t msec;
int i, j;
pool = pool_new(NODES);
j = NODES / 2;
gettimeofday(&tv, NULL);
root = alloc_node(pool);
root = make_node(root, 0);
for (i = 1; i < NODES; i++, j = (j + 17) % NODES)
root = insert(root, alloc_node(pool), j);
while (root)
root = delete_min(root);
gettimeofday(&tv2, NULL);
sec = tv2.tv_sec - tv.tv_sec;
msec = tv2.tv_usec - tv.tv_usec;
msec += sec * 1000000;
printf("%d nodes add/remove: %lu msec\n", NODES, msec);
pool_release(pool);
}
void
parse_item(void)
{
if (!gInItems) {
fprintf(stderr, "\\item found outside an items environment\n");
print_page_and_filename();
print_next_ten_tokens();
jump();
}
curr_node->type = Item;
get_token();
if (token.type == Lsquarebrace) {
/* I should parse the optional argument */
curr_node->next = alloc_node();
curr_node = curr_node->next;
curr_node->type = Description;
curr_node->next = alloc_node();
curr_node = curr_node->next;
gInOptional++;
parse_HyperDoc();
gInOptional--;
curr_node->type = Enddescription;
if (token.type != Rsquarebrace) {
fprintf(stderr, "(HyperDoc) Optional arguments must end with ].\n");
print_next_ten_tokens();
print_page_and_filename();
jump();
}
}
else {
unget_token();
}
}
struct node *parse_equality(struct compiler *compiler)
{
struct node *result = parse_boolean_unary(compiler);
while(is_equality_op(compiler))
{
struct node *node;
if(lexer_current(compiler) == T_NO_EQUALITY)
node = alloc_node(compiler, N_NO_EQUALITY);
else
{
node = alloc_node(compiler, N_BINARY_OP);
node->op = lexer_current(compiler);
}
node->left = result;
lexer_next(compiler);
node->right = parse_boolean_unary(compiler);
result = node;
}
return result;
}
void
quadtree_build(quadtree_t *curr) {
short x1 = curr->x1;
short y1 = curr->y1;
short x2 = curr->x2;
short y2 = curr->y2;
short midx = 0;
short midy = 0;
if (x1 == x2 && y1 == y2) {
return;
}
midx = (x1 + x2) >> 1;
midy = (y1 + y2) >> 1;
curr->nw = alloc_node(x1, y1, midx, midy);
quadtree_build(curr->nw);
if (x1 != x2) {
curr->sw = alloc_node(midx + 1, y1, x2, midy);
quadtree_build(curr->sw);
}
if (y1 != y2) {
curr->ne = alloc_node(x1, midy + 1, midx, y2);
quadtree_build(curr->ne);
}
if (x1 != x2 && y1 != y2) {
curr->se = alloc_node(midx + 1, midy + 1, x2, y2);
quadtree_build(curr->se);
}
}
int
main()//int argc, char ** argv) CHECK_TYPE
{
int sz = 5;
if (sz <= 0)
return 0;
list *root, *cur;
int i = 1;
root = alloc_node(0);
for(cur = root; i < sz; i++)
{
cur->next = alloc_node(i);
cur = cur->next;
}
for(cur = root; cur->next != NULL; cur = cur->next);
{
if(cur)
validptr(cur->next);
}
/* //cur :: { v: ptr(l1,.) | v.id = i} */
/* //l1 -> (4: {v: ptr(l2,.) | v = NULL || v.id = i + 1 ^ v != vvaddr - 4}) */
}
node_t quote_node(node_t node,int quote){
value_t value;
while(quote--){
value=alloc_value(SYMBOL,0);
value->string=unique_string("quote");
node=alloc_node(value,node);
node=alloc_node(alloc_value(LIST,node),0);
}
return node;
}
int main ()
{
int i = 0;
node *head = NULL;
srand(10);
if (!head) {
head = alloc_node('M');
}
push(&head, alloc_node('a'));
push(&head, alloc_node('l'));
push(&head, alloc_node('a'));
push(&head, alloc_node('y'));
push(&head, alloc_node('a'));
push(&head, alloc_node('l'));
push(&head, alloc_node('a'));
push(&head, alloc_node('M'));
printf("\nBefore\n");
disp(head);
// printf("\nAfter\n");
// reverse(head);
reverse_llist(&head);
printf("\nAfter reversing\n");
disp(head);
printf("\nAfter\n");
reverse(head);
}
void add_conf(char *identifier)
{
if (search_conf(identifier) != NULL)
return;
if (conf_list == NULL) {
next_conf_iterator = conf_list = last_conf = alloc_node(identifier);
return;
}
last_conf->next = alloc_node(identifier);
last_conf = last_conf->next;
}
void insert_CLRS(NODE * t, int v)
{
if (dbg_level == 0) {
fprintf(stderr, "%s%d%s, ", GREEN, v, NOCOLOR);
rb_insert(t, alloc_node(v, R));
verify_rbtree(t->L, 0);
} else {
printf("%sinsert %d%s\n", GREEN, v, NOCOLOR);
rb_insert(t, alloc_node(v, R));
______________________________("./fig/", t, t, "inserted %d", v);
}
}
static ucl_node_t
fill (int number_of_elements, int first)
{
ucl_node_t R, N, M;
int i;
R = alloc_node(first);
for (i=1, N = R; i<number_of_elements; ++i) {
M = alloc_node(i + first);
ucl_list_set_cdr(N, M);
N = M;
}
return R;
}
node_t hash_push_value(char* key,node_t value){
node_t head,target,nvalue;
head=HASH+key2hash(key,NUM);
target=get_node(head->cdr,key);
if(!target){
target=alloc_node(key);
target->cdr=head->cdr;
head->cdr=target;
}
nvalue=alloc_node(key);
nvalue->child=value;
node->child=push_value(node->child,nvalue);
return value;
}
NODE * str2tree(const char ** pstr)
{
/* examples:
* ()
* (2), (2+)
* (2(1)(3)), (2+(1)(3)), (2(1+)(3+))
* (2(1+)()), (2()(3+))
*/
int k;
const char * p = *pstr;
NODE * x = 0;
assert(*p == '(');
p++;
assert(isdigit(*p) || *p == ')');
if (isdigit(*p)) {
k = 0;
while (isdigit(*p))
k = k * 10 + (*p++ - '0');
if (*p == '+') {
x = alloc_node(k, R);
p++;
} else {
assert(*p == '(' || *p == ')');
x = alloc_node(k, B);
}
if (*p == '(') {
x->L = str2tree(&p);
if (x->L != nil)
x->L->P = x;
x->R = str2tree(&p);
if (x->R !=nil)
x->R->P = x;
}
} else {
x = nil;
}
assert(*p == ')');
p++;
printf("processed ");
for (const char * q = *pstr; q < p; q++)
printf("%s%c%s", GREEN, *q, NOCOLOR);
printf("\n");
*pstr = p;
return x;
}
void check_interrupt(void)
{
struct node* event;
if (g_dev.r4300.mi.regs[MI_INTR_REG] & g_dev.r4300.mi.regs[MI_INTR_MASK_REG])
g_cp0_regs[CP0_CAUSE_REG] = (g_cp0_regs[CP0_CAUSE_REG] | CP0_CAUSE_IP2) & ~CP0_CAUSE_EXCCODE_MASK;
else
g_cp0_regs[CP0_CAUSE_REG] &= ~CP0_CAUSE_IP2;
if ((g_cp0_regs[CP0_STATUS_REG] & (CP0_STATUS_IE | CP0_STATUS_EXL | CP0_STATUS_ERL)) != CP0_STATUS_IE) return;
if (g_cp0_regs[CP0_STATUS_REG] & g_cp0_regs[CP0_CAUSE_REG] & UINT32_C(0xFF00))
{
event = alloc_node(&q.pool);
if (event == NULL)
{
DebugMessage(M64MSG_ERROR, "Failed to allocate node for new interrupt event");
return;
}
event->data.count = next_interrupt = g_cp0_regs[CP0_COUNT_REG];
event->data.type = CHECK_INT;
if (q.first == NULL)
{
q.first = event;
event->next = NULL;
}
else
{
event->next = q.first;
q.first = event;
}
}
}
void check_interupt(void)
{
struct node *event;
if ((g_r4300.mi.regs[MI_INTR_REG] & g_r4300.mi.regs[MI_INTR_REG]))
g_cp0_regs[CP0_CAUSE_REG] = (g_cp0_regs[CP0_CAUSE_REG] | UINT32_C(0x400)) & UINT32_C(0xFFFFFF83);
else
g_cp0_regs[CP0_CAUSE_REG] &= ~UINT32_C(0x400);
if ((g_cp0_regs[CP0_STATUS_REG] & UINT32_C(7)) != 1)
return;
if (g_cp0_regs[CP0_STATUS_REG] & g_cp0_regs[CP0_CAUSE_REG] & UINT32_C(0xFF00))
{
event = alloc_node(&q.pool);
if (!event)
{
DebugMessage(M64MSG_ERROR, "Failed to allocate node for new interrupt event");
return;
}
event->data.count = next_interupt = g_cp0_regs[CP0_COUNT_REG];
event->data.type = CHECK_INT;
if (!q.first)
{
q.first = event;
event->next = NULL;
}
else
{
event->next = q.first;
q.first = event;
}
}
}
node_t* make_string_node(char *literal)
{
node_t *node = alloc_node();
node->type = STRING;
node->value.string_literal = literal;
return node;
}
node_t* make_field_node(char *fieldname)
{
node_t *node = alloc_node();
node->type = FIELD;
node->value.field.fieldname = fieldname;
return node;
}
/*
* get_node()
* Return node, either from hash or created from scratch
*/
struct openfile *
get_node(daddr_t d)
{
struct openfile *o;
/*
* From hash?
*/
o = hash_lookup(node_hash, d);
if (o) {
/*
* Yes--add a reference, and return
*/
ref_node(o);
return(o);
}
/*
* Get a new one, and return it
*/
o = alloc_node(d);
if (hash_insert(node_hash, d, o)) {
deref_node(o);
o = 0;
}
return(o);
}
dmp_pos dmp_range_init(
dmp_pool *pool, dmp_range *run,
int op, const char *data, uint32_t offset, uint32_t len)
{
run->start = run->end = alloc_node(pool, op, data, offset, len);
return run->start;
}
NODE * init_rbtree(const char * tstr)
{
nil = alloc_node(-1, B); /* the sentinel */
nil->P = nil;
nil->L = nil;
nil->R = nil;
NODE * head= alloc_node(INT_MAX, B);
head->P = nil;
head->L = str2tree(&tstr);
head->R = nil;
assert(*tstr == '\0');
return head;
}
int
main()
{
node_t *temp;
node_t *root = alloc_node(1);
root->next = alloc_node(2);
root->next->next = alloc_node(3);
root->next->next->next = alloc_node(4);
root->next->next->next->next = alloc_node(5);
root = remove_elem(&root, 1);
for (temp = root; temp != NULL; temp = temp->next) {
printf("%d \n", temp->val);
}
}
struct Node* insert_node(struct Node* list, int val1, int val2) {
struct Node* node = alloc_node();
node->val1 = val1;
node->val2 = val2;
node->next = list;
return node;
}
bool enqueue(T const & t)
{
node * n = alloc_node(t);
if (n == NULL)
return false;
for (;;)
{
atomic_node_ptr tail (tail_);
read_memory_barrier();
atomic_node_ptr next (tail->next);
if (likely(tail == tail_))
{
if (next.get_ptr() == 0)
{
if ( tail->next.cas(next, n) )
{
tail_.cas(tail, n);
return true;
}
}
else
tail_.cas(tail, next.get_ptr());
}
}
}
void
parse_begin_items(void)
{
TextNode *bi = curr_node;
/*
* This procedure parses a begin item. It sets the current
* node and sees if there is an optional argument for the itemspace
*/
bi->type = token.type;
get_token();
if (token.type == Lsquarebrace) {
bi->data.node = alloc_node();
curr_node = bi->data.node;
gInOptional++;
parse_HyperDoc();
gInOptional--;
curr_node->type = Enddescription;
if (token.type != Rsquarebrace) {
fprintf(stderr, "(HyperDoc) Optional arguments must end with ].\n");
print_next_ten_tokens();
print_page_and_filename();
jump();
}
curr_node = bi;
}
else
unget_token();
gInItems++;
}
dmp_pos dmp_range_insert(
dmp_pool *pool, dmp_range *run, dmp_pos pos,
int op, const char *data, uint32_t offset, uint32_t len)
{
dmp_node *node;
dmp_pos added_at = alloc_node(pool, op, data, offset, len);
if (added_at < 0)
return pos;
node = dmp_node_at(pool, added_at);
if (pos == -1) {
dmp_node *end = dmp_node_at(pool, run->end);
node->next = end->next;
end->next = added_at;
run->end = added_at;
}
else if (pos == 0) {
node->next = run->start;
run->start = added_at;
}
else {
dmp_node *after = dmp_node_at(pool, pos);
node->next = after->next;
after->next = added_at;
}
return added_at;
}
node_t* make_int_node(int literal)
{
node_t *node = alloc_node();
node->type = INT;
node->value.int_literal = literal;
return node;
}
static struct name_id* parse_line(char *line)
{
char *p;
int i;
char id_buf[MAX_ID_LEN+1];
struct name_id *node;
node = alloc_node();
p = line;
i = 0;
// Get name field
while (*p != ':') {
if (i > MAX_NAME_LEN)
error_msg_and_die("Name field too long");
node->name[i++] = *p++;
}
node->name[i] = '\0';
p++;
// Skip the second field
while (*p != ':')
p++;
p++;
// Get id field
i = 0;
while (*p != ':') {
if (i > MAX_ID_LEN)
error_msg_and_die("ID filed too long");
id_buf[i++] = *p++;
}
id_buf[i] = '\0';
node->id = atol(id_buf);
return node;
}
node_t* make_op_node(enum operation op)
{
node_t* node = alloc_node();
node->type = OP;
node->value.op = op;
return node;
}
EC_API ec_list ec_list_copy( ec_list list )
{
ec_list newlist;
ec_list_iterator iter;
ec_list_node node, newnode, last;
check_list(list);
newlist = ec_list_create();
if (! newlist) return NULL;
last = NULL;
iter = ec_list_iterator_create( list );
while ((node = ec_list_iterator_next( iter )))
{
check_node(node);
newnode = alloc_node( KEY(node), DATA(node) );
ASSERT( newnode );
if (! newnode) return NULL; /* argh ! */
if (last)
NEXT(last) = newnode;
else
{
HEAD(newlist) = newnode;
last = newnode;
}
}
ec_list_iterator_destroy( iter );
check_list(newlist);
return newlist;
}
node_t clone_node(node_t src,node_t dst){
if
dst=dst?alloc_node(src->key);
node_t dst=calloc(1,sizeof(node_));
return HEAD=dst;
}
