#include "../h/licasc.h"

/*
 =======================================================================

     etlasc =  lecture de l'entete d'un fichier ascii.

     parametres =
        e       fdfic   = descripteur du fichier ascii,
        e       lent    = longueur de l'entete,
         s      lent    = longueur de l'entete lue,
         s      rentt   = tableau de reels qui contiendra l'entete lue.

     retourne =
            kerr        = indicateur d'erreur :
                         -1 = entete inexistante,
                          0 = absence d'erreur,
                          1 = nombre de donnees demandees superieur au
                              nombre disponible.
     generiques =
         err    = erreur
         crlf   = \n
         par    = parametre lu sur une ligne
      P...      = pointeur
      S...      = structure
       ...t     = tableau

     auteur = marimai.henaff    iut.orsay
     version 1.6 du 6/18/92

 =======================================================================
*/

int etlasc ( fdfic, rentt, Plent)
FILE    *fdfic;
float   *rentt;
int     *Plent;

{

        /* ... variables locales  ... */

        double dpart[NPARM];

        int     kerr;
        int     i;
        int     kent, kfin, kcrlf;
        int     ient, ipar, ichr;
        int     lzlig, llig, npar;
        int     itypt[NPARM], idebt[NPARM], nlont[NPARM];

        char    zlig[LLIGM] ;
        char    *Pzlig =zlig ;
        char    zligw[LLIGM] ;
        char    *Pzligw =zligw ;


        /* ... initialisations ... */

        ient = 0;
        kerr = 0 ;
        kent = 0 ;
        kfin = 0 ;
        kcrlf = 0 ;
        llig = LLIGM;
        lzlig = LLIGM;

        /* ... boucle sur le fichier ... */

        fseek ( fdfic, 0, 0) ;

        while ( !feof ( fdfic) && (kfin == 0) ) {

           fgets ( zlig, LLIGM, fdfic);


              /* ... detection de la cle entete ... */

              if ( strncmp ( zlig, ZCLEENT, 2) == 0) {
                 kent = 1;
              }
              else {

                 /* ... detection d'un commentaire ... */

                 if ( strncmp ( zlig, ZCLECOM, strlen( ZCLECOM)) != 0) {

                    if ( kent == 1) {

                    /* ... detection d'une nouvelle cle ... */

                    if ( strncmp ( zlig, ZCLE, strlen( ZCLE)) == 0) {
                       kfin = 1;
                    }
                    else {

                       /* ... detection d'une ligne blanche ... */

                       if ( ! ligspc ( zlig, llig)) {

                       /* ... initialisations ... */

                       npar = NPARM;
                       for ( ipar = 0; ipar < npar; ipar++) {
                          dpart[ipar] = 0.0;
                          itypt[ipar] = 0;
                          idebt[ipar] = 0;
                          nlont[ipar] = 0;
                       }
                       ipar = 0;
                       kcrlf = 0;

                       /* ... on rajoute des espaces ... */

                       for ( ichr = 0; ichr < llig; ichr++) {
                          if ( zlig[ichr] == '\n') {
                             kcrlf = 1 ;
                          }
                          if ( kcrlf != 1) {
                             zligw[ichr] = zlig[ichr];
                          }
                          else {
                             strncpy ( zligw+ichr, " ", 1);
                          }
                       }


                       /* ... analyse synthaxique de la ligne ... */

                          anastx ( Pzligw, llig, &npar,
                                 itypt, idebt, nlont, dpart);
/*debug
printf ( "llig, npar = %d %d \n", llig, npar);
for ( i=0; i<npar; i++) {
  printf ( "itypt, idebt, nlont, dpart = %d %d %d %f \n",
           itypt[i], idebt[i], nlont[i], dpart[i]);
}
enddebug*/
                       /* ... remplissage du tableau des valeurs ... */

                          while (( ipar < npar) && (ient < *Plent)) {
                             if ( itypt[ipar] != 0) {
                                rentt[ient] = dpart[ipar];
                                ient++;
                             }
                            ipar++;
                          }
                          if ( ient == *Plent) kfin = 1;
                       }
                    }
                 }
              }
           }
        }

        /* ... detection erreur ... */

        if ( kent == 0) {
           kerr = -1 ;
        }
        if ( ient < *Plent) {
           kerr = 1;
        }

        /* ... fin du traitement .................................... */

        /* ... mise a jour des parametres de sortie ... */

        *Plent = ient ;

        return ( kerr);
}