#include <unistd.h>
#include <iostream>

using namespace std;

void crible(int desc_entree, int desc_sortie){

  //Crible le descripteur desc_entree qui est non vide avec sa 
  //premiere valeur et met le resultat dans le descripteur desc_sortie.
 
  //On lit le premier nombre
  int prems;
  if(read(desc_entree, &prems,sizeof(int))<0){
    cout << "Pbl de read"<<endl;
    exit(0);
  }
  cout << prems << " ";

  //On recopie dans desc_sortie les nombres qui ne sont pas multiple de prems
  int val_courante;
  while(read(desc_entree,&val_courante,sizeof(int))!=0){

    if(val_courante%prems !=0){
      if(write(desc_sortie,&val_courante,sizeof(int))<0){
	cout << "Pbl de write" << endl;
	exit(0);
      }
    }
  }
}


int main(){

  //On cree les deux tubes   
  int tube_entree[2];
  int tube_sortie[2];

  pipe(tube_sortie);
  pipe(tube_entree);

  //Interface
  int n;
  cout << "Cribler jusqu'a: ";
  cin >> n;
  cout << endl;
  cout << "Premiers inferieurs a " << n <<":"<< endl;

  //On remplit le tube d'entree puis on le ferme en ecriture, il ne sera plus
  //bloquant en lecture
  for(int i=2;i<=n;i++){
    write(tube_entree[1],&i,sizeof(int));}
  close(tube_entree[1]);
  

  //On se lance
  while(1){
    switch(fork()){
    
    case -1:{
      cout << "Pbl de fork" << endl;
      exit(0);
      break;
    }
    
    case 0:{//Le fils crible le tube d'entree et termine
      crible(tube_entree[0],tube_sortie[1]);
      exit(0);
    }
    
    default:{//Le pere retablit les tubes pour le prochain fils
      wait();//On attend la fin du dernier fils

      close(tube_sortie[1]);//On ferme tube_sortie en ecriture, il ne sera
                            //plus bloquant en lecture
      
      //Si tube_sortie est vide, c'est qu'on a fini
      int val_cour;
      if(read(tube_sortie[0],&val_cour,sizeof(int))==0){
	cout << endl;
	exit(0);}

      //On nettoie tube_entree
      close(tube_entree[0]);
      pipe(tube_entree);
     
      //On recopie tube_sortie dans tube_entree
      do{ 
	if(write(tube_entree[1],&val_cour,sizeof(int))<0){
	  cout<<"Pbl d'ecriture dans la recopie"<<endl;
	  exit(0);}
      }while(read(tube_sortie[0],&val_cour,sizeof(int))!=0);

      //On nettoie tube_sortie
      close(tube_sortie[0]);
      pipe(tube_sortie);

      //On ferme tube_entree en ecriture pour qu'il ne soit pas bloquant en
      //lecture
      close(tube_entree[1]);
							 }
    }
  }
}