void test_set_operations(){
set_t *even1 = new_set(10);
set_t *even2 = new_set(10);
set_t *odd = new_set(10);
int i;
for (i=0; i < 10; i++){
set_put(even1, 2*i);
set_put(even2, 2*i);
set_put(odd, 2*i+1);
}
set_union(even1, odd);
assert(set_size(even1) == 20);
set_difference(even2, odd);
assert(set_size(even2) == 10);
set_intersection(even2, odd);
assert(set_size(even2) == 0);
set_print(even1); printf("\n");
set_optimize(even1);
set_print(even1); printf("\n");
set_print(even2); printf("\n");
set_print(odd); printf("\n");
delete_set(even1);
delete_set(even2);
delete_set(odd);
}
void
aoi_release(struct aoi_space *space) {
map_foreach(space->object, delete_object, space);
map_delete(space, space->object);
delete_pair_list(space);
delete_set(space,space->watcher_static);
delete_set(space,space->marker_static);
delete_set(space,space->watcher_move);
delete_set(space,space->marker_move);
space->alloc(space->alloc_ud, space, sizeof(*space));
}
/**
* Called as part of the hashmap callback
* to cleanup the sets.
*/
static int set_map_delete_cb(void *data, const char *key, uint32_t key_len, void *value) {
(void)data;
(void)key;
(void)key_len;
hlld_set_wrapper *set = value;
delete_set(set);
return 0;
}
void fill_predict_set(void)
{
GRAMMAR *G_ptr;
TOKEN *ptr , *first , *follow , *predict;
SET *set_ptr , *set_srtat , *set_end;
predict = (TOKEN*) malloc(sizeof(TOKEN));
predict->set = NULL;
predict->next = NULL;
strncpy( predict->string , "predict" , strlen("predict")+1 );
for ( G_ptr = G_start ; G_ptr != NULL ; G_ptr = G_ptr->next )
{
set_srtat = NULL;
set_end = NULL;
//predict = search_token( predict_set_start , G_ptr->lhs );
for ( ptr = G_ptr->rhs_string ; ptr != NULL ; ptr = ptr->next )
{
first = search_token( first_set_start , ptr->string );
if ( first == NULL )
{
continue;
}
else if ( search_set( first , "£f" ) == TRUE )
{
add_set( predict , first );
delete_set( &(predict->set) , "£f" );
continue;
}
else
{
add_set( predict , first );
break;
}
}
if ( ptr == NULL )
{
follow = search_token( follow_set_start , G_ptr->lhs );
add_set( predict , follow );
}
for( set_ptr = predict->set ; set_ptr != NULL ; set_ptr = set_ptr->next )
{
insert_predict( &set_srtat , &set_end , set_ptr->string );
//printf("%s ",set_ptr->string);
}
G_ptr->set = set_srtat;
//printf("\n");
//view_token(predict);
free_set(&(predict->set));
}
}
void test_basic(){
set_t *set = new_set(10);
int i, j;
for (i=0; i < 10; i++){
for (j=0; j < 10; j++){
set_put(set, i);
}
}
assert(set_size(set) == 10);
delete_set(set);
}
/**
* Deletes old versions from the delta lists, and calls
* delete_set on the sets in the destroyed list.
*
* Safety: Same as remove_delta_versions
*/
static void delete_old_versions(hlld_setmgr *mgr, unsigned long long min_vsn) {
// Get the merged in pending ops, lock to avoid a race
pthread_mutex_lock(&mgr->write_lock);
set_list *old = remove_delta_versions(mgr->delta, &mgr->delta, min_vsn);
pthread_mutex_unlock(&mgr->write_lock);
// Delete the sets now that we have merged into both trees
set_list *next, *current = old;
while (current) {
if (current->type == DELETE) delete_set(current->set);
next = current->next;
free(current);
current = next;
}
}
void test_removing(){
set_t *set = new_set(0);
int i;
for (i=0; i < 1000; i++){ set_put(set, i); }
assert(set_size(set) == 1000);
set_optimize(set);
for (i=0; i < 1000; i += 2){ set_remove(set, i); }
assert(set_size(set) == 500);
for (i=0; i < 1000; i += 2){ set_put(set, i); }
assert(set_size(set) == 1000);
delete_set(set);
}
void test_picking(){
int n = 10000;
set_t *set = new_set(0);
int i;
for (i=0; i < n; i++){
set_put(set, i);
}
assert(set_size(set) == n);
set_entry_t *p = set_head(set);
for (i=0; i < n; i++){
assert(p->key == i);
p = p->next;
}
for (i=0; i < 3*n; i++){
int v = set_get_random(set);
assert(v < n);
}
delete_set(set);
}
/**
* Cleanup
* @arg mgr The manager to destroy
* @return 0 on success.
*/
int destroy_set_manager(hlld_setmgr *mgr) {
// Stop the vacuum thread
mgr->should_run = 0;
if (mgr->vacuum_thread) pthread_join(mgr->vacuum_thread, NULL);
// Nuke all the keys in the current version.
art_iter(mgr->set_map, set_map_delete_cb, mgr);
// Handle any delta operations
set_list *next, *current = mgr->delta;
while (current) {
// Only delete pending creates, pending
// deletes are still in the primary tree
if (current->type == CREATE)
delete_set(current->set);
next = current->next;
free(current);
current = next;
}
// Free the clients
setmgr_client *cl_next, *cl = mgr->clients;
while (cl) {
cl_next = cl->next;
free(cl);
cl = cl_next;
}
// Destroy the ART trees
destroy_art_tree(mgr->set_map);
destroy_art_tree(mgr->alt_set_map);
free((mgr->set_map < mgr->alt_set_map) ? mgr->set_map : mgr->alt_set_map);
// Free the manager
free(mgr);
return 0;
}
int comput_first_f( TOKEN *alpha , TOKEN *dst , char *dst_name )
{
int change = FALSE;
TOKEN *ptr , *ptr2 , *ptr3 , *ptr_end;
TOKEN *tmp;
is_lambda = FALSE;
tmp = (TOKEN*) malloc(sizeof(TOKEN));
strncpy( tmp->string , "tmp" , 4 );
tmp->set = NULL;
tmp->next = NULL;
if( alpha == NULL )
{
is_lambda = TRUE;
return FALSE;
}
if ( strcmp( alpha->string , "£f" ) == 0 )
{
//ptr = search_token( dst , dst_name );
//if ( insert_set( ptr , "£f" ) == TRUE )
is_lambda = TRUE;
change = TRUE;
}
else
{
ptr = search_token( dst , dst_name );
ptr2 = search_token( first_set_start , alpha->string );
add_set( tmp , ptr2 );
delete_set( &(tmp->set) , "£f" );
if ( add_set( ptr , tmp ) == TRUE )
change = TRUE;
free_set( &(tmp->set) );
for( ptr3 = alpha ; ptr3 != NULL ; ptr3 = ptr3->next )
{
ptr2 = search_token( first_set_start , ptr3->string );
if( search_set( ptr2 , "£f" ) != TRUE )
break;
if ( ptr3->next == NULL )
{
ptr_end = ptr3;
ptr3 = search_token( first_set_start , ptr_end->string );
if( search_set( ptr3 , "£f" ) == TRUE )
{
if ( insert_set( ptr , "£f" ) == TRUE )
{
is_lambda = TRUE;
change = TRUE;
}
}
break;
}
ptr2 = search_token( first_set_start , ptr3->next->string );
add_set( tmp , ptr2 );
delete_set( &(tmp->set) , "£f" );
if ( add_set( ptr , tmp ) == TRUE )
{
delete_set( &(ptr->set) , "£f" );
change = TRUE;
}
free_set( &(tmp->set) );
}
}
free_token(&tmp);
return change;
}
int propagate( int state , Config_set *A , Config_set *B )
{
STATE *shift_state;
Config_set *C_ptr , *ptr;
TOKEN *T_ptr , *first;
TOKEN *dot;
TOKEN *L2;
TOKEN *L1;
int i;
L1 = A->lookahead;
dot = A->dot;
L2 = B->lookahead;
//First(£^L)
for( T_ptr = dot->next ; T_ptr != NULL ; T_ptr = T_ptr->next )
{
first = search_token( first_set_start , T_ptr->string );
if (first == NULL )
continue;
if ( search_set(first,"£f") == TRUE )
{
add_set(L2,first);
delete_set( &(L2->set) , "£f" );
continue;
}
else
{
if ( add_set(L2,first) == FALSE )
return 0;
break;
}
}
//First(£^L) , £^ is lambda
if(T_ptr == NULL)
{
add_set( L2 , L1 );
}
//printf("%d\n", parser_table[state][make_id(dot->string)].go_to );
if( B->dot == NULL )
return 0;
i = parser_table[state][make_id(B->dot->string)-1].go_to;
//printf("%d %s -> %d\n",state , B->dot->string , i );
//view_state(state);
if( i == state )
return 0;
// shift state
for( shift_state = state_start ; i != shift_state->statenum ; shift_state = shift_state->next );
for( C_ptr = shift_state->config_set ; C_ptr != NULL && B->rule != C_ptr->rule ; C_ptr = C_ptr->set_next );
{
// if ( i == 105 )
// printf("hit\n");
propagate_link( i , B , C_ptr );
}
//comput lookahead by closue 0
C_ptr = shift_state->config_set;
for( C_ptr = shift_state->config_set ; C_ptr != NULL && C_ptr->set_next != NULL ; C_ptr = C_ptr->set_next )
{
for( ptr = shift_state->config_set ; ptr != NULL ; ptr = ptr->set_next )
{
if ( C_ptr->dot == NULL )
continue;
if ( strcmp( C_ptr->dot->string , ptr->rule->lhs ) == 0 )
{
propagate( shift_state->statenum , C_ptr , ptr );
}
}
}
return 0;
}
