/****************************************************************************/
/*  
**        T U L K K I E T . C
**
** Tiedostossa on TULKKI-ohjelman sanojen hakemisessa tarvittavat
** aliohjelmat.
**
** Aliohjelmat:
**    muuta_kaannos          - muuttaa muodon "sana/s-r" tarvittavaan muotoon
**    tulosta_kaannos        - tulostaa vastinsanat sanastosta
** Apualiohjelmat:
**    muuta_indeksiksi       - muuttaa muodon sr kielien indekseiksi
**    sama_sana              - tarkistaa onko "han (mask)" ja "HA*" samoja
**
**  Tekij„t:          Vesa Lappalainen
**                    Ohjelmointikurssi 1991
**  Tehty:            6.12.1991
**  Muutettu:
**  Mit„ muutettu:   
**
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "tulkki.h"
#include "mjonot.h"


/****************************************************************************/
void                      /*                                                */
muuta_indekseiksi(        /*                                                */
  char *jono             ,/* s   Jono joka muutetaan indekseiksi.           */
  Kielet_tyyppi *kielet  ,/* t   Taulukko jonne indeksit laitetaan.         */
  char *lyhenteet         /* s   Tunnetut lyhenteet.                        */
)    
/* 
** Funktiolla muutetaan muoto rse muotoon 1 0 2
**
** Globaalit: MAX_KIELIA
** Esimerkki: jono = "RE" lyhenteet = "SRE" - 1 2 
----------------------------------------------------------------------------*/
{
  int lkm=0,i,lp=strlen(lyhenteet);

  for (i=0; i<lp; i++ ) {
    if ( !strchr(jono,lyhenteet[i]) ) continue;
    kielet->kielet[lkm++] = i;
    if ( lkm >= MAX_KIELIA ) break;
  }

  kielet->lkm = lkm;
}


/****************************************************************************/
int                       /*                                                */
muuta_kaannos(            /*                                                */
  Kaannos_tyyppi *kaannos,/* s,t Mist„ mihin k„„nnet„„n                     */
  char *jono             ,/* s,t Jono, josta k„„nn”sohje etsit„„n.          */
  char *lyhenteet         /* s   Tunnetut lyhenteet.                        */
)    
/* 
** Funktiolla muutetaan merkkijonossa oleva k„„nn”sohje kielien indekseiksi.
** Samalla merkkijono katkaistaan kauttaviivan kohdalta.
**
** Muuttuu:   jono
** Kutsuu:    poista_tyhjat
**            palanen
**            kopioi_jono
**            jono_isoksi
**            muuta_indekseiksi
** Esimerkki: 
** | | Sy”tt”       | ohjelmalla v„litett„v„  k„„nn”skieli    |Esim. |kieli  |
** |-|--------------|-----------------------------------------|------|-------|
** |1| kissa        | oletus (sama kuin ed. kutsussa)         |      |       |
** |2| kissa/       | oletus (sama kuin ed. kutsussa, sopimus)|      |       |
** |3| kissa/-      | kaikki-kaikki                           |-     |sre-sre|
** |4| kissa/x-y    | xy-xy                                   |s-r   |sr-sr  |
** |5| kissa/x-y#   | x-y#                                    |s-re  |s-re   |
** |6| kissa/x#-y   | x#-y                                    |sr-e  |sr-e   |
** |7| kissa/x#-y#  | x#-y#                                   |sr-sre|sr-sre |
** |8| kissa/#-     | #-kaikki                                |s-    |s-sre  |
** |9| kissa/-#     | kaikki-#                                |-s    |sre-s  |
----------------------------------------------------------------------------*/
{
  char *kielet,mista[30],mihin[30];
  int jaljella;

  poista_tyhjat(palanen(jono,"/",&jaljella));               
  if (!jaljella) return 0;                                 /* 1 */

  kielet=poista_tyhjat(palanen(NULL,"/",&jaljella));    

  if (!*kielet) return 0;                                  /* 2 */

  kopioi_jono(N_S(mista),poista_tyhjat(palanen(kielet,"-",&jaljella)));
  kopioi_jono(N_S(mihin),poista_tyhjat(palanen(NULL,"-",&jaljella)));
  jono_isoksi(mista);
  jono_isoksi(mihin);

  if (!*mista) kopioi_jono(N_S(mista),lyhenteet);          /* 3,9 */
  if (!*mihin) kopioi_jono(N_S(mihin),lyhenteet);          /* 3,8 */

  if ( (mista[1]==0) && (mihin[1]==0) ) {                  /* 4   */
    mista[1]=mihin[0]; mista[2]=0;        /* s-r   -> sr-r        */
    mihin[1]=mista[0]; mihin[2]=0;        /* sr-r  -> sr-rs       */
  }

  muuta_indekseiksi(mista,&(kaannos->mista),lyhenteet);
  muuta_indekseiksi(mihin,&(kaannos->mihin),lyhenteet);

  return 0;
}


/****************************************************************************/
int                       /* 0 = on sama sana                               */
sama_sana(                /* 1 = ei ole sama sana                           */
  char *sana             ,/* s   Tutkittava sana                            */
  char *maski             /* s   Verrattava maski, joka jo muutettu isoiksi!*/
)    
/* 
** Funktiolla verrataan onko sana ja maski samat.  Koska sana voi olla my”s
** muotoa han (mask.) ja etsit„„n vain han, niin sulun j„lkeinen osa
** t„ytyy poistaa enne vertailua.  Samoin sana t„ytyy muuttaa isoiksi
** kirjaimiksi.
**
** Kutsuu:    kopioi_jono
**            jono_isoksi
**            wildmat
**            palanen
** Esimerkki: sana = "han (mask.)" maski = "HA*"  -> 0
**            sana = "hon (fem.)"  maski = "HA*"  -> 1
----------------------------------------------------------------------------*/
{
  char isana[80]; int jaljella;

  kopioi_jono(N_S(isana),sana);
  jono_isoksi(poista_tyhjat(palanen(isana,"(",&jaljella)));
  return wildmat(isana,maski);
}


/****************************************************************************/
void                      /*                                                */
tulosta_kaannos(          /*                                                */
  Sanasto_tyyppi *sanasto,/* s   Sanasto josta tulostetaan.                 */
  char *maski            ,/* s   Sana jonka k„„nn”s tulostetaan.            */
  Kaannos_tyyppi *kaannos /* s   Mist„ mihin k„„nnet„„n?                    */
)    
/* 
** Funktiolla tulostetaan sana k„„nnettyn„ kaannos-ohjeen mukaisesti.
**
** Kutsuu:    sana_isoksi
**            kopioi_jono
**            liita_jono
**            sama_sana
**            jono_pieneksi
** Algoritmi: K„yd„„n l„pi kaikki rivit
**              K„yd„„n l„pi rivill„ kaikki mist„-kielet
**                Tulostetaan kaikki mihin-kielet paitsi mist„-kieli
** Esimerkki:  Sana >h* /-[RET]
**   Tulostus: suomi   : h„n         = ruotsi  : han (mask.)
**                                   = englanti: he (mask.)
**             ruotsi  : han (mask.) = suomi   : h„n
**                                   = englanti: he (mask.)
**             englanti: he (mask.)  = suomi   : h„n
**                                   = ruotsi  : han (mask.)
**             suomi   : h„n         = ruotsi  : hon (fem.)
**                                   = englanti: she (fem.)
**             ruotsi  : hon (fem.)  = suomi   : h„n 
**                                   = englanti: she (fem.)
**             ...
----------------------------------------------------------------------------*/
{
  int mista_kieli,mihin_kieli,i,j,pisin_mista=0,pisin_mihin=0,pit;
  int nyt_kieli=-1,nyt_mihin=-1,loytyi=0;
  char kieli[80],mkieli[80],sana[80],nyt_sana[80]="";
  char mista_k,mihin_k;
  Sanat_tyyppi *sana_p;

  /* Etsit„„n pisimm„t kielet tulosteiden muotoilua varten:                 */
  for (i=0; i<kaannos->mista.lkm; i++) {
    pit = strlen(sanasto->kielet->sanat[kaannos->mista.kielet[i]]);
    if ( pit > pisin_mista ) pisin_mista = pit;
  }
  for (i=0; i<kaannos->mihin.lkm; i++) {
    pit = strlen(sanasto->kielet->sanat[kaannos->mihin.kielet[i]]);
    if ( pit > pisin_mihin ) pisin_mihin = pit;
  }

  jono_isoksi(maski);

  sana_p = sanasto->kielet->seuraava;

  while ( sana_p != NULL ) {                                /* Kaikki rivit */
    for (i=0; i<kaannos->mista.lkm; i++) {                  /* Mista-kielet */
      mista_kieli = kaannos->mista.kielet[i];
      if ( sama_sana(sana_p->sanat[mista_kieli],maski) == 0 ) {

        /* Tulostusta varten apumuuttujia jottei kielt„ ja sanaa toisteta:  */
        if ( nyt_kieli != mista_kieli ) {
          kopioi_jono(N_S(kieli),sanasto->kielet->sanat[mista_kieli]);
          jono_pieneksi(kieli); mista_k=':';
          nyt_kieli = mista_kieli; 
          nyt_sana[0]=0; /* Jos kieli vaihtuu niin saa sanakin vaihtua!     */
        }
        if (strcmp(nyt_sana,sana_p->sanat[mista_kieli])) {
          kopioi_jono(N_S(sana),sana_p->sanat[mista_kieli]);
          kopioi_jono(N_S(nyt_sana),sana);
        }

        for (j=0; j<kaannos->mihin.lkm; j++) {
          mihin_kieli = kaannos->mihin.kielet[j];
          if ( mista_kieli == mihin_kieli ) continue;
          if ( nyt_mihin != mihin_kieli ) {
            kopioi_jono(N_S(mkieli),sanasto->kielet->sanat[mihin_kieli]);
            jono_pieneksi(mkieli); mihin_k=':';
            nyt_mihin = mihin_kieli;
          }

          printf("%-*s%c %-15s = %-*s%c %s\n",pisin_mista,
                  kieli,mista_k,sana,pisin_mihin,
                                    mkieli,mihin_k,
                                        sana_p->sanat[mihin_kieli]);

          kieli[0]=0; sana[0]=0; mkieli[0]=0; mista_k=' '; mihin_k=' ';
          loytyi = 1;
        } /* for - mihin_kieli                                              */ 

      } /* if (sama_sana)                                                   */
    } /* for - mista_kieli                                                  */
    sana_p = sana_p->seuraava;
  } /* while ( sana_p != NULL )                                             */

  if (!loytyi) printf("Ei l”ydy sanastosta!\n");
}