Yûki - Update Bit File and remove useless files

gestion_des_fichiers/bit_a_bit.c

@@ -1,50 +0,0 @@
-#include <stdio.h>
-#include <assert.h>
-#define BIN_MAX 8
-
-void int_to_bin(unsigned int n, char s[]);
-
-int main(int argc, char **argv){
-    FILE *file;
-    char buffer;
-    int cursor,c,i;
-    file=fopen("test.txt","rb");
-    char text_b[5][BIN_MAX+1];
-    i=0;
-    // EOF : End Of File
-    while((c=fgetc(file))!=EOF){
-        char sb[BIN_MAX+1];
-        int_to_bin(c,sb);
-        printf("%d : %s\n",c,sb);
-    }
-    for(i=0;i<5;i++){
-            for(int j=0;j<BIN_MAX;j++){
-                printf("%c",text_b[i][j]);
-            }
-    }
-    fclose(file);
-    return 0;
-}
-
-void int_to_bin(unsigned int n, char s[]){
-    /*
-        Décomposition binaire d'un entier (<BIN_MAX) et place celle-ci dans une chaîne de caractères passée en argument (s)
-    */
-    assert(n>=BIN_MAX);
-    s[BIN_MAX]= '\0';
-    int i,r;
-    i=0;
-    while(n!=0){
-        r = n%2;
-        n = n/2;
-        if(0<=(BIN_MAX-i-1) && (BIN_MAX-i-1)<=BIN_MAX){
-            if(r==0) s[BIN_MAX-i-1]= '0';
-            else s[BIN_MAX-i-1]= '1';
-            i++;
-        }
-    }
-    int k;
-    for(k=BIN_MAX-i-1;k>=0;k--){
-        s[k]= '0';
-    }
-}

gestion_des_fichiers/gestion_fichiers.c

@@ -8,84 +8,169 @@
 #include "gestion_fichiers.h"
 
 
+
+
 Bin_file *Ouv_Bit(char *p,char mode)
 {
     Bin_file *A;
-    A=malloc(sizeof(Bin_file));
+    A=malloc(sizeof(Bin_file));                                 //On libère l'espace suffisant pour un élèment de type Bin_files
-    A->mode=mode;
+    A->mode=mode;                                               //On récupére le mode d'ouverture du fichier et on le rentre dansle struct
-    if(mode=='r')
+    if(mode=='r')                                               //suivant le mode (écriturer w ou lecture r) on va ouvrir le fichier a l'aide de fopen et on 
-    {
+    {                                                           //enregistre cela dans lestruct Bin_files
         A->file=fopen(p,"r");
     }
     else
     {
         A->file=fopen(p,"w");
     }
-    A->record_length=0;
+    A->record_length=0;                                         //On va ensuite initialiser tous les élèments du struct.
     A->i_record=0;
     A->i_octet=0;
     A->nb_octets=0;
     return A;
 }
 
-void Ec_Bit(Bin_file *output,char bit)
+void Ec_Bit(Bin_file *output,char bit)                          // On veux une fonction capable d'écrire un bit dans un fichier
 {
-    unsigned char octet,b;
+    unsigned char octet,b;                                      // On utilise deux variables octet et b qui vont permettre de récupérer les élèmets a écrire.
     int i;
     
-    output->octet[output->i_octet]=bit;
+    output->octet[output->i_octet]=bit;                         // On va mettre le premier élèment du tableau octet de la struct Bin_file a la valeur de bit
-    output->i_octet++;
+    output->i_octet++;                                          //On incremente aussi i_octet pour ne pas réecrire surcette valeur 
-    if (output->i_octet==8)
+    if (output->i_octet==8)                                     //Si le tableau octet est plein on va aller écire dans le tableau record
-    {
+    {               
-        octet=0;
+        octet=0;                                                //on passe octet a 0 et b a 0x80 soit 1000 0000
-        b=0x80;
+        b=0x80;                                                 // cela permet de toujoursgarder 1 en bit de poids fort dans b apre les décalages a droite
-        for(i=0;i<8;i++)
+        for(i=0;i<8;i++)                        
         {
-            if(output->octet[i]=='1')
+            if(output->octet[i]=='1')                           //si on a un '1' dans le tableau octet on va mettre dans octet le résultats de octet ou b
             {
                 octet=octet|b;           
             }
             b=b>>1;
         }
-        output->i_octet=0;
+        output->i_octet=0;                      
-        output->record[output->i_record]=octet;
+        output->record[output->i_record]=octet;                 // On va apres le for remmtre i_octet a 0 puis on passe dans record la valeur du char octet pour conserver
-        printf("%c",output->record);
+        output->i_record++;                                     //ce que l'on veut écrire
-        output->i_record++;
+        output->nb_octets++;                                    //On incrémente aussi i record pour passer a l'élèment suivant et nb_octets car on en a traiter un autre
-        output->nb_octets++;
+        if(output->i_record==BLOCK_SIZE)                        //On vérifie ensuite que record qui sert de buffer soit plein avant d'écrire sont contenue.
-        if(output->i_record==BLOCK_SIZE)
         {
-            fwrite(output->record,BLOCK_SIZE,1,output->file);
+            fwrite(output->record,1,BLOCK_SIZE,output->file);
-            output->i_record=0;
+            output->i_record=0;                                 //si on éceit on reinitialise i record pour passer auxélèments suivant
         }
     }
 
 }
 
-void Lec_Bit (Bin_file*input)
-{
-    char bit ;
 
-    if (input->record_length = 0)
+char Lec_Bit(Bin_file*input)
+{
+    char bit;                                                         //On veut lire un fichier bit a bit. Pourcela on va vérifier si la record length est nul ou non
+
+
+    if (input->record_length==0)                                                            
     {
-        fread (input->record,BLOCK_SIZE,1,input_file);
+        fread(input->record,BLOCK_SIZE,1,input->file);                // si il est nul on va aller le fichier
-        input->record_length = nb_octets ;
+        input->record_length=(BLOCK_SIZE/8);                          //on va rentré la longueur lue (4096 bit) en octet
-        input->i_record = 0 ;
+        input->i_record=0;                                            //on reinitialise i_record pour etre sur de reprendre le record du début
-        
+    
+        for (input->i_octet=0;input->i_octet<8;input->i_octet++)      //On va ensuite aller écrire dans le tableau octet.
+        {
+            if((input->record[input->i_record]>>1)&1)                 //pour cela on predre le premier élèment de record le décallé de 1 bit a droite et a chaque décallage on va comparer avec 1
+            {
+                input->octet[7-input->i_octet]='1';                   //Si le bit vaut 1 on ajoute '1' a octet, 0 sinon
+            }                                                         // cette méthode lisant en premeir les bits de poids faible, on les ajoutes en partant de la fin du tableau.
+            else
+            {
+                input->octet[7-input->i_octet]='0';
+            }
+        }
+            
+        input->i_record++;                                            //on incrémente i record  pour aller a l'élèment suivant on réinitialise i_octet et 
+        input->i_octet=0;
+        input->nb_octets=input->nb_octets+input->record_length;
     }
+    
+
+    bit=input->octet[input->i_octet];                               //On passe alors bit a la valeur de octet[0]
+    input->i_octet++;                                               //on incrémente ensuite le compteur
+    if(input->i_octet=8)
+    {
+       for (input->i_octet=0;input->i_octet<8;input->i_octet++)     //Comme précédemment on récupère les 1 et les 0 de record pour les passé dans octet
+         {
+            if((input->record[input->i_record]>>1)&1)
+            {
+                input->octet[7-input->i_octet]='1';
+            }
+            else
+            {
+                input->octet[7-input->i_octet]='0';
+            }
+        }
+        input->i_record++;
+        input->i_octet=0;
+        if(input->i_record=BLOCK_SIZE)                              //si on a parcouru tous le buffer on repasse a 0 la longueur
+        {
+            input->record_length=0;        
+        } 
+    }
+    return bit;                                                     // on renvoie le bit 
 }
 
+
+int Ferm_Bit(Bin_file *fichier)
+{
+    unsigned char octet,b;
+    int nb_octets=fichier->nb_octets;                                   
+   
+    if(fichier->mode="w")
+    {
+        if(fichier->i_octet!=0)
+        {
+            octet=0;
+            b=0x80;
+            int i;
+            for(i=0;i<fichier->i_octet;i++)
+            {
+                if(fichier->octet[i]=='1')
+                {
+                    octet=octet|b;
+                }
+                b=b>>1;
+            }
+            fichier->record[fichier->i_record]=octet;
+            fichier->i_record++;
+            nb_octets++;
+        }
+        if(fichier->i_record!=0)
+        {
+            fwrite(fichier->record,1,BLOCK_SIZE,fichier->file);
+        }
+    }
+    fclose(fichier->file);
+    free(fichier);
+    return nb_octets;
+}
+
+
 int main()
 {
     Bin_file *p;
     int i;
-    printf("test1\n");
+    p=Ouv_Bit("test.txt",'r');
-    p=Ouv_Bit("test.txt",'w');
+    printf("%d",p->record_length);
-    printf("test2\n");
+    /*
-    for(i=0;i<8;i++)
+    for(i=0;i<32762;i++)
     {
         Ec_Bit(p,'1');
     }
-    printf("test3\n");
+    */
-    fclose(p);
+    for(i=0;i<32762;i++)
+    {
+        printf("%c",Lec_Bit(p));
+    }
+    int n=Ferm_Bit(p);
+    printf("\n");
+    printf("%i\n",n);
     return 0;
-}
+}

gestion_des_fichiers/gestion_fichiers.h

@@ -1,3 +1,6 @@
+/*
+    Prototypes de gestion_fichiers.c + variables define + structure(s)
+*/
 #ifndef __GESTION_FICHIERS__
 #define __GESTION_FICHIERS__
 #include <stdio.h>
@@ -5,7 +8,7 @@
 
 typedef struct
 {
-    FILE *file;                         // Identificateur fichier
+    FILE*file;                          // Identificateur fichier
     char mode;                          // Mode de lecture r ou w
     unsigned char record[BLOCK_SIZE];   // Tampon pour lire ou écrire
     int record_length;                  // nombre d'élèments du tampon
@@ -13,6 +16,6 @@ typedef struct
     char octet[8];                      // On découpe l'octet en 8 caractère
     int i_octet;                        // indice dansl'octet
     int nb_octets;                      // Nb octet lis/écrit
+    
 }Bin_file;
-
 #endif