Back to index

salome-kernel  6.5.0
CalciumC.c
Go to the documentation of this file.
00001 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
00004 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
00005 //
00006 // This library is free software; you can redistribute it and/or
00007 // modify it under the terms of the GNU Lesser General Public
00008 // License as published by the Free Software Foundation; either
00009 // version 2.1 of the License.
00010 //
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 // Lesser General Public License for more details.
00015 //
00016 // You should have received a copy of the GNU Lesser General Public
00017 // License along with this library; if not, write to the Free Software
00018 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00019 //
00020 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00021 //
00022 
00023 //  File   : Calcium.c
00024 //  Author : Eric Fayolle (EDF)
00025 //  Module : KERNEL
00026 //
00027 #include "calcium.h"
00028 #include "calciumf.h"
00029 #include "CalciumFortranInt.h"
00030 #include <stdlib.h>
00031 #include <stdio.h>
00032 #include <string.h>
00033 #include <stddef.h>
00034 
00035 // Interface C de SalomeCalcium
00036 
00037 typedef int InfoType;
00038 typedef char bool;
00039 
00040 //TODO: ajouter les prototypes pour eviter les pbs de passage par valeur
00041 InfoType ecp_fint_ (void * component, char* nomVar, float t);
00042 InfoType ecp_fini_ (void * component, char* nomVar, int i);
00043 InfoType ecp_efft_ (void * component, char* nomVar, float t);
00044 InfoType ecp_effi_ (void * component, char* nomVar, int i);
00045 
00046 /************************************/
00047 /* INTERFACES DE LECTURE EN 0 COPIE */
00048 /************************************/
00049 
00050 /* Definition des méthodes calcium étendues en 0 copie */
00051 /* Le buffer est alloué par le port pas par l'utilisateur */
00052 /* Remarquer le type ** de data */
00053 /* L'utilisateur devra appeler ecp_..._free pour désallouer le buffer interne */
00054 /* Attention en cas de lectures multiples : le buffer retourné est le même */
00055 /* Attention si les niveaux sont actifs le buffer peut être supprimé automatiquement par calcium. */
00056 
00057 #define CALCIUM_EXT_LECT_INTERFACE_C_(_name,_timeType,_type,_typeName,_qual) \
00058   InfoType ecp_##_name (void * component, int mode,                     \
00059                         _timeType * ti, _timeType * tf, int * i,        \
00060                         char * nomvar, int bufferLength,                \
00061                         int * nRead, _type _qual ** data ) {            \
00062     size_t _nRead;                                                      \
00063     long   _i=*i;                                                       \
00064     fflush(stdout);                                                     \
00065     fflush(stderr);                                                     \
00066                                                                         \
00067     InfoType info =  ecp_lecture_##_typeName (component, mode, ti, tf, &_i, \
00068                                               nomvar, bufferLength, &_nRead, \
00069                                               data );                   \
00070     /*    std::cout << "-------- CalciumInterface(C Part), Valeur de data : " << std::endl; */ \
00071     /*    std::cout << "Ptr :" << *data << std::endl;                           */ \
00072     /*    for (int j=0; j<_nRead;++j)                                           */ \
00073     /*      printf("--- Valeur de data[%d] : %d \n",j,(*data)[j]);              */ \
00074     /*    std::cout << "Ptr :" << *data << std::endl;                           */ \
00075     /*                                                                  */ \
00076     /*    std::cerr << "-------- CalciumInterface(C Part) MARK 2 ------------------" << std::endl; */ \
00077     if(mode == CP_SEQUENTIEL)   \
00078       *i = _i;                                                          \
00079     *nRead=_nRead;                                                      \
00080     /*    std::cerr << "-------- CalciumInterface(C Part) MARK 3 ------------------" << std::endl; */ \
00081                                                                         \
00082     return info;                                                        \
00083   };                                                                    \
00084   void ecp_##_name##_free ( _type _qual * data) {                       \
00085     ecp_lecture_##_typeName##_free(data);                               \
00086   };
00087 
00088 
00089 /* L'interface de cette routine diffère de celle obtenue par la macro :
00090    CALCIUM_LECT_INTERFACE_C_.
00091    Le paramètre supplémentaire strSize indique la taille fixe et identique
00092    des chaînes stockées dans data (les ports CALCIUM n'en n'ont pas besoin)
00093 */
00094 InfoType ecp_lch(void * component, int mode, float * ti,        float * tf, int * i,
00095                 char  * nomvar, int bufferLength, int * nRead,
00096                 char *** data, int strSize) {
00097 
00098   size_t _nRead;
00099   long   _i=*i;
00100   fflush(stdout);fflush(stderr);
00101 
00102   InfoType info =  ecp_lecture_str (component, mode, ti, tf, &_i,
00103                                     nomvar, bufferLength, &_nRead,
00104                                     data);/*, strSize );
00105                                              strSize est  inutile pour les ports CALCIUM
00106                                              qui gèrent des tailles quelconques de chaines. */
00107   if(mode == CP_SEQUENTIEL)
00108     *i = _i;
00109   *nRead=_nRead;
00110   fflush(stdout);fflush(stderr);
00111   return info;
00112 };
00113 
00114 void ecp_lch_free (char* * data) {                              \
00115   ecp_lecture_str_free(data);                                   \
00116 };
00117 
00118 
00119 #define STAR *
00120 /*REVERIFIER MAINTENANT 0 COPY avec int2integer*/
00121 CALCIUM_EXT_LECT_INTERFACE_C_(len,float,int,int2integer,);
00122 CALCIUM_EXT_LECT_INTERFACE_C_(lre,float,float,float,);
00123 CALCIUM_EXT_LECT_INTERFACE_C_(ldb,double,double,double,);
00124 CALCIUM_EXT_LECT_INTERFACE_C_(llo,float,int,bool,);
00125 CALCIUM_EXT_LECT_INTERFACE_C_(lcp,float,float,cplx,);
00126 /* CALCIUM_EXT_LECT_INTERFACE_C_(lch,float,char,STAR[]);  */
00127 
00128 
00129 /**************************************/
00130 /* INTERFACES DE LECTURE AVEC RECOPIE */
00131 /**************************************/
00132 
00133 #define CALCIUM_LECT_INTERFACE_C_(_name,_timeType,_calInt,_type,_typeName,_qual,lastarg) \
00134   _calInt cp_##_name (void * component, _calInt mode,                   \
00135                        _timeType * ti, _timeType * tf, _calInt * i,     \
00136                        char * nomvar, _calInt bufferLength,             \
00137                        _calInt * nRead, _type _qual * data              \
00138                        lastarg ) {                                      \
00139                                                                         \
00140     int    _mode         = (int) mode;                                  \
00141     size_t _bufferLength = bufferLength;                                \
00142     size_t _nRead;                                                      \
00143     long   _i            =*i;                                           \
00144     fflush(stdout);                                                     \
00145     fflush(stderr);                                                     \
00146                                                                         \
00147     if ( (data == NULL) || (_bufferLength < 1) ) return CPNTNULL;       \
00148                                                                         \
00149     _calInt info =  ecp_lecture_##_typeName (component, _mode, ti, tf, &_i, \
00150                                               nomvar, _bufferLength, &_nRead, \
00151                                               &data );                  \
00152     if(mode == CP_SEQUENTIEL)                                           \
00153       *i = _i;                                                          \
00154     *nRead=_nRead;                                                      \
00155     fflush(stdout);                                                     \
00156     fflush(stderr);                                                     \
00157                                                                         \
00158     return info;                                                        \
00159   };                                                                    \
00160   void cp_##_name##_free ( _type _qual * data) {                        \
00161     ecp_lecture_##_typeName##_free(data);                               \
00162   };
00163 
00164 
00165 /* L'interface de cette routine diffère de celle obtenue par la macro :
00166    CALCIUM_LECT_INTERFACE_C_.
00167    Le paramètre supplémentaire strSize indique la taille fixe et identique
00168    des chaînes stockées dans data (les ports CALCIUM n'en n'ont pas besoin)
00169 */
00170 
00171 /* InfoType cp_lch(void * component, int mode, float * ti,      float * tf, int * i, */
00172 /*              char  * nomvar, int bufferLength, int * nRead, */
00173 /*              char ** data, int strSize) { */
00174 
00175 /*   size_t _nRead;                                                      */
00176 /*   long   _i=*i;                                                       */
00177 /*   fflush(stdout);fflush(stderr);                                                      */
00178 /*   fprintf(stderr,"Beginning of cp_lch: %s %d %f\n",nomvar,*i,*ti);    */
00179 /*   if ( (data == NULL) || (bufferLength < 1) ) return CPNTNULL;        */
00180 /*   InfoType info =  ecp_lecture_str (component, mode, ti, tf, &_i,  */
00181 /*                                  nomvar, bufferLength, &_nRead,  */
00182 /*                                  &data);*/
00183 /*, strSize );  */
00184 /*                                           strSize est  inutile pour les ports CALCIUM */
00185 /*                                           qui gèrent des tailles quelconques de chaines.  */
00186 /*   if(mode == CP_SEQUENTIEL)                                           */
00187 /*     *i = _i;                                                          */
00188 /*   *nRead=_nRead;                                                      */
00189 /*   fprintf(stderr,"End of cp_lch: %s %d \n",nomvar,*i);                        */
00190 /*   fflush(stdout);fflush(stderr);                                                      */
00191 /*   return info;                                                        */
00192 /* };                                                                    */
00193 
00194 
00195 /* Definition des méthodes calcium standard  */
00196 /* CALCIUM_LECT_INTERFACE_C_( <suffixe du nom de l'interface à générer>, <type du paramètre temporel>, <type d'entier à utiliser pour les paramètres de type entier>,
00197                               <type de données>, <nom de l'interface C2CPP à utiliser>, <qualificateur de type optionnel des données>,<paramètres supplémentaire ignoré>)*/
00198 
00199 CALCIUM_LECT_INTERFACE_C_(len,float ,int,int    ,int2integer,,);
00200 /*llg ne fonctionnera pas toujours correctement (port calcium_integer) si sizeof(long) == 64 bits && cal_int==int (32 bits)
00201   sinon problème de conversion de 64bits vers 32bits */
00202 CALCIUM_LECT_INTERFACE_C_(llg,float ,int,long   ,long2integer,,);
00203 
00204 CALCIUM_LECT_INTERFACE_C_(lln,float ,int,long   ,long,,);
00205 
00206 CALCIUM_LECT_INTERFACE_C_(lre,float ,int,float  ,float,,);
00207 CALCIUM_LECT_INTERFACE_C_(ldb,double,int,double ,double,,);
00208 CALCIUM_LECT_INTERFACE_C_(llo,float ,int,int    ,bool,,);
00209 CALCIUM_LECT_INTERFACE_C_(lcp,float ,int,float  ,cplx,,);
00210 #define STAR *
00211 #define LCH_LAST_PARAM ,int strsize
00212 CALCIUM_LECT_INTERFACE_C_(lch,float ,int,char   ,str,STAR, LCH_LAST_PARAM );
00213 
00214 
00215 /* Definition des méthodes calcium destinées à l'interfaçage fortran
00216    avec une taille des INTEGER fortran paramétrés à la configuration du KERNEL  */
00217 
00218 CALCIUM_LECT_INTERFACE_C_(len_fort_,float ,cal_int,cal_int ,integer,,);
00219 CALCIUM_LECT_INTERFACE_C_(lin_fort_,float ,cal_int,int     ,int2integer,,);
00220 /*llg_fort_ ne fonctionnera pas toujours correctement (port calcium_integer) si sizeof(long) == 64 bits && cal_int==int (32 bits)
00221   sinon problème de conversion de 64bits vers 32bits */
00222 CALCIUM_LECT_INTERFACE_C_(llg_fort_,float ,cal_int,long    ,long2integer,,);
00223 
00224 CALCIUM_LECT_INTERFACE_C_(lre_fort_,float ,cal_int,float   ,float,,);
00225 CALCIUM_LECT_INTERFACE_C_(ldb_fort_,double,cal_int,double  ,double,,);
00226 CALCIUM_LECT_INTERFACE_C_(llo_fort_,float ,cal_int,int     ,bool,,);   /*int pour bool ou cal_int */
00227 CALCIUM_LECT_INTERFACE_C_(lcp_fort_,float ,cal_int,float   ,cplx,,);
00228 CALCIUM_LECT_INTERFACE_C_(lch_fort_,float ,cal_int,char    ,str,STAR, LCH_LAST_PARAM );
00229 
00230 CALCIUM_LECT_INTERFACE_C_(lln_fort_,float ,cal_int,long    ,long,,);
00231 
00232 /**********************************************/
00233 /*  INTERFACES DE DÉBUT ET DE FIN DE COUPLAGE */
00234 /**********************************************/
00235 
00236 InfoType cp_cd (void * component, char * instanceName) {
00237   InfoType info =  ecp_cd_(component,instanceName);
00238   return info;
00239 }
00240 
00241 InfoType cp_fin (void * component, int code) {
00242   /* TODO : gérer avec les callbacks des ports DSC */
00243 
00244   InfoType info =  ecp_fin_(component,code);
00245 
00246   return info;
00247 }
00248 
00249 
00250 /***************************/
00251 /*  INTERFACES D'ECRITURE  */
00252 /***************************/
00253 
00254 #define CALCIUM_ECR_INTERFACE_C_(_name,_timeType,_calInt,_type,_typeName,_qual,lastarg) \
00255   _calInt cp_##_name (void * component, _calInt mode,                   \
00256                        _timeType t, _calInt i,                          \
00257                        char * nomvar, _calInt nbelem,                   \
00258                        _type _qual * data                               \
00259                        lastarg ) {                                      \
00260                                                                         \
00261     int     _mode         =  mode;                                      \
00262     long    _i            =  i;                                         \
00263     size_t  _nbelem       =  nbelem;                                    \
00264     _timeType _t          =  t;                                         \
00265     fflush(stdout);                                                     \
00266     fflush(stderr);                                                     \
00267     if ( (data == NULL) || (nbelem < 1) ) return CPNTNULL;              \
00268                                                                         \
00269     _calInt info =  ecp_ecriture_##_typeName (component, _mode, &_t, _i, \
00270                                                nomvar, _nbelem,         \
00271                                                data );                  \
00272     fflush(stdout);                                                     \
00273     fflush(stderr);                                                     \
00274                                                                         \
00275     return info;                                                        \
00276   };                                                                    \
00277 
00278 
00279 
00280 
00281 /* InfoType cp_ech(void * component, int mode, float t, int i, */
00282 /*              char  * nomvar,  int nbelem, */
00283 /*              char ** data, int strSize) { */
00284 
00285 /*long   _i=i;*/
00286 /*   fflush(stdout);fflush(stderr);                                                      */
00287 /*   fprintf(stderr,"Beginning of cp_ech: %s %d %f\n",nomvar,i,t);       */
00288 /*   if ( (data == NULL) || (nbelem < 1) ) return CPNTNULL;              */
00289 
00290 /*   InfoType info =  ecp_ecriture_str (component, mode, &t, i,  */
00291 /*                                   nomvar, nbelem,             */
00292 /*                                   data); */
00293 /*, strSize );*/
00294 /*   fprintf(stderr,"End of cp_ech: %s %d \n",nomvar,i);                         */
00295 /*   fflush(stdout);                                                     */
00296 /*   fflush(stderr);                                                     */
00297 
00298 /*   return info;                                                        */
00299 /* };                                                                    */
00300 
00301 /*  Definition des méthodes calcium standard  */
00302 /*  CALCIUM_ECR_INTERFACE_C_(_name,_timeType,_calInt,type,_typeName,_qual) */
00303 CALCIUM_ECR_INTERFACE_C_(een,float ,int,int   ,int2integer,,);
00304 /*elg ne fonctionnera pas toujours correctement (port calcium_integer) si sizeof(long) == 64 bits && cal_int==int (32 bits)
00305   sinon problème de conversion de 64bits vers 32bits */
00306 CALCIUM_ECR_INTERFACE_C_(elg,float ,int,long  ,long2integer,,);
00307 CALCIUM_ECR_INTERFACE_C_(ere,float ,int,float ,float,,);
00308 CALCIUM_ECR_INTERFACE_C_(edb,double,int,double,double,,);
00309 CALCIUM_ECR_INTERFACE_C_(elo,float ,int,int   ,bool,,);
00310 CALCIUM_ECR_INTERFACE_C_(ecp,float ,int,float ,cplx,,);
00311 CALCIUM_ECR_INTERFACE_C_(ech,float ,int,char  ,str,STAR,LCH_LAST_PARAM );
00312 
00313 CALCIUM_ECR_INTERFACE_C_(eln,float ,int,long  ,long,,);
00314 
00315 /* Definition des méthodes calcium destinées à l'interfaçage fortran
00316    avec une taille des INTEGER fortran paramétrés à la configuration du KERNEL  */
00317 
00318 CALCIUM_ECR_INTERFACE_C_(een_fort_,float ,cal_int,cal_int,integer,,);
00319 /*elg_fort_ ne fonctionnera pas toujours correctement (port calcium_integer) si sizeof(long) == 64 bits && cal_int==int (32 bits)
00320   sinon problème de conversion de 64bits vers 32bits */
00321 CALCIUM_ECR_INTERFACE_C_(elg_fort_,float ,cal_int,long   ,long2integer,,);
00322 CALCIUM_ECR_INTERFACE_C_(ein_fort_,float ,cal_int,int    ,int2integer,,);
00323 CALCIUM_ECR_INTERFACE_C_(ere_fort_,float ,cal_int,float ,float,,);
00324 CALCIUM_ECR_INTERFACE_C_(edb_fort_,double,cal_int,double,double,,);
00325 CALCIUM_ECR_INTERFACE_C_(elo_fort_,float ,cal_int,int   ,bool,,);
00326 CALCIUM_ECR_INTERFACE_C_(ecp_fort_,float ,cal_int,float ,cplx,,);
00327 CALCIUM_ECR_INTERFACE_C_(ech_fort_,float ,cal_int,char  ,str,STAR,LCH_LAST_PARAM );
00328 
00329 CALCIUM_ECR_INTERFACE_C_(eln_fort_,float ,cal_int,long   ,long,,);
00330 
00331 /***************************/
00332 /*  Interface for cleaning */
00333 /***************************/
00334 
00335 InfoType cp_fini (void * component, char * nomvar, int i)
00336 {
00337   InfoType info =  ecp_fini_(component,nomvar,i);
00338   return info;
00339 }
00340 
00341 InfoType cp_fint (void * component, char * nomvar, float t)
00342 {
00343   InfoType info =  ecp_fint_(component,nomvar,t);
00344   return info;
00345 }
00346 
00347 InfoType cp_effi (void * component, char * nomvar, int i)
00348 {
00349   InfoType info =  ecp_effi_(component,nomvar,i);
00350   return info;
00351 }
00352 
00353 InfoType cp_efft (void * component, char * nomvar, float t)
00354 {
00355   InfoType info =  ecp_efft_(component,nomvar,t);
00356   return info;
00357 }