tslib_fcd

C/C++ source

0001 
0002 /*****************************************************************************
0003              .....   "tslib_fcd.c"    .....
0004         ..... Interface C -- Fortran  pour TSLib client .....
0005             ..... Version double .....
0006             ..... YB  Mars 1994 .....
0007         .....       Life will never be the same      .....
0008  *****************************************************************************/
0009 
0010 #include <stdlib.h>
0011 #include <string.h>
0012 #include <memory.h>
0013 #include "tsconf.h"
0014 #include "tsdef.h"
0015 #include "tstype.h"
0016 char tslib_reel = 'd';
0017 #define PREPASIZE    8
0018 #define LHEURE        9
0019 #define LDATE        11
0020 
0021 /*----------------------------------------------------------------------------
0022                         TSSigDeclenche
0023 
0024   But : fonction demandant au serveur de lui renvoyer les valeurs d'un signal
0025         brut pour une occurrence d'une declenche donnee
0026 
0027   Arguments :
0028         NomDon    : nom de la donnee
0029         NumChoc   : numero de choc
0030         NomDec    : nom d'une declenche
0031         Occur     : occurrence d'une declenche
0032         NbMax     : nombre maximum de mesures souhaitees
0033         Extract   : type d'extraction souhaitee
0034 
0035         Unite     : liste des unites des mesures rendues
0036         NumVer    : numero de version du createur
0037         Date      : date d'execution du diagnostic ou du traitement
0038         Heure     : heure  d'execution du diagnostic ou du traitement
0039         NbMes     : nombre de valeurs rendues
0040         MaxReel   : nombre de valeurs trouvees
0041         T         : tableau des valeurs des temps
0042         Y         : tableau des valeurs des mesures
0043 
0044   Retour          : compte-rendu d'execution
0045 
0046 ------------------------------------------------------------------------------*/
0047 
0048 int
0049 tssigdeclenche_ (NomDon, NumChoc, NomDec, Occur, NbMax, Extract, Unite,
0050          NumVer, Date, Heure, NbMes, MaxReel, T, Y,
0051          lnd, lndc, lut, ldt, lhr, lT, lY)
0052 
0053      char *NomDon;
0054      Longint *NumChoc;
0055      char *NomDec;
0056      Longint *Occur;
0057      Longint *NbMax;
0058      Longint *Extract;
0059      char *Unite[];
0060      Longint *NumVer;
0061      char *Date;
0062      char *Heure;
0063      Longint *NbMes;
0064      Longint *MaxReel;
0065      char *T;
0066      char *Y;
0067      int lnd, lndc, lut, ldt, lhr, lT, lY;
0068 {
0069   struct S_Unite *ptunite;
0070   pS_Unite ptu;
0071   int cr = 0;
0072   int len;
0073   char Ndt[TAILLE_NOM_DONNEE], Ndec[PREPASIZE + 1], *ptc;
0074 
0075   if ((cr = check_dateheure (ldt, lhr)) < 0)
0076     return cr;
0077   cclean (NomDon, Ndt, lnd);
0078   cclean (NomDec, Ndec, lndc);
0079 
0080   cr = TSSigDeclenche (Ndt, *NumChoc, Ndec, *Occur, *NbMax, *Extract,
0081                &ptunite, NumVer, Date, Heure, NbMes, MaxReel, T, Y);
0082   if (!cr)
0083     {
0084       if (ptunite)
0085     {
0086       ptc = (char *) Unite;
0087       ptu = ptunite;
0088       do
0089         {
0090           if (ptu->nom)
0091         {
0092           len = strlen (ptu->nom);
0093           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
0094           if (lut > len)
0095             memset (ptc + len * sizeof (char), ' ', (lut - len));
0096         }
0097           ptc += lut * sizeof (char);
0098         }
0099       while (ptu = ptu->ps_suivant);
0100       free (ptunite);
0101     }
0102       clean_dateheure (Date, ldt, Heure, lhr);
0103     }
0104   return (cr);
0105 }
0106 
0107 /*----------------------------------------------------------------------------
0108                         TSXtrDeclenche
0109 
0110   But : fonction demandant au serveur de lui renvoyer les valeurs d'un signal
0111         brut extrait d'un groupe pour une occurrence d'une declenche donnee
0112 
0113   Arguments :
0114         NomDon    : nom de la donnee
0115         NumChoc   : numero de choc
0116         Indices   : tableau des indices du signal dans le groupe
0117         NomDec    : nom d'une declenche
0118         Occur     : occurrence d'une declenche
0119         NbMax     : nombre maximum de mesures souhaitees
0120         Extract   : type d'extraction souhaitee
0121 
0122         Unite     : liste des unites des mesures rendues
0123         NumVer    : numero de version du createur
0124         Date      : date d'execution du diagnostic ou du traitement
0125         Heure     : heure  d'execution du diagnostic ou du traitement
0126         NbMes     : nombre de valeurs rendues
0127         MaxReel   : nombre de valeurs trouvees
0128         T         : tableau des valeurs des temps
0129         Y         : tableau des valeurs des mesures
0130 
0131   Retour          : compte-rendu d'execution
0132 
0133 ------------------------------------------------------------------------------*/
0134 
0135 int
0136 tsxtrdeclenche_ (NomDon, NumChoc, Indices, NomDec, Occur, NbMax, Extract,
0137          Unite, NumVer, Date, Heure, NbMes, MaxReel, T, Y,
0138          lnd, lndc, lut, ldt, lhr, lT, lY)
0139 
0140      char *NomDon;
0141      Longint *NumChoc;
0142      Longint *Indices;
0143      char *NomDec;
0144      Longint *Occur;
0145      Longint *NbMax;
0146      Longint *Extract;
0147      char *Unite[];
0148      Longint *NumVer;
0149      char *Date;
0150      char *Heure;
0151      Longint *NbMes;
0152      Longint *MaxReel;
0153      char *T;
0154      char *Y;
0155      int lnd, lndc, lut, ldt, lhr, lT, lY;
0156 
0157 {
0158   struct S_Unite *ptunite;
0159   pS_Unite ptu;
0160   int cr = 0;
0161   int len;
0162   char Ndt[TAILLE_NOM_DONNEE], Ndec[PREPASIZE + 1], *ptc;
0163 
0164   if ((cr = check_dateheure (ldt, lhr)) < 0)
0165     return cr;
0166   cclean (NomDon, Ndt, lnd);
0167   cclean (NomDec, Ndec, lndc);
0168 
0169   cr = TSXtrDeclenche (Ndt, *NumChoc, Indices, Ndec, *Occur, *NbMax,
0170          *Extract, &ptunite, NumVer, Date, Heure, NbMes, MaxReel, T, Y);
0171   if (!cr)
0172     {
0173       if (ptunite)
0174     {
0175       ptc = (char *) Unite;
0176       ptu = ptunite;
0177       do
0178         {
0179           if (ptu->nom)
0180         {
0181           len = strlen (ptu->nom);
0182           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
0183           if (lut > len)
0184             memset (ptc + len * sizeof (char), ' ', (lut - len));
0185         }
0186           ptc += lut * sizeof (char);
0187         }
0188       while (ptu = ptu->ps_suivant);
0189       free (ptunite);
0190     }
0191       clean_dateheure (Date, ldt, Heure, lhr);
0192     }
0193   return (cr);
0194 }
0195 
0196 /*----------------------------------------------------------------------------
0197 
0198                         TSGrpDeclenche
0199 
0200   But : fonction demandant au serveur de lui renvoyer les valeurs d'un groupe
0201         de signaux bruts pour une occurrence d'une declenche donnee
0202 
0203   Arguments :
0204         NomDon    : nom de la donnee
0205         NumChoc   : numero de choc
0206         NomDec    : nom d'une declenche
0207         Occur     : occurrence d'une declenche
0208         NbMax     : nombre maximum de mesures souhaitees
0209         Extract   : type d'extraction souhaitee
0210 
0211         Unite     : liste des unites des mesures rendues
0212         NumVer    : numero de version du createur
0213         Date      : date d'execution du diagnostic ou du traitement
0214         Heure     : heure  d'execution du diagnostic ou du traitement
0215         NbMes     : nombre de valeurs rendues
0216         MaxReel   : nombre de valeurs trouvees
0217         T         : tableau des valeurs des temps
0218         Y         : tableau des valeurs des mesures
0219 
0220   Retour          : compte-rendu d'execution
0221 
0222 ------------------------------------------------------------------------------*/
0223 
0224 int
0225 tsgrpdeclenche_ (NomDon, NumChoc, NomDec, Occur, NbMax, Extract, Unite,
0226          NumVer, Date, Heure, NbMes, MaxReel, T, Y,
0227          lnd, lndc, lut, ldt, lhr, lT, lY)
0228 
0229      char *NomDon;
0230      Longint *NumChoc;
0231      char *NomDec;
0232      Longint *Occur;
0233      Longint *NbMax;
0234      Longint *Extract;
0235      char *Unite[];
0236      Longint *NumVer;
0237      char *Date;
0238      char *Heure;
0239      Longint *NbMes;
0240      Longint *MaxReel;
0241      char *T;
0242      char *Y;
0243      int lnd, lndc, lut, ldt, lhr, lT, lY;
0244 
0245 {
0246   struct S_Unite *ptunite;
0247   pS_Unite ptu;
0248   int cr = 0;
0249   int len;
0250   char Ndt[TAILLE_NOM_DONNEE], Ndec[PREPASIZE + 1], *ptc;
0251 
0252   if ((cr = check_dateheure (ldt, lhr)) < 0)
0253     return cr;
0254   cclean (NomDon, Ndt, lnd);
0255   cclean (NomDec, Ndec, lndc);
0256 
0257   cr = TSGrpDeclenche (Ndt, *NumChoc, Ndec, *Occur, *NbMax, *Extract,
0258                &ptunite, NumVer, Date, Heure, NbMes, MaxReel, T, Y);
0259   if (!cr)
0260     {
0261       if (ptunite)
0262     {
0263       ptc = (char *) Unite;
0264       ptu = ptunite;
0265       do
0266         {
0267           if (ptu->nom)
0268         {
0269           len = strlen (ptu->nom);
0270           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
0271           if (lut > len)
0272             memset (ptc + len * sizeof (char), ' ', (lut - len));
0273         }
0274           ptc += lut * sizeof (char);
0275         }
0276       while (ptu = ptu->ps_suivant);
0277       free (ptunite);
0278     }
0279       clean_dateheure (Date, ldt, Heure, lhr);
0280     }
0281   return (cr);
0282 }
0283 
0284 /*----------------------------------------------------------------------------
0285 
0286                         TSDescTrait
0287 
0288   But : fonction demandant au serveur de lui envoyer la description d'un
0289         traitement
0290 
0291   Arguments :
0292         NomTrait  : nom du traitement
0293         NumVer    : numero de version
0294 
0295         DescTrait : description du traitement
0296 
0297   Retour          : compte-rendu d'execution
0298 
0299 ------------------------------------------------------------------------------*/
0300 
0301 int
0302 tsdesctrait_ (NomTrait, NumVer, DescTrait, ldt)
0303 
0304      char *NomTrait;
0305      int *NumVer;
0306      char *DescTrait;
0307      int ldt;
0308 
0309 {
0310   pS_DescTrait ptdt;
0311   pS_Donnee ptd;
0312   int cr = 0, offset = 0;
0313   int len;
0314   char *pt = DescTrait;
0315   char Ndt[TAILLE_NOM_TRAITEMENT];
0316 
0317   cclean (NomTrait, Ndt, ldt);
0318   cr = TSDescTrait (Ndt, *NumVer, &ptdt);
0319 
0320   if (!cr)
0321     {
0322       ptd = ptdt->ps_donnee;
0323       if (ptdt->nom)
0324     {
0325       len = strlen (ptdt->nom);
0326       memcpy (pt, ptdt->nom, len);
0327       if (TAILLE_NOM_TRAITEMENT - 1 > len)
0328         memset (pt + len , ' ', (TAILLE_NOM_TRAITEMENT - len));
0329     }
0330       offset += TAILLE_NOM_TRAITEMENT - 1;
0331 
0332       if (ptdt->commentaire)
0333     {
0334       len = strlen (ptdt->commentaire);
0335       memcpy (pt + offset, ptdt->commentaire, len);
0336       if (TAILLE_COMMENTAIRE - 1 > len)
0337         memset (pt + offset + len , ' ', (TAILLE_COMMENTAIRE - len));
0338     }
0339       offset += TAILLE_COMMENTAIRE - 1;
0340 
0341       if (ptdt->auteurs)
0342     {
0343       len = strlen (ptdt->auteurs);
0344       memcpy (pt + offset, ptdt->auteurs, len);
0345       if (TAILLE_NOM_AUTEURS - 1 > len)
0346         memset (pt + offset + len , ' ', (TAILLE_NOM_AUTEURS - len));
0347     }
0348       offset += TAILLE_NOM_AUTEURS - 1;
0349 
0350       if (ptdt->date)
0351     {
0352       len = strlen (ptdt->date);
0353       memcpy (pt + offset, ptdt->date, len);
0354       if (TAILLE_DATE - 1 > len)
0355         memset (pt + offset + len , ' ', (TAILLE_DATE - len));
0356     }
0357       offset += TAILLE_DATE - 1;
0358 
0359       memcpy (pt + offset, &(ptdt->type), sizeof (Longint));
0360       offset += sizeof (Longint);
0361 
0362       memcpy (pt + offset, &(ptdt->num_version), sizeof (short));
0363       offset += sizeof (short);
0364 
0365       if (ptdt->localisation)
0366     {
0367 
0368       len = strlen (ptdt->localisation);
0369       memcpy (pt + offset, ptdt->localisation, len);
0370       if (TAILLE_NOM_LOCALISATION - 1 > len)
0371         memset (pt + offset + len , ' ', (TAILLE_NOM_LOCALISATION - len));
0372     }
0373       offset += TAILLE_NOM_LOCALISATION - 1;
0374 
0375       if (ptdt->machine)
0376     {
0377       len = strlen (ptdt->machine);
0378       memcpy (pt + offset, ptdt->machine, len);
0379       if (TAILLE_NOM_MACHINE - 1 > len)
0380         memset (pt + offset + len , ' ', (TAILLE_NOM_MACHINE - len));
0381     }
0382       offset += TAILLE_NOM_MACHINE - 1;
0383 
0384       memcpy (pt + offset, &(ptdt->nb_donnees), sizeof (short));
0385       offset += sizeof (short);
0386 
0387       if (ptd)
0388     {
0389       do
0390         {
0391           if (ptd->nom)
0392         {
0393           len = strlen (ptd->nom);
0394           memcpy (pt + offset, ptd->nom, len);
0395           if (TAILLE_NOM_DONNEE - 1 > len)
0396             memset (pt + offset + len , ' ', (TAILLE_NOM_DONNEE - len));
0397         }
0398           offset += TAILLE_NOM_DONNEE - 1;
0399         }
0400       while (ptd = ptd->ps_suivant);
0401       free (ptd);
0402     }
0403       free (ptdt);
0404     }
0405   return (cr);
0406 }
0407 
0408 /*----------------------------------------------------------------------------
0409 
0410                         TSDescDiag
0411 
0412   But : fonction demandant au serveur de lui envoyer la description d'un
0413         diagnostic
0414 
0415   Arguments :
0416         NomDiag   : nom du diagnostic
0417         NumVer    : numero de version
0418 
0419         DescDiag  : description du diagnostic
0420 
0421   Retour          : compte-rendu d'execution
0422 
0423 ------------------------------------------------------------------------------*/
0424 
0425 int
0426 tsdescdiag_ (NomDiag, NumVer, DescDiag, ldd)
0427 
0428      char *NomDiag;
0429      Longint *NumVer;
0430      char *DescDiag;
0431      int ldd;
0432 
0433 {
0434   pS_DescDiag ptdd;
0435   pS_Donnee ptd;
0436   int cr = 0, offset = 0;
0437   char *pt = DescDiag;
0438   int len;
0439   char Ndt[TAILLE_NOM_DIAGNOSTIC];
0440 
0441   cclean (NomDiag, Ndt, ldd);
0442   cr = TSDescDiag (Ndt, *NumVer, &ptdd);
0443   if (!cr)
0444     {
0445       ptd = ptdd->ps_donnee;
0446       if (ptdd->nom)
0447     {
0448       len = strlen (ptdd->nom);
0449       memcpy (pt, ptdd->nom, len);
0450       if (TAILLE_NOM_DIAGNOSTIC - 1 > len)
0451         memset (pt + len , ' ', (TAILLE_NOM_DIAGNOSTIC - len));
0452     }
0453       offset += TAILLE_NOM_DIAGNOSTIC - 1;
0454 
0455       if (ptdd->commentaire)
0456     {
0457       len = strlen (ptdd->commentaire);
0458       memcpy (pt + offset, ptdd->commentaire, len);
0459       if (TAILLE_COMMENTAIRE - 1 > len)
0460         memset (pt + offset + len , ' ', (TAILLE_COMMENTAIRE - len));
0461     }
0462       offset += TAILLE_COMMENTAIRE - 1;
0463 
0464       if (ptdd->auteurs)
0465     {
0466       len = strlen (ptdd->auteurs);
0467       memcpy (pt + offset, ptdd->auteurs, len);
0468       if (TAILLE_NOM_AUTEURS - 1 > len)
0469         memset (pt + offset + len , ' ', (TAILLE_NOM_AUTEURS - len));
0470     }
0471       offset += TAILLE_NOM_AUTEURS - 1;
0472 
0473       if (ptdd->date)
0474     {
0475       len = strlen (ptdd->date);
0476       memcpy (pt + offset, ptdd->date, len);
0477       if (TAILLE_DATE - 1 > len)
0478         memset (pt + offset + len , ' ', (TAILLE_DATE - len));
0479     }
0480       offset += TAILLE_DATE - 1;
0481 
0482       memcpy (pt + offset, &(ptdd->type), sizeof (Longint));
0483       offset += sizeof (Longint);
0484 
0485       memcpy (pt + offset, &(ptdd->num_version), sizeof (short));
0486       offset += sizeof (short);
0487 
0488       memcpy (pt + offset, &(ptdd->nb_donnees), sizeof (short));
0489       offset += sizeof (short);
0490       if (ptd)
0491     {
0492       do
0493         {
0494           if (ptd->nom)
0495         {
0496           len = strlen (ptd->nom);
0497           memcpy (pt + offset, ptd->nom, len);
0498           if (TAILLE_NOM_DONNEE - 1 > len)
0499             memset (pt + offset + len , ' ', (TAILLE_NOM_DONNEE - len));
0500         }
0501           offset += TAILLE_NOM_DONNEE - 1;
0502         }
0503       while (ptd = ptd->ps_suivant);
0504       free (ptd);
0505     }
0506       free (ptdd);
0507     }
0508   return (cr);
0509 }
0510 
0511 /*----------------------------------------------------------------------------
0512 
0513                         TSDescDon
0514 
0515   But : fonction demandant au serveur de lui envoyer la description d'une
0516         donnee
0517 
0518   Arguments :
0519         NomDon    : nom de la donnee
0520 
0521         DescDon   : description de la donnee
0522 
0523   Retour          : compte-rendu d'execution
0524 
0525 ------------------------------------------------------------------------------*/
0526 
0527 int
0528 tsdescdon_ (NomDon, DescDon, ldd)
0529 
0530      char *NomDon;
0531      char *DescDon;
0532      int ldd;
0533 
0534 {
0535   pS_DescDon ptdd;
0536   pS_DescCoord ptd;
0537   int cr = 0, offset = 0;
0538   char *pt = DescDon;
0539   int len;
0540   char Ndt[TAILLE_NOM_DONNEE];
0541 
0542   cclean (NomDon, Ndt, ldd);
0543   cr = TSDescDon (Ndt, &ptdd);
0544 
0545   if (!cr)
0546     {
0547       ptd = ptdd->ps_coord;
0548       if (ptdd->nom)
0549     {
0550       len = strlen (ptdd->nom);
0551       memcpy (pt, ptdd->nom, len);
0552       if (TAILLE_NOM_DONNEE - 1 > len)
0553         memset (pt + len , ' ', (TAILLE_NOM_DONNEE - len));
0554     }
0555       offset += TAILLE_NOM_DONNEE - 1;
0556 
0557       if (ptdd->nom_producteur)
0558     {
0559       len = strlen (ptdd->nom_producteur);
0560       memcpy (pt + offset, ptdd->nom_producteur, len);
0561       if (TAILLE_NOM_PRODUCTEUR - 1 > len)
0562         memset (pt + offset + len , ' ', (TAILLE_NOM_PRODUCTEUR - len));
0563     }
0564       offset += TAILLE_NOM_PRODUCTEUR - 1;
0565 
0566       if (ptdd->commentaire)
0567     {
0568       len = strlen (ptdd->commentaire);
0569       memcpy (pt + offset, ptdd->commentaire, len);
0570       if (TAILLE_COMMENTAIRE - 1 > len)
0571         memset (pt + offset + len , ' ', (TAILLE_COMMENTAIRE - len));
0572     }
0573       offset += TAILLE_COMMENTAIRE - 1;
0574 
0575       offset += 2;
0576 
0577       memcpy (pt + offset, &(ptdd->type), sizeof (Longint));
0578       offset += sizeof (Longint);
0579 
0580       memcpy (pt + offset, &(ptdd->nb_comp), sizeof (short));
0581       offset += sizeof (short);
0582 
0583       memcpy (pt + offset, &(ptdd->nb_coord), sizeof (short));
0584       offset += sizeof (short);
0585 
0586       if (ptd)
0587     {
0588       do
0589         {
0590           if (ptd->nom)
0591         {
0592           len = strlen (ptd->nom);
0593           memcpy (pt + offset, ptd->nom, len);
0594           if (TAILLE_NOM_COORDONNEE - 1 > len)
0595             memset (pt + offset + len , ' ', (TAILLE_NOM_COORDONNEE - len));
0596         }
0597           offset += TAILLE_NOM_COORDONNEE - 1;
0598           if (ptd->format)
0599         {
0600           len = strlen (ptd->format);
0601           memcpy (pt + offset, ptd->format, len);
0602           if (TAILLE_FORMAT - 1 > len)
0603             memset (pt + offset + len , ' ', (TAILLE_FORMAT - len));
0604         }
0605           offset += TAILLE_FORMAT - 1;
0606           if (ptd->unite)
0607         {
0608           len = strlen (ptd->unite);
0609           memcpy (pt + offset, ptd->unite, len);
0610           if (TAILLE_NOM_UNITE - 1 > len)
0611             memset (pt + offset + len , ' ', (TAILLE_NOM_UNITE - len));
0612         }
0613           offset += TAILLE_NOM_UNITE - 1;
0614           if (ptd->pretraitement)
0615         {
0616           len = strlen (ptd->pretraitement);
0617           memcpy (pt + offset, ptd->pretraitement, len);
0618           if (TAILLE_PRETRAITEMENT - 1 > len)
0619             memset (pt + offset + len , ' ', (TAILLE_PRETRAITEMENT - len));
0620         }
0621           offset += TAILLE_PRETRAITEMENT - 1;
0622         }
0623       while (ptd = ptd->ps_suivant);
0624       free (ptd);
0625     }
0626       free (ptdd);
0627     }
0628   return (cr);
0629 }
0630 
0631 /*----------------------------------------------------------------------------
0632 
0633                         TSExist
0634 
0635   But : fonction demandant au serveur de verifier l'existence d'une donnee
0636         et de lui envoyer les informations la concernant
0637 
0638   Arguments :
0639         NomDon    : nom de la donnee
0640         Entrees   : liste des entrees du traitement
0641 
0642         NbCoord   : tableau de valeurs des coordonnees ou nombre de mesures
0643         NumVer    : numero de version du createur
0644         Certif    : tableau des certifications
0645         Date      : date d'execution du diagnostic ou du traitement
0646         Heure     : heure  d'execution du diagnostic ou du traitement
0647 
0648   Retour          : compte-rendu d'execution
0649 
0650 ------------------------------------------------------------------------------*/
0651 
0652 
0653 int
0654 tsexist_ (NomDon, Entrees, NbCoord, NumVer, Certif, Date, Heure,
0655       lnd, ldt, lhr)
0656 
0657      char *NomDon;
0658      Longint *Entrees;
0659      Longint *NbCoord;
0660      Longint *NumVer;
0661      Longint *Certif;
0662      char *Heure, *Date;
0663      int lnd, ldt, lhr;
0664 {
0665   pS_Entree Entreesc;
0666   int cr = 0, i;
0667   char Ndt[TAILLE_NOM_DONNEE];
0668 
0669   if ((ldt < LDATE) || (lhr < LHEURE))
0670     return (-11);
0671 
0672   cclean (NomDon, Ndt, lnd);
0673 
0674   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
0675   Entreesc->union_var.lval = *Entrees;
0676   Entreesc->ps_suivant = NULL;
0677 
0678   cr = TSExist (Ndt, Entreesc, NbCoord, NumVer, Certif, Date, Heure);
0679 
0680   clean_dateheure (Date, ldt, Heure, lhr);
0681 
0682   free (Entreesc);
0683   return (cr);
0684 
0685 }
0686 
0687 /*----------------------------------------------------------------------------
0688 
0689                         TSWrite
0690 
0691   But : fonction envoyant au serveur la liste des parametres a ecrire en
0692         base de donnees et dans les fichiers de mesure
0693 
0694   Arguments :
0695         NomTrait  : nom du traitement
0696         Entrees   : liste des entrees du traitement
0697         Longueurs : longueurs des coordonnees
0698         Certif    : tableau des certifications
0699         TabVal    : tableau des mesures
0700         LongNb    : taille en octets du tableau Longueurs
0701         CertifNb  : taille en octets du tableau Certif
0702         ValNb     : taille en octets du tableau TabVal
0703 
0704   Retour          : compte-rendu d'execution
0705 
0706 ------------------------------------------------------------------------------*/
0707 
0708 int
0709 tswrite_ (NomTrait, Entrees, Longueurs, Certif, TabVal, LongNb, CertifNb, ValNb, lnt)
0710 
0711      char *NomTrait;
0712      Longint *Entrees;
0713      Longint *Longueurs;
0714      Longint *Certif;
0715      char *TabVal;
0716      Longint *LongNb, *CertifNb, *ValNb;
0717      int lnt;            /* longueur  nom traitement  */
0718 {
0719   pS_Entree Entreesc;
0720   int cr = 0;
0721   char Ndt[TAILLE_NOM_TRAITEMENT];
0722 
0723   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
0724   Entreesc->union_var.lval = *Entrees;
0725   Entreesc->ps_suivant = NULL;
0726 
0727   cclean (NomTrait, Ndt, lnt);
0728   cr = TSWrite (Ndt, Entreesc, Longueurs, Certif, TabVal, *LongNb,
0729         *CertifNb, *ValNb);
0730 
0731   free (Entreesc);
0732   return (cr);
0733 }
0734 
0735 /*----------------------------------------------------------------------------
0736 
0737                         TSWritePlusOc
0738 
0739   But : fonction envoyant au serveur la liste des parametres a ecrire en
0740         base de donnees et dans les fichiers de mesure
0741 
0742   Arguments :
0743         NomTrait  : nom du traitement
0744         Entrees   : numero du choc
0745         Occ       : numero d'occurence
0746         Longueurs : longueurs des coordonnees
0747         Certif    : tableau des certifications
0748         TabVal    : tableau des mesures
0749         LongNb    : taille en octets du tableau Longueurs
0750         CertifNb  : taille en octets du tableau Certif
0751         ValNb     : taille en octets du tableau TabVal
0752 
0753   Retour          : compte-rendu d'execution
0754 
0755 ------------------------------------------------------------------------------*/
0756 
0757 int
0758 tswriteplusoc_ (NomTrait, Entrees, Occ, Longueurs, Certif, TabVal, LongNb, 
0759           CertifNb, ValNb, lnt)
0760 
0761      char *NomTrait;
0762      Longint *Entrees;
0763      Longint *Occ;
0764      Longint *Longueurs;
0765      Longint *Certif;
0766      char *TabVal;
0767      Longint *LongNb, *CertifNb, *ValNb;
0768      int lnt;            /* longueur  nom traitement  */
0769 {
0770   pS_Entree Entreesc;
0771   int cr = 0;
0772   char Ndt[TAILLE_NOM_TRAITEMENT];
0773 
0774   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
0775   Entreesc->union_var.lval = *Entrees;
0776 
0777   if (*Occ > 0) {
0778     Entreesc->ps_suivant = (pS_Entree) malloc (sizeof (struct S_Entree));
0779     Entreesc->ps_suivant->union_var.lval = *Occ;
0780     Entreesc->ps_suivant->ps_suivant = NULL;
0781   }
0782   else
0783     Entreesc->ps_suivant = NULL;
0784 
0785  /* Entreesc->ps_suivant = NULL; */
0786 
0787   cclean (NomTrait, Ndt, lnt);
0788   cr = TSWrite (Ndt, Entreesc, Longueurs, Certif, TabVal, *LongNb,
0789         *CertifNb, *ValNb);
0790 
0791   free (Entreesc);
0792   return (cr);
0793 }
0794 
0795 /*----------------------------------------------------------------------------
0796 
0797                         TSWcertif
0798 
0799   But : fonction envoyant au serveur les certifications associees a une donnee
0800 
0801   Arguments :
0802         NomDon    : nom de la donnee
0803         Entrees   : liste des entrees du traitement
0804         Certif    : tableau des certifications
0805         CertifNb  : taille en octets du tableau Certif
0806 
0807   Retour          : compte-rendu d'execution
0808 
0809 ------------------------------------------------------------------------------*/
0810 
0811 
0812 int
0813 tswcertif_ (NomDon, Entrees, Certif, CertifNb, lnd)
0814 
0815      char *NomDon;
0816      Longint *Entrees;
0817      Longint *Certif;
0818      Longint *CertifNb;
0819      int lnd;
0820 
0821 {
0822   pS_Entree Entreesc;
0823   int cr = 0;
0824   char Ndt[TAILLE_NOM_DONNEE];
0825 
0826   cclean (NomDon, Ndt, lnd);
0827 
0828   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
0829   Entreesc->union_var.lval = *Entrees;
0830   Entreesc->ps_suivant = NULL;
0831 
0832   cr = TSWcertif (Ndt, Entreesc, Certif, *CertifNb);
0833 
0834   free (Entreesc);
0835   return (cr);
0836 }
0837 
0838 /*----------------------------------------------------------------------------
0839 
0840                         TSRSigRg
0841 
0842   But : fonction demandant au serveur de lui renvoyer un signal lu entre 2 rangs
0843 
0844   Arguments :
0845         NomDon    : nom de la donnee
0846         Entrees   : liste des entrees du traitement
0847         Rangs     : tableau contenant le rang initial et le rang final
0848         NbMax     : nombre maximum de mesures souhaitees
0849         Extract   : type d'extraction souhaitee
0850 
0851         Unite     : liste des unites des mesures rendues
0852         NumVer    : numero de version du createur
0853         Certif    : tableau des certifications
0854         Date      : date d'execution du diagnostic ou du traitement
0855         Heure     : heure  d'execution du diagnostic ou du traitement
0856         NbMes     : nombre de valeurs rendues
0857         MaxReel   : nombre reel de valeurs
0858         X         : tableau des valeurs des abscisses
0859         Y         : tableau des valeurs des mesures
0860 
0861   Retour          : compte-rendu d'execution
0862 
0863 ------------------------------------------------------------------------------*/
0864 
0865 
0866 int
0867 tsrsigrg_ (NomDon, Entrees, Rangs, NbMax, Extract, Unite, NumVer, Certif,
0868        Date, Heure, NbMes, MaxReel, X, Y,
0869        lnd, lut, ldt, lhr)
0870 
0871      char *NomDon;
0872      Longint *Entrees;
0873      Longint *Rangs;
0874      Longint *NbMax;
0875      Longint *Extract;
0876      char *Unite[];
0877      Longint *NumVer;
0878      Longint *Certif;
0879      char *Date;
0880      char *Heure;
0881      Longint *NbMes;
0882      Longint *MaxReel;
0883      char *X;
0884      char *Y;
0885      int lnd, lut, ldt, lhr;
0886 
0887 {
0888   struct S_Unite *ptunite;
0889   pS_Unite ptu;
0890   pS_Entree Entreesc;
0891   int cr = 0;
0892   int len;
0893   char *ptc, Ndt[TAILLE_NOM_DONNEE];
0894 
0895   if ((cr = check_dateheure (ldt, lhr)) < 0)
0896     return cr;
0897   cclean (NomDon, Ndt, lnd);
0898 
0899   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
0900   Entreesc->union_var.lval = *Entrees;
0901   Entreesc->ps_suivant = NULL;
0902 
0903   cr = TSRSigRg (Ndt, Entreesc, Rangs, *NbMax, *Extract, &ptunite, NumVer,
0904          Certif, Date, Heure, NbMes, MaxReel, X, Y);
0905 
0906   if (!cr)
0907     {
0908       if (ptunite)
0909     {
0910       ptc = (char *) Unite;
0911       ptu = ptunite;
0912 
0913       do
0914         {
0915           if (ptu->nom)
0916         {
0917           len = strlen (ptu->nom);
0918           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
0919           if (lut > len)
0920             memset (ptc + sizeof (char) * len, ' ', (lut - len));
0921         }
0922           ptc += sizeof (char) * lut;
0923         }
0924       while (ptu = ptu->ps_suivant);
0925       free (ptunite);
0926     }
0927       clean_dateheure (Date, ldt, Heure, lhr);
0928     }
0929   free (Entreesc);
0930   return (cr);
0931 
0932 }
0933 
0934 
0935 int
0936 tsrsigrgplusoc_ (NomDon, Entrees, Occ, Rangs, NbMax, Extract, Unite, NumVer,
0937                  Certif, Date, Heure, NbMes, MaxReel, X, Y, lnd, lut, ldt, lhr)
0938 
0939      char *NomDon;
0940      Longint *Entrees;
0941      Longint *Occ;
0942      Longint *Rangs;
0943      Longint *NbMax;
0944      Longint *Extract;
0945      char *Unite[];
0946      Longint *NumVer;
0947      Longint *Certif;
0948      char *Date;
0949      char *Heure;
0950      Longint *NbMes;
0951      Longint *MaxReel;
0952      char *X;
0953      char *Y;
0954      int lnd, lut, ldt, lhr;
0955 
0956 {
0957   struct S_Unite *ptunite;
0958   pS_Unite ptu;
0959   pS_Entree Entreesc;
0960   int cr = 0;
0961   int len;
0962   char *ptc, Ndt[TAILLE_NOM_DONNEE];
0963 
0964   if ((cr = check_dateheure (ldt, lhr)) < 0)
0965     return cr;
0966   cclean (NomDon, Ndt, lnd);
0967 
0968   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
0969   Entreesc->union_var.lval = *Entrees;
0970   /*Entreesc->ps_suivant = NULL; */
0971  
0972   if (*Occ > 0) {
0973     Entreesc->ps_suivant = (pS_Entree) malloc (sizeof (struct S_Entree));
0974     Entreesc->ps_suivant->union_var.lval = *Occ;
0975     Entreesc->ps_suivant->ps_suivant = NULL;
0976   }
0977   else
0978     Entreesc->ps_suivant = NULL; 
0979 
0980   cr = TSRSigRg (Ndt, Entreesc, Rangs, *NbMax, *Extract, &ptunite, NumVer,
0981          Certif, Date, Heure, NbMes, MaxReel, X, Y);
0982 
0983   if (!cr)
0984     {
0985       if (ptunite)
0986     {
0987       ptc = (char *) Unite;
0988       ptu = ptunite;
0989 
0990       do
0991         {
0992           if (ptu->nom)
0993         {
0994           len = strlen (ptu->nom);
0995           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
0996           if (lut > len)
0997             memset (ptc + sizeof (char) * len, ' ', (lut - len));
0998         }
0999           ptc += sizeof (char) * lut;
1000         }
1001       while (ptu = ptu->ps_suivant);
1002       free (ptunite);
1003     }
1004       clean_dateheure (Date, ldt, Heure, lhr);
1005     }
1006   free (Entreesc);
1007   return (cr);
1008 
1009 }
1010 
1011 /*----------------------------------------------------------------------------
1012 
1013                         TSRSigX
1014 
1015   But : fonction demandant au serveur de lui renvoyer un signal lu entre
1016         2 valeurs de l'abscisse
1017 
1018   Arguments :
1019         NomDon    : nom de la donnee
1020         Entrees   : liste des entrees du traitement
1021         XI        : valeur initiale de l'abscisse
1022         XF        : valeur finale de l'abscisse
1023         NbMax     : nombre maximum de mesures souhaitees
1024         Extract   : type d'extraction souhaitee
1025 
1026         Unite     : liste des unites des mesures rendues
1027         NumVer    : numero de version du createur
1028         Certif    : tableau des certifications
1029         Date      : date d'execution du diagnostic ou du traitement
1030         Heure     : heure  d'execution du diagnostic ou du traitement
1031         NbMes     : nombre de valeurs rendues
1032         MaxReel   : nombre reel de valeurs
1033         X         : tableau des valeurs des abscisses
1034         Y         : tableau des valeurs des mesures
1035 
1036   Retour          : compte-rendu d'execution
1037 
1038 ------------------------------------------------------------------------------*/
1039 
1040 int
1041 tsrsigx_ (NomDon, Entrees, XI, XF, NbMax, Extract, Unite, NumVer, Certif,
1042       Date, Heure, NbMes, MaxReel, X, Y,
1043       lnd, lut, ldt, lhr)
1044 
1045      char *NomDon;
1046      Longint *Entrees;
1047      Double *XI;
1048      Double *XF;
1049      Longint *NbMax;
1050      Longint *Extract;
1051      char *Unite[];
1052      Longint *NumVer;
1053      Longint *Certif;
1054      char *Date;
1055      char *Heure;
1056      Longint *NbMes;
1057      Longint *MaxReel;
1058      char *X;
1059      char *Y;
1060      int lnd, lut, ldt, lhr;
1061 
1062 {
1063   struct S_Unite *ptunite;
1064   pS_Unite ptu;
1065   pS_Entree Entreesc;
1066   int cr = 0;
1067   int len;
1068   char *ptc, Ndt[TAILLE_NOM_DONNEE];
1069 
1070 /**   YB   YB   **/
1071 /**  if(*XI < 1.E-24) return(17);**/
1072 /**  if(*XF < 1.E-24) return(17);**/
1073 /**   YB   YB   **/
1074 
1075   if ((cr = check_dateheure (ldt, lhr)) < 0)
1076     return cr;
1077   cclean (NomDon, Ndt, lnd);
1078 
1079   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1080   Entreesc->union_var.lval = *Entrees;
1081   Entreesc->ps_suivant = NULL;
1082 
1083   cr = TSRSigX (Ndt, Entreesc, *XI, *XF, *NbMax, *Extract, &ptunite,
1084         NumVer, Certif, Date, Heure, NbMes, MaxReel, X, Y);
1085 
1086   if (!cr)
1087     {
1088       if (ptunite)
1089     {
1090       ptc = (char *) Unite;
1091       ptu = ptunite;
1092 
1093       do
1094         {
1095           if (ptu->nom)
1096         {
1097           len = strlen (ptu->nom);
1098           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
1099           if (lut > len)
1100             memset (ptc + sizeof (char) * len, ' ', (lut - len));
1101         }
1102           ptc += sizeof (char) * lut;
1103         }
1104       while (ptu = ptu->ps_suivant);
1105       free (ptunite);
1106     }
1107       clean_dateheure (Date, ldt, Heure, lhr);
1108     }
1109   free (Entreesc);
1110   return (cr);
1111 }
1112 
1113 /*----------------------------------------------------------------------------
1114 
1115                         TSXtrRg
1116 
1117   But : fonction demandant au serveur de lui renvoyer un signal d'un groupe lu
1118         entre 2 rangs
1119 
1120   Arguments :
1121         NomDon    : nom de la donnee
1122         Entrees   : liste des entrees du traitement
1123         Indices   : tableau contenant les indices du signal dans le groupe
1124         Rangs     : tableau contenant le rang initial et le rang final
1125         NbMax     : nombre maximum de mesures souhaitees
1126         Extract   : type d'extraction souhaitee
1127 
1128         Unite     : liste des unites des mesures rendues
1129         NumVer    : numero de version du createur
1130         Certif    : tableau des certifications
1131         Date      : date d'execution du diagnostic ou du traitement
1132         Heure     : heure  d'execution du diagnostic ou du traitement
1133         NbMes     : nombre de valeurs rendues
1134         MaxReel   : nombre reel de valeurs
1135         X         : tableau des valeurs des abscisses
1136         Y         : tableau des valeurs des mesures
1137         Coord     : tableau des valeurs des autres coordonnees
1138 
1139   Retour          : compte-rendu d'execution
1140 
1141 ------------------------------------------------------------------------------*/
1142 
1143 int
1144 tsxtrrg_ (NomDon, Entrees, Indices, Rangs, NbMax, Extract, Unite, NumVer,
1145       Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord,
1146       lnd, lut, ldt, lhr, lX, lY, lC)
1147 
1148      char *NomDon;
1149      Longint *Entrees;
1150      Longint *Indices;
1151      Longint *Rangs;
1152      Longint *NbMax;
1153      Longint *Extract;
1154      char *Unite[];
1155      Longint *NumVer;
1156      Longint *Certif;
1157      char *Date;
1158      char *Heure;
1159      Longint *NbMes;
1160      Longint *MaxReel;
1161      char *X;
1162      char *Y;
1163      char *Coord;
1164      int lnd, lut, ldt, lhr, lX, lY, lC;
1165 {
1166   struct S_Unite *ptunite;
1167   pS_Unite ptu;
1168   pS_Entree Entreesc;
1169   int cr = 0;
1170   int len;
1171   char *ptc, Ndt[TAILLE_NOM_DONNEE];
1172 
1173   if ((cr = check_dateheure (ldt, lhr)) < 0)
1174     return cr;
1175   cclean (NomDon, Ndt, lnd);
1176 
1177   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1178   Entreesc->union_var.lval = *Entrees;
1179   Entreesc->ps_suivant = NULL;
1180 
1181   cr = TSXtrRg (Ndt, Entreesc, Indices, Rangs, *NbMax, *Extract, &ptunite,
1182         NumVer, Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord);
1183 
1184   if (!cr)
1185     {
1186       if (ptunite)
1187     {
1188       ptc = (char *) Unite;
1189       ptu = ptunite;
1190 
1191       do
1192         {
1193           if (ptu->nom)
1194         {
1195           len = strlen (ptu->nom);
1196           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
1197           if (lut > len)
1198             memset (ptc + sizeof (char) * len, ' ', (lut - len));
1199         }
1200           ptc += sizeof (char) * lut;
1201         }
1202       while (ptu = ptu->ps_suivant);
1203       free (ptunite);
1204     }
1205       clean_dateheure (Date, ldt, Heure, lhr);
1206     }
1207   free (Entreesc);
1208   return (cr);
1209 }
1210 
1211 
1212 int
1213 tsxtrrgplusoc_ (NomDon, Entrees, Occ, Indices, Rangs, NbMax, Extract, Unite,
1214                 NumVer, Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord,
1215             lnd, lut, ldt, lhr, lX, lY, lC)
1216 
1217      char *NomDon;
1218      Longint *Entrees;
1219      Longint *Occ;
1220      Longint *Indices;
1221      Longint *Rangs;
1222      Longint *NbMax;
1223      Longint *Extract;
1224      char *Unite[];
1225      Longint *NumVer;
1226      Longint *Certif;
1227      char *Date;
1228      char *Heure;
1229      Longint *NbMes;
1230      Longint *MaxReel;
1231      char *X;
1232      char *Y;
1233      char *Coord;
1234      int lnd, lut, ldt, lhr, lX, lY, lC;
1235 {
1236   struct S_Unite *ptunite;
1237   pS_Unite ptu;
1238   pS_Entree Entreesc;
1239   int cr = 0;
1240   int len;
1241   char *ptc, Ndt[TAILLE_NOM_DONNEE];
1242 
1243   if ((cr = check_dateheure (ldt, lhr)) < 0)
1244     return cr;
1245   cclean (NomDon, Ndt, lnd);
1246 
1247   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1248   Entreesc->union_var.lval = *Entrees;
1249 
1250   if (*Occ > 0) {
1251     Entreesc->ps_suivant = (pS_Entree) malloc (sizeof (struct S_Entree));
1252     Entreesc->ps_suivant->union_var.lval = *Occ;
1253     Entreesc->ps_suivant->ps_suivant = NULL;
1254   }
1255   else
1256     Entreesc->ps_suivant = NULL;
1257 
1258   cr = TSXtrRg (Ndt, Entreesc, Indices, Rangs, *NbMax, *Extract, &ptunite,
1259         NumVer, Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord);
1260 
1261   if (!cr)
1262     {
1263       if (ptunite)
1264     {
1265       ptc = (char *) Unite;
1266       ptu = ptunite;
1267 
1268       do
1269         {
1270           if (ptu->nom)
1271         {
1272           len = strlen (ptu->nom);
1273           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
1274           if (lut > len)
1275             memset (ptc + sizeof (char) * len, ' ', (lut - len));
1276         }
1277           ptc += sizeof (char) * lut;
1278         }
1279       while (ptu = ptu->ps_suivant);
1280       free (ptunite);
1281     }
1282       clean_dateheure (Date, ldt, Heure, lhr);
1283     }
1284   free (Entreesc);
1285   return (cr);
1286 }
1287 
1288 /*----------------------------------------------------------------------------
1289 
1290                         TSXtrX
1291 
1292   But : fonction demandant au serveur de lui renvoyer un signal d'un groupe lu
1293         entre 2 valeurs de l'abscisse
1294 
1295   Arguments :
1296         NomDon    : nom de la donnee
1297         Entrees   : liste des entrees du traitement
1298         Indices   : tableau contenant les indices du signal dans le groupe
1299         XI        : valeur initiale de l'abscisse
1300         XF        : valeur finale de l'abscisse
1301         NbMax     : nombre maximum de mesures souhaitees
1302         Extract   : type d'extraction souhaitee
1303 
1304         Unite     : liste des unites des mesures rendues
1305         NumVer    : numero de version du createur
1306         Certif    : tableau des certifications
1307         Date      : date d'execution du diagnostic ou du traitement
1308         Heure     : heure  d'execution du diagnostic ou du traitement
1309         NbMes     : nombre de valeurs rendues
1310         MaxReel   : nombre reel de valeurs
1311         X         : tableau des valeurs des abscisses
1312         Y         : tableau des valeurs des mesures
1313         Coord     : tableau des valeurs des autres coordonnees
1314 
1315   Retour          : compte-rendu d'execution
1316 
1317 ------------------------------------------------------------------------------*/
1318 
1319 int
1320 tsxtrx_ (NomDon, Entrees, Indices, XI, XF, NbMax, Extract, Unite, NumVer,
1321      Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord,
1322      lnd, lut, ldt, lhr, lX, lY, lC)
1323 
1324      char *NomDon;
1325      Longint *Entrees;
1326      Longint *Indices;
1327      Double *XI;
1328      Double *XF;
1329      Longint *NbMax;
1330      Longint *Extract;
1331      char *Unite[];
1332      Longint *NumVer;
1333      Longint *Certif;
1334      char *Date;
1335      char *Heure;
1336      Longint *NbMes;
1337      Longint *MaxReel;
1338      char *X;
1339      char *Y;
1340      char *Coord;
1341      int lnd, lut, ldt, lhr, lX, lY, lC;
1342 
1343 {
1344   struct S_Unite *ptunite;
1345   pS_Unite ptu;
1346   pS_Entree Entreesc;
1347   int cr = 0;
1348   int len;
1349   char *ptc, Ndt[TAILLE_NOM_DONNEE];
1350 /**   YB   YB   **/
1351 /**   if(*XI < 1.E-24) return(17); **/
1352 /**   if(*XF < 1.E-24) return(17); **/
1353 /**   YB   YB   **/
1354 
1355   if ((cr = check_dateheure (ldt, lhr)) < 0)
1356     return cr;
1357   cclean (NomDon, Ndt, lnd);
1358 
1359   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1360   Entreesc->union_var.lval = *Entrees;
1361   Entreesc->ps_suivant = NULL;
1362 
1363   cr = TSXtrX (Ndt, Entreesc, Indices, *XI, *XF, *NbMax, *Extract,
1364     &ptunite, NumVer, Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord);
1365 
1366   if (!cr)
1367     {
1368       if (ptunite)
1369     {
1370       ptc = (char *) Unite;
1371       ptu = ptunite;
1372 
1373       do
1374         {
1375           if (ptu->nom)
1376         {
1377           len = strlen (ptu->nom);
1378           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
1379           if (lut > len)
1380             memset (ptc + sizeof (char) * len, ' ', (lut - len));
1381         }
1382           ptc += sizeof (char) * lut;
1383         }
1384       while (ptu = ptu->ps_suivant);
1385       free (ptunite);
1386     }
1387       clean_dateheure (Date, ldt, Heure, lhr);
1388     }
1389   free (Entreesc);
1390   return (cr);
1391 }
1392 
1393 /*----------------------------------------------------------------------------
1394 
1395                         TSGrpRg
1396 
1397   But : fonction demandant au serveur de lui renvoyer un groupe de signaux lu
1398         entre 2 rangs donnes
1399 
1400   Arguments :
1401         NomDon    : nom de la donnee
1402         Entrees   : liste des entrees du traitement
1403         Rangs     : tableau contenant le rang initial et le rang final
1404         NbMax     : nombre maximum de mesures souhaitees
1405         Extract   : type d'extraction souhaitee
1406 
1407         Unite     : liste des unites des mesures rendues
1408         NumVer    : numero de version du createur
1409         Certif    : tableau des certifications
1410         Date      : date d'execution du diagnostic ou du traitement
1411         Heure     : heure  d'execution du diagnostic ou du traitement
1412         NbMes     : nombre de valeurs rendues
1413         MaxReel   : nombre reel de valeurs
1414         X         : tableau des valeurs des abscisses
1415         Y         : tableau des valeurs des mesures
1416         Coord     : tableau des valeurs des autres coordonnees
1417 
1418   Retour          : compte-rendu d'execution
1419 
1420 ------------------------------------------------------------------------------*/
1421 
1422 int
1423 tsgrprg_ (NomDon, Entrees, Rangs, NbMax, Extract, Unite, NumVer, Certif,
1424       Date, Heure, NbMes, MaxReel,  X, Y, Coord,
1425       lnd, lut, ldt, lhr, lX, lY, lC)
1426 
1427      char *NomDon;
1428      Longint *Entrees;
1429      Longint *Rangs;
1430      Longint *NbMax;
1431      Longint *Extract;
1432      char *Unite[];
1433      Longint *NumVer;
1434      Longint *Certif;
1435      char *Date;
1436      char *Heure;
1437      Longint *NbMes;
1438      Longint *MaxReel;
1439      char *X;
1440      char *Y;
1441      char *Coord;
1442      int lnd, lut, ldt, lhr, lX, lY, lC;
1443 
1444 {
1445   struct S_Unite *ptunite;
1446   pS_Unite ptu;
1447   pS_Entree Entreesc;
1448   int cr = 0;
1449   int len;
1450   char *ptc, Ndt[TAILLE_NOM_DONNEE];
1451 
1452   if ((cr = check_dateheure (ldt, lhr)) < 0)
1453     return cr;
1454   cclean (NomDon, Ndt, lnd);
1455 
1456   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1457   Entreesc->union_var.lval = *Entrees;
1458   Entreesc->ps_suivant = NULL;
1459 
1460   cr = TSGrpRg (Ndt, Entreesc, Rangs, *NbMax, *Extract, &ptunite, NumVer,
1461         Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord);
1462 
1463   if (!cr)
1464     {
1465       if (ptunite)
1466     {
1467       ptc = (char *) Unite;
1468       ptu = ptunite;
1469 
1470       do
1471         {
1472           if (ptu->nom)
1473         {
1474           len = strlen (ptu->nom);
1475           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
1476           if (lut > len)
1477             memset (ptc + sizeof (char) * len, ' ', (lut - len));
1478         }
1479           ptc += sizeof (char) * lut;
1480         }
1481       while (ptu = ptu->ps_suivant);
1482       free (ptunite);
1483     }
1484       clean_dateheure (Date, ldt, Heure, lhr);
1485     }
1486   free (Entreesc);
1487   return (cr);
1488 }
1489 
1490 /*----------------------------------------------------------------------------
1491 
1492                         TSGrpX
1493 
1494   But : fonction demandant au serveur de lui renvoyer un groupe de signaux lu
1495         entre 2 valeurs de l'abscisse
1496 
1497   Arguments :
1498         NomDon    : nom de la donnee
1499         Entrees   : liste des entrees du traitement
1500         XI        : valeur initiale de l'abscisse
1501         XF        : valeur finale de l'abscisse
1502         NbMax     : nombre maximum de mesures souhaitees
1503         Extract   : type d'extraction souhaitee
1504 
1505         Unite     : liste des unites des mesures rendues
1506         NumVer    : numero de version du createur
1507         Certif    : tableau des certifications
1508         Date      : date d'execution du diagnostic ou du traitement
1509         Heure     : heure  d'execution du diagnostic ou du traitement
1510         NbMes     : nombre de valeurs rendues
1511         MaxReel   : nombre reel de valeurs
1512         X         : tableau des valeurs des abscisses
1513         Y         : tableau des valeurs des mesures
1514         Coord     : tableau des valeurs des autres coordonnees
1515 
1516   Retour          : compte-rendu d'execution
1517 
1518 ------------------------------------------------------------------------------*/
1519 
1520 int
1521 tsgrpx_ (NomDon, Entrees, XI, XF, NbMax, Extract, Unite, NumVer, Certif,
1522      Date, Heure, NbMes, MaxReel, X, Y, Coord,
1523      lnd, lut, ldt, lhr, lX, lY, lC)
1524 
1525      char *NomDon;
1526      Longint *Entrees;
1527      Double *XI;
1528      Double *XF;
1529      Longint *NbMax;
1530      Longint *Extract;
1531      char *Unite[];
1532      Longint *NumVer;
1533      Longint *Certif;
1534      char *Date;
1535      char *Heure;
1536      Longint *NbMes;
1537      Longint *MaxReel;
1538      char *X;
1539      char *Y;
1540      char *Coord;
1541      int lnd, lut, ldt, lhr, lX, lY, lC;
1542 
1543 {
1544   struct S_Unite *ptunite;
1545   pS_Unite ptu;
1546   pS_Entree Entreesc;
1547   int cr = 0;
1548   int len;
1549   char *ptc, Ndt[TAILLE_NOM_DONNEE];
1550 
1551 /**   YB   YB   **/
1552 /**  if(*XI < 1.E-24) return(17);**/
1553 /**  if(*XF < 1.E-24) return(17);**/
1554 /**   YB   YB   **/
1555   if ((cr = check_dateheure (ldt, lhr)) < 0)
1556     return cr;
1557   cclean (NomDon, Ndt, lnd);
1558 
1559   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1560   Entreesc->union_var.lval = *Entrees;
1561   Entreesc->ps_suivant = NULL;
1562 
1563   cr = TSGrpX (Ndt, Entreesc, *XI, *XF, *NbMax, *Extract, &ptunite, NumVer,
1564            Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord);
1565 
1566   if (!cr)
1567     {
1568       if (ptunite)
1569     {
1570       ptc = (char *) Unite;
1571       ptu = ptunite;
1572 
1573       do
1574         {
1575           if (ptu->nom)
1576         {
1577           len = strlen (ptu->nom);
1578           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
1579           if (lut > len)
1580             memset (ptc + sizeof (char) * len, ' ', (lut - len));
1581         }
1582           ptc += sizeof (char) * lut;
1583         }
1584       while (ptu = ptu->ps_suivant);
1585       free (ptunite);
1586     }
1587       clean_dateheure (Date, ldt, Heure, lhr);
1588     }
1589   free (Entreesc);
1590   return (cr);
1591 }
1592 
1593 /*----------------------------------------------------------------------------
1594                                 TSLDiag
1595   But :
1596 
1597   Arguments :
1598 
1599   Retour          : compte-rendu d'execution
1600 
1601 ------------------------------------------------------------------------------*/
1602 
1603 int
1604 tsldiag_ (NumChoc, NbDiag, Listed, ld)
1605 
1606      Longint *NumChoc, *NbDiag;
1607      char *Listed[];
1608      int ld;
1609 {
1610   Longint cr = 0;
1611   int len, i;
1612   char *ptc;
1613 
1614   char *ldiag[50];
1615 
1616   cr = TSLDiag (*NumChoc, NbDiag, ldiag);
1617 
1618   if (cr == 0)
1619     {
1620       ptc = (char *) Listed;
1621       for (i = 0; i < *NbDiag; i++)
1622     {
1623       len = strlen (ldiag[i]);
1624 
1625       memcpy (ptc, ldiag[i], ((ld >= len) ? len : ld));
1626       if (ld > len)
1627         memset (ptc + sizeof (char) * len, ' ', (ld - len));
1628       ptc += sizeof (char) * ld;
1629     }
1630 
1631     }
1632   return ((int) cr);
1633 }
1634 
1635 /*----------------------------------------------------------------------------
1636                                 TSLTrait
1637   But :
1638 
1639   Arguments :
1640 
1641   Retour          : compte-rendu d'execution
1642 
1643 ------------------------------------------------------------------------------*/
1644 
1645 int
1646 tsltrait_ (NbTrait, Listet, ld)
1647 
1648      Longint *NbTrait;
1649      char *Listet[];
1650      int ld;
1651 {
1652   Longint cr = 0;
1653   int len, i;
1654   char *ptc;
1655 
1656   char *ltrait[50];
1657 
1658   cr = TSLTrait (NbTrait, ltrait);
1659 
1660   if (cr == 0)
1661     {
1662       ptc = (char *) Listet;
1663       for (i = 0; i < *NbTrait; i++)
1664     {
1665       len = strlen (ltrait[i]);
1666 
1667       memcpy (ptc, ltrait[i], ((ld >= len) ? len : ld));
1668       if (ld > len)
1669         memset (ptc + sizeof (char) * len, ' ', (ld - len));
1670       ptc += sizeof (char) * ld;
1671     }
1672 
1673     }
1674   return ((int) cr);
1675 }
1676 
1677 /*----------------------------------------------------------------------------
1678                                 TSLSig
1679 
1680   But :
1681 
1682   Arguments :
1683 
1684   Retour          : compte-rendu d'execution
1685 
1686 ------------------------------------------------------------------------------*/
1687 
1688 int
1689 tslsig_ (NumChoc, diag_name, NbSig, ListeS, ld, ls)
1690 
1691      Longint *NumChoc, *NbSig;
1692      char *diag_name, *ListeS[];
1693      int ld, ls;
1694 {
1695   Longint cr = 0;
1696   int len, i;
1697 
1698   char *lsig[95], *ptc;
1699   char Ndt[PREPASIZE + 1];
1700 
1701   cclean (diag_name, Ndt, ld);
1702 
1703   cr = TSLSig (*NumChoc, Ndt, NbSig, lsig);
1704   if (cr == 0)
1705     {
1706       ptc = (char *) ListeS;
1707       for (i = 0; i < *NbSig; i++)
1708     {
1709       len = strlen (lsig[i]);
1710       memcpy (ptc, lsig[i], ((ld >= len) ? len : ls));
1711       if (ls > len)
1712         memset (ptc + sizeof (char) * len, ' ', (ls - len));
1713       ptc += sizeof (char) * ls;
1714     }
1715     }
1716   return ((int) cr);
1717 }
1718 
1719 
1720 /*----------------------------------------------------------------------------
1721                                 TSRqparm
1722 
1723   But :
1724 
1725   Arguments :
1726 
1727   Retour          : compte-rendu d'execution
1728 
1729 ------------------------------------------------------------------------------*/
1730 
1731 int
1732 tsrqparm_ (NumChoc, diag, obj, param, nval, buff, nrep, ld, lo, lp, lb)
1733 
1734      Longint *NumChoc;
1735      char *diag, *obj, *param, *buff;
1736      int *nval, *nrep, ld, lo, lp, lb;
1737 {
1738   Longint cr = 0, fpar;
1739   int offset = 0;
1740   int len, i = 0;
1741   char Ndiag[PREPASIZE + 1], Nobj[PREPASIZE + 1], Nparam[PREPASIZE + 1];
1742 
1743   cclean (diag, Ndiag, ld);
1744   cclean (obj, Nobj, lo);
1745   cclean (param, Nparam, lp);
1746 
1747   strcpy(buff,"a");
1748   cr = TSRqParm (*NumChoc, Ndiag, Nobj, Nparam, *nval, buff, nrep, &fpar);
1749 
1750   return ((int) cr);
1751 }
1752 
1753 
1754 /*----------------------------------------------------------------------------
1755                                 TSRqdecl
1756 ------------------------------------------------------------------------------*/
1757 
1758 int
1759 tsrqdecl_ (NumChoc, decl, occur, date, ld)
1760 
1761      Longint *NumChoc;
1762      char *decl;
1763      int *occur, ld;
1764      float *date;
1765 {
1766   Longint cr = 0;
1767   int offset = 0;
1768   int len, i = 0;
1769   char Ndt[PREPASIZE + 1];
1770 
1771   cclean (decl, Ndt, ld);
1772 
1773   cr = TSRqdecl (*NumChoc, Ndt, *occur, date);
1774 
1775   return ((int) cr);
1776 }
1777 
1778 /*----------------------------------------------------------------------------
1779                                 TSGetinfo
1780 ------------------------------------------------------------------------------*/
1781 
1782 int
1783 tsgetinfo_ (NumChoc)
1784 
1785      int *NumChoc;
1786 {
1787   Longint cr = 0;
1788 
1789   cr = TSGetinfo (NumChoc);
1790 
1791   return ((int) cr);
1792 }
1793 /*----------------------------------------------------------------------------
1794                                 TSTData
1795 ------------------------------------------------------------------------------*/
1796 
1797 int
1798 tstdata_ (NumChoc, ndiag, t_choc, t_param,ld )
1799      Longint *NumChoc;
1800      char * ndiag;
1801      Longint *t_choc, *t_param;
1802      int ld;
1803 
1804 {
1805   Longint cr = 0;
1806 
1807   cr = TSTData (*NumChoc,ndiag, t_choc, t_param);
1808 
1809   return ((int)cr);
1810 }
1811 /*----------------------------------------------------------------------------
1812                                 TSLgDiag
1813 ------------------------------------------------------------------------------*/
1814 
1815 int
1816 tslgdiag_ (NumChoc, nomdiag, nbmes, ld )
1817 Longint *NumChoc, *nbmes;
1818 char *nomdiag;
1819 int ld;
1820 {
1821   Longint cr = 0;
1822   char Ndt[PREPASIZE + 1];
1823 
1824   cclean (nomdiag, Ndt, ld);
1825 
1826   cr = TSLgDiag (*NumChoc, Ndt, nbmes);
1827 
1828   return ((int) cr);
1829 }
1830 /*********** JS - 05.2005 - 
1831     ajout des 2 fcts tsinitocctrait_ ettsupdateocctrait_  ************/
1832 /*----------------------------------------------------------------------------
1833 
1834                         TSInitOccTrait
1835 
1836 But :     fonction envoyant au serveur les param�res ��rire 
1837     dans la base de donn�s au d�ut de l'��ution du traitement
1838 Arguments :
1839     NomTrait  : nom du traitement
1840     Numchoc   : numero du choc
1841     Occur      : numero de l'occurrence
1842     lt        : longueur du nom du traitement
1843 Retour : compte-rendu d'execution
1844 
1845 ------------------------------------------------------------------------------*/
1846 int 
1847 tsinitocctrait_  (NomTrait, Numchoc, Occur, lt)
1848 
1849      char *NomTrait;
1850      Longint *Numchoc, *Occur;
1851      int lt;
1852 {
1853   pS_Entree Entreesc;
1854   int cr = 0;
1855   char Ndt[TAILLE_NOM_TRAITEMENT];
1856   
1857   cclean (NomTrait, Ndt, lt);
1858   
1859   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1860   Entreesc->union_var.lval = *Numchoc;
1861   if (*Occur != 0) {
1862     Entreesc->ps_suivant = (pS_Entree) malloc (sizeof (struct S_Entree));
1863     Entreesc->ps_suivant->union_var.lval = *Occur;
1864     Entreesc->ps_suivant->ps_suivant = NULL;
1865   } else {
1866     Entreesc->ps_suivant = NULL;
1867   }
1868   
1869   cr= TSInitOccTrait (Ndt, Entreesc);
1870   free(Entreesc);
1871   return (cr);
1872 }
1873 
1874 /*----------------------------------------------------------------------------
1875 
1876                         TSUpdateOccTrait
1877 
1878 But :     fonction envoyant au serveur les param�res �rire 
1879     dans la base de donn�s a la fin de l'��ution du traitement
1880 Arguments :
1881     NomTrait  : nom du traitement
1882     ENumchoc   : numero du choc
1883     Occur      : numero de l'occurrence
1884     Status    : status de l'execution du traitement
1885     Dureems   : duree de l'execution du traitement en millisecondes
1886 Retour : compte-rendu d'execution
1887 
1888 ------------------------------------------------------------------------------*/
1889 int 
1890 tsupdateocctrait_  (NomTrait, Numchoc, Occur, Status, Dureems, lt)
1891      char *NomTrait;
1892      Longint *Numchoc, *Occur, *Status, *Dureems;
1893      int lt;
1894 {
1895   pS_Entree Entreesc;
1896   int cr = 0;
1897   char Ndt[TAILLE_NOM_TRAITEMENT];
1898   
1899   cclean (NomTrait, Ndt, lt);
1900   
1901   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1902   Entreesc->union_var.lval = *Numchoc;
1903   if (*Occur != 0) {
1904     Entreesc->ps_suivant = (pS_Entree) malloc (sizeof (struct S_Entree));
1905     Entreesc->ps_suivant->union_var.lval = *Occur;
1906     Entreesc->ps_suivant->ps_suivant = NULL;
1907   } else {
1908     Entreesc->ps_suivant = NULL;
1909   }
1910   
1911   cr= TSUpdateOccTrait (Ndt, Entreesc, *Status, *Dureems);
1912   free(Entreesc);
1913   return (cr);
1914 }
1915 
1916 /*---------------------------
1917   ---------------------------*/
1918 int
1919 cclean (chOld, chNew, Len)
1920 
1921      char *chOld, *chNew;
1922      Longint Len;
1923 {
1924   int i = 0;
1925   char *pts, *ptd;
1926 
1927   pts = chOld;
1928   ptd = chNew;
1929   while ((*pts != ' ') && (i < Len))
1930     {
1931       *ptd++ = *pts++;
1932       i++;
1933     }
1934   *ptd = '\0';
1935   return (0);
1936 }
1937 
1938 /****
1939  ****/
1940 int
1941 check_dateheure (ldate, lheure)
1942      int ldate, lheure;
1943 {
1944   if ((ldate < LDATE) || (lheure < LHEURE))
1945     return (-10);
1946 
1947   return (0);
1948 }
1949 
1950 /****
1951  ****/
1952 int
1953 clean_dateheure (date, ldate, heure, lheure)
1954      char *date, *heure;
1955      int ldate, lheure;
1956 {
1957   int i;
1958   for (i = LDATE; i < ldate; i++)
1959     date[i] = ' ';
1960   for (i = LHEURE; i < lheure; i++)
1961     heure[i] = ' ';
1962   return (0);
1963 }