/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        C O M P R E S S I O N / D E C O M P R E S S I O N   ' CDCM1 '   D ' U N E   C H A I N E  :                                 */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrC/CompressionDeCompression_Compression.01$vv$c' :                                                            */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20151227150148).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        A R G U M E N T S   D ' A P P E L  :                                                                                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NOM_DE_L_OUTIL                                                                                                                \
                    argv[0]
#define   NOM_DU_FICHIER                                                                                                                \
                    argv[1]
#define   BWT_UTILISER                                                                                                                  \
                    argv[2]
#define   HUF_UTILISER                                                                                                                  \
                    argv[3]
#define   EDITER_UNIQUEMENT_K_ET_LD_CUMULEES                                                                                            \
                    argv[4]
#define   EDITER_LES_COMPOSANTES_DES_K_PARTIELLES                                                                                       \
                    argv[5]
#define   BWT_TAILLE_DES_PAQUETS                                                                                                        \
                    argv[6]
#define   CDC_TAILLE_DES_PAQUETS                                                                                                        \
                    argv[7]
#define   BWT_FICHIER_RLE_1                                                                                                             \
                    argv[8]
#define   BWT_FICHIER_BWT__                                                                                                             \
                    argv[9]
#define   BWT_FICHIER_RLE_2                                                                                                             \
                    argv[10]
#define   BWT_FICHIER_HUF__                                                                                                             \
                    argv[11]


/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   G E N E R A L E S  :                                                                                 */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "CompressionDeCompression_Compression.01.vv.I"

#define   GET_ARGUMENTS(numero,sequence)                                                                                                \
                    {                                                                                                                   \
                    if        (argc >= numero)                                                                                          \
                              {                                                                                                         \
                              sequence;                                                                                                 \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                    }

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P R O G R A M M E   P R I N C I P A L  :                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
main(int argc,CHAR *argv[])
          {
          CDC_MettreEnConcurrenceLesDifferentesOptions=FAUX;

          BWT_Utiliser=VRAI;
          HUF_Utiliser=VRAI;

          BWT_EditerLesChaines=FAUX;

          CDC_EditerLesLongueurs=FAUX;
          CDC_EditerArguments=VRAI;
          CDC_EditerCDCBits=FAUX;
          CDC_EditerChronometrage=FAUX;
          CDC_Editer_K_bits=FAUX;
          CDC_EditerUniquement_K_et_LD_Cumulees=VRAI;
          CDC_EditerLesComposantesDes_K_Partielles=FAUX;

          HUF_EditerArbre=FAUX;
          HUF_EditerCodesDeHuffman=FAUX;
          HUF_EditerFrequences=FAUX;

          RLE_EditerLesChaines=FAUX;
                                        /* Mis ici pour en faciliter la mise a jour...                                               */

          if        (argc >= 2)
                    {
                    GET_ARGUMENTS(3 ,{BWT_Utiliser                               = atoi(BWT_UTILISER);});
                    GET_ARGUMENTS(4 ,{HUF_Utiliser                               = atoi(HUF_UTILISER);});
                    GET_ARGUMENTS(5 ,{CDC_EditerUniquement_K_et_LD_Cumulees      = atoi(EDITER_UNIQUEMENT_K_ET_LD_CUMULEES);});
                    GET_ARGUMENTS(6 ,{CDC_EditerLesComposantesDes_K_Partielles   = atoi(EDITER_LES_COMPOSANTES_DES_K_PARTIELLES);});
                    GET_ARGUMENTS(7 ,{BWT_TailleDesPaquets                       = atoi(BWT_TAILLE_DES_PAQUETS);});
                    GET_ARGUMENTS(8 ,{CDC_TailleDesPaquets                       = atoi(CDC_TAILLE_DES_PAQUETS);});

                    GET_ARGUMENTS(9 ,{BWT_Fichier_RLE_1                          = BWT_FICHIER_RLE_1;});
                    GET_ARGUMENTS(10,{BWT_Fichier_BWT__                          = BWT_FICHIER_BWT__;});
                    GET_ARGUMENTS(11,{BWT_Fichier_RLE_2                          = BWT_FICHIER_RLE_2;});
                    GET_ARGUMENTS(12,{BWT_Fichier_HUF__                          = BWT_FICHIER_HUF__;});

                    GET_ARGUMENTS(13,{fprintf(stderr,"ERREUR(CDC) : Les arguments en trop sont ignores.\n");});

                              {
                              int                 DescripteurDuFichier=open(NOM_DU_FICHIER,O_RDONLY);;
                              int                 etat_fichier;
                              struct    stat      EtatDuFichier;

                              if        (DescripteurDuFichier >= 0)
                                        {
                                        if        (fstat(DescripteurDuFichier,&EtatDuFichier) >= 0)
                                                  {
                                                  int       TailleDuFichier=EtatDuFichier.st_size;
                                                  int       NombreDOctetsLus;
                                                  char      *BufferDuFichier;

                                                  BufferDuFichier = MALLOC(TailleDuFichier);

                                                  if        (CDC_TailleDesPaquets > 0)
                                                            {
                                                            }
                                                  else
                                                            {
                                                            CDC_TailleDesPaquets = TailleDuFichier;
                                                            }

                                                  if        (BWT_TailleDesPaquets > 0)
                                                            {
                                                            }
                                                  else
                                                            {
                                                            BWT_TailleDesPaquets = TailleDuFichier;
                                                            }

                                                  if        (CDC_EditerArguments == VRAI)
                                                            {
                                                            printf("Fichier.............................. = %s\n"
                                                                  ,NOM_DU_FICHIER
                                                                   );

                                                            printf("Outil................................ = %s\n"
                                                                  ,NOM_DE_L_OUTIL
                                                                   );
                                        /* Edition du nom de l'outil utilise (introduit le 20160224104551).                          */

                                                            printf("TailleFichier........................ = %d (%s)\n"
                                                                  ,CONVERSION_BITS_OCTET(TailleDuFichier*NBITOC)
                                                                  ,BITS_OU_OCTETS
                                                                   );
                                                            printf("PaquetsDecoupageFichier.............. = %d (octets)\n"
                                                                  ,CDC_TailleDesPaquets
                                                                   );

                                                            if        (CDC_MettreEnConcurrenceLesDifferentesOptions == FAUX)
                                                                      {
                                                                      printf("BWT.................................. = %s\n"
                                                                            ,FORMAT_VRAI_FAUX(BWT_Utiliser)
                                                                             );

                                                                      if        (BWT_Utiliser == VRAI)
                                                                                {
                                                                                printf("PaquetsBWT........................... = %d (octets)\n"
                                                                                      ,BWT_TailleDesPaquets
                                                                                       );
                                                                                }
                                                                      else
                                                                                {
                                                                                }

                                                                      printf("HUF.................................. = %s\n"
                                                                            ,FORMAT_VRAI_FAUX(HUF_Utiliser)
                                                                             );
                                                                      }
                                                            else
                                                                      {
                                                                      }
                                                            }
                                                  else
                                                            {
                                                            }

                                                            {
                                                            CHAR      *nettoyage=MALLOC(1);

                                                            GENERE_FICHIER(BWT_Fichier_RLE_1,&nettoyage,0,"w");
                                                            GENERE_FICHIER(BWT_Fichier_BWT__,&nettoyage,0,"w");
                                                            GENERE_FICHIER(BWT_Fichier_RLE_2,&nettoyage,0,"w");
                                                            GENERE_FICHIER(BWT_Fichier_HUF__,&nettoyage,0,"w");
                                        /* Initialisation eventuelle d'un ou plusieurs fichiers donnant le resultat des quatre       */
                                        /* etapes {RLE_1,BWT,RLE_2,HUF}. Le mode "w" et la longueur nulle permettent de detruire     */
                                        /* une eventuelle version pre-existante et de preparer ensuite la construction progressive   */
                                        /* de ces fichiers en mode "a" ("appending" c'est-a-dire "writing at end of file").          */
                                                            }

                                                  NombreDOctetsLus = read(DescripteurDuFichier,BufferDuFichier,TailleDuFichier);

                                                  if        (NombreDOctetsLus == TailleDuFichier)
                                                            {
                                                            if        (CDC_MettreEnConcurrenceLesDifferentesOptions == FAUX)
                                                                      {
                                                                      F_MesureDe_K_EtDe_LD_Globale(BufferDuFichier,TailleDuFichier);
                                        /* Mesure de K et de LD du fichier argument...                                               */
                                                                      }
                                                            else
                                                                      {
                                                                      D_METTRE_EN_CONCURRENCE(VRAI,VRAI);
                                                                      D_METTRE_EN_CONCURRENCE(VRAI,FAUX);
                                                                      D_METTRE_EN_CONCURRENCE(FAUX,VRAI);
                                                                      D_METTRE_EN_CONCURRENCE(FAUX,FAUX);
                                        /* Mesure de K et de LD du fichier argument par concurrence de plusieurs methodes...         */

                                                                      if        (CONVERSION_BITS_OCTET(Complexite_K__Cumulee__Minimale) >= TailleDuFichier)
                                                                                {
                                                                                Complexite_K__Cumulee__Minimale = TailleDuFichier*NBITOC;
                                                                                Complexite_LD_Cumulee__Associee_A_Complexite_K__Cumulee__Minimale = 1;
                                        /* Dans le cas ou K est superieure ou egale a la taille du ficher, on force K et LD...       */
                                                                                }
                                                                      else
                                                                                {
                                                                                }

                                                                      printf("BWT.................................. = %s\n"
                                                                            ,FORMAT_VRAI_FAUX(BWT_Utiliser__Associee_A_Complexite_K__Cumulee__Minimale)
                                                                             );

                                                                      if        (BWT_Utiliser__Associee_A_Complexite_K__Cumulee__Minimale == VRAI)
                                                                                {
                                                                                printf("PaquetsBWT........................... = %d (octets)\n"
                                                                                      ,BWT_TailleDesPaquets
                                                                                       );
                                                                                }
                                                                      else
                                                                                {
                                                                                }

                                                                      printf("HUF.................................. = %s\n"
                                                                            ,FORMAT_VRAI_FAUX(HUF_Utiliser__Associee_A_Complexite_K__Cumulee__Minimale)
                                                                             );

                                                                      printf("K.................................... = %.0f (%s)\n"
                                                                            ,floor(CONVERSION_BITS_OCTET(Complexite_K__Cumulee__Minimale))
                                                                            ,BITS_OU_OCTETS
                                                                             );
                                                                      printf("LD................................... = %.0f (instructions)\n"
                                                                            ,Complexite_LD_Cumulee__Associee_A_Complexite_K__Cumulee__Minimale
                                                                             );
                                                                      }
                                                            }
                                                  else
                                                            {
                                                            fprintf(stderr
                                                                   ,"ERREUR(CDC) : %d octets ont ete lus au lieu de %d.\n"
                                                                   ,NombreDOctetsLus
                                                                   ,TailleDuFichier
                                                                    );
                                                            }
                                                  }
                                        else
                                                  {
                                                  fprintf(stderr
                                                         ,"ERREUR(CDC) : Probleme avec le fichier '%s'.\n"
                                                         ,NOM_DU_FICHIER
                                                          );
                                                  }
                                        close(DescripteurDuFichier);
                                        }
                              else
                                        {
                                        fprintf(stderr,"ERREUR(CDC) : Le fichier '%s' n'existe pas.\n",NOM_DU_FICHIER);
                                        }
                              }
                    }
          else
                    {
                    fprintf(stderr,"ERREUR(CDC) : Il n'y a pas assez d'arguments.\n");
                    }
          }



Copyright (c) Jean-François Colonna, 2016.
Copyright (c) CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / Ecole Polytechnique, 2016.