Replace fonctions.c

Code_With_Threads/fonctions.c

@@ -23,7 +23,7 @@ Initialise une liste de node contenant une liste
 void init_list_lst(list_lst *my_list) {
     my_list->first = NULL;
     my_list->last = NULL;
-    my_list->last = 0;
+    my_list->length = 0;
 }
 
 /*
@@ -39,7 +39,6 @@ void put_node_t(list_t *my_list, int value) {
         my_list->last = new;
     } else {
         my_list->last->next = new;
-        new->next = my_list->first;
         my_list->last = new;
     }
     my_list->length += 1;
@@ -49,8 +48,10 @@ void put_node_t(list_t *my_list, int value) {
 Ajoute un node contenant une liste à la fin d'une liste
 */
 void put_node_lst(list_lst *my_list, list_t *put_list) {
+//    if (!put_list);
     node_lst *new = malloc(sizeof(node_lst));
     if (!new) return;
+//    new->diviseurs = malloc(sizeof(list_t));
     new->next = NULL;
     new->diviseurs = put_list;
     if (my_list->length == 0) {
@@ -58,7 +59,6 @@ void put_node_lst(list_lst *my_list, list_t *put_list) {
         my_list->last = new;
     } else {
         my_list->last->next = new;
-        new->next = my_list->first;
         my_list->last = new;
     }
     my_list->length += 1;
@@ -68,44 +68,40 @@ void put_node_lst(list_lst *my_list, list_t *put_list) {
 Retire le premier node d'une liste et renvoit son entier
 */
 int get_node_t(list_t *my_list) {
-//    if (my_list->length == 0) return -1;
+    if (my_list->length == 0) return -1;
     int value = my_list->first->value;
     if (my_list->length == 1) {
         free(my_list->first);
         my_list->first = NULL;
         my_list->last = NULL;
         my_list->length = 0;
-        return value;
     } else {
-        node_t *temp = my_list->first;
-        my_list->last->next = temp->next;
-        my_list->first = temp->next;
-        free(temp);
+        node_t *temp = my_list->first->next;
+        free(my_list->first);
+        my_list->first = temp;
         my_list->length -= 1;
-        return value;
     }
+    return value;
 }
 
 /*
 Retire le premier node d'une liste et renvoit sa liste
 */
 list_t *get_node_lst(list_lst *my_list) {
-//    if (my_list->length == 0) return NULL;
+    if (my_list->length == 0) return NULL;
     list_t *get_list = my_list->first->diviseurs;
     if (my_list->length == 1) {
-        free(my_list->last);
+        free(my_list->first);
         my_list->first = NULL;
         my_list->last = NULL;
         my_list->length = 0;
-        return get_list;
     } else {
-        node_lst *temp = my_list->first;
-        my_list->last->next = temp->next;
-        my_list->first = temp->next;
-        free(temp);
+        node_lst *temp = my_list->first->next;
+        free(my_list->first);
+        my_list->first = temp;
         my_list->length -= 1;
-        return get_list;
     }
+    return get_list;
 }
 
 /*
@@ -120,9 +116,77 @@ int get_at_index(list_t *my_list, int index) {
     return temp->value;
 }
 
+/*
+void clear_node_t(node_t *t) {
+    free(t->next);
+    t->next = NULL;
+    t->value = 0;
+    t = NULL;
+}
+
+void clear_list_t(list_t *my_list) {
+    clear_node_t(my_list->last);
+    node_t *clearer = my_list->first;
+    while (clearer != NULL) {
+        my_list->first = my_list->first->next;
+        clear_node_t(clearer);
+        clearer = my_list->first;
+    }
+    my_list->length = 0;
+}
+
+void clear_node_lst(node_lst *n) {
+    list_t *clearer = n->diviseurs;
+    while(clearer != NULL) {
+        n = n->next;
+        clear_list_t(clearer);
+        clearer = n->diviseurs
+    }
+}
+
+void clear_list_lst(list_lst *my_list) {
+    node_lst *temp;
+    node_lst *pelem = my_list->first;
+    while (pelem) {
+        temp = pelem;
+        pelem = pelem->next;
+        free(temp);
+    }
+    init_list_t
+}
+*/
+
+
+
+void clear_list_t(list_t *my_list) {
+    if (my_list->length == 0) return;
+    node_t *temp = my_list->first->next;
+    while(temp->next != NULL) {
+        my_list->first->next = NULL;
+        free(my_list->first);
+        my_list->first = temp;
+        temp = temp->next;
+    }
+    free(temp);
+    init_list_t(my_list);
+    my_list = NULL;
+}
+
+void clear_list_lst(list_lst *my_list) {
+    if (my_list->length == 0) return;
+    while (my_list->length != 0) {
+        list_t *temp = get_node_lst(my_list);
+        clear_list_t(temp);
+        free(temp);
+    }
+}
+
+
+
 /*
 Renvoit une liste composée d'un entier suivi de ses diviseurs premiers
 */
+/*
 list_t *prime_list(int value) {
     list_t *prime = malloc(sizeof(list_t));
     if (!prime) return NULL;
@@ -142,51 +206,122 @@ list_t *prime_list(int value) {
     }
     return prime;
 }
+*/
+
 
 
+list_t *prime_list(int value) {
+    list_t *prime = malloc(sizeof(list_t));
+    if (!prime) return NULL;
+    init_list_t(prime);
+    put_node_t(prime, value);
+    
+    int in_node = 0;
+    int chiffre = value;
 
+    while (value % 2 == 0) {
+        if (2 != in_node) {
+            put_node_t(prime, 2);
+            in_node = 2;
+        }
+        value = value/2;
+    }
+    for (int i = 3; i*i <= value; i += 2) {
+        while (value % i == 0) {
+            if (i != in_node) {
+                put_node_t(prime, i);
+                in_node = i;
+            }
+            value = value / i;
+        }
+    }
+    if (value != chiffre){
+        put_node_t(prime, value);
+    }
+    
+    return prime;
+}
 
 
 buffer1 *init_buffer_1(int nthreads) {
-    buffer1 *buffer_1 =(buffer1 *) malloc(sizeof(buffer1));
+    buffer1 *buffer_1 = malloc(sizeof(buffer1));
     if (!buffer_1) {
+        free(buffer_1);
         printf ("Error with buffer_1.\n");
         return NULL;
-    } else {
-        printf ("buffer_1 created.\n");
     }
 
-    if (pthread_mutex_init(&(buffer_1->mutex), NULL) == -1) return NULL;
-    if (sem_init(&(buffer_1->free), 0, nthreads + 2) == -1) return NULL;
-    if (sem_init(&(buffer_1->full), 0, 0) == -1) return NULL;
+    if (pthread_mutex_init(&(buffer_1->mutex), NULL) == -1) {
+        free(buffer_1);
+        return NULL;
+    }
+    if (sem_init(&(buffer_1->free), 0, nthreads + 2) == -1) {
+        free(buffer_1);
+        return NULL;
+    }
+    if (sem_init(&(buffer_1->full), 0, 0) == -1) {
+        free(buffer_1);
+        return NULL;
+    }
 
-    buffer_1->length = nthreads + 2;
-    buffer_1->is_running = true;
+    buffer_1->length = 0;
+//    buffer_1->is_running = true;
     buffer_1->numbers = malloc(sizeof(list_t));
-    if (!buffer_1->numbers) return NULL;
+    if (!buffer_1->numbers) {
+        free(buffer_1->numbers);
+        free(buffer_1);
+        return NULL;
+    }
 
     init_list_t(buffer_1->numbers);
+
+    printf ("buffer_1 created.\n");
     return buffer_1;
 }
 
 buffer2 *init_buffer_2(int nthreads) {
-    buffer2 *buffer_2 =(buffer2 *) malloc(sizeof(buffer2));
+    buffer2 *buffer_2 = malloc(sizeof(buffer2));
     if (!buffer_2) {
+        free(buffer_2);
         printf ("Error with buffer_2.\n");
         return NULL;
-    } else {
-        printf ("buffer_2 created.\n");
     }
 
-    if (pthread_mutex_init(&(buffer_2->mutex), NULL) == -1) return NULL;
-    if (sem_init(&(buffer_2->free), 0, nthreads + 2) == -1) return NULL;
-    if (sem_init(&(buffer_2->full), 0, 0) == -1) return NULL;
+    if (pthread_mutex_init(&(buffer_2->mutex), NULL) == -1) {
+        free(buffer_2);
+        return NULL;
+    }
+    if (sem_init(&(buffer_2->free), 0, nthreads + 2) == -1) {
+        free(buffer_2);
+        return NULL;
+    }
+    if (sem_init(&(buffer_2->full), 0, 0) == -1) {
+        free(buffer_2);
+        return NULL;
+    }
 
-    buffer_2->length = nthreads + 2;
-    buffer_2->is_running = true;
+    buffer_2->length = 0;
+//    buffer_2->is_running = true;
     buffer_2->prime_numbers = malloc(sizeof(list_lst));
-    if (!buffer_2->prime_numbers) return NULL;
+    if (!buffer_2->prime_numbers) {
+        free(buffer_2->prime_numbers);
+        free(buffer_2);
+        return NULL;
+    }
 
     init_list_lst(buffer_2->prime_numbers);
+
+    printf ("buffer_2 created.\n");
     return buffer_2;
+}
+
+int count_lines(char *filename){
+    int number;
+    int lines = 0;
+    FILE *file = fopen(filename, "r");
+    while (fscanf(file, "%d", &number) != EOF) {
+        lines++;
+    }
+    fclose(file);
+    return lines;
 }
\ No newline at end of file