/* muunnos.c */
/****************************************************************************/
/*
**       M U U N N O S . C
**
** Kerho-ohjelman yleisi„ merkkijonofunktioita.
**
**
**  Tekij„t:          Vesa Lappalainen
**                    Ohjelmointikurssi 1991
**  Tehty:            20.12.1991
**  Muutettu:         6.12.1993/vl
**  Mit„ muutettu:    enemm„n erikoisarvoja
**  Muutettu:         10.12.1995/vl
**  Mit„ muutettu:    irroitettu pelk„t muunnokset omaksi tiedostokseen
**  Muutettu:         07.01.1996/vl
**  Mit„ muutettu:    muunosfunktioita kentt„-tyyppi„ varten
**
**
** Aliohjelmat:
** ------------
**    int_jonoksi            - muuttaa kokonaisluvun mjonoksi, -1 -> ""
**    double_jonoksi         - muuttaa reaaliluvun mjonoksi,   -1 -> ""
**    jono_intiksi           - muuttaa jonon kokonaisluvuksi,  "" -> -1
**    jono_doubleksi         - muuttaa jonon reaaliluvuksi,    "" -> -1
**
** Muunnosfunktioita:
** ------------------
**    char *puh_muunnos(char *s)
**     - j„tt„„ vain puhelinnumeroon kelpaavat merkit
**    char *numerot_muunnos(char *s)
**     - j„tt„„ vain numeroiksi kelpaavat merkit
**    char *arvos_muunnos(char *s)
**     - j„tt„„ vain arvosanaan kelpaavat merkit (0-9,«.)
**    char *int_muunnos(char *s)
**     - j„tt„„ vain kokonaislukuun kelpaavat merkit
**    char *double_muunnos(char *s)
**     - j„tt„„ vain reaalilukuun kelpaavat merkit
**    char *hetu_muunnos(char *s)
**     - j„tt„„ vain henkil”tunnukseen kelpaavat merkit
**
** Vakiot:
** -------
**
**  #define     HETUTARK      "0123456789ABCDEFHJKLMNPRSTUVWXY"
**  #define     HETUVALI      "*+-"
**  #define     PUH_MERKIT    "0123456789- "
**  #define     TYHJA_ARVO     - arvo joka tarkoittaa tyhj„„ merkkijonoa
**  #define     TYHJENNA_ARVO  - arvo joka tarkoittaa tyhjennett„v„„ kentt„„
**  #define     TYHJENNA_JONO  - jono, jolla k„sket„„n tyhjent„„ kentt„
**
*****************************************************************************/

#include <stdio.h>
#include <string.h>
#include "mjonot.h"
#include "muunnos.h"


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 );
}


/****************************************************************************/
static
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;
}


/****************************************************************************/
static
int                       /* 0 = ei ole                                     */
erikoisjono(              /* 1 = on                                         */
  const char *jono       ,/* s   Jono, jota tutkitaan.                      */
  double *arvo            /* t   Arvo jonne tulee arvo.                     */
)
/*
** Funktiolla k„sitell„„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.               */
  const 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.               */
  const 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(             /*                                                */
  const char *jono       ,/* s   Kokonaisluvuksi muutettava merkkijono      */
  const 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(           /*                                                */
  const char *jono       ,/* s   Reaaliluvuksi muutettava merkkijono        */
  const 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;
}

/****************************************************************************/
/* Apufunktioita muunnoksiin:                                               */
/****************************************************************************/

/****************************************************************************/
char *puh_muunnos(char *s)
{
  return jonossa_vain_merkit(s,PUH_MERKIT);
}

/****************************************************************************/
char *numerot_muunnos(char *s)
{
  return jonossa_vain_merkit(s,"0123456789");
}

/****************************************************************************/
char *arvos_muunnos(char *s)
{
  return jonossa_vain_merkit(s,ARVOSANA_MERKIT);
}

/****************************************************************************/
char *int_muunnos(char *s)
{
  return numerot_muunnos(s);
}

/****************************************************************************/
char *double_muunnos(char *s)
{
  return jonossa_vain_merkit(s,"0123456789.");
}

/****************************************************************************/
char *hetu_muunnos(char *s)
{
  char ts[100];
  kopioi_jono(N_S(ts),HETUTARK); liita_jono(N_S(ts),HETUVALI);
  jono_isoksi(s);
  return jonossa_vain_merkit(s,ts);
}