Changes between Version 11 and Version 12 of CaoCourseTme2

Timestamp:

Feb 16, 2007, 4:06:32 PM (19 years ago)

Author:

franck

Comment:

--

CaoCourseTme2

@@ -170 +170 @@
 {
     printf ("\nStatistique Diverses\n");
-    printf ("Usage  : %s 
-            [-v] [-o OutFile] InFile\n", command);
+    printf ("Usage  : %s [-v] [-o OutFile] InFile\n", command);
     printf ("-v          verbose mode\n");
     printf ("-o OutFile  output file (stdout by default)\n\n");
@@ -351 +350 @@
 '''Fichier hte.c'''
 {{{
-  1 #include <stdio.h>
-  2 #include <string.h>
-  3 #include <stdlib.h>
-  4 #include "hte.h"
-  5 
-  6 /*
-  7  * Calcul de l'index de hachage de Donald Knuth
-  8  * Elle produit un nombre entier à partir d'une chaine de caractères.
-  9  */
- 10 unsigned hte_hash (char *key)
- 11 {
- 12     char *c = key;
- 13     unsigned h;
- 14     for (h = 0; *c; c++)
- 15     {
- 16         h += (h ^ (h >> 1)) + 314159 * (unsigned char) *c;
- 17         while (h >= 516595003)
- 18             h -= 516595003;
- 19     }
- 20     return h;
- 21 }
- 22 
- 23 
- 24 /*
- 25  * Création d'un dictionnaire vide 
- 26  */
- 27 hte_root_t *hte_create (size_t nb_item)
- 28 {
- 29     hte_root_t *root;
- 30     unsigned i, nb_list;
- 31     static unsigned primes[] = { /*suite croissante de nombres premiers */
- 32         101, 149, 223, 347, 499, 727, 1163, 1697, 2503, 3989, 5839, 8543,
- 33         12503, 20143, 29483, 43151, 63179, 92503, 101747, 148961, 218107,
- 34         319313, 514243, 752891, 1212551, 1613873, 2599153, 3805463,
- 35         5571523, 8157241, 11943011, -1
- 36     };
- 37 
- 38     /* détermination de la taille réelle du dictionnaire */
- 39     for (i = 0; primes[i] < nb_item; i++);
- 40     nb_list = primes[i];
- 41     if (nb_item != -1)
- 42     {
- 43         /* allocation et initialisation du dictionnaire */
- 44         if ((root = malloc (sizeof (hte_root_t))))
- 45         {
- 46             root->NB_LIST = nb_list;
- 47             if ((root->LIST = calloc (nb_list, sizeof (hte_item_t *))))
- 48                 return root;
- 49         }
- 50     }
- 51     fprintf (stderr, "hte_create: not enough memory\n");
- 52     exit (1);
- 53 }
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "hte.h"
+}}}
+{{{
+/*
+ * Calcul de l'index de hachage de Donald Knuth
+ * Elle produit un nombre entier à partir d'une chaine de caractères.
+ */
+unsigned hte_hash (char *key)
+{
+    char *c = key;
+    unsigned h;
+    for (h = 0; *c; c++)
+    {
+        h += (h ^ (h >> 1)) + 314159 * (unsigned char) *c;
+        while (h >= 516595003)
+            h -= 516595003;
+    }
+    return h;
+}
+}}}
+{{{
+/*
+ * Création d'un dictionnaire vide 
+ */
+hte_root_t *hte_create (size_t nb_item)
+{
+    hte_root_t *root;
+    unsigned i, nb_list;
+    static unsigned primes[] = { /*suite croissante de nombres premiers */
+        101, 149, 223, 347, 499, 727, 1163, 1697, 2503, 3989, 5839, 8543,
+        12503, 20143, 29483, 43151, 63179, 92503, 101747, 148961, 218107,
+        319313, 514243, 752891, 1212551, 1613873, 2599153, 3805463,
+        5571523, 8157241, 11943011, -1
+    };
+
+    /* détermination de la taille réelle du dictionnaire */
+    for (i = 0; primes[i] < nb_item; i++);
+    nb_list = primes[i];
+    if (nb_item != -1)
+    {
+        /* allocation et initialisation du dictionnaire */
+        if ((root = malloc (sizeof (hte_root_t))))
+        {
+            root->NB_LIST = nb_list;
+            if ((root->LIST = calloc (nb_list, sizeof (hte_item_t *))))
+                return root;
+        }
+    }
+    fprintf (stderr, "hte_create: not enough memory\n");
+    exit (1);
+}
 }}}
 
@@ -410 +410 @@
 '''Fichier dejavu.c'''
 {{{
-  1 #include "hte.h"
-  2 #include <stdio.h>
-  3 #include <string.h>
-  4 #include <stdlib.h>
-  5 
-  6 /*
-  7  * structure définissant un item du dictionnaire
-  8  * Un item est formé d'un couple (clé,valeur) plus un pointeur
-  9  * permettant de chainer les items ayant le meme index de hachage
- 10  */
- 11 struct hte_item_s
- 12 {
- 13     struct hte_item_s *NEXT;    /* pointeur sur l'item suivant */
- 14     char KEY[];                 /* tableau flexible contenant la clé */
- 15 };
- 16 
- 17 
- 18 unsigned dejavu (char *key)
- 19 {
- 20     unsigned index;
- 21     hte_item_t *curr;
- 22     static hte_root_t *root_namealloc;
- 23 
- 24     if (key)
- 25     {
- 26         /* création du dictionnaire la première fois */
- 27         if (root_namealloc == NULL)
- 28             root_namealloc = hte_create (MAX_NAMEALLOC);
- 29 
- 30         /* calcul de l'index pour trouver la liste ou devrait être l'item */
- 31         index = hte_hash (key) % root_namealloc->NB_LIST;
- 32 
- 33         /* recherche et l'item dans sa liste et sortie si trouvé */
- 34         for (curr = root_namealloc->LIST[index]; curr; curr = curr->NEXT)
- 35         {
- 36             if ((int) curr == 0x4d52)
- 37                 fprintf (stderr,
- 38                          "------------------------------------------------------------ ARG1 \n");
- 39             if (strcmp (curr->KEY, key) == 0)
- 40                 return 1;
- 41         }
- 42 
- 43         /* création d'une nouvelle entrée */
- 44         curr = malloc (sizeof (struct hte_item_t *) + strlen (key) + 1);
- 45         if (curr)
- 46         {
- 47             if ((int) curr == 0x4d52)
- 48                 fprintf (stderr,
- 49                          "------------------------------------------------------------ ARG2 \n");
- 50             strcpy (curr->KEY, key);
- 51             curr->NEXT = root_namealloc->LIST[index];
- 52             if ((int) curr == 0x4d52)
- 53                 fprintf (stderr,
- 54                          "------------------------------------------------------------ ARG3 \n");
- 55             root_namealloc->LIST[index] = curr;
- 56             return 0;
- 57         }
- 58     }
- 59     perror ("dejavu");
- 60     exit (1);
- 61 }
+#include "hte.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+}}}
+{{{
+/*
+ * structure définissant un item du dictionnaire
+ * Un item est formé d'un couple (clé,valeur) plus un pointeur
+ * permettant de chainer les items ayant le meme index de hachage
+ */
+struct hte_item_s
+{
+    struct hte_item_s *NEXT;    /* pointeur sur l'item suivant */
+    char KEY[];                 /* tableau flexible contenant la clé */
+};
+}}}
+{{{
+unsigned dejavu (char *key)
+{
+    unsigned index;
+    hte_item_t *curr;
+    static hte_root_t *root_namealloc;
+
+    if (key)
+    {   
+        /* création du dictionnaire la première fois */
+        if (root_namealloc == NULL)
+            root_namealloc = hte_create (MAX_NAMEALLOC);
+
+        /* calcul de l'index pour trouver la liste ou devrait être l'item */
+        index = hte_hash (key) % root_namealloc->NB_LIST;
+
+        /* recherche et l'item dans sa liste et sortie si trouvé */
+        for (curr = root_namealloc->LIST[index]; curr; curr = curr->NEXT)
+            if (strcmp (curr->KEY, key) == 0)
+                return 1;
+
+        /* création d'une nouvelle entrée */
+        curr = malloc (sizeof (struct hte_item_t *) + strlen (key) + 1); 
+        if (curr)
+        {
+            strcpy (curr->KEY, key);
+            curr->NEXT = root_namealloc->LIST[index];
+            root_namealloc->LIST[index] = curr;
+            return 0;
+        }
+    }   
+    perror ("dejavu");
+    exit (1);
+}
 }}}
 
@@ -478 +468 @@
 
 {{{
-  1 #include <stdio.h>
-  2 #include <string.h>
-  3 #include <stdlib.h>
-  4 #include "hte.h"
-  5 
-  6 
-  7 /*
-  8  * structure définissant un item du dictionnaire
-  9  * Un item est formé d'un couple (clé,valeur) plus un pointeur
- 10  * permettant de chainer les items ayant le meme index de hachage
- 11  */
- 12 struct hte_item_s
- 13 {
- 14     struct hte_item_s *NEXT;    /* pointeur sur l'item suivant */
- 15     hte_data_t *DATA;           /* valeur associée à l'item */
- 16     char KEY[];                 /* tableau flexible contenant la clé */
- 17 };
- 18 
- 19 
- 20 /*
- 21  * Recherche d'un item de clé key dans le dictionaire root
- 22  */
- 23 hte_data_t *hte_get (hte_root_t * root, char *key)
- 24 {
- 25     int index;
- 26     hte_item_t *curr;
- 27 
- 28     if (key)
- 29     {
- 30         /* calcul de l'index pour trouver la liste ou devrait être l'item */
- 31         index = hte_hash (key) % root->NB_LIST;
- 32 
- 33         /* recherche et l'item dans sa liste et sortie si trouvé */
- 34         for (curr = root->LIST[index]; curr; curr = curr->NEXT)
- 35             if (strcmp (key, curr->KEY) == 0)
- 36                 return curr->DATA;
- 37 
- 38         return NULL;
- 39     }
- 40     perror ("hte_get");
- 41     exit (1);
- 42 }
- 43 
- 44 /*
- 45  * Recherche d'un item de clé key dans le dictionnaire root
- 46  * avec création en cas d'absence 
- 47  * et affectation d'une nouvelle donnée data
- 48  */
- 49 void hte_add (hte_root_t * root, char *key, hte_data_t * data)
- 50 {
- 51     int index;
- 52     hte_item_t *curr;
- 53 
- 54     if (key)
- 55     {
- 56         /* calcul de l'index pour trouver la liste ou devrait être l'item */
- 57         index = hte_hash (key) % root->NB_LIST;
- 58 
- 59         /* recherche et l'item dans sa liste et sortie si trouvé */
- 60         for (curr = root->LIST[index]; curr; curr = curr->NEXT)
- 61         {
- 62             if (strcmp (curr->KEY, key) == 0)
- 63             {
- 64                 curr->DATA = data;
- 65                 return;
- 66             }
- 67         }
- 68 
- 69         /* création d'une nouvelle entrée */
- 70         curr = malloc (sizeof (struct hte_item_t *) + sizeof (void *) + strlen (key) + 1);
- 71         if (curr)
- 72         {
- 73             strcpy (curr->KEY, key);
- 74             curr->NEXT = root->LIST[index];
- 75             root->LIST[index] = curr;
- 76             curr->DATA = data;
- 77             return;
- 78         }
- 79     }
- 80     perror ("hte_add");
- 81     exit (1);
- 82 }
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "hte.h"
+}}}
+{{{
+/*
+ * structure définissant un item du dictionnaire
+ * Un item est formé d'un couple (clé,valeur) plus un pointeur
+ * permettant de chainer les items ayant le meme index de hachage
+ */
+struct hte_item_s
+{
+    struct hte_item_s *NEXT;    /* pointeur sur l'item suivant */
+    hte_data_t *DATA;           /* valeur associée à l'item */
+    char KEY[];                 /* tableau flexible contenant la clé */
+};
+}}}
+{{{
+/*
+ * Recherche d'un item de clé key dans le dictionaire root
+ */
+hte_data_t *hte_get (hte_root_t * root, char *key)
+{
+    int index;
+    hte_item_t *curr;
+
+    if (key)
+    {
+        /* calcul de l'index pour trouver la liste ou devrait être l'item */
+        index = hte_hash (key) % root->NB_LIST;
+
+        /* recherche et l'item dans sa liste et sortie si trouvé */
+        for (curr = root->LIST[index]; curr; curr = curr->NEXT)
+            if (strcmp (key, curr->KEY) == 0)
+                return curr->DATA;
+
+        return NULL;
+    }
+    perror ("hte_get");
+    exit (1);
+}
+}}}
+{{{
+/*
+ * Recherche d'un item de clé key dans le dictionnaire root
+ * avec création en cas d'absence 
+ * et affectation d'une nouvelle donnée data
+ */
+void hte_add (hte_root_t * root, char *key, hte_data_t * data)
+{
+    int index;
+    hte_item_t *curr;
+
+    if (key)
+    {
+        /* calcul de l'index pour trouver la liste ou devrait être l'item */
+        index = hte_hash (key) % root->NB_LIST;
+
+        /* recherche et l'item dans sa liste et sortie si trouvé */
+        for (curr = root->LIST[index]; curr; curr = curr->NEXT)
+        {
+            if (strcmp (curr->KEY, key) == 0)
+            {
+                curr->DATA = data;
+                return;
+            }
+        }
+
+        /* création d'une nouvelle entrée */
+        curr = malloc (sizeof (struct hte_item_t *) + sizeof (void *) + strlen (key) + 1);
+        if (curr)
+        {
+            strcpy (curr->KEY, key);
+            curr->NEXT = root->LIST[index];
+            root->LIST[index] = curr;
+            curr->DATA = data;
+            return;
+        }
+    }
+    perror ("hte_add");
+    exit (1);
+}
 }}}
 
@@ -566 +557 @@
 '''Fichier namealloc.c'''
 {{{
-  1 #include "hte.h"
-  2 #include <stdio.h>
-  3 #include <string.h>
-  4 #include <stdlib.h>
-  5 
-  6 /*
-  7  * structure définissant un item du dictionnaire
-  8  * Un item est formé d'un couple (clé,valeur) plus un pointeur
-  9  * permettant de chainer les items ayant le meme index de hachage
- 10  */
- 11 struct hte_item_s
- 12 {
- 13     struct hte_item_s *NEXT;    /* pointeur sur l'item suivant */
- 14     char KEY[];                 /* tableau flexible contenant la clé */
- 15 };
- 16 
- 17 
- 18 char *namealloc (char *key)
- 19 {
- 20     int index;
- 21     hte_item_t *curr;
- 22     static hte_root_t *root_namealloc;
- 23 
- 24     if (key)
- 25     {
- 26         /* création du dictionnaire la première fois */
- 27         if (root_namealloc == NULL)
- 28             root_namealloc = hte_create (MAX_NAMEALLOC);
- 29 
- 30         /* calcul de l'index pour trouver la liste ou devrait être l'item */
- 31         index = hte_hash (key) % root_namealloc->NB_LIST;
- 32 
- 33         /* recherche et l'item dans sa liste et sortie si trouvé */
- 34         for (curr = root_namealloc->LIST[index]; curr; curr = curr->NEXT)
- 35         {
- 36             if (strcmp (curr->KEY, key) == 0)
- 37                 return curr->KEY;
- 38         }
- 39 
- 40         /* création d'une nouvelle entrée */
- 41         curr = malloc (sizeof (struct hte_item_t *) + strlen (key) + 1);
- 42         if (curr)
- 43         {
- 44             strcpy (curr->KEY, key);
- 45             curr->NEXT = root_namealloc->LIST[index];
- 46             root_namealloc->LIST[index] = curr;
- 47             return curr->KEY;
- 48         }
- 49     }
- 50     perror ("namealloc");
- 51     exit (1);
- 52 }
-}}}
+#include "hte.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+}}}
+{{{
+/*
+ * structure définissant un item du dictionnaire
+ * Un item est formé d'un couple (clé,valeur) plus un pointeur
+ * permettant de chainer les items ayant le meme index de hachage
+ */
+struct hte_item_s
+{
+    struct hte_item_s *NEXT;    /* pointeur sur l'item suivant */
+    char KEY[];                 /* tableau flexible contenant la clé */
+};  
+}}}
+{{{    
+char *namealloc (char *key)
+{
+    int index;
+    hte_item_t *curr;
+    static hte_root_t *root_namealloc;
+
+    if (key)
+    {
+        /* création du dictionnaire la première fois */
+        if (root_namealloc == NULL)
+            root_namealloc = hte_create (MAX_NAMEALLOC);
+    
+        /* calcul de l'index pour trouver la liste ou devrait être l'item */
+        index = hte_hash (key) % root_namealloc->NB_LIST;
+
+        /* recherche et l'item dans sa liste et sortie si trouvé */
+        for (curr = root_namealloc->LIST[index]; curr; curr = curr->NEXT)
+        {
+            if (strcmp (curr->KEY, key) == 0)
+                return curr->KEY;
+        }
+    
+        /* création d'une nouvelle entrée */
+        curr = malloc (sizeof (struct hte_item_t *) + strlen (key) + 1);
+        if (curr)
+        {
+            strcpy (curr->KEY, key);
+            curr->NEXT = root_namealloc->LIST[index];
+            root_namealloc->LIST[index] = curr;
+            return curr->KEY;
+        }
+    }
+    perror ("namealloc");
+    exit (1);
+}   
+}}}