/****************************************************************************/
/*
**        K E R H O E T S . C
**
** Kerhosta tietyn ehdon t�ytt�vien j�senien etsiminen
**
** Aliohjelmat:
**    lajittele              - tekee permutaatiotaulukon valitun kent�n
**                             mukaisesti
**    etsi_indeksit          - etsii annetun maskin ehdon t�ytt�vi� j�seni�
**    kysy_kentat_ja_etsi    - interaktiivinen kysyminen, etsiminen,
**                             selaaminen, korjailu ja poisto
**    laske_montako_muuta    - etsii onko muita kuin valittua j�sent�
**       
**
**  Tekij�t:          Vesa Lappalainen
**                    Ohjelmointikurssi 1991
**  Tehty:            13.11.1991
**  Muutettu:         17.11.1991/vl
**  Mit� muutettu:     rakennetta siistitty
**                     lis�tty lajittelu
**  Muutettu:         23.11.1991/vl
**  Mit� muutettu:     tyyppik�site yleistetty
**  Muutettu:         24.12.1991/vl
**  Mit� muutettu:     ep�yht�l�haku
**                     negatiivisten lukujen lajittelu korjattu
**                     tyhj�n sotun lajittelu korjattu
**  Muutettu:         4.12.1993/vl
**  Mit� muutettu:     laita_selaus_kohdalla korjattu siten, ettei
**                     viimeisen poisto n�yt� v��r�� j�sent�
*/

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

#define MERKKEJA 256

/****************************************************************************/
/*    
**      T i e t o t y y p i t                                                 
*/                                                                          
typedef struct {   /* Lajittelussa apuna k�ytett�v� tietue.                 */
  int kentan_nro;               /* Kentt� jonka mukaan lajitellaan.         */
  Jasen_tyyppi **jasenet;       /* Osoitin osoitintaulukon alkuun.          */
} Vertaa_tyyppi;                /*                                          */

typedef struct {   /* Avaimen muodostuksessa k�ytett� tyyppi                */
  int  alustettu;               /* Onko taulukko alustettu vai ei.          */
  char avainarvo[MERKKEJA];     /* Miten kukin kirjain muuttuu              */
} Jarjestys_avain_tyyppi;       /*


/****************************************************************************/
/*    
**      G l o b a a l i t  muuttujat                                  
*/
static Jarjestys_avain_tyyppi 
  JARJESTYS = {0,""};           /* Avaimen muodostuksessa k�ytett�v� taul.  */

/****************************************************************************/
/*  
**      A L I O H J E L M A T                                                   
*/


#define A_1(mika,miksi) j->avainarvo[(unsigned char)mika] = miksi
#define A_A(mi,mp,miksi) A_1(mi,miksi); A_1(mp,miksi)

/****************************************************************************/
void                        /*                                              */
alusta_jarjestys(           /*                                              */
  Jarjestys_avain_tyyppi *j /* s,t Alustettava j�rjestystaulukko.           */
)    
/* 
** Aliohjelmalla alustetaan avaimen muodostamisessa tarvittava taulukko.
** Tyhj�, v�limerkit ja tuntemattomat = 0x20
** '0' = 0x30 ... '9' = 0x39
** 'A' = 0x41 ... 'Z' = 0x5a
** '�' = 0x5b ...
**
**
----------------------------------------------------------------------------*/
{
  int i;

  if (j->alustettu) return;
  j->alustettu = 1;

  for (i=0; i<MERKKEJA; i++) A_1(i,0x20); /* Kaikki tuntemat. merkit v�lil. */

  A_1('0',0x30); A_1('1',0x31); A_1('2',0x32); A_1('3',0x33); A_1('4',0x34); 
  A_1('5',0x35); A_1('6',0x36); A_1('7',0x37); A_1('8',0x38); A_1('9',0x39); 

  A_A('A','a',0x41);  A_A('B','b',0x42);  A_A('C','c',0x43);  
  A_A('D','d',0x44);  A_A('E','e',0x45);  A_A('F','f',0x46);
  A_A('G','g',0x47);  A_A('H','h',0x48);  A_A('I','i',0x49);
  A_A('J','j',0x4a);  A_A('K','k',0x4b);  A_A('L','l',0x4c);
  A_A('M','m',0x4d);  A_A('N','n',0x4e);  A_A('O','o',0x4f);
  A_A('P','p',0x50);  A_A('Q','q',0x51);  A_A('R','r',0x52);
  A_A('S','s',0x53);  A_A('T','t',0x54);  A_A('U','u',0x55);
  A_A('V','v',0x56);  A_A('W','w',0x57);  A_A('X','x',0x58);
  A_A('Y','y',0x59);  A_A('Z','z',0x5a);
  A_A('�','�',0x59);  
  A_A('�','�',0x5b);  A_A('�','�',0x5c);  A_A('�','�',0x5d);

}

#undef A_1
#undef A_A

/****************************************************************************/
void                      /*                                                */
tee_avain(                /*                                                */
  int kentan_nro         ,/* s   Kent�n numero, joka muutetaan avaimeksi.   */
  Jasen_tyyppi *jasen     /* s,t J�sen jonka tiedoista avain tehd��n.       */
)    
/* 
** Aliohjelmalla tehd��n lajitteluavain j�senen tiedoista.
** Oletus: Avainkent�n koko v�hint��n 20 tavua.
**
** Globaalit: JARJESTYS
** Kutsuu:    kentan_tyyppi
**            kentan_osoite
**            kopioi_jono
**            poista_tyhjat
----------------------------------------------------------------------------*/
{
  void *p; char s[20]; unsigned char *a; 
  int i; double d; 
  int tyyppi;

  if (!JARJESTYS.alustettu) alusta_jarjestys(&JARJESTYS);

  i = sizeof(jasen->avain);
  if (i<20) {
    printf("TEE AVAIN: Liian pieni avainkentt�!\n");
    return;
  }

  tyyppi = kentan_tyyppi(kentan_nro,jasen);
  p      = kentan_osoite(kentan_nro,jasen);

  switch (tyyppi) {
    case Tjono:
      kopioi_jono(N_S(jasen->avain),p);
      poista_tyhjat(jasen->avain);
      for (a=(unsigned char *)jasen->avain; *a; a++) {
        *a = JARJESTYS.avainarvo[*a];
      }
      poista_tyhjat(jasen->avain);
      return; 

    case Tsotu:
      kopioi_jono(N_S(s),p); liita_jono(N_S(s),"      ");
      kopioi_jono(N_S(jasen->avain),s);
      jasen->avain[0] = s[4];  /* Vaihdetaan pv ja vuosi kesken��n! */
      jasen->avain[1] = s[5];
      jasen->avain[4] = s[0];
      jasen->avain[5] = s[1];
      return;

    case Tint: 
      i = *(int *)p;
      sprintf(jasen->avain,"%+05d",i);
      if ( jasen->avain[0] == '-' ) jasen->avain[0]='+'-1; /* jotta - < + */
      return;

    case Tdouble: 
      d = *(double *)p;
      sprintf(jasen->avain,"%+015.7lf",d);
      if ( jasen->avain[0] == '-' ) jasen->avain[0]='+'-1; /* jotta - < + */
      return;

    default:
      printf("TEE AVAIN: Ei ole kentt�� %d!\n",kentan_nro); 
      return;
      
  }
}

static Vertaa_tyyppi VERTAA;    /* Tiedonv�litys lajittele -> vertaile      */

/****************************************************************************/
int                       /* -1  1. pienempi                                */
vertaile(                 /*  0  Yht�suuria                                 */
                          /*  1  1. suurempi                                */
  const void *a          ,/* s   1. verrattavan indeksi.                    */
  const void *b           /* s   2. verrattavan indeksi.                    */
)    
/* 
** Funktiolla verrataan kahta indeksin avulla annettua j�sent� toisiinsa.
** Verrattava kentt� katsotaan globaalista muuttujasta VERTAA.kentan_nro.
**
** Globaalit: VERTAA
----------------------------------------------------------------------------*/
{
  return (strcmp(
    VERTAA.jasenet[*(int *)a]->avain,
    VERTAA.jasenet[*(int *)b]->avain
  ));
}


/****************************************************************************/
void                      /*                                                */
lajittele(                /*                                                */
                          /*                                                */
  Kerho_tyyppi *kerho    ,/* s   Lajiteltava kerho                          */
  Jarjestys_tyyppi *jarj ,/* s,t Lajiteltava permutaatiotaulukko            */
  int kentan_nro          /* s   Mink� kent�n mukaan lajitellaan            */
)    
/* 
** Funktiolla lajitellaan jarj taulukko annetun kent�n mukaan oikeaan
** j�rjestykseen.  Lajiteltava kentt� valitaan kentan_nro mukaan.
** Mik�li jarj.indekseja = 0, alustetaan taulukko 0 1 2 3
** muuten k�ytet��n olemassa olevaa numerointia.
** Ei viel� j�rjest� AND ja OR etsimisen mukaan!
** 
** Globaalit: K�ytt�� vertaa -funktion kanssa yhteist� aluetta VERTAA
** Kutsuu:    qsort
** Algoritmi: V�litet��n permutaatiotaulukko qsort aliohjelmalle
----------------------------------------------------------------------------*/
{
  int j,ind,max_ind;


  if ( (kentan_nro < 0) || !jarj->jarjesta ) return;

  /* Permutaation alustus tarvittaessa.                                     */
  if ( jarj->indekseja == 0 ) {
    max_ind = jarj->max_koko;
    if ( max_ind > kerho->jasenia ) max_ind = kerho->jasenia;
    ind = 0;
    for (j=0; j<max_ind; j++) 
      if ( kerho->jasenet[j] )      /* NULL-j�seni� ei laiteta              */
        jarj->indeksit[ind++] = j;
    jarj->indekseja = ind;
  }


  for (j=0; j<jarj->indekseja; j++) {
    tee_avain(kentan_nro,kerho->jasenet[jarj->indeksit[j]]);
  }

  VERTAA.kentan_nro = kentan_nro;
  VERTAA.jasenet    = kerho->jasenet;

  qsort( (void *)(jarj->indeksit),  /* Lajiteltava taulukko                 */
         jarj->indekseja,           /* Taulukon alkioiden lukum��r�         */
         sizeof(jarj->indeksit[0]), /* Yksitt�isen alkion koko              */
         vertaile);                 /* Vertailualiohjelman nimi             */
}


/****************************************************************************/
int                       /* 0 = ei l�ydy muita joihin t�sm��               */
laske_montako_muuta(      /* muuten muiden t�sm��vien m��r�                 */
  Kerho_tyyppi *kerho    ,/* s   Kerho josta etsit��n                       */
  int kentta             ,/* s   Kentt� johon verrataan                     */
  char *jono             ,/* s   Jono jota etsit��n                         */
  int  kuka_ei           ,/* s   Henkil� jota ei etsit�.                    */
  int  *viimeinen        ,/* t   Indeksi viimeiseen l�ytyneeseen            */
  int  *oliko_kuka_ei     /* t   Oliko se joka ei saa olla                  */
)
/*
** Funktiolla lasketaan montako muuta ehdon t�sm�lleen t�ytt�v�� j�sent�
** kerhosta l�ytyy.  Palautetaan parametrina my�s viimeinen johon t�sm�si.
**
** Algoritmi: Verrataan jokaista paitsi ei-etsitt�v��.
----------------------------------------------------------------------------*/
{
  int j,montako=0;
  *viimeinen      = -1;
  *oliko_kuka_ei  = 0;
  for (j=0; j<kerho->jasenia; j++) {
    if ( strcmp(jono,kentta_jonoksi(kentta,kerho->jasenet[j]) ) == 0 ) {
      if ( j == kuka_ei ) *oliko_kuka_ei = 1;
      else {
        montako++;
        *viimeinen = j;
      }
    }
  }
  return montako;
}

/****************************************************************************/
typedef enum { 
 YHT,
 ERIS,
 PIEN,
 PIENYHT,
 SUUR,
 SUURYHT
} Vertailu_oper_tyyppi;

typedef struct {
  char *ehto;
  int  pit;
  Vertailu_oper_tyyppi kasky;
} Vertailu_tyyppi;

static Vertailu_tyyppi EHDOT[] = {
  { ""  , 0, YHT},
  { "==", 2, YHT},
  { "!=", 2, ERIS},
  { "<=", 2, PIENYHT},
  { "<" , 1, PIEN},
  { ">=", 2, SUURYHT},
  { ">" , 1, SUUR},
  { NULL, 0, YHT}
};

/****************************************************************************/
int                       /* 1 = ei t�sm��                                  */
tutki_tasmaako(           /* 0 = t�sm��                                     */
  Jasen_tyyppi *jasen    ,/* s   Tutkittva j�sen                            */
  char *ikentta          ,/* s   Kentt� muutettuna isoiksi kirjaimeksi      */
  char *maski            ,/* s   Maski muutettuna isoiksi kirjaimeksi       */
  int knro                /* s   Kent�n numero.                             */
)    
/* 
** Funktiolla tutkitaan onko annettu ehto voimassa.  Ehdot:
**  <, <= ,> , >= , !=, ==
** Mik�li ehtoa ei ole annettu, tulkitaan ehto tavalliseksi
** wildmat vertailuksi.
**
** Globaalit: EHDOT
** Muuttuu:   jasen->avain
** Kutsuu:    kentta_jonoksi
**            jono_kentaksi
**            wildmat
** Esimerkki: ikentta "20", maski "<=50"  -> 0
----------------------------------------------------------------------------*/
{
  int i,tulos,ehto_ind=0; char *m; Jasen_tyyppi mjasen;

  for (i=1; EHDOT[i].ehto; i++) 
    if ( strstr(maski,EHDOT[i].ehto) == maski ) { 
      ehto_ind = i; break; 
    }

  m = maski+EHDOT[ehto_ind].pit;

  switch ( EHDOT[ehto_ind].kasky ) {

    case YHT:     
      return wildmat(ikentta,m);

    case ERIS:    
      return !wildmat(ikentta,m);

    case PIEN:
    case PIENYHT:
    case SUUR:
    case SUURYHT:
      jono_kentaksi(knro,&mjasen,m);
      tee_avain(knro,&mjasen);
      tee_avain(knro,jasen);
      tulos = strcmp(jasen->avain,mjasen.avain);
      switch ( EHDOT[ehto_ind].kasky ) {
        case PIEN:    return !(tulos<0);
        case PIENYHT: return !(tulos<=0);
        case SUUR:    return !(tulos>0);
        case SUURYHT: return !(tulos>=0);
      }

    default:      
      return 1;
  }
}


/****************************************************************************/
int                       /*                                                */
etsi_indeksit(            /* = l�ytyneiden indeksien lukum��r�              */
  Kerho_tyyppi *kerho    ,/* s   Kerho josta etsit��n                       */
  int kentta             ,/* s   Kent�n numero, josta etsit��n (tai AND,OR) */
  Haku_tyyppi *maski     ,/* s   Arvot joiden mukaan etsit��n.              */
  Jarjestys_tyyppi *etsi  /* t   Taulukko jonne l�ytyneet talletetaan       */
)
/* 
** Funktiolla etsit��n maskin mukaisia kentti� rekisterist�.
** Palautetaan taulukossa niiden paikkojen indeksit, joista
** maski l�ytyi.  Mik�li kentt� on OR etsit��n TAI-toimintona kaikkia
** kentti� (eli jos yksikin kentt� t�sm��) ja mik�li kentta==AND
** etsit��n JA-toimintona (eli kaikkien kenttien t�ytyy t�sm�t�).
** Jos maskin kentt� on tyhj�, ei kentt�� verrata lainkaan.
** Jos maskin kentt� alkaa ~, niin vastaavan kent�n t�ytyy olla tyhj�.
** Mik�li ket��n ei l�ydy, laitetaan silti indeksit[0]=0, jotta siihen voidaan
** varmasti viitata.
**
** Kutsuu:    jono_isoksi
**            kopioi_jono, N_S
**            wildmat
** Algoritmi: Kokeillaan jokaista paikkaa ja merkit��n l�ytym�t yl�s.
**            Isot ja pienet kirjaimet samaistetaan.
----------------------------------------------------------------------------*/
{
  char isana[80],*m;
  int j,k,k1=kentta,k2=kentta,samat,yksi_riittaa=1;


  if ( kentta==ETSI_AND || kentta==ETSI_OR ) { k1=0; k2=KENTTIA-1; }

  etsi->indekseja=0; etsi->indeksit[0]=0;
  if ( kentta == ETSI_AND ) yksi_riittaa=0;     /* Muille paitsi ANDille    */

  for (k=k1; k<=k2; k++) 
    jono_isoksi(maski[k]);

  for (j=0; j<kerho->jasenia; j++) {            /* Tutkitaan kaikki j�senet */

    if (!kerho->jasenet[j]) continue;           /* Ohitetaan NULL-osoittimet*/
    samat=0;

    for (k=k1; k<=k2; k++) {                    /* Tarkistetaan kent�t.     */
      kopioi_jono(N_S(isana),kentta_jonoksi(k,kerho->jasenet[j]));
      jono_isoksi(isana);

      m = maski[k];

      if (!*m) continue;                  /* Tyhjist� kentist� ei v�litet�. */

      samat = !tutki_tasmaako(kerho->jasenet[j],isana,m,k);

      if ( samat && yksi_riittaa ) break;       /* Yksi ja TAI l�ytyi       */

      if ( (!samat) && (!yksi_riittaa) ) break; /* JA ei l�ydy              */

    }

    if ( samat ) {
      etsi->indeksit[etsi->indekseja++]=j;
      if ( etsi->indekseja>=etsi->max_koko ) break;
    }
  }

  if ( etsi->indekseja > 1 ) lajittele(kerho,etsi,k1);
  return etsi->indekseja;
}


/****************************************************************************/
void                      /*                                                */
laita_selaus_kohdalla(    /*                                                */
  Kerho_tyyppi *kerho    ,/* s   Selailtavan kerho tiedot.                  */
  Selaus_tyyppi *selaus   /* s,t Selattavat tiedot.                         */
)
/*
** Aliohjelmalla laitetaan selaus-tietueen kohdalla kent�n arvo oikeisiin
** rajoihin.  Samalla muutetaan kerhon nykyj�sen.
** Muuttuu:   selaus->kohdalla
**            kerho->nykyjasen
----------------------------------------------------------------------------*/
{
  if ( selaus->kohdalla < 0 ) selaus->kohdalla = 0;
  if ( selaus->kohdalla >= selaus->selattavat->indekseja )
    selaus->kohdalla = selaus->selattavat->indekseja - 1; /* korj. 4.12.93  */
  if ( selaus->selattavat->indekseja <= 0 ) { /* T�m� vain kun mit��n ei ole*/
    selaus->selattavat->indekseja   = 0;
    selaus->kohdalla                = 0;
    selaus->selattavat->indeksit[0] = 0;
  }

  kerho->nykyjasen = selaus->selattavat->indeksit[selaus->kohdalla];
}


/****************************************************************************/
char                      /*                                                */
selaile(                  /* Viimeksi painettu merkki (paitsi + tai -)      */
  Kerho_tyyppi *kerho    ,/* s   Selailtavan kerho tiedot.                  */
  Selaus_tyyppi *selaus   /* s,t Selattavat tiedot.                         */
)
/*
** Funktiolla selataan selaus-listassa olevia henkil�it�.
** Mik�li painetaan muuta kuin + tai -, palautetaan painettu n�pp�in.
** Painetuiksi sallitaan kuitenkin vain listassa olevat n�pp�imet
** sek� +, - ja RET.
** Aluksi tulostetaan kohdalla oleva henkil� (mik�li t�llainen on olemassa).
** T�m�n j�lkeen tulostetaan viesti, johon lis�t��n mahdollisesti per��n
** tieto + ja - k�yt�st�, mik�li n�m� ovat olemassa.
**
** Muuttuu:   selaus->kohdalla
**            kerho->nykyjasen
** Sy�tt�:    n�pp�imist�
** Tulostus:  n�ytt��n
** Kutsuu:    tulosta_jasen
**            kopioi_jono, N_S
**            liita_jono
**            odota_nappain
** Esimerkki: viesti = "Selaile" vali = ' ' ja on selattavia kump. suuntaan
**            tulostaa kohdalla olevan j�senen tiedot ja
**            "Selaile, seuraava (+), edellinen (-):"
----------------------------------------------------------------------------*/
{
  int suunta=0;
  char painettu,vali;
  char sallitut[80];


  while (1) {

    selaus->kohdalla += suunta;

    laita_selaus_kohdalla(kerho,selaus);

    if ( selaus->selattavat->indekseja > 0 ) {/* Jos joku on kohdalla, tulos*/
      printf("\n");
      printf("#%03d ------------------------------------------------------\n",
        kerho->nykyjasen+1);
      tulosta_jasen(stdout,kerho->jasenet[kerho->nykyjasen]);
      printf("------------------------------------------------------------\n");
    }

    printf("%s",selaus->viesti);
    vali = selaus->vali;
    kopioi_jono(N_S(sallitut),selaus->sallitut);

    /* Jos voidaan selata eteenp�in                                         */   
    if ( selaus->kohdalla < selaus->selattavat->indekseja-1 ) {
      printf(",%c%c = seuraava (%d)",
          vali,NAP_SEURAAVA,selaus->selattavat->indekseja-selaus->kohdalla-1);
      liita_jono(N_S(sallitut),NAP_SEUR_LOPPU);
      vali = ' ';
    }

    if ( selaus->kohdalla > 0 ) {           /* Jos voidaan selata taaksep�in*/
      printf(",%c%c = edellinen (%d)",
               vali,NAP_EDELLINEN,selaus->kohdalla);
      liita_jono(N_S(sallitut),NAP_EDEL_ALKU);
    }

    printf(":");
    painettu=odota_nappain(sallitut,NAP_RET,VAIN_ISOT);
    suunta = 0;
    switch (painettu) {
      case NAP_EDELLINEN: suunta = -1; break;
      case NAP_SEURAAVA:  suunta =  1; break;
      case NAP_ALKUUN:    selaus->kohdalla=0; break;
      case NAP_LOPPUUN:   selaus->kohdalla=selaus->selattavat->indekseja-1;
                          break;
      default : return painettu;
    }
  } 
}


/****************************************************************************/
void                      /*                                                */
tayta_viesti_ja_sallitut( /*                                                */
  int korj_poisto        ,/* s   Onko korjaus ja poisto mukana? (0=ei, 1=on)*/
  Selaus_tyyppi *selaus   /* s,t Paikka jonne tiedot t�ytet��n.             */
)    
/* 
** Aliohjelmalla t�ytet��n viesti muotoon:
**  Valitse kent�� jonka mukaan etsit��n (?=kentt�lista uudell.)
** Mik�li korjaus ja poisto on sallittu, lis�t��n viestiin viel�
**  ,\npoisto (P), korjailu (K)
** Samoin sallittujen kirjaimien joukkoon laitetaan kaikki kentt�listan
** mukaiset kirjaimet sek� ? J T (lista, JA, TAI) ja tarvittaessa P ja/tai K.
**
** Muuttuu:   selaus->viesti
**            selaus->sallitut
** Kutsuu:    kopioi_jono, N_S
**            liita_jono
----------------------------------------------------------------------------*/
{
  char viestin_jatko[80];

  kopioi_jono(N_S(selaus->viesti),
    "Valitse kentt� jonka mukaan etsit��n (?=kentt�lista uudell.)");
  selaus->vali = '\n';

  /* T�ytet��n n�pp�inlistaan nyt sallitut n�pp�imet                        */

  kopioi_jono(N_S(selaus->sallitut),KENTTAVALINNAT);

  if ( strlen(selaus->sallitut) > KENTTIA )
    selaus->sallitut[KENTTIA]=0; /* Poistetaan listasta ylim. kirjaimet     */
  liita_jono(N_S(selaus->sallitut),NAP_JA_TAI); 
  liita_jono(N_S(selaus->sallitut),"?");

  /* Jos korj ja poisto sallittu ja on joku jota n�ytt�� ruudussa.          */

  if ( korj_poisto && selaus->selattavat->indekseja>0 ) {
    sprintf(viestin_jatko,",\n%c = poisto, %c = korjailu",
                                      NAP_POISTO,    NAP_KORJ); 
    liita_jono(N_S(selaus->viesti),viestin_jatko);
    liita_jono(N_S(selaus->sallitut),NAP_KORJ_POISTO);
    selaus->vali = ' ';
  }

}


/****************************************************************************/
char                      /*                                                */
selaile_ja_odota_valinta( /*                                                */
  Kerho_tyyppi *kerho    ,/* s   Selailtava kerho                           */
  Selaus_tyyppi *selaus  ,/* s,t Tietue jonne l�ytymis yms. tiedot laitetaan*/
  int korj_poisto         /* s   Onko korjailu ja poisto sallittu           */
)    
/* 
** Funktiolla t�ytet��n n�yt�lle tuleva kysymys ja sallitut n�pp�imet sek�
** t�m�n j�lkeen annetaan selaus-funktion hoitaa teht�vi� kunnes painetaan
** jotain muuta kuin + tai -.  Mik�li painetaan ? tulostetaan kentt�lista
** ja jatketaan viel� selailua kun l�ydettyjen lista on tyhjennetty.
**
** Muuttuu:   etsi.selattavat
** Sy�tt�:    n�pp�imist�
** Tulostus:  n�ytt��n
** Kutsuu:    tayta_viesti_ja_sallitut
**            selaile
----------------------------------------------------------------------------*/
{
  char painettu;

  /* Kysell��n kunnes ei en�� haluta kentt�listaa.                          */
  do {

    tayta_viesti_ja_sallitut(korj_poisto,selaus);

    painettu = selaile(kerho,selaus);
    printf("%c\n",painettu);
     
    if ( painettu == '?' ) {
      printf("\n\n");
      tulosta_kenttalista(selaus->sallitut); printf("\n");
      selaus->selattavat->indekseja = 0; /* Jottei lista rullaa pois kuvasta*/
    }

  } while ( painettu == '?' );

  return painettu;
}

/****************************************************************************/
int                       /* -1 = ep�onnistui                               */
varaa_jarjestys(          /*  0 = onnistui                                  */
  Kerho_tyyppi *kerho    ,/* s                                              */
  int koko               ,/* s   Taulukolle varattava koko                  */
  Jarjestys_tyyppi *loytyi/* t                                              */
)    
/* 
** Funktiolla varataan tilaa j�rjestystaulukolle mik�li max_koko=-1.
** Samalla muut kent�t alustetaan siten, ett� on yksi l�ytynyt joka
** osoittaa nyky_jaseneen.
** Jos koko<=0, niin varataan tilaa kerhon j�senist�n verran.
**
----------------------------------------------------------------------------*/
{
  if ( loytyi->max_koko == -1 ) {
    if ( koko <= 0 ) koko = kerho->jasenia;
    
    /* Luodaan etsimistaulukko. J�senien m��r� riitt�� t�ss� aliohjelmassa  */
    /* koska j�seni� ei lis�t� t��ll�.  Lopetetaan mik�li tilaa ei saada!   */                     
    if ( !(loytyi->indeksit = malloc(sizeof(int)*koko)) ) return -1;

    loytyi->max_koko    = koko;
    loytyi->indekseja   = 1;
    loytyi->indeksit[0] = kerho->nykyjasen;
    loytyi->jarjesta    = 1;
  }
  return 0;
}

/****************************************************************************/
int                       /* -1 = ep�onnistui                               */
etsi_indekseja(           /* L�ytyneiden kenttien lukum��r�.                */
  Kerho_tyyppi *kerho    ,/* s,t Kerho josta etsit��n                       */
  int kentan_nro         ,/* s   Kent�n numero, jonka mukaan etsit��n       */
  Jarjestys_tyyppi *loytyi/* t   Taulukko jonne l�ytyneet talletetaan.      */
)    
/* 
** Funktiolla etsit��n kerhosta kent�st� kentan_nro niit� j�seni�, joilla
** ko. kent�ss� on kerho->haku ehdon t�ytt�v�t tiedot.  Jos kent�n numero
** on JA tai TAI, niin koko tietueen tiedot k�ytet��n hyv�ksi.
** Mik�li l�ytyneit� on yli yksi, tulostetaan l�ytyneiden lukum��r�.
** Voidaan kutsua my�s alustamattomalla taulukolla, mik�li sen max_koko=-1;
** t�ll�in taulukko alustetaan ja varataan sille tarvittava permutaatio
** taulukko.
**
** Muuttuu:   kerho->nykyjasen
** Tulostus:  n�yt��n
** Kutsuu:    etsi_indeksit
----------------------------------------------------------------------------*/
{
  if (varaa_jarjestys(kerho,0,loytyi)) return -1;
  etsi_indeksit(kerho,kentan_nro,kerho->haku,loytyi);
  if ( loytyi->indekseja > 1 )
    printf("T�h�n t�sm�� %d j�sent�:\n",loytyi->indekseja);
  kerho->nykyjasen = loytyi->indeksit[0];
  return loytyi->indekseja;
}


/****************************************************************************/
int                       /* -1 = ep�onnistui                               */
alusta_selaustaulukko(    /* 0  = onnistui,                                 */
  Kerho_tyyppi *kerho    ,/* s   Kerho josta etsit��n.                      */
  Selaus_tyyppi *selaus  ,/* t   Alustettava taulukko.                      */
  Jarjestys_tyyppi *loytyi/* s   K�ytettev� j�rjestystaulukko.              */
)    
/* 
** Funktiolla varataan tilaa selaustaulukolle ja alustetaan se sis�lt�m��n
** vain kerhon nykyj�sen.  Mik�li tilaa ei saada, palautetaan -1.
** Selaustaulukko pit�� muistaa vapauttaa kutsulla:
**  free(selaus->selattavat.indeksit);
**
** Kutsuu:    malloc
----------------------------------------------------------------------------*/
{
  if ( !kerho->jasenia ) return -1;    /* Turha etsi� jollei ole j�seni�!   */

  if ( !kerho->haku ) {                /* Onko hakumaskia ennest��n?        */
    if ( !(kerho->haku = calloc(KENTTIA,sizeof(kerho->haku[0]))) )  
      return -1;

    /* 1. kerralla hakuehto laitetaan tyhj�ksi. calloc hoiti t�m�n!         */    
  }

  if (varaa_jarjestys(kerho,0,loytyi)) return -1;

  selaus->kohdalla   = 0;
  selaus->selattavat = loytyi;

  return 0;
}


/****************************************************************************/
int                       /*     -1 = etsiminen ei onnistu                  */
kysy_kentat_ja_etsi(      /*     Muuten l�ytyneiden kenttien lukum��r�      */
  Kerho_tyyppi *kerho    ,/* s,t Kerho josta etsit��n.                      */
  int korj_poisto         /* s   Onko korjailu ja poisto mukana (1=on, 0=ei)*/
)
/* 
** Funktiolla kysyt��n mink� kent�n mukaan etsit��n, kysyt��n
** tiedot ja etsit��n ehdot t�ytt�vien kenttien indeksit.
** N�it� voidaan sitten selata yl�s tai alas.  My�s korjailu
** ja poisto on mahdollista, jos korj_poisto=1.
**
** Sy�tt�:    P��ttelt�
** Tulostus:  N�ytt��n
** Kutsuu:    ks. alla
----------------------------------------------------------------------------*/
{
            
  int  poistettuja=0; 
  char painettu;        /* Viimeksi painettu n�pp�in n�pp�imen�             */   
  int  kentan_nro;      /* Kun painettu n�pp�in muutetaan kent�n nroksi     */         
  Selaus_tyyppi selaus;
  Jarjestys_tyyppi loytyi = {-1};

  if ( alusta_selaustaulukko(kerho,&selaus,&loytyi) ) return -1;

  while ( (painettu = 
            selaile_ja_odota_valinta(kerho,&selaus,korj_poisto)
          ) != NAP_RET ) {

    /* Tutkitaan painettua n�pp�int�.  Jos jokin kentt�listasta, kysyt��n   */
    /* sen kent�n arvo ja etsit��n.                                         */

    kentan_nro = paikka(KENTTAVALINNAT,painettu);

    if ( kentan_nro < 0 ) continue; /* Itse asiassa n�in ei voi k�yd�!      */

    if ( kentan_nro < KENTTIA ) {
      if ( kysy_haku(kerho->haku,kentan_nro) ) break;
      etsi_indekseja(kerho,kentan_nro,&loytyi);
      selaus.kohdalla=0;
    }


    /* Ei mik��n kentt�listasta.  Onko jokin muu tunnettu?                  */
    switch (painettu) {
      case NAP_KORJ  : 
        printf("Korjaa tietoja tarvittaessa!\n");
        kysy_jasenen_tiedot(kerho,kerho->jasenet[kerho->nykyjasen],PAIVITYS);
        break;

      case NAP_POISTO: 
        if ( !poista_jasen(kerho,kerho->nykyjasen) ) {
          /* Selaustaulukko pit�� korjata!                                  */
          if ( --selaus.selattavat->indekseja >0 )
            memmove(
              selaus.selattavat->indeksit + selaus.kohdalla,
              selaus.selattavat->indeksit + selaus.kohdalla+1,
              sizeof(selaus.selattavat->indeksit[selaus.kohdalla])*
                (selaus.selattavat->indekseja - selaus.kohdalla)
            );
          poistettuja++;
        }
        break;

      case NAP_JA: 
        printf("T�yt� JA-hakuehdot:\n");
        if ( kysy_hakutiedot(kerho->haku) ) break;
        etsi_indekseja(kerho,ETSI_AND,&loytyi);
        selaus.kohdalla=0;
        break;

      case NAP_TAI: 
        printf("T�yt� TAI-hakuehdot:\n");
        if ( kysy_hakutiedot(kerho->haku) ) break;
        etsi_indekseja(kerho,ETSI_OR,&loytyi);
        selaus.kohdalla=0;
        break;

    }

  }

  free(selaus.selattavat->indeksit);
  if (poistettuja) poista_NULL(kerho);
  return selaus.selattavat->indekseja;
}