Discussion :

[vinzzzz]

Hello,

J'ai cette superbe erreur qui apparait lors de l'execution de mon programme. Voici le bout de code a prioris concerné (réduit au minimum vital):

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
 
int add_list_data(char *str_list_file, s_params *par) 
{
	FILE *f;
	int n,
	     nread = 0,
	     status ;
 
	char buf[150],
		apobuf[10],
		ligbuf[50],
		complexbuf[50];
 
	f = fopen(str_list_file, "r") ;
	if(f) {
		while(fgets(buf, 150, f)) {
			n = par->nfiles ;
			status = sscanf(buf, "%s %s %s", apobuf, complexbuf, ligbuf) ;
 
			if(status == 3) {
				nread += add_prot(apobuf, complexbuf, ligbuf, par) ;
			}
		}
	}
 
        // FLAG
	return(nread) ;
}

Voila en gros, le code s'arrete au FLAG, dans le sens ou je fait un printf avant le return ca fonctionne, mais dés que je retourne dans ma fonction appelante ca plante. Il termine donc correctement tout ce qu'il y a avant (a prioris).

En enlevant le sscanf, plus aucun problème. J'en ai déduit que ca venait donc du sscanf. Or je ne comprends pas pourquoi: tous mes buffers sont largements assez grands pour contenir mes diverses lectures (fichiers et colonnes). Bref je n'ai aucun problème, en théorie, de dépassement: Mon fichier de test contiens trois lignes ayant trois colonnes de chacunes exactement 5 caractères).

Voila si quelqu'un a une idée...
Merci d'avance

[|PaRa-BoL]

tous mes buffers sont largements assez grands

N'oublie pas que pour chaque buffer le \0 final est rajouté.

[acx01b]

salut

peut-être qu'on pourrait t'aider si tu postais le code en entier ?

[vinzzzz]

Ben le code en entier serait bien trop énorme...

Par ailleurs je sais bien que le \0 y est ajouté. D'ailleurs, j'affiche a la fin de la fonction (juste avant que ca plante) ma structure qui contiens les informations que j'ai récupéré dans le fichiers, et elles sont bien là... La structure est la suivante (je sais pas si ca peut vs etre utile...):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
typedef struct s_params
{
	char **fapo,
		 **fcomplex,
		 **fligan ;
 
	int nfiles ;
 
	float ashape_min_size,	
		  ashape_max_size ;	
 
} s_params ;

Ainsi la fonction add_prot ne fait qu'ajouter les 3 chaines de caractères trouvées dans les tableaux fapo, fcomplex, fligan... Donc quelques allocations rien de bien dangereux.

[|PaRa-BoL]

Donc quelques allocations rien de bien dangereux.

Si la preuve

[diogene]

Ainsi la fonction add_prot ne fait qu'ajouter les 3 chaines de caractères trouvées dans les tableaux fapo, fcomplex, fligan... Donc quelques allocations rien de bien dangereux.

Vu les déclarations

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
typedef struct s_params
{
	char **fapo,
		 **fcomplex,
		 **fligan ;
....

il vaudrait le coup de voir le code de add_prot

[vinzzzz]

Allons y alors:

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
 
int add_prot(char *apo, char *complex, char *ligan, s_params *par) 
{
	FILE *f = fopen(apo, "r") ;
	int nm1 ;
	if(f) {
		fclose(f) ;
		f = fopen(complex, "r") ;
		if(f) {
			nm1 = par->nfiles ;
			par->nfiles += 1 ;
			par->fapo     = (char**) my_realloc(par->fapo, (par->nfiles)*sizeof(char*)) ;
			par->fligan   = (char**) my_realloc(par->fligan, (par->nfiles)*sizeof(char*)) ;
			par->fcomplex = (char**) my_realloc(par->fcomplex, (par->nfiles)*sizeof(char*)) ;
 
			par->fapo[nm1] = my_malloc((strlen(apo)+1)*sizeof(char)) ;
			par->fcomplex[nm1] = my_malloc((strlen(complex)+1)*sizeof(char)) ;
			par->fligan[nm1] = my_malloc((strlen(ligan)+1)*sizeof(char)) ;
 
			strcpy(par->fapo[nm1], apo) ;
			strcpy(par->fcomplex[nm1], complex) ;
			strcpy(par->fligan[nm1], ligan) ;
 
			fclose(f) ;
		}
		else return 0 ;
	}
	else return 0 ;
 
	return 1 ;
}

A noter l'utilisation de my_malloc et my_realloc, simplment car j'utilise un petit gestionnaire d'allocation. Mais j'ai testé avec les versions standard (malloc et realloc) et même problème.

[Emmanuel Delahaye]

Hello,

J'ai cette superbe erreur qui apparait lors de l'execution de mon programme. Voici le bout de code a prioris concerné (réduit au minimum vital):
<...>
Voila si quelqu'un a une idée...

Donne un exemple de fichiers de données à traiter.

J'en suis là :

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
80
81
82
83
84
85
86
87
88
89
90
91
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define my_realloc(a, b) realloc(a, b)
#define my_malloc(a) malloc(a)
 
typedef struct s_params
{
   char **fapo, **fcomplex, **fligan;
   int nfiles;
   float ashape_min_size, ashape_max_size;
}
s_params;
 
int add_prot (char *apo, char *complex, char *ligan, s_params * par)
{
   FILE *f = fopen (apo, "r");
   int nm1;
   if (f != NULL)
   {
      fclose (f);
      f = fopen (complex, "r");
      if (f)
      {
         nm1 = par->nfiles;
         par->nfiles += 1;
         par->fapo =my_realloc (par->fapo, (par->nfiles) * sizeof (char *));
         par->fligan =my_realloc (par->fligan,
                                  (par->nfiles) * sizeof (char *));
         par->fcomplex =my_realloc (par->fcomplex,
                                  (par->nfiles) * sizeof (char *));
 
         par->fapo[nm1] = my_malloc ((strlen (apo) + 1) * sizeof (char));
         par->fcomplex[nm1] =
            my_malloc ((strlen (complex) + 1) * sizeof (char));
         par->fligan[nm1] = my_malloc ((strlen (ligan) + 1) * sizeof (char));
 
         strcpy (par->fapo[nm1], apo);
         strcpy (par->fcomplex[nm1], complex);
         strcpy (par->fligan[nm1], ligan);
 
         fclose (f);
      }
      else
         return 0;
   }
   else
      return 0;
 
   return 1;
}
 
int add_list_data (char const *str_list_file, s_params * par)
{
   FILE *f;
   int n, nread = 0, status;
 
   char buf[150], apobuf[10], ligbuf[50], complexbuf[50];
 
   f = fopen (str_list_file, "r");
   if (f)
   {
      while (fgets (buf, 150, f))
      {
         n = par->nfiles;
         status = sscanf (buf, "%s %s %s", apobuf, complexbuf, ligbuf);
 
         if (status == 3)
         {
            nread += add_prot (apobuf, complexbuf, ligbuf, par);
         }
      }
   }
 
   // FLAG
   return (nread);
}
 
int main (void)
{
 
   char str_list_file[128] = "ABCD";
 
   s_params par = { 0 };
 
   int err = add_list_data (str_list_file, &par);
   printf ("err = %d\n", err);
   return EXIT_SUCCESS;
}

[vinzzzz]

Je test avec le fichier suivant:

2onjapo.pdb 2onjco.pdb CFM
1btaapo.pdb 1btaco.pdb HEA
2fejapo.pdb 2fejco.pdb CLP
1pnmapo.pdb 1pnmco.pdb FES

Je viens de lancer le prog sous linux fedora (je suis habituellement sous ubuntu) et non aucun problème... Y'a quelque chose que je comprends vraiment pas dans cette histoire.

Merci en tout cas a tous pour votre aide... Y'a des fois quand ca veux pas

[|PaRa-BoL]

Ca ne veux pas dire que ça ne se reproduira pas dans 3heures...c'est un comportement indéfini.

[vinzzzz]

Bon, j'ai identifié le problème je crois................. En augmantant la taille des buffers ca fonctionne.

En fait J'ai inversé les tailles allouées a deux buffers: apo et ligan... En gros j'utilise apo pour lire les premières colonnes, ce qui en théorie (au niveau des noms) est ce que je comptait faire, sauf que je lui ai alloué 10 caractères (ce que j'aurai du faire pour ligan qui lui en contiens 50 au lieu de 10) au lieu de 50. Et dans mon exemple, la première colonne contiennent 11 caractères... Je pense que c'est ca car ca ne plante plus là....

3 pages pour une idiotie pareille. Vraiment, vraiment désolé d'avoir pris de votre temps a tous...

[|PaRa-BoL]

Or je ne comprends pas pourquoi: tous mes buffers sont largements assez grands pour contenir mes diverses lectures