/****************************************************************************/
/*
**       K E R H O A L I . C
**
** Kerho-ohjelman yleisi„ aliohjelmia.
**
** Aliohjelmat:
**    onko_tyhjenna_jono     - 1 = jos tutkittava jono on ==
**    erikoisarvo            - muuttaa reaaliluvun merkkijonoksi jos
**                             kyseess„ on jokin erikoisarvoa kuvaava arvo
**    erikoisjono            - muuttaa jonon reaaliluvuksi, jos jono jokin
**                             erikoisjono (kuten "" tai "==")
**    int_jonoksi            - muuttaa kokonaisluvun mjonoksi, -1 -> ""
**    double_jonoksi         - muuttaa reaaliluvun mjonoksi,   -1 -> ""
**    jono_intiksi           - muuttaa jonon kokonaisluvuksi,  "" -> -1
**    jono_doubleksi         - muuttaa jonon reaaliluvuksi,    "" -> -1
**    lue_merkki             - lukee yhden merkin n„pp„imist”lt„
**                             (laiteriippuva)
**    odota_nappain          - odottaa yhden vain sallitussa joukossa olevan
**                             n„pp„imen painallusta
**    odota_jotakin          - odottaa mink„ tahansa n„pp„imen painamista
**    kylla_vastaus          - odottaa K tai E n„pp„imen painallusta
**    ei_toimi               - tulostaa viestin "Ei toimi" ja odottaa
**                             n„pp„imen painallusta.
**    viiva                  - piirt„„ koko ruudun levyisen viivan
**
**
**  Tekij„t:          Vesa Lappalainen
**                    Ohjelmointikurssi 1991
**  Tehty:            20.12.1991
**  Muutettu:         6.12.1993/vl
**  Mit„ muutettu:    enemm„n erikoisarvoja
**
*/

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

#ifdef __TURBOC__
#  include <conio.h>
#  define  GETCH
#endif


/****************************************************************************/
typedef struct {
  double arvo;
  char  *jono;
} Erikoiset_tyyppi;


static Erikoiset_tyyppi Erikoiset[] = {
  { TYHJA_ARVO    , ""            },
  { TYHJENNA_ARVO , TYHJENNA_JONO },
  { 0             , NULL          }
};


/****************************************************************************/
int                       /* 0 = ei                                         */
onko_tyhjenna_jono(       /* 1 = p:ss„ oleva jono k„skee tyhjent„m„„n kent„n*/
  const char *p           /*                                                */
)
/*
** Funktiolla tutkitaan onko jono p sellainen, joka m„„r„„ tyhjent„m„„n
** kent„n.
**
----------------------------------------------------------------------------*/
{
  return ( strcmp(p,TYHJENNA_JONO) == 0 );
}


/****************************************************************************/
int                       /* 0 = ei ole                                     */
erikoisarvo(              /* 1 = on                                         */
  char *jono             ,/* t   Jono, jonne tulos tulee                    */
  int max_pit            ,/* s   Jonon maksimipituus                        */
  double arvo             /* s   Arvo joka muutetaan jonoksi.               */
)
/*
** Funktiolla k„sitell„„n kaikki erikoisarvot
**  -1  -> ""
**  -2  -> "=="
**
----------------------------------------------------------------------------*/
{
  int i;
  for (i=0; Erikoiset[i].arvo; i++)
    if ( Erikoiset[i].arvo == arvo ) {
      kopioi_jono(jono,max_pit,Erikoiset[i].jono);
      return 1;
    }

  return 0;
}

/****************************************************************************/
int                       /* 0 = ei ole                                     */
erikoisjono(              /* 1 = on                                         */
  const char *jono       ,/* s   Jono, jota tutkitaan.                      */
  double *arvo            /* t   Arvo jonne tulee arvo.                     */
)
/*
** Funktiolla k„sitett„„n kaikki erikoisarvot
**  -1  <- ""
**  -2  <- "=="
**
----------------------------------------------------------------------------*/
{
  int i;
  for (i=0; Erikoiset[i].arvo; i++)
    if ( strcmp(Erikoiset[i].jono,jono) == 0 ) {
      *arvo =Erikoiset[i].arvo;
      return 1;
    }
  return 0;
}


/****************************************************************************/
char                      /*                                                */
*int_jonoksi(             /* Jonon osoite                                   */
  char *jono             ,/* t   Jono, jonne tulos tulee                    */
  int max_pit            ,/* s   Jonon maksimipituus                        */
  int arvo               ,/* s   Arvo joka muutetaan jonoksi.               */
  char *formaatti         /* s   Formaatti, jota muutoksessa k„ytet„„n      */
)
/*
** Funktiolla muutetaan kokonaisluku merkkijonoksi annettun formaatin
** mukaan. Mik„li luku on TYHJA_ARVO, palautetaan tyhj„ jono.
**
----------------------------------------------------------------------------*/
{
  char apu[80];

  if ( erikoisarvo(jono,max_pit,arvo) ) return jono;

  sprintf(apu,formaatti,arvo);
  kopioi_jono(jono,max_pit,apu);
  return jono;
}


/****************************************************************************/
char                      /*                                                */
*double_jonoksi(          /* Jonon osoite                                   */
  char *jono             ,/* t   Jono, jonne tulos tulee                    */
  int max_pit            ,/* s   Jonon maksimipituus                        */
  double arvo            ,/* s   Arvo joka muutetaan jonoksi.               */
  char *formaatti         /* s   Formaatti, jota muutoksessa k„ytet„„n      */
)
/*
** Funktiolla muutetaan reaaliluku merkkijonoksi annettun formaatin
** mukaan. Mik„li luku on TYHJA_ARVO, palautetaan tyhj„ jono.
**
----------------------------------------------------------------------------*/
{
  char apu[80];

  if ( erikoisarvo(jono,max_pit,arvo) ) return jono;

  sprintf(apu,formaatti,arvo);
  kopioi_jono(jono,max_pit,apu);
  return jono;
}


/****************************************************************************/
int                       /*                                                */
jono_intiksi(             /*                                                */
  char *jono             ,/* s   Kokonaisluvuksi muutettava merkkijono      */
  char *formaatti         /* s   Formaatti jota muunnoksessa k„ytet„„n.     */
)
/*
** Funktiolla muutetaan merkkijono kokonaisluvuksi. Mik„li jono on tyhj„
** palautetaan TYHJA_ARVO
**
----------------------------------------------------------------------------*/
{
  int i = TYHJA_ARVO;
  double d;
  if ( erikoisjono(jono,&d) ) return (int)d;
  sscanf(jono,formaatti,&i);
  return i;
}


/****************************************************************************/
double                    /*                                                */
jono_doubleksi(           /*                                                */
  char *jono             ,/* s   Reaaliluvuksi muutettava merkkijono        */
  char *formaatti         /* s   Formaatti jota muunnoksessa k„ytet„„n.     */
)
/*
** Funktiolla muutetaan merkkijono reaaliluvuksi. Mik„li jono on tyhj„
** palautetaan TYHJA_ARVO
**
----------------------------------------------------------------------------*/
{
  double r=TYHJA_ARVO;
  if ( erikoisjono(jono,&r) ) return r;
  sscanf(jono,formaatti,&r);
  return r;
}


/****************************************************************************/
char lue_merkki(void)   /* N„pp„imist”lt„ luettu merkki.                    */
/* Funktiolla luetaan n„pp„imist”lt„ yksi merkki.  Mik„li ohjelmassa
** ei ole m„„ritelty vakiota GETCH, vaaditaan RET-n„pp„imen painallus.
** Globaalit: GETCH - m„„ritys
** Sy”tt”:    N„pp„imist”
----------------------------------------------------------------------------*/
{
/* Seuraava toimii mm. Turbo C:ss„: */
#ifdef GETCH
  return getch();

#else

/* Seuraava on standardin mukainen: */
  char s[50];
  fgets(s,50,stdin);
  return s[0];
#endif

}


/****************************************************************************/
char                      /*                                                */
odota_nappain(            /*       = p„„tteelt„ luettu merkki               */
  char *kelpaavat,        /* s   Ne merkit, jotka hyv„ksyt„„n.              */
  char oletus,            /* s   Merkki joka palautetaan, mik„li pain. RET. */
  int isot                /* s   Jos !=0 niin isot ja pienet samaistetaan.  */
)
/*
** P„„tteelt„ luetaan merkki. Jos isot ja pienet kirjaimet halutaan
** samaistaa (isot!=0), niin muutetaan luettu merkki isoksi.
** Jos oletus ei ole 0-merkki ja ollaan kohdattu rivinvaihto 
** tai return- n„pp„imen painallus palautetaan oletus. 
** T„m„ operaatio toistuu kunnes ollaan luettu merkki joka kuuluu 
** sallittuun joukkoon (kelpaavat).  
** Jos sallittu joukko on NULL, niin kaikki painetut kelpaavat
----------------------------------------------------------------------------*/
{
  char painettu;
  do {
    while (!(painettu=lue_merkki()));      /* Luetaan painettu n„pp„in.     */
    if (isot) painettu = isoksi(painettu); /* Jos tarvitsee muuttaa isoksi. */
    if ( oletus && ((painettu=='\n') || (painettu=='\r')) )
      return oletus;                       /* Pal. oletus jos painettu RET  */
  } while ( kelpaavat && !strchr(kelpaavat,painettu) );
  return painettu;
}


/****************************************************************************/
void odota_jotakin(void)
/* 
** Aliohjelmalla odotetaan kunnes jotakin n„pp„int„ on painettu.
** Kutsuu:    odota_nappain
** Algoritmi:
**   odota_nappain aliohjelmalle sallitaan kaikki merkit (kelpaavat=NULL)
**   ja oletusn„pp„int„ ei k„ytet„ (ei haittaisi vaikka k„ytett„isiinkin).
----------------------------------------------------------------------------*/      
{
  printf("Paina jotakin!\n");
  odota_nappain(NULL,0,VAIN_ISOT);
}


/****************************************************************************/
int kylla_vastaus(void)   /* 1 jos painettiin K tai RET ja 0 jos E          */
/* 
** Funktiolla odotetaan kunnes painetaan K tai E tai RET
** Tulostus:  N„yt”lle rivin vaihto.
----------------------------------------------------------------------------*/
{
  int palautus;
  palautus = (odota_nappain("KE",'K',VAIN_ISOT)=='K');
  printf("\n");
  return palautus; 
}


/****************************************************************************/
void ei_toimi(            /*                                                */
  Kerho_tyyppi *kerho     /* s   H„m„yst„ jottei valitusta k„ytt„m„tt”myydes*/
)
/* Funktiolla tulostetaan teksti ei toimi ja odotetaan n„pp„int„.
----------------------------------------------------------------------------*/
{
  printf("\nEi toimi viel„! ");
  if ( kerho->jasenia == 0 );
  odota_jotakin();
}


/****************************************************************************/
void logo(void)
/* Funktiolla tulostetaan ohjelman logo.
** Tulostus:  N„ytt””n
----------------------------------------------------------------------------*/
{
  printf("\n");
  printf("      ###################################\n");
  printf("      #        R E K I S T E R I        #\n");
  printf("      #        versio %10s"    "        #\n",VERSIO);
  printf("      #               VL                #\n");
  printf("      ###################################\n");
}

/****************************************************************************/
void viiva(void)
{
printf(
"===============================================================================\n"
);
}