Bonjour,


Dans le cours de mon projet de développement, je met à jour mon Objet String perso que j'utilise dans le projet par l'ajout de quelques fonctions (voilà pour l'intro )

J'ai créé une table de style clé/valeur (en fait ancienne/nouvelle sous-chaine) sous forme de pile. Ce nouveau type est donc utilisé dans une fonction de remplacement que voici:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
C_Str_error C_Str_replace_from_table (C_Str * const self,
                                      C_Str_table * const table)
{
   C_Str_error err = C_STR_NO_ERR;
 
 
   if (self != NULL && table != NULL)
   {
      size_t         count = 0;
      char        *  p     = self->sz_string;
      C_Str_table *  t     = table;
 
 
      /* Parcours de la chaine caracteres par caracteres. */
      while (*p)
      {
         /*
          * Pour chaque avancement dans la chaine, on compare la liste complete
          * des ID dans la table d'ensemble.
          */
         while (t != NULL)
         {
            if (*p == t->id[0])
            {
               if (memcmp (p, t->id, t->id_size) == 0)
               {
                  C_Str_replace_string (self, count, t->id_size - 1, t->data);
                  break;
               }
            }
 
            /* Passage a l'ID suivant. */
            t = t->next;
         }
 
 
         t = table;
         p++;
         count++;
      }
   }
   else
   {
      err = C_STR_NULL_ARG;
   }
 
 
   return err;
}
Voici également la fonction de remplacement utilisée dans cette fonction:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
C_Str_error C_Str_replace_string (C_Str * const self,
                                  size_t start,
                                  size_t lenght,
                                  char const * const s_str)
{
   C_Str_error err = C_STR_NO_ERR;
   char * tmp_str = NULL;
   size_t size = 0;
 
 
   if (self != NULL && self->sz_string != NULL && s_str != NULL)
   {
      if (self->len > 0)
      {
         size = strlen (s_str);
         tmp_str = malloc (self->len - lenght + size);
 
         if (tmp_str != NULL)
         {
            /* ----- Construction de la nouvelle chaine ----- */
 
            /* Debut de la chaine d'origine. */
            memcpy (tmp_str, self->sz_string, start);
 
            /* Nouvelle chaine. */
            memcpy (&tmp_str[start], s_str, size);
 
            /* Fin de la chaine d'origine. */
            memcpy (
               &tmp_str[start + size],
               &self->sz_string[start + lenght + 1],
               self->len - lenght - start
            );
            /* ----- */
 
 
            err = C_Str_resize (self, strlen (tmp_str));
 
            if (err == C_STR_NO_ERR)
            {
               memset (self->sz_string, 0, self->len + 1);
               memcpy (self->sz_string, tmp_str, self->len);
            }
 
 
            free (tmp_str);
            tmp_str = NULL;
         }
         else
         {
            /* Erreur: impossible d'allouer l'espace requis. */
            err = C_STR_DYN_ALLOC_ERR;
         }
      }
      else
      {
         /* Erreur: la chaine est vide. */
         err = C_STR_BAD_STR_LEN;
      }
   }
   else
   {
      /* Erreur: probleme avec un argument passe en parametre. */
      err = C_STR_NULL_ARG;
   }
 
 
   return err;
}
J'ai un problème de remplacement dont je ne trouve pas l'origine, ce problème survient lorsque la chaine de remplacement est trop longue (ceci dit dans mes tests elles ne sont pas longues du tout, ce que je ne comprend pas).

Voici la sortie avec mes tests:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
C_Str, C ANSI/ISO String object - 2.2.0
 
 
<date/> : 09/07/08
<file/> : main.c
<copy/> : (c) 2008
<mail/> : franhec@gmail.com
<author/> : HECHT Franck
<project/> : CFG
 
 
id: <project/>, count: 8, *p: <
 
 
toto
   CFG
   <file/>
   <author/> - <copy/>
   <mail/>
   <date/>
toto
 
id: <file/>, count: 15, *p: <
 
 
toto
   CFG
   main.c
   <author/> - <copy/>
   <mail/>
   <date/>
toto
 
id: <author/>, count: 25, *p: <
 
 
toto
   CFG
   main.c
   HECHT Franck - <copy/>
   <mail/>
   <date/>
toto
 
id: <copy/>, count: 40, *p: <
 
 
toto
   CFG
   main.c
   HECHT Franck - (c) 2008
   <mail/>
   <date/>
toto
 
id: <mail/>, count: 52, *p: <
 
 
toto
   CFG
   main.c
   HECHT Franck - (c) 2008
   franhec@gmail.com
   <date/>
toto
 
id: <date/>, count: 63, *p: <
 
 
toto
   CFG
   main.c
   HECHT Franck - (c) 2008
   franhec@gma09/07/08   <date/>
toto
 
 
Process returned 0 (0x0)   execution time : 0.000 s
Press any key to continue.
On peut remarquer que l'avant dernière balise est correctement remplacée mais la dernière, est détectée trop tôt par rapport à son emplacement d'origine, ce qui est vraiment bizarre je vous l'accorde mais je ne trouve pas pourquoi

Si vous voyez quelque chose....