int main() { CARTE c; Liste l1,l2,l3,l4,l5;
char rep; int n;
l1=creer_liste(); l2=creer_liste();
l3=creer_liste(); l4=creer_liste();
l5=creer_liste();
do {
printf("quitter(0); Ajouter en tete(1); Ajouter en queu(2); Supprimer en tete(3); Visualiser(4); Supprimer(5)"); fflush(stdout);
rep=getchar();
switch(rep) {
case '1': printf("Valeur(1..13) et couleur (0..3) \n"); scanf("%d %hhd",&(c.rang),&(c.couleur));
if (c.rang>=1 && c.rang<=13 && c.couleur>=0 && c.couleur<=3)
l1=ajout_tete(c,l1);
break;
case '2': printf("Valeur(1..13) et couleur (0..3) \n"); scanf("%d %hhd",&(c.rang),&(c.couleur));
if (c.rang>=1 && c.rang<=13 && c.couleur>=0 && c.couleur<=3)
l1=ajout_queue(c,l1);
break;
case '3': supprimen(0,l1);
break;
case '4': visualiser_liste(l1);
break;
case '5': printf("Quelle est la position a supprimer ? \n");
scanf("%d",&n);
if (n>=0)
l1=supprimen(n,l1);
break;
default : continue;
break;
}
getchar();
} while (rep !='0');
return 0;
}
int add_ignore (char *name)
{
char *realname;
char *message;
struct ignore_list_t *nouvelle;
if (name == NULL)
return (-1);
if (ignore_list == NULL)
ignore_list = creer_liste();
else {
if(search_first_cel_with_name_in_list(name, ignore_list) != NULL)
return -1;
}
realname = str_to_first_word(name);
message = name + my_strlen (realname);
message = strip_spaces(message);
nouvelle = my_malloc (sizeof (struct ignore_list_t));
nouvelle->name = my_malloc_strcpy(realname);
if (message != NULL && *message != '\0')
nouvelle->message = my_malloc_strcpy(message);
else
nouvelle->message = NULL;
ajout_liste (&ignore_list, nouvelle);
free(realname);
if (message != NULL)
free(message);
return 0;
}
int add_contact (char *name)
{
struct contact_list_t *nouvelle;
if (name == NULL)
return (-1);
if (contact_list == NULL)
contact_list = creer_liste();
else {
if(search_first_cel_with_name_in_list(name, contact_list) != NULL)
return -1;
}
nouvelle = my_malloc (sizeof (struct contact_list_t));
nouvelle->name = my_malloc_strcpy (name);
ajout_liste (&contact_list, nouvelle);
return 0;
}
int main2(int argc, char *argv[],plateauGraphique *plateau){
processeur liste_processeur[16][16];
adresse j1,j2 ;
int nbTours = 20;
int x,y;
char nomBouton[5],b[3];
GtkColorButton *couleur1;
GdkColor color;
int couleur;
srand(time(NULL));
j1.x = plateau->demarre[0].xy.x;
j1.y = plateau->demarre[0].xy.y;
j2.x = plateau->demarre[1].xy.x;
j2.y = plateau->demarre[1].xy.y;
/* printf("%s\n",argv[0]); */
/* printf("%s\n",argv[1]); */
/* printf("%s\n",argv[2]); */
creer_liste(liste_processeur,argc,argv,j1,j2,plateau);
/* printf("Combien de tours de jeu voulez-vous ??\n"); */
LancerBoite();
/* printf("nbTour : %d\n",Choix); */
jeu( liste_processeur, Choix,(plateauGraphique*)plateau);
affichage_gtk(liste_processeur,plateau);
affichage_fin_jeu(controle_victoire(liste_processeur,*(short int *)&liste_processeur[j1.x][j1.y].ram[1],*(short int *)&liste_processeur[j2.x][j2.y].ram[1]));
/* for(x = 0; x<16; x+=1){ */
/* for(y = 0; y<16; y+=1){ */
/* couleur = liste_processeur[y][x].ram[1]; */
/* if(x>9){ */
/* nomBouton[0] = '1'; */
/* nomBouton[1] = 48+(char)x%10; */
/* } */
/* else{ */
/* nomBouton[1] = 48+(char)x%10; */
/* nomBouton[0] = '0'; */
/* } */
/* nomBouton[2] = 0; */
/* if(y>9){ */
/* b[0] = '1'; */
/* b[1] = (char)(48+y%10); */
/* } */
/* else{ */
/* b[1] = (char)(48+y%10); */
/* b[0] = '0'; */
/* } */
/* b[2] = 0; */
/* strcat(nomBouton,b); */
/* if (liste_processeur[y][x].ram[1]!=0){ */
/* /\* printf("Couleur : %d\n",liste_processeur[y][x].ram[1]); *\/ */
/* /\* printf("x = %d, y = %d, bouton : %s\n",x,y,nomBouton); *\/ */
/* couleur1 = (GtkColorButton *)gtk_builder_get_object(p_builder, nomBouton); */
/* color.red=0; */
/* color.green=0; */
/* color.blue=0; */
/* gtk_color_button_set_color(couleur1,&color); */
/* liste_processeur[y][x].ram[1]=0; */
/* } */
/* } */
/* } */
return 1;
}
int main() {
int choix, result;
task * list1, * list2, * tache;
do {
printf("\n********** Menu **********\n\n"
"0 - Quitter.\n"
"1 - Fonction cree_tache.\n"
"2 - Fonction cree_liste.\n"
"3 - Fonction affiche_liste.\n"
"4 - Fonction ajoute_tache.\n"
"5 - Fonction annule_tache.\n"
"6 - Fonction execute_tache_FIFO.\n"
"7 - Fonction depile_tache.\n"
"8 - Fonction execute_tache_LIFO.\n"
"9 - Fonction load_data.\n"
"10 - Fonction load_data2.\n"
"11 - Fonction insere_tache.\n"
"12 - Fonction insere_tache_priorite.\n"
"13 - Fonction fusion_listes.\n"
"14 - Fonction MAJ_priorite.\n\n"
"Choix : ");
scanf("%d", &choix);
switch(choix) {
/* Quitter. */
case 0 :
printf("\n\nfin\n\n");
break;
/* Fonction cree_tache. */
case 1 :
printf("Test fonction cree_tache:\n");
printf("Cas 1 : valeurs courantes\n");
tache = cree_tache("aa",1);
affiche_liste(tache);
printf("Cas 2 : id vide\n");
tache = cree_tache("",5);
affiche_liste(tache);
printf("Cas 2 bis : duree negative\n");
tache = cree_tache("rr",-6);
affiche_liste(tache);
printf("Cas 3 : id = NULL\n"
"Impossible de créer une tache sans identifiant.\n");
break;
/* Fonction cree_liste. */
case 2 :
printf("Test fonction cree_liste:\n");
printf("Cas 1 : tache classique\n");
tache = cree_tache("gf",30);
list1 = cree_liste(tache);
affiche_liste(list1);
printf("Cas 2 : Tache vide\n");
list1 = cree_liste(NULL);
affiche_liste(list1);
printf("Cas 3 : valeur aberrante pour la tache\n");
list1 = cree_liste("ab");
affiche_liste(list1);
break;
/* Fonction affiche_liste. */
case 3 :
printf("Test fonction affiche_liste:\n");
printf("Cas 1 : valeurs courantes\n");
tache = cree_tache("ab",10);
list1 = cree_liste(tache);
affiche_liste(list1);
printf("Cas 2 : liste avec une tache null\n");
tache = NULL;
list1 = creer_liste(tache);
affiche_liste(list1);
printf("Cas 3 : liste null\n");
list1 = NULL;
affiche_liste(list1);
break;
/* Fonction ajoute_tache. */
case 4 :
printf("Test fonction ajoute_tache:\n");
printf("Cas 1 : ajout classique d'une tache a une liste\n");
tache = cree_tache("ab",10);
list1 = cree_liste(tache);
tache = cree_tache("cd",20);
result = ajoute_tache(list1, tache);
printf("resultat : %d \n",result);
printf("Cas 2 : liste null \n");
result = ajoute_tache(NULL,tache);
printf("resultat : %d \n",result);
printf("Cas 3 : tache null \n");
result = ajoute_tache(list1,NULL);
printf("resultat : %d \n",result);
printf("cas 4 : valeur aberrante pour la tache\n");
result = ajoute_tache(list1,"cd");
printf("resultat : %d \n",result);
break;
/* Fonction annule_tache. */
case 5 :
printf("Test fonction annule_tache:\n");
printf("Cas 1 : valeurs courantes\n");
list1 = cree_liste(cree_tache("aa",2));
list1 = ajoute_tache(list1, cree_tache("bb",5));
list1 = annule_tache(list1, "bb");
affiche_liste(list1);
printf("Cas 2 : tache non comprise dans la liste\n");
list1 = cree_liste(cree_tache("aa",2));
list1 = ajoute_tache(list1, cree_tache("bb",5));
list1 = annule_tache(list1, "ff");
affiche_liste(list1);
printf("Cas 3 : liste NULL\n");
list1 = NULL;
list1 = annule_tache(list1, "ff");
affiche_liste(list1);
break;
/* Fonction execute_tache_FIFO. */
case 6 :
printf("Test fonction execute_tache_FIFO:\n");
printf("Cas 1 : normal \n");
list1 = cree_liste(cree_tache("aa" 10));
list1 = ajoute_tache(list1, cree_tache("bb", 2));
list1 = ajoute_tache(list1, cree_tache("cc", 65));
list1 = execute_tache_FIFO(list1);
affiche_liste(list1);
printf("Cas 2 : La liste est vide\n");
list1 = NULL;
list1 = execute_tache_FIFO(NULL);
affiche_liste(list1);
break;
/* Fonction depile_tache. */
case 7 :
printf("Test fonction depil_tache:\n");
printf("Cas 1 : liste non vide\n");
list1 = cree_liste(cree_tache("aa" 10));
list1 = ajoute_tache(list1, cree_tache("bb", 2));
list1 = depile_tache(list1);
affiche_liste(list1);
printf("Cas 1 bis : liste à une tache\n");
list1 = cree_liste(cree_tache("aa" 10));
list1 = depile_tache(list1);
affiche_liste(list1);
printf("Cas 2 : liste vide\n");
list1 = cree_liste(NULL);
list1 = depile_tache(list1);
affiche_liste(list1);
break;
/* Fonction execute_tache_LIFO. */
case 8 :
printf("Test fonction execute_tache_LIFO:\n");
printf("Cas 1 : normal \n");
list1 = cree_liste(cree_tache("aa" 10));
list1 = ajoute_tache(list1, cree_tache("bb", 2));
list1 = ajoute_tache(list1, cree_tache("cc", 65));
list1 = execute_tache_LIFO(list1);
affiche_liste(list1);
printf("Cas 2 : La liste est vide\n");
list1 = NULL;
list1 = execute_tache_LIFO(NULL);
affiche_liste(list1);
break;
/* Fonction load_data. */
case 9 :
printf("Test fonction load_data:\n");
printf("Cas 1 : nom de fichier correct\n");
list1 = load_data("tasks.dat");
affiche_liste(list1);
printf("Cas 2 : nom de fichier sans extension\n");
list1 = load_data("tasks");
affiche_liste(list1);
printf("Cas 3 : Fichier null \n");
list1 = load_data(NULL);
affiche_liste(list1);
printf("Cas 4 : valeur aberrante du nom de fichier\n"
"la fonction s'interrompt lors de son exécution.\n");
break;
/* Fonction load_data2. */
case 10 :
printf("Test fonction load_data2:\n");
printf("Cas 1 : nom de fichier correct\n");
list1 = load_data2("tasks.dat");
affiche_liste(list1);
printf("Cas 2 : nom de fichier sans extension\n");
list1 = load_data2("tasks");
affiche_liste(list1);
printf("Cas 3 : Fichier null \n");
list1 = load_data2(NULL);
affiche_liste(list1);
printf("Cas 4 : valeur aberrante du nom de fichier\n"
"la fonction s'interrompt lors de son exécution.\n");
break;
/* Fonction insere_tache. */
case 11 :
printf("Test fonction insere_tache:\n");
printf("Cas 1 : liste et tache classique\n");
tache = cree_tache("de",30);
list1 = cree_tache("ab", 10);
list1 = cree_liste(list1);
list1 = insere_tache(list1, tache);
tache = cree_tache("ab", 50);
list1 = insere_tache(list_tache, t2);
affiche_list1(list1);
printf("Cas 2 : liste vide\n"
"Arret de la fonction.\n");
printf("Cas 2 bis : tache vide\n"
"Arret de la fonction.\n");
printf("Cas 3 : valeur aberrante\n"
"Arret de la fonction.\n");
break;
/* Fonction insere_tache_priorite. */
case 12 :
printf("Test fonction insere_tache_priorite:\n");
printf("Cas 1 : valeurs courantes\n");
list1 = cree_liste(cree_tache("yy", 18));
list1 = insere_tache_priorite(list1, cree_tache("xx", 7));
list1 = insere_tache_priorite(list1, cree_tache("rr", 1));
affiche_liste(list1);
printf("Cas 2 : liste null\n");
list1 = NULL;
list1 = insere_tache_priorite(list1, cree_tache("vv", 76));
affiche_liste(list1);
printf("Cas 2 bis : tache null\n");
list1 = cree_liste(cree_tache("gg", 8));
list1 = insere_tache_priorite(list1, NULL);
affiche_liste(list1);
printf("Cas 3 : liste null et tache null\n");
list1 = NULL;
list1 = insere_tache_priorite(list1, NULL);
affiche_liste(list1);
break;
/* Fonction fusion_listes. */
case 13 :
printf("Test fonction fusion_listes:\n");
printf("Cas 1 : 2 listes classiques\n");
tache = cree_tache("ab", 10);
list1 = cree_liste(tache);
list1 = insere_tache(list1, cree_tache("aa", 4));
list1 = insere_tache(list1, cree_tache("zz", 1));
printf("\nListe 1 :\n");
affiche_liste(list1);
tache = cree_tache("ee", 7);
list2 = cree_liste(tache);
list2 = insere_tache(list2, cree_tache("rr", 25));
list2 = insere_tache(list2, cree_tache("tt", 8));
printf("\nListe 2 :\n");
affiche_liste(l2);
list1 = fusion_listes(list1, list2);
printf("\nListe fusionnée:\n");
affiche_liste(list1);
printf("Cas 2 : l'un des 2 liste est vide\n");
list1 = cree_liste(cree_tache("yy", 18));
list1 = insere_tache(list1, cree_tache("uu", 6));
list1 = insere_tache(list1, cree_tache("ii", 12));
affiche_liste(list1);
list1 = fusion_listes(NULL,list1);
affiche_liste(list1);
printf("Cas 3 : deux listes vides\n");
list1 = fusion_listes(NULL,NULL);
affiche_liste(list1);
break;
/* Fonction MAJ_priorite. */
case 14 :
printf("Test fonction MAJ_priorite:\n");
printf("Cas 1 : liste non vide\n");
list1 = cree_liste(cree_tache("yy", 18));
list1 = insere_tache(list1, cree_tache("uu", 6));
list1 = insere_tache(list1, cree_tache("ii", 12));
result = MAJ_priorite(list1);
printf("Resultat : %d\n", result);
printf("Cas 2 : liste vide\n");
list1 = NULL;
result = MAJ_priorite(list1);
printf("Resultat : %d\n", result);
break;
}
} while (choix != 0);
return 0;
}
int main(int argc, char ** argv){
struct timeval start, end;
Liste * fichiers = fichiers_reguliers(SHAKESPEARE_DIR);
Liste * mots;
char * fichier;
TrieHybride * t = NULL;
int i,fd,fd2,arg_fusion,res;
double res_d;
char buff[128];
pthread_t tid[NB_THREADS];
pthread_attr_t attr;
briandais_t * br;
/****************************************************************************
BENCHMARK INSERTION NON MULTITHREADE
****************************************************************************/
printf("Insertion de toutes les pieces de Shakespeare \t\t: En cours ...");
fflush(stdout);
temps(&start);
while((fichier=supprimer_debut(fichiers))){
t=lire_fichier_th(fichier,t);
free(fichier);
}
temps(&end);
afficher_res(start,end);
destroy_liste(fichiers);
/****************************************************************************
SUPPRESSION MOTS HAMLET
****************************************************************************/
printf("Suppression des mots de la piece \"Hamlet\" \t\t: En cours ...");
fflush(stdout);
fd=ouvrir_fichier(SHAKESPEARE_DIR"hamlet.txt");
if(fd<0){
perror("ouverture fichier");
exit(EXIT_FAILURE);
}
temps(&start);
while(mot_suivant(fd,buff)>0){
t=supprimer(t,buff);
}
temps(&end);
afficher_res(start,end);
if(close(fd)==-1){
perror("close");
exit(EXIT_FAILURE);
}
/****************************************************************************
RECHERCHE ALL'S WELL & HAMLET
****************************************************************************/
printf("Recherche des mots de All's Well et Hamlet \t\t: En cours ...");
fflush(stdout);
fd=ouvrir_fichier(SHAKESPEARE_DIR"hamlet.txt");
if(fd<0){
perror("ouverture fichier");
exit(EXIT_FAILURE);
}
fd2=ouvrir_fichier(SHAKESPEARE_DIR"allswell.txt");
if(fd2<0){
perror("ouverture fichier");
exit(EXIT_FAILURE);
}
temps(&start);
while(mot_suivant(fd,buff)>0){
recherche_trie_hybride(t,buff);
}
while(mot_suivant(fd2,buff)>0){
recherche_trie_hybride(t,buff);
}
temps(&end);
afficher_res(start,end);
if(close(fd)==-1){
perror("close");
exit(EXIT_FAILURE);
}
if(close(fd2)==-1){
perror("close");
exit(EXIT_FAILURE);
}
/****************************************************************************
DESTRUCTION TRIE HYBRIDE
****************************************************************************/
printf("Destruction du trie hybride \t\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
free_trie_hybride(t);
temps(&end);
afficher_res(start,end);
/****************************************************************************
CREATION SHAKESPEARE MULTITHREADE
****************************************************************************/
fics=fichiers_reguliers(SHAKESPEARE_DIR);
tries=creer_liste();
sem_init(&sem,1,0);
arg_fusion=fics->taille;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
printf("Insertion multithreade des oeuvres de Shakespeare\t: En cours ...");
fflush(stdout);
temps(&start);
pthread_mutex_lock(&mutex_fics);
for(i=0;i<NB_THREADS-1;i++){
if(pthread_create(&(tid[i]),&attr,creation_trie_thread,NULL)==-1){
perror("pthread_create");
exit(EXIT_FAILURE);
}
}
if(pthread_create(&(tid[NB_THREADS-1]),&attr,fusion_thread,&arg_fusion)==-1){
perror("pthread_create");
exit(EXIT_FAILURE);
}
pthread_cond_wait(&cond,&mutex_fics);
temps(&end);
afficher_res(start,end);
destroy_liste(fics);
t=supprimer_debut(tries);
destroy_liste(tries);
/****************************************************************************
COMPTAGE MOTS
****************************************************************************/
printf("Comptage des mots \t\t\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
res=comptage_mots(t);
temps(&end);
afficher_res(start,end);
printf("\t\t\t\t\t\t\t %d\n",res);
/****************************************************************************
POINTEURS VERS NULL
****************************************************************************/
printf("Comptage des pointeurs vers NULL\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
res=comptage_nil(t);
temps(&end);
afficher_res(start,end);
printf("\t\t\t\t\t\t\t %d\n",res);
/****************************************************************************
CREATION ET DESTRUCTION DE LA LISTE DES MOTS
****************************************************************************/
printf("Creation et destruction de la liste des mots\t\t: En cours ...");
fflush(stdout);
temps(&start);
mots=liste_mots(t);
while(mots->taille!=0){
char * tmp=supprimer_debut(mots);
free(tmp);
}
free(mots);
temps(&end);
afficher_res(start,end);
/****************************************************************************
HAUTEUR
****************************************************************************/
printf("Calcul de la hauteur \t\t\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
res=hauteur(t);
temps(&end);
afficher_res(start,end);
printf("\t\t\t\t\t\t\t %d\n",res);
/****************************************************************************
EQUILIBRAGE
****************************************************************************/
printf("Equilibrage du trie\t\t\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
t=equilibrer(t);
temps(&end);
afficher_res(start,end);
/****************************************************************************
RECALCUL HAUTEUR
****************************************************************************/
printf("Recalcul de la hauteur \t\t\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
res=hauteur(t);
temps(&end);
afficher_res(start,end);
printf("\t\t\t\t\t\t\t %d\n",res);
/****************************************************************************
PROFONDEUR MOYENNE
****************************************************************************/
printf("Profondeur Moyenne\t\t\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
res_d=profondeur_moyenne(t);
temps(&end);
afficher_res(start,end);
printf("\t\t\t\t\t\t\t %f\n",res_d);
/****************************************************************************
CONVERSION VERS BRIANDAIS
****************************************************************************/
printf("Conversion vers arbre de la briandais\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
br=conversion(t);
temps(&end);
afficher_res(start,end);
destroy_briandais(&br);
/****************************************************************************
INSERTION D'UN MOT INEXISTANT
****************************************************************************/
printf("Insertion d'un mot inexistant(anticonstitutionnellement): En cours ...");
fflush(stdout);
temps(&start);
t=ajouter_trie_hybride("anticonstitutionnellement",t);
temps(&end);
afficher_res(start,end);
/****************************************************************************
INSERTION D'UN MOT INEXISTANT
****************************************************************************/
printf("Usage memoire (en octets)\t\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
res=usage_memoire(t);
temps(&end);
afficher_res(start,end);
printf("\t\t\t\t\t\t\t %d\n",res);
free_trie_hybride(t);
return EXIT_SUCCESS;
}
