IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

Je galere avec l'assignation dynamique de mémoire


Sujet :

C

  1. #1
    Membre à l'essai
    Inscrit en
    Avril 2007
    Messages
    7
    Détails du profil
    Informations forums :
    Inscription : Avril 2007
    Messages : 7
    Par défaut Je galere avec l'assignation dynamique de mémoire
    Salut,

    J'ai créé une fonction récursive qui parcours une arborescence à la recherche d'un certain type de dossier, qui les Zippes quand elle les trouve. J'ai galéré toute l'après midi avec l'assignation de mémoire dynamique pour des tableaux de chaines. J'ai pourtant consulté beaucoup de pages de forums, et j'ai l'impression d'avoir fait ce qu'il fallait. Le code compile, mais l'appli crash au bout de quelques secondes. Je ne vous mets qu'un bout du code...
    Y'a-t'il un pro qui aurait quelques minutes pour m'aider ?

    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
     
    int arbo (char PATH[256])
    {
    ...
    char **SubFolderNames = NULL;
     
    struct dirent *folder;     //|Déclaration de la structure qui contiendra le dossier 
       DIR *rep;               //|
     
       rep = opendir(PATH);     //Ouvre les sous dossiers de rep  
     
     
       while ((folder = readdir(rep)))       //boucle qui traite tous les sous dossiers
       {
       if (i%STEP ==2) {SubFolderNames = realloc (SubFolderNames, (i + STEP) * sizeof (char *));}
       if (i>1)        //si i=0 d_name=. et si i=1 d_name=.. (dans ces cas la procédure ne s'applique pas)
          { 
           SubFolderNames[i]= (char *) malloc (sizeof (folder->d_name));         
           RESULTS[i]=0;     
           strcpy(SubFolderNames[i],folder->d_name);  //On recupère le nom du ième sous dossier dans SubFolderNames
           sprintf(FULLPATH,"%s\\%s",PATH,SubFolderNames[i]);   //On stocke le chemin du sous dossier en cours dans FULLPATH       
     
           if (Project_Or_Not(FULLPATH) )    //Si le sous dossier est un projet 
              {    ....    }
           else           //Si le sous dossier n'est pas un projet
              {
             if (opendir(FULLPATH))                
                 {
                 RESULTS[i]=arbo(FULLPATH);  //appelle de la fontion 
                 }           
             else   {   ...   }
              }
     
          } //fin de if (i>1) 
     
       i++; 
       }//Fin du while qui traite les sous dossiers 
    ...
    }//Fin de la fonction arbo
    Je suis bien sur a votre disposition si vous avez besoin d'éclaircissements ou de voir plus de code.
    Merci d'avance

  2. #2
    Membre éprouvé
    Avatar de granquet
    Profil pro
    Étudiant
    Inscrit en
    Octobre 2005
    Messages
    1 201
    Détails du profil
    Informations personnelles :
    Localisation : France, Pyrénées Orientales (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Octobre 2005
    Messages : 1 201
    Par défaut
    si les fonctions renvoient des choses, c'est une bonne idée de tester ce qu'elles renvoient.

    http://emmanuel-delahaye.developpez....es.htm#realloc

  3. #3
    Rédacteur
    Avatar de Franck.H
    Homme Profil pro
    Développeur .NET
    Inscrit en
    Janvier 2004
    Messages
    6 951
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : France, Haut Rhin (Alsace)

    Informations professionnelles :
    Activité : Développeur .NET
    Secteur : Service public

    Informations forums :
    Inscription : Janvier 2004
    Messages : 6 951
    Par défaut
    Tu as mal alloué l'espace pour la chaîne, il faut faire ceci:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    SubFolderNames[i] = malloc (strlen (folder->d_name) + 1);
     
    if (SubFolderNames[i] != NULL)
    {
       /* Remplissage de la chaine... */
    }
    D'ailleurs le cast sur le retour des allocations dynamique ne sont pas recommandé et même inutiles en C
    Mon Site
    Ma bibliothèque de gestion des chaînes de caractères en C

    L'imagination est plus importante que le savoir. A. Einstein

    Je ne répond à aucune question technique par MP, merci d'avance !

  4. #4
    Expert confirmé

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 610
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 610
    Billets dans le blog
    2
    Par défaut
    [
    Plusieurs choses d'emblée :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
       while ((folder = readdir(rep)) != NULL)       //boucle qui traite tous les sous dossiers
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
           SubFolderNames[i]= (char *) malloc (sizeof (folder->d_name)+1);
    Et il faudrait tester le code de retour avant de faire le strcpy...

    D'autre part es-tu sûr que PATH et FULLPATH soit inférieur à 256 ?

  5. #5
    Membre Expert
    Avatar de Gruik
    Profil pro
    Développeur Web
    Inscrit en
    Juillet 2003
    Messages
    1 566
    Détails du profil
    Informations personnelles :
    Âge : 42
    Localisation : France

    Informations professionnelles :
    Activité : Développeur Web

    Informations forums :
    Inscription : Juillet 2003
    Messages : 1 566
    Par défaut
    Oui, on ne sait pas ce qu'est FULLPATH

  6. #6
    Membre à l'essai
    Inscrit en
    Avril 2007
    Messages
    7
    Détails du profil
    Informations forums :
    Inscription : Avril 2007
    Messages : 7
    Par défaut
    Merci pour vos remarques et suggestions qui m'ont presque toutes toutes servies.
    J'ai même réussit a avoir un code stable pendant un moment en mélangeant des chaines de taille fixe et des chaînes de taille dynamique, mais je me suis dit que j'allais tout passer en dynamique pour le coté fonctionnel d'une part, et pour le coté pédagogique d'autre part.
    Et me voilà donc encore en train d'appeler au secours
    Cette fois-ci je vous mets l'integralité du code de la fonction, j'espère que ça fera pas trop usine a gaz pour vous...
    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
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
     
    int arbo (char *PATH)
    //Cette fonction parcoureras l'arborescence à la recherche de projets et essaiera de zipper les projets qu'elle trouve
    //Prends le chemin du dossier à analyser en paramètre, et renvoie 1 si un projet a été archivé, 0 si aucun projet n'a été trouvé 
    { 
     
    int i=0;
    int j;
    int z=0;
    int u=0;
     
    char * CmdLine= malloc(sizeof(char));   
    char * FULLPATH = malloc(sizeof(char));         //Contiendra le chemin complet du dossier en cours
    int * RESULTS=NULL;     //contiendra une valeur associée a un dossier (RESULTS[i] associé a SubFolderNames[i])                 
    int State;       //Code d'état (zip+rd)
     
    char **SubFolderNames = NULL;  //Contient tous les sous dossiers du dossier en cours 
    char **FoldersNotZipped = NULL;  //Contient les sous dossiers dont la valeur associée est 0
     
    struct dirent * folder;     //|Déclaration de la structure qui contiendra le dossier en cours
       DIR *rep;                
       rep = opendir(PATH);     //Ouvre les sous dossiers de rep  
     
    while ((folder = readdir(rep)))       //boucle qui traite tous les sous dossiers
       {
       if (i%STEP ==2) {SubFolderNames = realloc (SubFolderNames, (i + STEP) * sizeof (char *));} //Assignation mémoire SubFolderNames
       if (i>1)        //si i=0 d_name=. et si i=1 d_name=.. (dans ces cas la procédure ne s'applique pas)
          { 
           RESULTS=realloc(RESULTS, (i+1) * sizeof(int));    //assignation memoire RESULT
           SubFolderNames[i] = malloc (strlen (folder->d_name) + 1); //Assignation mémoire SubFolderNames[i]
     
           if (strlen(FULLPATH) < (strlen(SubFolderNames[i])+strlen(PATH)+1))  //|Assignation de mémoire 
              {                                                                //|pour FULLPATH si plus grand que 
              FULLPATH= realloc (FULLPATH,(strlen(SubFolderNames[i])+ strlen(PATH)+1)*sizeof(char));
              }
          if (SubFolderNames[i] != NULL)                                        
             {
             strcpy(SubFolderNames[i],folder->d_name);  //On recupère le nom du ième sous dossier dans SubFolderNames
             }  
           else {printf("\nNo more memory available\n"); system("pause"); }     
           RESULTS[i]=0;    
           sprintf(FULLPATH,"%s\\%s",PATH,SubFolderNames[i]);   //On stocke le chemin du sous dossier en cours dans FullPATH       
           if (Project_Or_Not(FULLPATH) || !strcmp(SubFolderNames[i],"_Common"))    //Si le sous dossier est un projet ou un dossier Common
              {
              State=Add_Folder (FULLPATH);          //On le zippe
     
              if (State!=0) {fprintf(Log,"%s\n",FULLPATH);State=0;} //si erreur pendant la compression -> log
              else {
                   CmdLine = realloc (CmdLine, (strlen(FULLPATH)+20)* sizeof(char));     //memoire pour CmdLine
                   if (CmdLine!=NULL)
                      {
                      sprintf(CmdLine,"rd /S /Q \"%s\"",FULLPATH);State=system(CmdLine);//suppression du dossier 
                      }
                   else {printf("\nNo more memory available\n"); system("pause"); }
                   }     
              if (State!=0) {fprintf(Log,"%s\n",FULLPATH);}      //Si erreur pendant la supression ->log
     
              RESULTS[i]=1;        
              }
           else
              {
             if (opendir(FULLPATH))                
                 {
                 RESULTS[i]=arbo(FULLPATH); //appelle la fonction sur les sous dossiers
                 }           
              else
                 {
                 RESULTS[i]=0;  
                 }
              }
          } //fin de if (i>1) 
       i++; 
       }//Fin de la boucle qui traite les sous dossiers 
    if (i==1) return 0;//Si le dossier est vide on renvoie 0
     
    //Cette boucle compte les 0 et les 1 renvoyés par l'appel de la fonction sur les sous dossier du dossier en cours
    for (j=2;j<i;j++)
        {
        if (j%STEP ==2) {FoldersNotZipped = realloc (FoldersNotZipped, (j + STEP) * sizeof (char *));}
        if (RESULTS[j]==0) 
           {
           sprintf(FULLPATH,"%s\\%s",PATH,SubFolderNames[j]);   //|On stocke le chemin du sous dossier en cours dans FullPATH  
           FoldersNotZipped[z]=  malloc ((strlen(FULLPATH)+1)* sizeof(char)); 
           if (FoldersNotZipped[z] != NULL)
            {//On stocke les chemins associé a un 0 dans le tableau FoldersNotZipped
             strcpy(FoldersNotZipped[z],FULLPATH); //On recupère le nom du ième sous dossier dans SubFolderNames
            }  
           else {printf("\nNo more memory available\n"); system("pause"); }         
           z++;
           }
        else 
           {
           u++;
           }
        }//fin de for (j=2;j<i;j++)
    //Liberation des mémoires reservées
    free (SubFolderNames);
    free (RESULTS);
    free (PATH);
    //En fonction des valeurs renvoyées par les sous dossiers, on renvoie 1 , 0 ou on renvoie 1 et on log le nom de dossier
    if (u==0) {free(FoldersNotZipped); return 0; }
    if (z==0) {free(FoldersNotZipped);return 1; }
    if (u!=0 && z!=0)
         {      
          for (i=0;i<z;i++)
              {  
               if (opendir(FoldersNotZipped[i])) {fprintf(Log,"%s\n",FoldersNotZipped[i]);}
              ToCheck++;
              }     
          free(FoldersNotZipped);
          return 1;          
         }
     
    }//fin de la fonction arbo

  7. #7
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 69
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par alexinho
    Cette fois-ci je vous mets l'integralité du code de la fonction, j'espère que ça fera pas trop usine a gaz pour vous...
    La version compilable est payante ou quoi ?
    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
     
    Project   : Forums
    Compiler  : GNU GCC Compiler (called directly)
    Directory : C:\dev\forums\
    --------------------------------------------------------------------------------
    Switching to target: default
    Compiling: main.c
    main.c: In function `arbo':
    main.c:12: warning: implicit declaration of function `malloc'
    main.c:14: error: `NULL' undeclared (first use in this function)
    main.c:14: error: (Each undeclared identifier is reported only once
    main.c:14: error: for each function it appears in.)
    main.c:21: error: `DIR' undeclared (first use in this function)
    main.c:21: error: `rep' undeclared (first use in this function)
    main.c:22: warning: implicit declaration of function `opendir'
    main.c:24: warning: implicit declaration of function `readdir'
    main.c:24: warning: assignment makes pointer from integer without a cast
    main.c:26: error: `STEP' undeclared (first use in this function)
    main.c:26: warning: implicit declaration of function `realloc'
    main.c:26: warning: assignment makes pointer from integer without a cast
    main.c:29: warning: assignment makes pointer from integer without a cast
    main.c:30: warning: implicit declaration of function `strlen'
    main.c:30: error: dereferencing pointer to incomplete type
    main.c:34: warning: assignment makes pointer from integer without a cast
    main.c:38: warning: implicit declaration of function `strcpy'
    main.c:38: error: dereferencing pointer to incomplete type
    main.c:40: warning: implicit declaration of function `printf'
    main.c:40: warning: implicit declaration of function `system'
    main.c:42: warning: implicit declaration of function `sprintf'
    main.c:43: warning: implicit declaration of function `Project_Or_Not'
    main.c:43: warning: implicit declaration of function `strcmp'
    main.c:45: warning: implicit declaration of function `Add_Folder'
    main.c:47: warning: implicit declaration of function `fprintf'
    main.c:47: error: `Log' undeclared (first use in this function)
    main.c:49: warning: assignment makes pointer from integer without a cast
    main.c:79: warning: assignment makes pointer from integer without a cast
    main.c:97: warning: implicit declaration of function `free'
    main.c:108: error: `ToCheck' undeclared (first use in this function)
    Process terminated with status 1 (0 minutes, 3 seconds)
    10 errors, 20 warnings
    Faut arréter de nous faire perdre notre temps avec du code incomplet...

  8. #8
    Membre à l'essai
    Inscrit en
    Avril 2007
    Messages
    7
    Détails du profil
    Informations forums :
    Inscription : Avril 2007
    Messages : 7
    Par défaut
    Non bien sur, le reste du code est gratuit, comme l'amabilité du reste!
    Loin de moi l'idée de faire perdre du temps a qui que ce soit, simplement il est écrit dans les règles du forum (et oui il y a des gens qui les lisent ) qu'il faut se limiter dans la quantité de code qu'on met sur le forum.
    Mais puisque quelqu'un d'aussi experimenté que toi sembles assez sympa pour jetter un oeil sur mon travail d'amateur, je ne vais pas me priver :
    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
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include <string.h>
    #include <dirent.h>
    #define STEP 15  
     
     
     
    FILE * Log;                      //Declaration fichier log
    int ToCheck=0;
    int Length=0;
    //---------------------------------------------------------------------------------------------------------------------------\\
    //---------------------------------------------------------------------------------------------------------------------------\\
    //---------------------------------------------------------------------------------------------------------------------------\\
     
    int Project_Or_Not (char *FULLPATH)
    //Cette fonction determine si un dossier est un projet ou pas 
    {
       struct dirent *lecture;     //|Déclaration de la structure qui contiendra le dossier en cours
       DIR *rep;                   //|
       char TEMP[256];           //Chaine temporaire
       rep = opendir(FULLPATH);     //Ouvre les sous dossiers de PATH   
       int sub=0;
     
        while ((lecture = readdir(rep)))         //|
        {                                        //|
        sprintf(TEMP,"%s",lecture->d_name);      //|On lit le nom de chaque sous dossier
        if (!strcmp(TEMP,"From_Cust")) sub++;    //|Si il a un des noms suivant, on incrémente 
        if (!strcmp(TEMP,"To_Cust")) sub++;      //|le compteur "sub".
        if (!strcmp(TEMP,"WORK")) sub++;         //|From_Cust, To_Cust, WORK, Admin
        if (!strcmp(TEMP,"Admin")) sub++;        //|sont des sous dossiers d'un projet
        }                                        //|
     
    if (sub>=2) return 1;
    return 0;
    }
    //---------------------------------------------------------------------------------------------------------------------------\\
    //---------------------------------------------------------------------------------------------------------------------------\\
    //---------------------------------------------------------------------------------------------------------------------------\\
     
    int Copy_wzzip (void)
    //Cette fonction copie l'exe de winzip dans c:\windows\temp, afin de le lancer d'un chemin sans espace (pose des problèmes sinon)
    {
        system ("copy \"C:\\Program Files\\WinZip\\wzzip.exe\" c:\\windows\\temp");    //crée une copie de winzip dans c:\windows\temp
    }
     
    //---------------------------------------------------------------------------------------------------------------------------\\
    //---------------------------------------------------------------------------------------------------------------------------\\
    //---------------------------------------------------------------------------------------------------------------------------\\
     
    int Add_Folder (char * FULLPATH)
    //Cette fonction zippera un dossier dont le chemin 
    {
      int Code;                                    //contiendra le code d'erreur
      int i;
      int j;
      char NAME[strlen(FULLPATH)];                              //Contiendra le nom du projet
      char SHORTPATH[strlen(FULLPATH)];                         //Contient le chemin sans le nom de projet
      char CmdLine[strlen(FULLPATH)+40];                           //Contiendra les Ligne de Commande passées au système
      strcpy(SHORTPATH,FULLPATH);
     
      for (i=(strlen(SHORTPATH)-1);i>=0;i--)       //Cette boucle parcours la chaine a l'envers    
          {
     
          if (SHORTPATH[i]=='\\')         //si on tombe sur un "\" on va remplace
             {
             for (j=i+1;j<=strlen(SHORTPATH);j++)      //Cette boucle extrait le nom de dossier          
                 {
                 NAME[j-(i+1)]=SHORTPATH[j];           //Copie caractère par caractère
                 }
             SHORTPATH[i]='\0';
             i=-1;
             }                             
          } 
     
                                                                                                   //|preparation de la ligne 
    sprintf(CmdLine,"C:\\windows\\temp\\wzzip.exe -r -p -whs -en \"%s\\%s.zip\" \"%s\"",           //|de commande qui lance 
    SHORTPATH,NAME,FULLPATH);                                                                      //|la Compression
     
     
      Code = system (CmdLine);    //on recupere le code d'état renvoyé par la ligne de commande
      //Ajouter la ligne qui efface le dossier
     
      free(SHORTPATH);    //|Liberation de l'espace memoire 
      free (CmdLine);     //|reservé pour les chaines
      free(NAME);         //| 
     
      return Code;        //retourne le code d'état
     
    } 
    //---------------------------------------------------------------------------------------------------------------------------\\
    //---------------------------------------------------------------------------------------------------------------------------\\
    //---------------------------------------------------------------------------------------------------------------------------\\
     
    int arbo (char *PATH)
    //Cette fonction parcoureras l'arborescence à la recherche de projets et essaiera de zipper les projets qu'elle trouve
    //Prends le chemin du dossier à analyser en paramètre, et renvoie 1 si un projet a été archivé, 0 si aucun projet n'a été trouvé 
    { 
     
    int i=0;
    int j;
    int z=0;
    int u=0;
     
    char * CmdLine= malloc(sizeof(char));   
    char * FULLPATH = malloc(sizeof(char));         //Contiendra le chemin complet du dossier en cours
    int * RESULTS=NULL;     //contiendra une valeur associée a un dossier (RESULTS[i] associé a SubFolderNames[i])                 
    int State;       //Code d'état (zip+rd)
     
    char **SubFolderNames = NULL;  //Contient tous les sous dossiers du dossier en cours 
    char **FoldersNotZipped = NULL;  //Contient les sous dossiers dont la valeur associée est 0
     
    struct dirent * folder;     //|Déclaration de la structure qui contiendra le dossier en cours
       DIR *rep;                
       rep = opendir(PATH);     //Ouvre les sous dossiers de rep  
     
    while ((folder = readdir(rep)))       //boucle qui traite tous les sous dossiers
       {
       if (i%STEP ==2) {SubFolderNames = realloc (SubFolderNames, (i + STEP) * sizeof (char *));} //Assignation mémoire SubFolderNames
       if (i>1)        //si i=0 d_name=. et si i=1 d_name=.. (dans ces cas la procédure ne s'applique pas)
          { 
           RESULTS=realloc(RESULTS, (i+1) * sizeof(int));    //assignation memoire RESULT
           SubFolderNames[i] = malloc (strlen (folder->d_name) + 1); //Assignation mémoire SubFolderNames[i]
     
           if (strlen(FULLPATH) < (strlen(SubFolderNames[i])+strlen(PATH)+1))  //|Assignation de mémoire 
              {                                                                //|pour FULLPATH si plus grand que 
              FULLPATH= realloc (FULLPATH,(strlen(SubFolderNames[i])+ strlen(PATH)+1)*sizeof(char));
              }
          if (SubFolderNames[i] != NULL)                                        
             {
             strcpy(SubFolderNames[i],folder->d_name);  //On recupère le nom du ième sous dossier dans SubFolderNames
             }  
           else {printf("\nNo more memory available\n"); system("pause"); }     
           RESULTS[i]=0;    
           sprintf(FULLPATH,"%s\\%s",PATH,SubFolderNames[i]);   //On stocke le chemin du sous dossier en cours dans FullPATH       
           if (Project_Or_Not(FULLPATH) || !strcmp(SubFolderNames[i],"_Common"))    //Si le sous dossier est un projet ou un dossier Common
              {
              State=Add_Folder (FULLPATH);          //On le zippe
     
              if (State!=0) {fprintf(Log,"%s\n",FULLPATH);State=0;} //si erreur pendant la compression -> log
              else {
                   CmdLine = realloc (CmdLine, (strlen(FULLPATH)+20)* sizeof(char));     //memoire pour CmdLine
                   if (CmdLine!=NULL)
                      {
                      sprintf(CmdLine,"rd /S /Q \"%s\"",FULLPATH);State=system(CmdLine);//suppression du dossier 
                      }
                   else {printf("\nNo more memory available\n"); system("pause"); }
                   }     
              if (State!=0) {fprintf(Log,"%s\n",FULLPATH);}      //Si erreur pendant la supression ->log
     
              RESULTS[i]=1;        
              }
           else
              {
             if (opendir(FULLPATH))                
                 {
                 RESULTS[i]=arbo(FULLPATH); //appelle la fonction sur les sous dossiers
                 }           
              else
                 {
                 RESULTS[i]=0;  
                 }
              }
          } //fin de if (i>1) 
       i++; 
       }//Fin de la boucle qui traite les sous dossiers 
    if (i==1) return 0;//Si le dossier est vide on renvoie 0
     
    //Cette boucle compte les 0 et les 1 renvoyés par l'appel de la fonction sur les sous dossier du dossier en cours
    for (j=2;j<i;j++)
        {
        if (j%STEP ==2) {FoldersNotZipped = realloc (FoldersNotZipped, (j + STEP) * sizeof (char *));}
        if (RESULTS[j]==0) 
           {
           sprintf(FULLPATH,"%s\\%s",PATH,SubFolderNames[j]);   //|On stocke le chemin du sous dossier en cours dans FullPATH  
           FoldersNotZipped[z]=  malloc ((strlen(FULLPATH)+1)* sizeof(char)); 
           if (FoldersNotZipped[z] != NULL)
            {//On stocke les chemins associé a un 0 dans le tableau FoldersNotZipped
             strcpy(FoldersNotZipped[z],FULLPATH); //On recupère le nom du ième sous dossier dans SubFolderNames
            }  
           else {printf("\nNo more memory available\n"); system("pause"); }         
           z++;
           }
        else 
           {
           u++;
           }
        }//fin de for (j=2;j<i;j++)
    //Liberation des mémoires reservées
    free (SubFolderNames);
    free (RESULTS);
    free (PATH);
    //En fonction des valeurs renvoyées par les sous dossiers, on renvoie 1 , 0 ou on renvoie 1 et on log le nom de dossier
    if (u==0) {free(FoldersNotZipped); return 0; }
    if (z==0) {free(FoldersNotZipped);return 1; }
    if (u!=0 && z!=0)
         {      
          for (i=0;i<z;i++)
              {  
               if (opendir(FoldersNotZipped[i])) {fprintf(Log,"%s\n",FoldersNotZipped[i]);}
              ToCheck++;
              }     
          free(FoldersNotZipped);
          return 1;          
         }
     
    }//fin de la fonction arbo
     
    //---------------------------------------------------------------------------------------------------------------------------\\
    //---------------------------------------------------------------------------------------------------------------------------\\
    //---------------------------------------------------------------------------------------------------------------------------\\
     
     
    int main (int argc, char *argv[])
    {
    char CmdLine[256];
     
    clock_t
      temps_initial, /* Temps initial en micro-secondes */
      temps_final;   /* Temps final en micro-secondes */
     
    float
      temps_cpu;    /* Temps total en micro-secondes */   
     
    Log = fopen("c:\\windows\\temp\\log.txt", "w+");                 //| 
                                                                     //| 
       if (Log == NULL) {                                            //| Ouverture du  fichier de logs
    		fprintf(stderr,"The Log file could not be created");     //| 
    		system("pause");exit(-1);                                //| 
    	}   
      Copy_wzzip();   //crée une copie de wzzip (sans espace dans le chemin)
     
      temps_initial = clock ();  //Prends l'heure de départ
     
      arbo(argv[1]);  //appelle la fonction qui parcours l'arborescence
     
      fclose(Log);	//Ferme le fichier de logs
      temps_final = clock ();    //Prends l'heure de fin	
     
      temps_cpu = (temps_final - temps_initial) * 1e-3;  //calcule le temps ecoulé et le convertit en secondes
     
      printf("\ntemps : %.2f\n",temps_cpu);  	
     
      system ("del c:\\windows\\temp\\wzzip.exe");
      if (ToCheck!=0){ sprintf(CmdLine,"Move \"c:\\windows\\temp\\log.txt\" \"%%USERPROFILE%%\\DESKTOP\\\""); system(CmdLine);}
     
      system("PAUSE");
     
      return 0;
     
    }
    Ah oui, je n'ai pas précisé mais ce code doit tourner sous windows, la compatibilité n'est donc pas une priorité.
    J'utilises DEVC++ pour compiler.
    Les prerequis pour l'utilisation du tool sont
    -Winzip Pro 10 ou 11
    -Winzip Command Line 2

    Merci d'avance

  9. #9
    Membre éprouvé
    Avatar de granquet
    Profil pro
    Étudiant
    Inscrit en
    Octobre 2005
    Messages
    1 201
    Détails du profil
    Informations personnelles :
    Localisation : France, Pyrénées Orientales (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Octobre 2005
    Messages : 1 201
    Par défaut
    quantitée de code limitée ne veux pas dire code non compilable

  10. #10
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 69
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par alexinho
    <...>jetter un oeil sur mon travail d'amateur, je ne vais pas me priver :
    Pas mal de choses à mettre au point avant de continer :
    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
     
    Project   : Forums
    Compiler  : GNU GCC Compiler (called directly)
    Directory : C:\dev\forums\
    --------------------------------------------------------------------------------
    Switching to target: default
    Compiling: main.c
    main.c:14:1: warning: multi-line comment
    main.c:39:1: warning: multi-line comment
    main.c:49:1: warning: multi-line comment
    main.c: In function `Add_Folder':
    main.c:69: warning: comparison between signed and unsigned
    main.c:93:1: warning: multi-line comment
    main.c:211:1: warning: multi-line comment
    main.c: At top level:
    main.c:216: warning: unused parameter 'argc'
    main.c: In function `Copy_wzzip':
    main.c:47: warning: control reaches end of non-void function
    main.c: In function `arbo':
    main.c:209: warning: control reaches end of non-void function
    Linking console executable: console.exe
    Process terminated with status 0 (0 minutes, 7 seconds)
    0 errors, 9 warnings
    Si ton compilateur ne dit rien, il est sans doute mal réglé :

    http://emmanuel-delahaye.developpez....tm#cfg_compilo

    Quelque remarques sur ton code :
    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
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    402
    403
    404
     
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include <string.h>
    #include <dirent.h>
     
    #define STEP 15
     
    /* -ed- des globales, ? */
    FILE *Log;                      /* Declaration fichier log */
    int ToCheck = 0;
    int Length = 0;
     
    /* -ed- les commentaires, c'est bien, mais ils doivent rester lisibles
            et de pas depasser 80 colonnes.
            '//' n'est pas conforme a C 90. */
     
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
     
    /* Cette fonction determine si un dossier est un projet ou pas */
    int Project_Or_Not (char *FULLPATH)
    {
       /* |Déclaration de la structure qui contiendra le dossier en cours */
       struct dirent *lecture;
       DIR *rep;
       /* Chaine temporaire */
       char TEMP[256];
     
       /* Ouvre les sous dossiers de PATH */
       rep = opendir (FULLPATH);
     
    /* -ed- la definition d'une variable apres une fonction
            n'est pas conforme a C90. */
       int sub = 0;
     
       while ((lecture = readdir (rep)))
       {
          /* On lit le nom de chaque sous dossier */
          sprintf (TEMP, "%s", lecture->d_name);
          /* Si il a un des noms suivant, on incrémente le compteur "sub".
             From_Cust, To_Cust, WORK, Admin sont des sous dossiers d'un projet */
          if (!strcmp (TEMP, "From_Cust"))
             sub++;
          if (!strcmp (TEMP, "To_Cust"))
             sub++;
          if (!strcmp (TEMP, "WORK"))
             sub++;
          if (!strcmp (TEMP, "Admin"))
             sub++;
       }
     
       if (sub >= 2)
          return 1;
       return 0;
    }
     
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
     
    /* Cette fonction copie l'exe de winzip dans c:\windows\temp,
       afin de le lancer d'un chemin sans espace (pose des problèmes sinon) */
     
    /* -ed- ne retourne rien : void. */
    void Copy_wzzip (void)
    {
       /* crée une copie de winzip dans c:\windows\temp */
       system ("copy \"C:\\Program Files\\WinZip\\wzzip.exe\" c:\\windows\\temp");
    }
     
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
     
    /* Cette fonction zippera un dossier dont le chemin contiendra
       le code d'erreur */
    int Add_Folder (char *FULLPATH)
    {
       int Code;
       int i;
       int j;
       /* Contiendra le nom du projet */
       char NAME[strlen (FULLPATH)];
       /* Contient le chemin sans le nom de projet */
       char SHORTPATH[strlen (FULLPATH)];
       /* Contiendra les Ligne de Commande passées au système */
       char CmdLine[strlen (FULLPATH) + 40];
     
       /* -ed- qui dit que la taille est suffisante ?
          L'allocation dynamique est plus sure (strdup(),
          par exemple, qui est POSIX.1, donc tres portable) */
       strcpy (SHORTPATH, FULLPATH);
     
       /* -ed- c'est pas une bonne idee de mettre une
          fonction dans une boucle, surtout si
          c'est un invariant. Perte de temps.
     
          Pour faire ce genre de recherche,
          envisager strchr() ou strrchr()...
        */
       /* Cette boucle parcours la chaine a l'envers */
       for (i = (strlen (SHORTPATH) - 1); i >= 0; i--)
       {
          if (SHORTPATH[i] == '\\') /* si on tombe sur un "\" on va remplace */
          {
             for (j = i + 1; j <= strlen (SHORTPATH); j++) /* Cette boucle extrait le nom de dossier */
             {
                NAME[j - (i + 1)] = SHORTPATH[j]; /* Copie caractère par caractère */
             }
             SHORTPATH[i] = '\0';
             i = -1;
          }
       }
     
       /* preparation de la ligne de commande qui lance la Compression */
       sprintf (CmdLine, "C:\\windows\\temp\\wzzip.exe"
                " -r -p -whs -en \"%s\\%s.zip\" \"%s\"",
                SHORTPATH, NAME, FULLPATH);
     
       /* on recupere le code d'état renvoyé par la ligne de commande */
       Code = system (CmdLine);
     
       /* Ajouter la ligne qui efface le dossier */
     
    #if 0
    /* -ed- BUG ! On ne peut libérer que ce qui a ete alloue. */
     
       /* Liberation de l'espace memoire reservé pour les chaines */
       free (SHORTPATH);
       free (CmdLine);
       free (NAME);
    #endif
     
       return Code;                 /* retourne le code d'état */
     
    }
     
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
     
    int arbo (char *PATH)
    /* Cette fonction parcoureras l'arborescence à la recherche de projets
       et essaiera de zipper les projets qu'elle trouve
       Prends le chemin du dossier à analyser en paramètre,
       et renvoie 1 si un projet a été archivé, 0 si aucun projet n'a été trouvé */
    {
     
       int i = 0;
       int j;
       int z = 0;
       int u = 0;
     
    /* -ed- sizeof(char) vaut 1 par definition.
            Pourquoi allouer 1 caractere ?
            Autant laisser NULL. */
       char *CmdLine = malloc (sizeof (char));
       /* Contiendra le chemin complet du dossier en cours */
       char *FULLPATH = malloc (sizeof (char));
       /* contiendra une valeur associée a un dossier
          (RESULTS[i] associé a SubFolderNames[i]) */
       int *RESULTS = NULL;
       int State;                   /* Code d'état (zip+rd) */
     
       /* Contient tous les sous dossiers du dossier en cours */
       char **SubFolderNames = NULL;
       /* Contient les sous dossiers dont la valeur associée est 0 */
       char **FoldersNotZipped = NULL;
     
       /* Déclaration de la structure qui contiendra le dossier en cours */
       struct dirent *folder;
       DIR *rep;
       rep = opendir (PATH);        /* Ouvre les sous dossiers de rep */
     
       /* boucle qui traite tous les sous dossiers */
       while ((folder = readdir (rep)))
       {
          if (i % STEP == 2)
          {
             /* Assignation mémoire SubFolderNames */
             SubFolderNames =
                realloc (SubFolderNames, (i + STEP) * sizeof (char *));
          }
          if (i > 1)                /* si i=0 d_name=. et si i=1 d_name=.. (dans ces cas la procédure ne s'applique pas) */
          {
             /* assignation memoire RESULT */
             RESULTS = realloc (RESULTS, (i + 1) * sizeof (int));
             /* Assignation mémoire SubFolderNames[i] */
             SubFolderNames[i] = malloc (strlen (folder->d_name) + 1);
     
             /* Assignation de mémoire pour FULLPATH si plus grand que */
             if (strlen (FULLPATH) <
                 (strlen (SubFolderNames[i]) + strlen (PATH) + 1))
             {
                FULLPATH =
                   realloc (FULLPATH,
                            (strlen (SubFolderNames[i]) + strlen (PATH) +
                             1) * sizeof (char));
             }
             if (SubFolderNames[i] != NULL)
             {
                /* On recupère le nom du ième sous dossier dans SubFolderNames */
                strcpy (SubFolderNames[i], folder->d_name);
             }
             else
             {
                printf ("\nNo more memory available\n");
                system ("pause");
             }
             RESULTS[i] = 0;
             /* On stocke le chemin du sous dossier en cours dans FullPATH */
             sprintf (FULLPATH, "%s\\%s", PATH, SubFolderNames[i]);
     
             /* Si le sous dossier est un projet ou un dossier Common */
             if (Project_Or_Not (FULLPATH)
                 || !strcmp (SubFolderNames[i], "_Common"))
             {
                State = Add_Folder (FULLPATH); /* On le zippe */
     
                if (State != 0)
                {
                   fprintf (Log, "%s\n", FULLPATH);
                   State = 0;
                }                   /* si erreur pendant la compression -> log */
                else
                {
                   /* memoire pour CmdLine */
                   CmdLine =
                      realloc (CmdLine, (strlen (FULLPATH) + 20) * sizeof (char));
                   if (CmdLine != NULL)
                   {
                      sprintf (CmdLine, "rd /S /Q \"%s\"", FULLPATH);
                      State = system (CmdLine); /* suppression du dossier */
                   }
                   else
                   {
                      printf ("\nNo more memory available\n");
                      system ("pause");
                   }
                }
                if (State != 0)
                {
                   fprintf (Log, "%s\n", FULLPATH);
                }                   /* Si erreur pendant la supression ->log */
     
                RESULTS[i] = 1;
             }
             else
             {
                if (opendir (FULLPATH))
                {
                   /* appelle la fonction sur les sous dossiers */
                   RESULTS[i] = arbo (FULLPATH);
                }
                else
                {
                   RESULTS[i] = 0;
                }
             }
          }                         /* fin de if (i>1) */
          i++;
       }                            /* Fin de la boucle qui traite les sous dossiers */
       if (i == 1)
          return 0;                 /* Si le dossier est vide on renvoie 0 */
     
       /* Cette boucle compte les 0 et les 1 renvoyés par
          l'appel de la fonction sur les sous dossier du
          dossier en cours */
       for (j = 2; j < i; j++)
       {
          if (j % STEP == 2)
          {
             FoldersNotZipped =
                realloc (FoldersNotZipped, (j + STEP) * sizeof (char *));
          }
          if (RESULTS[j] == 0)
          {
             /* On stocke le chemin du sous dossier en cours dans FullPATH */
             sprintf (FULLPATH, "%s\\%s", PATH, SubFolderNames[j]);
             FoldersNotZipped[z] =
                malloc ((strlen (FULLPATH) + 1) * sizeof (char));
             if (FoldersNotZipped[z] != NULL)
             {
                /* On stocke les chemins associé a un 0 dans le
                   tableau FoldersNotZipped
                   On recupère le nom du ième sous dossier dans SubFolderNames */
                strcpy (FoldersNotZipped[z], FULLPATH);
             }
             else
             {
                printf ("\nNo more memory available\n");
                system ("pause");
             }
             z++;
          }
          else
          {
             u++;
          }
       }                            /* fin de for (j=2;j<i;j++) */
    /* Liberation des mémoires reservées */
       free (SubFolderNames);
       free (RESULTS);
       free (PATH);
    /* En fonction des valeurs renvoyées par les sous dossiers,
       on renvoie 1 , 0 ou on renvoie 1 et on log le nom de dossier */
       if (u == 0)
       {
          free (FoldersNotZipped);
          return 0;
       }
       if (z == 0)
       {
          free (FoldersNotZipped);
          return 1;
       }
       if (u != 0 && z != 0)
       {
          for (i = 0; i < z; i++)
          {
             if (opendir (FoldersNotZipped[i]))
             {
                fprintf (Log, "%s\n", FoldersNotZipped[i]);
             }
             ToCheck++;
          }
          free (FoldersNotZipped);
          return 1;
       }
     
    /* -ed- DANGER ! Fonction douteuse.
            Il y a possibilite de quitter cette fonction
            recursive sans retourner une valeur valide.
     
            Risque de comportement indefini.
     
            D'une maniere generale, les returns multiples
            sont un risque pour le programme et nuisent à
            la lecture et à la qualité du code. */
     
    }
     
    /* fin de la fonction arbo */
     
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
     
    int main (int argc, char *argv[])
    {
       /* --ed- argc n'est pas utilise,
          ce qui signifie que le nombre de parametres
          n'est pas controle. Il y a un risque important
          de comportement indéfini */
     
       char CmdLine[256];
     
       clock_t temps_initial,       /* Temps initial en micro-secondes */
         temps_final;               /* Temps final en micro-secondes */
     
       /* -ed- pourquoi float alors que le calcul se fait en double ? */
       float temps_cpu;             /* Temps total en micro-secondes */
     
       Log = fopen ("c:\\windows\\temp\\log.txt", "w+"); /* | */
       /* | */
       if (Log == NULL)
       {                            /* | Ouverture du  fichier de logs */
          fprintf (stderr, "The Log file could not be created"); /* | */
          system ("pause");
          exit (-1);                /* | */
       }
       Copy_wzzip ();               /* crée une copie de wzzip (sans espace dans le chemin) */
     
       temps_initial = clock ();    /* Prends l'heure de départ */
     
       arbo (argv[1]);              /* appelle la fonction qui parcours l'arborescence */
     
       fclose (Log);                /* Ferme le fichier de logs */
       temps_final = clock ();      /* Prends l'heure de fin */
     
       /* -ed- Les calculs de temps doivent etre faits
          avec CLOCKS_PER_SEC et non une constante
          tiree d'un chapeau... */
       /* calcule le temps ecoulé et le convertit en secondes */
       temps_cpu = (temps_final - temps_initial) * 1e-3;
     
       printf ("\ntemps : %.2f\n", temps_cpu);
     
       system ("del c:\\windows\\temp\\wzzip.exe");
       if (ToCheck != 0)
       {
          sprintf (CmdLine,
                   "Move \"c:\\windows\\temp\\log.txt\" \"%%USERPROFILE%%\\DESKTOP\\\"");
          system (CmdLine);
       }
     
       system ("PAUSE");
     
       return 0;
    }

  11. #11
    Membre à l'essai
    Inscrit en
    Avril 2007
    Messages
    7
    Détails du profil
    Informations forums :
    Inscription : Avril 2007
    Messages : 7
    Par défaut
    Merci beaucoup pour tes conseils, je vais essayer d'améliorer le code en revoyant tout ça. Je te donnerais des nouvelles

  12. #12
    Membre à l'essai
    Inscrit en
    Avril 2007
    Messages
    7
    Détails du profil
    Informations forums :
    Inscription : Avril 2007
    Messages : 7
    Par défaut
    j'ai fait de mon mieux pour améliorer les choses, mais ça bug toujours!
    Tu peux jetter un oeil?
    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
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    402
    403
    404
    405
    406
    407
    408
    409
    410
    411
    412
    413
    414
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include <string.h>
    #include <dirent.h>
     
    #define STEP 15
     
    /* -ed- des globales, ? */
    /* -Al- c'est problèmatique ?*/
     
    FILE *Log;                      /* Declaration fichier log */
     
     
    /* -ed- les commentaires, c'est bien, mais ils doivent rester lisibles
            et de pas depasser 80 colonnes.
            '//' n'est pas conforme a C 90. */
    /* -Al- Merci pour ton travail de mise en page :) */  
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
     
    /* Cette fonction determine si un dossier est un projet ou pas */
    int Project_Or_Not (char *FULLPATH)
    {
       /* Déclaration de la structure qui contiendra le dossier en cours */
       struct dirent *lecture;
       DIR *rep;
       /* Chaine temporaire */
       char TEMP[256];
       int sub = 0;
       /* Ouvre les sous dossiers de PATH */
       rep = opendir (FULLPATH);
    /* -ed- la definition d'une variable apres une fonction
            n'est pas conforme a C90. */
    /* -Al- Mis à jour */        
     
     
       while ((lecture = readdir (rep)))
       {
          /* On lit le nom de chaque sous dossier */
          sprintf (TEMP, "%s", lecture->d_name);
          /* Si il a un des noms suivant, on incrémente le compteur "sub".
             From_Cust, To_Cust, WORK, Admin sont des sous dossiers d'un projet */
          if (!strcmp (TEMP, "From_Cust"))
             sub++;
          if (!strcmp (TEMP, "To_Cust"))
             sub++;
          if (!strcmp (TEMP, "WORK"))
             sub++;
          if (!strcmp (TEMP, "Admin"))
             sub++;
       }
     
       if (sub >= 2)  /*si il y a au moins 2 de ces sous dossiers*/
          return 1;
       return 0;     /*retourne 0 sinon*/
    }
     
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
     
    /* Cette fonction copie l'exe de winzip dans c:\windows\temp,
       afin de le lancer d'un chemin sans espace (pose des problèmes sinon) */
     
    /* -ed- ne retourne rien : void. */
    void Copy_wzzip (void)
    {
       /* crée une copie de winzip dans c:\windows\temp */
       system ("copy \"C:\\Program Files\\WinZip\\wzzip.exe\" c:\\windows\\temp");
    }
     
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
     
    /* Cette fonction zippera un dossier dont le chemin contiendra
       le code d'erreur */
    int Add_Folder (char *FULLPATH)
    {
       int Code;
       int i;
       int j;
       int l;
       /* Contiendra le nom du projet */
       char NAME[256];
       /* Contient le chemin sans le nom de projet */
       char *SHORTPATH = NULL;
       /* Contiendra les Ligne de Commande passées au système */
       char *CmdLine;
     
       /* -ed- qui dit que la taille est suffisante ?
          L'allocation dynamique est plus sure (strdup(),
          par exemple, qui est POSIX.1, donc tres portable) */ 
       /* -Al- Mis à jour */
       SHORTPATH=strdup(FULLPATH);
     
       /* -ed-  c'est pas une bonne idee de mettre une
          fonction dans une boucle, surtout si
          c'est un invariant. Perte de temps.
          
          Pour faire ce genre de recherche,
          envisager strchr() ou strrchr()...
        */
       /* -Al- Je ne connaissais pas ces fontions, elles m'ont l'air plutôt utile 
          effectivement, j'essaierais de changer ça quand j'aurais un code qui 
          fonctionne. 
          J'ai corrigé le problème du strlen appelé en boucle, effectivement c'est
          une perte de temps */
     
       /* Cette boucle parcours la chaine a l'envers */
       l=strlen (SHORTPATH);
       for (i = (l - 1); i >= 0; i--)
       {
          if (SHORTPATH[i] == '\\') /* si on tombe sur un "\" on va remplace par \0*/
          {
             /* Cette boucle extrait le nom de dossier */
             for (j = i + 1; j <= l; j++) 
             {
                NAME[j - (i + 1)] = SHORTPATH[j]; /* Copie caractère par caractère */
             }
             SHORTPATH[i] = '\0';
             i = -1;
          }
       }
       CmdLine = malloc ((strlen(FULLPATH)+strlen(SHORTPATH)+80)*sizeof(char));
       /* preparation de la ligne de commande qui lance la Compression */
       sprintf (CmdLine, "C:\\windows\\temp\\wzzip.exe"
                " -r -p -whs -en \"%s\\%s.zip\" \"%s\"",
                SHORTPATH, NAME, FULLPATH);
     
       /* on recupere le code d'état renvoyé par la ligne de commande */
       Code = system (CmdLine);
     
       /* Ajouter la ligne qui efface le dossier */
     
     
     
    /* -ed- BUG ! On ne peut libérer que ce qui a ete alloue. */
    /* -Al- Mis à jour */ 
       /* Liberation de l'espace memoire reservé pour les chaines */
       if(SHORTPATH != NULL) free (SHORTPATH);
       if(CmdLine != NULL) free (CmdLine);
       if (NAME != NULL) free (NAME);
     
       return Code;                 /* retourne le code d'état */
     
    }
     
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
     
    int arbo (char *PATH)
    /* Cette fonction parcoureras l'arborescence à la recherche de projets
       et essaiera de zipper les projets qu'elle trouve
       Prends le chemin du dossier à analyser en paramètre,
       et renvoie 1 si un projet a été archivé, 0 si aucun projet n'a été trouvé */
    {
     
       int i = 0;
       int j;
       int z = 0;
       int u = 0;
     
       /* -ed- sizeof(char) vaut 1 par definition.
            Pourquoi allouer 1 caractere ?
            Autant laisser NULL. */
       /* -Al- Mis à jour*/     
       char *CmdLine = NULL;
       /* Contiendra le chemin complet du dossier en cours */
       char *FULLPATH = NULL;
       /* contiendra une valeur associée a un sous dossier
          (RESULTS[i] associé a SubFolderNames[i]) */
       int *RESULTS = NULL;
       int State;           /* Code d'état (zip+rd) */
     
       /* Contient tous les sous dossiers du dossier en cours */
       char **SubFolderNames = NULL;
       /* Contient les sous dossiers dont la valeur associée est 0 */
       char **FoldersNotZipped = NULL;
     
       /* Déclaration de la structure qui contiendra le dossier en cours */
       struct dirent *folder;
       DIR *rep;
       rep = opendir (PATH);        /* Ouvre les sous dossiers de rep */
     
       /* boucle qui traite tous les sous dossiers */
       while ((folder = readdir (rep)))
       {
          if (i % STEP == 2)
          {
             /* Assignation mémoire SubFolderNames */
             SubFolderNames =
                realloc (SubFolderNames, (i + STEP) * sizeof (char *));
          }
          if (i > 1)      
          /* si i=0 d_name=. et si i=1 d_name=.. (la procédure ne s'applique pas) */
          {
             /* assignation memoire RESULT */
             RESULTS = realloc (RESULTS, (i + 1) * sizeof (int));
             /* Assignation mémoire SubFolderNames[i] */
             SubFolderNames[i] = malloc (strlen (folder->d_name) + 1);
     
             /* Assignation de mémoire pour FULLPATH si plus grand que */
             if (strlen (FULLPATH) <
                 (strlen (SubFolderNames[i]) + strlen (PATH) + 1))
             {
                FULLPATH =
                   realloc (FULLPATH,
                            (strlen (SubFolderNames[i]) + strlen (PATH) +
                             1) * sizeof (char));
             }
             if (SubFolderNames[i] != NULL)
             {
                /* On recupère le nom du ième sous dossier dans SubFolderNames */
                strcpy (SubFolderNames[i], folder->d_name);
             }
             else
             {
                printf ("\nNo more memory available\n");
                system ("pause");
                exit (-1);
             }
             RESULTS[i] = 0;
             /* On stocke le chemin du sous dossier en cours dans FullPATH */
             sprintf (FULLPATH, "%s\\%s", PATH, SubFolderNames[i]);
     
             /* Si le sous dossier est un projet ou un dossier Common */
             if (Project_Or_Not (FULLPATH)
                 || !strcmp (SubFolderNames[i], "_Common"))
             {
                State = Add_Folder (FULLPATH); /* On le zippe */
     
                if (State != 0)
                {
                   fprintf (Log, "%s\n", FULLPATH);
                   State = 0;
                }                   /* si erreur pendant la compression -> log */
                else
                {
                   /* memoire pour CmdLine */
                   CmdLine =
                      realloc (CmdLine, (strlen (FULLPATH) + 20) * sizeof (char));
                   if (CmdLine != NULL)
                   {
                      sprintf (CmdLine, "rd /S /Q \"%s\"", FULLPATH);
                      State = system (CmdLine); /* suppression du dossier */
                   }
                   else
                   {
                      printf ("\nNo more memory available\n");
                      system ("pause");
                      exit (-1);
                   }
                }
                if (State != 0)
                {
                   fprintf (Log, "%s\n", FULLPATH);
                }                   /* Si erreur pendant la supression ->log */
     
                RESULTS[i] = 1;
             }
             else
             {
                if (opendir (FULLPATH))
                {
                   /* appelle la fonction sur les sous dossiers */
                   RESULTS[i] = arbo (FULLPATH);
                }
                else
                {
                   RESULTS[i] = 0;
                }
             }
          }                         /* fin de if (i>1) */
          i++;
       }                          /* Fin de la boucle qui traite les sous dossiers*/
     
       /* Cette boucle compte les 0 et les 1 renvoyés par
          l'appel de la fonction sur les sous dossier du
          dossier en cours */
       for (j = 2; j < i; j++)
       {
          if (j % STEP == 2)
          {
             FoldersNotZipped =
                realloc (FoldersNotZipped, (j + STEP) * sizeof (char *));
          }
          if (RESULTS[j] == 0)
          {
             /* On stocke le chemin du sous dossier en cours dans FullPATH */
             sprintf (FULLPATH, "%s\\%s", PATH, SubFolderNames[j]);
             FoldersNotZipped[z] =
                malloc ((strlen (FULLPATH) + 1) * sizeof (char));
             if (FoldersNotZipped[z] != NULL)
             {
                /* On stocke les chemins associé a un 0 dans le
                   tableau FoldersNotZipped
                   On recupère le nom du ième sous dossier dans SubFolderNames */
                strcpy (FoldersNotZipped[z], FULLPATH);
             }
             else
             {
                printf ("\nNo more memory available\n");
                system ("pause");
                exit (-1);
             }
             z++;
          }
          else
          {
             u++;
          }
       }             /* fin de for (j=2;j<i;j++) */
    /* Liberation des mémoires reservées */
      free (SubFolderNames);
      free (RESULTS);
     
    /* En fonction des valeurs renvoyées par les sous dossiers,
       on renvoie 1 , 0 ou on renvoie 1 et on log le nom de dossier */
       if (u == 0)
       {
          free (FoldersNotZipped);
          return 0;
       }
     
       for (i = 0; i < z; i++)
        {
         if (opendir (FoldersNotZipped[i]))
         {
            fprintf (Log, "%s\n", FoldersNotZipped[i]);
         }
     
        }
        free (FoldersNotZipped);
        return 1;
     
    }
     /* -ed- DANGER ! Fonction douteuse.
            Il y a possibilite de quitter cette fonction
            recursive sans retourner une valeur valide.
     
            Risque de comportement indefini.
     
            D'une maniere generale, les returns multiples
            sont un risque pour le programme et nuisent à
            la lecture et à la qualité du code. */
     /* -Al- Mis à jour : Est-ce suffisemment simplifié?*/ 
     
    /* fin de la fonction arbo */
     
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
     
    int main (int argc, char *argv[])
    {
       /* --ed- argc n'est pas utilise,
          ce qui signifie que le nombre de parametres
          n'est pas controle. Il y a un risque important
          de comportement indéfini */
       /* -Al- Mis à jour */   
       char CmdLine[256];
     
       clock_t temps_initial,       /* Temps initial en micro-secondes */
         temps_final;               /* Temps final en micro-secondes */
     
       /* -ed- pourquoi float alors que le calcul se fait en double ? */
       /* -Al- Mis à jour */
       double temps_cpu;             /* Temps total en micro-secondes */
     
       Log = fopen ("c:\\windows\\temp\\log.txt", "w+"); 
     
       if (Log == NULL)
       {                            /* Ouverture du  fichier de logs */
          fprintf (stderr, "The Log file could not be created"); 
          system ("pause");
          exit (-1);                
       }
       Copy_wzzip ();     /* crée une copie de wzzip (sans espace dans le chemin) */
     
       temps_initial = clock ();    /* Prends l'heure de départ */
     
       if (argc==2) 
          arbo (argv[1]);       /* appelle la fonction qui parcours l'arborescence*/
       else 
          printf("Please check arguments\n");
     
       fclose (Log);                /* Ferme le fichier de logs */
       temps_final = clock ();      /* Prends l'heure de fin */
    /* -ed- Les calculs de temps doivent etre faits
          avec CLOCKS_PER_SEC et non une constante
          tiree d'un chapeau... */
    /* -Al- Mis à jour */
     
       /* calcule le temps ecoulé et le convertit en secondes */
       temps_cpu = (temps_final - temps_initial) / CLOCKS_PER_SEC;
     
       printf ("\ntemps : %d\n", temps_cpu);
     
       system ("del c:\\windows\\temp\\wzzip.exe");
     
       sprintf (CmdLine,
              "Move \"c:\\windows\\temp\\log.txt\" \"%%USERPROFILE%%\\DESKTOP\\\"");
       system (CmdLine);
     
     
       system ("PAUSE");
     
       return 0;
    }

  13. #13
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 69
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par alexinho
    J'ai toujours le même soucis avec mon code... ça crash
    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
     
     
    /* Cette fonction zippera un dossier dont le chemin contiendra
       le code d'erreur */
    int Add_Folder (char *FULLPATH)
    {
       /* Contiendra le nom du projet */
       char NAME[256];
       /* Contient le chemin sans le nom de projet */
       char *SHORTPATH = NULL;
       /* Contiendra les Ligne de Commande passées au système */
       char CmdLine[strlen (FULLPATH) + 40];
     
       /* -Al- Mis à jour */
       SHORTPATH=strdup(FULLPATH);
     
    /* -ed- BUG ! On ne peut libérer que ce qui a ete alloue. */
    /* -Al- Mis à jour */ 
       /* Liberation de l'espace memoire reservé pour les chaines */
       if(SHORTPATH != NULL) free (SHORTPATH);
       if(CmdLine != NULL) free (CmdLine);
       if (NAME != NULL) free (NAME);
    Tu n'as rien corrigé du tout, ou presque...

    OK, pour SHORTPATH (majuscule, on ne sait pas pourquoi...). strdup() utilise malloc(), donc free. (inutile de faire e test à NULL, free(NULL) est défini et sans danger).

    Mais tu penses sincèrement que CmdLine et NAME ont été alloués par malloc() ?

  14. #14
    Membre à l'essai
    Inscrit en
    Avril 2007
    Messages
    7
    Détails du profil
    Informations forums :
    Inscription : Avril 2007
    Messages : 7
    Par défaut
    Quand tu dis "tu n'a rien corrigé du tout" tu parles de l'ensemble des erreurs que tu m'a signalées ou de celle ci uniquement?

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
     
     
    /* -ed- BUG ! On ne peut libérer que ce qui a ete alloue. */
    /* -Al- Mis à jour */ 
       /* Liberation de l'espace memoire reservé pour les chaines */
       free (SHORTPATH);
     
     
       return Code;                 /* retourne le code d'état */
     
    }

  15. #15
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 69
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par alexinho
    Quand tu dis "tu n'a rien corrigé du tout" tu parles de l'ensemble des erreurs que tu m'a signalées ou de celle ci uniquement?
    Celle-ci uniquement. Oui, j'ai vu que tu avais corrigé le reste.

    Alors, ça plante toujours ?

  16. #16
    Membre à l'essai
    Inscrit en
    Avril 2007
    Messages
    7
    Détails du profil
    Informations forums :
    Inscription : Avril 2007
    Messages : 7
    Par défaut
    J'ai trouvé plusieurs autres problèmes, dont un que je n'arrive pas à comprendre. J'arrive à faire marcher le programme en utilisant une constante pour allouer de la memoire, donc c'est pas vraiment un soucis en soit.
    Pourtant pour le coté pedagogique j'aimerais bien que tu m'explique ce qui ne va pas si tu arrives a comprendre.
    J'ai mis en évidence le problème dans le code (vers la ligne 190):
    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
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include <string.h>
    #include <dirent.h>
     
    #define STEP 15
     
     
     
    FILE *Log;                      /* Declaration fichier log */
    int ToCheck = 0;
     
     
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
     
    /* Cette fonction determine si un dossier est un projet ou pas */
    int ProjectOrNot (char *FullPath)
    {
     
       /* Déclaration de la structure qui contiendra le dossier en cours */
       struct dirent *lecture;
       DIR *rep;
       /* Chaine temporaire */
       char TEMP[256];
       int sub = 0;
       /* Ouvre les sous dossiers de Path */
       rep = opendir (FullPath);
     
       while ((lecture = readdir (rep)))
       {
          /* On lit le nom de chaque sous dossier */
          sprintf (TEMP, "%s", lecture->d_name);
          /* Si il a un des noms suivant, on incrémente le compteur "sub".
             From_Cust, To_Cust, WORK, Admin sont des sous dossiers d'un projet */
          if (!strcmp (TEMP, "From_Cust"))
             sub++;
          if (!strcmp (TEMP, "To_Cust"))
             sub++;
          if (!strcmp (TEMP, "WORK"))
             sub++;
          if (!strcmp (TEMP, "Admin"))
             sub++;
       }
     
       if (sub >= 2)  /*si il y a au moins 2 de ces sous dossiers*/
          return 1;
     
       return 0;     /*retourne 0 sinon*/
    }
     
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
     
    /* Cette fonction copie l'exe de winzip dans c:\windows\temp,
       afin de le lancer d'un chemin sans espace (pose des problèmes sinon) */
     
    void Copy_wzzip (void)
    {
       /* crée une copie de winzip dans c:\windows\temp */
       system ("copy \"C:\\Program Files\\WinZip\\wzzip.exe\" c:\\windows\\temp");
    }
     
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
     
    /* Cette fonction zippera un dossier dont le chemin contiendra
       le code d'erreur */
    int Add_Folder (char *FullPath)
    {
       int Code;
       int i;
       int j;
       int l;
       /* Contiendra le nom du projet */
       char Name[256];
       /* Contient le chemin sans le nom de projet */
       char *ShortPath = NULL;
       /* Contiendra les Ligne de Commande passées au système */
       char *CmdLine = NULL;
     
       ShortPath=strdup(FullPath);
     
       /* Cette boucle parcours la chaine a l'envers */
       l=strlen (ShortPath);
       for (i = (l - 1); i >= 0; i--)
       {
          if (ShortPath[i] == '\\') /* si on tombe sur un "\" on va remplace par \0*/
          {
             /* Cette boucle extrait le nom de dossier */
             for (j = i + 1; j <= l; j++) 
             {
                Name[j - (i + 1)] = ShortPath[j]; /* Copie caractère par caractère */
             }
             ShortPath[i] = '\0';
             i = -1;
          }
       }
       CmdLine = malloc ((strlen(FullPath)+strlen(ShortPath)+strlen(Name)+80)*sizeof(char));
       /* preparation de la ligne de commande qui lance la Compression */
       sprintf (CmdLine, "C:\\windows\\temp\\wzzip.exe"
                " -r -p -whs -en \"%s\\%s.zip\" \"%s\"",
                ShortPath, Name, FullPath);
     
       /* on recupere le code d'état renvoyé par la ligne de commande */
       Code = system (CmdLine);
     
       /* Liberation de l'espace memoire reservé pour les chaines */
       free (ShortPath);
     
       return Code;                 /* retourne le code d'état */
     
    }
     
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
     
    int arbo (char *Path)
    /* Cette fonction parcoureras l'arborescence à la recherche de projets
       et essaiera de zipper les projets qu'elle trouve
       Prends le chemin du dossier à analyser en paramètre,
       et renvoie 1 si un projet a été archivé, 0 si aucun projet n'a été trouvé */
    {
       int a = 0;
       int i = 0;
       int j;
       int z = 0;
       int u = 0;
     
       char *CmdLine = NULL;
       /* Contiendra le chemin complet du dossier en cours */
       /*On assigne une valeur a FullPath sinon strlen(FullPath) plantera par la suite*/
       char *FullPath = malloc(100);  
       /* contiendra une valeur associée a un sous dossier
          (RESULTS[i] associé a SubFolderNames[i]) */
       int *RESULTS = NULL;
       int State;           /* Code d'état (zip+rd) */
     
       /* Contient tous les sous dossiers du dossier en cours */
       char **SubFolderNames = NULL;
       /* Contient les sous dossiers dont la valeur associée est 0 */
       char **FoldersNotZipped = NULL;
     
       /* Déclaration de la structure qui contiendra le dossier en cours */
       struct dirent *folder;
       DIR *rep;
       rep = opendir (Path);        /* Ouvre les sous dossiers de rep */
     
       /*On assigne une valeur a FullPath sinon strlen(FullPath) plantera par la suite*/
       FullPath = malloc(20);  
       /* boucle qui traite tous les sous dossiers */
       while ((folder = readdir (rep)))
       {
          if (i % STEP == 2)
          {
             /* Assignation mémoire SubFolderNames */
             SubFolderNames =
                realloc (SubFolderNames, (i + STEP) * sizeof (char *));
          }
          if (i > 1)      
          /* si i=0 d_name=. et si i=1 d_name=.. (la procédure ne s'applique pas) */
          {
             /* assignation memoire RESULT */
             RESULTS = realloc (RESULTS, (i + 1) * sizeof (int));
             /* Assignation mémoire SubFolderNames[i] */
     
             SubFolderNames[i] = malloc (strlen (folder->d_name) + 1);
             if (SubFolderNames[i] != NULL)
             {
                /* On recupère le nom du ième sous dossier dans SubFolderNames */
                strcpy (SubFolderNames[i], folder->d_name);
             }
             else
             {
                printf ("\nNo more memory available\n");
                system ("pause");
                exit (-1);
             }
            RESULTS[i] = 0;
             /* Assignation de mémoire pour FullPath  */
     
               if (strlen (FullPath) <
                 strlen (SubFolderNames[i]) + strlen("\\")+ strlen (Path) +1)
             {
         /***********************************************************************
         Ce code occasionne un plantage             
                FullPath =
                   realloc (FullPath,
                       strlen (SubFolderNames[i]) + strlen (Path) + strlen("\\")+1);
             
         ***********************************************************************/ 
          /*Ce code tourne*/
                FullPath =
                   realloc (FullPath,1000);
     
         /***********************************************************************/          
             }               
             /* On stocke le chemin du sous dossier en cours dans FullPath */
             sprintf (FullPath, "%s\\%s", Path, SubFolderNames[i]);
     
             /* Si le sous dossier est un projet ou un dossier Common */
             if (opendir (FullPath))
             {
                 a=ProjectOrNot (FullPath);
             }
             if (a!=0
                 || !strcmp (SubFolderNames[i], "_Common"))
             {
                State = Add_Folder (FullPath); /* On le zippe */
     
                if (State != 0)
                {
                   fprintf (Log, "%s\n", FullPath);
                   ToCheck++;
                   State = 0;
                }                   /* si erreur pendant la compression -> log */
                else
                {
                   /* memoire pour CmdLine */
                   CmdLine =
                      realloc (CmdLine, (strlen (FullPath) + 20) * sizeof (char));
                   if (CmdLine != NULL)
                   {
                      sprintf (CmdLine, "rd /S /Q \"%s\"", FullPath);
                      State = system (CmdLine); /* suppression du dossier */
                   }
                   else
                   {
                      printf ("\nNo more memory available\n");
                      system ("pause");
                      exit (-1);
                   }
                }
                if (State != 0)
                {
                   fprintf (Log, "%s\n", FullPath);
                   ToCheck++;
                }                   /* Si erreur pendant la supression ->log */
             RESULTS[i] = 1;
             }
             else
             {
                if (opendir (FullPath))
                {
                   /* appelle la fonction sur les sous dossiers */
                   RESULTS[i] = arbo (FullPath);
                }
                else
                {
                   RESULTS[i] = 0;
                }
             }
          }                         /* fin de if (i>1) */
          i++;
       }                          /* Fin de la boucle qui traite les sous dossiers*/
     
       /* Cette boucle compte les 0 et les 1 renvoyés par
          l'appel de la fonction sur les sous dossier du
          dossier en cours */
       for (j = 2; j < i; j++)
       {
          if (j % STEP == 2)
          {
             FoldersNotZipped =
                realloc (FoldersNotZipped, (j + STEP) * sizeof (char *));
          }
          if (RESULTS[j] == 0)
          {
             /* On stocke le chemin du sous dossier en cours dans FullPath */
             sprintf (FullPath, "%s\\%s", Path, SubFolderNames[j]);
             FoldersNotZipped[z] =
                malloc ((strlen (FullPath) + 1) * sizeof (char));
             if (FoldersNotZipped[z] != NULL)
             {
                /* On stocke les chemins associé a un 0 dans le
                   tableau FoldersNotZipped
                   On recupère le nom du ième sous dossier dans SubFolderNames */
                strcpy (FoldersNotZipped[z], FullPath);
             }
             else
             {
                printf ("\nNo more memory available\n");
                system ("pause");
                exit (-1);
             }
             z++;
          }
          else
          {
             u++;
          }
       }             /* fin de for (j=2;j<i;j++) */
    /* Liberation des mémoires reservées */
      free (SubFolderNames);
      free (RESULTS);
     
    /* En fonction des valeurs renvoyées par les sous dossiers,
       on renvoie 1 , 0 ou on renvoie 1 et on log le nom de dossier */
       if (u == 0)
       {
          free (FoldersNotZipped);
          return 0;
       }
     
       for (i = 0; i < z; i++)
        {
         if (opendir (FoldersNotZipped[i]))
         {
            fprintf (Log, "%s\n", FoldersNotZipped[i]);
            ToCheck++;
         }
     
        }
        free (FoldersNotZipped);
        return 1;
     
    }
     
     
    /* fin de la fonction arbo */
     
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
    /* -------------------------------------------------------------------------- */
     
    int main (int argc, char *argv[])
    {
       char CmdLine[256];
     
       clock_t temps_initial,       /* Temps initial en micro-secondes */
         temps_final;               /* Temps final en micro-secondes */
     
     
       double temps_cpu;             /* Temps total en micro-secondes */
     
       Log = fopen ("c:\\windows\\temp\\log.txt", "w+"); 
     
       if (Log == NULL)
       {                            /* Ouverture du  fichier de logs */
          fprintf (stderr, "The Log file could not be created"); 
          system ("pause");
          exit (-1);                
       }
       Copy_wzzip ();     /* crée une copie de wzzip (sans espace dans le chemin) */
     
       temps_initial = clock ();    /* Prends l'heure de départ */
     
       if (argc==2) 
          arbo (argv[1]);       /* appelle la fonction qui parcours l'arborescence*/
       else 
          printf("Please check arguments\n");
     
       fclose (Log);                /* Ferme le fichier de logs */
       temps_final = clock ();      /* Prends l'heure de fin */
     
     
       /* calcule le temps ecoulé et le convertit en secondes */
       temps_cpu = (temps_final - temps_initial) / CLOCKS_PER_SEC;
     
       printf ("\ntemps : %.2f\n", temps_cpu);
     
       system ("del c:\\windows\\temp\\wzzip.exe");
     
     
       sprintf (CmdLine,
              "Move \"c:\\windows\\temp\\log.txt\" \"%%USERPROFILE%%\\DESKTOP\\\"");
     
       if (ToCheck!=0)
          system (CmdLine);
     
     
       system ("PAUSE");
     
       return 0;
    }
    Question subsidiaire, que penses-tu de cette façon de parcourir l'arborescence? Une fonction recursive etait-elle une solution bien adaptée, ou y en avait-il d'autres meilleures ?

Discussions similaires

  1. Réponses: 6
    Dernier message: 10/11/2005, 08h58
  2. galere avec le port serie...
    Par toto4650 dans le forum MFC
    Réponses: 6
    Dernier message: 09/09/2005, 16h33
  3. [VC++/ASM] Allocation dynamique de mémoire ?
    Par Magus (Dave) dans le forum x86 32-bits / 64-bits
    Réponses: 7
    Dernier message: 21/12/2004, 15h05
  4. Problème avec la RTL dynamique
    Par lamojuli dans le forum C++Builder
    Réponses: 5
    Dernier message: 03/11/2004, 14h45
  5. Allocation dynamique de mémoire en asm
    Par narmataru dans le forum Assembleur
    Réponses: 7
    Dernier message: 17/12/2002, 22h31

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo