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

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

     ligasc = lecture sequentielle d'une ligne dans un fichier ascii
              au format fsi.

     parametres =
        e  fdfic        = descripteur du fichier ascii,
        e  kser         = numero de la serie contenant la ligne,
        e  iechd        = rang du premier echantillon (n0 de la ligne),
        e  nvecm        = nombre maximum de vecteurs demandes,
         s rvalt        = tableau des valeurs lues,
         s zstrt        = tableau des chaines lues,
         s nval         = nombre de valeurs effectivement lues.
         s nstr         = nombre de chaines effectivement lues.

     retourne =
           kerr         = indicateur d'erreur :
                          -3 = serie absente dans le fichier,
                          -2 = certains vecteurs ne sont pas presents
                                dans la serie,
                          -1 = rang du premier echantillon superieur au
                             nombre d'echantillons presents,
                           0 = absence d'erreur,
                           1 = nombre d'echantillons demandes superieur
                             au nombre d'echantillons presents.

     generiques =
         err    = erreur
      P...      = pointeur
      S...      = structure
       ...t     = tableau

     auteur = sylvain.coudray   MBARI-IFREMER/diti/dsi/ie
     version 1.1 du 02/01/95
  =======================================================================
*/

int ligasc ( fdfic, kser, iechd, nvecm, rvalt, zstrt, nvallu, nstrlu)
FILE    *fdfic;
int     *kser, *iechd, *nvecm, *nvallu, *nstrlu;
float   rvalt[];
char    *zstrt[];
{
        /* ... variables locales  ... */

        double dpart[NPARM];

        int     kerr ;
        int     i ;
        int     bfin, bcrlf ;
        int     bser ;
        int     iech, ival, ipar, ichr, ivec, imat, itab, istr;
        int     nvec;
        int     lzlig, llig, npar ;
        int     itypt[NPARM], idebt[NPARM], nlont[NPARM] ;

        char    zser[3], zvec[2];
        char    zlig[LLIGM] ;
        char    *Pzlig =zlig ;
        char    zligw[LLIGM] ;
        char    *Pzligw =zligw ;

        char    *p_string;

        /* ... initialisations ... */


        bser = 0;

        iech = 0;
        ival = 0;
        istr = 0;
        kerr = 0 ;

        bfin = 0 ;
        bcrlf = 0 ;
        llig = LLIGM ;
        lzlig = LLIGM ;

        sprintf ( zvec, "%s", ZCLEVEC) ;
        sprintf ( zser, "%s%d", ZCLESER, *kser ) ;

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

        rewind ( fdfic);

        while (bfin == 0) {

         /* ... lecture d'une ligne ... */

         fgets ( zlig, LLIGM, fdfic) ;

         if (feof ( fdfic)) {
             bfin = 1;
         }
         else {

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

          if ( strncmp ( zlig, ZCLEENT, 2) != 0) {

           /* ... detection de la cle serie ... */

           if ( strncmp ( zlig, zser, 3) == 0) {
              if ( !bser) {
                 bser = 1 ;
              }
              else {
                 bfin = 1 ;
              }
           }
           else {

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

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

                 if ( bser == 1) {


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

                    if (strncmp( zlig, ZCLESER, strlen( ZCLESER)) == 0){

                       if ( iech < *iechd) kerr = -1 ;
                       bfin = 1 ;

                    }
                    else {

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

                       if ( ! ligspc ( zlig, llig)) {

                             iech++ ;
                             if ( iech >= *iechd) {

                                /* ... initialisations ... */

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

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

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

                                /* analyse syntaxique de la ligne */

                                anastx ( Pzligw, llig, &npar,
                                         itypt, idebt, nlont, dpart) ;
/*debug
printf ( "zlig = %s \n", zlig);
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 */
                                /* remplissage du tableau des chaines */

                                nvec = npar;
                                if ( *nvecm < npar) nvec = *nvecm;
/*debug
printf ( " npar = %d\n", npar);
printf ( " nvec = %d\n", nvec);
enddebug*/

                                for( ivec=0; ivec<nvec; ivec++) {
                                      if (itypt[ivec] == 0) {
                                        p_string = (char *) malloc (nlont[ivec]+1);
                                        strncpy ( p_string,
                                                  Pzligw + idebt[ivec] - 1,
                                                  nlont[ivec]);
                                        *(p_string + nlont[ivec]) = NULL;
                                        zstrt[istr] = p_string;
                                        istr++;
/*debug
printf (" nlont[ivec] = %d \n", nlont[ivec]);
printf (" pzligw   = %s \n", Pzligw + idebt[ivec] - 1);
printf (" p_string = %s \n", p_string);
enddebug*/
                                      } else {
                                        rvalt[ival] = dpart[ivec] ;
                                        ival++ ;
                                      }
                                }

/*debug
printf ( " ival, istr, nvec %d %d %d\n", ival, istr, nvec);
enddebug*/

                                bfin = 1 ;

                             } /* fin test iech >= *iechd */

                       } /* fin detection d'une ligne blanche */

                    } /* fin detection d'une nouvelle cle serie */

                 } /* fin test bser == 1 */

              } /* fin detection d'un commentaire */

           } /* fin dectection de la cle serie */
          } /* detection de la cle entete */
         } /* fin test feof */

        } /* while (bfin == 0), boucle sur lignes */

        *nvallu = ival ;
        *nstrlu = istr ;

        if (bser == 0) {
           kerr = -3 ;
        }

        return ( kerr) ;

}