#include 
#include 
#include 
#include 
#include 
#include 

int    *positions;
int     nb_positions;
size_t  taille_bloc;

§MEVBCBfstatic void init( size_t longueur )
{
  positions = NULL;
  nb_positions = 0;
  taille_bloc = BUFSIZ - longueur + 1;

  return;
}

§MEVBCBfint main( int argc, char **argv )
{
   void  usage(char *s);
   void  strrech( char *buffer, int nblus,
                  char *ChaineAchercher, size_t longueur );
   int     fd;
   char    buffer[BUFSIZ];
   char   *ChaineAchercher;
   size_t  longueur;
   int     nblus;

   /*
    * Le fichier et la chaîne à chercher
    * ont-ils été passés en argument ?
    */

   if ( argc != 3 )
     usage( argv[0] );
   ChaineAchercher = argv[2];
   longueur = strlen( ChaineAchercher );

   /*
    * initialisation des variables globales.
    */
   init( longueur );

   /* Ouverture du fichier passé en argument. */

   if( (fd = open( argv[1], O_RDONLY )) == -1 )
   {
      perror( "open" );
      exit( 1 );
   }

    /* Boucle de lecture du fichier. */

   while( nblus = read( fd, buffer, sizeof buffer ) )
   {
     /*
      * Récupération des positions de la chaîne
      * dans le buffer courant.
      */

     strrech( buffer, nblus, ChaineAchercher, longueur );

     /*
      * Si BUFSIZ caractères ont été lus, on
      * recule de (longueur-1) caractères
      * dans le fichier, pour être sûr de n'oublier
      * aucune position de la chaîne.
      */

     if( nblus == BUFSIZ )
       lseek( fd, -(long)(longueur - 1), SEEK_CUR );
   }
   close( fd );

   /* Impression des positions trouvées. */

   if ( nb_positions == 0 )
     printf( "La chaîne \"%s\" n'a pas été trouvée\n"
             "dans le fichier \"%s\".\n",
              ChaineAchercher, argv[1] );

    else
   {
     int pos;

     printf( "Dans le fichier \"%s\", la chaîne \"%s\"\n"
             "a été trouvée aux positions :\n\n",
              argv[1], ChaineAchercher );
     for( pos=0; pos
/*
 * Fonction de récupération des positions
 * de la chaîne dans le buffer courant.
 */

§MEVBCBfvoid strrech( char *s, int nblus,
              §MEVBCBfchar *ChaineAchercher, size_t longueur )
{
   char       *buffer, *ptr;
   static int  n = 0, nombre_octets_lus = 0;
   int         i;

   /*
    * On prend garde de remplacer les éventuels caractères
    * "nuls" par des blancs pour pouvoir utiliser
    * la fonction "strstr".
    */

   buffer = malloc( nblus+1 );
   memcpy( buffer, s, nblus );
   for( i=0; i
   /* Boucle de recherche de la chaîne. */

   for( ptr=buffer;
        ptr=strstr( ptr, ChaineAchercher );
        ptr+=longueur )
   {
     /*
      * extension du vecteur positions.
      */

     positions = (int *)realloc( positions, ++n*sizeof(int) );
     assert( positions != NULL );

     /*
      * position de la chaîne trouvée par
      * rapport au début du bloc lu.
      */

     positions[n-1] = ptr - buffer + 1;

     /*
      * position de la chaîne trouvée par
      * rapport au début du fichier.
      */

     positions[n-1] += nombre_octets_lus;
   }
   free( buffer );

    /*
    * Nombre d'octets déjà lus dans le fichier.
    */

   nombre_octets_lus += taille_bloc;
   nb_positions = n;

   return;
}

§MEVBCBfvoid usage(char *s)
{
   fprintf( stderr, "usage: %s fichier"
                    " ChaineAchercher.\n", s );
   exit(1);
}