MED fichier
filecf.c
Aller à la documentation de ce fichier.
1 /* This file is part of MED.
2  *
3  * COPYRIGHT (C) 1999 - 2016 EDF R&D, CEA/DEN
4  * MED is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * MED is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public License
15  * along with MED. If not, see <http://www.gnu.org/licenses/>.
16  */
17 
18 
19 #include <med.h>
20 #include "med_config.h"
21 #include "med_outils.h"
22 #include <string.h>
23 #include <stdlib.h>
24 
25 extern void *MedVersionedApi3F;
26 extern void f77Api3IsSet(void * obj);
27 
28 /*
29 From Fortran call of following C functions :
30 - MEDfileOpen
31 - MEDfileClose
32 - MEDfileCommentWr
33 - MEDfileCommentRd
34 - MEDfileNumVersionRd
35 - MEDfileStrVersionRd
36 - MEDfileCompatibility
37 - MEDfileObjectsMount
38 - MEDfileObjectsUnmount
39 - MEDfileObjectExist
40 - MEDfileExist
41 */
42 
43 #define nmfifope F77_FUNC(mfifope,MFIFOPE)
44 #define nmfifvop F77_FUNC(mfifvop,MFIFVOP)
45 #define nmfifclo F77_FUNC(mfifclo,MFIFCLO)
46 #define nmfifnam F77_FUNC(mfifnam,MFIFNAM)
47 #define nmfifcow F77_FUNC(mfifcow,MFIFCOW)
48 #define nmfifcor F77_FUNC(mfifcor,MFIFCOR)
49 #define nmfifnvr F77_FUNC(mfifnvr,MFIFNVR)
50 #define nmfifsvr F77_FUNC(mfifsvr,MFIFSVR)
51 #define nmfifcom F77_FUNC(mfifcom,MFIFCOM)
52 #define nmfifomn F77_FUNC(mfifomn,MFIFOMN)
53 #define nmfifoun F77_FUNC(mfifoun,MFIFOUN)
54 #define nmfifoex F77_FUNC(mfifoex,MFIFOEX)
55 #define nmfifexi F77_FUNC(mfifexi,MFIFEXI)
56 
57 
58 
59 #ifdef PPRO_NT
60 med_idt
61 MFIFVOP(const char const *name,
62  const unsigned int bidon,
63  const int const *access,
64  const med_int* const major,
65  const med_int* const minor,
66  const med_int* const release
67  const med_int* const len)
68 #else
69 med_idt
70 nmfifvop (const char const *name,
71  const int const *access,
72  const med_int* const major,
73  const med_int* const minor,
74  const med_int* const release,
75  const med_int* const len )
76 #endif
77 {
78  char *_fn;
79  med_idt _ret;
80  med_access_mode _access;
81 
82  /* Cette méthode a pour unique but de forcer la construction
83  de l'objet MedVersionedApi3F et donc la mise à jour de MedVersionedApi3
84  avec les APis fortran. Certains compilateurs suppriment le symbole MedVersionedApi3F
85  croyant qu'il nest pas utilisé et la mise à jour de MedVersionedApi n'est
86  alors pas effectuée.*/
88 
89  _fn = _MED2cstring((char *) name, (int) *len);
90  if (!_fn) return(-1);
91  _access = (med_access_mode) *access;
92 
93  _ret = (med_idt) MEDfileVersionOpen(_fn, _access,*major,*minor,*release);
94  /* ISCRUTE_long(_ret); */
95  _MEDcstringFree(_fn);
96 
97  return(_ret);
98 }
99 
100 
101 
102 #ifdef PPRO_NT
103 med_idt
104 MFIFOPE(const char const *name,
105  const unsigned int bidon,
106  const int const *access,
107  const med_int const *len)
108 #else
109 med_idt
110 nmfifope (const char const *name,
111  const int const *access,
112  const med_int const *len)
113 #endif
114 {
115  char *_fn;
116  med_idt _ret;
117  med_access_mode _access;
118 
119  /* Cette méthode a pour unique but de forcer la construction
120  de l'objet MedVersionedApi3F et donc la mise à jour de MedVersionedApi3
121  avec les APis fortran. Certains compilateurs suppriment le symbole MedVersionedApi3F
122  croyant qu'il nest pas utilisé et la mise à jour de MedVersionedApi n'est
123  alors pas effectuée.*/
125 
126  _fn = _MED2cstring((char *) name, (int) *len);
127  if (!_fn) return(-1);
128  _access = (med_access_mode) *access;
129 
130  _ret = (med_idt) MEDfileOpen(_fn, _access);
131  /* ISCRUTE_long(_ret); */
132  _MEDcstringFree(_fn);
133 
134  return(_ret);
135 }
136 
137 
138 
139 #ifdef PPRO_NT
140 med_int
141 MFIFNAM(med_idt *fid,
142  char const *filename,
143  const unsigned int bidon,
144  /* const med_int const *filenamesize, */
145  const med_int const *filenamelen)
146 #else
147 med_int
149  char const *filename,
150  /* const med_int const *filenamesize, */
151  const med_int const *filenamelen)
152 #endif
153 {
154  char *_fn=NULL;
155  med_int _ret=-1;
156 
157  /* ISCRUTE(*filenamesize); */
158  /* ISCRUTE(*filenamelen); */
159  /* ISCRUTE_id(*fid); */
160  _ret = MEDfileName(*fid, NULL, 0);
161  /* ISCRUTE(_ret); */
162  /* if ( (_ret<0) || ( (*filenamesize) == 0) ) return _ret; */
163  if ( (_ret<0) || ( (*filenamelen) == 0) ) return _ret;
164  if ( (*filenamelen != 0) &&
165  ( (_ret) > (*filenamelen) ) ) return -1;
166 
167  char *_fs1=(char *) malloc(_ret*sizeof(char)+1);
168 
169  _ret = (med_int) MEDfileName(*fid,_fs1, *filenamelen);
170  /* SSCRUTE(_fs1); */
171  /* ISCRUTE(*filenamesize); */
172  /* ISCRUTE_id(*fid); */
173  _MEDc2fString(_fs1,(char*)filename,*filenamelen);
174  free(_fs1);
175 
176  return(_ret);
177 }
178 
179 
180 
181 #ifdef PPRO_NT
182 med_int
183 MFIFCLO(med_idt *fid)
184 #else
185 med_int
187 #endif
188 {
189  med_int _ret;
190 
191  _ret = (med_int) MEDfileClose(*fid);
192 
193  return(_ret);
194 }
195 
196 
197 
198 #ifdef PPRO_NT
199 med_int
200 MFIFCOW(const med_idt const *fid,
201  const char const *comment,
202  const unsigned int bidon,
203  const med_int *commentlen)
204 #else
205 med_int
206 nmfifcow(const med_idt const *fid,
207  const char const *comment,
208  const med_int *commentlen)
209 #endif
210 {
211  med_int _ret;
212  char* _fs1;
213 
214  _fs1 = _MED2cstring((char *) comment, (med_int) *commentlen);
215  if (!_fs1)
216  return(-1);
217 
218  _ret = (med_int) MEDfileCommentWr(*fid, _fs1);
219 
220  _MEDcstringFree(_fs1);
221 
222  return(_ret);
223 }
224 
225 
226 
227 #ifdef PPRO_NT
228 med_int
229 MFIFCOR(const med_idt const *fid,
230  char const *comment,
231  const unsigned int bidon,
232  const med_int *commentlen)
233 #else
234 med_int
235 nmfifcor(const med_idt const *fid,
236  char const *comment,
237  const med_int *commentlen)
238 #endif
239 {
240  med_int _ret;
241  char _fs1[MED_COMMENT_SIZE+1]="";
242 
243  _ret = (med_int) MEDfileCommentRd(*fid,_fs1);
244 
245  _MEDc2fString(_fs1,(char*)comment,*commentlen);
246 
247  return(_ret);
248 }
249 
250 
251 
252 #ifdef PPRO_NT
253 med_int
254 MFIFNVR(const med_idt const *fid,
255  med_int* const major,
256  med_int* const minor,
257  med_int* const release)
258 #else
259 med_int
260 nmfifnvr(const med_idt const *fid,
261  med_int* const major,
262  med_int* const minor,
263  med_int* const release)
264 #endif
265 {
266  med_int _ret;
267 
268  _ret = (med_int) MEDfileNumVersionRd(*fid,major,minor,release);
269 
270  return(_ret);
271 }
272 
273 
274 
275 #ifdef PPRO_NT
276 med_int
277 MFIFSVR(const med_idt const *fid,
278  char* const medversion,
279  const unsigned int bidon,
280  const med_int const *len)
281 #else
282 med_int
283 nmfifsvr(const med_idt const *fid,
284  char* const medversion,
285  const med_int const *len)
286 #endif
287 {
288  med_int _ret;
289  char _fs1[20]="";
290 
291  _ret = (med_int) MEDfileStrVersionRd(*fid, _fs1);
292 
293  _MEDc2fString(_fs1,medversion,*len);
294 
295  return(_ret);
296 }
297 
298 
299 #ifdef PPRO_NT
300 med_int
301 MFIFCOM(const char const *name,
302  const unsigned int bidon,
303  const med_int const *len,
304  med_int *hdfok,
305  med_int *medok)
306 #else
307 med_int
308 nmfifcom(const char const *name,
309  const med_int const *len,
310  med_int *hdfok,
311  med_int *medok)
312 #endif
313 {
314  med_int _ret;
315  med_bool _medok, _hdfok;
316  char *_fs1;
317 
318  _fs1 = _MED2cstring((char *) name, (int) *len);
319  if (!_fs1)
320  return(-1);
321 
322  _ret = (med_int) MEDfileCompatibility(_fs1,&_hdfok,&_medok);
323 
324  *hdfok = (med_int) _hdfok;
325  *medok = (med_int) _medok;
326 
327  _MEDcstringFree(_fs1);
328 
329  return(_ret);
330 }
331 
332 
333 #ifdef PPRO_NT
334 med_int
335 MFIFOMN (med_idt *fid,
336  char *fname,
337  unsigned int bidon,
338  med_int *len,
339  med_int *class)
340 #else
341 med_int
343  char *fname,
344  med_int *len,
345  med_int *class)
346 #endif
347 {
348  char *_fn;
349  med_int _ret;
350  med_class _class = (med_class) *class;
351 
352  _fn = _MED2cstring((char *) fname, (int) *len);
353  if (!_fn)
354  return(-1);
355 
356  _ret = (med_int) MEDfileObjectsMount(*fid, _fn, _class );
357 
358  _MEDcstringFree(_fn);
359 
360  return(_ret);
361 }
362 
363 #ifdef PPRO_NT
364 med_int
365 MFIFOUN (const med_idt const *fid,
366  med_idt const *mid,
367  const med_int const *class)
368 #else
369 med_int
370 nmfifoun(const med_idt const *fid,
371  med_idt const *mid,
372  const med_int const *class)
373 #endif
374 {
375  med_int _ret;
376  med_class _class = (med_class) *class;
377 
378  _ret = (med_int) MEDfileObjectsUnmount(*fid,
379  *mid,
380  _class);
381 
382  return(_ret);
383 }
384 
385 
386 #ifdef PPRO_NT
387 med_int
388 MFIFOEX (const med_idt const *fid,
389  const med_int const *class,
390  char *oname,
391  unsigned int bidon,
392  med_int *len,
393  med_int *oxist)
394 #else
395 med_int
396 nmfifoex(const med_idt const *fid,
397  const med_int const *class,
398  char *oname,
399  med_int *len,
400  med_int *oexist)
401 #endif
402 {
403  char *_fn;
404  med_int _ret;
405  med_bool _oexist;
406  med_class _class = (med_class) *class;
407 
408  _fn = _MED2cstring((char *) oname, (int) *len);
409  if (!_fn) return(-1);
410 
411  _ret = (med_int) MEDfileObjectExist(*fid,
412  _class,
413  _fn,
414  &_oexist);
415  *oexist = (med_int) _oexist;
416  _MEDcstringFree(_fn);
417 
418  return(_ret);
419 }
420 
421 
422 
423 #ifdef PPRO_NT
424 med_int
425 MFIFEXI (const char * const fname,
426  unsigned int bidon,
427  med_int *len,
428  const int const *access,
429  med_int *fexist,
430  med_int *accok)
431 #else
432 med_int
433 nmfifexi(const char * const fname,
434  med_int *len,
435  const int const *access,
436  med_int *fexist,
437  med_int *accok)
438 #endif
439 {
440  char *_fn;
441  med_int _ret;
442  med_bool _fexist,_accok;
443  med_access_mode _access = (med_access_mode) *access;
444 
445  _fn = _MED2cstring((char *) fname, (int) *len);
446  if (!_fn) return(-1);
447 
448  _ret = (med_int) MEDfileExist(_fn,
449  _access,
450  &_fexist,
451  &_accok);
452  *fexist = (med_int) _fexist;
453  *accok = (med_int) _accok;
454  _MEDcstringFree(_fn);
455 
456  return(_ret);
457 }
#define nmfifcom
Definition: filecf.c:51
MEDC_EXPORT med_err _MEDcstringFree(char *chaine)
MEDC_EXPORT med_err MEDfileStrVersionRd(const med_idt fid, char *const version)
Lecture du numéro de version de la bibliothèque MED utilisée pour créer le fichier (renvoyé sous la f...
med_access_mode
Definition: med.h:113
MEDC_EXPORT med_idt MEDfileOpen(const char *const filename, const med_access_mode accessmode)
Ouverture d'un fichier MED.
Definition: MEDfileOpen.c:41
#define nmfifcow
Definition: filecf.c:47
MEDC_EXPORT med_err MEDfileCommentRd(const med_idt fid, char *const comment)
Lecture d'un descripteur dans un fichier MED.
void f77Api3IsSet(void *obj)
med_class
Definition: med.h:173
#define nmfifnam
Definition: filecf.c:46
#define nmfifoun
Definition: filecf.c:53
MEDC_EXPORT med_err MEDfileNumVersionRd(const med_idt fid, med_int *const major, med_int *const minor, med_int *const release)
Lecture du numéro de version de la bibliothèque MED utilisée pour créer le fichier.
#define nmfifope
Definition: filecf.c:43
#define nmfifomn
Definition: filecf.c:52
MEDC_EXPORT med_err MEDfileObjectsUnmount(const med_idt fid, const med_idt mid, const med_class medclass)
Une fois le démontage effectué, les données précédemment montées ne sont plus accessibles.
int med_int
Definition: med.h:316
#define nmfifsvr
Definition: filecf.c:50
MEDC_EXPORT med_err MEDfileCommentWr(const med_idt fid, const char *const comment)
Ecriture d'un descripteur dans un fichier MED.
MEDC_EXPORT med_err MEDfileExist(const char *const filename, const med_access_mode accessmode, med_bool *const fileexist, med_bool *const accessok)
Interroge l'existence d'un fichier de nom filename et la possibilité de l'ouvrir selon le mode d'accè...
Definition: MEDfileExist.c:51
void * MedVersionedApi3F
MEDC_EXPORT med_err MEDfileClose(med_idt fid)
Fermeture d'un fichier MED.
Definition: MEDfileClose.c:30
MEDC_EXPORT med_int MEDfileName(med_idt fid, char *const filename, const med_int filenamesize)
Renvoi le nom de fichier MED à partir d'un med_idt.
Definition: MEDfileName.c:35
#define nmfifoex
Definition: filecf.c:54
#define nmfifnvr
Definition: filecf.c:49
MEDC_EXPORT med_err MEDfileObjectExist(const med_idt fid, const med_class medclass, const char *const objectname, med_bool *const objectexist)
Interroge le fichier fid pour tester l'existence de l'objet objectname de type medclass.
#define MED_COMMENT_SIZE
Definition: med.h:72
MEDC_EXPORT med_err _MEDc2fString(const char *const chainec, char *const chainef, med_int longueur_buffer77)
hid_t med_idt
Definition: med.h:309
MEDC_EXPORT med_idt MEDfileObjectsMount(const med_idt fid, const char *const filename, const med_class medclass)
Cette routine permet de monter dans le fichier courant un type de données (exemples les maillages...
MEDC_EXPORT med_idt MEDfileVersionOpen(const char *const filename, const med_access_mode accessmode, const med_int major, const med_int minor, const med_int release)
Ouverture d'un fichier MED en indiquant la version du modèle à utiliser en cas de création d'un nouve...
#define nmfifcor
Definition: filecf.c:48
med_bool
Definition: med.h:240
#define nmfifclo
Definition: filecf.c:45
MEDC_EXPORT char * _MED2cstring(char *chaine, int longueur)
Definition: MED2cstring.c:35
#define nmfifexi
Definition: filecf.c:55
MEDC_EXPORT med_err MEDfileCompatibility(const char *const filename, med_bool *const hdfok, med_bool *const medok)
Vérification de la compatibilité d'un fichier avec HDF et MED.
#define nmfifvop
Definition: filecf.c:44