Compilation foireuse bloquant la sortie standard

Version imprimable

25/04/2010, 16h09
Hoder

Compilation foireuse bloquant la sortie standard

Bonjour,

J'ai un probleme vraiment etrange, je realise en ce moment un sudoku en projet que l'on doit rendre demain. Nous recuperons des sudokus sur l'entree standard puis nous devons le resoudre et l'afficher le plus rapidement possible. Il est fini mais nous avons utilise fgets() et nous pensons qu'en faisant une petite fonction maison de 4 lignes, ca devrait marcher.
Eh bien ca marche nickel mais seulement quand on compile (avec gcc) avec les sources (*.c) dans le Makefile. Si on creer des fichiers objets (*.o), et qu'on les links (toujours avec gcc), la sortie standard n'affiche plus rien tant que l'on a pas ecrit quelque chose. Si apres chaque read de ligne que je fais, je mets un write(1, "", 1) par exemple, le resultat s'affiche bien.

En somme, connaissez-vous un moyen de resoudre le probleme occassionne par le linkage des fichiers objets, bloquant l'affichage de la sortie standard ?

Merci d'avance

EDIT : En fait, non ca doit venir encore d'ailleurs mais je ne sais pas de quoi :s Mais manifestemment, ce n'est pas au niveau du code mais bien de la compilation. Voici les CFLAGS que j'ai rajoute : -O -O2 -s -W -Wall -ansi -pedantic.

RE-EDIT : En fait, c'est le CFLAGS -02 qui bloque l'affichage et -O fait carrement SegFault... Je vais devoir les enlever alors mais connaissez-vous la raison de cela ?
25/04/2010, 21h02
gl

Citation:

Envoyé par Hoder

RE-EDIT : En fait, c'est le CFLAGS -02 qui bloque l'affichage et -O fait carrement SegFault... Je vais devoir les enlever alors mais connaissez-vous la raison de cela ?

Tu as probablement une erreur dans ton code qui induit un comportement différent en fonction du niveau d'optimisation.
26/04/2010, 00h56
LittleWhite

Bonjour,

gdb et valgrind seront vos amis ( du moins les outils pour vous aider :D )
26/04/2010, 17h50
Hoder

On est repasser a une version antérieure et les optimisations ont pu être mises.
Mais justement, le truc c'est que si je compile sans ces flags, ca marchait impec', c'est seulement quand je les rajoutais.

Citation:

Tu as probablement une erreur dans ton code

C'est justement ce que je me demandais, mais bon, je vais pas vous copier/coller tout mon programme, ca serait un peu long ^^
Tant pis, et merci quand meme :)
26/04/2010, 22h52
Obsidian

Il y a 99,999% de chances que ta segfault soit due à une erreur dans ton code plutôt que dans celui du compilateur. Ton code n'est pas forcement si long que tu le crois. Poste-le ici est veillant à utiliser les balises [code] et [/code].

Pour la sortie standard, sache que celle-ci bufferise par défaut tout ce que tu écris dedans jusqu'à un retour à la ligne ou si le tampon est plein. Il faudra peut-être modifier ce comportement si tu fais des manipulations particulières avec l'affichage.

Ca doit etre ca, je ne pensais pas que l'entree standard bufferisait, contrairement a printf() justement.
Je vais recoder la fonction qui creait le probleme pour voir cela.

EDIT :
Ceci fonctionne :
Code:

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 static char **stock_sudoku(int *finish) { char buffer[30]; int ctr; char **tab; ctr = 0; tab = xmalloc(sizeof(*tab) * 11); while (*finish != TRUE && ctr <= 10) /* Recupere 10 lignes */ { if ((fgets(buffer, sizeof(buffer), stdin)) == NULL) *finish = TRUE; else tab[ctr] = strdup(buffer); ctr++; } tab[ctr] = NULL; return (tab); } int sudoku() { char **tab; int finish; finish = FALSE; while (finish != TRUE) { tab = stock_sudoku(&finish); /* Recupere les sudokus a partir de l'entree standard */ begin_sudoku(tab); /* Nettoie la map et fait tout l'algo sur Sudoku */ if (finish == FALSE) { fprintl(1, DELIMITER); /* Affiche un simple delimiteur avec retour a la ligne sur l'entree standard */ free_tab(tab); } } printf("FINI\n"); return (SUCCESS); }
Mais on voulait augmenter la vitesse en evitant de passer par fgets qui serait peut-etre plus long qu'une fonction a nous de 3 lignes ^^.
On a fait une fonction qui recupere toujours le meme nombre de caracteres (vu que les cases des sudokus donnees sont toujours de 21 caracteres :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 char *get_next_line(const int fd) { char buffer[20]; char *line; int nb_read; if (!(nb_read = read(fd, buffer, 21))) return (NULL); buffer[nb_read] = '\0'; line = strdup(buffer); return (line); }
Suite a ce recode, je n'ai plus le probleme, mais un autre est apparu. Ca SegFault toujours au return de la fonction sudoku() (la fonction appellant sudoku() est le main et il n'y a rien d'autre apres cela, mais si on met un printf() dans le main, rien ne s'affiche, voici ce que me sort gdb : "Program received signal SIGSEGV, Segmentation fault. 0x00000000 in ?? ()").

Malgre ca, j'ai rajoute dans le Makefile -0 et -02, et la, plus rien ne rentre sur l'entree standard ^^. Normalement, je ressors un truc dans le style :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 |------------------| | 4 8 9 3 1 7 6 2 5| | 6 5 1 2 4 8 9 7 3| | 3 2 7 9 6 5 8 1 4| | 9 7 8 5 3 2 1 4 6| | 5 3 6 4 8 1 7 9 2| | 2 1 4 7 9 6 5 3 8| | 1 9 5 8 2 3 4 6 7| | 8 4 3 6 7 9 2 5 1| | 7 6 2 1 5 4 3 8 9| |------------------| ####################
(Ca rend mieux sur console :P)
Mais la, il me ressort :
Code:

1 2 3 4 5 |------------------| |------------------| #################### FINI
Mais sans SegFault ^^

Code:

1 2 3 4 5 6 7 8 9 10 11 12 char *get_next_line(const int fd) { char buffer[20]; char *line; int nb_read; if (!(nb_read = read(fd, buffer, 21))) return (NULL); buffer[nb_read] = '\0'; line = strdup(buffer); return (line); }
ça sera bien de tester la validité de ton paramètre et d'initialiser tes variables.
le test du retour de read est foireux, regarde le manpage. Que se passe-t-il lorsque read retourne -1 ?
Mais surtout, pourquoi demander un read de 21 octets quand ta chaîne en prend 20 seulement ? cela aurait du être au maximum

Code:

sizeof(buffer)

. Je pense que ton problème vient surtout de là.
Ca serait une bonne chose aussi de tester le retour de strdup, voir même de sans passer car maintenant tu va devoir libérer cet espace ailleurs que dans la fonction qui l'a crée ? Pourquoi ne pas créer buffer[] en dehors de la fonction et le passer en paramètre ? Ca serait plus sur et aussi plus rapide que de demander d'empiler cette chaine a chaque appel de cette fonction.
Moi j'aurai gardé le fgets.

Dans stock_sudoku( :
Code:

1 2 char **tab; tab = xmalloc(sizeof(*tab) * 11);
mouai, pkoi pas un char * tab [11] ?
D'après ton commentaire tu veux récupérer 10 lignes mais tu en réserves 11 :?
D'ailleurs dans ta boucle tu va de 0 à 10 inclus, ça doit te faire bizarre quand tu as saisis tes 10 lignes.
Moi j'aurai putôt vérifié que fgets retournait buffer mais bon ...
Code:

1 2 3 else tab[ctr] = strdup(buffer); ctr++
Y'a rien qui cloche pour toi là ?
Un conseil pour éviter toute réflexion à la relecture, utilises des balises pour tes instructions de contrôle mais si il n'y a qu'une ligne ?

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 char *get_next_line(const int fd) { char buffer[21]; char *line; int nb_read; bzero(buffer, sizeof(buffer)); line = NULL; nb_read = 0; if (!(nb_read = xread(fd, buffer, sizeof(buffer)))) return (NULL); buffer[nb_read] = '\0'; line = strdup(buffer); return (line); }
J'ai initialise toutes les variables et rajoute xread() qui permet de verifier si read() a eu un probleme (je l'avais pas fais cette fois parce qu'un peu la flemme, desole).

Et pour strdup, bah j'en ai besoin vu que je dois stocker mon tableau. Donc que je fasse le buffer dans get_next_line() ou dans stock_sudoku(), dans tout les cas, faut que je malloc et que je stockes (a moins que tu ne vois un autre moyen - ceci dit, j'aurai aussi pu faire une matrice...).

Merci pour l'astuce du sizeof(buffer) dans le read() aussi, j'avais jamais pense a ca et c'est vrai que ca me sera bien pratique a l'avenir, pour modifier buffer sans devoir modifier tout le reste.
Code:

1 2 3 4 else tab[ctr] = strdup(buffer); ctr++;
Mouais, c'est vrai que c'est un peu moche ^^ A l'origine, ca servait de le mettre ici mais apres, j'ai prefere utiliser une variable pour remplir le role, enfin bref.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 static char **stock_sudoku(int *finish) { int ctr; char **tab; ctr = 0; tab = xmalloc(sizeof(*tab) * 10); while (*finish != TRUE && ctr <= 10) { if ((tab[ctr++] = get_next_line(0)) == NULL) *finish = TRUE; } tab[ctr] = NULL; return (tab); }
Et au final, ca marche encore sans les flags d'optimisations sinon, avec -0 et/ou -02 : get_next_line me renvoit directement NULL.
Mais au moins ca ne SegFault plus a la fin, ca devait sans doute etre du au buffer trop petit comme tu me l'as fait remarquer.

01/05/2010, 15h27
bizulk
- Je ne connais pas xread et xmalloc
- Oui tu aurais pu faire une matrice parce que la taille de ton tableau est définie avant exécution. Tu verras que cette gestion de l'allocation de mémoire peut te jouer des tours.
- Préférer bzero à memset (regarde le manpage de cette fonction)
- Si read return l'erreur -1 tu fais comme si tout allait bien ...
- Je t'ai conseillé d'initialiser ta mémoire ailleurs car tu retournes tab qui est une variable locale et tu dois avoir un warning la-dessus. Ca fonctionne car tu alloues de la mémoire dynamiquement, mais ce n'est pas des habitudes a prendre .
Code:

1 2 3 else tab[ctr] = strdup(buffer); ctr++;
Je crois que tu ne m'a pas compris, quoiqu'il arrive tu incrémentais ctr alors que aurais du le faire que si ta chaîne est validée.
Code:

1 2 if ((tab[ctr++] = get_next_line(0)) == NULL)
T'est sur de ce que tu fais là ? Que les habitués de la norme me corrigent mais d'après moi cela se passe dans cet ordre :
- tab[ctr]= get_next_line(0))
- ctr++
- comparer tab[ctr] à NULL ce qui peut être le cas (car tu n'initialise pas tab). Mais ce qui n'est surement pas ce que tu souhaitais tester.
Code:

1 2 tab = xmalloc(sizeof(*tab) * 10); while (*finish != TRUE && ctr <= 10)
Ta boucle n'est pas bonne c'est ctr<10.

S'il s'agit d'un sudoku, pourquoi saisir 10 lignes de 20 caractères ?

Code:

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
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
 
#define TRUE 1
#define FALSE 0
#define ROW 9
#define COL 10
 
typedef char LINE[COL] ;
 
// attention avec fgets : http://c.developpez.com/faq/index.php?page=clavier_ecran#CONS_fgets
int get_next_line(LINE line)
{		char c ;
	if (line == NULL) return 1 ;
 
	if ( fgets(line, COL, stdin) != line )
	{
		printf("could not read line\n") ;
		return 1 ;
	}
	// lire le buffer d'entree pour vider le tampon jusqu'à \n
	do
	{
		c = getc (stdin) ;
	} while ( c != '\n') ;
 
	if (strlen(line) < (COL-1))
	{
		printf("invalid line\n") ;	 
		return 1 ;
	}
	return 0 ;
}
 
int stock_sudoku(LINE tab[])
{
	int           ctr;
	int ret = 0 ;
	if (tab == NULL) return 1 ;
 
	for (ctr = 0 ; (ret == 0) && (ctr < ROW) ; ctr++)
	{
		ret = get_next_line(tab[ctr]) ;
		if ( 0 !=ret)
		{printf("could not read table at line : %d\n", ctr) ;}
	}
	return ret ;
}
 
 
int main (int argc, char * argv[])
{
	int i ;
	int ret = 0 ;
	LINE tab[ROW] ;
	LINE tutu ;
 
	printf("test unitaire saisie ligne : ") ;
	get_next_line (tutu) ;
	printf("%s\n", tutu) ;
 
	memset (tab, 0 , sizeof(tab)) ;
 
	ret = stock_sudoku(tab) ;
	if( ret != 0 )
	{
		printf("could not read table\n") ;
		return -1 ;
	}
	for (i = 0 ; i < ROW ; i++)
	{
		printf("%s\n", tab[i]) ;
	}
	return 0 ;
}

01/05/2010, 19h24
diogene

@bizulk

Citation:

Je t'ai conseillé d'initialiser ta mémoire ailleurs car tu retournes tab qui est une variable locale et tu dois avoir un warning la-dessus

Il n'est pas du tout déconseillé de retourner la valeur d'une variable locale (comme ici). C'est même le cas le plus fréquent. Par contre, il ne faut pas retourner l'adresse d'une variable locale.

Citation:

Code:

if ((tab[ctr++] = get_next_line(0)) == NULL)

T'est sur de ce que tu fais là ? Que les habitués de la norme me corrigent mais d'après moi cela se passe dans cet ordre :
tab[ctr]= get_next_line(0))
ctr++
comparer tab[ctr] à NULL ce qui peut être le cas (car tu n'initialise pas tab). Mais ce qui n'est surement pas ce que tu souhaitais tester.

Non, cette expression n'est pas évaluée de cette façon : Il n'y a pas comparaison de tab[ctr] à NULL, mais comparaison à NULL de la valeur de l'expression

Code:

tab[ctr++] = get_next_line(0)

L'évaluation se fait de la façon suivante :
1- Evaluation de get_next_line(0) qui donne un valeur V (égale à la valeur retournée par la fonction)
2- Evaluation de l'adresse A correspondant à tab[ctr]
L'ordre des évaluations peut être 1 puis 2 ou 2 puis 1. Ce n'est pas spécifié.

3- Placement de la valeur V à l'adresse A (si besoin est, la valeur V est convertie au préalable en le type du contenu de A et prend la valeur V').
V (ou V') est la valeur de l'expression (celle qui sera comparée à NULL).
4- Incrément de ctr
L'ordre des évaluations peut être 3 puis 4 ou 4 puis 3. Ce n'est pas spécifié.

@bizulk
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 int get_next_line(LINE line) { char c ; if (line == NULL) return 1 ; if ( fgets(line, COL, stdin) != line ) { ... } // lire le buffer d'entree pour vider le tampon jusqu'à \n do { c = getc (stdin) ; } while ( c != '\n') ; ... }
Le test pour vider le tampon est erroné : fgets() place le '\n' dans line si il y a suffisamment de place pour le stocker. Dans ce cas, le buffer est vide et le do while nous oblige à taper une ligne supplémentaire pour avoir le '\n'.
On ne doit faire cette boucle que si le '\n' n'est pas déjà dans line et donc si line était trop petit pour contenir la ligne entrée.

01/05/2010, 20h43
bizulk

Oui oui on retourne une variable locale bien sur je ne sais pas ce qui m'a pris. 8O

pour fgets :
Non puisque fgets lit COL-1 caractères (les 9 chiffres). '\n' étant le dixième il est tout de suite dépilé il n'y a pas a retaper [enter].
Fais le test ...

Merci d'avoir corrigé l'évaluation des expressions. Néanmoins cette écriture n'aide pas à la clarté du code.
01/05/2010, 22h44
diogene
Citation:

Non puisque fgets lit COL-1 caractères (les 9 chiffres). '\n' étant le dixième il est tout de suite dépilé il n'y a pas a retaper [enter].
Fais le test ...

Ce n'est pas très sérieux, cette entrée qui ne marche que si on tape un nombre de caractères qui ne tiennent pas dans le buffer. Alors qu'il est si simple de tester la présence du '\n' :
Code:

1 2 3 4 5 if(strchr(line,'\n') == NULL) do { c = getc (stdin) ; } while ( c != '\n') ;
Citation:

Néanmoins cette écriture n'aide pas à la clarté du code.

Certes !