Pourquoi ce programme est-il segfaulting?

J'ai écrit un programme appelé Mathtext. Ce programme donne en texte brut "style" par le transfert de certaines plages de caractères en Unicode gammes telles que les mathématiques letterlike symboles" pour produire de la plaine-texte en italique, en gras, serif, etc.

Il fonctionne comme une, ligne par ligne, interprète, comme une coquille, de la sortie de la traduction de la ligne après ligne est entré. Cela signifie que les fichiers peuvent être cat/canalisations à traduire l'intégralité d'un fichier, ainsi que le fait que vous pouvez quitter la "coque" en appuyant sur ^D, ce qui est détecté par stdin frapper les expressions du FOLKLORE.

Tout fonctionne. Cependant, lorsque j'appuie sur ^D et de sortie, il segmentation. J'ai encore du mal à saisir ce qui est à l'origine.

De la compilation avec -g -O0 aide un peu; je sais maintenant que le problème se pose à partir d'un strlen appel à transposer quand ^D est pressé. Toutefois, la transposition ne doit jamais être appelée au cours d' ^D, comme des expressions du folklore est vrai!

Program received signal SIGSEGV, Segmentation fault. 
__strlen_sse2 () ../sysdeps/x86_64/multiarch/../strlen.S:31 
31 ../sysdeps/x86_64/multiarch/../strlen.S: Aucun fichier ou répertoire. 
dans ../sysdeps/x86_64/multiarch/../strlen.S 
(gdb) où 
#0 __strlen_sse2 () ../sysdeps/x86_64/multiarch/../strlen.S:31 
#1 0x0000000000400b0e dans transpose (s=0x0, capsDelta=120263, smallDelta=120257, numDelta=0) à mathtext.c:58 
#2 0x0000000000400e2b en main (argc=2, argv=0x7fffffffe4b8) à mathtext.c:92
s'il vous plaît montrer le code autour de la ligne 92 de mathtext.c

OriginalL'auteur Delan Azabani | 2010-08-31

  1. 3

    La plupart des utilisations de feof() sont d'un bug et ce programme illustre parfaitement dans cette boucle principale:

    char temp[1048576];
do {
if (!strcmp(argv[1], "serifb"))
transpose(fgets(temp, 1048576, stdin), 119808 - 'A', 119834 - 'a', 120782 - '0');
else if (!strcmp(argv[1], "serifi"))
transpose(fgets(temp, 1048576, stdin), 119860 - 'A', 119886 - 'a', 0);
else if (!strcmp(argv[1], "serifbi"))
transpose(fgets(temp, 1048576, stdin), 119912 - 'A', 119938 - 'a', 0);
else if (!strcmp(argv[1], "sans"))
transpose(fgets(temp, 1048576, stdin), 120224 - 'A', 120250 - 'a', 120802 - '0');
else if (!strcmp(argv[1], "sansb"))
transpose(fgets(temp, 1048576, stdin), 120276 - 'A', 120302 - 'a', 120812 - '0');
else if (!strcmp(argv[1], "sansi"))
transpose(fgets(temp, 1048576, stdin), 120328 - 'A', 120354 - 'a', 0);
else if (!strcmp(argv[1], "sansbi"))
transpose(fgets(temp, 1048576, stdin), 120380 - 'A', 120406 - 'a', 0);
else if (!strcmp(argv[1], "mono"))
transpose(fgets(temp, 1048576, stdin), 120432 - 'A', 120458 - 'a', 120822 - '0');
else if (!strcmp(argv[1], "fullwidth"))
transposeBlock(fgets(temp, 1048576, stdin), '!', '~', 65281 - '!');
else return help();
} while(!feof(stdin));

    À la fin-de-fichier, fgets() sera de retour NULL, et puis la prochaine invocation de feof() retournera true. De sorte que la bonne approche est de tester la valeur de retour de ta fonction d'entrée - et puisque vous êtes en train de faire le test de toute façon, il n'y a pas besoin d'appeler feof() (sauf si vous voulez distinguer une erreur de fichier à partir de fin-de-fichier).

    char temp[1048576];
while (fgets(temp, sizeof temp, stdin) != NULL) {
if (!strcmp(argv[1], "serifb"))
transpose(temp, 119808 - 'A', 119834 - 'a', 120782 - '0');
else if (!strcmp(argv[1], "serifi"))
transpose(temp, 119860 - 'A', 119886 - 'a', 0);
else if (!strcmp(argv[1], "serifbi"))
transpose(temp, 119912 - 'A', 119938 - 'a', 0);
else if (!strcmp(argv[1], "sans"))
transpose(temp, 120224 - 'A', 120250 - 'a', 120802 - '0');
else if (!strcmp(argv[1], "sansb"))
transpose(temp, 120276 - 'A', 120302 - 'a', 120812 - '0');
else if (!strcmp(argv[1], "sansi"))
transpose(temp, 120328 - 'A', 120354 - 'a', 0);
else if (!strcmp(argv[1], "sansbi"))
transpose(temp, 120380 - 'A', 120406 - 'a', 0);
else if (!strcmp(argv[1], "mono"))
transpose(temp, 120432 - 'A', 120458 - 'a', 120822 - '0');
else if (!strcmp(argv[1], "fullwidth"))
transposeBlock(temp, '!', '~', 65281 - '!');
else return help();
}
    Merci beaucoup, ta solution a fonctionné parfaitement!

    OriginalL'auteur caf

  2. 3

    Votre programme est référence NULL, depuis fgets retourne NULL en cas d'erreur ou expressions du FOLKLORE, et que vous êtes en passant directement à la transposition qui utilise le résultat naïvement.

    OriginalL'auteur Hasturkun

  3. 1

    feof ne pouvez pas prédire l'avenir. Il ne sait pas que c'est la fin de fichier jusqu'à ce que vous appuyez sur le ^D clé, en ce moment, votre programme est de retour en attente d'entrée dans fgets. La lecture d'un fichier ne produisent pas l'erreur, car tous l'entrée est déjà présent au début. Vérifier la valeur NULL dans votre fonction de transposition.

    Un moyen plus facile de dire c'est: EOF n'est pas défini jusqu'à ce que vous lire au-delà des expressions du FOLKLORE. Le dernier valide la lecture de lire JUSQU'À, mais pas au-delà du FOLKLORE et donc la lecture qui échoue a exactement 0 octets à lire.

    OriginalL'auteur Karl Bielefeldt