Système de découpe de fichier

Soyez le premier à donner votre avis sur cette source.

Snippet vu 5 153 fois - Téléchargée 29 fois

Contenu du snippet

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 :


/*****************************

              • 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"); } */ }

A voir également

Ajouter un commentaire

Commentaires

Messages postés
4
Date d'inscription
vendredi 4 juin 2004
Statut
Membre
Dernière intervention
10 novembre 2006

en fait, pas trop car ce programme recherche une chaine de caracteres qui se repetent dans le texte... par contre si tu modifie le source, il y aurait moyen de faire ce que tu desire...
Messages postés
757
Date d'inscription
vendredi 7 septembre 2001
Statut
Membre
Dernière intervention
19 juin 2008

cette application me permetterai t'il de decouper une images en plusieurs petites, du genre tuiler une grosse images !
Messages postés
5
Date d'inscription
mercredi 25 février 2004
Statut
Membre
Dernière intervention
9 juin 2004

Ok et bien je te remercie de ta reponse c'est beaucoup plus clair maintenant

bonne soirée a tous
Messages postés
3011
Date d'inscription
jeudi 26 septembre 2002
Statut
Membre
Dernière intervention
27 novembre 2004
7
test le code retour de ton programme et tu vera qu'avec ou sans return 0 c'est bien 0
encore faut il que le compilo suive le standard, mais je crois que c99 est supporté par la plupart des compilo maintenant

maintenant tout la question est de savoir si du code en c99 ou si tu prefer le standard le plus rependu, l'ansi c89
Messages postés
5
Date d'inscription
mercredi 25 février 2004
Statut
Membre
Dernière intervention
9 juin 2004

Ce que je ne comprend pas alors c'est que l'on ma dis qu'il etait obligatoire, que le type de declaration implicite n'est plus autorise en C99 et donc quand on declare main en type int on doit mettre return 0 a la fin

exemple on ne doit plus ecrire

main()
{
}

mais

int main~()
{
return 0;
}

En fait on le met seulement si on a envie (je croit que ca aide pour le debuggage) mais je croit aussi que la fonction main renvoie toujours quelque chose ce qui impose se return 0
voila pourquoi j'ai un peu de mal a comprendre d'un cote on me dit qu'il est obligatoire avec de bons arguments et de l'autres cotés il n'est pas obligatoire avec aussi de bons arguments la je vous avouerais que je ne sais plus
Si quelqu'un pouvait m'eclairer j'eviterais de me cogner contre les murs merci
Afficher les 14 commentaires

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.