SYSTÈME DE DÉCOUPE DE FICHIER

/*****************************
******************************
******* Oz ********************
*** Découpe de fichier ***********
*****************************
*****************************
*****************************/

#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


//definition de la taille du tampon
#define TAILLE_BUF 1024
#define INTSIZE 10

/***
**** Ce programme decoupe un fichier en plusieurs petits fichiers de la manière que suit:
 On lui di de faire cette decoule toute les "ligne" ligne, il va jusque cette ligne, il cherche la fin des infos de la societe en cours et créé un nouveau fichier avec ces infos, et il continu jusque la fin du "gros" fichier.

****/


/**************************************************
***** Fonction qui change un int en string... *****
**************************************************/

char *itoa(int value)
{
  int count,i,sign;
  char *ptr,*string,*temp;

  count = 0;
  if ((sign = value) < 0)
    {
      value = -value;
      count++;
    }

  temp = (char *) malloc(INTSIZE + 2);
  if (temp == NULL)
    {
      return(NULL);
    }
  memset(temp,'\0', INTSIZE + 2);

  string = (char *) malloc(INTSIZE + 2);
  if (string == NULL)
    {
      return(NULL);
    }
  memset(string,'\0', INTSIZE + 2);
  ptr = string;


  do {
    *temp++ = value % 10 + '0';
    count++;
  }  while (( value /= 10) >0);

  if (sign < 0)
    *temp++ = '-';

  *temp-- = '\0';

  for (i = 0; i < count; i++, temp--, ptr++)
    {
      memcpy(ptr,temp,sizeof(char));
    }

  return(string);
}


/*****************************************************************
****** CopieJusque permet de copier 'ligne' lignes d'un fichier **
************* (qui est pointé par le descripteur desc)  **********
****** dans un nouveau fichier(pointé par le descripteur desc2) **
*****************************************************************/

int CopieJusque (int desc,int desc2,int ligne) {

	/*** Déclaration de variables... ***********************************
	**** cpt nous permet de compter les lignes du fichier à copier  ****
	**** p[1] est notre tampon mémoire dans lequel on stocke ***********
	**** le caractère lu dans le fichier que l'on copie ****************
	*******************************************************************/

	int cpt=0,caractere=0;
	char p[1];
	p[1]='\0';

	while (cpt!=ligne) {

		if (read(desc,p,1)==0) return caractere;
		else {
			if (p[0]=='\n')	cpt++;
			write(desc2,p,1);
			caractere++;
		}
	}
	return caractere;
}

/****************************************************************************************************
*******  CopieLigneTampon va nous permettre de garder en mémoire dans 
'buffer' les 'nb_ligne'  ******
******* premières lignes du fichier pointé par le descripteur 'desc'  
*******************************
****************************************************************************************************/

int CopieLigneTampon (int desc, int nb_ligne, char buffer[TAILLE_BUF]) {

	int cpt=0,i=0,desc2,caractere=0;
	char p[1];
	p[1]='\0';
	buffer[0]='\0';

	while (cpt!=nb_ligne) {
		if (read(desc,p,1)==0) return caractere;
		else {
			if (p[0]=='\n')	cpt++;
			buffer[i]=p[0];
			i++;
			caractere++;
		}
	}
	return caractere;
}

/********************************************************************************
****  CreeNomFichier nous permet de générer un nom de fichier 
*******************
****  avec le nom du fichier de depart et le nombre de fois ou on la decoupé 
****
********************************************************************************/

char *CreeNomFichier (char *nom, int i) {

	char *serie;
	char *resultat;
	int tmp,tmp2;
	serie=(char *)malloc(2);
	serie=itoa(i);

	resultat=(char *)malloc(TAILLE_BUF);
	resultat=strcat (resultat,nom);

	if (i<10) {
		serie[1]=serie[0];
		serie[0]='0';
	}

	resultat=strcat (resultat,serie);
	resultat=strcat (resultat,".TXT");
	return (resultat);
}

/*******************************************************************************************************
***** Va rechercher un mot 'mot' ds un fichier deja ouvert ('desc' 
->descripteur de ce fichier)... *****
***** le descripteur pointe initialement a la position 'offset' 
****************************************
***** renvoie '0' si ok et '-1' si ce mot n'y est pas 
**************************************************
*******************************************************************************************************/

int ChercheMot (char *mot, int desc,int desc2,off_t offset_t){

	int cpt=0;
	char p[1];
	off_t offset=offset_t;
	p[1]='\0';
	while (read(desc,p,1)!=0) {
		if (mot[cpt]=='\0') return 0;
		else {
			if (p[0]==mot[cpt]) {
				cpt++;
			}
			else {
				cpt=0;
				lseek(desc,offset,SEEK_SET);
				read(desc,p,1);
				write(desc2,p,1);
				offset++;
				lseek(desc,offset,SEEK_SET);
			}
		}
	}
	return (-1);
}


/*****************************************************************************************************
****** Va inverser le mot de separation 
**************************************************************
*****************************************************************************************************/

char *InverseMot (char *mot) {

	int taille,i;
	char *mot_inverse;
	mot_inverse=(char *)malloc(sizeof(char *));
	taille=strlen(mot);
	i=0;
	while( taille!=-1) {

		taille--;
		mot_inverse[i]=mot[taille];
		i++;
	}
	mot_inverse[i]='\0';
	return mot_inverse;


}
/*******************************************************************
********** Cherche l 'offset de la firme recherchée *****************
*******************************************************************/
int Cherche_Offset_Firme (char *mot, int desc){

	int cpt=0;
	char p[1];
	off_t offset=0,offset_tmp=0;
	p[1]='\0';
	while (read(desc,p,1)!=0) {
		if (mot[cpt]=='\0') return offset;
		else {
			if (p[0]==mot[cpt]) {
				cpt++;
				offset_tmp++;
				lseek(desc,offset_tmp,SEEK_SET);
			}
			else {
				cpt=0;
				lseek(desc,offset,SEEK_SET);
				read(desc,p,1);

				offset++;
				offset_tmp=offset;
				lseek(desc,offset,SEEK_SET);
			}
		}
	}
	return (offset);
}
/*******************************************************************************************************
***** Va rechercher à l'envers un mot 'mot' ds un fichier deja ouvert 
('desc' ->descripteur de ce fichier)... *****
***** le descripteur pointe initialement a la position 'offset' 
****************************************
***** renvoie 'offset_t' si ok et '-1' si ce mot n'y est pas 
**************************************************
*******************************************************************************************************/

int ChercheMotAvant (char *mot, int desc,off_t offset_t){

	int cpt=0;
	char p[1];
	off_t offset=offset_t, offset_tmp=offset_t;
	p[1]='\0';
	while (read(desc,p,1)!=0) {
		if (mot[cpt]=='\0') return (offset+2);
		else {

			if (p[0]==mot[cpt]) {
				cpt++;
				offset_tmp--;
				lseek(desc,offset_tmp,SEEK_SET);
			}
			else {
				cpt=0;
				lseek(desc,offset,SEEK_SET);
				read(desc,p,1);
				offset--;
				offset_tmp=offset;
				lseek(desc,offset,SEEK_SET);
			}
		}

	}
	 return (offset+2);
}


/***********************************************************************************
***** Divise un fichier 'nom' en n fichiers avec des coupure de 'ligne' 
lignes. ****
***********************************************************************************/

void DiviseFichier (char *nom,int ligne) {

	int  desc,desc2,i=0,tmp;
	char buffer [TAILLE_BUF];
	char *p,*string;
	string=(char *)malloc(200);

	desc=open(nom,O_RDONLY);
	CopieLigneTampon (desc,2,buffer);

	while (read(desc,p,1)!=0) {
		string=CreeNomFichier (nom, i)	;
		i++;
		desc2=open(string,O_CREAT|O_WRONLY,0644);
		tmp=strlen(buffer);
		write(desc2,buffer,tmp);
		CopieJusque (desc,desc2,ligne);
	}
	close (desc);

}

/********************************************************************
***** Divise par rapport a une ligne ,puis va chercher le mot...*****
********************************************************************/

void Decoupage (char *nom,int ligne,char *mot) {

	int  desc,desc2,i=0,tmp,caractere=0;
	char buffer [TAILLE_BUF];
	char *p,*string;
	string=(char *)malloc(200);

	desc=open(nom,O_RDONLY);
	caractere=CopieLigneTampon (desc,2,buffer);

	while (read(desc,p,1)!=0) {
		string=CreeNomFichier (nom, i);
		i++;
		desc2=open(string,O_CREAT|O_WRONLY,0644);
		tmp=strlen(buffer);
		write(desc2,buffer,tmp);
		caractere=caractere + CopieJusque (desc,desc2,ligne);
		ChercheMot (mot,desc,desc2,caractere);

	}
	close (desc);
}

/********************************************************************
***** Fonction qui va chercher un mot puis revient en arriere *******
***** pour trouver le mot séparateur et copie de ce séparateur ******
***** au suivant... *************************************************
********************************************************************/

int SortFirme (char *nom,char *mot,char *firme) {

	int  desc,desc2,i=0,tmp,offset;
	char buffer [TAILLE_BUF];
	char *p,*string,*inverse;
	string=(char *)malloc(200);
	inverse=(char *)malloc(sizeof(char *));
	string=CreeNomFichier (nom, 0);
	desc=open(nom,O_RDONLY);
	CopieLigneTampon (desc,2,buffer);
	desc2=open(string,O_CREAT|O_WRONLY,0644);
	tmp=strlen(buffer);
	write(desc2,buffer,tmp);
	inverse=InverseMot (mot);
	offset=ChercheMotAvant (inverse,desc,(Cherche_Offset_Firme (firme,desc)));
	lseek(desc,offset,SEEK_SET);
	ChercheMot (mot,desc,desc2,offset);
	return 0;

}

/******************************************
****** Lancement de la fonction ***********
******************************************/

main (int argc,char *argv[]) {
	// c'est ici que l'on modifie le nombre de ligne... 15000
     int ligne=atoi(argv[2]);
	/*if (argc==4)*/ Decoupage (argv[1],ligne,argv[3]);
    /*
	else {
		if (argc==3)
			SortFirme (argv[1],argv[2],argv[3]);
		else printf("\n Usage : './decoupe' pour decouper un fichier FFPDDRED \n 
et './decoupe numéro_firme' pour ressortir les DDR d'une seule firme\n \n");
	}      */
}