# entmaacf.c

Aller à la documentation de ce fichier.

    00001 /*  This file is part of MED.
    00002  *
    00003  *  COPYRIGHT (C) 1999 - 2011  EDF R&D, CEA/DEN
    00004  *  MED is free software: you can redistribute it and/or modify
    00005  *  it under the terms of the GNU Lesser General Public License as published by
    00006  *  the Free Software Foundation, either version 3 of the License, or
    00007  *  (at your option) any later version.
    00008  *
    00009  *  MED is distributed in the hope that it will be useful,
    00010  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    00011  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00012  *  GNU Lesser General Public License for more details.
    00013  *
    00014  *  You should have received a copy of the GNU Lesser General Public License
    00015  *  along with MED.  If not, see <http://www.gnu.org/licenses/>.
    00016  */
    00017
    00018
    00019 #include <med.h>
    00020 #include "med_config.h"
    00021 #include "med_outils.h"
    00022 #include <stdlib.h>
    00023 #include <string.h>
    00024
    00025 #define nedfcone F77_FUNC(edfcone,EDFCONE)
    00026 #define nedfconl F77_FUNC(edfconl,EDFCONL)
    00027 #define nedfcooe F77_FUNC(edfcooe,EDFCOOE)
    00028 #define nedfcool F77_FUNC(edfcool,EDFCOOL)
    00029 #define nedfnema F77_FUNC(edfnema,EDFNEMA)
    00030 #define nedfnome F77_FUNC(edfnome,EDFNOME)
    00031 #define nedfnoml F77_FUNC(edfnoml,EDFNOML)
    00032 #define nedfnume F77_FUNC(edfnume,EDFNUME)
    00033 #define nedfnuml F77_FUNC(edfnuml,EDFNUML)
    00034 #define nedfpgce F77_FUNC(edfpgce,EDFPGCE)
    00035 #define nedfpgcl F77_FUNC(edfpgcl,EDFPGCL)
    00036 #define nedfpygi F77_FUNC(edfpygi,EDFPYGI)
    00037 #define nedfpece F77_FUNC(edfpece,EDFPECE)
    00038 #define nedfpecl F77_FUNC(edfpecl,EDFPECL)
    00039 #define nedfpyei F77_FUNC(edfpyei,EDFPYEI)
    00040 #define nedficoe F77_FUNC(edficoe,EDFICOE)
    00041 #define nedficol F77_FUNC(edficol,EDFICOL)
    00042 #define nedfscoe F77_FUNC(edfscoe,EDFSCOE)
    00043 #define nedfscol F77_FUNC(edfscol,EDFSCOL)
    00044
    00045
    00046 #ifdef PPRO_NT
    00047 med_int
    00048 __stdcall EDFCONE(med_int *fid, char *maa, unsigned int bidon,
    00049                   med_int *lon, med_int *mdim, med_int *con,med_int *mode_switch,
    00050                   med_int *nbre,
    00051                   med_int *type_ent,
    00052                   med_int *type_geo,med_int *type_con )
    00053 #else
    00054 med_int
    00055 nedfcone(med_int *fid, char *maa, med_int *lon,med_int *mdim,
    00056          med_int *con, med_int *mode_switch, med_int *nbre,
    00057          med_int *type_ent,med_int *type_geo,med_int *type_con)
    00058 #endif
    00059 {
    00060   char *fn;
    00061   med_int ret;
    00062
    00063   fn = _MED2cstring(maa, (int) * lon);
    00064
    00065   if (!fn)
    00066     return(-1);
    00067
    00068   ret = (med_int) MEDconnEcr ((med_idt) *fid,fn,(med_int) *mdim,
    00069                               (med_int *)con,(med_mode_switch) *mode_switch,(med_int)*nbre,
    00070                               (med_entite_maillage)*type_ent,
    00071                               (med_geometrie_element) *type_geo,
    00072                               (med_connectivite) *type_con);
    00073
    00074   _MEDcstringFree(fn);
    00075
    00076   return(ret);
    00077
    00078 }
    00079
    00080
    00081 #ifdef PPRO_NT
    00082 med_int
    00083 __stdcall EDFCONL(med_int *fid, char *maa, unsigned int bidon,
    00084                   med_int *lon, med_int *mdim, med_int *con, med_int *mode_switch,
    00085                   med_int * pfltabtmp, med_int *psizetmp,
    00086                   med_int *type_ent,med_int *type_geo,
    00087                   med_int *type_con )
    00088 #else
    00089 med_int
    00090 nedfconl(med_int *fid, char *maa, med_int *lon,med_int *mdim,med_int *con,
    00091          med_int *mode_switch,
    00092          med_int * pfltabtmp, med_int *psizetmp,
    00093          med_int *type_ent,med_int *type_geo,med_int *type_con )
    00094 #endif
    00095 {
    00096   char *fn;
    00097   med_int ret;
    00098
    00099   fn = _MED2cstring(maa, (int) * lon);
    00100
    00101   if (!fn)
    00102     return(-1);
    00103
    00104   ret = (med_int) MEDconnLire((med_idt) *fid, fn,(med_int) *mdim,(med_int *) con,
    00105                               (med_mode_switch) *mode_switch,
    00106                               (med_int *) pfltabtmp, (med_size) *psizetmp,
    00107                               (med_entite_maillage) *type_ent,
    00108                               (med_geometrie_element) *type_geo,
    00109                               (med_connectivite) *type_con);
    00110
    00111   _MEDcstringFree(fn);
    00112
    00113   return(ret);
    00114 }
    00115
    00116
    00117 #ifdef PPRO_NT
    00118 med_int
    00119 __stdcall EDFCOOE(med_int *fid,char *maa,unsigned int bidon1,med_int *lon1,
    00120                   med_int *mdim, med_float * coo,med_int * modcoo, med_int *n,
    00121                   med_int *type_rep, char *nom,
    00122                   unsigned int bidon2, med_int *lon2,
    00123                   char *unit, unsigned int bidon3, med_int *lon3)
    00124 #else
    00125 med_int
    00126 nedfcooe(med_int *fid, char *maa, med_int *lon1, med_int *mdim,
    00127          med_float* coo,med_int *modcoo, med_int *n,
    00128          med_int *type_rep, char *nom, med_int *lon2,
    00129          char *unit, med_int *lon3)
    00130 #endif
    00131 {
    00132   med_int ret;
    00133   char *  fn1, *fn2, *fn3;
    00134   med_repere type_rep_c;
    00135
    00136   fn1 = _MED2cstring(maa, (int) * lon1);
    00137   fn2 = _MED1cstring(nom, (int) * lon2,(int) *mdim*MED_TAILLE_PNOM);
    00138   fn3 = _MED1cstring(unit, (int) * lon3,(int) *mdim*MED_TAILLE_PNOM);
    00139
    00140   if (!fn1 || !fn2 || !fn3)
    00141     return(-1);
    00142
    00143   type_rep_c = (med_repere) *type_rep;
    00144   ret = (med_int) MEDcoordEcr((med_idt) *fid, fn1, (med_int) *mdim,
    00145                               (med_float *) coo,(med_mode_switch)*modcoo,
    00146                               (med_int) *n,type_rep_c,
    00147                               fn2,fn3);
    00148   _MEDcstringFree(fn1);
    00149   _MEDcstringFree(fn2);
    00150   _MEDcstringFree(fn3);
    00151
    00152   return(ret);
    00153 }
    00154
    00155
    00156
    00157 #ifdef PPRO_NT
    00158 med_int
    00159 __stdcall EDFCOOL(med_int *fid, char *maa, unsigned int bidon1,
    00160                   med_int *lon1, med_int *mdim, med_float * coo, med_int * modcoo,
    00161                   med_int *numco, med_int * pfltabtmp, med_int * psize,
    00162                   med_int *type_rep, char *nom, unsigned int bidon2, char *unit,
    00163                   unsigned int bidon3)
    00164 #else
    00165 med_int
    00166 nedfcool(med_int *fid, char *maa,med_int *lon1,med_int *mdim,
    00167          med_float * coo,med_int * modcoo,
    00168          med_int * numco,med_int * pfltabtmp, med_int * psize,
    00169          med_int *type_rep, char *nom,
    00170          char *unit)
    00171 #endif
    00172 {
    00173   med_int ret;
    00174   char * fn1,* fs1,* fs2;
    00175   med_repere type_rep_c;
    00176   med_size lpsize;
    00177
    00178   lpsize = (med_size) *psize;
    00179
    00180   fn1 = _MED2cstring(maa, (int) * lon1);
    00181   fs1 = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*(*mdim)+1);
    00182   fs2 = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*(*mdim)+1);
    00183
    00184   if (!(fn1&&fs1&&fs2))
    00185     return(-1);
    00186
    00187   ret = (med_int) MEDcoordLire((med_idt) *fid, fn1, (med_int ) *mdim,
    00188                                (med_float *) coo,(med_mode_switch)*modcoo,
    00189                                (med_int) *numco, (med_int *) pfltabtmp, lpsize,
    00190                                &type_rep_c, fs1, fs2);
    00191
    00192   *type_rep = (med_int) type_rep_c;
    00193   strncpy(nom,fs1,MED_TAILLE_PNOM*(*mdim));
    00194   _MEDfstring(nom ,MED_TAILLE_PNOM*(*mdim));
    00195   strncpy(unit,fs2,MED_TAILLE_PNOM*(*mdim));
    00196   _MEDfstring(unit,MED_TAILLE_PNOM*(*mdim));
    00197
    00198   _MEDcstringFree(fn1);
    00199   free(fs1);
    00200   free(fs2);
    00201
    00202   return(ret);
    00203 }
    00204
    00205
    00206 #ifdef PPRO_NT
    00207 int
    00208 __stdcall EDFNOME (med_int *fid,char *maa, unsigned int bidon1, med_int *lon1,
    00209                    char *nom, unsigned int bidon2, med_int *lon2,
    00210                    med_int *n, med_int *type_ent,
    00211                    med_int *type_geo)
    00212
    00213 #else
    00214 med_int
    00215 nedfnome(med_int *fid,char *maa,med_int *lon1, char *nom,med_int *lon2,
    00216          med_int *n,med_int *type_ent,med_int *type_geo)
    00217 #endif
    00218 {
    00219   med_int ret;
    00220   char * fn1, *fn2;
    00221
    00222   fn1 = _MED2cstring(maa, (int) * lon1);
    00223   fn2 = _MED1cstring(nom, (int) * lon2,(int) *n*MED_TAILLE_PNOM);
    00224
    00225   if (!fn1 || !fn2)
    00226     return(-1);
    00227
    00228   ret = (med_int) MEDnomEcr((med_idt) *fid, fn1, fn2, (med_int) *n,
    00229                             (med_entite_maillage) *type_ent,
    00230                             (med_geometrie_element) *type_geo);
    00231
    00232   _MEDcstringFree(fn1);
    00233   _MEDcstringFree(fn2);
    00234
    00235   return(ret);
    00236 }
    00237
    00238 #ifdef PPRO_NT
    00239 med_int
    00240 __stdcall EDFNOML(med_int *fid,char *maa, unsigned int bidon1, med_int *lon1,
    00241                   char *nom , unsigned int bidon2, med_int *n,
    00242                   med_int *type_ent, med_int *type_geo)
    00243
    00244 #else
    00245 med_int
    00246 nedfnoml(med_int *fid,char *maa,med_int *lon1, char *nom,med_int *n,
    00247          med_int *type_ent,med_int *type_geo)
    00248 #endif
    00249 {
    00250   med_int ret;
    00251   char * fn1,* fs1;
    00252
    00253   fn1 = _MED2cstring(maa, (int) * lon1);
    00254   fs1 = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*(*n)+1);
    00255
    00256   if ( !(fn1&&fs1) )
    00257     return(-1);
    00258
    00259   ret = (med_int) MEDnomLire((med_idt) *fid, fn1, (char *) fs1, (med_int) *n,
    00260                              (med_entite_maillage) *type_ent,
    00261                              (med_geometrie_element) *type_geo);
    00262
    00263   strncpy(nom,fs1,MED_TAILLE_PNOM*(*n));
    00264   _MEDfstring(nom,MED_TAILLE_PNOM*(*n));
    00265
    00266   _MEDcstringFree(fn1);
    00267   free(fs1);
    00268
    00269   return(ret);
    00270 }
    00271
    00272
    00273 #ifdef PPRO_NT
    00274 med_int
    00275 __stdcall EDFNUME(med_int *fid,char *maa, unsigned int bidon1, med_int *lon1,
    00276                   med_int *num, med_int *n, med_int *type_ent,
    00277                   med_int *type_geo)
    00278 #else
    00279 med_int
    00280 nedfnume(med_int *fid,char *maa, med_int *lon1, med_int *num, med_int *n,
    00281          med_int *type_ent,med_int *type_geo)
    00282 #endif
    00283 {
    00284   med_int ret;
    00285   char * fn1;
    00286
    00287   fn1 = _MED2cstring(maa, (int) * lon1);
    00288
    00289   if (!fn1 )
    00290     return(-1);
    00291
    00292   ret = (med_int) MEDnumEcr((med_idt) *fid, fn1, (med_int *) num, (med_int)*n,
    00293                             (med_entite_maillage) *type_ent,
    00294                             (med_geometrie_element) *type_geo);
    00295
    00296   _MEDcstringFree(fn1);
    00297
    00298   return(ret);
    00299 }
    00300
    00301
    00302 #ifdef PPRO_NT
    00303 int
    00304 __stdcall EDFNUML(med_int *fid,char *maa, unsigned int bidon1, med_int *lon1,
    00305                   med_int *num , med_int *n, med_int *type_ent,
    00306                   med_int *type_geo)
    00307 #else
    00308 med_int
    00309 nedfnuml(med_int *fid,char *maa, med_int *lon1, med_int *num , med_int *n,
    00310          med_int *type_ent,med_int *type_geo)
    00311 #endif
    00312 {
    00313   med_int ret;
    00314   char *fn1;
    00315
    00316   fn1 = _MED2cstring(maa, (int) * lon1);
    00317
    00318   if (!fn1 )
    00319     return(-1);
    00320
    00321   ret = (med_int) MEDnumLire((med_idt) *fid, fn1, (med_int *) num,(med_int)*n,
    00322                              (med_entite_maillage) *type_ent,
    00323                              (med_geometrie_element) *type_geo);
    00324
    00325   _MEDcstringFree(fn1);
    00326
    00327   return(ret);
    00328 }
    00329
    00330 #ifdef PPRO_NT
    00331 med_int
    00332 __stdcall EDFNEMA (med_int *fid, char *maa, unsigned int bidon, med_int *lon,
    00333                    med_int *quoi, med_int *typ_ent, med_int *typ_geo,
    00334                    med_int *typ_conn)
    00335 #else
    00336 med_int
    00337 nedfnema(med_int *fid, char *maa, med_int *lon, med_int *quoi,
    00338          med_int *typ_ent, med_int *typ_geo,med_int *typ_conn)
    00339 #endif
    00340 {
    00341   med_int ret;
    00342   char *fn1;
    00343
    00344   fn1 = _MED2cstring(maa, (int) * lon);
    00345
    00346   if (!fn1 )
    00347     return(-1);
    00348
    00349   ret = (med_int) MEDnEntMaa((med_idt) *fid, fn1, (med_table) *quoi,
    00350                              (med_entite_maillage) *typ_ent,
    00351                              (med_geometrie_element) *typ_geo,
    00352                              (med_connectivite) *typ_conn);
    00353
    00354   _MEDcstringFree(fn1);
    00355
    00356   return(ret);
    00357 }
    00358
    00359
    00360 #ifdef PPRO_NT
    00361 med_int
    00362 __stdcall EDFPGCE(med_int *fid, char *maa, unsigned int bidon,med_int *lon,
    00363                   med_int *index, med_int *ni, med_int *con,
    00364                   med_int *type_ent,med_int *type_con)
    00365 #else
    00366 med_int
    00367 nedfpgce(med_int *fid, char *maa, med_int *lon,
    00368          med_int *index, med_int *ni, med_int *con,
    00369          med_int *type_ent,med_int *type_con)
    00370 #endif
    00371 {
    00372   char *fn;
    00373   med_int ret;
    00374
    00375   fn = _MED2cstring(maa, (int) * lon);
    00376
    00377   if (!fn)
    00378     return(-1);
    00379
    00380   ret = (med_int) MEDpolygoneConnEcr((med_idt) *fid,fn,(med_int *) index,(med_int) *ni,
    00381                                      (med_int *)con,(med_entite_maillage)*type_ent,
    00382                                      (med_connectivite) *type_con);
    00383
    00384   _MEDcstringFree(fn);
    00385
    00386   return(ret);
    00387 }
    00388
    00389
    00390 #ifdef PPRO_NT
    00391 med_int
    00392 __stdcall EDFPGCL(med_int *fid, char *maa, unsigned int bidon,med_int *lon,
    00393                   med_int *index, med_int *ni, med_int *con,
    00394                   med_int *type_ent,med_int *type_con)
    00395 #else
    00396 med_int
    00397 nedfpgcl(med_int *fid, char *maa, med_int *lon,
    00398          med_int *index, med_int *ni, med_int *con,
    00399          med_int *type_ent,med_int *type_con)
    00400 #endif
    00401 {
    00402   char *fn;
    00403   med_int ret;
    00404
    00405   fn = _MED2cstring(maa, (int) * lon);
    00406
    00407   if (!fn)
    00408     return(-1);
    00409
    00410   ret = (med_int) MEDpolygoneConnLire((med_idt) *fid, fn,
    00411                                       (med_int *) index,(med_int) *ni,(med_int *) con,
    00412                                       (med_entite_maillage) *type_ent,
    00413                                       (med_connectivite) *type_con);
    00414
    00415   _MEDcstringFree(fn);
    00416
    00417   return(ret);
    00418 }
    00419
    00420 #ifdef PPRO_NT
    00421 med_int
    00422 __stdcall EDFPYGI(med_int *fid, char *maa, unsigned int bidon,med_int *lon,
    00423                   med_int *type_ent,med_int *type_con,med_int *consize)
    00424 #else
    00425 med_int
    00426 nedfpygi(med_int *fid, char *maa, med_int *lon,
    00427          med_int *type_ent,med_int *type_con,med_int *consize)
    00428 #endif
    00429 {
    00430   char *fn;
    00431   med_int ret;
    00432
    00433   fn = _MED2cstring(maa, (int) * lon);
    00434
    00435   if (!fn)
    00436     return(-1);
    00437
    00438   ret = (med_int) MEDpolygoneInfo((med_idt) *fid, fn,
    00439                                   (med_entite_maillage) *type_ent,
    00440                                   (med_connectivite) *type_con,
    00441                                   (med_int *) consize);
    00442
    00443   _MEDcstringFree(fn);
    00444
    00445   return(ret);
    00446 }
    00447
    00448
    00449 #ifdef PPRO_NT
    00450 med_int
    00451 __stdcall EDFPECE(med_int *fid, char *maa, unsigned int bidon,med_int *lon,
    00452                   med_int *indexp, med_int *np,med_int *indexf, med_int *nf,
    00453                   med_int *con,med_int *type_con)
    00454 #else
    00455 med_int
    00456 nedfpece(med_int *fid, char *maa, med_int *lon,
    00457          med_int *indexp, med_int *np,med_int *indexf, med_int *nf,
    00458          med_int *con,med_int *type_con)
    00459 #endif
    00460 {
    00461   char *fn;
    00462   med_int ret;
    00463
    00464   fn = _MED2cstring(maa, (int) * lon);
    00465
    00466   if (!fn)
    00467     return(-1);
    00468
    00469   ret = (med_int) MEDpolyedreConnEcr((med_idt) *fid,fn,(med_int *)indexp,(med_int) *np,
    00470                                      (med_int *)indexf,(med_int) *nf,(med_int *)con,
    00471                                      (med_connectivite) *type_con);
    00472
    00473   _MEDcstringFree(fn);
    00474
    00475   return(ret);
    00476 }
    00477
    00478
    00479 #ifdef PPRO_NT
    00480 med_int
    00481 __stdcall EDFPECL(med_int *fid, char *maa, unsigned int bidon,med_int *lon,
    00482                   med_int *indexp, med_int *np,
    00483                   med_int * indexf,med_int *nf,
    00484                   med_int *con,med_int *type_con)
    00485 #else
    00486 med_int
    00487 nedfpecl(med_int *fid, char *maa, med_int *lon,
    00488          med_int *indexp, med_int *np,
    00489          med_int *indexf,med_int *nf,
    00490          med_int *con,med_int *type_con)
    00491 #endif
    00492 {
    00493   char *fn;
    00494   med_int ret;
    00495
    00496   fn = _MED2cstring(maa, (int) * lon);
    00497
    00498   if (!fn)
    00499     return(-1);
    00500
    00501   ret = (med_int) MEDpolyedreConnLire((med_idt) *fid, fn,
    00502                                       (med_int *) indexp,(med_int) *np,
    00503                                       (med_int *) indexf,(med_int) *nf,
    00504                                       (med_int *) con,
    00505                                       (med_connectivite) *type_con);
    00506
    00507   _MEDcstringFree(fn);
    00508
    00509   return(ret);
    00510 }
    00511
    00512 #ifdef PPRO_NT
    00513 med_int
    00514 __stdcall EDFPYEI(med_int *fid, char *maa, unsigned int bidon,med_int *lon,
    00515                   med_int *type_con,med_int *nf,med_int *consize)
    00516 #else
    00517 med_int
    00518 nedfpyei(med_int *fid, char *maa, med_int *lon,
    00519          med_int *type_con,med_int *nf,med_int *consize)
    00520 #endif
    00521 {
    00522   char *fn;
    00523   med_int ret;
    00524
    00525   fn = _MED2cstring(maa, (int) * lon);
    00526
    00527   if (!fn)
    00528     return(-1);
    00529
    00530   ret = (med_int) MEDpolyedreInfo((med_idt) *fid, fn,
    00531                                   (med_connectivite) *type_con,
    00532                                   (med_int *) nf,
    00533                                   (med_int *) consize);
    00534
    00535   _MEDcstringFree(fn);
    00536
    00537   return(ret);
    00538 }
    00539
    00540
    00541 #ifdef PPRO_NT
    00542 med_int
    00543 __stdcall EDFICOE(med_int *fid,char *maa,unsigned int bidon1,med_int *lon1,
    00544                   med_int *mdim, med_float * indices,med_int *n,
    00545                   med_int *axe, char *comp,
    00546                   unsigned int bidon2, med_int *lon2,
    00547                   char *unit, unsigned int bidon3, med_int *lon3)
    00548 #else
    00549 med_int
    00550 nedficoe(med_int *fid, char *maa, med_int *lon1, med_int *mdim,
    00551          med_float* indices,med_int *n,
    00552          med_int *axe, char *comp, med_int *lon2,
    00553          char *unit, med_int *lon3)
    00554 #endif
    00555 {
    00556   med_int ret;
    00557   char *  fn1, *fn2, *fn3;
    00558
    00559   fn1 = _MED2cstring(maa, (int) * lon1);
    00560   fn2 = _MED1cstring(comp, (int) * lon2,(int) *mdim*MED_TAILLE_PNOM);
    00561   fn3 = _MED1cstring(unit, (int) * lon3,(int) *mdim*MED_TAILLE_PNOM);
    00562
    00563   if (!fn1 || !fn2 || !fn3)
    00564     return(-1);
    00565
    00566   ret = (med_int) MEDindicesCoordEcr((med_idt) *fid, fn1, (med_int) *mdim,
    00567                                      (med_float *) indices,(med_int) *n,
    00568                                      (med_int) *axe,fn2,fn3);
    00569
    00570   _MEDcstringFree(fn1);
    00571   _MEDcstringFree(fn2);
    00572   _MEDcstringFree(fn3);
    00573
    00574   return(ret);
    00575 }
    00576
    00577 #ifdef PPRO_NT
    00578 med_int
    00579 __stdcall EDFICOL(med_int *fid,char *maa,unsigned int bidon1,med_int *lon1,
    00580                   med_int *mdim, med_float * indices,med_int *n,
    00581                   med_int *axe, char *comp,
    00582                   unsigned int bidon2, med_int *lon2,
    00583                   char *unit, unsigned int bidon3, med_int *lon3)
    00584 #else
    00585 med_int
    00586 nedficol(med_int *fid, char *maa, med_int *lon1, med_int *mdim,
    00587          med_float* indices,med_int *n,
    00588          med_int *axe, char *comp, med_int *lon2,
    00589          char *unit, med_int *lon3)
    00590 #endif
    00591 {
    00592   med_int ret;
    00593   char *  fn1, *fs1, *fs2;
    00594
    00595   fn1 = _MED2cstring(maa, (int) * lon1);
    00596   fs1 = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM+1);
    00597   fs2 = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM+1);
    00598
    00599   if (!(fn1 && fs1 && fs2))
    00600     return(-1);
    00601
    00602   ret = (med_int) MEDindicesCoordLire((med_idt) *fid, fn1, (med_int) *mdim,
    00603                                       (med_float *) indices,(med_int) *n,
    00604                                       (med_int) *axe,fs1,fs2);
    00605
    00606   strncpy(comp,fs1,MED_TAILLE_PNOM);
    00607   _MEDfstring(comp ,MED_TAILLE_PNOM);
    00608   strncpy(unit,fs2,MED_TAILLE_PNOM);
    00609   _MEDfstring(unit,MED_TAILLE_PNOM);
    00610
    00611   _MEDcstringFree(fn1);
    00612   free(fs1);
    00613   free(fs2);
    00614
    00615   return(ret);
    00616 }
    00617
    00618 #ifdef PPRO_NT
    00619 med_int
    00620 __stdcall EDFSCOE(med_int *fid,char *maa, unsigned int bidon1, med_int *lon1,
    00621                   med_int * mdim,med_int *structure)
    00622 #else
    00623 med_int
    00624 nedfscoe(med_int *fid,char *maa, med_int *lon1, med_int *mdim, med_int *structure)
    00625 #endif
    00626 {
    00627   med_int ret;
    00628   char * fn1;
    00629
    00630   fn1 = _MED2cstring(maa, (int) * lon1);
    00631
    00632   if (!fn1 )
    00633     return(-1);
    00634
    00635   ret = (med_int) MEDstructureCoordEcr((med_idt) *fid, fn1, (med_int) *mdim, (med_int *) structure);
    00636
    00637   _MEDcstringFree(fn1);
    00638
    00639   return(ret);
    00640 }
    00641
    00642
    00643 #ifdef PPRO_NT
    00644 med_int
    00645 __stdcall EDFSCOL(med_int *fid,char *maa, unsigned int bidon1, med_int *lon1,
    00646                   med_int *mdim,med_int *structure)
    00647 #else
    00648 med_int
    00649 nedfscol(med_int *fid,char *maa, med_int *lon1, med_int *mdim,med_int *structure)
    00650 #endif
    00651 {
    00652   med_int ret;
    00653   char * fn1;
    00654
    00655   fn1 = _MED2cstring(maa, (int) * lon1);
    00656
    00657   if (!fn1 )
    00658     return(-1);
    00659
    00660   ret = (med_int) MEDstructureCoordLire((med_idt) *fid, fn1, (med_int) *mdim, (med_int *) structure);
    00661
    00662   _MEDcstringFree(fn1);
    00663
    00664   return(ret);
    00665 }