Programme équivalent à DIR

Version imprimable

Voir 40 message(s) de cette discussion en une page

Citation:

Envoyé par _SamSoft_

Donc un gros problème (mais où ? 8O)

En commençant par corriger ça.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 Project : Forums Compiler : GNU GCC Compiler (called directly) Directory : C:\dev\forums\ -------------------------------------------------------------------------------- Switching to target: default Compiling: main.c main.c: In function `main': main.c:55: warning: control reaches end of non-void function Linking console executable: console.exe Process terminated with status 0 (0 minutes, 1 seconds) 0 errors, 1 warnings
J'ai indiqué 3000 fois comment configurer le compilateur. Je ne comprends pas que ce genre de bug ne soit pas corrigé. A croire que tu ne lis ni les réponses ni les messages du compilateur...

Autre problème, comme tu t'obstines à mener plusieurs projets de front, arrive ce qui devait arriver. Tu mélanges les questions, les codes, les résultats... Bref, c'est le souk...

Je serais toi, j'arrêterais de me disperser et je traiterais un sujet à la fois, mais à fond et étape par étape.

17/09/2007, 19h53
Skyounet

Tu t'es trompé de code _SamSoft_ tu as mis le code d'un autre projet.
17/09/2007, 20h12
_SamSoft_

C'est quoi la blague (j'ai pas saisis) c'est bien le code du projet du listeur de fichiers/dossiers -_-
17/09/2007, 20h13
Skyounet

Citation:

Envoyé par _SamSoft_

C'est quoi la blague (j'ai pas saisis) c'est bien le code du projet du listeur de fichiers/dossiers -_-

Pas dans ce message non.
http://www.developpez.net/forums/sho...6&postcount=80
17/09/2007, 20h20
_SamSoft_

Ah et m****e [aie] (toutes mes excuses, Emmanuel m'avait pourtant prévenu -_-)

Je corrige (et je reprecise que je reste sur ce projet) !

Et moi je vous ai dit 3000 fois que je l'ai fais :

Code:

1
2
 
-Wall -Wextra -O2 -Wwrite-strings -Wstrict-prototypes

Je l'ai mis dans Outils/Options du compilo/
Appeler lors de la compilation.

Et je n'ai pas votre message -_-

EDIT: En reconstruisant et en recompilant j'ai vu :

size_t sizeDir = sizeof directory ne sert à rien donc j'ai supprimé :

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <errno.h>
#include <sys/stat.h>
#include "myHeader.h"
int lister(char *directory);
 
int main(void)
{
   int end;
 
   do
   {
      char directory[256];
      printf ("NAME OR <ENTER> FOR EXIT) : ");
      fgets (directory, sizeof directory, stdin);
      fclean (directory, stdin);
      end = (directory[0] == '\0');
      if (!end)
      {
         lister(directory);
      }
   }
   while (!end);
   return 0;
}
int lister(char *directory)
{
   DIR *dir = NULL;
   struct dirent *file = NULL;
   struct stat infos;
 
   if((dir = opendir(directory)) == NULL)
   {
      return EXIT_FAILURE;
   }
   printf("FOLDER %s:\n", directory);
 
   while((file = readdir(dir)) != NULL)
   {
   stat (file->d_name, &infos);
      if(strcmp(file->d_name, ".") && strcmp(file->d_name, ".."))
      {
         if(S_ISDIR (infos.st_mode))
         {
      printf("\n[FOLDER]\t%s\n", file->d_name);
         }
         else
         {
            printf("\n[FILE]\t%s\n", file->d_name);
         }
      }
   }
 
   printf("\nEND OF THE FOLDER: %s\n", directory);
 
   closedir(dir);
 
   return EXIT_SUCCESS;
}

PS: Ok, je reste sur ce projet il est plus interessant :D

Je suis très proche de la fin du logiciel, j'ai réussi à comprendre les erreurs (il en reste encore -_- mais je cherche)...

code :

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 <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <errno.h>
#include <sys/stat.h>
#include "myHeader.h"
int list(char *directory, size_t sizeDir);
 
int main(void)
{
  int end;
  size_t sizeDir;
  char directory[256];
  sizeDir = sizeof directory;
 
 
   do
   {
      printf ("NAME OR <ENTER> FOR EXIT) : ");
      fgets (directory, sizeof directory, stdin); /* we take the path */
      fclean (directory, stdin);
      end = (directory[0] == '\0');
      if (!end)
      {
         list(directory, sizeDir);
      }
   }
   while (!end); //while end[0] != '\0'
   return 0;
}
int list(char *directory, size_t sizeDir)
{
   DIR *dir = NULL;
  int err;
   struct dirent *file = NULL;
   struct stat infos;
 
   if((dir = opendir(directory)) == NULL)
   {
      return EXIT_FAILURE;
   }
   printf("FOLDER %s:\n", directory);
 
   while((file = readdir(dir)) != NULL)
   {
   stat(file->d_name, &infos);
   err = stat(file->d_name, &infos);
      if(strcmp(file->d_name, ".") && strcmp(file->d_name, ".."))
      {
     if(err)
     {
          if(S_ISDIR (infos.st_mode))
          {
      printf("\n[FOLDER]\t%s\n", file->d_name);
          }
          else
          {
            printf("\n[FILE]\t%s\n", file->d_name);
          }
    }
        else
        {
         printf ("'%s' IS UNKNOW\n", directory);
         return 1;
        }
      }
   }
 
   printf("\nEND OF THE FOLDER: %s\n", directory);
 
   closedir(dir);
 
   return EXIT_SUCCESS;
}

J'ai toujours le problème : si je met c:\dev-cpp il met tout le temps [FOLDER] file->d_name;

Si vous avez une idée (de(s) ligne(s) ?)

Merci d'avance :)

En cas de réussite, la fonction stat() renvoie la valeur 0 en cas de réussite. Dès lors, je ne comprends pas ça:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
            if (err)
            {
                if (S_ISDIR (infos.st_mode))
                {
                    printf("\n[FOLDER]\t%s\n", file->d_name);
                }
                else
                {
                    printf("\n[FILE]\t%s\n", file->d_name);
                }
            }
            else
            {
                printf ("'%s' IS UNKNOW\n", directory);
                return 1;
            }

Thierry

Il y a un problème avec le code de ta fonction list() au niveau de l'appel de stat(). En effet, à moins de tester le répertoire courant (i.e. directory pointe sur la chaine "."), stat(file->d_name, &infos) retourne -1, car le fichier en question ne peut être trouvé dans le répertoire courant (ou alors c'est un hasard, et il ne s'agit pas du bon fichier).

Pour que la fonction list() fonctionne correctement, je mémorise le répertoire courant avec la fonction getcwd(), puis le change en appelant chdir(directory) avant d'entrer dans la boucle while (naturellement, je reviens dans le répertoire initial une fois la travail effectué).

Les fonctions chdir() et getcwd() sont POSIX.1. Je crois qu'elles sont implantées par la bibliothèque fournie avec MinGW.
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 int list(char *directory, size_t sizeDir) { DIR *dir = NULL; int err; struct dirent *file = NULL; struct stat infos; char cwd[32] = ""; if ((dir = opendir(directory)) == NULL) { return EXIT_FAILURE; } printf("FOLDER %s:\n", directory); /* -tc- on memorise le repertoire courant de travail */ if (getcwd(cwd, sizeof cwd) == NULL) { /* -tc- gestion des erreurs a ameliorer */ return EXIT_FAILURE; } /* -tc- on change le repertoire de travail courant qui devient directory */ if (chdir(directory) != 0) { /* -tc- idem: a ameliorer */ return EXIT_FAILURE; } while ((file = readdir(dir)) != NULL) { /* -tc- ici, tu appelais deux fois stat() */ err = stat(file->d_name, &infos); if (strcmp(file->d_name, ".") && strcmp(file->d_name, "..")) { if (err == 0) { if (S_ISDIR (infos.st_mode)) { printf("\n[FOLDER]\t%s\n", file->d_name); } else { printf("\n[FILE]\t%s\n", file->d_name); } } else { printf ("'%s' IS UNKNOW\n", directory); chdir(cwd); return 1; } } } /* -tc- on retourne dans le repertoire de travail initial */ chdir(cwd); printf("\nEND OF THE FOLDER: %s\n", directory); closedir(dir); (void) sizeDir; return EXIT_SUCCESS; }
Juste une petite remarque au niveau de la gestion des erreurs dans la fonction list. Cette dernière retourne toujours EXIT_FAILURE lorsqu'une erreur intervient. Tu pourrais mettre au point un système un peu plus informatif... Par ailleurs, je suis un adepte de la programmation structurée dont un des principes fondamentaux est d'avoir un seul point de sortie par fonction. C'est une question de goût, je trouve que ça rend le code beaucoup plus facile à lire.

Thierry

18/09/2007, 15h36
Thierry Chappuis

Citation:

Envoyé par Emmanuel Delahaye

C'est pas utile...
... un coup de chdir(".."); et c'est OK.

Il y a sans doute quelque chose qui m'échappe. Pourquoi chdir("..") nous ramènerait dans le cwd initial. Celui-ci n'est pas nécessairement le répertoire parent, puisque directory est n'importe quel répertoire saisi par l'utilisateur. Je me trompe?

Thierry
18/09/2007, 15h51
Emmanuel Delahaye

Citation:

Envoyé par Thierry Chappuis

Il y a sans doute quelque chose qui m'échappe. Pourquoi chdir("..") nous ramènerait dans le cwd initial. Celui-ci n'est pas nécessairement le répertoire parent, puisque directory est n'importe quel répertoire saisi par l'utilisateur. Je me trompe?

Non, c'est moi. Je pensais que tu parlais du parcours de l'arborescence...
18/09/2007, 15h52
Jean-Marc.Bourguet

Citation:

Envoyé par Thierry Chappuis

Il y a sans doute quelque chose qui m'échappe. Pourquoi chdir("..") nous ramènerait dans le cwd initial. Celui-ci n'est pas nécessairement le répertoire parent, puisque directory est n'importe quel répertoire saisi par l'utilisateur. Je me trompe?

De plus, il faut faire attention aux liens symboliques (attention, experimenter avec un shell ne suffit pas: certains implementant cd .. de maniere a bien revenir quand on a suivit un lien symbolique) et ce meme pendant le parcours de l'arborescence.
18/09/2007, 15h58
Thierry Chappuis

Citation:

Envoyé par Jean-Marc.Bourguet

De plus, il faut faire attention aux liens symboliques (attention, experimenter avec un shell ne suffit pas: certains implementant cd .. de maniere a bien revenir quand on a suivit un lien symbolique) et ce meme pendant le parcours de l'arborescence.

Donc, même lors du parcours d'une arborescence, tu conseilles de sauvegarder le chemin du répertoire parent.

Thierry
18/09/2007, 16h17
Jean-Marc.Bourguet

Citation:

Envoyé par Thierry Chappuis

Donc, même lors du parcours d'une arborescence, tu conseilles de sauvegarder le chemin du répertoire parent.

Il faut le faire au moins quand on suit un lien symbolique (pour savoir si une entree est un lien symbolique, il faut utiliser lstat plutot que stat), ca me semble plus simple de le faire toujours.
18/09/2007, 17h57
_SamSoft_

Le problème c'est que je ne souhaite pas parcourir une arboressence. Je m'explique.

Avec ce que je veux faire :

L'utilisateur tape c:\monDoc et il voit :

Citation:

[FOLDER] monDocument1
[FOLDER] monDocument2
[FILE] monFichier1.txt
[FOLDER] monDocument3

Et non pas :

Citation:

[FOLDER] monDocument1
->monFichierX.x
->monFichierY.x
[FOLDER] monDocument2
->monFichierX.x
->monFichierY.txt
[FILE] monFichier1.txt
[FOLDER] monDocument3
->vide

PS: Je lis vos commentaires et je vais essayer de mon modifier mon code
18/09/2007, 18h27
Thierry Chappuis

Citation:

Envoyé par _SamSoft_

Le problème c'est que je ne souhaite pas parcourir une arboressence. Je m'explique.

Ca, je l'ai bien compris, mais les corrections que j'ai apporté à ta fonction list() sont nécessaires pour atteindre le but recherché. En effet, en l'état, lorsque tu lis une entrée de directory avec readdir() et que directory ne correspond pas au répertoire de travail courant, stat(file->d_name, &infos) renvoie toujours la valeur -1 indiquant qu'une erreur s'est produite.

Thierry

Votre code ne marche pas: (c:\dev-cpp me sort rien) :

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <errno.h>
#include <sys/stat.h>
#include "myHeader.h"
int list(char *directory, size_t sizeDir);
 
int main(void)
{
  int end;
  size_t sizeDir;
  char directory[256];
  sizeDir = sizeof directory;
 
 
   do
   {
      printf ("NAME OR <ENTER> FOR EXIT) : ");
      fgets (directory, sizeof directory, stdin); /* we take the path */
      fclean (directory, stdin);
      end = (directory[0] == '\0');
      if (!end)
      {
         list(directory, sizeDir);
      }
   }
   while (!end); //while end[0] != '\0'
   return 0;
}
int list(char *directory, size_t sizeDir)
{
    DIR *dir = NULL;
    int err;
    struct dirent *file = NULL;
    struct stat infos;
    char cwd[32] = "";
 
    if ((dir = opendir(directory)) == NULL)
    {
        return EXIT_FAILURE;
    }
    printf("FOLDER %s:\n", directory);
 
    /* -tc- on memorise le repertoire courant de travail */
    if (getcwd(cwd, sizeof cwd) == NULL)
    {
        /* -tc- gestion des erreurs a ameliorer */
        return EXIT_FAILURE;
    }
    /* -tc- on change le repertoire de travail courant qui devient directory */
    if (chdir(directory) != 0)
    {
        /* -tc- idem: a ameliorer */
        return EXIT_FAILURE;
    }
 
    while ((file = readdir(dir)) != NULL)
    {
        /* -tc- ici, tu appelais deux fois stat() */
        err = stat(file->d_name, &infos);
        if (strcmp(file->d_name, ".") && strcmp(file->d_name, ".."))
        {
            if (err == 0)
            {
                if (S_ISDIR (infos.st_mode))
                {
                    printf("\n[FOLDER]\t%s\n", file->d_name);
                }
                else
                {
                    printf("\n[FILE]\t%s\n", file->d_name);
                }
 
            }
            else
            {
                printf ("'%s' IS UNKNOW\n", directory);
                chdir(cwd);
                return 1;
            }
        }
    }
 
    /* -tc- on retourne dans le repertoire de travail initial */
    chdir(cwd);
    printf("\nEND OF THE FOLDER: %s\n", directory);
 
    closedir(dir);
 
    (void) sizeDir;
 
    return EXIT_SUCCESS;
}

18/09/2007, 19h17
Thierry Chappuis

En ajoutant ce fichier d'en-tête:

Code:

#include <unistd.h>

ça fonctionne parfaitement chez moi. Je n'ai fais que quelques tests.

Thierry

toujours rien -_-

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <errno.h>
#include <sys/stat.h>
#include <unistd.h>
#include "myHeader.h"
int list(char *directory, size_t sizeDir);
 
int main(void)
{
  int end;
  size_t sizeDir;
  char directory[256];
  sizeDir = sizeof directory;
 
 
   do
   {
      printf ("NAME OR <ENTER> FOR EXIT) : ");
      fgets (directory, sizeof directory, stdin); /* we take the path */
      fclean (directory, stdin);
      end = (directory[0] == '\0');
      if (!end)
      {
         list(directory, sizeDir);
      }
   }
   while (!end); //while end[0] != '\0'
   return 0;
}
int list(char *directory, size_t sizeDir)
{
    DIR *dir = NULL;
    int err;
    struct dirent *file = NULL;
    struct stat infos;
    char cwd[32] = "";
 
    if ((dir = opendir(directory)) == NULL)
    {
        return EXIT_FAILURE;
    }
    printf("FOLDER %s:\n", directory);
 
    /* -tc- on memorise le repertoire courant de travail */
    if (getcwd(cwd, sizeof cwd) == NULL)
    {
        /* -tc- gestion des erreurs a ameliorer */
        return EXIT_FAILURE;
    }
    /* -tc- on change le repertoire de travail courant qui devient directory */
    if (chdir(directory) != 0)
    {
        /* -tc- idem: a ameliorer */
        return EXIT_FAILURE;
    }
 
    while ((file = readdir(dir)) != NULL)
    {
        /* -tc- ici, tu appelais deux fois stat() */
        err = stat(file->d_name, &infos);
        if (strcmp(file->d_name, ".") && strcmp(file->d_name, ".."))
        {
            if (err == 0)
            {
                if (S_ISDIR (infos.st_mode))
                {
                    printf("\n[FOLDER]\t%s\n", file->d_name);
                }
                else
                {
                    printf("\n[FILE]\t%s\n", file->d_name);
                }
 
            }
            else
            {
                printf ("'%s' IS UNKNOW\n", directory);
                chdir(cwd);
                return 1;
            }
        }
    }
 
    /* -tc- on retourne dans le repertoire de travail initial */
    chdir(cwd);
    printf("\nEND OF THE FOLDER: %s\n", directory);
 
    closedir(dir);
 
    (void) sizeDir;
 
    return EXIT_SUCCESS;
}

18/09/2007, 19h35
Thierry Chappuis

As-tu essayé avec C:\\dev-cpp (en doublant le caractère '\')? Désolé, je n'ai pas de Windows sous la main pour tester moi-même.

Thierry
18/09/2007, 19h41
_SamSoft_

Citation:

NAME OR <ENTER> FOR EXIT) : c:\\dev-cpp
FOLDER c:\\dev-cpp:
NAME OR <ENTER> FOR EXIT) :

Citation:

NAME OR <ENTER> FOR EXIT) : c:\dev-cpp
FOLDER c:\dev-cpp:
NAME OR <ENTER> FOR EXIT) :
18/09/2007, 20h07
_SamSoft_

Votre méthode ne fonction peut être que sous Linux ?

Quelle est la valeur retournée par la fonction test() ci-dessous???

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
int list(char *directory, size_t sizeDir)
{
    DIR *dir = NULL;
    int err;
    struct dirent *file = NULL;
    struct stat infos;
    char cwd[32] = "";
 
    if ((dir = opendir(directory)) == NULL)
    {
        return 4;
    }
    printf("FOLDER %s:\n", directory);
 
    /* -tc- on memorise le repertoire courant de travail */
    if (getcwd(cwd, sizeof cwd) == NULL)
    {
        /* -tc- gestion des erreurs a ameliorer */
        return 3;
    }
    /* -tc- on change le repertoire de travail courant qui devient directory */
    if (chdir(directory) != 0)
    {
        /* -tc- idem: a ameliorer */
        return 2;
    }
 
    while ((file = readdir(dir)) != NULL)
    {
        /* -tc- ici, tu appelais deux fois stat() */
        err = stat(file->d_name, &infos);
        if (strcmp(file->d_name, ".") && strcmp(file->d_name, ".."))
        {
            if (err == 0)
            {
                if (S_ISDIR (infos.st_mode))
                {
                    printf("\n[FOLDER]\t%s\n", file->d_name);
                }
                else
                {
                    printf("\n[FILE]\t%s\n", file->d_name);
                }
 
            }
            else
            {
                printf ("'%s' IS UNKNOW\n", directory);
                chdir(cwd);
                return 1;
            }
        }
    }
 
    /* -tc- on retourne dans le repertoire de travail initial */
    chdir(cwd);
    printf("\nEND OF THE FOLDER: %s\n", directory);
 
    closedir(dir);
 
    (void) sizeDir;
 
    return 0;
}

Thierry

18/09/2007, 20h09
Emmanuel Delahaye

Citation:

Envoyé par _SamSoft_

Le problème c'est que je ne souhaite pas parcourir une arboressence. Je m'explique.

Enfin ! Depuis le début, je te demande ce que tu veux faire exactement... On ne peut pas le deviner, on est pas dans ta tête...

Alors il faut cesser ces appels récursifs...
18/09/2007, 20h15
_SamSoft_

Thierry : Aucune fonction test

Emmanuel : Je l'ai dis 2 fois :D
18/09/2007, 20h19
Thierry Chappuis

Citation:

Envoyé par _SamSoft_

Thierry : Aucune fonction test

Emmanuel : Je l'ai dis 2 fois :D

Excuse-moi, la fonction list() que j'ai posté ici. A part ça, toutes les fonctions utilisées sont POSIX.1 et sont toutes implantées par MinGW. Il n'y a aucune supposition Linux-spécifique au sein de la fonction list().

Thierry
18/09/2007, 20h20
_SamSoft_

Tout dépend de s'il y a des erreurs où pas, si tout ce passe bien :

return 0;
18/09/2007, 20h24
Thierry Chappuis

Citation:

Envoyé par _SamSoft_

Tout dépend de s'il y a des erreurs où pas, si tout ce passe bien :

return 0;

C'est ce que retourne la fonction list() ou c'est ce que tu penses? L'intérêt de la manipulation est d'identifier où se produit l'erreur. As-tu essayé avec la fonction que j'ai posté ici?

Thierry

Retour : 3

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <errno.h>
#include <sys/stat.h>
#include <unistd.h>
#include "myHeader.h"
int list(char *directory, size_t sizeDir);
 
int main(void)
{
  int end, rslt=0;
  size_t sizeDir;
  char directory[256];
  sizeDir = sizeof directory;
 
 
   do
   {
      printf ("NAME OR <ENTER> FOR EXIT) : ");
      fgets (directory, sizeof directory, stdin); /* we take the path */
      fclean (directory, stdin);
      end = (directory[0] == '\0');
      if (!end)
      {
         rslt = list(directory, sizeDir);
     fprintf(stdout, "%i", rslt);
      }
   }
   while (!end); //while end[0] != '\0'
   return 0;
}
int list(char *directory, size_t sizeDir)
{
    DIR *dir = NULL;
    int err;
    struct dirent *file = NULL;
    struct stat infos;
    char cwd[32] = "";
 
    if ((dir = opendir(directory)) == NULL)
    {
        return 4;
    }
    printf("FOLDER %s:\n", directory);
 
    /* -tc- on memorise le repertoire courant de travail */
    if (getcwd(cwd, sizeof cwd) == NULL)
    {
        /* -tc- gestion des erreurs a ameliorer */
        return 3;
    }
    /* -tc- on change le repertoire de travail courant qui devient directory */
    if (chdir(directory) != 0)
    {
        /* -tc- idem: a ameliorer */
        return 2;
    }
 
    while ((file = readdir(dir)) != NULL)
    {
        /* -tc- ici, tu appelais deux fois stat() */
        err = stat(file->d_name, &infos);
        if (strcmp(file->d_name, ".") && strcmp(file->d_name, ".."))
        {
            if (err == 0)
            {
                if (S_ISDIR (infos.st_mode))
                {
                    printf("\n[FOLDER]\t%s\n", file->d_name);
                }
                else
                {
                    printf("\n[FILE]\t%s\n", file->d_name);
                }
 
            }
            else
            {
                printf ("'%s' IS UNKNOW\n", directory);
                chdir(cwd);
                return 1;
            }
        }
    }
 
    /* -tc- on retourne dans le repertoire de travail initial */
    chdir(cwd);
    printf("\nEND OF THE FOLDER: %s\n", directory);
 
    closedir(dir);
 
    (void) sizeDir;
 
    return 0;
}

Je ne comprend pas à quoi sert :

Code:

1
2
3
4
5
6
7
/* -tc- on memorise le repertoire courant de travail */
    if (getcwd(cwd, sizeof cwd) == NULL)
    {
        /* -tc- gestion des erreurs a ameliorer */
        return 3;
    }

Vu que l'on ne travail que dans directory ?!

18/09/2007, 20h40
Thierry Chappuis

Lorsque tu passes file->d_name à la fonction stat(), elle regarde dans le 'current working directory', et non dans directory...

Thierry
18/09/2007, 20h41
_SamSoft_

Ah ok :) Mais vous dîtes que chez vous ca marche alors pourquoi ca ne marche pas chez moi (sachant que ca compile et que le path est bon -_- )

Le code suivant fonctionne. C'était le tampon cwd qui n'était pas assez grand. En effet, les chemins sous Windows sont souvent plus long que sous Linux. En passant de char cwd[32]; à char cwd[100];, c'est en ordre! (testé sous WinXP)

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <errno.h>
#include <sys/stat.h>
#include <unistd.h>
#include "myHeader.h"
 
int list(char *directory, size_t sizeDir);
 
int main(void)
{
  int end, rslt=0;
  size_t sizeDir;
  char directory[256];
  sizeDir = sizeof directory;
 
 
   do
   {
      printf ("NAME OR <ENTER> FOR EXIT) : ");
      fgets (directory, sizeof directory, stdin); /* we take the path */
      fclean (directory, stdin);
      end = (directory[0] == '\0');
      if (!end)
      {
         rslt = list(directory, sizeDir);
     fprintf(stdout, "rslt = %i", rslt);
      }
   }
   while (!end); //while end[0] != '\0'
   return 0;
}
int list(char *directory, size_t sizeDir)
{
    DIR *dir = NULL;
    int err;
    struct dirent *file = NULL;
    struct stat infos;
    char cwd[100] = "";
 
    if ((dir = opendir(directory)) == NULL)
    {
        return EXIT_FAILURE;
    }
    printf("FOLDER %s:\n", directory);
 
    /* -tc- on memorise le repertoire courant de travail */
    if (getcwd(cwd, sizeof cwd) == NULL)
    {
        /* -tc- gestion des erreurs a ameliorer */
        return EXIT_FAILURE;
    }
    /* -tc- on change le repertoire de travail courant qui devient directory */
    if (chdir(directory) != 0)
    {
        /* -tc- idem: a ameliorer */
        return EXIT_FAILURE;
    }
 
    while ((file = readdir(dir)) != NULL)
    {
        /* -tc- ici, tu appelais deux fois stat() */
        err = stat(file->d_name, &infos);
        if (strcmp(file->d_name, ".") && strcmp(file->d_name, ".."))
        {
            if (err == 0)
            {
                if (S_ISDIR (infos.st_mode))
                {
                    printf("\n[FOLDER]\t%s\n", file->d_name);
                }
                else
                {
                    printf("\n[FILE]\t%s\n", file->d_name);
                }
 
            }
            else
            {
                printf ("'%s' IS UNKNOW\n", directory);
                chdir(cwd);
                return EXIT_FAILURE;
            }
        }
    }
 
    /* -tc- on retourne dans le repertoire de travail initial */
    chdir(cwd);
    printf("\nEND OF THE FOLDER: %s\n", directory);
 
    closedir(dir);
 
    (void) sizeDir;
 
    return EXIT_SUCCESS;
}

Thierry

18/09/2007, 20h55
_SamSoft_

Ca fonction à merveille (merci). Je vais étudier tout cela en détails demain :)

Désolé pour tout ce temps (j'avais une tonne de devoirs -_- ):

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <errno.h>
#include <sys/stat.h>
#include <unistd.h>
#include "myHeader.h"
 
int list(char *directory, size_t sizeDir);
 
int main(void)
{
  int end, error=0;
  size_t sizeDir;
  char directory[256];
  sizeDir = sizeof directory;
 
 
   do
   {
      printf ("Path or <enter> for exit: ");
      fgets (directory, sizeof directory, stdin); /* -sh- we take the path */
      fclean (directory, stdin);
      end = (directory[0] == '\0');
      if (!end)
      {
         error = list(directory, sizeDir);
     switch(error)
     {
     case 0:
         fprintf(stdout, "\nNo Error\n\n");
         break;
     case 1:
         fprintf(stdout, "\n%s is unknown\n\n", directory);
         break;
     case 2:
         fprintf(stdout, "\nInternal error\n\n");
         break;
     case 3:
         fprintf(stdout, "\nInternal error\n\n");
         break;
     case 4:
         fprintf(stdout, "\nError when reading %s\n\n", directory);
         break;
     }
      }
   }
   while (!end); /* while end[0] != '\0' */
   return 0;
}
int list(char *directory, size_t sizeDir)
{
  char cwd[256] = "";
    DIR *dir = NULL;
    int err;
    struct dirent *file = NULL;
    struct stat infos;
 
    if ((dir = opendir(directory)) == NULL)
    {
        return 4;
    }
    printf("FOLDER %s:\n", directory);
 
    /* -tc- we memorise the current working directory */
    if (getcwd(cwd, sizeof cwd) == NULL)
        return 3;
    if (chdir(directory) != 0)
        return 2;
    while ((file = readdir(dir)) != NULL)
    {
        err = stat(file->d_name, &infos);
        if (strcmp(file->d_name, ".") && strcmp(file->d_name, ".."))
        {
            if (err == 0)
            {
                if (S_ISDIR (infos.st_mode))
                {
                    printf("\n[Folder]\t%s\n", file->d_name);
                }
                else
                {
                    printf("\n[File]\t%s\n", file->d_name);
                }
 
            }
            else
            {
                chdir(cwd);
                return 1;
            }
        }
    }
 
    /* -tc- we return the initial repertory */
    chdir(cwd);
    printf("\nEND OF THE FOLDER: %s\n", directory);
 
    closedir(dir);
 
    (void) sizeDir;
 
    return 0;
}

J'ai rajouter des trucs sympas (utiles pour l'utilisateur)

J'ai compris : (dîtes moi si c'est pas ca)

-chdir permet de remplacer current doc par le path fournit en paramètre

Pas compris :

-

Code:

La fonction getcwd() copie le chemin d'accès absolu du répertoire de travail courant dans la chaîne pointée par buf, qui est de longueur size.

(Ca veut dire quoi en gros ?)

-

Code:

if (strcmp(file->d_name, ".") && strcmp(file->d_name, ".."))

Code:

struct dirent *file = NULL;

Où puis-je trouver ce que contient dirent (je sais déjà ce que contient stat) ?

Merci d'avance :)

20/09/2007, 14h39
Emmanuel Delahaye

Citation:

Envoyé par _SamSoft_

Où puis-je trouver ce que contient dirent (je sais déjà ce que contient stat) ?

stat est public (le but est d'avoir des infos). dirent est opaque (sauf d_name). Tu n'auras pas d'infos supplémentaires.

http://www.opengroup.org/onlinepubs/.../dirent.h.html
20/09/2007, 14h41
_SamSoft_

Entendu mais je cherche quels champs contient dirent

Et pour l'autre question ?
20/09/2007, 14h50
Emmanuel Delahaye

Citation:

Envoyé par _SamSoft_

Entendu mais je cherche quels champs contient dirent

Le seul champ connu, documenté et portable est d_name. Est-ce si difficile à comprendre ? Les autres dépendent de l'implémentation, autrement dit le programmeur n'y a pas accès et n'a pas à s'y intéresser.
20/09/2007, 14h57
Médinoc

getcwd() fait l'inverse de chdir() : chdir() permet de forcer le répertoire courant, getcwd() permet de le consulter.
20/09/2007, 14h59
_SamSoft_

J'avais cru ("Ne crois pas, instruis toi", je sais -_- ) que vous parliez d'autre chose. Merci Emmanuel et Medinoc.

Sinon pour ceci ? :

Code:

if (strcmp(file->d_name, ".") && strcmp(file->d_name, ".."))

Citation:

En français : si(nom fichier = ".") et (nom fichier = "..")) alors

Ca n'a pas de sens ?!
20/09/2007, 15h06
Jean-Marc.Bourguet

Citation:

Envoyé par _SamSoft_

J'avais cru ("Ne crois pas, instruis toi", je sais -_- ) que vous parliez d'autre chose. Merci Emmanuel et Medinoc.

Sinon pour ceci ?

La premiere chose a apprendre, c'est a lire les docs. Et la deuxieme a les trouver soi-meme. Poser des questions, c'est bien si on a d'abord essaye de se debrouiller tout seul.

Comme tu n'es pas encore a la deuxieme etape et que tu t'interesses a POSIX: http://www.unix.org/version3. Regarde en particulier "Interface Tables" et "Read the online Single UNIX specification Version 3".

Voir 40 message(s) de cette discussion en une page

Fuseau horaire GMT +2. Il est actuellement 15h27.