ajout de commentaire dans le texte

Thorsieger
1 parent e1737bb6
Showing 2 changed files with 143 additions and 119 deletions Show diff stats
main.c
tree.c
@@ -59,6 +59,7 @@ char recommencer = &#39; &#39;;
   wprintf(L"Le fichier testé contient %d mots qui ne sont pas présent dans le dictionnaire.\n",result);
   fclose(fp);
  
+  //Demande si volonté de recommencer
   wprintf(L"Voulez vous tester un autre fichier ?[Y]\n");
   wscanf(L" %c",&recommencer);
   }while(recommencer == 'Y' || recommencer == 'y');
 #include "tree.h"
  
-void cons_tree(struct node ** ptr_tree, wchar_t val)
+//Contruction d'un arbre
+void cons_tree(struct node **ptr_tree, wchar_t val)
 {
   *ptr_tree = malloc(sizeof(struct node));
   (*ptr_tree)->val = val;
   (*ptr_tree)->fin = 0;
-  (*ptr_tree)->nbr_fils=0;
-  (*ptr_tree)->fils = malloc(sizeof(struct node*));
-  (*ptr_tree)->fils[0]=NULL;
+  (*ptr_tree)->nbr_fils = 0;
+  (*ptr_tree)->fils = malloc(sizeof(struct node *)); //Tableau de taille 1 de pointeur de noeud
+  (*ptr_tree)->fils[0] = NULL;                       //Cette node n'a pas de fils
 }
  
+//Initialiation de chaque element du dictionnaire à nul
 void mk_empty_tree(dico *Dico)
 {
-  for(int i = 0; i < Dico->taille; i++)
+  for (int i = 0; i < Dico->taille; i++)
   {
-    Dico->tab_ptr_tree[i] = NULL;
+    Dico->tab_ptr_tree[i] = NULL; //Chaque element du dico est vide
   }
 }
  
+//Création d'un dictionnaire pour enregister les 26 lettres de l'alphabet
 void init_dico(dico *Dico)
 {
   Dico->taille = 26;
-  Dico->tab_ptr_tree = malloc(Dico->taille*sizeof(struct node*));
+  Dico->tab_ptr_tree = malloc(Dico->taille * sizeof(struct node *));
   mk_empty_tree(Dico);
 }
  
-void add(struct node **tab_ptr_tree, wchar_t val[],int taille, int fl)
+//ajout d'un mot dans le dictionnaire dans son arbre (liée à la première lettre du mot)
+void add(struct node **tab_ptr_tree, wchar_t val[], int taille, int fl)
 {
-  if(tab_ptr_tree[fl]==NULL)cons_tree(&(tab_ptr_tree[fl]),val[0]+97);
-  Node* noeudtest = tab_ptr_tree[fl];
-  for(int i = 1;i<taille;i++)
+  if (tab_ptr_tree[fl] == NULL)cons_tree(&(tab_ptr_tree[fl]), val[0] + 97); //si l'arbre n'existe pas on le crée
+
+  Node *noeudtest = tab_ptr_tree[fl];
+  for (int i = 1; i < taille; i++)//on va travailler sur toutes les lettres du mot
+  {
+    int trouve = -1;
+    for (int j = 0; j < noeudtest->nbr_fils; j++)//On recherche si la lettre existe déja
+    {
+      if (noeudtest->fils[j]->val == val[i])trouve = j;
+    }
+    if (trouve == -1)
     {
-      int trouve = -1;
-      for(int j=0;j<noeudtest->nbr_fils;j++)
-	{
-	  if(noeudtest->fils[j]->val==val[i])trouve=j;
-	}
-      if(trouve==-1)
-	{	  
-	  //ajouter lettre
-	   noeudtest->nbr_fils++;
-	   noeudtest->fils = realloc(noeudtest->fils,(noeudtest->nbr_fils)*sizeof(struct node*));
-	   cons_tree(&(noeudtest->fils[(noeudtest->nbr_fils)-1]),val[i]);
-	   trouve = noeudtest->nbr_fils-1;
-	}
-      
-      noeudtest = noeudtest->fils[trouve];//on jump au noeud suivant
+      //ajouter lettre
+      noeudtest->nbr_fils++;
+      noeudtest->fils = realloc(noeudtest->fils, (noeudtest->nbr_fils) * sizeof(struct node *));//On ajoute de la place dans le tableau de fils pour y mettre celui ci
+      cons_tree(&(noeudtest->fils[(noeudtest->nbr_fils) - 1]), val[i]);
+      trouve = noeudtest->nbr_fils - 1;
     }
-  noeudtest->fin = 1;
  
+    noeudtest = noeudtest->fils[trouve]; //on jump au noeud suivant (lettre existante ou venant d'étre créé)
+  }
+  noeudtest->fin = 1;//On a terminé le mot, cette lettre est la dernière du mot
 }
  
+//Calcul de la taille de la chaine de caractère donnée en paramètre
 int size(wchar_t val[])
 {
   int cpt = 0;
-  while(val!= NULL && val[cpt]!='\0')
-    {
-      cpt++;
-    }
+  while (val != NULL && val[cpt] != '\0')
+  {
+    cpt++;
+  }
   return cpt;
 }
  
+//Tous les caractères en majuscules sont mis en minuscule (même ceux avec accent)
 void toLowerCase(wchar_t mot[])
 {
-  for(int i=0;i<size(mot);i++)
-    {
-      if((mot[i]<='Z' && mot[i]>='A') || (mot[i]>=192 && mot[i]<=214) || (mot[i]>=216 && mot[i]<=222))mot[i]+=32;
-      else if(mot[i]==138|| mot[i]==140 || mot[i]==142) mot[i]+=16;
-      else if(mot[i]==159) mot[i]+=96;
-    }
+  for (int i = 0; i < size(mot); i++)
+  {
+    if ((mot[i] <= 'Z' && mot[i] >= 'A') || (mot[i] >= 192 && mot[i] <= 214) || (mot[i] >= 216 && mot[i] <= 222))mot[i] += 32;
+    else if (mot[i] == 138 || mot[i] == 140 || mot[i] == 142)mot[i] += 16;
+    else if (mot[i] == 159)mot[i] += 96;
+  }
 }
  
-void splitcarac(dico *Dico,wchar_t message[],wchar_t separateur[])
+//Récupération de la première lettre du mot et découpade de celui ci en fonction des séparateurs
+void splitcarac(dico *Dico, wchar_t message[], wchar_t separateur[])
 {
-  int first_letter =-1;
-  if(message[0]>='a' && message[0]<='z')
+
+  //On récupére l'id de la première lettre dans notre dico
+  int first_letter = -1;
+  if (message[0] >= 'a' && message[0] <= 'z')
   {
-    first_letter = (int)message[0]-97;
+    first_letter = (int)message[0] - 97;
   }
   else
   {
-    for(int i = 26; i < Dico->taille; i++)
+    for (int i = 26; i < Dico->taille; i++)//On recherche si elle existe et qu'elle n'est pas de 'a' à 'z'
     {
-      if(Dico->tab_ptr_tree[i]->val == message[0]){first_letter = i;break;}
+      if (Dico->tab_ptr_tree[i]->val == message[0])
+      {
+        first_letter = i;
+        break;
+      }
     }
-    if(first_letter == -1)
+    if (first_letter == -1)//Elle n'exite pas, on l'ajoute
     {
       first_letter = Dico->taille;
       Dico->taille++;
-      Dico->tab_ptr_tree = realloc(Dico->tab_ptr_tree,(Dico->taille)*sizeof(struct node*));
+      Dico->tab_ptr_tree = realloc(Dico->tab_ptr_tree, (Dico->taille) * sizeof(struct node *));//On laisse la place pour ajouter une première lettre de mot
       Dico->tab_ptr_tree[first_letter] = NULL;
-      cons_tree(&(Dico->tab_ptr_tree[first_letter]),message[0]);
+      cons_tree(&(Dico->tab_ptr_tree[first_letter]), message[0]);
     }
   }
-  
+
   wchar_t *buffer;
-  wchar_t *token = wcstok(message, separateur, &buffer);
-  add(Dico->tab_ptr_tree,token,size(token),first_letter);
-  if(buffer!=NULL)splitcarac(Dico,buffer,separateur);
+  wchar_t *token = wcstok(message, separateur, &buffer);//On découpe le mot selon les séparateurs
+  add(Dico->tab_ptr_tree, token, size(token), first_letter);//On ajoute le mot (jusqu'au séparateur) au dictionnaire
+  if (buffer != NULL)splitcarac(Dico, buffer, separateur);//S'il reste des mots à ajouter on recommence
 }
  
+//Chargement du dictionnaire
 void load_dico(FILE *fp, dico *Dico, wchar_t separateur[])
 {
-  wchar_t val[3000];
-  
-  while(fwscanf(fp, L"%ls",val)==1)
-    {
-      toLowerCase(val);
-      splitcarac(Dico,val,separateur);
-    }
+  wchar_t val[3000];//Nombre de caractère max sur une page
+
+  while (fwscanf(fp, L"%ls", val) == 1)
+  {
+    toLowerCase(val);//Les caractères sont mis en miniscule
+    splitcarac(Dico, val, separateur);//On ajoute tous les mots au dictionnaire
+  }
  
-    //On peut tester la bonne ou mauvaise terminaison de la lecture
-    if(feof(fp))    printf("Fin normal de lecture\n");
-    if(ferror(fp))  printf("ERREUR de lecture\n");
+  //On peut tester la bonne ou mauvaise terminaison de la lecture
+  if (ferror(fp))wprintf(L"ERREUR de lecture\n");
 }
  
+//On libère toute la mémoire de chaque arbre
 void free_tree(struct node *ptr_tree)
 {
-  if(ptr_tree==NULL)return;
-  if(ptr_tree->nbr_fils==0){free(ptr_tree->fils);return;}
-  for(int i=(ptr_tree->nbr_fils)-1;i>=0;i--)
+  if (ptr_tree == NULL)return;//On a terminé
+  if (ptr_tree->nbr_fils == 0)//Le noeud n'a pas de fils on peut libérer la mémoire
+  {
+    free(ptr_tree->fils);
+    return;
+  }
+  for (int i = (ptr_tree->nbr_fils) - 1; i >= 0; i--)//si le noeud à des fils ré-exécute la fontion
   {
     free_tree(ptr_tree->fils[i]);
     free(ptr_tree->fils[i]);
@@ -127,11 +145,12 @@ void free_tree(struct node *ptr_tree)
   free(ptr_tree->fils);
 }
  
+//On libére la mémoire du dictionnaire
 void free_dico(dico Dico)
 {
-  for(int i=0;i<Dico.taille;i++)
+  for (int i = 0; i < Dico.taille; i++)//On libére chaque arbre
   {
-    if(Dico.tab_ptr_tree[i]!=NULL)
+    if (Dico.tab_ptr_tree[i] != NULL)
     {
       free_tree(Dico.tab_ptr_tree[i]);
       free(Dico.tab_ptr_tree[i]);
@@ -140,80 +159,84 @@ void free_dico(dico Dico)
   free(Dico.tab_ptr_tree);
 }
  
-/*Recherche dans le dictionnaire*/
-int find_mot(dico Dico,wchar_t mot[])
+//Recherche dans le dictionnaire d'un mot
+int find_mot(dico Dico, wchar_t mot[])
 {
-    if (mot==NULL) {
-      return 0;
-    }
-    if(mot[0]>='0' && mot[0]<='9')return 0;
+  if (mot == NULL)return 0;
+  if (mot[0] >= '0' && mot[0] <= '9')return 0;
  
-    int fl =-1;
-    if(mot[0]>='a' && mot[0]<='z')
-    {
-      fl = (int)mot[0]-97;
-    }
-    else
+  int fl = -1;
+  if (mot[0] >= 'a' && mot[0] <= 'z')
+  {
+    fl = (int)mot[0] - 97;
+  }
+  else
+  {
+    for (int i = 26; i < Dico.taille; i++)
     {
-      for(int i = 26; i < Dico.taille; i++)
+      if (Dico.tab_ptr_tree[i]->val == mot[0])
       {
-        if(Dico.tab_ptr_tree[i]->val == mot[0]){fl = i;break;}
+        fl = i;
+        break;
       }
-      if(fl == -1)return 1;
     }
+    if (fl == -1)return 1;
+  }
  
-    int taille = size(mot);
-    if(taille==1 && Dico.tab_ptr_tree[fl]!=NULL)
-    {
-        if(Dico.tab_ptr_tree[fl]->fin==0)return 1;
-        else return 0;//vrais
-    }
-    if(taille==1 && Dico.tab_ptr_tree[fl]==NULL)return 1;//faux
+  int taille = size(mot);
+  if (taille == 1 && Dico.tab_ptr_tree[fl] != NULL)
+  {
+    if (Dico.tab_ptr_tree[fl]->fin == 0)return 1;
+    else return 0; //vrais
+  }
+  if (taille == 1 && Dico.tab_ptr_tree[fl] == NULL)return 1; //faux
  
-    struct node *ptr_node = Dico.tab_ptr_tree[fl];
-    for(int i=1;i<taille;i++)
+  struct node *ptr_node = Dico.tab_ptr_tree[fl];
+  for (int i = 1; i < taille; i++)
+  {
+    if (ptr_node->nbr_fils == 0)return 1;
+    for (int k = 0; k < (ptr_node->nbr_fils); k++)
     {
-        if(ptr_node->nbr_fils==0)return 1;
-        for(int k=0;k<(ptr_node->nbr_fils);k++)
-        {
-            if(ptr_node->fils[k]->val==mot[i])
-            {
-                ptr_node=ptr_node->fils[k];
-                break;
-            }
-	    else if(k+1==ptr_node->nbr_fils)return 1;
-        }
+      if (ptr_node->fils[k]->val == mot[i])
+      {
+        ptr_node = ptr_node->fils[k];
+        break;
+      }
+      else if (k + 1 == ptr_node->nbr_fils)
+        return 1;
     }
+  }
  
-    if(ptr_node->fin==0)return 1;
-    else return 0;
+  if (ptr_node->fin == 0)return 1;
+  else return 0;
 }
  
-int find_erreur(dico Dico, FILE *fp,wchar_t separateur[])
+//Test de présence de chaque mot du fichier de l'utilisateur
+int find_erreur(dico Dico, FILE *fp, wchar_t separateur[])
 {
   wchar_t val[3000];
-  int cpt_erreur =0;
-  
-  while(fwscanf(fp, L"%ls",val)==1)
-    {
-      toLowerCase(val);
-      cpt_erreur += split_text(Dico,val,separateur);
-    }
+  int cpt_erreur = 0;
  
-    //On peut tester la bonne ou mauvaise terminaison de la lecture
-    if(feof(fp))    printf("Fin normal de lecture\n");
-    if(ferror(fp))  printf("ERREUR de lecture\n");
+  while (fwscanf(fp, L"%ls", val) == 1)
+  {
+    toLowerCase(val);//Fichier mit en minuscule
+    cpt_erreur += split_text(Dico, val, separateur);//découpage et analyse du texte selon les séparateur
+  }
  
-    return cpt_erreur;
+  //On peut tester la bonne ou mauvaise terminaison de la lecture
+  if (ferror(fp))wprintf(L"ERREUR de lecture\n");
+
+  return cpt_erreur;
 }
  
-int split_text(dico Dico,wchar_t message[], wchar_t separateur[])
-{  
-  if(message[0] == 0)return 0;
+//Découpage et analyse du texte selon les séparateur
+int split_text(dico Dico, wchar_t message[], wchar_t separateur[])
+{
+  if (message[0] == 0)return 0;
   wchar_t *buffer;
-  wchar_t *token = wcstok(message, separateur, &buffer);
-  int err = find_mot(Dico,token);
-  if(buffer!=NULL)err += split_text(Dico,buffer,separateur);
+  wchar_t *token = wcstok(message, separateur, &buffer);//Découpage selon les caractère de séparation
+  int err = find_mot(Dico, token);//recherche de la présence du mot dans le dictionnaire
+  if (buffer != NULL)err += split_text(Dico, buffer, separateur);
  
   return err;
 }