Erreur à la fin d'un programme.

J'ai écris un programme qui pour l'instant reste simple. Il s'agit d'une commande prenant au maximum 4 paramètres. Je vous passe la fonction de vérification de la syntaxe de ces paramètres. La deuxième fonction nommée "chemin" va chercher dans un fichier le chemin d'un autre fichier...

(Je programme avec Dev-C++)

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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
 
#if defined (WIN32)
#   include <windows.h>
#   define TO_CONSOLE__(dest, src, size) \
        CharToOemBuff((src), (dest), (size))
#else
#   include <string.h>
#   define TO_CONSOLE__(dest, src, size) \
        strncat((dest), (src), (size) - 1)
#endif
 
char *to_console(char *dest, char const *src, size_t size)
{
    char *p_ret = NULL;
 
    if (dest != NULL && src != NULL && size > 1)
    {
        *dest = 0;
        TO_CONSOLE__(dest, src, size);
        p_ret = dest;
    }
 
    return p_ret;
}
 
int chemin(char *langue, char *path, FILE *config) 
{   
    char c, lang[3], tampon[60];
    int i;
 
         if(config == NULL)
         {
              to_console(tampon, "\nErreur: le fichier config.spell est introuvable\n", sizeof tampon);
              puts(tampon); 
              return 1;
         }
 
         while(fgetc(config) != EOF)
         {
              fseek(config, -1, SEEK_CUR);
              i = 0;
 
                   while(c != ' ')
                   {
                        c = fgetc(config);
                        lang[i] = c;  
                        i++; 
                   }
 
              lang[2] = '\0';
 
                   if(strcmp(lang, langue) == 0)
                   {
                        /* Recupération du chemin */
                        i = 0;
 
                             while(c != '\n')
                             {
                                  c = fgetc(config);
                                  path[i] = c;
                                  i++;
                             }
 
                        path[i-1] = '\0';
                        return 0;
                   }
 
                   while(c != '\n')
                        c = fgetc(config);
          }        
 
 
    to_console(tampon, "\nErreur de lecture du fichier config.spell", sizeof tampon);
    puts(tampon);
    to_console(tampon, "\nLa langue spécifiée est introuvable", sizeof tampon);
    puts(tampon);
    to_console(tampon, "\nVerifiez que les chemins d'accès sont corrects\n", sizeof tampon);
    puts(tampon);
    return 1;
}             
 
 
int main(int argc, char *argv[])
{
    char *path = (char*)malloc(sizeof(char)), tampon[60];
    FILE *config;
 
    config = fopen("config.spell", "rb");
 
         if(verification(argc, argv) == 1) /* La fonction là n'est pas présente */
              return 1;   
 
         if(chemin(argv[2], path, config) == 1)
         {
              fclose(config);
              return 1;
         }     
 
    to_console(tampon, path, sizeof tampon);
    puts(tampon);
    fclose(config);
    return 0;
}
 
/* Contenu du fichier config.spell */
fr D:/dev-cpp/projets/L3/Projet/Dictionnaires/french.dict
en D:/dev-cpp/projets/L3/Projet/Dictionnaires/british-english.dict

Il s'agit d'un programme qui est censé vérifié l'orthographe d'un texte par rapport à un dictionnaire (français ou anglais)

Exemple:

spell -l fr nomfichier.txt

spell est le nom de la commande, -l est un paramètre (il ne sert à rien concrètement, c'est juste pour la syntaxe), fr est la langue du fichier à vérifier (ça peut donc être 'en' aussi, si le fichier est en anglais), et 'nomfichier.txt' est le nom du fichier à vérifier.

Pour l'instant, le programme ne fait que prendre le chemin complet du dico choisit dans le fichier config.spell et le stocke dans la chaine 'path'.

la fonction to_console est une fonction que j'ai créée afin de pouvoir utiliser le codage ISO 8814-1 dans la console windows. Ne vous en préocuppez pas, c'est en gros comme un printf...
to_console formate une chaine, et puts() l'affiche, c'est tout.

Voilà, j'en viens à mon problème. Arrivé à la fin de la fonction 'main', donc juste avant de quitter le programme grâce à 'return 0', un message d'erreur bizarre s'affiche:

L'instruction à "0x7c9218c5" emploie l'adresse mémoire "0x63694437". La mémoire ne peut pas être "read".

Il s'agit donc d'un problème de gestion de la mémoire, enfin je crois. Mais je ne sais pas du tout comment y remédier, quelqu'un pourrait m'aider ?

Merci d'avance!

Je n'ai pas tout regardé en détail mais il y a quelques petits soucis

Code:

char *path = (char*)malloc(sizeof(char))

T'alloue généreusement un pointeur sur UN caractère et non sur une chaîne.

pour dimensionner une chaîne devant contenir un répertoire, il existe une constante MAX_PATH.

Il faut ensuite vérifier que l'allocation demandée a été correcte et ne pas oublier de libérer la mémoire lorsqu'on ne l'utilise plus.

Dans ta fonction chemin
Code:

1 2 3 4 5 6 7 8 9 while(c != ' ') { c = fgetc(config); lang[i] = c; i++; } lang[2] = '\0';
Il serait prudent de rajouter une condition sur i dans la boucle et de remplacer
lang[2] = '\0' par lang[i] = '\0';
Code:

1 2 3 4 5 6 7 8 9 while((c != ' ')&&(i<2)) { c = fgetc(config); lang[i] = c; i++; } lang[i] = '\0';
puis de monter une erreur si le caractère suivant n'est pas un espace, ce qui te permettrais d'avoir des noms de langues de longueur variables en dimensionnant plus généreusement tes chaînes contenant les langues.

Bonne continuation.

Avec Code::Block et quand le fichier config.spell existe et est bien formaté, je n'ai pas d'erreur à l'exécution.
Par contre, tu ne devrais pas appeler fclose sur une variable NULL (si le fichier n'a pas pu être ouvert). Tu devrais aussi vérifier le retour de malloc (qu'il est inutile de caster, d'ailleurs), et allouer plus d'un caractère pour y stocker le chemin du dictionnaire.