Suppression de caractères d'un gros fichier texte

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

#define MAX_STRING 1024

void delete_char(char *src, char c, int len);

typedef struct {
   char **array;
   int size;
   int allocSize;
   } ARR;


void sortie(char *msg, int nret)
{
   fprintf(stderr, msg);
   exit(nret);
}

void initArray(ARR* a, int sz)
{
   a->size = 0;
   a->allocSize = sz;
   a->array = (char **) malloc(sizeof(char *) * sz);
   }

long findOrAddArray(ARR *arr, char *item)
{

   long i = arr->size;
   int n = strlen(item);
   char * key = malloc(n + 1 + sizeof(long));
   strcpy(key, item);

   if ( arr->size == arr->allocSize ) {
       arr->allocSize *= 2;
       char ** p  = (char **) malloc(sizeof(char *) * arr->allocSize);
       memcpy(p, arr->array, sizeof(char *) * arr->size);
       free(arr->array);
       arr->array = p;
   }
   arr->array[i] = key;
   arr->size++;
   return i;
}



void outBuf(int fd, char **s, int n)
{
   char *buf = malloc(n*15);
   char *p = buf;
           while ( n-- > 0 )
       {
       char *t = *s++;
       *p++ = *t++;

       char *h = strchr(p, '>');
        if(h != NULL)
        {
         write(fd, p, n);
                   }
      else{
      delete_char(p, 'N', 0);
      write(fd, p, n);
            }
       }
   free(buf);
}


int main(int argc, char* argv[])
{
       char buf1[MAX_STRING];

       if (argc <= 1)
       sortie("Input file missed !\n", 1);

       char *inFile = argv[1];
       char *outFile = NULL;

       if ( argc > 1 )
       outFile = argv[2];

       ARR gsm;
       initArray(&gsm, 2000);

       long i;
       int fd;

   if ((fd = open(inFile,O_RDONLY))<1){
       sortie("Cant open file \n", 1);
   }

       if(inFile == NULL) {
       sortie("File is empty \n", 1);
               }

   struct stat st;
   stat(inFile, &st);
   unsigned long fsz = st.st_size;

   if ( fsz == 0 ){
       sortie("File is empty \n", 1);
       }

   else{fprintf(stderr, "size = %d\n", fsz);
          }

   char *bufFile = malloc(st.st_size);
   if ( !bufFile )
       sortie("Erreur malloc bufFile\n", 2);


       /************************ Lecture ***************************/

   time_t t0, t1, t2, t3;
   int nr;
   char *pbf, *p;
   int n = 1;
   long nl = 0;
   long ncur = 0;
   double cx = 100.0/fsz;

   time(&t0);

   for (pbf = bufFile; (nr=read(fd, pbf, 4096)) > 0; pbf += nr )
   {
       for (p=pbf; p<pbf+nr; p++)
       {
           if ( *p == '\r' )
               *p = ' ';
           else if ( *p == '\n' )
               nl++, *p = 0;
       }
       ncur += nr;
       if (cx*ncur > n )
       {
           fprintf(stderr, "\rRead %d%%", n);
           fflush(stderr);
           n = 1 + cx*ncur;
       }
   }
   *pbf = 0;
   if ( pbf>bufFile && pbf[-1] )
       nl++;
   close(fd);

   time(&t1);
           fprintf(stderr, "\rRead 100%%, NL=%d  %ds\n", nl, t1-t0);

   if ( nl == 0 )
       sortie("File empty\n", 4);


/************************ Traitement ***************************/
   char **row = (char **)malloc(nl*sizeof(char *));
   if ( !row )
       sortie("Erreur malloc row\n", 2);

   long *vgsm = (long *)malloc(nl*sizeof(long));
   if ( !vgsm )
       sortie("Erreur malloc vgsm\n", 2);

   char **prow = row;
   long *pvgsm = vgsm;

   pbf = bufFile;

  while ( *pbf )
   {
       *pvgsm = 0;
       *prow = NULL;
        i = strlen(pbf)+1;

       if ( p = strtok(pbf, "") ) {
           *pvgsm = findOrAddArray(&gsm, p);
           if ( (p=strtok(NULL, "")) && strtok(NULL, "") )
               *prow = p; // pointe sur tag
       }
       prow++;
       pvgsm++;
       pbf += i;
   }
   if ( gsm.size == 0 )
       sortie("No input lines\n", 3);

   time(&t2);
   fprintf(stderr, "\nTreatment 100%%, %ds\n", t2-t1);

   /************************ Ecriture ***************************/

   size_t szRes = gsm.size * sizeof(long);
   char **res = (char **)malloc(szRes);
   if ( !res )
       sortie("Erreur malloc res\n", 2);
   char **res0 = (char **)malloc(szRes);
   if ( !res0 )
       sortie("Erreur malloc res0\n", 2);
   char zero[] = "0";
   for (i=0; i<gsm.size; i++)
       res0[i] = zero;
   memcpy(res, res0, szRes);

       int fdo = 1;
       if ( outFile ){
               fdo = open(outFile, O_WRONLY|O_CREAT|O_TRUNC,0755);
       }

   if ( fdo < 0 )
   {
       fprintf(stderr, "%s: Fail to open outfile, use of stdout\n", outFile);
       fdo = 1;
   }

   outBuf(fdo,gsm.array, gsm.size);

   time(&t3);
           fprintf(stderr, "\rEcriture 100%%, %ds\n", t3-t2);

   /************************ Terminé**************************/
           fprintf(stderr, "Temp total: %d'%02d\n", (t3-t0)/60, (t3-t0)%60);

       free(gsm.array);
   free(res);
   free(res0);
   free(bufFile);
   exit(0);

}

void delete_char(char *src, char c, int len)
{
       char *dst;
       int i;

       // Do not remove NULL characters.
       if ( c == 0 )
               return;

       // Small attempt to control a buffer overflow if the
       // the string is not null-terminated and a proper length
       // is not specified.
       if ( len <= 0 )
               len = MAX_STRING;

       dst = src;

       for ( i = 0; i < len && *src != 0; i++, src++ )
       {
               if ( *src != c )
                       *dst++ = *src;
       }

       // Ensure the string is null-terminated.
       *dst = 0;

       return;
}