Description of tslib

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 = 'f';
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 int
0935 tsrsigrgplusoc_ (NomDon, Entrees, Occ, Rangs, NbMax, Extract, Unite, NumVer,
0936                  Certif, Date, Heure, NbMes, MaxReel, X, Y, lnd, lut, ldt, lhr)
0937 
0938      char *NomDon;
0939      Longint *Entrees;
0940      Longint *Occ;
0941      Longint *Rangs;
0942      Longint *NbMax;
0943      Longint *Extract;
0944      char *Unite[];
0945      Longint *NumVer;
0946      Longint *Certif;
0947      char *Date;
0948      char *Heure;
0949      Longint *NbMes;
0950      Longint *MaxReel;
0951      char *X;
0952      char *Y;
0953      int lnd, lut, ldt, lhr;
0954 
0955 {
0956   struct S_Unite *ptunite;
0957   pS_Unite ptu;
0958   pS_Entree Entreesc;
0959   int cr = 0;
0960   int len;
0961   char *ptc, Ndt[TAILLE_NOM_DONNEE];
0962 
0963   if ((cr = check_dateheure (ldt, lhr)) < 0)
0964     return cr;
0965   cclean (NomDon, Ndt, lnd);
0966 
0967   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
0968   Entreesc->union_var.lval = *Entrees;
0969   /*Entreesc->ps_suivant = NULL; */
0970 
0971   if (*Occ > 0) {
0972     Entreesc->ps_suivant = (pS_Entree) malloc (sizeof (struct S_Entree));
0973     Entreesc->ps_suivant->union_var.lval = *Occ;
0974     Entreesc->ps_suivant->ps_suivant = NULL;
0975   }
0976   else
0977     Entreesc->ps_suivant = NULL;
0978 
0979   cr = TSRSigRg (Ndt, Entreesc, Rangs, *NbMax, *Extract, &ptunite, NumVer,
0980                  Certif, Date, Heure, NbMes, MaxReel, X, Y);
0981 
0982   if (!cr)
0983     {
0984       if (ptunite)
0985         {
0986           ptc = (char *) Unite;
0987           ptu = ptunite;
0988 
0989           do
0990             {
0991               if (ptu->nom)
0992                 {
0993                   len = strlen (ptu->nom);
0994                   memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
0995                   if (lut > len)
0996                     memset (ptc + sizeof (char) * len, ' ', (lut - len));
0997                 }
0998               ptc += sizeof (char) * lut;
0999             }
1000           while (ptu = ptu->ps_suivant);
1001           free (ptunite);
1002         }
1003       clean_dateheure (Date, ldt, Heure, lhr);
1004     }
1005   free (Entreesc);
1006   return (cr);
1007 
1008 }
1009 /*----------------------------------------------------------------------------
1010 
1011                         TSRSigX
1012 
1013   But : fonction demandant au serveur de lui renvoyer un signal lu entre
1014         2 valeurs de l'abscisse
1015 
1016   Arguments :
1017         NomDon    : nom de la donnee
1018         Entrees   : liste des entrees du traitement
1019         XI        : valeur initiale de l'abscisse
1020         XF        : valeur finale de l'abscisse
1021         NbMax     : nombre maximum de mesures souhaitees
1022         Extract   : type d'extraction souhaitee
1023 
1024         Unite     : liste des unites des mesures rendues
1025         NumVer    : numero de version du createur
1026         Certif    : tableau des certifications
1027         Date      : date d'execution du diagnostic ou du traitement
1028         Heure     : heure  d'execution du diagnostic ou du traitement
1029         NbMes     : nombre de valeurs rendues
1030         MaxReel   : nombre reel de valeurs
1031         X         : tableau des valeurs des abscisses
1032         Y         : tableau des valeurs des mesures
1033 
1034   Retour          : compte-rendu d'execution
1035 
1036 ------------------------------------------------------------------------------*/
1037 
1038 int
1039 tsrsigx_ (NomDon, Entrees, XI, XF, NbMax, Extract, Unite, NumVer, Certif,
1040       Date, Heure, NbMes, MaxReel, X, Y,
1041       lnd, lut, ldt, lhr)
1042 
1043      char *NomDon;
1044      Longint *Entrees;
1045      Double *XI;
1046      Double *XF;
1047      Longint *NbMax;
1048      Longint *Extract;
1049      char *Unite[];
1050      Longint *NumVer;
1051      Longint *Certif;
1052      char *Date;
1053      char *Heure;
1054      Longint *NbMes;
1055      Longint *MaxReel;
1056      char *X;
1057      char *Y;
1058      int lnd, lut, ldt, lhr;
1059 
1060 {
1061   struct S_Unite *ptunite;
1062   pS_Unite ptu;
1063   pS_Entree Entreesc;
1064   int cr = 0;
1065   int len;
1066   char *ptc, Ndt[TAILLE_NOM_DONNEE];
1067 
1068 /**   YB   YB   **
1069   if(*XI < 1.E-24) return(17);
1070   if(*XF < 1.E-24) return(17);
1071 **   YB   YB   **/
1072 
1073   if ((cr = check_dateheure (ldt, lhr)) < 0)
1074     return cr;
1075   cclean (NomDon, Ndt, lnd);
1076 
1077   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1078   Entreesc->union_var.lval = *Entrees;
1079   Entreesc->ps_suivant = NULL;
1080 
1081   cr = TSRSigX (Ndt, Entreesc, *XI, *XF, *NbMax, *Extract, &ptunite,
1082         NumVer, Certif, Date, Heure, NbMes, MaxReel, X, Y);
1083 
1084   if (!cr)
1085     {
1086       if (ptunite)
1087     {
1088       ptc = (char *) Unite;
1089       ptu = ptunite;
1090 
1091       do
1092         {
1093           if (ptu->nom)
1094         {
1095           len = strlen (ptu->nom);
1096           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
1097           if (lut > len)
1098             memset (ptc + sizeof (char) * len, ' ', (lut - len));
1099         }
1100           ptc += sizeof (char) * lut;
1101         }
1102       while (ptu = ptu->ps_suivant);
1103       free (ptunite);
1104     }
1105       clean_dateheure (Date, ldt, Heure, lhr);
1106     }
1107   free (Entreesc);
1108   return (cr);
1109 }
1110 
1111 /*----------------------------------------------------------------------------
1112 
1113                         TSXtrRg
1114 
1115   But : fonction demandant au serveur de lui renvoyer un signal d'un groupe lu
1116         entre 2 rangs
1117 
1118   Arguments :
1119         NomDon    : nom de la donnee
1120         Entrees   : liste des entrees du traitement
1121         Indices   : tableau contenant les indices du signal dans le groupe
1122         Rangs     : tableau contenant le rang initial et le rang final
1123         NbMax     : nombre maximum de mesures souhaitees
1124         Extract   : type d'extraction souhaitee
1125 
1126         Unite     : liste des unites des mesures rendues
1127         NumVer    : numero de version du createur
1128         Certif    : tableau des certifications
1129         Date      : date d'execution du diagnostic ou du traitement
1130         Heure     : heure  d'execution du diagnostic ou du traitement
1131         NbMes     : nombre de valeurs rendues
1132         MaxReel   : nombre reel de valeurs
1133         X         : tableau des valeurs des abscisses
1134         Y         : tableau des valeurs des mesures
1135         Coord     : tableau des valeurs des autres coordonnees
1136 
1137   Retour          : compte-rendu d'execution
1138 
1139 ------------------------------------------------------------------------------*/
1140 
1141 int
1142 tsxtrrg_ (NomDon, Entrees, Indices, Rangs, NbMax, Extract, Unite, NumVer,
1143       Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord,
1144       lnd, lut, ldt, lhr, lX, lY, lC)
1145 
1146      char *NomDon;
1147      Longint *Entrees;
1148      Longint *Indices;
1149      Longint *Rangs;
1150      Longint *NbMax;
1151      Longint *Extract;
1152      char *Unite[];
1153      Longint *NumVer;
1154      Longint *Certif;
1155      char *Date;
1156      char *Heure;
1157      Longint *NbMes;
1158      Longint *MaxReel;
1159      char *X;
1160      char *Y;
1161      char *Coord;
1162      int lnd, lut, ldt, lhr, lX, lY, lC;
1163 {
1164   struct S_Unite *ptunite;
1165   pS_Unite ptu;
1166   pS_Entree Entreesc;
1167   int cr = 0;
1168   int len;
1169   char *ptc, Ndt[TAILLE_NOM_DONNEE];
1170 
1171   if ((cr = check_dateheure (ldt, lhr)) < 0)
1172     return cr;
1173   cclean (NomDon, Ndt, lnd);
1174 
1175   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1176   Entreesc->union_var.lval = *Entrees;
1177   Entreesc->ps_suivant = NULL;
1178 
1179   cr = TSXtrRg (Ndt, Entreesc, Indices, Rangs, *NbMax, *Extract, &ptunite,
1180         NumVer, Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord);
1181 
1182   if (!cr)
1183     {
1184       if (ptunite)
1185     {
1186       ptc = (char *) Unite;
1187       ptu = ptunite;
1188 
1189       do
1190         {
1191           if (ptu->nom)
1192         {
1193           len = strlen (ptu->nom);
1194           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
1195           if (lut > len)
1196             memset (ptc + sizeof (char) * len, ' ', (lut - len));
1197         }
1198           ptc += sizeof (char) * lut;
1199         }
1200       while (ptu = ptu->ps_suivant);
1201       free (ptunite);
1202     }
1203       clean_dateheure (Date, ldt, Heure, lhr);
1204     }
1205   free (Entreesc);
1206   return (cr);
1207 }
1208 
1209 int
1210 tsxtrrgplusoc_ (NomDon, Entrees, Occ, Indices, Rangs, NbMax, Extract, Unite,
1211                 NumVer, Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord,
1212                 lnd, lut, ldt, lhr, lX, lY, lC)
1213 
1214      char *NomDon;
1215      Longint *Entrees;
1216      Longint *Occ;
1217      Longint *Indices;
1218      Longint *Rangs;
1219      Longint *NbMax;
1220      Longint *Extract;
1221      char *Unite[];
1222      Longint *NumVer;
1223      Longint *Certif;
1224      char *Date;
1225      char *Heure;
1226      Longint *NbMes;
1227      Longint *MaxReel;
1228      char *X;
1229      char *Y;
1230      char *Coord;
1231      int lnd, lut, ldt, lhr, lX, lY, lC;
1232 {
1233   struct S_Unite *ptunite;
1234   pS_Unite ptu;
1235   pS_Entree Entreesc;
1236   int cr = 0;
1237   int len;
1238   char *ptc, Ndt[TAILLE_NOM_DONNEE];
1239 
1240   if ((cr = check_dateheure (ldt, lhr)) < 0)
1241     return cr;
1242   cclean (NomDon, Ndt, lnd);
1243 
1244   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1245   Entreesc->union_var.lval = *Entrees;
1246 
1247   if (*Occ > 0) {
1248     Entreesc->ps_suivant = (pS_Entree) malloc (sizeof (struct S_Entree));
1249     Entreesc->ps_suivant->union_var.lval = *Occ;
1250     Entreesc->ps_suivant->ps_suivant = NULL;
1251   }
1252   else
1253     Entreesc->ps_suivant = NULL;
1254 
1255   cr = TSXtrRg (Ndt, Entreesc, Indices, Rangs, *NbMax, *Extract, &ptunite,
1256                 NumVer, Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord);
1257 
1258   if (!cr)
1259     {
1260       if (ptunite)
1261         {
1262           ptc = (char *) Unite;
1263           ptu = ptunite;
1264 
1265           do
1266             {
1267               if (ptu->nom)
1268                 {
1269                   len = strlen (ptu->nom);
1270                   memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
1271                   if (lut > len)
1272                     memset (ptc + sizeof (char) * len, ' ', (lut - len));
1273                 }
1274               ptc += sizeof (char) * lut;
1275             }
1276           while (ptu = ptu->ps_suivant);
1277           free (ptunite);
1278         }
1279       clean_dateheure (Date, ldt, Heure, lhr);
1280     }
1281   free (Entreesc);
1282   return (cr);
1283 }
1284 
1285 /*----------------------------------------------------------------------------
1286 
1287                         TSXtrX
1288 
1289   But : fonction demandant au serveur de lui renvoyer un signal d'un groupe lu
1290         entre 2 valeurs de l'abscisse
1291 
1292   Arguments :
1293         NomDon    : nom de la donnee
1294         Entrees   : liste des entrees du traitement
1295         Indices   : tableau contenant les indices du signal dans le groupe
1296         XI        : valeur initiale de l'abscisse
1297         XF        : valeur finale de l'abscisse
1298         NbMax     : nombre maximum de mesures souhaitees
1299         Extract   : type d'extraction souhaitee
1300 
1301         Unite     : liste des unites des mesures rendues
1302         NumVer    : numero de version du createur
1303         Certif    : tableau des certifications
1304         Date      : date d'execution du diagnostic ou du traitement
1305         Heure     : heure  d'execution du diagnostic ou du traitement
1306         NbMes     : nombre de valeurs rendues
1307         MaxReel   : nombre reel de valeurs
1308         X         : tableau des valeurs des abscisses
1309         Y         : tableau des valeurs des mesures
1310         Coord     : tableau des valeurs des autres coordonnees
1311 
1312   Retour          : compte-rendu d'execution
1313 
1314 ------------------------------------------------------------------------------*/
1315 
1316 int
1317 tsxtrx_ (NomDon, Entrees, Indices, XI, XF, NbMax, Extract, Unite, NumVer,
1318      Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord,
1319      lnd, lut, ldt, lhr, lX, lY, lC)
1320 
1321      char *NomDon;
1322      Longint *Entrees;
1323      Longint *Indices;
1324      Double *XI;
1325      Double *XF;
1326      Longint *NbMax;
1327      Longint *Extract;
1328      char *Unite[];
1329      Longint *NumVer;
1330      Longint *Certif;
1331      char *Date;
1332      char *Heure;
1333      Longint *NbMes;
1334      Longint *MaxReel;
1335      char *X;
1336      char *Y;
1337      char *Coord;
1338      int lnd, lut, ldt, lhr, lX, lY, lC;
1339 
1340 {
1341   struct S_Unite *ptunite;
1342   pS_Unite ptu;
1343   pS_Entree Entreesc;
1344   int cr = 0;
1345   int len;
1346   char *ptc, Ndt[TAILLE_NOM_DONNEE];
1347 /**   YB   YB   **
1348   if(*XI < 1.E-24) return(17);
1349   if(*XF < 1.E-24) return(17);
1350 **   YB   YB   **/
1351 
1352   if ((cr = check_dateheure (ldt, lhr)) < 0)
1353     return cr;
1354   cclean (NomDon, Ndt, lnd);
1355 
1356   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1357   Entreesc->union_var.lval = *Entrees;
1358   Entreesc->ps_suivant = NULL;
1359 
1360   cr = TSXtrX (Ndt, Entreesc, Indices, *XI, *XF, *NbMax, *Extract,
1361     &ptunite, NumVer, Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord);
1362 
1363   if (!cr)
1364     {
1365       if (ptunite)
1366     {
1367       ptc = (char *) Unite;
1368       ptu = ptunite;
1369 
1370       do
1371         {
1372           if (ptu->nom)
1373         {
1374           len = strlen (ptu->nom);
1375           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
1376           if (lut > len)
1377             memset (ptc + sizeof (char) * len, ' ', (lut - len));
1378         }
1379           ptc += sizeof (char) * lut;
1380         }
1381       while (ptu = ptu->ps_suivant);
1382       free (ptunite);
1383     }
1384       clean_dateheure (Date, ldt, Heure, lhr);
1385     }
1386   free (Entreesc);
1387   return (cr);
1388 }
1389 
1390 /*----------------------------------------------------------------------------
1391 
1392                         TSGrpRg
1393 
1394   But : fonction demandant au serveur de lui renvoyer un groupe de signaux lu
1395         entre 2 rangs donnes
1396 
1397   Arguments :
1398         NomDon    : nom de la donnee
1399         Entrees   : liste des entrees du traitement
1400         Rangs     : tableau contenant le rang initial et le rang final
1401         NbMax     : nombre maximum de mesures souhaitees
1402         Extract   : type d'extraction souhaitee
1403 
1404         Unite     : liste des unites des mesures rendues
1405         NumVer    : numero de version du createur
1406         Certif    : tableau des certifications
1407         Date      : date d'execution du diagnostic ou du traitement
1408         Heure     : heure  d'execution du diagnostic ou du traitement
1409         NbMes     : nombre de valeurs rendues
1410         MaxReel   : nombre reel de valeurs
1411         X         : tableau des valeurs des abscisses
1412         Y         : tableau des valeurs des mesures
1413         Coord     : tableau des valeurs des autres coordonnees
1414 
1415   Retour          : compte-rendu d'execution
1416 
1417 ------------------------------------------------------------------------------*/
1418 
1419 int
1420 tsgrprg_ (NomDon, Entrees, Rangs, NbMax, Extract, Unite, NumVer, Certif,
1421       Date, Heure, NbMes, MaxReel,  X, Y, Coord,
1422       lnd, lut, ldt, lhr, lX, lY, lC)
1423 
1424      char *NomDon;
1425      Longint *Entrees;
1426      Longint *Rangs;
1427      Longint *NbMax;
1428      Longint *Extract;
1429      char *Unite[];
1430      Longint *NumVer;
1431      Longint *Certif;
1432      char *Date;
1433      char *Heure;
1434      Longint *NbMes;
1435      Longint *MaxReel;
1436      char *X;
1437      char *Y;
1438      char *Coord;
1439      int lnd, lut, ldt, lhr, lX, lY, lC;
1440 
1441 {
1442   struct S_Unite *ptunite;
1443   pS_Unite ptu;
1444   pS_Entree Entreesc;
1445   int cr = 0;
1446   int len;
1447   char *ptc, Ndt[TAILLE_NOM_DONNEE];
1448 
1449   if ((cr = check_dateheure (ldt, lhr)) < 0)
1450     return cr;
1451   cclean (NomDon, Ndt, lnd);
1452 
1453   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1454   Entreesc->union_var.lval = *Entrees;
1455   Entreesc->ps_suivant = NULL;
1456 
1457   cr = TSGrpRg (Ndt, Entreesc, Rangs, *NbMax, *Extract, &ptunite, NumVer,
1458         Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord);
1459 
1460   if (!cr)
1461     {
1462       if (ptunite)
1463     {
1464       ptc = (char *) Unite;
1465       ptu = ptunite;
1466 
1467       do
1468         {
1469           if (ptu->nom)
1470         {
1471           len = strlen (ptu->nom);
1472           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
1473           if (lut > len)
1474             memset (ptc + sizeof (char) * len, ' ', (lut - len));
1475         }
1476           ptc += sizeof (char) * lut;
1477         }
1478       while (ptu = ptu->ps_suivant);
1479       free (ptunite);
1480     }
1481       clean_dateheure (Date, ldt, Heure, lhr);
1482     }
1483   free (Entreesc);
1484   return (cr);
1485 }
1486 
1487 /*----------------------------------------------------------------------------
1488 
1489                         TSGrpX
1490 
1491   But : fonction demandant au serveur de lui renvoyer un groupe de signaux lu
1492         entre 2 valeurs de l'abscisse
1493 
1494   Arguments :
1495         NomDon    : nom de la donnee
1496         Entrees   : liste des entrees du traitement
1497         XI        : valeur initiale de l'abscisse
1498         XF        : valeur finale de l'abscisse
1499         NbMax     : nombre maximum de mesures souhaitees
1500         Extract   : type d'extraction souhaitee
1501 
1502         Unite     : liste des unites des mesures rendues
1503         NumVer    : numero de version du createur
1504         Certif    : tableau des certifications
1505         Date      : date d'execution du diagnostic ou du traitement
1506         Heure     : heure  d'execution du diagnostic ou du traitement
1507         NbMes     : nombre de valeurs rendues
1508         MaxReel   : nombre reel de valeurs
1509         X         : tableau des valeurs des abscisses
1510         Y         : tableau des valeurs des mesures
1511         Coord     : tableau des valeurs des autres coordonnees
1512 
1513   Retour          : compte-rendu d'execution
1514 
1515 ------------------------------------------------------------------------------*/
1516 
1517 int
1518 tsgrpx_ (NomDon, Entrees, XI, XF, NbMax, Extract, Unite, NumVer, Certif,
1519      Date, Heure, NbMes, MaxReel, X, Y, Coord,
1520      lnd, lut, ldt, lhr, lX, lY, lC)
1521 
1522      char *NomDon;
1523      Longint *Entrees;
1524      Double *XI;
1525      Double *XF;
1526      Longint *NbMax;
1527      Longint *Extract;
1528      char *Unite[];
1529      Longint *NumVer;
1530      Longint *Certif;
1531      char *Date;
1532      char *Heure;
1533      Longint *NbMes;
1534      Longint *MaxReel;
1535      char *X;
1536      char *Y;
1537      char *Coord;
1538      int lnd, lut, ldt, lhr, lX, lY, lC;
1539 
1540 {
1541   struct S_Unite *ptunite;
1542   pS_Unite ptu;
1543   pS_Entree Entreesc;
1544   int cr = 0;
1545   int len;
1546   char *ptc, Ndt[TAILLE_NOM_DONNEE];
1547 
1548 /**   YB   YB   **
1549   if(*XI < 1.E-24) return(17);
1550   if(*XF < 1.E-24) return(17);
1551 **   YB   YB   **/
1552   if ((cr = check_dateheure (ldt, lhr)) < 0)
1553     return cr;
1554   cclean (NomDon, Ndt, lnd);
1555 
1556   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1557   Entreesc->union_var.lval = *Entrees;
1558   Entreesc->ps_suivant = NULL;
1559 
1560   cr = TSGrpX (Ndt, Entreesc, *XI, *XF, *NbMax, *Extract, &ptunite, NumVer,
1561            Certif, Date, Heure, NbMes, MaxReel, X, Y, Coord);
1562 
1563   if (!cr)
1564     {
1565       if (ptunite)
1566     {
1567       ptc = (char *) Unite;
1568       ptu = ptunite;
1569 
1570       do
1571         {
1572           if (ptu->nom)
1573         {
1574           len = strlen (ptu->nom);
1575           memcpy (ptc, ptu->nom, ((lut >= len) ? len : lut));
1576           if (lut > len)
1577             memset (ptc + sizeof (char) * len, ' ', (lut - len));
1578         }
1579           ptc += sizeof (char) * lut;
1580         }
1581       while (ptu = ptu->ps_suivant);
1582       free (ptunite);
1583     }
1584       clean_dateheure (Date, ldt, Heure, lhr);
1585     }
1586   free (Entreesc);
1587   return (cr);
1588 }
1589 
1590 /*----------------------------------------------------------------------------
1591                                 TSLDiag
1592   But :
1593 
1594   Arguments :
1595 
1596   Retour          : compte-rendu d'execution
1597 
1598 ------------------------------------------------------------------------------*/
1599 
1600 int
1601 tsldiag_ (NumChoc, NbDiag, Listed, ld)
1602 
1603      Longint *NumChoc, *NbDiag;
1604      char *Listed[];
1605      int ld;
1606 {
1607   Longint cr = 0;
1608   int len, i;
1609   char *ptc;
1610 
1611   char *ldiag[50];
1612 
1613   cr = TSLDiag (*NumChoc, NbDiag, ldiag);
1614 
1615   if (cr == 0)
1616     {
1617       ptc = (char *) Listed;
1618       for (i = 0; i < *NbDiag; i++)
1619     {
1620       len = strlen (ldiag[i]);
1621 
1622       memcpy (ptc, ldiag[i], ((ld >= len) ? len : ld));
1623       if (ld > len)
1624         memset (ptc + sizeof (char) * len, ' ', (ld - len));
1625       ptc += sizeof (char) * ld;
1626     }
1627 
1628     }
1629   return ((int) cr);
1630 }
1631 
1632 /*----------------------------------------------------------------------------
1633                                 TSLTrait
1634   But :
1635 
1636   Arguments :
1637 
1638   Retour          : compte-rendu d'execution
1639 
1640 ------------------------------------------------------------------------------*/
1641 
1642 int
1643 tsltrait_ (NbTrait, Listet, ld)
1644 
1645      Longint *NbTrait;
1646      char *Listet[];
1647      int ld;
1648 {
1649   Longint cr = 0;
1650   int len, i;
1651   char *ptc;
1652 
1653   char *ltrait[50];
1654 
1655   cr = TSLTrait (NbTrait, ltrait);
1656 
1657   if (cr == 0)
1658     {
1659       ptc = (char *) Listet;
1660       for (i = 0; i < *NbTrait; i++)
1661     {
1662       len = strlen (ltrait[i]);
1663 
1664       memcpy (ptc, ltrait[i], ((ld >= len) ? len : ld));
1665       if (ld > len)
1666         memset (ptc + sizeof (char) * len, ' ', (ld - len));
1667       ptc += sizeof (char) * ld;
1668     }
1669 
1670     }
1671   return ((int) cr);
1672 }
1673 
1674 /*----------------------------------------------------------------------------
1675                                 TSLSig
1676 
1677   But :
1678 
1679   Arguments :
1680 
1681   Retour          : compte-rendu d'execution
1682 
1683 ------------------------------------------------------------------------------*/
1684 
1685 int
1686 tslsig_ (NumChoc, diag_name, NbSig, ListeS, ld, ls)
1687 
1688      Longint *NumChoc, *NbSig;
1689      char *diag_name, *ListeS[];
1690      int ld, ls;
1691 {
1692   Longint cr = 0;
1693   int len, i;
1694 
1695   char *lsig[95], *ptc;
1696   char Ndt[PREPASIZE + 1];
1697 
1698   cclean (diag_name, Ndt, ld);
1699 
1700   cr = TSLSig (*NumChoc, Ndt, NbSig, lsig);
1701   if (cr == 0)
1702     {
1703       ptc = (char *) ListeS;
1704       for (i = 0; i < *NbSig; i++)
1705     {
1706       len = strlen (lsig[i]);
1707       memcpy (ptc, lsig[i], ((ld >= len) ? len : ls));
1708       if (ls > len)
1709         memset (ptc + sizeof (char) * len, ' ', (ls - len));
1710       ptc += sizeof (char) * ls;
1711     }
1712     }
1713   return ((int) cr);
1714 }
1715 
1716 
1717 /*----------------------------------------------------------------------------
1718                                 TSRqparm
1719 
1720   But :
1721 
1722   Arguments :
1723 
1724   Retour          : compte-rendu d'execution
1725 
1726 ------------------------------------------------------------------------------*/
1727 
1728 int
1729 tsrqparm_ (NumChoc, diag, obj, param, nval, buff, nrep, ld, lo, lp, lb)
1730 
1731      Longint *NumChoc;
1732      char *diag, *obj, *param, *buff;
1733      int *nval, *nrep, ld, lo, lp, lb;
1734 {
1735   Longint cr = 0, fpar;
1736   int offset = 0;
1737   int len, i = 0;
1738   char Ndiag[PREPASIZE + 1], Nobj[PREPASIZE + 1], Nparam[PREPASIZE + 1];
1739 
1740   cclean (diag, Ndiag, ld);
1741   cclean (obj, Nobj, lo);
1742   cclean (param, Nparam, lp);
1743 
1744   strcpy(buff,"a");
1745   cr = TSRqParm (*NumChoc, Ndiag, Nobj, Nparam, *nval, buff, nrep, &fpar);
1746 
1747   return ((int) cr);
1748 }
1749 
1750 
1751 /*----------------------------------------------------------------------------
1752                                 TSRqdecl
1753 ------------------------------------------------------------------------------*/
1754 
1755 int
1756 tsrqdecl_ (NumChoc, decl, occur, date, ld)
1757 
1758      Longint *NumChoc;
1759      char *decl;
1760      int *occur, ld;
1761      float *date;
1762 {
1763   Longint cr = 0;
1764   int offset = 0;
1765   int len, i = 0;
1766   char Ndt[PREPASIZE + 1];
1767 
1768   cclean (decl, Ndt, ld);
1769 
1770   cr = TSRqdecl (*NumChoc, Ndt, *occur, date);
1771 
1772   return ((int) cr);
1773 }
1774 
1775 /*----------------------------------------------------------------------------
1776                                 TSGetinfo
1777 ------------------------------------------------------------------------------*/
1778 
1779 int
1780 tsgetinfo_ (NumChoc)
1781 
1782      int *NumChoc;
1783 {
1784   Longint cr = 0;
1785 
1786   cr = TSGetinfo (NumChoc);
1787 
1788   return ((int) cr);
1789 }
1790 /*----------------------------------------------------------------------------
1791                                 TSTData
1792 ------------------------------------------------------------------------------*/
1793 
1794 int
1795 tstdata_ (NumChoc, ndiag, t_choc, t_param,ld )
1796      Longint *NumChoc;
1797      char * ndiag;
1798      Longint *t_choc, *t_param;
1799      int ld;
1800 
1801 {
1802   Longint cr = 0;
1803 
1804   cr = TSTData (*NumChoc,ndiag, t_choc, t_param);
1805 
1806   return ((int)cr);
1807 }
1808 /*----------------------------------------------------------------------------
1809                                 TSLgDiag
1810 ------------------------------------------------------------------------------*/
1811 
1812 int
1813 tslgdiag_ (NumChoc, nomdiag, nbmes, ld )
1814 Longint *NumChoc, *nbmes;
1815 char *nomdiag;
1816 int ld;
1817 {
1818   Longint cr = 0;
1819   char Ndt[PREPASIZE + 1];
1820 
1821   cclean (nomdiag, Ndt, ld);
1822 
1823   cr = TSLgDiag (*NumChoc, Ndt, nbmes);
1824 
1825   return ((int) cr);
1826 }
1827 
1828 /*********** JS - 05.2005 - 
1829     ajout des 2 fcts tsinitocctrait_ ettsupdateocctrait_  ************/
1830 /*----------------------------------------------------------------------------
1831 
1832                         TSInitOccTrait
1833 
1834 But :     fonction envoyant au serveur les param�res ��rire 
1835     dans la base de donn�s au d�ut de l'��ution du traitement
1836 Arguments :
1837     NomTrait  : nom du traitement
1838     Numchoc   : numero du choc
1839     Occur      : numero de l'occurrence
1840     lt        : longueur du nom du traitement
1841 Retour : compte-rendu d'execution
1842 
1843 ------------------------------------------------------------------------------*/
1844 int 
1845 tsinitocctrait_  (NomTrait, Numchoc, Occur, lt)
1846 
1847      char *NomTrait;
1848      Longint *Numchoc, *Occur;
1849      int lt;
1850 {
1851   pS_Entree Entreesc;
1852   int cr = 0;
1853   char Ndt[TAILLE_NOM_TRAITEMENT];
1854   
1855   cclean (NomTrait, Ndt, lt);
1856   
1857   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1858   Entreesc->union_var.lval = *Numchoc;
1859   if (*Occur != 0) {
1860     Entreesc->ps_suivant = (pS_Entree) malloc (sizeof (struct S_Entree));
1861     Entreesc->ps_suivant->union_var.lval = *Occur;
1862     Entreesc->ps_suivant->ps_suivant = NULL;
1863   } else {
1864     Entreesc->ps_suivant = NULL;
1865   }
1866   
1867   cr= TSInitOccTrait (Ndt, Entreesc);
1868   free(Entreesc);
1869   return (cr);
1870 }
1871 
1872 /*----------------------------------------------------------------------------
1873 
1874                         TSUpdateOccTrait
1875 
1876 But :     fonction envoyant au serveur les param�res �rire 
1877     dans la base de donn�s a la fin de l'��ution du traitement
1878 Arguments :
1879     NomTrait  : nom du traitement
1880     ENumchoc   : numero du choc
1881     Occur      : numero de l'occurrence
1882     Status    : status de l'execution du traitement
1883     Dureems   : duree de l'execution du traitement en millisecondes
1884 Retour : compte-rendu d'execution
1885 
1886 ------------------------------------------------------------------------------*/
1887 int 
1888 tsupdateocctrait_  (NomTrait, Numchoc, Occur, Status, Dureems, lt)
1889      char *NomTrait;
1890      Longint *Numchoc, *Occur, *Status, *Dureems;
1891      int lt;
1892 {
1893   pS_Entree Entreesc;
1894   int cr = 0;
1895   char Ndt[TAILLE_NOM_TRAITEMENT];
1896   
1897   cclean (NomTrait, Ndt, lt);
1898   
1899   Entreesc = (pS_Entree) malloc (sizeof (struct S_Entree));
1900   Entreesc->union_var.lval = *Numchoc;
1901   if (*Occur != 0) {
1902     Entreesc->ps_suivant = (pS_Entree) malloc (sizeof (struct S_Entree));
1903     Entreesc->ps_suivant->union_var.lval = *Occur;
1904     Entreesc->ps_suivant->ps_suivant = NULL;
1905   } else {
1906     Entreesc->ps_suivant = NULL;
1907   }
1908   
1909   cr= TSUpdateOccTrait (Ndt, Entreesc, Status, Dureems);
1910   free(Entreesc);
1911   return (cr);
1912 }
1913 
1914 /*---------------------------
1915   ---------------------------*/
1916 int
1917 cclean (chOld, chNew, Len)
1918 
1919      char *chOld, *chNew;
1920      Longint Len;
1921 {
1922   int i = 0;
1923   char *pts, *ptd;
1924 
1925   pts = chOld;
1926   ptd = chNew;
1927   while ((*pts != ' ') && (i < Len))
1928     {
1929       *ptd++ = *pts++;
1930       i++;
1931     }
1932   *ptd = '\0';
1933   return (0);
1934 }
1935 
1936 /****
1937  ****/
1938 int
1939 check_dateheure (ldate, lheure)
1940      int ldate, lheure;
1941 {
1942   if ((ldate < LDATE) || (lheure < LHEURE))
1943     return (-10);
1944 
1945   return (0);
1946 }
1947 
1948 /****
1949  ****/
1950 int
1951 clean_dateheure (date, ldate, heure, lheure)
1952      char *date, *heure;
1953      int ldate, lheure;
1954 {
1955   int i;
1956   for (i = LDATE; i < ldate; i++)
1957     date[i] = ' ';
1958   for (i = LHEURE; i < lheure; i++)
1959     heure[i] = ' ';
1960   return (0);
1961 }
tslib_fcf

PURPOSE

SYNOPSIS

DESCRIPTION

CROSS-REFERENCE INFORMATION

SOURCE CODE
