commentaires

run.c

 #include "run.h"
 #define uint_64 unsigned long long
 
-void put_in_buffer_1(char *c, struct buffer_rc *ptr){ //ajouter un element dans le buffer 1
+//Toutes les spécifications des fonctions sont mises avant le début de la fonction
 
-    ptr->tab[ptr->head] = malloc(sizeof(char)*(strlen(c) + 1)); // on stoxke de espace
+//------------------------------------------------------------------------------------------
+
+
+/*Ajout d'un element dans le buffer 1*/
+void put_in_buffer_1(char *c, struct buffer_rc *ptr){
+
+    ptr->tab[ptr->head] = malloc(sizeof(char)*(strlen(c) + 1));
     if(ptr->tab[ptr->head] ==NULL){return;}
-    strcpy(ptr->tab[ptr->head],c); //copie
+    strcpy(ptr->tab[ptr->head],c);
 
     ptr->len++;
-    ptr->head = (ptr->head + 1)%ptr->size; //chaque fois qu'un élément est ajouté,
-    //on augmente le pointeur de 1 mais l'espace du buffer est de size donc faire un modulo
+    ptr->head = (ptr->head + 1)%ptr->size;
+    /*chaque fois qu'un élément est ajouté,
+    on augmente le pointeur de 1
+    mais l'espace du buffer est
+    d'une certaine taillle
+    donc faire un modulo*/
 
 }
 
-char *get_from_buffer_1(struct buffer_rc *ptr){ // chercher dans le buffer 1
+
+/*Recherche dans le buffer 1*/
+char *get_from_buffer_1(struct buffer_rc *ptr){
     char *result;
-    result = ptr->tab[ptr->tail]; // donne un valeur a result
+    result = ptr->tab[ptr->tail];
     ptr->tab[ptr->tail] = NULL;
     ptr->len--; //diminue l'espace occupé dans le buffer
     ptr->tail = (ptr->tail + 1)%ptr->size;
@@ -23,33 +35,39 @@ char *get_from_buffer_1(struct buffer_rc *ptr){ // chercher dans le buffer 1
     return result;
 }
 
-void put_in_buffer_2(struct queue *ptr, struct buffer_cw *buf){ //ajouter un element dans le buffer 2
+
+/*Recherche d'un element dans le buffer 2*/
+void put_in_buffer_2(struct queue *ptr, struct buffer_cw *buf){
     buf->tab[buf->head] = ptr;
-    buf->len++; //augmente l'espace occupé dans le buffer
+    buf->len++;        //augmente l'espace occupé dans le buffer
     buf->head = (buf->head + 1)%buf->size;
 }
 
-queue_t *get_from_buffer_2(struct buffer_cw *buf){ // trouver un element
+
+/*Recherche d'un element dans le buffer 2*/
+queue_t *get_from_buffer_2(struct buffer_cw *buf){
 
     struct queue *result;
-    result = buf->tab[buf->tail]; //donne une valeur a result
+    result = buf->tab[buf->tail];
     buf->tab[buf->tail] = NULL;
-    buf->len--; //diminue l'espace occupé par le buffer
+    buf->len--;  //diminue l'espace occupé par le buffer
     buf->tail = (buf->tail + 1)%buf->size;
 
     return result;
 }
 
-
-int is_div(uint_64 number, uint_64 i) { // Vérifie si i est un diviseur de number.
+/* Vérifie si i est un diviseur de number */
+int is_div(uint_64 number, uint_64 i) {
     if (i == 0){return 0;}
 
-    return (number % i == 0) ; // renvoie 0 si le nombre n'est pas divisible par i et 1 si il est divisible
+    return (number % i == 0) ;
+    /*renvoie 0
+    si le nombre n'est pas divisible par i
+    et 1 si il est divisible*/
 }
 
-/*
-exponentiation modulaire : calcul plus rapidement des grandes puissances entières
-*/
+
+/* exponentiation modulaire : calcul plus rapidement des grandes puissances entières*/
 uint_64 modpow (uint_64 base, uint_64 exp, uint_64 mod){
 
     uint_64 result = 1;
@@ -65,11 +83,15 @@ uint_64 modpow (uint_64 base, uint_64 exp, uint_64 mod){
     return result;
 }
 
+
+/* Donne des nombres aléatoire avec
+k les nombres et N la borne supérieur*/
 uint_64* randomiser (int k, uint_64 N){
 
     uint_64 *result;
     result = malloc(sizeof(uint_64)*k);
-    srand(time(NULL));
+    srand(time(NULL)); // initialisation du générateur de
+                       // nombre aléatoire par la fonction time
     for (int i = 0; i < k; i++)
     {
         result[i] = rand() % (N-1) +1;
@@ -78,9 +100,8 @@ uint_64* randomiser (int k, uint_64 N){
 
 }
 
-/*
-Vérifie si number est premier
-*/
+
+/*Vérifie si number est premier */
 int is_prime (uint_64 number){
 
     uint_64 *random;