cleaning pile & list

include/util.h

@@ -45,25 +45,29 @@ char *util_read_file (char *filename);
 // Sinon vous encourez selon la loi jusqu'à trois ans de prison
 // et jusqu'à 300 000 € de dommages et intérêts.
 
+// Le piratage est illégal,
+// de même que sont interdits: cracks, warez, sérials (sauf évaluation), etc.
+// Est bien sûr autorisé tout ce qui concerne les logiciels gratuits, freewares et évaluation.
+
 typedef struct pile {int valeur; struct pile *prec;} pile; // structure d'un élément
-void util_pile_push   (pile **, int);   //  empile une valeur sur la pile
+int  util_pile_push   (pile **, int);   //  empile une valeur sur la pile
-int  util_pile_pop    (pile **);  //  pop retire la dernière valeur empilée
+int  util_pile_pop    (pile **);  //  retire la dernière valeur empilée
 void util_pile_clear  (pile **);  //  vide la pile
 int  util_pile_length (pile *p);  //  retourne le nombre d'éléments de la pile
 void util_pile_view   (pile *);   //  affiche la pile en commençant par le sommet
 
-
 //------------------------------------------------------------------------------
 
-typedef struct elem {int value; struct elem *prev; struct elem *next;} elem ;
+typedef struct elem {int value; struct elem *prev; struct elem *next;} elem;
 typedef struct {elem *first; elem *last;} dblist;   //  structure d'accès à la liste
-void list_2x2_init (dblist *l);                  //  initialisation
+void util_list_2x2_init (dblist *l);                //  initialisation
-void list_2x2_push_back  (dblist *l, int val);   //  ajout d'une valeur en fin de liste
+int util_list_2x2_push_back  (dblist *l, int val);  //  ajoute une valeur en fin de liste
-void list_2x2_push_front (dblist *l, int val);   //  ajout d'une valeur en début de liste
+int util_list_2x2_push_front (dblist *l, int val);  //  ajoute une valeur en début de liste
-int  list_2x2_pop_back   (dblist *l);  //  retrait d'une valeur en fin de liste
+int  util_list_2x2_pop_back  (dblist *l);   //  retire une valeur en fin de liste
-int  list_2x2_pop_front  (dblist *l);  //  retrait d'une valeur en début de liste
+int  util_list_2x2_pop_front (dblist *l);   //  retire une valeur en début de liste
-void list_2x2_view  (dblist l);        //  affichage de toute la liste
+int  util_list_2x2_length (dblist l);       //  retourne le nombre d'éléments de la liste
-void list_2x2_clear (dblist *l);       //  vidage de toute la liste
+void util_list_2x2_view   (dblist l);       //  affiche les valeurs de toute la liste
+void util_list_2x2_clear  (dblist *l);      //  vide toute la liste
 
 //------------------------------------------------------------------------------
 

src/fsm/measure.c

@@ -35,14 +35,14 @@
 
 /******************************************************************************/
 /*                                                                            */
-/*            FFFFFFFFFFFF          SSSS            MM         MM             */
+/*            FFFFFFFFFFFF          SSSSS           MM         MM             */
-/*            FF                  SS    SS          MMMM     MMMM             */
+/*            FF                  SSS    SS         MMMM     MMMM             */
 /*            FF                  SS                MM MM   MM MM             */
 /*            FFFFFFF               SS              MM  MM MM  MM             */
 /*            FF                       SS           MM    MM   MM             */
-/*            FF                         SS         MM         MM             */
+/*            FF                         SSS        MM         MM             */
-/*            FF                 SS     SS          MM         MM             */
+/*            FF                 SS     SSS         MM         MM             */
-/*            FF                   SSSSS            MM         MM             */
+/*            FF                   SSSSSS           MM         MM             */
 /*                                                                            */
 /******************************************************************************/
 
@@ -74,17 +74,18 @@
 //  When a list of measurements is established, it is possible to evaluate
 //  if the results of a measurement are correlated with some other results.
 
-//  https://fr.wikibooks.org/wiki/Structures_de_donn%C3%A9es_en_C/Les_listes_simples
+//------------------------------------------------------------------------------
 
 //  structure de données : chaque "item" comportera :
 
 //  - identifiant (clé)  (+/- pointeur vers : date de création, auteur,...)
 
 //  - type de mesure
-//    (les 6 items suivants documentent l'ensemble de toutes les valeurs
+//    les 6 items suivants peuvent documenter l'ensemble de toutes les valeurs
-//         à recueillir pour de tous les types de mesure possibles;
+//         à recueillir pour documenter tous les types de mesure possibles;
-//         tous ne peuvent être simultanément utilisés
+//    tous ces items ne doivent pas être simultanément complétés
-//         mais ils occupent peu de place dans le tableau)
+//         mais, si un tableau etait utilisé, il y aurait peu de place perdue;
+
 //  - pointeur vers le premier groupe de règles (une au moins)
 //  - pointeur vers un second groupe de règles (une au moins)
 //  - pointeur vers des objets ou situations (un au moins)
@@ -102,8 +103,6 @@ void fsm_add_measure (char *measure_name) {fsm_debug_msg (2, 0, measure_name, 2)
 void fsm_measures_list_init ()
 {
     fsm_debug_msg (0,0, "fsm_measures_list_init()", 2);  //  sub_automaton 2
-    if (0) util_pile_test();
+    if (1) util_pile_test();
     if (0) util_double_list_test();
 }
-
-

src/util/list_2x2.c

@@ -31,13 +31,13 @@
 #include "../../include/util.h"
 
 
-void list_2x2_init(dblist *l)
+void util_list_2x2_init (dblist *l)
 {
    l->first = NULL;
    l->last = NULL;
 }
 
-void list_2x2_push_back(dblist *l, int val)
+int util_list_2x2_push_back (dblist *l, int val)
 {
    elem *nouv = malloc (sizeof(elem));
    if (! nouv) exit (EXIT_FAILURE);
@@ -47,9 +47,10 @@ void list_2x2_push_back(dblist *l, int val)
    if (l->last) l->last->next = nouv;
    else l->first = nouv;
    l->last = nouv;        
+   return val;
 }
 
-void list_2x2_push_front(dblist *l, int val)
+int util_list_2x2_push_front (dblist *l, int val)
 {
    elem *nouv = malloc(sizeof(elem));
    if (! nouv) exit (EXIT_FAILURE);
@@ -59,9 +60,10 @@ void list_2x2_push_front(dblist *l, int val)
    if (l->first) l->first->prev = nouv;
    else l->last = nouv;
    l->first = nouv;
+   return val;
 }
 
-int list_2x2_pop_back(dblist *l)
+int util_list_2x2_pop_back (dblist *l)
 {
    int val;
    elem *tmp = l->last;
@@ -74,7 +76,7 @@ int list_2x2_pop_back(dblist *l)
    return val;
 }
 
-int list_2x2_pop_front(dblist *l)
+int util_list_2x2_pop_front (dblist *l)
 {
    int val;
    elem *tmp = l->first;
@@ -87,17 +89,7 @@ int list_2x2_pop_front(dblist *l)
    return val;
 }
 
-void list_2x2_view(dblist l)
+void util_list_2x2_clear (dblist *l)
-{
-   elem *pelem = l.first;
-   while (pelem)
-   {
-     printf ("%d\n", pelem->value);
-     pelem = pelem->next;
-   }
-}
-
-void list_2x2_clear(dblist *l)
 {
    elem *tmp;
    elem *pelem = l->first;
@@ -110,3 +102,29 @@ void list_2x2_clear(dblist *l)
    l->first = NULL;
    l->last = NULL;
 }
+
+int util_list_2x2_length (dblist l)
+{
+    elem *pelem = l.first;
+    int cpt = 0;
+    while (pelem)
+    {
+        cpt ++;
+        pelem = pelem->next;
+    }
+   return cpt;
+}
+
+void util_list_2x2_view (dblist l)
+{
+    printf ("view liste  (n = %d)\n", util_list_2x2_length (l));
+    elem *pelem = l.first;
+    while (pelem)
+    {
+        printf ("> %d <\n", pelem->value);
+        pelem = pelem->next;
+    }
+    puts ("--------------");
+}
+
+

src/util/pile.c

@@ -28,17 +28,17 @@
 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  */
 
 
-
 #include "../../include/util.h"
 
 
-void util_pile_push (pile **p, int Val)
+int util_pile_push (pile **p, int Val)
 {
     pile *element = malloc (sizeof(pile));
     if (!element) exit (EXIT_FAILURE);     // Si l'allocation a échoué.
     element->valeur = Val;
     element->prec = *p;
     *p = element;       // Le pointeur pointe sur le dernier élément.
+    return Val;
 }
 
 int util_pile_pop (pile **p)
@@ -58,30 +58,32 @@ void util_pile_clear (pile **p)
 {
     pile *tmp;
     while (*p)
-      {
+    {
-         tmp = (*p)->prec;
+        tmp = (*p)->prec;
-         free (*p);
+        free (*p);
-         *p = tmp;
+        *p = tmp;
-      }
+    }
 }
 
 int util_pile_length (pile *p)
 {
     int n=0;
     while (p)
-      {
+    {
-          n++;
+        n++;
-          p = p->prec;
+        p = p->prec;
-      }
+    }
     return n;
 }
 
 void util_pile_view (pile *p)
 {
+    printf ("view pile  (n = %d)\n", util_pile_length (p));
     while (p)
-      {
+    {
-         printf ("%d\n", p->valeur);
+        printf ("%d\n", p->valeur);
-         p = p->prec;
+        p = p->prec;
-      }
+    }
+    puts ("------");
 }
 

src/util/tests.c

@@ -34,64 +34,51 @@
 
 void util_pile_test()
 {
-    pile *MaPile = NULL;   // Impératif de l'initialiser à NULL
+    pile *exemple = NULL;   // doit être initialisée à NULL
 
-    util_pile_push(&MaPile, 10);
+    printf ("push  > %d\n", util_pile_push (&exemple, 1));
-    util_pile_push(&MaPile, 25);
+    printf ("push  > %d\n", util_pile_push (&exemple, 2));
-    util_pile_push(&MaPile, 33);
+    printf ("push  > %d\n", util_pile_push (&exemple, 3));
-    util_pile_push(&MaPile, 12);  // Empile 4 valeurs.
+    printf ("push  > %d\n", util_pile_push (&exemple, 4));
 
-    puts("Affichage de la pile :");
+    util_pile_view (exemple);
-    util_pile_view(MaPile);       // Affiche la totalité de la pile.
-    puts("------");
 
-    printf("Nb d'elements : %d\n",util_pile_length(MaPile));
+    printf ("pop   > %d\n", util_pile_pop (&exemple));
-    puts("------");
+    printf ("pop   > %d\n", util_pile_pop (&exemple));
 
-    puts("Deux valeurs soutirées de la pile :");
+    util_pile_view(exemple);
-    printf("%d\n",util_pile_pop(&MaPile));   // Affiche deux valeurs
-    printf("%d\n",util_pile_pop(&MaPile));   // soutirées de la pile.
-    puts("------");
 
-    puts("Affichage de la pile :");
+    printf ("clear pile\n");  util_pile_clear (&exemple);
-    util_pile_view(MaPile);          // Affiche la totalité de la pile.
-    puts("------");
 
-    util_pile_clear(&MaPile);        // Vide la pile.
+    util_pile_view(exemple);
-
-    util_pile_push(&MaPile, 18);     // Empile une valeur.
-
-    puts("Affichage de la pile apres vidage et ajout d'une valeur :");
-    util_pile_view(MaPile);          // Affiche la totalité de la pile.
-    puts("------\n");
-
-    util_pile_clear(&MaPile);    // Vider la pile avant de quitter.
 }
 
 void util_double_list_test()
 {
-    dblist MaListe;
+    dblist exemple;
 
-    list_2x2_init(&MaListe);
+    util_list_2x2_init (&exemple);
 
-    list_2x2_push_front(&MaListe,10);
+    printf ("push front > %d\n", util_list_2x2_push_front (&exemple, 10));
-    list_2x2_push_back(&MaListe,20);
+    printf ("push back  > %d\n", util_list_2x2_push_back  (&exemple, 100));
-    list_2x2_push_back(&MaListe,40);
+    printf ("push back  > %d\n", util_list_2x2_push_back  (&exemple, 1000));
-    list_2x2_push_front(&MaListe,50);
+    printf ("push front > %d\n", util_list_2x2_push_front (&exemple, 1));
 
-    list_2x2_view(MaListe);
+    util_list_2x2_view (exemple);
-    puts("--------------");
 
-    printf("%d\n",list_2x2_pop_front(&MaListe));
+    printf ("pop back   > %d\n", util_list_2x2_pop_back   (&exemple));
-    printf("%d\n",list_2x2_pop_front(&MaListe));
+    printf ("pop back   > %d\n", util_list_2x2_pop_back   (&exemple));
-    printf("%d\n",list_2x2_pop_back(&MaListe));
+    printf ("pop back   > %d\n", util_list_2x2_pop_back   (&exemple));
-    puts("--------------");
+    printf ("pop back   > %d\n", util_list_2x2_push_back  (&exemple, 2));
 
-    list_2x2_push_back(&MaListe,30);
+    util_list_2x2_view (exemple);
 
-    printf("%d\n",list_2x2_pop_front(&MaListe));
+    printf ("push back  > %d\n", util_list_2x2_push_back  (&exemple, 3));
-    printf("%d\n",list_2x2_pop_front(&MaListe));
+    printf ("push front > %d\n", util_list_2x2_push_front (&exemple, 0));
-    puts("--------------");
 
-    list_2x2_clear(&MaListe);
+    util_list_2x2_view (exemple);
+
+    printf ("clear all\n");      util_list_2x2_clear (&exemple);
+
+    util_list_2x2_view (exemple);
 }