#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <math.h>

#include "ssrfg2.h"
FILE *lptferr;
char versi[3];

/*
Fonction atoi modifiée permettant de transformer des chaînes de caractères débutant par des blancs
*/
int latoi(const char zone[])
{
   short l,j;

   if (isdigit(zone[0]))return(atoi(zone));
   if (zone[0]!=' ') return(0);
   l=(short)strlen(zone);
   j=0;
   while (zone[j++]==' ' ){
      if (j> l) break;
   }
   return(atoi(zone+j-1));
}

/* Transformation de ECC4 -> long */
unsigned long carlong (unsigned char c[])
{
  short i;
  unsigned long l;

  l=0;
  for(i=0;i<4;i++)
    l = (l*256)+c[i];
  return(l);
}

/* Fonction de lecturer des entêtes et de tables et sous-tables */
void accstb (FILE *fich,long *_offset,short *_size,long *_taille)
	{

	    fread(entete_stab.sgstn,1,_tentete,fich);
	    *_size=(short)entete_stab.lastn;
	    *_offset=carlong(entete_stab.ofstn);
        *_taille=carlong(entete_stab.lgstn);
	}

/* Fonction de vérification des octes des checksum */
short verifoct(FILE *fich,short nblong,unsigned long cpt[])
{
     long i,k,j,tlec;
     short  nblec,dlec;
     short t;
     unsigned long dum;
     unsigned char buf[512],sdum[5];

	  tlec  = nblong*4;
      nblec = (short)(tlec/512);
      dlec  = (short)(tlec%512);
/*
fprintf(lptferr,"tlec : %d - nblec : %d - dlec : %d\n",tlec,nblec,dlec);
fprintf(lptferr,"Avant verifoct : pos : %d\n",ftell(fich));
*/
      for(i=0;i<=nblec;i++)
      {
        if(i==nblec)t=dlec;
        else t=512;
        fread(buf,t,1,fich);

/* fprintf(lptferr,"lecture %d pos : %d\n",i,ftell(fich));  */

        for(k=0;k<t/4;k++)
        {
           for(j=0;j<4;j++)sdum[j]=buf[k*4+j];
           dum=carlong(sdum);
           if(cpt[k+(128*i)]!=dum){
               return(8);
           }
        }
      }
     return(0);
}

/* Fonction de vérifiaction des octets de contrôles */
short verif(FILE *fich,long pos_debut,long taille,long chks)
{
	return(0);

}


/* Fonction d'ouverture de la table de l'arbre de décision */
short optree(char *dirtab)
{
    char trtab[100];
    long taille,chks;

    sprintf(trtab,"%s%s",dirtab,TR_NAME);
    pttree = fopen(trtab,"rb");
    if(pttree==NULL)
        //CD 04/01/07
        //return(98);
        return(99);

    fread(entete_table.sign,1,32,pttree);
    accstb(pttree,&_toffset,&_trsize,&taille);
    taille_arbre=taille+_toffset;
    chks=carlong(entete_table.kgen);

    if(verif(pttree,_toffset,taille,chks) !=0)
        //CD 04/01/07
        //return(99);
        return 98;

    return(0);

} /* fin de la fonction optree */



/*  Fonction d'ouverture de la table de codes diags  cim10 */
short opdiag10(char *dirtab)
{
    char dxtab[100];
    long taille,tailtot,chks;

    sprintf(dxtab,"%s%s",dirtab,DX_NAME10);
    ptmdiag10 = fopen(dxtab,"rb");
    if(ptmdiag10==NULL) return(99);

    tailtot=0;
    fread(entete_table.sign,_tentete,1,ptmdiag10);
    accstb(ptmdiag10,&_doffnop10,&_dsize,&taille);
    tailtot += taille;
    accstb(ptmdiag10,&_doffpro10,&_dxmsize2,&taille);
    _dxmsize=_dxmsize2-1;
    tailtot += taille;
    chks=carlong(entete_table.kgen);

    if(verif(ptmdiag10,_doffnop10,tailtot,chks) !=0) return(98);

    return(0);

} /* fin de la fonction opdiag */

short opaccam(char *dirtab)
	{
        char dxtab[100];
        long taille,tailtot,chks;


        sprintf(dxtab,"%s%s",dirtab,CCAM_NAME);
        ptaccam = fopen(dxtab,"rb");
        if(ptaccam==NULL)
			//return(9);
            return 99;

        tailtot=0;
        fread(entete_table.sign,sizeof(struct ENTETE),1,ptaccam);
        accstb(ptaccam,&_poffnop_ccam,&_psize_ccam,&taille);
        tailtot += taille;
        chks=carlong(entete_table.kgen);

		_prmsize=1 ; /* Attribution directe car ne se trouve pas dans les entetes de table */
//        if(verif(ptaccam,_poffnop_ccam,tailtot,chks) !=0)
//			return(8);

	return(0);

} /* fin de la fonction opacccam */


/* Hash coding applicable au diagnostics */
short hashcode(char *acode,short *hcod)
{
    short i,m;
    char code[3];
    short hc[3]={132,11,1};

    strncpy(code,acode,3);
    *hcod=0;
    for(i=0;i<3;i++)
    {
        switch (code[i])
        {
            case ' ': m=0;break;
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                m=code[i]-'0'+1;break;
            case caras :
                if(i<2)
                    m=11;
                else
                    return(-1);
                break;
            default : return(-1);
       }
       *hcod += m*hc[i];
    }
    //CD 04/01/07
    return 0;
}


/* Fonction de détermination de la position du profil de diags */
void convdiag10(char *adrcod,unsigned char prof[])
    {
     char trans[4],*buf;
     long hdg10,fpos;
     short hdgf10;
     unsigned char pref[2][2],hcod[2];
     unsigned short i,j,nbd,nboff;

        for(i=0;i<_dsize;i++)prof[i]=0;
        strncpy(trans,adrcod,3);trans[3]='\0';
        if(trans[0]==' ') return;
        hdg10 = (long)(toupper(trans[0])-'A')*100;
        hdg10 += atoi(trans+1);
        if(hdg10<0 || hdg10>=2600)return;
        hdg10 *= _tpref;
        for(i=0;i<2;i++)
         for(j=0;j<2;j++)pref[i][j]=0;
        if(hdg10==0)
         {
          fseek(ptmdiag10,_doffnop10+hdg10,0);
          fread(pref[1],_tpref,1,ptmdiag10);
         }
        else
         {
          fseek(ptmdiag10,_doffnop10+hdg10-_tpref,0);
          fread(pref,_tpref,2,ptmdiag10);
         }
        if( memcmp(pref[0],pref[1],2)==0)return;
        nboff=pref[0][0]*256+pref[0][1];
        nbd=(pref[1][0]*256+pref[1][1])-nboff;
        hashcode(adrcod+3,&hdgf10);
        hcod[0]=hdgf10/256;
        hcod[1]=hdgf10%256;
        if((buf = (char *)malloc(nbd*_tsuf))==0){
              for(i=0;i<_dsize;i++)prof[i]=0;
              return;
        }
        fpos=_doffnop10+_nbpref*_tpref+(long)nboff*_tsuf;
        fseek(ptmdiag10,fpos,0);
        fread(buf,nbd*_tsuf,1,ptmdiag10);
        i=0;
        /*CD 12/01/07
        while(memcmp(buf+i,hcod,2)!=0 && i<nbd*_tsuf)i+=_tsuf;*/
        while( (i<nbd*_tsuf) && (memcmp(buf+i,hcod,2)!=0) )
            i+=_tsuf;
        if(i<nbd*_tsuf)
        {
           memcpy(prof,buf+i+2,_tsuf - 2);
        }
        free(buf);
    } /* fin de la fonction convdiag10 */


/* Fonction de lecture du profil de diags */
short dxmap10(char diagc[],short indice)
{
    long pos;
    unsigned char prof[TAILLEVECC];
    unsigned char profil[TAILLEVECL];

    convdiag10(diagc,prof);
    pos=((prof[0]*256)+prof[1])*_dxmsize2 + _doffpro10;
	fseek(ptmdiag10,pos,0);
	fread(profil,_dxmsize2,1,ptmdiag10);
	profctl[indice]=profil[0];
	memcpy(prof_diags+indice*_dxmsize,profil+1,_dxmsize);
	return (1);
}

/* Fonction de recherche d'information dans l'arbre */
short trmap(short nn)
	{
	    long pos;
        unsigned char buflec[TAILLEVECC];

		pos = (long)nn*(long)_trsize +(long)_toffset;
		if (pos > taille_arbre || pos < 0) return(3);
		fseek(pttree,pos,0);
		fread(buflec,_trsize,1,pttree);
        treetab.subclus=buflec[0];
        treetab.para1=buflec[1];
        treetab.para2=buflec[2];
        treetab.nbranch=buflec[3];
        treetab.pfils=(buflec[4]*256)+buflec[5];
        /*
        fprintf(lptferr,"n : %d | f: %d | p1 : %d  | p2 : %d | nb : %d | pf : %d\n",
                 nn,treetab.subclus,treetab.para1,treetab.para2,treetab.nbranch,treetab.pfils);
        */
        _stpos=treetab.pfils;
        return(0);
	} /* short trmap */

/* Fonction de Hash coding des actes */
long convacte(char acte[])
    {
     long hacte;
        if(acte[0]==' ') return(-1);
        hacte = (long)(toupper(acte[0])-'A')*1000;
        hacte += atoi(acte+1);
        hacte *= _psize;
        return(hacte);
    } /* fin de la fonction convacte */


/* Fonction de recherche de profil d'actes */
short prmap(char acte[],short indice)
{
		long pos;
        char zone[5];

		strncpy(zone,acte,lgacte);zone[lgacte]=0;
        pos = convacte(zone)+_poffnop;
        if(pos<=_poffnop ) return(0);
		fseek(ptacte,pos,0);
        fread(prof_actes+indice*_psize,_psize,1,ptacte);
		return (1);
}


short prmap_ccam(char acte[],short indice)
{
     unsigned char *buf;
     long haccam,fpos;
	 char zone[5];

     unsigned char pref[2][_tpref_ccam],hcod[3];
     unsigned short i,j,nba,nboff;
	 static int puis26[3]={676,26,1} ;

	 haccam=0;
		for(i=0;i<3;i++)
		{
           haccam+=(long)((toupper(acte[i])-'A')*puis26[i]);
		}

        if(haccam<0 || haccam>=17576) return(0);

		haccam *= _tpref_ccam;
        for(i=0;i<2;i++)
         for(j=0;j<_tpref_ccam;j++)
			 pref[i][j]=0;
        if(haccam==0)
         {
          fseek(ptaccam,_poffnop_ccam+haccam,0);
          fread(pref[1],_tpref_ccam,1,ptaccam);
         }
        else
         {
          fseek(ptaccam,_poffnop_ccam+haccam-_tpref_ccam,0);
          fread(pref,_tpref_ccam,2,ptaccam);
         }
        if( memcmp(pref[0],pref[1],_tpref_ccam)==0)
			return(0);

		nboff=pref[0][0]*256+pref[0][1];

        nba=(pref[1][0]*256+pref[1][1])-nboff;

		strncpy(zone,acte+4,4);zone[4]=0;
        hcod[0]=acte[3]-'A';
        hcod[1]=(atoi(zone))/256;
        hcod[2]=(atoi(zone))%256;

        if((buf = (unsigned char *)malloc(nba*_tsuf_ccam))==0)
		{
              return(0);
        }

        fpos=_poffnop_ccam+_nbpref_ccam*_tpref_ccam+(long)nboff*_tsuf_ccam;
        fseek(ptaccam,fpos,0);
        fread(buf,nba*_tsuf_ccam,1,ptaccam);
        i=0;
        /*CD 12/01/07
        while(memcmp(buf+i,hcod,3)!=0 && i< nba * _tsuf_ccam)*/
		while( (i<(nba*_tsuf_ccam)) && (memcmp(buf+i,hcod,3)!=0) )
			i+=_tsuf_ccam;
        if(i<nba*_tsuf_ccam)
        {
           memcpy(prof_actes+indice*_prmsize,buf+i+3,_tsuf_ccam - 3);
        }
        free(buf);
		return (1);

} /* fin de la fonction convacte */


/* Fonction 0: âge supérieur à la valeur de para1*256 + para2 */
short agelt()
{
  if (age < treetab.para1*256+treetab.para2) return(1);
  return(0);
}

/* Fonction 1 : Détermination de la CMC */
short dcmc()
{
   short cmc;

   cmc=prof_diags[0];
   if(cmc==0 || cmc==99){
     cmc = prof_diags[_dxmsize];
     if (cmc==0 || cmc==99) cmc=prof_diags[_dxmsize*2];
     if (cmc==0) cmc=99;
   }
   return(tabcmc[cmc]);
}

/* Fonction 2  : Profil de la manif. morb. princ contient le N° de liste : para1*256+para2 */
short dplist()
{
   short i;
   uchar zone[2];

   if (strncmp(ris.diagpc,"      ",lgdiag)!=0 && strncmp(ris.diagpc,"ZAIGU ",lgdiag)!=0)return(0);
   i=0;
   zone[0]=(uchar)(treetab.para1);
   zone[1]=(uchar)(treetab.para2);
   /*CD 16/01/07
   while(memcmp(prof_diags+i+_dxmsize+1,zone,2)!=0 && i<_dxmsize)i+=2;*/
   while((i<_dxmsize) && (memcmp(prof_diags+i+_dxmsize+1,zone,2)!=0))
       i+=2;
   if(i<_dxmsize){
       return(1);
       }

   return(0);
}

/* Fonction 3 : Un acte à la caractéristique para1*256+para2 */
short aclist()
{
  short i;

  if (nbactes==0) return(0);
  for(i=0;i<nbactes;i++)
       if(prof_actes[i]==treetab.para1*256+treetab.para2) return(1);
  return(0);
}


/* Fonction 4 : N'existe plus */
short pcplist()
{
 return(0);
}

/* Fonction 5 :  Un des NBDIAGTOT diagnostics du RHS contient le N° de liste : para1*256+para2 */
short tdglist()
{
   short i,j;
   uchar zone[2];

   zone[0]=(uchar)(treetab.para1);
   zone[1]=(uchar)(treetab.para2);
   for(j=0;j<NBDIAGTOT;j++){
     i=0;
     /*CD 16/01/07
     while(memcmp(prof_diags+i+j*_dxmsize+1,zone,2)!=0 && i<_dxmsize)i+=2;*/
     while((i<_dxmsize) && (memcmp(prof_diags+i+j*_dxmsize+1,zone,2)!=0))
         i+=2;
     if(i<_dxmsize)
         return(1);
   }
   return(0);
}

/* Fonction 6 : Dépendance physique est inférieure ou égale à para1*256+para2 */
short phylt()
{
  if (dephy <= treetab.para1*256+treetab.para2) return(1);
  return(0);
}

/* Fonction 7 : N'existe plus */
short rellt()
{
 return(0);
}

/* Fonction 8 : Fauteuil roulant égal à 1 */
short faut()
{
   if (ris.fautrou!='1' )return(0);
   return(1);
}

/* Fonction 9 : Délai intervention chirurgicale est inférieure à para1 jours */
short chir()
{
  if(nbjchir <= treetab.para1 && nbjchir>=0)return(1);
  return(0);
}

/* Fonction 10 : Type de rééducation = para1 et durée est supérieur à para2 heures*/
short reedegh()
{
  char zone[5];

  strncpy(zone,ris.procreed[treetab.para1-1],4);zone[4]=0;
  if (latoi(zone) >= treetab.para2*60)return(1);
  return(0);
}

/* Fonction 11 :  Type de rééducation différent de para1 et durée est supérieur à para2 heures*/
short reedifh()
{
  short i;
  char zone[5];

  for(i=1;i<=NBREEDTEST;i++){
    if (i!=treetab.para1){
       strncpy(zone,ris.procreed[i-1],4);zone[4]=0;
       if(latoi(zone) >= treetab.para2*60)return(1) ;
     }
  }
  return(0);
}

/*Fonction 13 : Type de rééducation = para1 et durée est supérieur à para2 minutes*/
short reedegm()
{
  char zone[5];

  strncpy(zone,ris.procreed[treetab.para1-1],4);zone[4]=0;
  if (latoi(zone)/nbjpres >= treetab.para2)return(1);
  return(0);
}

/* Fonction 14 : Type de rééducation différent de para1 et durée/jour est supérieur à para2 minutes */
short reedifm()
{
  short i;
  char zone[5];

  for(i=1;i<=NBREEDTEST;i++){
    if (i!=treetab.para1){
       strncpy(zone,ris.procreed[i-1],4);zone[4]=0;
       if(latoi(zone)/nbjpres >= treetab.para2)return(1) ;
     }
  }
  return(0);
}

/* Fonction 15 : Masque de rééducation est compatible avec para1 et durée est supérieure à para2 heures */
short rdpribgth()
{
  short i;
  char zone[5];

  for(i=0;i<8;i++){
     if(puis2[i] & treetab.para1){
       strncpy(zone,ris.procreed[i],4);zone[4]=0;
       if(latoi(zone) >= treetab.para2*60)return(i+1) ;
      }
   }
   return(0);
}

/* Fonction 16 : Masque de rééducation est compatible avec para1 et durée/jour est supérieure à para2 minutes */
short rdpribgtm()
{
  short i;
  char zone[5];

  for(i=0;i<8;i++){
     if(puis2[i] & treetab.para1){
       strncpy(zone,ris.procreed[i],4);zone[4]=0;
       if(latoi(zone)/nbjpres >= treetab.para2)return(i+1) ;
      }
   }
   return(0);
}

/* Fonction 17: Nombre de jours de présence est inférieur à  para1 */
short nbjlt()
{
    if (nbjpres < (treetab.para1) ) return(1);
    return(0);
}

/*-------
Fonction 18
Est-ce que au moins deux diagmostics ont la caracteristique bit treetab.param2
de l'octet treetab.param1 positionnee
--------*/
short tdg2list()
{
   short i,j,k;
   uchar zone[2];

   k=0;
   zone[0]=(uchar)(treetab.para1);
   zone[1]=(uchar)(treetab.para2);
   for(j=0;j<NBDIAGTOT;j++){
     i=0;
     /*CD 16/01/07
     while(memcmp(prof_diags+i+j*_dxmsize+1,zone,2)!=0 && i<_dxmsize)i+=2;*/
     while((i<_dxmsize) && (memcmp(prof_diags+i+j*_dxmsize+1,zone,2)!=0))
         i+=2;
     if(i<_dxmsize)
     {
         if(k ==1) return(1);
         else k++;
     }
   }
   return(0);
}

/* Test 19 : Fonction Goto */
short aller()
{
  return(treetab.para1*256+treetab.para2);
}

/* Fonction 12 : */
short grp()
{
  return(0);
}


void convdate (char *adat,short *p_jj,short *p_mm,short *p_aa)
{
        char zw[5];

        sprintf(zw,"%2.2s",adat);
        *p_jj=atoi(zw);
        sprintf(zw,"%2.2s",adat+2);
        *p_mm=atoi(zw);
        sprintf(zw,"%4.4s",adat+4);
        *p_aa=atoi(zw);

} /* fin de la fonction convdat */

/* calcul de l'âge anniversaire */
void callage(char *d1, char *d2)
{
	short aa1,aa2,mm1,mm2,jj1,jj2;

	convdate(d1,&jj1,&mm1,&aa1);
	convdate(d2,&jj2,&mm2,&aa2);

	age= aa1-aa2;
	if (mm1<mm2) age -= 1;
	if (mm2==mm1 && jj1<jj2) age -=1;

}



/* Fonction groupage proprement dit :
Paramètres d'appel:
	1. char risin[] : Chaîne de caractère contenant le RHS
	2. char diratb[] : Chaîne de caractère contenant le répertoire des tables
	3. short *cmc  : Pointeur de short permettant de renseigner la CMC
	4. short *ghj  : Pointeur de short permettant de renseigner le GHJ
	5. short *retc  : Pointeur de short permettant de renseigner le code retour
	6. short vecerr[] : Tableau de short contenant l'ensemble des erreurs détectées sur le RHS
	7. FILE *ptferr : Fichier d'erreur
*/

int grpssr(char risin[],char dirtab[],short *cmc,short *ghj,short *retc,short vecerr[],FILE *ptferr,char version[])
{
    char zone[10];
    short i,j,k,l,err;
    short ok_co,ret,rval;
    //char datlun[9];
	char risin1[512];
	long nbjTmp;
    char buft[500];
    //CD 05/01/07
    int posacte;/*position fixe des actes dans le RHS*/

    lptferr=ptferr ;

    strcpy(risin1,risin);

    l=sizeof(struct RIS);
    /* initialisation du tableau des CMC */
    for(i=0;i<TAILLEVECL;i++) tabcmc[i]=0;
    for(i=11;i<19;i++)tabcmc[i]=i-11;
    tabcmc[20]=8;tabcmc[30]=9;tabcmc[40]=10;tabcmc[50]=11;tabcmc[60]=12;tabcmc[99]=13;

//CD 02/01/07
    InitErreur(vecerr);
    
	lgdiag=6; /* Quelque soit la version des RHS on tronque les Diags */

    //CD 02/01/07
    //pb initialisation de variables
    ret=0;
    nbdiagas=0;
    lgacte=4;
    memset(&(ris.finess),0,sizeof(struct RIS));

    /*CD 02/01/07 format M04
    if (strncmp(risin1+9,"M01",3)==0){lgacte=4;}
    else if (strncmp(risin1+9,"M02",3)==0 ){lgacte=4;}
    else if (strncmp(risin1+9,"M03",3)==0){lgacte=8;}
*/
    
    /*CD uniquement format M04*/
    lgacte=8;nbdiagas=20;posacte=343;
    
    if(pttree==NULL)
    {
        if((ret=optree(dirtab))!=0)
        {
            fprintf(ptferr,"Pb d'ouverture des tables arbre: %d\n",ret);
            *retc=ret;
            return(ret);
        }
        else
            strncpy(versi,entete_table.verc,2);
    }

    strncpy(version,versi,2);version[2]=0;

/*CD 02/01/07 format M04
    if(!ret && (ptacte==NULL))
	{
       if((ret=opacte(dirtab))!=0)
       {
           fprintf(ptferr,"Pb d'ouverture de la table des actes CDAM: %d\n",ret);
           *retc=ret;
           return(ret);
       }
       else
           if(strncmp(version,entete_table.verc,2)!=0)
           {
               ret=9;
               fprintf(ptferr,"Version des tables incompatible (Arbre - Actes) \n");
               *retc=ret;
               return(ret);
           }
    }
*/
    if(!ret && (ptaccam==NULL))
    {
        if((ret=opaccam(dirtab))!=0)
        {
            fprintf(ptferr,"Pb d'ouverture de la table des actes CCAM: %d\n",ret);
           *retc=ret;
           return(ret);
       }
       else
           if(strncmp(version,entete_table.verc,2)!=0)
           {
               ret=9;
               fprintf(ptferr,"Version des tables incompatible (Arbre - Actes) \n");
               *retc=ret;
               return(ret);
           }
    }

    if(!ret && (ptmdiag10==NULL))
    {
       if((ret=opdiag10(dirtab))!=0)
       {
           fprintf(ptferr,"Pb d'ouverture des tables des diags : %d\n",ret);
           *retc=ret;
           return(ret);
       }
       else
           if(strncmp(version,entete_table.verc,2)!=0)
           {
               ret=9;
               fprintf(ptferr,"Version des tables incompatible (Arbre - Diags) \n");
               *retc=ret;
               return(ret);
           }
    }

/* Avant l'intégration dans la structure RHS : trimmage des diagnostics recomposition d'un RHS version 2*/
 /*CD 05/01/07 changement de la structure struct RIS
    if (strncmp(risin1+9,"M02",3)==0 || strncmp(risin1+9,"M03",3)==0)
    {
        //CD 05/01/07
        //for(i=0,j=0;i<NBDIAGS;i++,j++)
        for(i=0;i<nbdiags;i++)
        {
            strncpy(zone,risin1+99+i*8,6);
            k=5;
            while(zone[k]=='+' && k>1)
            {
                zone[k--]=' ';
            }
            strncpy(risin1+99+i*6,zone,6);
        }
        sprintf(risin1,"%147.147s%s",risin1,risin1+163);
    }
*/
    for(i=0;i<nbdiagas+3;i++)
    {
        strncpy(zone,risin1+99+i*8,lgdiag);
        k=5;
        while(zone[k]=='+' && k>1)
        {
            zone[k--]=' ';
        }
        strncpy(risin1+99+i*6,zone,6);
    }
    strcpy(buft,risin1+283);
    risin1[237]=0;
    strcat(risin1,buft);
    strncpy(ris.finess,risin1,sizeof(struct RIS));
    
    /*CD 05/01/07 changement de la structure struct RIS
    strncpy(ris.finess,risin1,sizeof(struct RIS));
    strncpy(str_diags,ris.diagpc,LG_DIAGS);
    str_diags[LG_DIAGS]=0;*/
    strncpy(str_diags,ris.diagpc,(nbdiagas+3)*lgdiag);
    str_diags[(nbdiagas+3)*lgdiag]=0;
    
    //CD 05/01/07
    //for(i=0;i<NBDIAGS;i++)
    for(i=0;i<nbdiagas+3;i++)
    {
        dxmap10(str_diags+(i*lgdiag),i);
    }

    /* chargement des actes CCAM ou CDAM */
    strncpy(zone,ris.nbactes,2);zone[2]=0;
    nbactes=latoi(zone);
    /*CD 08/01/07 limitation du nombre d'actes à 10*/
    if(nbactes>10)
        nbactes=10;
    
    /*CD 10/01/07 initialisation des masques des actes*/
    memset(prof_actes,0,sizeof(prof_actes));
     
    for(i=0;i<nbactes;i++)
    {
        tab_actes[i].len=lgacte;
        //CD 05/01/07
        //strncpy(tab_actes[i].arr,risin1+l+i*lgacte,lgacte);
        strncpy(tab_actes[i].arr,risin+posacte+i*lgacte,lgacte);
        if(lgacte==4)
            prmap(tab_actes[i].arr,i);
        if(lgacte==8)
            prmap_ccam(tab_actes[i].arr,i);
    }
	
	age = -1;
	nbjchir = -1;
	/* Récupération de la date du lundi de la semaine du RHS */
	if (contfmt(ris.nosem,"999999",1,5)==0 && contnumsem(ris.nosem)==0)
	{
		dlundi_s(ris.nosem,datlun);

		/* Calcul de l'âge anniversaire à partir du lundi de la semaine */
		if (contfmt(ris.naiss,"Z9Z99999",1,7)==0 && contdate(ris.naiss)==0)
			callage(datlun,ris.naiss);

		/* Calcul du nombre de jours de chir avant le 1er jour de la semaine */
		/* ET : 2005/09/07 */
		if(contfmt(ris.datchir,"Z9Z99999",1,7)==0 && contdate(ris.datchir)==0)
		{
			nbjTmp=nombre_jour_1860(datlun)-nombre_jour_1860(ris.datchir);
			if (nbjTmp>999)
				nbjchir=999;
			else
			{
				if (-7<nbjTmp && nbjTmp<0)
					nbjchir=0;
				else
					if (-7>=nbjTmp && nbjTmp<0)
						nbjchir=-1;
					else
						nbjchir=(short)nbjTmp;
			}
		}
	}
	else
	{
		strncpy(datlun,"        ",8);
		datlun[8]=0;
	}

    ok_co= controle(vecerr,retc,cmc,ghj);
	
	// 31/01/2007 CD CG on compte un jour pour chaque '1' dans les journées de présences
	nbjpres=0;
	for(i=0;i<5;i++)
        if(ris.nbjhwe[i]=='1')
            nbjpres += 1;
    for(i=0;i<2;i++)
        if(ris.nbjwe[i]=='1')
            nbjpres += 1;

	// ok_co != 0 => erreur bloquante 
    if (ok_co!=0 )
        return(ok_co);

    dephy=(short)(ris.dephab-'0')+(short)(ris.depali-'0')+(short)(ris.depdep-'0')+(short)(ris.depcont-'0');
    // 31/01/2007 CD CG plus utilisé en M24
	//deprel=(short)(ris.depcomp-'0')+(short)(ris.deprel-'0');

    j=0;err=0;
    /* parcours de l'arbre */
    i = 0;
    trmap(i);
    while (treetab.nbranch != 0)
    {
        j++;
        if(j>1000){
            err=1;
            break;
        }
        rval = (*funcbuf[treetab.subclus])();
        if (treetab.subclus!=19)
            if (rval > treetab.nbranch){
                err=2;
                break;
            }
            i = _stpos + rval;
            if((ret=trmap(i))!=0){
                err=ret;
                break;
            }
    }

    *ghj = _stpos;
    *retc = treetab.para1;
    *cmc = treetab.para2;
    if (err!=0)
    {
        *ghj=904;
        *cmc=99;
        *retc=err;
    }
    return(0);
}

