C'est un petit programme qui permet de découper "proprement" un fichier de plusieurs mégas qui a été formaté comme suit:
On a une liste d'informations dans ce fichier et on peut trouver une redondance ( un mot, un nombre) qui sert de séparateur.
Prenons un exemple :
On a des détails sur plusieurs sociétés dans un même fichier et au début de chaque détail sur une société se trouve un mot séparateur (que l'on va nommer "mot"). A chaque fois que l'on rencontre le mot "mot", cela signifie que le fichier "va traiter" une nouvelle société.
Source / Exemple :
/*****************************
- 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");
} */
}
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.