void del_tree(struct node *n)
{
if (n == NULL)
return;
del_tree(n->left);
del_tree(n->right);
free(n);
}
int del_tree(t_node **tree)
{
if (tree && *tree)
{
if ((*tree) && (*tree)->left)
del_tree(&((*tree)->left));
if ((*tree) && (*tree)->right)
del_tree(&((*tree)->right));
clear_node(tree);
tree = NULL;
}
savior_tree(NULL, TRUE);
return (TRUE);
}
int
del_tree(
ptree_t* t
)
{
int i,j;
if(NULL == t)
goto exit;
/* delete all the children */
for(i=0; i< PTREE_CHILDREN; i++) {
/* shm_free the rg array of rt_info */
if(NULL!=t->ptnode[i].rg) {
for(j=0;j<t->ptnode[i].rg_pos;j++) {
/* if non intermediate delete the routing info */
if(t->ptnode[i].rg[j].rtlw !=NULL)
del_rt_list(t->ptnode[i].rg[j].rtlw);
}
shm_free(t->ptnode[i].rg);
}
/* if non leaf delete all the children */
if(t->ptnode[i].next != NULL)
del_tree(t->ptnode[i].next);
}
shm_free(t);
exit:
return 0;
}
/* test */
int main()
{
struct node *l, *r, *root = cons(1);
l = cons(2);
r = cons(3);
root->left = l;
root->right = r;
l->left = cons(4);
l->right = cons(5);
r->left = cons(6);
r->right = cons(7);
printf("before:\n");
print(root, 0);
printf("\n");
printf("breadth-first traversal...\n");
bro_link(root);
printf("\n");
printf("after:\n");
print(root, 0);
del_tree(root);
return 0;
}
void
free_rt_data(
rt_data_t* rt_data,
int all
)
{
int j;
if(NULL!=rt_data) {
/* del GW list */
del_pgw_list(rt_data->pgw_l);
rt_data->pgw_l = 0 ;
/* del prefix tree */
del_tree(rt_data->pt);
rt_data->pt = 0 ;
/* del prefixless rules */
if(NULL!=rt_data->noprefix.rg) {
for(j=0;j<rt_data->noprefix.rg_pos;j++) {
if(rt_data->noprefix.rg[j].rtlw !=NULL) {
del_rt_list(rt_data->noprefix.rg[j].rtlw);
rt_data->noprefix.rg[j].rtlw = 0;
}
}
shm_free(rt_data->noprefix.rg);
rt_data->noprefix.rg = 0;
}
/* del carriers */
del_carriers_list(rt_data->carriers);
rt_data->carriers=0;
/* del top level */
if (all) shm_free(rt_data);
}
}
void
free_rt_data(
rt_data_t* rt_data,
int all
)
{
int j;
if(NULL!=rt_data) {
/* del GW list */
del_pgw_list(rt_data->pgw_l);
rt_data->pgw_l = 0 ;
/* del GW addr list */
del_pgw_addr_list(rt_data->pgw_addr_l);
rt_data->pgw_addr_l =0;
/* del prefix tree */
del_tree(rt_data->pt);
/* del prefixless rules */
if(NULL!=rt_data->noprefix.rg) {
for(j=0;j<rt_data->noprefix.rg_pos;j++) {
if(rt_data->noprefix.rg[j].rtlw !=NULL) {
del_rt_list(rt_data->noprefix.rg[j].rtlw);
rt_data->noprefix.rg[j].rtlw = 0;
}
}
shm_free(rt_data->noprefix.rg);
rt_data->noprefix.rg = 0;
}
/* del top level or reset to 0 it's content */
if (all) shm_free(rt_data);
else memset(rt_data, 0, sizeof(rt_data_t));
}
}
int main() {
bintree mytree = {0};
srand(time(NULL));
for (unsigned long long i = 0; i < TREE_SIZE; i++) {
add_to_tree(&mytree, rand() % 100);
}
print_tree(&mytree);
del_tree(&mytree);
return 0;
}
int del_tree(struct _node *root){
/* Deja free ou blague... */
if(root==NULL)
return EXIT_FAILURE;
/* Si on est sur un feuille c'est facile! */
if(!is_leaf(root))
del_tree(root->first_son);
del_bro(root);
return EXIT_SUCCESS;
}
void del_tree(TreeNode *tree)
{
int i;
// Si ce n'est pas une feuille, appel récursif
if(tree->childs[0] != NULL)
{
for(i=0; i<4; ++i)
del_tree(tree->childs[i]);
}
free(tree);
}
int del_bro(struct _node *node) {
if(node==NULL)
return EXIT_FAILURE;
fprintf(stderr,"%c",node->c);
if(!is_last_son(node))
del_tree(node->brother);
if(node->variable!=NULL)
free(node->variable);
free(node);
return EXIT_SUCCESS;
}
VOID cut_tree(WORD sobj, WORD dup)
{
WORD where;
LONG tree;
if (rcs_lock)
hndl_locked();
else
{
tree = tree_addr(sobj - 1);
where = find_value((BYTE *) tree);
rcs_clipkind = get_kind(where);
ad_clip = copy_tree(tree, ROOT, TRUE);
if (!dup)
del_tree(sobj);
}
}
void tree_mergeNode(TreeNode *parent)
{
int i, j;
TreeNode *tmpChilds[4];
// On stoque l'addresse des fils, et on les détache du parent
for(i=0; i<4; ++i)
{
tmpChilds[i] = parent->childs[i];
parent->childs[i] = NULL;
}
// Remise à propre du parent
for(i=0; i<NODE_MAX_DYNAMIC_ACTOR; ++i)
parent->dynamicObjects[i] = NULL;
for(i=0; i<NODE_MAX_STATIC_ACTOR; ++i)
parent->staticObjects[i] = NULL;
parent->nb_dynamicObjects = 0;
parent->nb_staticObjects = 0;
// On réinjecte les actors des fils dans le père et on supprime les fils
for(i=0; i<4; ++i)
{
for(j=0; j<NODE_MAX_DYNAMIC_ACTOR; ++j)
{
if(tmpChilds[i]->dynamicObjects[j] != NULL)
{
parent->dynamicObjects[parent->nb_dynamicObjects] = tmpChilds[i]->dynamicObjects[j];
parent->nb_dynamicObjects++;
}
}
for(j=0; j<NODE_MAX_STATIC_ACTOR; ++j)
{
if(tmpChilds[i]->staticObjects[j] != NULL)
{
parent->staticObjects[parent->nb_staticObjects] = tmpChilds[i]->staticObjects[j];
parent->nb_staticObjects++;
}
}
del_tree(tmpChilds[i]);
}
// Mise à jour du nombre de nodes
nb_nodes -= 4;
}
int exit_pgm(int exit_code)
{
t_node *tree;
t_line *stline;
t_duo *env;
tree = savior_tree(NULL, FALSE);
savior_history(NULL, FALSE);
stline = savior_stline(NULL, FALSE);
env = savior_env(NULL, FALSE);
del_tree(&tree);
savior_tree(NULL, TRUE);
save_history();
duo_del(&env);
savior_env(NULL, TRUE);
reset_term();
del_stline(&stline);
savior_stline(NULL, TRUE);
exit(exit_code);
return (0);
}
/******************************************************************************
mysql_install_db()
Install the test databases.
******************************************************************************/
void mysql_install_db()
{
char temp[PATH_MAX];
// var directory
snprintf(temp, PATH_MAX, "%s/var", mysql_test_dir);
// clean up old direcotry
del_tree(temp);
// create var directory
mkdir(temp, S_IRWXU);
// create subdirectories
log_msg("Creating test-suite folders...\n");
snprintf(temp, PATH_MAX, "%s/var/run", mysql_test_dir);
mkdir(temp, S_IRWXU);
snprintf(temp, PATH_MAX, "%s/var/tmp", mysql_test_dir);
mkdir(temp, S_IRWXU);
snprintf(temp, PATH_MAX, "%s/var/master-data", mysql_test_dir);
mkdir(temp, S_IRWXU);
snprintf(temp, PATH_MAX, "%s/var/master-data/mysql", mysql_test_dir);
mkdir(temp, S_IRWXU);
snprintf(temp, PATH_MAX, "%s/var/master-data/test", mysql_test_dir);
mkdir(temp, S_IRWXU);
snprintf(temp, PATH_MAX, "%s/var/slave-data", mysql_test_dir);
mkdir(temp, S_IRWXU);
snprintf(temp, PATH_MAX, "%s/var/slave-data/mysql", mysql_test_dir);
mkdir(temp, S_IRWXU);
snprintf(temp, PATH_MAX, "%s/var/slave-data/test", mysql_test_dir);
mkdir(temp, S_IRWXU);
// install databases
log_msg("Creating test databases for master... \n");
install_db(master_dir);
log_msg("Creating test databases for slave... \n");
install_db(slave_dir);
}
int
km_coffee_align3(char *seq_f, int k, int k_leaf, char *method, char *aln_f, int n_cores, int gapopen, int gapext, char *init)
{
char *use_as_temp = get_tmp_4_tcoffee();
#ifdef _OPENMP
omp_set_num_threads(n_cores);
#endif
SeqSet *seq_set = read_fasta(seq_f);
qsort(seq_set->seqs, seq_set->n_seqs, sizeof(Seq*), my_seq_sort);
srand(time(0));
short j = -1;
short i;
/****************************************************
Sequences to vector using k-mers
*****************************************************/
short alphabet[256];
// standard alphabet
for (i = 65; i < 91; ++i)
if ((i==66) || (i==74) || (i==79) || (i==88) || (i==90))
alphabet[i] = 0;
else
alphabet[i] = ++j;
j=-1;
for (i = 97; i < 123; ++i)
if ((i==98) || (i==106) || (i==111) || (i==120) || (i==122))
alphabet[i] = 0;
else
alphabet[i] = ++j;
// shrinked alphabet
// for (i = 0; i < 256; ++i)
// alphabet[i] = 0;
// char *groups[]={"LlVvIiMmCcAaGgSsTtPpFfYyWw","EeDdNnQqKkRrHh"};
// char *groups[]={"LlVvIiMmCc","AaGgSsTtPp","FfYyWw","EeDdNnQqKkRrHh"};
// size_t n_groups = 4;
// size_t len;
// char *group;
// for (i=0; i<n_groups; ++i)
// {
// group=groups[i];
// len=strlen(group);
// for (j=0; j<len; ++j)
// alphabet[group[j]]=i+1;
// }
VectorSet *vec_set = seqset2vecs_kmer(seq_set, 2, 21, alphabet);
/****************************************************
Sequences to vector using distances
*****************************************************/
// char *groups[]={"LVIMC","AGSTP","FYW","EDNQKRH"};
// size_t n_groups = 4;
// char *groups[]={"LlVvIiMmCc","AaGgSsTtPp","FfYyWw","EeDdNnQqKkRrHh"};
// char *groups[]={"LlVvIiMmCcAaGgSsTtPpFfYyWw","EeDdNnQqKkRrHh"};
// size_t n_groups = 2;
// VectorSet *vec_set = seqset2vecs_whatever(seq_set, groups, n_groups);
// char vec_file[500];
// sprintf(vec_file, "%s_2_8_%li_%li.txt", strrchr(seq_f, '/')+1, vec_set->n_vecs, vec_set->dim);
// print_vecs(vec_set, &vec_file[0]);
// read_vecs(vec_set, "matrix_59");
// exit(1);
// normalize(vec_set);
KM_node *root = hierarchical_kmeans(vec_set, k, k_leaf, init, 0.001);
// KM_node *root = simple_clust(vec_set, k);
char templatee[400];
sprintf(templatee, "%s/km_coffee_tmp_XXXXXX", use_as_temp);
char tmp_str[FILENAME_MAX];
km_cwd = getcwd(tmp_str, FILENAME_MAX);
km_tmp_dir = my_make_temp_dir(templatee, "main");
chdir(km_tmp_dir);
char out_f[500];
if (aln_f[0] != '/')
sprintf(out_f, "%s/%s", km_cwd, aln_f);
else
sprintf(out_f, "%s", aln_f);
size_t n_vecs = seq_set->n_seqs;
int *assignment = (int*)malloc(n_vecs*sizeof(int));
size_t l;
for (l = 0; l< n_vecs; ++l)
assignment[l]=vec_set->vecs[l]->id;
// printf("TRAVERSE\n");
delVecSet(vec_set);
traverse_km_tree(root, assignment, seq_set, out_f, n_cores, gapopen, gapext, method);
free( assignment);
del_tree(root);
delSeqSet(seq_set);
free(km_tmp_dir);
return EXIT_SUCCESS;
}
int main()
{
TreeNode *tree = NULL;
TreeNode *node;
guint i;
g_assert (!add_tree (&tree, 1));
g_assert (!add_tree (&tree, 2));
g_assert (!add_tree (&tree, 3));
g_assert ( add_tree (&tree, 1));
g_assert ( add_tree (&tree, 2));
g_assert ( add_tree (&tree, 3));
g_assert (!test_tree (&tree, 0));
g_assert ( test_tree (&tree, 1));
g_assert ( test_tree (&tree, 2));
g_assert ( test_tree (&tree, 3));
g_assert (!test_tree (&tree, 4));
g_assert (!del_tree (&tree, 0));
g_assert ( del_tree (&tree, 2));
g_assert (!del_tree (&tree, 4));
g_assert (!test_tree (&tree, 0));
g_assert ( test_tree (&tree, 1));
g_assert (!test_tree (&tree, 2));
g_assert ( test_tree (&tree, 3));
g_assert (!test_tree (&tree, 4));
g_assert ( add_tree (&tree, 1));
g_assert (!add_tree (&tree, 2));
g_assert ( add_tree (&tree, 3));
g_assert ( del_tree (&tree, 1));
g_assert ( del_tree (&tree, 2));
g_assert ( del_tree (&tree, 3));
g_assert (tree == NULL);
GSK_RBTREE_FIRST (TREE(&tree), node);
g_assert (node == NULL);
GSK_RBTREE_LAST (TREE(&tree), node);
g_assert (node == NULL);
/* Construct tree with odd numbers 1..999 inclusive */
for (i = 1; i <= 999; i += 2)
g_assert (!add_tree (&tree, i));
GSK_RBTREE_FIRST (TREE(&tree), node);
g_assert (node != NULL);
g_assert (node->value == 1);
GSK_RBTREE_LAST (TREE(&tree), node);
g_assert (node != NULL);
g_assert (node->value == 999);
for (i = 1; i <= 999; i += 2)
{
g_assert (test_tree (&tree, i));
g_assert (!test_tree (&tree, i+1));
}
for (i = 0; i <= 999; i++)
{
GSK_RBTREE_SUPREMUM_COMPARATOR (TREE(&tree), i, COMPARE_INT_WITH_TREE_NODE, node);
g_assert (node);
g_assert (node->value == (i%2)?i:(i+1));
}
GSK_RBTREE_SUPREMUM_COMPARATOR (TREE(&tree), 1000, COMPARE_INT_WITH_TREE_NODE, node);
g_assert (node==NULL);
for (i = 1; i <= 1000; i++)
{
TreeNode *node;
GSK_RBTREE_INFIMUM_COMPARATOR (TREE(&tree), i, COMPARE_INT_WITH_TREE_NODE, node);
g_assert (node);
g_assert (node->value == (i%2)?i:(i-1));
}
GSK_RBTREE_INFIMUM_COMPARATOR (TREE(&tree), 0, COMPARE_INT_WITH_TREE_NODE, node);
g_assert (node==NULL);
for (i = 1; i <= 999; i += 2)
g_assert (del_tree (&tree, i));
/* random rbctree test */
g_printerr ("Testing RBC-tree macros... ");
for (i = 0; i < 1000; i++)
test_random_rbcint_tree (10, TRUE);
g_printerr (".");
for (i = 0; i < 100; i++)
test_random_rbcint_tree (100, TRUE);
g_printerr (".");
for (i = 0; i < 50; i++)
{
test_random_rbcint_tree (1000, FALSE);
g_printerr (".");
}
for (i = 0; i < 5; i++)
{
test_random_rbcint_tree (10000, FALSE);
g_printerr (".");
}
g_printerr (" done.\n");
return 0;
}
int main()
{
// Ressources
unsigned long t_debut, t_fin;
float dt, waitShoot = 0;
BITMAP *buffer;
int fin = 0, v = 200;
Map *map;
DepthList *depthList;
Rect screen_pos, map_pos;
Actor *joueur;
// Initialisation
fprintf(stderr,"Initialisation ...\n");
timeBeginPeriod(1);
set_uformat(U_ASCII);
set_color_depth(32);
allegro_init();
install_keyboard();
install_mouse();
srand(time(NULL));
if(set_gfx_mode(GFX_AUTODETECT_WINDOWED, 1024, 768, 0, 0))
ERREUR("Echec du lancement du mode graphique.");
buffer = create_bitmap(SCREEN_W, SCREEN_H);
resman_loadSprites();
fprintf(stderr,"Chargement des ressources ...\n");
map = new_map("media/map/test1");
map_pos.x = map_pos.y = 0;
map_pos.w = map->w;
map_pos.h = map->h;
actList = new_glist();
root = new_tree(map_pos);
map_addEntities(map, actList, root);
depthList = new_dlist();
screen_pos.w = SCREEN_W;
screen_pos.h = SCREEN_H;
// Ajout du joueur
joueur = actor_addJoueur(actList, root, 500, 500);
// Intro
debut();
// Boucle principale
fprintf(stderr,"Debut !\n");
t_debut = timeGetTime();
while(!fin)
{
// Gestion clavier
if(key[KEY_ESC])
{
fin = 1;
}
if(key[KEY_W])
{
joueur->vit_y = -v;
joueur->direction_regard = HAUT;
joueur->etat = ETAT_MARCHE;
}
else if(key[KEY_S])
{
joueur->vit_y = v;
joueur->direction_regard = BAS;
joueur->etat = ETAT_MARCHE;
}
else
joueur->vit_y = 0;
if(key[KEY_A])
{
joueur->vit_x = -v;
joueur->direction_regard = GAUCHE;
joueur->etat = ETAT_MARCHE;
}
else if(key[KEY_D])
{
joueur->vit_x = v;
joueur->direction_regard = DROITE;
joueur->etat = ETAT_MARCHE;
}
else
joueur->vit_x = 0;
if(joueur->vit_x != 0 && joueur->vit_y != 0)
{
joueur->vit_x /= sqrt(2);
joueur->vit_y /= sqrt(2);
}
if(!key[KEY_W] && !key[KEY_D] && !key[KEY_S] && !key[KEY_A])
joueur->etat = ETAT_REPOS;
if(key[KEY_Q])
{
if(waitShoot <= 0)
{
waitShoot = .1;
actor_addTree(actList, root, mouse_x + screen_pos.x, mouse_y + screen_pos.y);
}
}
waitShoot -= dt;
if(mouse_b&1)
{
float vx, vy, v;
if(waitShoot <= 0)
{
waitShoot = .3;
vx = mouse_x - (joueur->pos_x - screen_pos.x);
vy = mouse_y - (joueur->pos_y - screen_pos.y);
v = sqrt(vx*vx + vy*vy);
vx = vx/v;
vy = vy/v;
actor_addMissile(actList, root, joueur->pos_x + vx*joueur->w*1.5, joueur->pos_y + vy*joueur->h*1.5, vx*300, vy*300);
}
}
if(key[KEY_P])
{
FILE *fd = fopen("arbres.txt", "w+");
Actor *act;
glist_startIter(actList);
while(!glist_endIter(actList))
{
act = glist_getCurrentData(actList);
if(act->type == ACT_TREE)
fprintf(fd, "%d\n%d\n", (int) act->pos_x, (int) act->pos_y);
glist_iter(actList);
}
fclose(fd);
}
// Double buffer
clear_bitmap(buffer);
render_map(buffer, map, screen_pos.x, screen_pos.y);
// Mises à jour
resman_updateSprites(&dt);
actor_spawnMonster(actList, root);
actor_ia(actList, joueur);
// Deplacement
glist_startIter(actList);
while(!glist_endIter(actList))
{
actor_update(glist_getCurrentData(actList), map_pos, map, dt);
if( ((Actor*) glist_getCurrentData(actList))->deleting)
{
glist_remCell(actList, glist_getCurrentId(actList));
}
else
glist_iter(actList);
}
// Cadrage ecran
screen_pos.x = joueur->pos_x - SCREEN_W/2;
screen_pos.y = joueur->pos_y - SCREEN_H/2;
// Collision
tree_collisionDetection(root);
// Affichage
tree_update(root);
dlist_getActorsFromTree(depthList, root, screen_pos);
dlist_update(depthList, screen_pos);
dlist_blit(depthList, buffer, screen_pos);
draw_cursor(buffer);
textprintf_centre_ex(buffer, font, SCREEN_W/2, 5, makecol(0, 0, 0), makecol(255, 0, 0), " Vies restantes : %d | Score : %d ", joueur->vie, score);
// Rafraichissement écran
vsync();
blit(buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
// Gestion du temps
t_fin = timeGetTime();
dt = ((float)t_fin - t_debut)/1000;
t_debut = t_fin;
// Test fin de jeu
if(joueur->deleting)
fin = 1;
resman_freeList();
}
// Game over
gameover();
// Fin
timeEndPeriod(1);
delete_map(map);
del_tree(root);
del_dlist(depthList);
del_glist(actList);
destroy_bitmap(buffer);
resman_freeSprites();
allegro_exit();
return 0;
}
