Changes between Version 7 and Version 8 of CaoCourseTme2

Timestamp:

Feb 16, 2007, 11:15:58 AM (19 years ago)

Author:

franck

Comment:

--

CaoCourseTme2

@@ -73 +73 @@
  1. Que fait la regle indent ? quelle est la signification des flags utilisés par le programme indent ?
 
-'''Makefile'''
+'''Fichier Makefile'''
 {{{
   1 # Definition des commandes 
@@ -121 +121 @@
  *  Pourquoi inclure {{{stdio.h}}} ici ?
 
-'''main.c'''
+'''Fichier main.h'''
 {{{
   1 #ifndef _MAIN_H_
@@ -153 +153 @@
  1. Que faut-il faire pour transformer ce programme en filtre ?
 
-'''main.c'''
+'''Fichier main.c'''
 {{{
   1 #include <stdlib.h>
@@ -238 +238 @@
 == Les fonctions de bases de la tables de hachage ==
 
-'''hte.h'''
+'''Fichier hte.h'''
 {{{
   1 #ifndef _HTE_H_
@@ -356 +356 @@
 }}}
 
-'''hte.c'''
+'''Fichier hte.c'''
 {{{
   1 #include <stdio.h>
@@ -412 +412 @@
  53 }
 }}}
+
+== Le service ''dejavu'' ==
+
+'''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 }
+}}}
+
+== Le service ''dictionnaire'' ==
+
+'''Fichier dico.c'''
+
+{{{
+  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 }
+}}}
+
+=== Le service allocateur de nom ===
+
+'''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 }
+}}}