/*
      --------------------------------------------------------
      LIA_PHON : Un systeme complet de phonetisation de textes
      --------------------------------------------------------
  
      Copyright (C) 2001 FREDERIC BECHET
  
      ..................................................................
  
      This file is part of LIA_PHON
  
      LIA_PHON is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation; either version 2 of the License, or
      (at your option) any later version.
  
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU General Public License for more details.
  
      You should have received a copy of the GNU General Public License
      along with this program; if not, write to the Free Software
      Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
      ..................................................................
  
      For any publication related to scientific work using LIA_PHON,
      the following reference paper must be mentioned in the bibliography: 
          
      Bechet F., 2001, "LIA_PHON - Un systeme complet de phonetisation
      de textes", revue Traitement Automatique des Langues (T.A.L.)
      volume 42, numero 1/2001, edition Hermes
      ..................................................................
                                
      Contact :
                FREDERIC BECHET - LIA - UNIVERSITE D'AVIGNON
                AGROPARC BP1228 84911  AVIGNON  CEDEX 09  FRANCE
                frederic.bechet@lia.univ-avignon.fr
      ..................................................................
  */
  /*..........................................*/
  /* ooOOoo | Rule Based Transcription System */
  /*-RUMBAS-|---------------------------------*/
  /* ooOOoo |     FRED  -  LIA 1996           */
  /*..........................................*/
  
  /*  Fred 12/1996 - Generation des variantes  */
  
  /*  Format d'entree : <graphie> <phonetique> <info ....>  */
  
  
  /*  Phonetise une chaine deja syllabisee  */
  
  #include <stdio.h>
  #include <genevari.h>
  #include <contrainte.h>
  
  #define True        1
  #define False       0
  #define MaxWindow   16
  
  int SeeReg;
  
  /*................................................................*/
  
  /*  Verifie les contraintes graphiques  */
  
  int min(a,b) int a,b; { return a<b?a:b; }
  int max(a,b) int a,b; { return a>b?a:b; }
  
  int PlusLongContGraphik(nu,poids)
   int nu,*poids;
  {
  char *ch;
  int n,m,i;
  for(n=m=0,ch=TablGraphik[nu][1],*poids=0;ch[n];)
   {
   for(i=0;(ch[n+i])&&(ch[n+i]!=',');i++)
    if ((ch[n+i]>='a')&&(ch[n+i]<='z')) *poids=max(*poids,(int)ch[n+i]);;
   m=max(m,i);
   if (ch[n+i]==',') n++;
   n+=i;
   }
  return m;
  }
  
  int ContGraphik(c,nu)
   char c;
   int *nu;
  {
  for(*nu=0;TablGraphik[*nu][0][0];(*nu)++)
   if (c==TablGraphik[*nu][0][0]) return True;
  return False;
  }
  
  int PresentGraphik(test,ch)
   char *test,*ch;
  {
  int n,i;
  /*
  printf("test : %s in %s
  ",test,ch);
  */
  for (n=0;ch[n];n++)
   {
   for (i=0;(test[i])&&(ch[n+i])&&(ch[n+i]!=',')&&(test[i]==ch[n+i]);i++);
   if ((ch[n+i]=='\0')||(ch[n+i]==',')) return i;
   while((ch[n+i])&&(ch[n+i]!=',')) i++;
   n+=i;
   }
  return 0;
  }
  
  int SiChiffre(c)
   char c;
  {
  if ((c>='0')&&(c<='9')) return True;
  return False;
  }
  
  /*................................................................*/
  
  /*  Trie les regles phonetiques  */
  
  int score_chaine(ch)
   char *ch;
  {
  int n,i=0,coef,nu,poids;  /*  Le coef c'est la longueur de chaque 'caractere'  */
  char c;
  
  for(n=0,i=0;ch[n];n++)
   {
   c=ch[n]; coef=1;
   if ((c=='+')||(c=='+')||(c=='Ý')) c='a';
   else
    if ((c=='+')||(c=='+')||(c=='-')||(c=='-')) c='e';
    else
     if ((c=='Ñ')||(c=='Ý')) c='i';
     else
      if ((c=='-')||(c=='+')) c='o';
      else
       if ((c=='+')||(c=='Ï')) c='u';
       else
        if (c=='µ') c='c';
        else
         if ((c>='A')&&(c<='Z'))
          {
          /*  C'est une contrainte  */
          if (ContGraphik(c,&nu))
           {
           coef=PlusLongContGraphik(nu,&poids);
           /*c=(char)poids;*/
           }
          c='z';
          }
         else c='z';
   i+=(coef*(400-(int)c));
   }
  return i;
  }
  
  int LongueurContrainte(ch)
   char *ch;
  {
  int n,nu,l,p;
  
  for(n=l=0;ch[n];n++)
   if (ContGraphik(ch[n],&nu)) l+=PlusLongContGraphik(nu,&p);
   else l++;
  return l;
  }
  
  void poids_regle(seat,pgauche,pdroite,cont,p1,p2,p3)
   char *seat,*pgauche,*pdroite,*cont;
   int *p1,*p2,*p3;
  {
  char ch[TailleLigne];
  
  sprintf(ch,"%s%s",seat,pdroite);
  *p1=(LongueurContrainte(ch)*1000)+score_chaine(ch);
  *p2=(LongueurContrainte(pgauche)*1000)+score_chaine(pgauche);
  *p3=(LongueurContrainte(cont)*1000)+score_chaine(cont);
  }
  
  /*  Fonctions d'allocation memoire  */
  
  ty_regles creer_regles(pgauche,pdroite,seat,phon,cont,exemple)
   char *pgauche,*pdroite,*seat,*phon,*cont,*exemple;
  {
  ty_regles pt;
  
  pt=(ty_regles) malloc(sizeof(struct type_regles));
  pt->pgauche=(char *)strdup(pgauche);
  pt->pdroite=(char *)strdup(pdroite);
  pt->seat=(char *)strdup(seat);
  pt->phon=(char *)strdup(phon);
  pt->cont=(char *)strdup(cont);
  pt->exemple=(char *)strdup(exemple);
  poids_regle(seat,pgauche,pdroite,cont,&(pt->p1),&(pt->p2),&(pt->p3));
  return pt;
  }
  
  /*  Lecture d'une regle de phonetisation  */
  
  int infe_poids(p1,p2,p3,q1,q2,q3)
   int p1,p2,p3,q1,q2,q3;
  {
  if (p1<q1) return True;
  if (p1==q1)
   {
   if (p2<q2) return True;
   if (p2==q2)
    if (p3<q3) return True;
    else return False;
   else return False;
   }
  else return False;
  }
  
  void insere_regle(pt,Nb_Regles,Regles)
   ty_regles pt, *Regles;
   int Nb_Regles;
  {
  int n,i;
  
  for (i=0;i<Nb_Regles;i++)
   if (infe_poids(Regles[i]->p1,Regles[i]->p2,Regles[i]->p3,
          pt->p1,pt->p2,pt->p3))
    {
    for (n=Nb_Regles;n>i;n--)
     Regles[n]=Regles[n-1];
    Regles[i]=pt;
    return;
    }
  Regles[Nb_Regles]=pt;
  }
  
  int decoupe_string(d,ch,resu,n_ligne)
   char d,*ch,*resu;
   int n_ligne;
  {
  int n;
  
  for(n=0;(ch[n])&&(ch[n]!=d);n++) resu[n]=ch[n];
  if (!ch[n])
   {
   printf("%s Bad Format, desole pour vous .... a la ligne %d
  ",ch,n_ligne);
   exit(0);
   }
  resu[n]='\0';
  return n;
  }
  
  void nettoie_p(ch,resu)
   char *ch,*resu;
  {
  int n,i=0,nu;
  
  if ((ch[0]!='l')||((!SiChiffre(ch[1]))&&(!ch[1]=='\0')))
   for(n=0,i=0;ch[n];n++)
    if ((ch[n]=='"')||(ch[n]=='.'))
     ;
    else
     if (ContGraphik(ch[n],&nu))
      {
      resu[i++]=ch[n];
      if (SiChiffre(ch[n+1])) n++;  /*  On saute les indices 0->9  */
      }
     else
      resu[i++]=ch[n];
  resu[i]='\0';
  }
  
  void nettoie_phon(ch,resu)
   char *ch,*resu;
  {
  int n,i;
  
  for(n=0,i=0;ch[n];n++)
   if (ch[n]!=' ') resu[i++]=ch[n];
  resu[i]='\0';
  }
  
  void modif_liaison(ch1,ch2,avphon,apphon)
   char *ch1,*ch2,*avphon,*apphon;
  {
  int n,i,t,tc;
  char chad[TailleLigne];
  
  chad[0]='\0';
  for (i=0;avphon[i];i++) ch2[i]=avphon[i];
  strcpy(ch2+i,ch1);
  t=strlen(ch2);
  for (n=0;apphon[n];)
   if (apphon[n]=='-')
    {
    for(++n;(apphon[n]==ch2[t-2])&&(apphon[n+1]==ch2[t-1]);n+=2)
     { t-=2; ch2[t]='\0'; }
    if ((apphon[n])&&(apphon[n]!='-')&&(apphon[n]!='+'))
     { printf("ERREUR - ERREUR : %s ne finit pas par %s
  ",ch1,apphon); exit(0); }
    }
   else
    if(apphon[n]=='+')
     {
     for (++n;(apphon[n])&&(apphon[n+1])&&(apphon[n]!='-')&&(apphon[n]!='+');n+=2)
      {
      tc=strlen(chad);
      strncpy(chad+tc,apphon+n,2);
      chad[tc+2]='\0';
      }
     }
    else
     { printf("ERREUR - ERREUR : mauvais format pour apphon : %s
  ",apphon); exit(0); }
  strcat(ch2,chad);
  }
  
  ty_regles *lecture_regles(pathfic,nomfic,NbRegles)
   char *pathfic,*nomfic;
   int *NbRegles;
  {
  ty_regles *Regles;
  FILE *file;
  char ch[TailleLigne],temp[TailleLigne],
       pgauche[TailleLigne],pdroite[TailleLigne],
       seat[TailleLigne],phon[TailleLigne],cont[TailleLigne],exemple[TailleLigne];
  int n,i,nb,n_ligne;
  
  sprintf(ch,"%s%s",pathfic,nomfic);
  /*printf("ouverture de %s
  ", ch);*/
  if (!(file=fopen(ch,"rt")))
   {
   printf("Impossible d'ouvrir le fichier regles : %s
  ",ch);
   exit(0);
   }
   else /*printf("        ok
  ")*/;
  for(nb=0;fgets(ch,TailleLigne,file);) if (ch[0]=='r') nb++;
   
  (*NbRegles)=nb;
  fseek(file,0,SEEK_SET);
  Regles=(ty_regles *) malloc(nb * sizeof(ty_regles));
  /*printf("Lecture des regles en cours :
  ");*/
  for(i=n_ligne=0;fgets(ch,TailleLigne,file);n_ligne++)
   if (!strncmp(ch,"regle",5))
    {
    pgauche[0]=pdroite[0]=seat[0]=phon[0]=cont[0]=exemple[0]='\0';
    n=decoupe_string('<',ch,temp,n_ligne)+1;
    n+=decoupe_string(',',ch+n,temp,n_ligne)+2;
    nettoie_p(temp,pgauche);
    n+=decoupe_string('"',ch+n,seat,n_ligne)+2;
    n+=decoupe_string('>',ch+n,temp,n_ligne)+3;
    nettoie_p(temp,pdroite);
    n+=decoupe_string('"',ch+n,phon,n_ligne)+3;
    n+=decoupe_string('"',ch+n,cont,n_ligne)+3;
    n+=decoupe_string('"',ch+n,exemple,n_ligne);
    insere_regle(creer_regles(pgauche,pdroite,seat,phon,cont,exemple),i++,Regles);
    }
  fclose(file);
  return(Regles);
  }
  
  /*  Phonetise  */
  
  int compatible_char(c1,c2)
   char c1,*c2;  /*  La regle est dans c1  */
  {
  int n;
  /*printf("CompaChar : %c et %s 
  ",c1,c2);*/
  if (c1==(*c2)) return True;  /*  Egalite parfaite  */
  
  /*  Verification avec la table graphik  */
  
  for(n=0;TablGraphik[n][0][0];n++)
   if (c1==TablGraphik[n][0][0])
    return PresentGraphik(c2,TablGraphik[n][1]);
  return 0;
  }
  
  int verifie_pgauche(pg1,pg2)
   char *pg1,*pg2;
  {
  int i,j,depl,nu,poids;
  /*
  printf("compatible gauche : #%s# #%s#
  ",pg1,pg2);
  */
  if ((*pg1=='\0')&&(*pg2=='\0')) return True;
  /*
  for (i=strlen(pg1)-1,j=strlen(pg2)-1;(i>=0)&&(j>=0)&&
      (depl=compatible_char(pg1[i],pg2+j));i--,j-=depl);
  */
  for (i=strlen(pg1)-1,j=strlen(pg2)-1;(i>=0)&&(j>=0);)
   {
   depl=compatible_char(pg1[i],pg2+j);
   if (depl) { i--; j--; }
   else
    {
    if (!ContGraphik(pg1[i],&nu)) return False;
    j-=(PlusLongContGraphik(nu,&poids)-1);
    if (!compatible_char(pg1[i],pg2+j)) return False;
    i--; j--;
    }
   }
  if (i<0) { /*printf("Vrai
  ");*/ return True; }
  /*printf("Faux
  ");*/ return False;
  }
  
  int verifie_seatdroite(seat,pdroite,ch)
   char *seat,*pdroite,*ch;
  {
  int i,j,k,depl;
  /*
  printf("compatible seatdroite : #%s#%s#%s#
  ",seat,pdroite,ch);
  */
  for (i=0,k=0;(seat[i])&&(ch[k])&&(depl=compatible_char(seat[i],ch+k));i++,k+=depl);
  if (seat[i]) return False;
  for(j=0;(pdroite[j])&&(ch[k])&&(depl=compatible_char(pdroite[j],ch+k));j++,k+=depl);
  if (pdroite[j]) return False;
  /*printf("cestoubon 
  ");*/ return True;
  }
  
  /*................................................................*/
  
  /*  Test des contraintes non graphiques  */
  
  int TestSubChaine(test,ch)
   char *test,*ch;
  {
  int n,l;
  l=strlen(test);
  for (n=0;ch[n];)
   if (!strncmp(test,ch+n,l)) return True;
   else
    {
    while((ch[n])&&(ch[n]!=' ')&&(ch[n]!='
  ')&&(ch[n]!=' ')) n++;
    while((ch[n])&&((ch[n]==' ')||(ch[n]=='
  ')||(ch[n]=='\t'))) n++;
    }
  return False;
  }
  
  int verifie_contrainte(cont_r,cont)
   char *cont_r,*cont;
  {
  int n;
  
  /*  Si l'une des contraintes est absente, alors elle est verifiee  */
  if ((*cont_r=='\0')||(*cont=='\0')) return True;
  
  /*  S'il y a egalite parfaite, elle est verifiee  */
  if (!strcmp(cont_r,cont)) return True;
  
  /*  Sinon on test avec la table des contraintes  */
  
  for (n=0;TablContrainte[n][0][0];n++)
   if (!strcmp(cont_r,TablContrainte[n][0]))
    return TestSubChaine(cont,TablContrainte[n][1]);
  printf("Warning : contrainte inconnue -> %s
  ",cont_r);
  return False;
  }
  
  /*................................................................*/
  
  int compatible_pattern(posi,ch,pgauche,cont,Regles)
   int posi;
   char *ch,*pgauche,*cont;
   ty_regles *Regles;
  
  {
  /*  On verifie la partie gauche  */
  if (!verifie_pgauche(Regles[posi]->pgauche,pgauche))
   return False;
  if (!verifie_seatdroite(Regles[posi]->seat,Regles[posi]->pdroite,ch))
   return False;
  if (!verifie_contrainte(Regles[posi]->cont,cont))
   return False;
  return True;
  }
  
  int dichotomie_posi(p1,debr,finr,Regles)
   int p1,debr,finr;
   ty_regles *Regles;
  
  {
  int posi;
  
  while (finr>=debr)
   {
   /*
   printf("recherche entre %d et %d (borne : %d -> %d) avec p1=%d
  ",debr,finr,
      Regles[debr]->p1,Regles[finr]->p1,p1);
   */
   posi=(int)((finr-debr+1)/2)+debr;
   if (Regles[posi]->p1==p1)
    {
    /*  On revient au premier p1 de la classe  */
    while ((posi>0)&&(Regles[posi]->p1==p1)) posi--;
    if (Regles[posi]->p1!=p1) posi++;
    /*printf("On a trouve un p1 Ok en %d (avec p2=%d)
  ",posi,Regles[posi]->p2);*/
    return posi;
    }
   else
    if (Regles[posi]->p1>p1)
     debr=posi+1;
    else
     finr=posi-1;
   }
  return debr;
  }
  
  int calcule_limite(ch,twin)
   char *ch;
   int twin;
  {
  return ((twin*1000)+(twin*(400-(int)'z')));
  }
  
  int trouve_dicho_regle(ch,pgauche,cont,debr,finr,twin,tg,newlin,Regles,NbRegles)
   char *ch,*pgauche,*cont;
   int debr,finr,twin,tg,*newlin;
   ty_regles *Regles;
   int NbRegles;
  {
  int p1,posi,limite;
  
  p1=(twin*1000)+score_chaine(ch);
  limite=calcule_limite(ch,twin);
  
  /*  Recherche dichotomique sur p1  */
  
  posi=dichotomie_posi(p1,debr,finr,Regles);
  /*
  if (SeeReg) printf("nbregle=%d limite=%d  posi=%d regle[posi]->p1=%d
  ",
      NbRegles,limite,posi,Regles[posi]->p1); 
  */
  for (;(posi<NbRegles)&&(Regles[posi]->p1>=limite);posi++)
   {
   /*if (SeeReg) printf("    * %d regle[posi]->p1=%d
  ",posi,Regles[posi]->p1); */
  
   if (compatible_pattern(posi,ch,pgauche,cont,Regles))
    {
    /*if (SeeReg) printf("Trouve 
  ");*/
    return posi+1;
    }
   }
  *newlin=posi;
  /*if (SeeReg) printf("Pastrouve
  ");*/
  return False;
  }
  
  int trouve_dicho_regle_baktrak(ch,pgauche,cont,debr,finr,twin,tg,newlin,Regles,NbRegles,oldrules)
   char *ch,*pgauche,*cont;
   int debr,finr,twin,tg,*newlin;
   ty_regles *Regles;
   int NbRegles,oldrules;
  {
  int p1,posi,limite;
  
  p1=(twin*1000)+score_chaine(ch);
  limite=calcule_limite(ch,twin);
  
  /*  Recherche dichotomique sur p1  */
  posi=max(oldrules,dichotomie_posi(p1,debr,finr,Regles));
  /*printf("  DICHOMAX : debr=%d finr=%d oldrules=%d posi=%d
  ",debr,finr,oldrules,posi); */
  
  for (;(posi<NbRegles)&&(Regles[posi]->p1>=limite);posi++)
   if (compatible_pattern(posi,ch,pgauche,cont,Regles))
    return posi+1;
  *newlin=posi;
  return False;
  }
  
  /*................................................................*/
  
  /*  Modif pour le fonctionnement avec backtraking  */
  
  #define MaxPile 400
  
  struct { int n_in,n_out,n_regle; } Pile[MaxPile];
  int pindice=0;
  
  void Empile(ni,no,nr)
   int ni,no,nr;
  {
  if (pindice==MaxPile)
   { printf("Pile pleine, sorry so ....
  "); exit(0); }
  Pile[pindice].n_in=ni;
  Pile[pindice].n_out=no;
  Pile[pindice].n_regle=nr;
  pindice++;
  }
  
  int Depile(ni,no,nr)
   int *ni,*no,*nr;
  {
  if (pindice==0) return 0;
  pindice--;
  *ni=Pile[pindice].n_in;
  *no=Pile[pindice].n_out;
  *nr=Pile[pindice].n_regle;
  return 1;
  }
  
  char *phonetise_baktrak(ch_in,cont,Regles,NbRegles)
   char *ch_in,*cont;
   ty_regles *Regles;
   int NbRegles;
  
  {
  int ni,no,posi,twin,debr,pafini=True,pas_impasse,ndepile=-1,l,foistaille=4;
  static char ch[TailleLigne],ch_sortie[TailleLigne],*pgauche,sauvchar,*chresu,*chtemp;
  static char ch_entree[TailleLigne];
  
  chresu=(char*)malloc(sizeof(char)*TailleLigne*foistaille);
  
  pindice=0;
  
  if (SeeReg) printf("R+gles utilis+es : ");
  
  sprintf(ch_entree,"  %s  ",ch_in);
  
  for(ch_sortie[0]=chresu[0]='\0',ni=no=debr=0;pafini;)
   {
   for (pas_impasse=True;(pas_impasse)&&(ch_entree[ni])&&(ch_entree[ni]!='
  ');)
    {
    /*printf("Il reste a traiter : |%s|
  ",ch_entree+ni); */
  
    twin=min(MaxWindow,strlen(ch_entree+ni));
    strncpy(ch,ch_entree+ni,twin+1);
    sauvchar=ch_entree[ni];
    ch_entree[ni]='\0';
    pgauche=ch_entree;
    
    if (ndepile>=0) debr=ndepile; else debr=0;
    for(posi=0;(posi==0)&&(twin>0);twin--)
     {
     ch[twin]='\0';
     posi=trouve_dicho_regle_baktrak(ch,pgauche,cont,debr,NbRegles-1,
                  twin,ni,&debr,Regles,NbRegles,ndepile);
     }
    ch_entree[ni]=sauvchar;
    if (posi<=ndepile)
     {
     /* On evite l'emploi de la regle juste depilee */
     /*printf("  deja employee : %d (pour %s) - mise a 0
  ",posi,ch_entree);*/
  
     posi=0;
     }
    if (posi==0)
     pas_impasse=False;
    else
     {
     ndepile=-1; /* On reinitialise la derniere pile */
  
     Empile(ni,no,posi);
     /*printf("On empile : %d
  ",posi);*/
  
     if (SeeReg) printf("%d ",posi);
     if ((no+strlen(Regles[posi-1]->phon))>=TailleLigne)
      {
      printf("WARNING : taille de ch_sortie insuffisante !!!!
  ");
      exit(0);
      }
     strcpy(ch_sortie+no,Regles[posi-1]->phon);
     no=strlen(ch_sortie);
     ni+=strlen(Regles[posi-1]->seat);
     debr=0;
     }
    }
  
   if (pas_impasse)
    {
    l=strlen(chresu);
    if ((l+strlen(ch_sortie)+2)>=foistaille*TailleLigne)
     {
     /* WARNING : taille de ch_sortie insuffisante !!!!  */
     foistaille++;
     chtemp=(char*)malloc(sizeof(char)*TailleLigne*foistaille);
     strcpy(chtemp,chresu);
     free(chresu);
     chresu=chtemp;
     }
  
    /*printf("Taille resu avant = %d - Ajoute : %s",l,ch_sortie);*/
  
    chresu[l]='
  '; chresu[l+1]='\0';
    strcat(chresu,ch_sortie);
    
    /*printf(" - Taille apres : %d
  GLOB : %s
  ",strlen(chresu),chresu); */
   
    }
   else
    /*printf("IMPA : %s
  ",ch_sortie)*/;
   pafini=Depile(&ni,&no,&ndepile);
   /*printf("On depile : %d
  ",ndepile); */
  
   /*if (SeeReg) printf(" [BAKT] ");*/
   }
  if (SeeReg) printf("
  ");
  l=strlen(chresu);
  chresu[l]='
  '; chresu[l+1]='\0';
  
  return chresu;
  }
  
  /*................................................................*/
  
  char *phonetise(ch_in,cont,Regles,NbRegles)
   char *ch_in,*cont;
   ty_regles *Regles;
   int NbRegles;
  
  {
  int n,posi,twin,debr;
  static char ch[TailleLigne],*pgauche,sauvchar,*ch_sortie;
  static char ch_entree[TailleLigne];
  ch_sortie=(char*)malloc(sizeof(char)*TailleLigne);
  sprintf(ch_entree,"  %s  ",ch_in);
  if (SeeReg) printf("Regles utilisees : ");
  ch_sortie[0]='\0';
  for (n=0;(ch_entree[n])&&(ch_entree[n]!='
  ');)
   {
   twin=min(MaxWindow,strlen(ch_entree+n));
   strncpy(ch,ch_entree+n,twin+1);
   sauvchar=ch_entree[n];
   ch_entree[n]='\0';
   pgauche=ch_entree;
   debr=0;
   for(posi=0;(posi==0)&&(twin>0);twin--)
    {
    ch[twin]='\0';
    /*if (SeeReg) printf("test : |%s|
  ",ch);*/
  
    posi=trouve_dicho_regle(ch,pgauche,cont,debr,NbRegles-1,twin,n,&debr,Regles,NbRegles);
    }
   ch_entree[n]=sauvchar;
   if (posi==0)
    {
    /* On avance de 2 caracteres  */
    if (SeeReg) printf("Pas de rÉgles qui s'applique
  ");
    sprintf(ch,"%s%c%c",ch_sortie,ch_entree[n],ch_entree[n+1]);
    strcpy(ch_sortie,ch);
    n+=2;
    }
   else
    {
    if (SeeReg) printf("%d ",posi-1);
    strcat(ch_sortie,Regles[posi-1]->phon);
    n+=strlen(Regles[posi-1]->seat);
    }
   }
  if (SeeReg) printf("
  ");
  return ch_sortie;
  }
  
  /*................................................................*/
  
  /*  Re-affichage des regles triees  */
  
  void ChangeIIPartie(pg,t_cont,nlibre)
   char *pg;
   int *t_cont,*nlibre;
  {
  char c1[TailleLigne];
  int n=0,i=0,nu;
  
  if (pg[n]=='\0')
   {
   if ((*nlibre)==0) sprintf(c1,"l");
   else sprintf(c1,"l%d",(*nlibre));
   (*nlibre)++;
   }
  else
   {
   for(n=0,i=0;pg[n];n++)
    if (ContGraphik(pg[n],&nu))
     {
     if ((i!=0)&&(c1[i-1]!='.'))
      { c1[i++]='"'; c1[i++]='.'; }
     c1[i++]=pg[n];
     if (t_cont[nu]!=0) c1[i++]=(char) ('0'+t_cont[nu]);
     c1[i++]='.';
     t_cont[nu]++;
     }
    else
     {
     if ((i==0)||(c1[i-1]=='.')) c1[i++]='"';
     c1[i++]=pg[n];
     }
   if (c1[i-1]=='.')
    c1[i-1]='\0';
   else
    { c1[i]='"'; c1[i+1]='\0'; }
   }
  strcpy(pg,c1);
  }
  
  void ChangePartie(pg,pd)
   char *pg,*pd;
  {
  int *t_cont,n,i,nlibre=0;
  
  for (n=0;TablGraphik[n][0][0];n++);
  t_cont=(int *)malloc(sizeof(int)*(++n));
  for(i=0;i<n;i++) t_cont[i]=0;
  ChangeIIPartie(pg,t_cont,&nlibre);
  ChangeIIPartie(pd,t_cont,&nlibre);
  }
  
  void affiche_regles(Regles,NbRegles)
  ty_regles *Regles;
  int NbRegles;
  {
  int i,j,nu;
  char pgauche[TailleLigne],pdroite[TailleLigne];
  
  for (i=0;i<NbRegles;i++)
   {
   strcpy(pgauche,Regles[i]->pgauche);
   strcpy(pdroite,Regles[i]->pdroite);
   ChangePartie(pgauche,pdroite);
   printf("regle(%d,<%s,\"%s\",%s>,\"%s\",\"%s\",\"%s\") ->",
      i+1,pgauche,Regles[i]->seat,pdroite,
      Regles[i]->phon,Regles[i]->cont,Regles[i]->exemple);
  
   for (j=0;pgauche[j];j++)
     if (ContGraphik(pgauche[j],&nu))
      if (SiChiffre(pgauche[j+1]))
       printf("
          classe(%c%c,\"%c\")",pgauche[j],pgauche[j+1],pgauche[j]);
      else
       printf("
          classe(%c,\"%c\")",pgauche[j],pgauche[j]);
   for (j=0;pdroite[j];j++)
     if (ContGraphik(pdroite[j],&nu))
      if (SiChiffre(pdroite[j+1]))
       printf("
          classe(%c%c,\"%c\")",pdroite[j],pdroite[j+1],pdroite[j]);
      else
       printf("
          classe(%c,\"%c\")",pdroite[j],pdroite[j]);
   printf(" ;
  ");
   }
  }
    
  /*................................................................*/
  
  /*  Main Program  */
  
  void FindConstraint(ch,cont,graphie)
   char *ch,*cont;
  {
  int n,i,j;
  
  cont[0]='\0';
  
  if (ch[0]=='"')
   {
   ch[0]=' ';
   for(n=1;ch[n]!='"';n++);
   ch[n]=' ';
   }
  else
   for (n=0;(ch[n])&&(ch[n]!='
  ')&&(ch[n]!=' ');n++);
  
  if (ch[n]=='
  ') ch[n]='\0'; if (ch[n]=='\0') return;
  
  for (j=n;(ch[n])&&(ch[n]!='
  ')&&(ch[n]==' ');n++);
  if (ch[n]=='
  ') ch[n]='\0'; if (ch[n]=='\0') return;
  for (i=0;(ch[n])&&(ch[n]!='
  ')&&(ch[n]!=' ');n++,i++) cont[i]=ch[n];
  ch[j]='\0'; cont[i]='\0';
  }
  
  void DecoupeLigne(ligne,graphie,Ph,cont)
   char *ligne,**graphie,**Ph,**cont;
  {
  int n;
  *graphie=ligne;
  for(n=0;(ligne[n])&&(ligne[n]!=' ');n++);
  if (ligne[n]=='\0') { printf("Mauvais format : %s
  ",ligne); exit(0); }
  ligne[n]='\0';
  *Ph=ligne+n+1;
  for(++n;(ligne[n])&&(ligne[n]!=' ');n++);
  
  if (ligne[n]=='\0')
   {
   /*printf("Mauvais format : %s
  ",ligne); exit(0);*/
   *cont=ligne+n;
   }
  else
   {
   ligne[n]='\0';
   *cont=ligne+n+1;
   }
  }
  
  /*................................................................*/
  
  int main(argc,argv)
   int argc;
   char **argv;
  {
  int     n,i,NbRegles;
  int     siafregles=False;
  char    fichregles[TailleLigne],path_fich[TailleLigne],*retour,
  	ligne[TailleLigne],*Ph,*cont,*graphie;
  ty_regles *Regles;
  
  fichregles[0]='\0';   /*  init du fich de regles courantes  */
  
  for (n=1;n<argc;n++)
   switch (argv[n][1])
      {
      case 'a' :  /*  Affiche les regles triees  */
          siafregles=True;
          break;
      case 'r' :  /*  Specifie un fichier regles autre que regles_phon.pro3  */
          strcpy(fichregles,argv[++n]);
          break;
      case 'h' :  /*  Affiche la liste des options possibles  */
          printf("Usage:  rumbas [-a|-r|-h|-s|-tnom-dico]
  ");
          printf("              a : affiche le fichier de regles triees
  ");
          printf("              r : charge un fichier de regles different'
  ");
          printf("              h : affiche ce message
  ");
          printf("              s : edite des statistiques
  ");
          printf("              t : fait un test des regle avec le dico nom-dico
  ");
          exit(0);
      }
  
  #ifdef COMPIL_MSDOS
  for (i=n=0;argv[0][n];n++) if (argv[0][n]=='\\') i=n;
  if (i==0) strcpy(path_fich,".\\");
  else
   {
   strncpy(path_fich,argv[0],i+1);
   path_fich[i+1]='\0'; 
   }
  #else
  for (i=n=0;argv[0][n];n++) if (argv[0][n]=='/') i=n;
  if (i==0) strcpy(path_fich,"./");
  else
   {
   strncpy(path_fich,argv[0],i+1);
   path_fich[i+1]='\0'; 
   }
  #endif
  
  if (fichregles[0]=='\0')
   {
  #ifdef COMPIL_MSDOS
   strcpy(fichregles,"data\\rule_variante.pro");
  #else
   strcpy(fichregles,"data/rule_variante.pro");
  #endif
   Regles=lecture_regles(path_fich,fichregles,&NbRegles);
   }
  else /*  Dans le cas ou un autre fichregle est select on met pas le path  */
   Regles=lecture_regles("",fichregles,&NbRegles);
  
  if (siafregles)
   { affiche_regles(Regles,NbRegles); exit(0); }
  
  while(fgets(ligne,TailleLigne,stdin))
   {
   ligne[strlen(ligne)-1]='\0';
   DecoupeLigne(ligne,&graphie,&Ph,&cont);
   retour=phonetise(Ph,cont,Regles,NbRegles);
   if (retour)
    {
    printf("%s %s %s
  ",graphie,retour,cont);
    free(retour);
    }
   else printf("%s %s %s
  ",graphie,Ph,cont);
   }
  exit(0); 
  }
   
  /*................................................................*/