//**********************************************************************
//**********************************************************************
//	Projet      : Ulysse
//	Laboratoire : GREYC-ISMRA
//	Fichier     : 
//      Annee       : 1997          ,
//	Auteur      : Christophe GODEREAUX
//**********************************************************************
//**********************************************************************

/*************************************************************************
 FICHIER CONTENANT DES FONCTIONS C ET C++ BIEN UTILES DANS CERTAINS CAS !!
**************************************************************************/

#ifndef UTILLLL
#define UTILLLL

#ifndef TRUE
#define TRUE 1
#endif

#ifndef FALSE
#define FALSE 0
#endif

#include <strstream.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <iostream.h>
#include <fstream.h>
#include <ctype.h>
#include <time.h>
#include <string.h>
#include <sys/time.h> // pour rand() et pour usleep
//#include "/soleil/gcc/lib/g++-include/time.h"


// solution de /usr/openwin/share/src/xview/demos/spider/util.c
#include <signal.h>
//#include <X11/Xos.h>		// for (sys/)time.h 
#include <unistd.h> //pour pause

#ifndef SOLAR
#define RAND_MAX_A_MOI 2147483647.0 //existe sous solaris RAND_MAX = 32767
#else
#define RAND_MAX_A_MOI 32766.0 //existe sous solaris RAND_MAX = 32767
#endif

#define CAR_SEP1 '{'
#define CAR_SEP2 '}'

#define LONGUEUR_CHAINE_MAX 5000

//**********************************************************************
//	GENERATEUR DE NOMBRES ALEATOIRES 
//**********************************************************************

int rnd(int max)
{//cout<<"max="<<max<<' ';cout.flush();
  return (int)(1+rand()/RAND_MAX_A_MOI*max);
}

void randomize()
{
  struct timeval tp;
  struct timezone tzp;
  gettimeofday(&tp,&tzp); 
    // dans #include <sys/time.h>
    // tp.tv_sec=nombre de secondes depuis 01/01/1970
    // tp.tv_usec=nombre de micro secondes en plus -> 0<tv_usec<999999
  srand((int)tp.tv_usec+1);
}


//**********************************************************************
//	DEBUGAGES 
//**********************************************************************

void debn(const char* message)
{
  if (message != NULL){
    cout <<message<<"\n";
    cout.flush();
  } else debn("Danger : debn doit afficher un pointeur nul !!!!!");
}

void deb(const char* message)
{
  if (message != NULL){
    cout <<message;
    cout.flush();
  } else debn("Danger : deb doit afficher un pointeur nul !!!!!");
}

void debi(const int message)
{
    cout <<message;
    cout.flush();
}

void debin(const int message)
{
    cout <<message<<"\n";
    cout.flush();
}


#define DEB0 debin(0);
#define DEB1 debin(1);
#define DEB2 debin(2);
#define DEB3 debin(3);
#define DEB4 debin(4);
#define DEB5 debin(5);
#define DEB6 debin(6);
#define DEB7 debin(7);
#define DEB8 debin(8);
#define DEB9 debin(9);


//**********************************************************************
//	TRAITEMENT SUR LES CHAINES DE CARACTERES 
//**********************************************************************

int eg(const char* a,const char* b){return !strcmp(a,b);}

void majusc(char * s)
{
 for(;*s!=0;s++)
  if ((*s & 128)==0)
   *s=toupper(*s);
  else if (*s=='é') *s='É';
  else if (*s=='è') *s='È';
  else if (*s=='ê') *s='Ê';
  else if (*s=='à') *s='À';
  else if (*s=='â') *s='Â';
  else if (*s=='î') *s='Î';
  else if (*s=='ô') *s='Ô';
  else if (*s=='û') *s='Û';
  else if (*s=='ç') *s='Ç';
}


void minusc(char * s)
{
 for(;*s!=0;s++)
  if ((*s & 128)==0)
   *s=tolower(*s);
  else if (*s=='É') *s='é';
  else if (*s=='È') *s='è';
  else if (*s=='Ê') *s='ê';
  else if (*s=='À') *s='à';
  else if (*s=='Â') *s='â';
  else if (*s=='Î') *s='î';
  else if (*s=='Ô') *s='ô';
  else if (*s=='Û') *s='û';
  else if (*s=='Ç') *s='ç';
}

void enlever_char(char * s,char c)
{
 for(;*s!=0;s++)
  if (*s==c) *s=' ';
}

void enlever_char(char * s,char *c)
{
 char* i=c;
 for(;*s!=0;s++)
   for(c=i;*c!=0;c++)
    if (*s==*c) *s=' ';
}

void copy_jusque(char * e,char c)
{
 for(;*e!=0;e++)
  if (*e==c) {*e=0;return;}
}

//**********************************************************************
//	TRAITEMENTS PLUS COMPLEXES SUR LES CHAINES DE CARACTERES 
//**********************************************************************

void modifier_point_phrase(char* p)
{
  int n=strlen(p);//debin(n);
  if (n>1 && p[n-2]=='.' && p[n-1]!=' ') {
    p[n-2]=' ';p[n-1]='.';
    return;
  }  
  if (eg(p,".") ||p[n-1]!='.'||(n>1&&p[n-1]=='.' && p[n-2]==' ')) return;
  p[n-1]=' ';p[n]='.';p[n+1]=(char)0;
//debn(p);
}

void suprimer_doublon_espaces(char* e)
{
  char *p =strdup(e); char *s=p; char* q=e;
  for(;*s!=0;s++){
    *s=*q;
//cout<<*q<<*s;
    if (*q==' ') for(;*q!=0 && *q==' ';q++); //deb("esp ");
    else q++;
    if (*q==0) *(s+1)=0;
  }
//debn("");deb("p :");debn(p);
  strcpy(e,p);
//debn("");deb("e :");debn(e);
}

void traiter_enonce_pour_analyse_syntaxique(char *e)
{
  majusc(e);
  //suppression du dernier espace
  if (e[strlen(e)-1]==' ') e[strlen(e)-1]=(char)0; 
  enlever_char(e,"\',-_>");
//debn("");deb("avant :");debn(e);
  modifier_point_phrase(e);
  suprimer_doublon_espaces(e);
//debn("");deb("apres :");debn(e);

}
  
 

//**********************************************************************
//	TRAITEMENT DES "ENONCES ALEATOIRES " EX: { BONJOUR SALUT } 
//**********************************************************************

int compter_mots(char* e,char dern)
{  
  int i=0;
  char cherche='c';
  for(;*e!=0;e++){
    if (*e==dern) return i;
    else if (*e!=' ' && cherche!=' '){
      i++;cherche=' ';
    }
    else if (*e==' ' && cherche==' ') cherche='c';
  }
  return i;
}

void effacer_mots(char* e,char dern,int sauf)
{  
  int i=0;
  int remp=TRUE;
  char cherche='c';
  for(;*e!=0;e++){
    if (*e==dern) { *e=' '; return;}
    else if (*e!=' ' && cherche!=' '){
      i++;cherche=' ';
      if (i==sauf) remp=FALSE;
    }
    else if (*e==' ' && cherche==' ') {remp=TRUE;cherche='c';}
    if (remp) *e=' ';
  }
}

void traiter_au_hasard(char * e)
{
  int igarde=0; 
  for(;*e!=0;e++)
   if (*e==CAR_SEP1){
     *e=' ';
     igarde=rnd(compter_mots(e,CAR_SEP2));
     effacer_mots(e,CAR_SEP2,igarde);
  }
}


//**********************************************************************
//	FICHIERS ET USLEEP
//**********************************************************************


char *ecrire_message(char *message,char *destinataire,char* mode="w")
{
  FILE *f;
  f=fopen(destinataire,mode);
  fputs(message,f);
  fclose(f);
  return message;
} 

char *lire_message(char *message,char *fichier,int num_ligne=1)
{
  FILE *f;
  f=fopen(fichier,"r");
  for (int i=0;i<num_ligne;i++) fgets(message,LONGUEUR_CHAINE_MAX,f);
  fclose(f);
  return message;
} 

void stopme(int y) {
	signal(SIGALRM, SIG_DFL);
}

void usleep(long value) {
	void			stopme(int y);
	struct itimerval	ntval,
				otval;

	ntval.it_interval.tv_sec  = 0;
	ntval.it_interval.tv_usec = 0;
	ntval.it_value.tv_sec     = 0;
	ntval.it_value.tv_usec    = value;
	signal(SIGALRM, stopme);
	setitimer(ITIMER_REAL, &ntval, &otval);
	pause();
}


//void usleep(int d){ for(int i=0; i<d*100;i++){}}


#endif