00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include <stdlib.h>
00022 #include <stdio.h>
00023 #include <stdarg.h>
00024 #include "fortran_macros.h"
00025 #include "cgnslib.h"
00026 #include "cgns_header.h"
00027 #include <string.h>
00028 #include "cgns_io.h"
00029 #ifdef MEM_DEBUG
00030 #include "cg_malloc.h"
00031 #endif
00032
00033
00034
00035
00036
00037 static void string_2_C_string(char *string, int string_length,
00038 char *c_string, int max_len, int *ierr) {
00039 int i, iend;
00040
00041 if (string == NULL || c_string == NULL) {
00042 cgi_error ("NULL string pointer");
00043 *ierr = CG_ERROR;
00044 return;
00045 }
00046
00048 for (iend = string_length-1; iend >= 0; iend--) {
00049 if (string[iend] != ' ') break;
00050 }
00051 if (iend >= max_len) iend = max_len - 1;
00052
00054 for (i = 0; i <= iend; i++)
00055 c_string[i] = string[i];
00056
00058 c_string[i] = '\0';
00059 *ierr = CG_OK;
00060 }
00061
00062
00063
00064 static void string_2_F_string(char *c_string, char *string,
00065 int string_length, int *ierr) {
00066 int i, len;
00067
00068 if (c_string == NULL || string == NULL) {
00069 cgi_error ("NULL string pointer");
00070 *ierr = CG_ERROR;
00071 return;
00072 }
00073 len = strlen(c_string);
00074 if (len > string_length) len = string_length;
00075
00076 for (i = 0; i < len; i++)
00077 string[i] = c_string[i];
00078 while (i < string_length)
00079 string[i++] = ' ';
00080 *ierr = CG_OK;
00081 }
00082
00083
00084
00085
00086
00087 CGNSDLL void FMNAME(cg_is_cgns_f, CG_IS_CGNS_F) (STR_PSTR(filename),
00088 int *file_type, int *ier STR_PLEN(filename)) {
00089 int length;
00090 char *c_name;
00091
00092 length = (int) STR_LEN(filename);
00093 c_name = CGNS_NEW(char, length+1);
00094
00095 string_2_C_string(STR_PTR(filename), STR_LEN(filename), c_name, length, ier);
00096 if (*ier == 0)
00097 *ier = cg_is_cgns(c_name, file_type);
00098 CGNS_FREE(c_name);
00099 }
00100
00101
00102
00103 CGNSDLL void FMNAME(cg_open_f, CG_OPEN_F) (STR_PSTR(filename), int *mode,
00104 int *fn, int *ier STR_PLEN(filename)) {
00105 int length;
00106 char *c_name;
00107
00108 length = (int) STR_LEN(filename);
00109 c_name = CGNS_NEW(char, length+1);
00110
00111 string_2_C_string(STR_PTR(filename), STR_LEN(filename), c_name, length, ier);
00112 if (*ier) {
00113 free (c_name);
00114 return;
00115 }
00116 #if DEBUG_FTOC
00117 printf("filename='%s'\n",c_name);
00118 #endif
00119 *ier = cg_open(c_name, *mode, fn);
00120 free(c_name);
00121 }
00122
00123
00124
00125 CGNSDLL void FMNAME(cg_version_f, CG_VERSION_F) (int *fn, float *FileVersion, int *ier) {
00126
00127 *ier = cg_version(*fn, FileVersion);
00128 }
00129
00130
00131
00132 CGNSDLL void FMNAME(cg_close_f, CG_CLOSE_F) (int *fn, int *ier) {
00133
00134 *ier = cg_close(*fn);
00135 }
00136
00137
00138
00139 CGNSDLL void FMNAME(cg_save_as_f, CG_SAVE_AS_F) (int *fn, STR_PSTR(filename),
00140 int *file_type, int *follow_links, int *ier STR_PLEN(filename)) {
00141 int length;
00142 char *c_name;
00143
00144 length = (int) STR_LEN(filename);
00145 c_name = CGNS_NEW(char, length+1);
00146
00147 string_2_C_string(STR_PTR(filename), STR_LEN(filename), c_name, length, ier);
00148 if (*ier) {
00149 free (c_name);
00150 return;
00151 }
00152 *ier = cg_save_as(*fn, c_name, *file_type, *follow_links);
00153 free(c_name);
00154 }
00155
00156
00157
00158 CGNSDLL void FMNAME(cg_set_file_type_f, CG_SET_FILE_TYPE_F) (int *ft, int *ier) {
00159
00160 *ier = cg_set_file_type(*ft);
00161 }
00162
00163
00164
00165 CGNSDLL void FMNAME(cg_get_file_type_f, CG_GET_FILE_TYPE_F) (int *fn, int *ft, int *ier) {
00166
00167 *ier = cg_get_file_type(*fn, ft);
00168 }
00169
00170
00171
00172 CGNSDLL void FMNAME(cg_set_compress_f, CG_SET_COMPRESS_F) (int *cmpr, int *ier) {
00173
00174 *ier = cg_set_compress(*cmpr);
00175 }
00176
00177
00178
00179 CGNSDLL void FMNAME(cg_get_compress_f, CG_GET_COMPRESS_F) (int *cmpr, int *ier) {
00180
00181 *ier = cg_get_compress(cmpr);
00182 }
00183
00184
00185
00186 CGNSDLL void FMNAME(cg_set_path_f, CG_SET_PATH_F) (STR_PSTR(pathname),
00187 int *ier STR_PLEN(pathname)) {
00188 int length;
00189 char *c_name;
00190
00191 length = (int) STR_LEN(pathname);
00192 c_name = CGNS_NEW(char, length+1);
00193
00194 string_2_C_string(STR_PTR(pathname), STR_LEN(pathname), c_name, length, ier);
00195 if (*ier) {
00196 free (c_name);
00197 return;
00198 }
00199 *ier = cg_set_path(c_name);
00200 free(c_name);
00201 }
00202
00203
00204
00205 CGNSDLL void FMNAME(cg_add_path_f, CG_ADD_PATH_F) (STR_PSTR(pathname),
00206 int *ier STR_PLEN(pathname)) {
00207 int length;
00208 char *c_name;
00209
00210 length = (int) STR_LEN(pathname);
00211 c_name = CGNS_NEW(char, length+1);
00212
00213 string_2_C_string(STR_PTR(pathname), STR_LEN(pathname), c_name, length, ier);
00214 if (*ier) {
00215 free (c_name);
00216 return;
00217 }
00218 *ier = cg_add_path(c_name);
00219 free(c_name);
00220 }
00221
00222
00223
00224
00225
00226 CGNSDLL void FMNAME(cg_nbases_f, CG_NBASES_F) (int *fn, int *nbases, int *ier) {
00227
00228 *ier = cg_nbases(*fn, nbases);
00229 }
00230
00231
00232
00233 CGNSDLL void FMNAME(cg_base_read_f, CG_BASE_READ_F) (int *fn, int *B, STR_PSTR(basename),
00234 int *cell_dim, int *phys_dim, int *ier STR_PLEN(basename)) {
00235 char c_name[CGIO_MAX_NAME_LENGTH+1];
00236
00237 *ier = cg_base_read(*fn, *B, c_name, cell_dim, phys_dim);
00238 if (!*ier)
00239 string_2_F_string(c_name, STR_PTR(basename), STR_LEN(basename), ier);
00240 }
00241
00242
00243
00244 CGNSDLL void FMNAME(cg_base_id_f, CG_BASE_ID_F) (int *fn, int *B, double *base_id,
00245 int *ier) {
00246
00247 *ier = cg_base_id(*fn, *B, base_id);
00248 }
00249
00250
00251
00252 CGNSDLL void FMNAME(cg_base_write_f, CG_BASE_WRITE_F) (int *fn, STR_PSTR(basename),
00253 int *cell_dim, int *phys_dim, int *B, int *ier STR_PLEN(basename)) {
00254 char c_name[CGIO_MAX_NAME_LENGTH+1];
00255
00256 string_2_C_string(STR_PTR(basename), STR_LEN(basename),
00257 c_name, CGIO_MAX_NAME_LENGTH, ier);
00258 if (*ier) return;
00259 #if DEBUG_FTOC
00260 printf("\nbasename='%s'\n", c_name);
00261 printf("cell_dim=%d\n",*cell_dim);
00262 printf("phys_dim=%d\n",*phys_dim);
00263 #endif
00264
00265 *ier = cg_base_write(*fn, c_name, *cell_dim, *phys_dim, B);
00266 }
00267
00268
00269
00270
00271
00272 CGNSDLL void FMNAME(cg_nzones_f, CG_NZONES_F) (int *fn, int *B, int *nzones, int *ier) {
00273
00274 *ier = cg_nzones(*fn, *B, nzones);
00275 }
00276
00277
00278
00279 CGNSDLL void FMNAME(cg_zone_type_f, CG_ZONE_TYPE_F) (int *fn, int *B, int *Z,
00280 ZoneType_t *type, int *ier) {
00281
00282 *ier = cg_zone_type(*fn, *B, *Z, type);
00283 }
00284
00285
00286
00287 CGNSDLL void FMNAME(cg_zone_read_f, CG_ZONE_READ_F) (int *fn, int *B, int *Z,
00288 STR_PSTR(zonename), int *size, int *ier STR_PLEN(zonename)) {
00289 char c_name[CGIO_MAX_NAME_LENGTH+1];
00290
00291 *ier = cg_zone_read(*fn, *B, *Z, c_name, size);
00292 if (!*ier)
00293 string_2_F_string(c_name, STR_PTR(zonename), STR_LEN(zonename), ier);
00294 }
00295
00296
00297
00298 CGNSDLL void FMNAME(cg_zone_id_f, CG_ZONE_ID_F) (int *fn, int *B, int *Z, double *zone_id,
00299 int *ier) {
00300
00301 *ier = cg_zone_id(*fn, *B, *Z, zone_id);
00302 }
00303
00304
00305
00306 CGNSDLL void FMNAME(cg_zone_write_f, CG_ZONE_WRITE_F) (int *fn, int *B, STR_PSTR(zonename),
00307 int *size, ZoneType_t *type, int *Z, int *ier STR_PLEN(zonename)) {
00308 char c_name[CGIO_MAX_NAME_LENGTH+1];
00309
00310 string_2_C_string(STR_PTR(zonename), STR_LEN(zonename),
00311 c_name, CGIO_MAX_NAME_LENGTH, ier);
00312 if (*ier) return;
00313
00314 #if DEBUG_FTOC
00315 printf("\n zonename='%s'\n", c_name);
00316 #endif
00317
00318 *ier = cg_zone_write(*fn, *B, c_name, size, *type, Z);
00319 }
00320
00321
00322
00323
00324
00325 CGNSDLL void FMNAME(cg_nfamilies_f, CG_NFAMILIES_F) (int *fn, int *B,
00326 int *nfamilies, int *ier) {
00327
00328 *ier = cg_nfamilies(*fn, *B, nfamilies);
00329 }
00330
00331
00332
00333 CGNSDLL void FMNAME(cg_family_read_f, CG_FAMILY_READ_F) (int *fn, int *B, int *F,
00334 STR_PSTR(family_name), int *nboco, int *ngeos, int *ier
00335 STR_PLEN(family_name)) {
00336 char c_name[CGIO_MAX_NAME_LENGTH+1];
00337
00338 *ier = cg_family_read(*fn, *B, *F, c_name, nboco, ngeos);
00339 if (!*ier)
00340 string_2_F_string(c_name, STR_PTR(family_name), STR_LEN(family_name), ier);
00341 }
00342
00343
00344
00345 CGNSDLL void FMNAME(cg_family_write_f, CG_FAMILY_WRITE_F) (int *fn, int *B,
00346 STR_PSTR(family_name), int *F, int *ier STR_PLEN(family_name)) {
00347 char c_name[CGIO_MAX_NAME_LENGTH+1];
00348
00349 string_2_C_string(STR_PTR(family_name), STR_LEN(family_name),
00350 c_name, CGIO_MAX_NAME_LENGTH, ier);
00351 if (!*ier)
00352 *ier = cg_family_write(*fn, *B, c_name, F);
00353 }
00354
00355
00356
00357
00358
00359 CGNSDLL void FMNAME(cg_fambc_read_f, CG_FAMBC_READ_F) (int *fn, int *B, int *F,
00360 int *BC, STR_PSTR(fambc_name), BCType_t *bocotype, int *ier
00361 STR_PLEN(fambc_name)) {
00362 char c_name[CGIO_MAX_NAME_LENGTH+1];
00363
00364 *ier = cg_fambc_read(*fn, *B, *F, *BC, c_name, bocotype);
00365 if (!*ier)
00366 string_2_F_string(c_name, STR_PTR(fambc_name), STR_LEN(fambc_name), ier);
00367 }
00368
00369
00370
00371 CGNSDLL void FMNAME(cg_fambc_write_f, CG_FAMBC_WRITE_F) (int *fn, int *B, int *F,
00372 STR_PSTR(fambc_name), BCType_t *bocotype, int *BC, int *ier
00373 STR_PLEN(fambc_name)) {
00374 char c_name[CGIO_MAX_NAME_LENGTH+1];
00375
00376 string_2_C_string(STR_PTR(fambc_name), STR_LEN(fambc_name),
00377 c_name, CGIO_MAX_NAME_LENGTH, ier);
00378 if (!*ier)
00379 *ier = cg_fambc_write(*fn, *B, *F, c_name, *bocotype, BC);
00380 }
00381
00382
00383
00384
00385
00386 CGNSDLL void FMNAME(cg_geo_read_f, CG_GEO_READ_F) (int *fn, int *B, int *F, int *G,
00387 STR_PSTR(geo_name), STR_PSTR(geo_file), STR_PSTR(CAD_name),
00388 int *npart, int *ier STR_PLEN(geo_name) STR_PLEN(geo_file)
00389 STR_PLEN(CAD_name)) {
00390 char c_geo_name[CGIO_MAX_NAME_LENGTH+1];
00391 char c_CAD_name[CGIO_MAX_NAME_LENGTH+1];
00392 char *c_geo_file;
00393
00394 *ier = cg_geo_read(*fn, *B, *F, *G, c_geo_name, &c_geo_file,
00395 c_CAD_name, npart);
00396 if (*ier) return;
00397
00398 string_2_F_string(c_geo_name, STR_PTR(geo_name), STR_LEN(geo_name), ier);
00399 if (*ier) return;
00400 string_2_F_string(c_CAD_name, STR_PTR(CAD_name), STR_LEN(CAD_name), ier);
00401 if (*ier) return;
00402 string_2_F_string(c_geo_file, STR_PTR(geo_file), STR_LEN(geo_file), ier);
00403 free(c_geo_file);
00404 }
00405
00406
00407
00408 CGNSDLL void FMNAME(cg_geo_write_f, CG_GEO_WRITE_F) (int *fn, int *B, int *F,
00409 STR_PSTR(geo_name), STR_PSTR(geo_file), STR_PSTR(CAD_name),
00410 int *G, int *ier STR_PLEN(geo_name) STR_PLEN(geo_file)
00411 STR_PLEN(CAD_name)) {
00412 char c_geo_name[CGIO_MAX_NAME_LENGTH+1];
00413 char c_CAD_name[CGIO_MAX_NAME_LENGTH+1];
00414 char *c_geo_file;
00415 int length;
00416
00417
00418 string_2_C_string(STR_PTR(geo_name), STR_LEN(geo_name),
00419 c_geo_name, CGIO_MAX_NAME_LENGTH, ier);
00420 if (*ier) return;
00421 string_2_C_string(STR_PTR(CAD_name), STR_LEN(CAD_name),
00422 c_CAD_name, CGIO_MAX_NAME_LENGTH, ier);
00423 if (*ier) return;
00424
00425 length = STR_LEN(geo_file);
00426 c_geo_file = CGNS_NEW(char, length+1);
00427 string_2_C_string(STR_PTR(geo_file), STR_LEN(geo_file),
00428 c_geo_file, length, ier);
00429 if (!*ier)
00430 *ier = cg_geo_write(*fn, *B, *F, c_geo_name, c_geo_file, c_CAD_name, G);
00431 free(c_geo_file);
00432 }
00433
00434
00435
00436
00437
00438 CGNSDLL void FMNAME(cg_part_read_f, CG_PART_READ_F) (int *fn, int *B, int *F, int *G,
00439 int *P, STR_PSTR(part_name), int *ier STR_PLEN(part_name)) {
00440 char c_part_name[CGIO_MAX_NAME_LENGTH+1];
00441
00442 *ier = cg_part_read(*fn, *B, *F, *G, *P, c_part_name);
00443 if (!*ier)
00444 string_2_F_string(c_part_name, STR_PTR(part_name), STR_LEN(part_name), ier);
00445 }
00446
00447
00448
00449 CGNSDLL void FMNAME(cg_part_write_f, CG_PART_WRITE_F) (int *fn, int *B, int *F,
00450 int *G, STR_PSTR(part_name), int *P, int *ier STR_PLEN(part_name)) {
00451 char c_part_name[CGIO_MAX_NAME_LENGTH+1];
00452
00453
00454 string_2_C_string(STR_PTR(part_name), STR_LEN(part_name),
00455 c_part_name, CGIO_MAX_NAME_LENGTH, ier);
00456 if (!*ier)
00457 *ier = cg_part_write(*fn, *B, *F, *G, c_part_name, P);
00458 }
00459
00460
00461
00462
00463
00464 CGNSDLL void FMNAME(cg_ndiscrete_f, CG_NDISCRETE_F) (int *fn, int *B, int *Z,
00465 int *ndiscrete, int *ier) {
00466
00467 *ier = cg_ndiscrete(*fn, *B, *Z, ndiscrete);
00468 }
00469
00470
00471
00472 CGNSDLL void FMNAME(cg_discrete_read_f, CG_DISCRETE_READ_F) (int *fn, int *B, int *Z,
00473 int *D, STR_PSTR(discrete_name), int *ier STR_PLEN(discrete_name)) {
00474 char c_name[CGIO_MAX_NAME_LENGTH+1];
00475
00476 *ier = cg_discrete_read(*fn, *B, *Z, *D, c_name);
00477 if (!*ier)
00478 string_2_F_string(c_name, STR_PTR(discrete_name), STR_LEN(discrete_name), ier);
00479 }
00480
00481
00482
00483 CGNSDLL void FMNAME(cg_discrete_write_f, CG_DISCRETE_WRITE_F) (int *fn, int *B, int *Z,
00484 STR_PSTR(discrete_name), int *D, int *ier STR_PLEN(discrete_name)) {
00485 char c_name[CGIO_MAX_NAME_LENGTH+1];
00486
00487 string_2_C_string(STR_PTR(discrete_name), STR_LEN(discrete_name),
00488 c_name, CGIO_MAX_NAME_LENGTH, ier);
00489 if (*ier) return;
00490 #if DEBUG_FTOC
00491 printf(" discrete_name='%s'\n", c_name);
00492 #endif
00493
00494 *ier = cg_discrete_write(*fn, *B, *Z, c_name, D);
00495 }
00496
00497
00498
00499
00500
00501 CGNSDLL void FMNAME(cg_ncoords_f, CG_NCOORDS_F) (int *fn, int *B, int *Z, int *ncoords,
00502 int *ier) {
00503
00504 *ier = cg_ncoords(*fn, *B, *Z, ncoords);
00505 }
00506
00507
00508
00509 CGNSDLL void FMNAME(cg_coord_info_f, CG_COORD_INFO_F) (int *fn, int *B, int *Z, int *C,
00510 DataType_t *type, STR_PSTR(coordname), int *ier STR_PLEN(coordname)) {
00511 char c_name[CGIO_MAX_NAME_LENGTH+1];
00512
00513 *ier = cg_coord_info(*fn, *B, *Z, *C, type, c_name);
00514 if (!*ier)
00515 string_2_F_string(c_name, STR_PTR(coordname), STR_LEN(coordname), ier);
00516 }
00517
00518
00519
00520 CGNSDLL void FMNAME(cg_coord_read_f, CG_COORD_READ_F) (int *fn, int *B, int *Z,
00521 STR_PSTR(coordname), DataType_t *type, int *rmin, int *rmax,
00522 void *coord, int *ier STR_PLEN(coordname)) {
00523 char c_name[CGIO_MAX_NAME_LENGTH+1];
00524
00525 string_2_C_string(STR_PTR(coordname), STR_LEN(coordname),
00526 c_name, CGIO_MAX_NAME_LENGTH, ier);
00527 if (*ier) return;
00528
00529 #if DEBUG_FTOC
00530 printf("coordname='%s'\n", c_name);
00531 #endif
00532
00533 *ier = cg_coord_read(*fn, *B, *Z, c_name, *type, rmin, rmax, coord);
00534 }
00535
00536
00537
00538 CGNSDLL void FMNAME(cg_coord_id_f, CG_COORD_ID_F) (int *fn, int *B, int *Z, int *C,
00539 double *coord_id, int *ier) {
00540
00541 *ier = cg_coord_id(*fn, *B, *Z, *C, coord_id);
00542 }
00543
00544
00545
00546 CGNSDLL void FMNAME(cg_coord_write_f, CG_COORD_WRITE_F) (int *fn, int *B, int *Z,
00547 DataType_t *type, STR_PSTR(coordname), void *coord, int *C, int *ier
00548 STR_PLEN(coordname)) {
00549 char c_name[CGIO_MAX_NAME_LENGTH+1];
00550
00551 string_2_C_string(STR_PTR(coordname), STR_LEN(coordname),
00552 c_name, CGIO_MAX_NAME_LENGTH, ier);
00553 if (*ier) return;
00554 #if DEBUG_FTOC
00555 printf(" coordname='%s'\n", c_name);
00556 #endif
00557
00558 *ier = cg_coord_write(*fn, *B, *Z, *type, c_name, coord, C);
00559 }
00560
00561
00562
00563 CGNSDLL void FMNAME(cg_coord_partial_write_f, CG_COORD_PARTIAL_WRITE_F) (int *fn,
00564 int *B, int *Z, DataType_t *type, STR_PSTR(coordname), int *rmin,
00565 int *rmax, void *coord, int *C, int *ier STR_PLEN(coordname))
00566 {
00567 char c_name[CGIO_MAX_NAME_LENGTH+1];
00568
00569 string_2_C_string(STR_PTR(coordname), STR_LEN(coordname),
00570 c_name, CGIO_MAX_NAME_LENGTH, ier);
00571 if (*ier) return;
00572 #if DEBUG_FTOC
00573 printf(" coordname='%s'\n", c_name);
00574 #endif
00575
00576 *ier = cg_coord_partial_write(*fn, *B, *Z, *type, c_name, rmin, rmax,
00577 coord, C);
00578 }
00579
00580
00581
00582
00583
00584 CGNSDLL void FMNAME(cg_nsections_f, CG_NSECTIONS_F) (int *fn, int *B, int *Z,
00585 int *nsections, int *ier) {
00586
00587 *ier = cg_nsections(*fn, *B, *Z, nsections);
00588 }
00589
00590
00591
00592 CGNSDLL void FMNAME(cg_section_read_f, CG_SECTION_READ_F) (int *fn, int *B, int *Z,
00593 int *E, STR_PSTR(section_name), ElementType_t *type, int *start, int *end,
00594 int *nbndry, int *parent_flag, int *ier STR_PLEN(section_name)) {
00595 char c_name[CGIO_MAX_NAME_LENGTH+1];
00596
00597 *ier = cg_section_read(*fn, *B, *Z, *E, c_name, type, start,
00598 end, nbndry, parent_flag);
00599 if (!*ier)
00600 string_2_F_string(c_name, STR_PTR(section_name), STR_LEN(section_name), ier);
00601 }
00602
00603
00604
00605 CGNSDLL void FMNAME(cg_elements_read_f, CG_ELEMENTS_READ_F) (int *fn, int *B, int *Z,
00606 int *E, int *elements, int *parent_data, int *ier) {
00607
00608 *ier = cg_elements_read(*fn, *B, *Z, *E, elements, parent_data);
00609 }
00610
00611
00612
00613 CGNSDLL void FMNAME(cg_elementdatasize_f, CG_ELEMENTDATASIZE_F) (int *fn, int *B, int *Z,
00614 int *E, int *ElementDataSize, int *ier) {
00615
00616 *ier = cg_ElementDataSize(*fn, *B, *Z, *E, ElementDataSize);
00617 }
00618
00619
00620
00621 CGNSDLL void FMNAME(cg_elementpartialsize_f, CG_ELEMENTPARTIALSIZE_F) (int *fn, int *B, int *Z,
00622 int *E, int *start, int *end, int *ElementDataSize, int *ier) {
00623
00624 *ier = cg_ElementPartialSize(*fn, *B, *Z, *E, *start, *end, ElementDataSize);
00625 }
00626
00627
00628
00629 CGNSDLL void FMNAME(cg_section_write_f, CG_SECTION_WRITE_F) (int *fn, int *B, int *Z,
00630 STR_PSTR(section_name), ElementType_t *type, int *start, int *end, int *nbndry,
00631 int *elements, int *S, int *ier STR_PLEN(section_name)) {
00632 char c_name[CGIO_MAX_NAME_LENGTH+1];
00633
00634
00635 string_2_C_string(STR_PTR(section_name), STR_LEN(section_name),
00636 c_name, CGIO_MAX_NAME_LENGTH, ier);
00637 if (!*ier)
00638 *ier = cg_section_write(*fn, *B, *Z, c_name, *type, *start, *end,
00639 *nbndry, elements, S);
00640 }
00641
00642
00643
00644 CGNSDLL void FMNAME(cg_parent_data_write_f, CG_PARENT_DATA_WRITE_F) (int *fn, int *B,
00645 int *Z, int *S, int *parent_data, int *ier) {
00646
00647 *ier = cg_parent_data_write(*fn, *B, *Z, *S, parent_data);
00648 }
00649
00650
00651
00652 CGNSDLL void FMNAME(cg_section_partial_write_f, CG_SECTION_PARTIAL_WRITE_F) (int *fn,
00653 int *B, int *Z, STR_PSTR(section_name), ElementType_t *type, int *start,
00654 int *end, int *nbndry, int *elements, int *S,
00655 int *ier STR_PLEN(section_name))
00656 {
00657 char c_name[CGIO_MAX_NAME_LENGTH+1];
00658
00659
00660 string_2_C_string(STR_PTR(section_name), STR_LEN(section_name),
00661 c_name, CGIO_MAX_NAME_LENGTH, ier);
00662 if (!*ier)
00663 *ier = cg_section_partial_write(*fn, *B, *Z, c_name, *type, *start,
00664 *end, *nbndry, elements, S);
00665 }
00666
00667
00668
00669 CGNSDLL void FMNAME(cg_parent_data_partial_write_f, CG_PARENT_DATA_PARTIAL_WRITE_F)
00670 (int *fn, int *B, int *Z, int *S, int *rmin, int *rmax, int *parent_data,
00671 int *ier)
00672 {
00673 *ier = cg_parent_data_partial_write(*fn, *B, *Z, *S, *rmin, *rmax,
00674 parent_data);
00675 }
00676
00677
00678
00679
00680
00681 CGNSDLL void FMNAME(cg_nsols_f, CG_NSOLS_F) (int *fn, int *B, int *Z, int *nsols, int *ier) {
00682
00683 *ier = cg_nsols(*fn, *B, *Z, nsols);
00684 }
00685
00686
00687
00688 CGNSDLL void FMNAME(cg_sol_info_f, CG_SOL_INFO_F) (int *fn, int *B, int *Z, int *S,
00689 STR_PSTR(solname), GridLocation_t *location, int *ier STR_PLEN(solname)) {
00690 char c_name[CGIO_MAX_NAME_LENGTH+1];
00691
00692 *ier = cg_sol_info(*fn, *B, *Z, *S, c_name, location);
00693 if (!*ier)
00694 string_2_F_string(c_name, STR_PTR(solname), STR_LEN(solname), ier);
00695 }
00696
00697
00698
00699 CGNSDLL void FMNAME(cg_sol_id_f, CG_SOL_ID_F) (int *fn, int *B, int *Z, int *S,
00700 double *sol_id, int *ier) {
00701
00702 *ier = cg_sol_id(*fn, *B, *Z, *S, sol_id);
00703 }
00704
00705
00706
00707 CGNSDLL void FMNAME(cg_sol_write_f, CG_SOL_WRITE_F)(int *fn, int *B, int *Z, STR_PSTR(solname),
00708 GridLocation_t *location, int *S, int *ier STR_PLEN(solname)) {
00709 char c_name[CGIO_MAX_NAME_LENGTH+1];
00710
00711 string_2_C_string(STR_PTR(solname), STR_LEN(solname),
00712 c_name, CGIO_MAX_NAME_LENGTH, ier);
00713 if (*ier) return;
00714 #if DEBUG_FTOC
00715 printf("\n solname='%s'\n", c_name);
00716 #endif
00717
00718 *ier = cg_sol_write(*fn, *B, *Z, c_name, *location, S);
00719 }
00720
00721
00722
00723
00724
00725 CGNSDLL void FMNAME(cg_nfields_f, CG_NFIELDS_F) (int *fn, int *B, int *Z, int *S,
00726 int *nfields, int *ier) {
00727
00728 *ier = cg_nfields(*fn, *B, *Z, *S, nfields);
00729 }
00730
00731
00732
00733 CGNSDLL void FMNAME(cg_field_info_f, CG_FIELD_INFO_F) (int *fn, int *B, int *Z, int *S,
00734 int *F, DataType_t *type, STR_PSTR(fieldname), int *ier STR_PLEN(fieldname)) {
00735 char c_name[CGIO_MAX_NAME_LENGTH+1];
00736
00737 *ier = cg_field_info(*fn, *B, *Z, *S, *F, type, c_name);
00738 if (!*ier)
00739 string_2_F_string(c_name, STR_PTR(fieldname), STR_LEN(fieldname), ier);
00740 }
00741
00742
00743
00744 CGNSDLL void FMNAME(cg_field_read_f, CG_FIELD_READ_F) (int *fn, int *B, int *Z, int *S,
00745 STR_PSTR(fieldname), DataType_t *type, int *rmin, int *rmax,
00746 void *field_ptr, int *ier STR_PLEN(fieldname)) {
00747 char c_name[CGIO_MAX_NAME_LENGTH+1];
00748
00749 string_2_C_string(STR_PTR(fieldname), STR_LEN(fieldname),
00750 c_name, CGIO_MAX_NAME_LENGTH, ier);
00751 if (*ier) return;
00752 #if DEBUG_FTOC
00753 printf("fieldname='%s'\n", c_name);
00754 #endif
00755
00756 *ier = cg_field_read(*fn, *B, *Z, *S, c_name, *type, rmin, rmax, field_ptr);
00757 }
00758
00759
00760
00761 CGNSDLL void FMNAME(cg_field_id_f, CG_FIELD_ID_F) (int *fn, int *B, int *Z, int *S, int *F,
00762 double *field_id, int *ier) {
00763
00764 *ier = cg_field_id(*fn, *B, *Z, *S, *F, field_id);
00765 }
00766
00767
00768
00769 CGNSDLL void FMNAME(cg_field_write_f, CG_FIELD_WRITE_F) (int *fn, int *B, int *Z, int *S,
00770 DataType_t *type, STR_PSTR(fieldname), void *field_ptr, int *F,
00771 int *ier STR_PLEN(fieldname)) {
00772 char c_name[CGIO_MAX_NAME_LENGTH+1];
00773
00774 string_2_C_string(STR_PTR(fieldname), STR_LEN(fieldname),
00775 c_name, CGIO_MAX_NAME_LENGTH, ier);
00776 if (*ier) return;
00777 #if DEBUG_FTOC
00778 printf(" fieldname='%s'\n", c_name);
00779 #endif
00780
00781 *ier = cg_field_write(*fn, *B, *Z, *S, *type, c_name, field_ptr, F);
00782 }
00783
00784
00785
00786 CGNSDLL void FMNAME(cg_field_partial_write_f, CG_FIELD_PARTIAL_WRITE_F) (int *fn,
00787 int *B, int *Z, int *S, DataType_t *type, STR_PSTR(fieldname),
00788 int *rmin, int *rmax, void *field_ptr, int *F,
00789 int *ier STR_PLEN(fieldname)) {
00790 char c_name[CGIO_MAX_NAME_LENGTH+1];
00791
00792 string_2_C_string(STR_PTR(fieldname), STR_LEN(fieldname),
00793 c_name, CGIO_MAX_NAME_LENGTH, ier);
00794 if (*ier) return;
00795 #if DEBUG_FTOC
00796 printf(" fieldname='%s'\n", c_name);
00797 #endif
00798
00799 *ier = cg_field_partial_write(*fn, *B, *Z, *S, *type, c_name, rmin,
00800 rmax, field_ptr, F);
00801 }
00802
00803
00804
00805
00806
00807 CGNSDLL void FMNAME(cg_nholes_f, CG_NHOLES_F) (int *fn, int *B, int *Z, int *nholes,
00808 int *ier) {
00809
00810 *ier = cg_nholes(*fn, *B, *Z, nholes);
00811 }
00812
00813
00814
00815 CGNSDLL void FMNAME(cg_hole_info_f, CG_HOLE_INFO_F) (int *fn, int *B, int *Z, int *I,
00816 STR_PSTR(holename), GridLocation_t *location, PointSetType_t *ptset_type,
00817 int *nptsets, int *npnts, int *ier STR_PLEN(holename)) {
00818 char c_name[CGIO_MAX_NAME_LENGTH+1];
00819
00820 *ier = cg_hole_info(*fn, *B, *Z, *I, c_name, location,
00821 ptset_type, nptsets, npnts);
00822 if (!*ier)
00823 string_2_F_string(c_name, STR_PTR(holename), STR_LEN(holename), ier);
00824 }
00825
00826
00827
00828 CGNSDLL void FMNAME(cg_hole_read_f, CG_HOLE_READ_F) (int *fn, int *B, int *Z, int *I,
00829 int *pnts, int *ier) {
00830
00831 *ier = cg_hole_read(*fn, *B, *Z, *I, pnts);
00832 }
00833
00834
00835
00836 CGNSDLL void FMNAME(cg_hole_id_f, CG_HOLE_ID_F) (int *fn, int *B, int *Z, int *I,
00837 double *hole_id, int *ier) {
00838
00839 *ier = cg_hole_id(*fn, *B, *Z, *I, hole_id);
00840 }
00841
00842
00843
00844 CGNSDLL void FMNAME(cg_hole_write_f, CG_HOLE_WRITE_F) (int *fn, int *B, int *Z,
00845 STR_PSTR(holename), GridLocation_t *location, PointSetType_t *ptset_type,
00846 int *nptsets, int *npnts, int *pnts, int *I, int *ier STR_PLEN(holename)) {
00847 char c_name[CGIO_MAX_NAME_LENGTH+1];
00848
00849 string_2_C_string(STR_PTR(holename), STR_LEN(holename),
00850 c_name, CGIO_MAX_NAME_LENGTH, ier);
00851 if (*ier) return;
00852 #if DEBUG_FTOC
00853 printf("holename='%s'\n", c_name);
00854 #endif
00855
00856 *ier = cg_hole_write(*fn, *B, *Z, c_name, *location, *ptset_type,
00857 *nptsets, *npnts, pnts, I);
00858 }
00859
00860
00861
00862
00863
00864 CGNSDLL void FMNAME(cg_nconns_f, CG_NCONNS_F) (int *fn, int *B, int *Z, int *nconns,
00865 int *ier) {
00866
00867 *ier = cg_nconns(*fn, *B, *Z, nconns);
00868 }
00869
00870
00871
00872 CGNSDLL void FMNAME(cg_conn_info_f, CG_CONN_INFO_F) (int *fn, int *B, int *Z, int *I,
00873 STR_PSTR(connectname), GridLocation_t *location, GridConnectivityType_t *type,
00874 PointSetType_t *ptset_type, int *npnts, STR_PSTR(donorname),
00875 ZoneType_t *donor_zonetype, PointSetType_t *donor_ptset_type,
00876 DataType_t *donor_datatype, int *ndata_donor, int *ier
00877 STR_PLEN(connectname) STR_PLEN(donorname)) {
00878 char cc_name[CGIO_MAX_NAME_LENGTH+1], dc_name[CGIO_MAX_NAME_LENGTH+1];
00879
00880 *ier = cg_conn_info(*fn, *B, *Z, *I, cc_name, location,
00881 type, ptset_type, npnts, dc_name,
00882 donor_zonetype, donor_ptset_type, donor_datatype,
00883 ndata_donor);
00884 if (!*ier) {
00885 string_2_F_string(cc_name, STR_PTR(connectname), STR_LEN(connectname), ier);
00886 if (*ier) return;
00887 string_2_F_string(dc_name, STR_PTR(donorname), STR_LEN(donorname), ier);
00888 }
00889 }
00890
00891
00892
00893 CGNSDLL void FMNAME(cg_conn_read_f, CG_CONN_READ_F) (int *fn, int *B, int *Z, int *I,
00894 int *pnts, DataType_t *donor_datatype, void *donor_data, int *ier) {
00895
00896 *ier = cg_conn_read(*fn, *B, *Z, *I, pnts, *donor_datatype, donor_data);
00897 }
00898
00899
00900
00901 CGNSDLL void FMNAME(cg_conn_read_short_f, CG_CONN_READ_SHORT_F) (int *fn, int *B,
00902 int *Z, int *I, int *pnts, int *ier) {
00903
00904 *ier = cg_conn_read_short(*fn, *B, *Z, *I, pnts);
00905 }
00906
00907
00908
00909 CGNSDLL void FMNAME(cg_conn_id_f, CG_CONN_ID_F) (int *fn, int *B, int *Z, int *I,
00910 double *conn_id, int *ier) {
00911
00912 *ier = cg_conn_id(*fn, *B, *Z, *I, conn_id);
00913 }
00914
00915
00916
00917 CGNSDLL void FMNAME(cg_conn_write_f, CG_CONN_WRITE_F) (int *fn, int *B, int *Z,
00918 STR_PSTR(connectname), GridLocation_t *location, GridConnectivityType_t *type,
00919 PointSetType_t *ptset_type, int *npnts, int *pnts, STR_PSTR(donorname),
00920 ZoneType_t *donor_zonetype, PointSetType_t *donor_ptset_type,
00921 DataType_t *donor_datatype, int *ndata_donor, void *donor_data, int *I,
00922 int *ier STR_PLEN(connectname) STR_PLEN(donorname)) {
00923 char cc_name[CGIO_MAX_NAME_LENGTH+1], dc_name[CGIO_MAX_NAME_LENGTH+1];
00924
00925 string_2_C_string(STR_PTR(connectname), STR_LEN(connectname),
00926 cc_name, CGIO_MAX_NAME_LENGTH, ier);
00927 if (*ier) return;
00928 string_2_C_string(STR_PTR(donorname), STR_LEN(donorname),
00929 dc_name, CGIO_MAX_NAME_LENGTH, ier);
00930 if (*ier) return;
00931
00932 #if DEBUG_FTOC
00933 printf("connectname='%s'\n", cc_name);
00934 printf("donorname='%s'\n", dc_name);
00935 #endif
00936
00937 *ier = cg_conn_write(*fn, *B, *Z, cc_name, *location, *type, *ptset_type,
00938 *npnts, pnts, dc_name, *donor_zonetype, *donor_ptset_type,
00939 *donor_datatype, *ndata_donor, donor_data, I);
00940 }
00941
00942
00943
00944 CGNSDLL void FMNAME(cg_conn_write_short_f, CG_CONN_WRITE_SHORT_F) (int *fn, int *B,
00945 int *Z, STR_PSTR(connectname), GridLocation_t *location,
00946 GridConnectivityType_t *type, PointSetType_t *ptset_type, int *npnts,
00947 int *pnts, STR_PSTR(donorname), int *I,
00948 int *ier STR_PLEN(connectname) STR_PLEN(donorname)) {
00949 char cc_name[CGIO_MAX_NAME_LENGTH+1], dc_name[CGIO_MAX_NAME_LENGTH+1];
00950
00951 string_2_C_string(STR_PTR(connectname), STR_LEN(connectname),
00952 cc_name, CGIO_MAX_NAME_LENGTH, ier);
00953 if (*ier) return;
00954 string_2_C_string(STR_PTR(donorname), STR_LEN(donorname),
00955 dc_name, CGIO_MAX_NAME_LENGTH, ier);
00956 if (*ier) return;
00957
00958 #if DEBUG_FTOC
00959 printf("connectname='%s'\n", cc_name);
00960 printf("donorname='%s'\n", dc_name);
00961 #endif
00962
00963 *ier = cg_conn_write_short(*fn, *B, *Z, cc_name, *location, *type,
00964 *ptset_type, *npnts, pnts, dc_name, I);
00965 }
00966
00967
00968
00969
00970
00971 CGNSDLL void FMNAME(cg_n1to1_f, CG_N1TO1_F) (int *fn, int *B, int *Z, int *n1to1,
00972 int *ier) {
00973
00974 *ier = cg_n1to1(*fn, *B, *Z, n1to1);
00975 }
00976
00977
00978
00979 CGNSDLL void FMNAME(cg_1to1_read_f, CG_1TO1_READ_F) (int *fn, int *B, int *Z, int *I,
00980 STR_PSTR(connectname), STR_PSTR(donorname), int *range, int *donor_range,
00981 int *transform, int *ier STR_PLEN(connectname) STR_PLEN(donorname)) {
00982 char cc_name[CGIO_MAX_NAME_LENGTH+1], dc_name[CGIO_MAX_NAME_LENGTH+1];
00983
00984 *ier = cg_1to1_read(*fn, *B, *Z, *I, cc_name, dc_name,
00985 range, donor_range, transform);
00986 if (!*ier) {
00987 string_2_F_string(cc_name, STR_PTR(connectname), STR_LEN(connectname), ier);
00988 if (*ier) return;
00989 string_2_F_string(dc_name, STR_PTR(donorname), STR_LEN(donorname), ier);
00990 }
00991 }
00992
00993
00994
00995 CGNSDLL void FMNAME(cg_1to1_id_f, CG_1TO1_ID_F) (int *fn, int *B, int *Z, int *I,
00996 double *one21_id, int *ier) {
00997
00998 *ier = cg_1to1_id(*fn, *B, *Z, *I, one21_id);
00999 }
01000
01001
01002
01003 CGNSDLL void FMNAME(cg_1to1_write_f, CG_1TO1_WRITE_F) (int *fn, int *B, int *Z,
01004 STR_PSTR(connectname), STR_PSTR(donorname), int *range,
01005 int *donor_range, int *transform, int *I, int *ier
01006 STR_PLEN(connectname) STR_PLEN(donorname)) {
01007 char cc_name[CGIO_MAX_NAME_LENGTH+1], dc_name[CGIO_MAX_NAME_LENGTH+1];
01008
01009 string_2_C_string(STR_PTR(connectname), STR_LEN(connectname),
01010 cc_name, CGIO_MAX_NAME_LENGTH, ier);
01011 if (*ier) return;
01012 string_2_C_string(STR_PTR(donorname), STR_LEN(donorname),
01013 dc_name, CGIO_MAX_NAME_LENGTH, ier);
01014 if (*ier) return;
01015
01016 #if DEBUG_FTOC
01017 printf("connectname='%s'\n", cc_name);
01018 printf("donorname='%s'\n", dc_name);
01019 #endif
01020
01021 *ier = cg_1to1_write(*fn, *B, *Z, cc_name, dc_name, range,
01022 donor_range, transform, I);
01023 }
01024
01025
01026
01027
01028
01029 CGNSDLL void FMNAME(cg_n1to1_global_f, CG_N1TO1_GLOBAL_F) (int *fn, int *B,
01030 int *n1to1_global, int *ier) {
01031
01032 *ier = cg_n1to1_global(*fn, *B, n1to1_global);
01033 }
01034
01035
01036
01037 CGNSDLL void FMNAME(cg_1to1_read_global_f, CG_1TO1_READ_GLOBAL_F) (int *fn, int *B,
01038 STR_PSTR(connectname), STR_PSTR(zonename), STR_PSTR(donorname),
01039 int *range, int *donor_range, int *transform, int *ier
01040 STR_PLEN(connectname) STR_PLEN(zonename) STR_PLEN(donorname)) {
01041 int n, i, step, len, ierr;
01042 int cell_dim, phys_dim;
01043 int Ndim;
01044 int Nglobal;
01045 char **c_connectname, **c_zonename, **c_donorname;
01046 char basename[CGIO_MAX_NAME_LENGTH+1];
01047 int **c_range, **c_donor_range;
01048 int **c_transform;
01049
01050
01051 *ier=0;
01052
01053
01054 if (cg_base_read(*fn, *B, basename, &cell_dim, &phys_dim)) {
01055 *ier=1;
01056 return;
01057 }
01058
01059 Ndim = cell_dim;
01060
01061
01062 if (cg_n1to1_global(*fn, *B, &Nglobal)) {
01063 *ier=1;
01064 return;
01065 }
01066 if (Nglobal<1) {
01067 cgi_error("Number of interface must equal 1 or more");
01068 *ier=1;
01069 return;
01070 }
01071
01072 if ((c_connectname = (char **)malloc(Nglobal*sizeof(char *)))==NULL ||
01073 (c_zonename = (char **)malloc(Nglobal*sizeof(char *)))==NULL ||
01074 (c_donorname = (char **)malloc(Nglobal*sizeof(char *)))==NULL ||
01075 (c_range = (int **) malloc(Nglobal*sizeof(int *)))==NULL ||
01076 (c_donor_range = (int **) malloc(Nglobal*sizeof(int *)))==NULL ||
01077 (c_transform = (int **) malloc(Nglobal*sizeof(int *)))==NULL) {
01078 cgi_error("Error allocating memory...");
01079 *ier = 1;
01080 return;
01081 }
01082 len = CGIO_MAX_NAME_LENGTH+1;
01083 for (n=0; n<Nglobal; n++) {
01084 if ((c_connectname[n] = (char *)malloc(len*sizeof(char)))==NULL ||
01085 (c_zonename[n] = (char *)malloc(len*sizeof(char)))==NULL ||
01086 (c_donorname[n] = (char *)malloc(len*sizeof(char)))==NULL ||
01087 (c_range[n] = (int *) malloc(6*sizeof(int)))==NULL ||
01088 (c_donor_range[n] = (int *) malloc(6*sizeof(int)))==NULL ||
01089 (c_transform[n] = (int *) malloc(3*sizeof(int)))==NULL) {
01090 cgi_error("Error allocating memory...");
01091 *ier = 1;
01092 return;
01093 }
01094 }
01095
01096 if (cg_1to1_read_global(*fn, *B, (char **)c_connectname, (char **)c_zonename,
01097 (char **)c_donorname, (int **)c_range, (int **)c_donor_range, (int **)c_transform)){
01098 *ier=1;
01099 return;
01100 }
01101
01102 for (n=0; n<Nglobal; n++) {
01103 step = n*CGIO_MAX_NAME_LENGTH;
01104 string_2_F_string(c_connectname[n], STR_PTR(connectname)+step,
01105 CGIO_MAX_NAME_LENGTH, &ierr);
01106 string_2_F_string(c_zonename[n], STR_PTR(zonename) +step,
01107 CGIO_MAX_NAME_LENGTH, &ierr);
01108 string_2_F_string(c_donorname[n], STR_PTR(donorname) +step,
01109 CGIO_MAX_NAME_LENGTH, &ierr);
01110
01111 for (i=0; i<Ndim; i++) {
01112 step = Ndim*2*n;
01113 range[step+i] = c_range[n][i];
01114 range[step+i+Ndim] = c_range[n][i+Ndim];
01115 donor_range[step+i] = c_donor_range[n][i];
01116 donor_range[step+i+Ndim] = c_donor_range[n][i+Ndim];
01117 transform[Ndim*n+i] = c_transform[n][i];
01118 }
01119 #if DEBUG_FTOC
01120 printf("c_connectname[n]='%s'\n",c_connectname[n]);
01121 printf("c_zonename [n]='%s'\n",c_zonename[n]);
01122 printf("c_donorname [n]='%s'\n",c_donorname[n]);
01123 printf("..................12345678901234567890123456789012\n");
01124 #endif
01125 }
01126 #if DEBUG_FTOC
01127 printf("connectname='%s'\n",connectname);
01128 printf("zonename ='%s'\n",zonename);
01129 printf("donorname ='%s'\n",donorname);
01130 printf(".............+2345678901234567890123456789012+2345678901234567890123456789012\n");
01131 #endif
01132 for (n=0; n<Nglobal; n++) {
01133 free(c_connectname[n]);
01134 free(c_zonename[n]);
01135 free(c_donorname[n]);
01136 free(c_range[n]);
01137 free(c_donor_range[n]);
01138 free(c_transform[n]);
01139 }
01140 free(c_connectname);
01141 free(c_zonename);
01142 free(c_donorname);
01143 free(c_range);
01144 free(c_donor_range);
01145 free(c_transform);
01146 }
01147
01148
01149
01150
01151
01152 CGNSDLL void FMNAME(cg_nbocos_f, CG_NBOCOS_F) (int *fn, int *B, int *Z, int *nbocos,
01153 int *ier) {
01154
01155 *ier = cg_nbocos(*fn, *B, *Z, nbocos);
01156 }
01157
01158
01159
01160 CGNSDLL void FMNAME(cg_boco_info_f, CG_BOCO_INFO_F) (int *fn, int *B, int *Z, int *BC,
01161 STR_PSTR(boconame), BCType_t *bocotype, PointSetType_t *ptset_type,
01162 int *npnts, int *NormalIndex, int *NormalListFlag, DataType_t *NormalDataType,
01163 int *ndataset, int *ier STR_PLEN(boconame)) {
01164 char c_name[CGIO_MAX_NAME_LENGTH+1];
01165
01166 *ier = cg_boco_info(*fn, *B, *Z, *BC, c_name, bocotype,
01167 ptset_type, npnts, NormalIndex, NormalListFlag,
01168 NormalDataType, ndataset);
01169 if (!*ier)
01170 string_2_F_string(c_name, STR_PTR(boconame), STR_LEN(boconame), ier);
01171 }
01172
01173
01174
01175 CGNSDLL void FMNAME(cg_boco_read_f, CG_BOCO_READ_F) (int *fn, int *B, int *Z, int *BC,
01176 int *pnts, void *NormalList, int *ier) {
01177
01178 *ier = cg_boco_read(*fn, *B, *Z, *BC, pnts, NormalList);
01179 }
01180
01181
01182
01183 CGNSDLL void FMNAME(cg_boco_id_f, CG_BOCO_ID_F) (int *fn, int *B, int *Z, int *BC,
01184 double *boco_id, int *ier) {
01185
01186 *ier = cg_boco_id(*fn, *B, *Z, *BC, boco_id);
01187 }
01188
01189
01190
01191 CGNSDLL void FMNAME(cg_boco_write_f, CG_BOCO_WRITE_F) (int *fn, int *B, int *Z,
01192 STR_PSTR(boconame), BCType_t *bocotype, PointSetType_t *ptset_type,
01193 int *npnts, int *pnts, int *BC, int *ier STR_PLEN(boconame)) {
01194 char c_name[CGIO_MAX_NAME_LENGTH+1];
01195
01196 string_2_C_string(STR_PTR(boconame), STR_LEN(boconame),
01197 c_name, CGIO_MAX_NAME_LENGTH, ier);
01198 if (*ier) return;
01199 #if DEBUG_FTOC
01200 printf("boconame='%s'\n", c_name);
01201 #endif
01202
01203 *ier = cg_boco_write(*fn, *B, *Z, c_name, *bocotype, *ptset_type,
01204 *npnts, pnts, BC);
01205 }
01206
01207
01208
01209 CGNSDLL void FMNAME(cg_boco_normal_write_f, CG_BOCO_NORMAL_WRITE_F) (int *fn, int *B,
01210 int *Z, int *BC, int *NormalIndex, int *NormalListFlag,
01211 DataType_t *NormalDataType, void *NormalList, int *ier) {
01212
01213 *ier = cg_boco_normal_write(*fn, *B, *Z, *BC, NormalIndex,
01214 *NormalListFlag, *NormalDataType, NormalList);
01215 }
01216
01217
01218
01219
01220
01221 CGNSDLL void FMNAME(cg_bc_wallfunction_read_f, CG_BC_WALLFUNCTION_READ_F) (int *fn,
01222 int *B, int *Z, int *BC, WallFunctionType_t *WallFunctionType, int *ier) {
01223
01224 *ier = cg_bc_wallfunction_read(*fn, *B, *Z, *BC, WallFunctionType);
01225 }
01226
01227
01228
01229 CGNSDLL void FMNAME(cg_bc_wallfunction_write_f, CG_BC_WALLFUNCTION_WRITE_F) (int *fn,
01230 int *B, int *Z, int *BC, WallFunctionType_t *WallFunctionType, int *ier) {
01231
01232 *ier = cg_bc_wallfunction_write(*fn, *B, *Z, *BC, *WallFunctionType);
01233 }
01234
01235
01236
01237
01238
01239 CGNSDLL void FMNAME(cg_bc_area_read_f, CG_BC_AREA_READ_F) (int *fn, int *B,
01240 int *Z, int *BC, AreaType_t *AreaType, float *SurfaceArea,
01241 STR_PSTR(RegionName), int *ier STR_PLEN(RegionName)) {
01242 char c_name[CGIO_MAX_NAME_LENGTH+1];
01243
01244 *ier = cg_bc_area_read(*fn, *B, *Z, *BC, AreaType, SurfaceArea, c_name);
01245 if (!*ier)
01246 string_2_F_string(c_name, STR_PTR(RegionName), STR_LEN(RegionName), ier);
01247 }
01248
01249
01250
01251 CGNSDLL void FMNAME(cg_bc_area_write_f, CG_BC_AREA_WRITE_F) (int *fn, int *B,
01252 int *Z, int *BC, AreaType_t *AreaType, float *SurfaceArea,
01253 STR_PSTR(RegionName), int *ier STR_PLEN(RegionName)) {
01254 char c_name[CGIO_MAX_NAME_LENGTH+1];
01255 #if DEBUG_FTOC
01256 int n;
01257 #endif
01258
01259 string_2_C_string(STR_PTR(RegionName), STR_LEN(RegionName),
01260 c_name, CGIO_MAX_NAME_LENGTH, ier);
01261 if (*ier) return;
01262 #if DEBUG_FTOC
01263 printf("RegionName='");
01264 for (n=0; n<32; n++) printf("%c",*((STR_PTR(RegionName))+n));
01265 printf("', c_name='%s'\n", c_name);
01266 #endif
01267 *ier = cg_bc_area_write(*fn, *B, *Z, *BC, *AreaType, *SurfaceArea, c_name);
01268 }
01269
01270
01271
01272
01273
01274 CGNSDLL void FMNAME(cg_conn_periodic_read_f, CG_CONN_PERIODIC_READ_F) (int *fn,
01275 int *B, int *Z, int *I, float *RotationCenter, float *RotationAngle,
01276 float *Translation, int *ier) {
01277
01278 *ier = cg_conn_periodic_read(*fn, *B, *Z, *I, RotationCenter,
01279 RotationAngle, Translation);
01280 }
01281
01282
01283
01284 CGNSDLL void FMNAME(cg_conn_periodic_write_f, CG_CONN_PERIODIC_WRITE_F) (int *fn,
01285 int *B, int *Z, int *I, float *RotationCenter, float *RotationAngle,
01286 float *Translation, int *ier) {
01287
01288 *ier = cg_conn_periodic_write(*fn, *B, *Z, *I, RotationCenter,
01289 RotationAngle, Translation);
01290 }
01291
01292
01293
01294 CGNSDLL void FMNAME(cg_1to1_periodic_read_f, CG_1TO1_PERIODIC_READ_F) (int *fn,
01295 int *B, int *Z, int *I, float *RotationCenter, float *RotationAngle,
01296 float *Translation, int *ier) {
01297
01298 *ier = cg_1to1_periodic_read(*fn, *B, *Z, *I, RotationCenter,
01299 RotationAngle, Translation);
01300 }
01301
01302
01303
01304 CGNSDLL void FMNAME(cg_1to1_periodic_write_f, CG_1TO1_PERIODIC_WRITE_F) (int *fn,
01305 int *B, int *Z, int *I, float *RotationCenter, float *RotationAngle,
01306 float *Translation, int *ier) {
01307
01308 *ier = cg_1to1_periodic_write(*fn, *B, *Z, *I, RotationCenter,
01309 RotationAngle, Translation);
01310 }
01311
01312
01313
01314
01315
01316 CGNSDLL void FMNAME(cg_conn_average_read_f, CG_CONN_AVERAGE_READ_F) (int *fn, int *B,
01317 int *Z, int *I, AverageInterfaceType_t *AverageInterfaceType, int *ier) {
01318
01319 *ier = cg_conn_average_read(*fn, *B, *Z, *I, AverageInterfaceType);
01320 }
01321
01322
01323
01324 CGNSDLL void FMNAME(cg_conn_average_write_f, CG_CONN_AVERAGE_WRITE_F) (int *fn, int *B,
01325 int *Z, int *I, AverageInterfaceType_t *AverageInterfaceType, int *ier) {
01326
01327 *ier = cg_conn_average_write(*fn, *B, *Z, *I, *AverageInterfaceType);
01328 }
01329
01330
01331
01332 CGNSDLL void FMNAME(cg_1to1_average_read_f, CG_1TO1_AVERAGE_READ_F) (int *fn, int *B,
01333 int *Z, int *I, AverageInterfaceType_t *AverageInterfaceType, int *ier) {
01334
01335 *ier = cg_1to1_average_read(*fn, *B, *Z, *I, AverageInterfaceType);
01336 }
01337
01338
01339
01340 CGNSDLL void FMNAME(cg_1to1_average_write_f, CG_1TO1_AVERAGE_WRITE_F) (int *fn, int *B,
01341 int *Z, int *I, AverageInterfaceType_t *AverageInterfaceType, int *ier) {
01342
01343 *ier = cg_1to1_average_write(*fn, *B, *Z, *I, *AverageInterfaceType);
01344 }
01345
01346
01347
01348
01349
01350 CGNSDLL void FMNAME(cg_dataset_read_f, CG_DATASET_READ_F) (int *fn, int *B, int *Z,
01351 int *BC, int *DSet, STR_PSTR(Dataset_name), BCType_t *BCType,
01352 int *DirichletFlag, int *NeumannFlag, int *ier STR_PLEN(Dataset_name)) {
01353 char c_name[CGIO_MAX_NAME_LENGTH+1];
01354
01355 *ier = cg_dataset_read(*fn, *B, *Z, *BC, *DSet, c_name,
01356 BCType, DirichletFlag, NeumannFlag);
01357 if (!*ier)
01358 string_2_F_string(c_name, STR_PTR(Dataset_name), STR_LEN(Dataset_name), ier);
01359 }
01360
01361
01362
01363 CGNSDLL void FMNAME(cg_dataset_write_f, CG_DATASET_WRITE_F) (int *fn, int *B, int *Z,
01364 int *BC, STR_PSTR(Dataset_name), BCType_t *BCType, int *Dset,
01365 int *ier STR_PLEN(Dataset_name)) {
01366 char c_name[CGIO_MAX_NAME_LENGTH+1];
01367
01368 string_2_C_string(STR_PTR(Dataset_name), STR_LEN(Dataset_name),
01369 c_name, CGIO_MAX_NAME_LENGTH, ier);
01370 if (*ier) return;
01371 #if DEBUG_FTOC
01372 printf("Dataset_name='%s'\n", c_name);
01373 #endif
01374
01375 *ier = cg_dataset_write(*fn, *B, *Z, *BC, c_name, *BCType, Dset);
01376 }
01377
01378
01379
01380 CGNSDLL void FMNAME(cg_bcdataset_write_f, CG_BCDATASET_WRITE_F) (
01381 STR_PSTR(Dataset_name), BCType_t *BCType, BCDataType_t *BCDataType,
01382 int *ier STR_PLEN(Dataset_name))
01383 {
01384 char c_name[CGIO_MAX_NAME_LENGTH+1];
01385
01386 string_2_C_string(STR_PTR(Dataset_name), STR_LEN(Dataset_name),
01387 c_name, CGIO_MAX_NAME_LENGTH, ier);
01388 if (*ier) return;
01389 #if DEBUG_FTOC
01390 printf("Dataset_name='%s'\n", c_name);
01391 #endif
01392
01393 *ier = cg_bcdataset_write(c_name, *BCType, *BCDataType);
01394 }
01395
01396
01397
01398 CGNSDLL void FMNAME(cg_bcdataset_info_f, CG_BCDATASET_INFO_F) (int *ndataset,
01399 int *ier STR_PLEN(Dataset_name))
01400 {
01401 *ier = cg_bcdataset_info(ndataset);
01402 }
01403
01404
01405
01406 CGNSDLL void FMNAME(cg_bcdataset_read_f, CG_BCDATASET_READ_F) (int *index,
01407 STR_PSTR(Dataset_name), BCType_t *BCType,
01408 int *DirichletFlag, int *NeumannFlag, int *ier STR_PLEN(Dataset_name))
01409 {
01410 char c_name[CGIO_MAX_NAME_LENGTH+1];
01411
01412 *ier = cg_bcdataset_read(*index, c_name, BCType, DirichletFlag, NeumannFlag);
01413 if (!*ier)
01414 string_2_F_string(c_name, STR_PTR(Dataset_name), STR_LEN(Dataset_name), ier);
01415 }
01416
01417
01418
01419
01420
01421 CGNSDLL void FMNAME(cg_bcdata_write_f, CG_BCDATA_WRITE_F) (int *fn, int *B, int *Z,
01422 int *BC, int *Dset, BCDataType_t *BCDataType, int *ier) {
01423
01424 *ier = cg_bcdata_write(*fn, *B, *Z, *BC, *Dset, *BCDataType);
01425 }
01426
01427
01428
01429
01430
01431 CGNSDLL void FMNAME(cg_n_rigid_motions_f, CG_N_RIGID_MOTIONS_F) (int *fn, int *B,
01432 int *Z, int *n_rigid_motions, int *ier) {
01433
01434 *ier = cg_n_rigid_motions(*fn, *B, *Z, n_rigid_motions);
01435 }
01436
01437
01438
01439 CGNSDLL void FMNAME(cg_rigid_motion_read_f, CG_RIGID_MOTION_READ_F) (int *fn, int *B,
01440 int *Z, int *R, STR_PSTR(rmotion_name), RigidGridMotionType_t *type,
01441 int *ier STR_PLEN(rmotion_name)) {
01442 char c_name[CGIO_MAX_NAME_LENGTH+1];
01443
01444 *ier = cg_rigid_motion_read(*fn, *B, *Z, *R, c_name, type);
01445 if (!*ier)
01446 string_2_F_string(c_name, STR_PTR(rmotion_name), STR_LEN(rmotion_name), ier);
01447 }
01448
01449
01450
01451 CGNSDLL void FMNAME(cg_rigid_motion_write_f, CG_RIGID_MOTION_WRITE_F) (int *fn,
01452 int *B, int *Z, STR_PSTR(rmotion_name), RigidGridMotionType_t *type,
01453 int *R, int *ier STR_PLEN(rmotion_name)) {
01454 char c_name[CGIO_MAX_NAME_LENGTH+1];
01455
01456 string_2_C_string(STR_PTR(rmotion_name), STR_LEN(rmotion_name),
01457 c_name, CGIO_MAX_NAME_LENGTH, ier);
01458 if (!*ier)
01459 *ier = cg_rigid_motion_write(*fn, *B, *Z, c_name, *type, R);
01460 }
01461
01462
01463
01464
01465
01466 CGNSDLL void FMNAME(cg_n_arbitrary_motions_f, CG_N_ARBITRARY_MOTIONS_F) (int *fn,
01467 int *B, int *Z, int *n_arbitrary_motions, int *ier) {
01468
01469 *ier = cg_n_arbitrary_motions(*fn, *B, *Z, n_arbitrary_motions);
01470 }
01471
01472
01473
01474 CGNSDLL void FMNAME(cg_arbitrary_motion_read_f, CG_ARBITRARY_MOTION_READ_F)
01475 (int *fn, int *B, int *Z, int *A, STR_PSTR(amotion_name),
01476 ArbitraryGridMotionType_t *type, int *ier STR_PLEN(amotion_name)) {
01477 char c_name[CGIO_MAX_NAME_LENGTH+1];
01478
01479 *ier = cg_arbitrary_motion_read(*fn, *B, *Z, *A, c_name, type);
01480 if (!*ier)
01481 string_2_F_string(c_name, STR_PTR(amotion_name), STR_LEN(amotion_name), ier);
01482 }
01483
01484
01485
01486 CGNSDLL void FMNAME(cg_arbitrary_motion_write_f, CG_ARBITRARY_MOTION_WRITE_F) (int *fn,
01487 int *B, int *Z, STR_PSTR(amotion_name), ArbitraryGridMotionType_t *type,
01488 int *A, int *ier STR_PLEN(amotion_name)) {
01489 char c_name[CGIO_MAX_NAME_LENGTH+1];
01490
01491 string_2_C_string(STR_PTR(amotion_name), STR_LEN(amotion_name),
01492 c_name, CGIO_MAX_NAME_LENGTH, ier);
01493 if (!*ier)
01494 *ier = cg_arbitrary_motion_write(*fn, *B, *Z, c_name, *type, A);
01495 }
01496
01497
01498
01499
01500
01501 CGNSDLL void FMNAME(cg_ngrids_f, CG_NGRIDS_F) (int *fn, int *B, int *Z, int *ngrids,
01502 int *ier){
01503
01504 *ier = cg_ngrids(*fn, *B, *Z, ngrids);
01505 }
01506
01507
01508
01509 CGNSDLL void FMNAME(cg_grid_read_f, CG_GRID_READ_F) (int *fn, int *B, int *Z,
01510 int *G, STR_PSTR(gridname), int *ier STR_PLEN(gridname)) {
01511 char c_name[CGIO_MAX_NAME_LENGTH+1];
01512
01513 *ier = cg_grid_read(*fn, *B, *Z, *G, c_name);
01514 if (!*ier)
01515 string_2_F_string(c_name, STR_PTR(gridname), STR_LEN(gridname), ier);
01516 }
01517
01518
01519
01520 CGNSDLL void FMNAME(cg_grid_write_f, CG_GRID_WRITE_F) (int *fn, int *B, int *Z,
01521 STR_PSTR(gridname), int *G, int *ier STR_PLEN(gridname)) {
01522 char c_name[CGIO_MAX_NAME_LENGTH+1];
01523
01524 string_2_C_string(STR_PTR(gridname), STR_LEN(gridname),
01525 c_name, CGIO_MAX_NAME_LENGTH, ier);
01526 if (!*ier)
01527 *ier = cg_grid_write(*fn, *B, *Z, c_name, G);
01528 }
01529
01530
01531
01532
01533
01534 CGNSDLL void FMNAME(cg_simulation_type_read_f, CG_SIMULATION_TYPE_READ_F) (int *fn,
01535 int *B, SimulationType_t *type, int *ier) {
01536
01537 *ier = cg_simulation_type_read(*fn, *B, type);
01538 }
01539
01540
01541
01542 CGNSDLL void FMNAME(cg_simulation_type_write_f, CG_SIMULATION_TYPE_WRITE_F) (int *fn,
01543 int *B, SimulationType_t *type, int *ier) {
01544
01545 *ier = cg_simulation_type_write(*fn, *B, *type);
01546 }
01547
01548
01549
01550
01551
01552 CGNSDLL void FMNAME(cg_biter_read_f, CG_BITER_READ_F) (int *fn, int *B,
01553 STR_PSTR(bitername), int *nsteps, int *ier STR_PLEN(bitername)) {
01554 char c_name[CGIO_MAX_NAME_LENGTH+1];
01555
01556 *ier = cg_biter_read(*fn, *B, c_name, nsteps);
01557 if (!*ier)
01558 string_2_F_string(c_name, STR_PTR(bitername), STR_LEN(bitername), ier);
01559 }
01560
01561
01562
01563 CGNSDLL void FMNAME(cg_biter_write_f, CG_BITER_WRITE_F) (int *fn, int *B,
01564 STR_PSTR(bitername), int *nsteps, int *ier STR_PLEN(bitername)) {
01565 char c_name[CGIO_MAX_NAME_LENGTH+1];
01566
01567 string_2_C_string(STR_PTR(bitername), STR_LEN(bitername),
01568 c_name, CGIO_MAX_NAME_LENGTH, ier);
01569 if (!*ier)
01570 *ier = cg_biter_write(*fn, *B, c_name, *nsteps);
01571 }
01572
01573
01574
01575
01576
01577 CGNSDLL void FMNAME(cg_ziter_read_f, CG_ZITER_READ_F) (int *fn, int *B, int *Z,
01578 STR_PSTR(zitername), int *ier STR_PLEN(zitername)) {
01579 char c_name[CGIO_MAX_NAME_LENGTH+1];
01580
01581 *ier = cg_ziter_read(*fn, *B, *Z, c_name);
01582 if (!*ier)
01583 string_2_F_string(c_name, STR_PTR(zitername), STR_LEN(zitername), ier);
01584 }
01585
01586
01587
01588 CGNSDLL void FMNAME(cg_ziter_write_f, CG_ZITER_WRITE_F) (int *fn, int *B, int *Z,
01589 STR_PSTR(zitername), int *ier STR_PLEN(zitername)) {
01590 char c_name[CGIO_MAX_NAME_LENGTH+1];
01591
01592 string_2_C_string(STR_PTR(zitername), STR_LEN(zitername),
01593 c_name, CGIO_MAX_NAME_LENGTH, ier);
01594 if (!*ier)
01595 *ier = cg_ziter_write(*fn, *B, *Z, c_name);
01596 }
01597
01598
01599
01600
01601
01602 CGNSDLL void FMNAME(cg_gravity_read_f, CG_GRAVITY_READ_F) (int *fn, int *B,
01603 float *gravity_vector, int *ier) {
01604
01605 *ier = cg_gravity_read(*fn, *B, gravity_vector);
01606 }
01607
01608
01609
01610 CGNSDLL void FMNAME(cg_gravity_write_f, CG_GRAVITY_WRITE_F) (int *fn, int *B,
01611 float *gravity_vector, int *ier) {
01612
01613 *ier = cg_gravity_write(*fn, *B, gravity_vector);
01614 }
01615
01616
01617
01618
01619
01620 CGNSDLL void FMNAME(cg_axisym_read_f, CG_AXISYM_READ_F) (int *fn, int *B,
01621 float *ref_point, float *axis, int *ier) {
01622
01623 *ier = cg_axisym_read(*fn, *B, ref_point, axis);
01624 }
01625
01626
01627
01628 CGNSDLL void FMNAME(cg_axisym_write_f, CG_AXISYM_WRITE_F) (int *fn, int *B,
01629 float *ref_point, float *axis, int *ier) {
01630
01631 *ier = cg_axisym_write(*fn, *B, ref_point, axis);
01632 }
01633
01634
01635
01636
01637
01638 CGNSDLL void FMNAME(cg_rotating_read_f, CG_ROTATING_READ_F) (float *rot_rate,
01639 float *rot_center, int *ier) {
01640
01641 *ier = cg_rotating_read(rot_rate, rot_center);
01642 }
01643
01644
01645
01646 CGNSDLL void FMNAME(cg_rotating_write_f, CG_ROTATING_WRITE_F) (float *rot_rate,
01647 float *rot_center, int *ier) {
01648
01649 *ier = cg_rotating_write(rot_rate, rot_center);
01650 }
01651
01652
01653
01654
01655
01656 CGNSDLL void FMNAME(cg_ptset_info_f, CG_PTSET_INFO_F) (PointSetType_t *ptset_type, int *npnts, int *ier) {
01657
01658 *ier = cg_ptset_info(ptset_type, npnts);
01659 }
01660
01661
01662
01663 CGNSDLL void FMNAME(cg_ptset_read_f, CG_PTSET_READ_F) (int *pnts, int *ier) {
01664
01665 *ier = cg_ptset_read(pnts);
01666 }
01667
01668
01669
01670 CGNSDLL void FMNAME(cg_ptset_write_f, CG_PTSET_WRITE_F) (PointSetType_t *ptset_type, int *npnts, int *pnts, int *ier) {
01671
01672 *ier = cg_ptset_write(*ptset_type, *npnts, pnts);
01673 }
01674
01675
01676
01677
01678
01679 #ifdef WIN32_FORTRAN
01680 CGNSDLL void __stdcall cg_goto_f(int *fn, int *B, int *ier, ...) {
01681 #else
01682 CGNSDLL void FMNAME(cg_goto_f, CG_GOTO_F)(int *fn, int *B, int *ier, ...) {
01683 #endif
01684
01685 #ifdef _CRAY
01686 _fcd cray_string;
01687 #endif
01688 char *f_label[CG_MAX_GOTO_DEPTH], *label[CG_MAX_GOTO_DEPTH];
01689 int index[CG_MAX_GOTO_DEPTH], n, i, len[CG_MAX_GOTO_DEPTH];
01690 va_list ap;
01691
01692
01693
01694
01695 va_start(ap, ier);
01696
01697
01698 for (n = 0; n < CG_MAX_GOTO_DEPTH; n++) {
01699 #ifdef _CRAY
01700 cray_string = va_arg(ap, _fcd);
01701 f_label[n] = _fcdtocp(cray_string);
01702 len[n] = _fcdlen(cray_string);
01703 #else
01704 f_label[n] = va_arg(ap, char *);
01705 # ifdef WIN32_FORTRAN
01706
01707 len[n] = va_arg(ap, int);
01708 # endif
01709 #endif
01710 if (f_label[n][0] == ' ' || 0 == strncmp(f_label[n],"end",3) ||
01711 0 == strncmp(f_label[n],"END",3)) break;
01712
01713 index[n] = *(va_arg(ap, int *));
01714 if (index[n] < 0) {
01715 cgi_error("Incorrect input to function cg_goto_f");
01716 *ier = 1;
01717 return;
01718 }
01719 }
01720
01721 #if !defined(_CRAY) && !defined(WIN32_FORTRAN)
01722 for (i=0; i<n; i++) {
01723 len[i] = va_arg(ap, int);
01724 }
01725 #endif
01726 va_end(ap);
01727
01728
01729 for (i=0; i < n; i++) {
01730 label[i] = CGNS_NEW(char,len[i]+1);
01731 string_2_C_string(f_label[i], len[i], label[i], len[i], ier);
01732 }
01733
01734 #if DEBUG_GOTO
01735 printf("\nIn cg_ftoc.c: narguments=%d\n",n);
01736 for (i=0; i<n; i++) printf("\targ %d: '%s' #%d\n",i,label[i], index[i]);
01737 #endif
01738
01739 *ier = cgi_set_posit(*fn, *B, n, index, label);
01740
01741 for (i=0; i<n; i++) CGNS_FREE(label[i]);
01742 return;
01743 }
01744
01745
01746
01747 #ifdef WIN32_FORTRAN
01748 CGNSDLL void __stdcall cg_gorel_f(int *fn, int *ier, ...) {
01749 #else
01750 CGNSDLL void FMNAME(cg_gorel_f, CG_GOREL_F)(int *fn, int *ier, ...) {
01751 #endif
01752
01753 #ifdef _CRAY
01754 _fcd cray_string;
01755 #endif
01756 char *f_label[CG_MAX_GOTO_DEPTH], *label[CG_MAX_GOTO_DEPTH];
01757 int index[CG_MAX_GOTO_DEPTH], n, i, len[CG_MAX_GOTO_DEPTH];
01758 va_list ap;
01759
01760 if (posit == 0) {
01761 cgi_error ("position not set with cg_goto");
01762 *ier = CG_ERROR;
01763 return;
01764 }
01765 if (*fn != posit_file) {
01766 cgi_error("current position is in the wrong file");
01767 *ier = CG_ERROR;
01768 return;
01769 }
01770
01771
01772
01773
01774 va_start(ap, ier);
01775
01776
01777 for (n = 0; n < CG_MAX_GOTO_DEPTH; n++) {
01778 #ifdef _CRAY
01779 cray_string = va_arg(ap, _fcd);
01780 f_label[n] = _fcdtocp(cray_string);
01781 len[n] = _fcdlen(cray_string);
01782 #else
01783 f_label[n] = va_arg(ap, char *);
01784 # ifdef WIN32_FORTRAN
01785
01786 len[n] = va_arg(ap, int);
01787 # endif
01788 #endif
01789 if (f_label[n][0] == ' ' || 0 == strncmp(f_label[n],"end",3) ||
01790 0 == strncmp(f_label[n],"END",3)) break;
01791
01792 index[n] = *(va_arg(ap, int *));
01793 if (index[n] < 0) {
01794 cgi_error("Incorrect input to function cg_goto_f");
01795 *ier = 1;
01796 return;
01797 }
01798 }
01799
01800 #if !defined(_CRAY) && !defined(WIN32_FORTRAN)
01801 for (i=0; i<n; i++) {
01802 len[i] = va_arg(ap, int);
01803 }
01804 #endif
01805 va_end(ap);
01806
01807
01808 for (i=0; i < n; i++) {
01809 label[i] = CGNS_NEW(char,len[i]+1);
01810 string_2_C_string(f_label[i], len[i], label[i], len[i], ier);
01811 }
01812
01813 #if DEBUG_GOTO
01814 printf("\nIn cg_ftoc.c: narguments=%d\n",n);
01815 for (i=0; i<n; i++) printf("\targ %d: '%s' #%d\n",i,label[i], index[i]);
01816 #endif
01817
01818 *ier = cgi_update_posit(n, index, label);
01819
01820 for (i=0; i<n; i++) CGNS_FREE(label[i]);
01821 return;
01822 }
01823
01824
01825
01826 CGNSDLL void FMNAME(cg_gopath_f, CG_GOPATH_F) (int *fn,
01827 STR_PSTR(path), int *ier STR_PLEN(path)) {
01828 int length;
01829 char *c_path;
01830
01831 length = (int) STR_LEN(path);
01832 c_path = CGNS_NEW(char, length+1);
01833
01834 string_2_C_string(STR_PTR(path), STR_LEN(path), c_path, length, ier);
01835 if (*ier == 0)
01836 *ier = cg_gopath(*fn, c_path);
01837 CGNS_FREE(c_path);
01838 }
01839
01840
01841
01842
01843
01844 CGNSDLL void FMNAME(cg_famname_read_f, CG_FAMNAME_READ_F) (STR_PSTR(famname), int *ier
01845 STR_PLEN(famname)) {
01846 char c_name[CGIO_MAX_NAME_LENGTH+1];
01847 int ierr;
01848
01849 *ier = cg_famname_read(c_name);
01850 if (*ier != CG_ERROR) {
01851 string_2_F_string(c_name, STR_PTR(famname), STR_LEN(famname), &ierr);
01852 if (ierr) *ier = ierr;
01853 }
01854 }
01855
01856
01857
01858 CGNSDLL void FMNAME(cg_convergence_read_f, CG_CONVERGENCE_READ_F) (int *iterations,
01859 STR_PSTR(NormDefinitions), int *ier STR_PLEN(NormDefinitions)) {
01860 char *c_descr_text;
01861
01862 *ier = cg_convergence_read(iterations, &c_descr_text);
01863 if (*ier) return;
01864 string_2_F_string(c_descr_text, STR_PTR(NormDefinitions),
01865 STR_LEN(NormDefinitions), ier);
01866 free(c_descr_text);
01867 }
01868
01869
01870
01871 CGNSDLL void FMNAME(cg_state_size_f, CG_STATE_SIZE_F) (int *size, int *ier) {
01872 char *c_descr_text;
01873
01874 *ier = cg_state_read(&c_descr_text);
01875 if (!*ier) {
01876 *size = strlen(c_descr_text);
01877 free(c_descr_text);
01878 }
01879 }
01880
01881
01882
01883 CGNSDLL void FMNAME(cg_state_read_f, CG_STATE_READ_F) (STR_PSTR(StateDescription), int *ier
01884 STR_PLEN(StateDescription)) {
01885 char *c_descr_text;
01886
01887 *ier = cg_state_read(&c_descr_text);
01888 if (*ier) return;
01889 string_2_F_string(c_descr_text, STR_PTR(StateDescription),
01890 STR_LEN(StateDescription), ier);
01891 free(c_descr_text);
01892 }
01893
01894
01895
01896 CGNSDLL void FMNAME(cg_equationset_read_f, CG_EQUATIONSET_READ_F) (int *EquationDimension,
01897 int *GoverningEquationsFlag, int *GasModelFlag, int *ViscosityModelFlag,
01898 int *ThermalConductivityModelFlag, int *TurbulenceClosureFlag,
01899 int *TurbulenceModelFlag, int *ier) {
01900
01901 *ier = cg_equationset_read(EquationDimension, GoverningEquationsFlag,
01902 GasModelFlag, ViscosityModelFlag, ThermalConductivityModelFlag,
01903 TurbulenceClosureFlag, TurbulenceModelFlag);
01904 #if DEBUG_FTOC
01905 printf("in cg_ftoc, EquationDimension=%d\n",*EquationDimension);
01906 #endif
01907 }
01908
01909
01910
01911 CGNSDLL void FMNAME(cg_equationset_chemistry_read_f, CG_EQUATIONSET_CHEMISTRY_READ_F) (
01912 int *ThermalRelaxationFlag, int *ChemicalKineticsFlag, int *ier) {
01913
01914 *ier = cg_equationset_chemistry_read(ThermalRelaxationFlag, ChemicalKineticsFlag);
01915 }
01916
01917
01918
01919 CGNSDLL void FMNAME(cg_equationset_elecmagn_read_f, CG_EQUATIONSET_ELECMAGN_READ_F) (
01920 int *ElecFldModelFlag, int *MagnFldModelFlag, int *ConductivityModelFlag,
01921 int *ier) {
01922
01923 *ier = cg_equationset_elecmagn_read(ElecFldModelFlag, MagnFldModelFlag,
01924 ConductivityModelFlag);
01925 }
01926
01927
01928
01929 CGNSDLL void FMNAME(cg_governing_read_f, CG_GOVERNING_READ_F) (GoverningEquationsType_t *EquationsType,
01930 int *ier) {
01931
01932 *ier = cg_governing_read(EquationsType);
01933 }
01934
01935
01936
01937 CGNSDLL void FMNAME(cg_diffusion_read_f, CG_DIFFUSION_READ_F) (int *diffusion_model, int *ier) {
01938
01939 *ier = cg_diffusion_read(diffusion_model);
01940 }
01941
01942
01943
01944 CGNSDLL void FMNAME(cg_model_read_f, CG_MODEL_READ_F) (STR_PSTR(ModelLabel), ModelType_t *ModelType,
01945 int *ier STR_PLEN(ModelLabel)) {
01946 char c_name[CGIO_MAX_NAME_LENGTH+1];
01947
01948
01949 string_2_C_string(STR_PTR(ModelLabel), STR_LEN(ModelLabel),
01950 c_name, CGIO_MAX_NAME_LENGTH, ier);
01951 if (!*ier)
01952 *ier = cg_model_read(c_name, ModelType);
01953 }
01954
01955
01956
01957 CGNSDLL void FMNAME(cg_narrays_f, CG_NARRAYS_F) (int *narrays, int *ier) {
01958
01959 *ier = cg_narrays(narrays);
01960 }
01961
01962
01963
01964 CGNSDLL void FMNAME(cg_array_info_f, CG_ARRAY_INFO_F) (int *A, STR_PSTR(ArrayName), DataType_t *DataType,
01965 int *DataDimension, int *DimensionVector, int *ier STR_PLEN(ArrayName)) {
01966 char c_name[CGIO_MAX_NAME_LENGTH+1];
01967
01968 *ier = cg_array_info(*A, c_name, DataType, DataDimension, DimensionVector);
01969 if (!*ier)
01970 string_2_F_string(c_name, STR_PTR(ArrayName), STR_LEN(ArrayName), ier);
01971 }
01972
01973
01974
01975 #ifdef WIN32_FORTRAN
01976 CGNSDLL void __stdcall cg_array_read_f(int *A, void *Data, ...) {
01977 va_list ap;
01978 int *ier;
01979 int DataDimension, *DimensionVector;
01980 char *ArrayName;
01981 DataType_t DataType;
01982
01983 ArrayName = CGNS_NEW(char,CGIO_MAX_NAME_LENGTH+1);
01984 DimensionVector = CGNS_NEW(int, 3);
01985 cg_array_info(*A, ArrayName, &DataType, &DataDimension, DimensionVector);
01986
01987 va_start(ap, Data);
01988 if (DataType == Character) (void) va_arg(ap, int);
01989 ier = va_arg(ap, int *);
01990 va_end(ap);
01991 #else
01992 CGNSDLL void FMNAME(cg_array_read_f, CG_ARRAY_READ_F) (int *A, void *Data, int *ier) {
01993 #endif
01994
01995 *ier = cg_array_read(*A, Data);
01996 }
01997
01998
01999
02000 #ifdef WIN32_FORTRAN
02001 CGNSDLL void __stdcall cg_array_read_as_f(int *A, DataType_t *type, void *Data, ...) {
02002 va_list ap;
02003 int *ier;
02004 va_start(ap, Data);
02005 if (*type == Character) (void) va_arg(ap, int);
02006 ier = va_arg(ap, int *);
02007 va_end(ap);
02008 #else
02009 CGNSDLL void FMNAME(cg_array_read_as_f, CG_ARRAY_READ_AS_F) (int *A, DataType_t *type,
02010 void *Data, int *ier) {
02011 #endif
02012
02013 *ier = cg_array_read_as(*A, *type, Data);
02014 }
02015
02016
02017
02018 CGNSDLL void FMNAME(cg_nintegrals_f, CG_NINTEGRALS_F) (int *nintegrals, int *ier) {
02019
02020 *ier = cg_nintegrals(nintegrals);
02021 }
02022
02023
02024
02025 CGNSDLL void FMNAME(cg_integral_read_f, CG_INTEGRAL_READ_F) (int *IntegralDataIndex,
02026 STR_PSTR(IntegralDataName), int *ier STR_PLEN(IntegralDataName)) {
02027 char c_name[CGIO_MAX_NAME_LENGTH+1];
02028
02029 *ier = cg_integral_read(*IntegralDataIndex, c_name);
02030 if (!*ier)
02031 string_2_F_string(c_name, STR_PTR(IntegralDataName),
02032 STR_LEN(IntegralDataName), ier);
02033 }
02034
02035
02036
02037 CGNSDLL void FMNAME(cg_rind_read_f, CG_RIND_READ_F) (int *RindData, int *ier) {
02038
02039 *ier = cg_rind_read(RindData);
02040 }
02041
02042
02043
02044 CGNSDLL void FMNAME(cg_ndescriptors_f, CG_NDESCRIPTORS_F) (int *ndescriptors, int *ier) {
02045
02046 *ier = cg_ndescriptors(ndescriptors);
02047 }
02048
02049
02050
02051 CGNSDLL void FMNAME(cg_descriptor_size_f, CG_DESCRIPTOR_SIZE_F) (int *descr_no,
02052 int *descr_size, int *ier) {
02053 char *c_descr_text;
02054 char descr_name[CGIO_MAX_NAME_LENGTH+1];
02055
02056 *ier = cg_descriptor_read(*descr_no, descr_name, &c_descr_text);
02057 if (!*ier) {
02058 *descr_size = strlen(c_descr_text);
02059 free(c_descr_text);
02060 }
02061 }
02062
02063
02064
02065 CGNSDLL void FMNAME(cg_descriptor_read_f, CG_DESCRIPTOR_READ_F) (int *descr_no,
02066 STR_PSTR(descr_name), STR_PSTR(descr_text), int *ier
02067 STR_PLEN(descr_name) STR_PLEN(descr_text)) {
02068 char *c_descr_text;
02069 char c_name[CGIO_MAX_NAME_LENGTH+1];
02070
02071 *ier = cg_descriptor_read(*descr_no, c_name, &c_descr_text);
02072 if (*ier) return;
02073 #if DEBUG_FTOC
02074 printf("In cg_descriptor_read_f, descr_no=%d, descr_name='%s', c_descr_text='%s'\n",
02075 *descr_no, c_name, c_descr_text);
02076 #endif
02077 string_2_F_string(c_name, STR_PTR(descr_name), STR_LEN(descr_name), ier);
02078 if (!*ier)
02079 string_2_F_string(c_descr_text, STR_PTR(descr_text),
02080 STR_LEN(descr_text), ier);
02081 free(c_descr_text);
02082 }
02083
02084
02085
02086 CGNSDLL void FMNAME(cg_nunits_f, CG_NUNITS_F) (int *nunits, int *ier) {
02087
02088 *ier = cg_nunits(nunits);
02089 }
02090
02091
02092
02093 CGNSDLL void FMNAME(cg_units_read_f, CG_UNITS_READ_F) (MassUnits_t *mass, LengthUnits_t *length,
02094 TimeUnits_t *time, TemperatureUnits_t *temperature, AngleUnits_t *angle, int *ier) {
02095
02096 *ier = cg_units_read(mass, length, time, temperature, angle);
02097 }
02098
02099
02100
02101 CGNSDLL void FMNAME(cg_unitsfull_read_f, CG_UNITSFULL_READ_F) (MassUnits_t *mass,
02102 LengthUnits_t *length, TimeUnits_t *time, TemperatureUnits_t *temperature,
02103 AngleUnits_t *angle, ElectricCurrentUnits_t *current,
02104 SubstanceAmountUnits_t *amount, LuminousIntensityUnits_t *intensity, int *ier) {
02105
02106 *ier = cg_unitsfull_read(mass, length, time, temperature, angle,
02107 current, amount, intensity);
02108 }
02109
02110
02111
02112 CGNSDLL void FMNAME(cg_exponents_info_f, CG_EXPONENTS_INFO_F) (DataType_t *DataType, int *ier) {
02113
02114 *ier = cg_exponents_info(DataType);
02115 }
02116
02117
02118
02119 CGNSDLL void FMNAME(cg_nexponents_f, CG_NEXPONENTS_F) (int *nexps, int *ier) {
02120 *ier = cg_nexponents(nexps);
02121 }
02122
02123
02124
02125 CGNSDLL void FMNAME(cg_exponents_read_f, CG_EXPONENTS_READ_F) (void *exponents, int *ier) {
02126
02127 *ier = cg_exponents_read(exponents);
02128 }
02129
02130
02131
02132 CGNSDLL void FMNAME(cg_expfull_read_f, CG_EXPFULL_READ_F) (void *exponents, int *ier) {
02133
02134 *ier = cg_expfull_read(exponents);
02135 }
02136
02137
02138
02139 CGNSDLL void FMNAME(cg_conversion_info_f, CG_CONVERSION_INFO_F) (DataType_t *DataType, int *ier) {
02140
02141 *ier = cg_conversion_info(DataType);
02142 }
02143
02144
02145
02146 CGNSDLL void FMNAME(cg_conversion_read_f, CG_CONVERSION_READ_F) (void *ConversionFactors,
02147 int *ier) {
02148
02149 *ier = cg_conversion_read(ConversionFactors);
02150 }
02151
02152
02153
02154 CGNSDLL void FMNAME(cg_dataclass_read_f, CG_DATACLASS_READ_F) (DataClass_t *dataclass, int *ier) {
02155
02156 *ier = cg_dataclass_read(dataclass);
02157 }
02158
02159
02160
02161 CGNSDLL void FMNAME(cg_gridlocation_read_f, CG_GRIDLOCATION_READ_F) (GridLocation_t *GridLocation,
02162 int *ier) {
02163
02164 *ier = cg_gridlocation_read(GridLocation);
02165 }
02166
02167
02168
02169 CGNSDLL void FMNAME(cg_ordinal_read_f, CG_ORDINAL_READ_F) (int *Ordinal, int *ier) {
02170
02171 *ier = cg_ordinal_read(Ordinal);
02172 }
02173
02174
02175
02176 CGNSDLL void FMNAME(cg_npe_f, CG_NPE_F) (ElementType_t *type, int *npe, int *ier) {
02177
02178 *ier = cg_npe(*type, npe);
02179 }
02180
02181
02182
02183 CGNSDLL void FMNAME(cg_is_link_f, CG_IS_LINK_F) (int *path_length, int *ier) {
02184
02185 *ier = cg_is_link(path_length);
02186 }
02187
02188
02189
02190 CGNSDLL void FMNAME(cg_link_read_f, CG_LINK_READ_F) (
02191 STR_PSTR(filename), STR_PSTR(link_path), int *ier
02192 STR_PLEN(filename) STR_PLEN(link_path)) {
02193 char *f_name, *l_name;
02194
02195 *ier = cg_link_read(&f_name, &l_name);
02196 if (*ier) return;
02197 string_2_F_string(f_name, STR_PTR(filename), STR_LEN(filename), ier);
02198 if (!*ier)
02199 string_2_F_string(l_name, STR_PTR(link_path), STR_LEN(link_path), ier);
02200 free(f_name);
02201 free(l_name);
02202 }
02203
02204
02205
02206 CGNSDLL void FMNAME(cg_nuser_data_f, CG_NUSER_DATA_F) (int *nuser_data, int *ier) {
02207
02208 *ier = cg_nuser_data(nuser_data);
02209 }
02210
02211
02212
02213 CGNSDLL void FMNAME(cg_user_data_read_f, CG_USER_DATA_READ_F) (int *index, STR_PSTR(dataname),
02214 int *ier STR_PLEN(dataname)) {
02215 char c_name[CGIO_MAX_NAME_LENGTH+1];
02216 int ierr;
02217
02218 *ier = cg_user_data_read(*index, c_name);
02219 if (*ier != CG_ERROR) {
02220 string_2_F_string(c_name, STR_PTR(dataname), STR_LEN(dataname), &ierr);
02221 if (ierr) *ier = ierr;
02222 }
02223 }
02224
02225
02226
02227
02228
02229 CGNSDLL void FMNAME(cg_famname_write_f, CG_FAMNAME_WRITE_F) (STR_PSTR(family_name),
02230 int *ier STR_PLEN(family_name)) {
02231 char c_name[CGIO_MAX_NAME_LENGTH+1];
02232
02233
02234 string_2_C_string(STR_PTR(family_name), STR_LEN(family_name),
02235 c_name, CGIO_MAX_NAME_LENGTH, ier);
02236 if (!*ier)
02237 *ier = cg_famname_write(c_name);
02238 }
02239
02240
02241
02242 CGNSDLL void FMNAME(cg_convergence_write_f, CG_CONVERGENCE_WRITE_F) (int *iterations,
02243 STR_PSTR(NormDefinitions), int *ier STR_PLEN(NormDefinitions)) {
02244 char *c_string;
02245 int len;
02246
02247 len = STR_LEN(NormDefinitions);
02248
02249 c_string = CGNS_NEW(char, len+1);
02250 string_2_C_string(STR_PTR(NormDefinitions), len, c_string, len, ier);
02251 if (!*ier) {
02252 #if DEBUG_FTOC
02253 printf("In cg_ftoc: c_NormDefinitions = '%s'",c_string);
02254 #endif
02255 *ier = cg_convergence_write(*iterations, c_string);
02256 }
02257 free(c_string);
02258 }
02259
02260
02261
02262 CGNSDLL void FMNAME(cg_state_write_f, CG_STATE_WRITE_F) (STR_PSTR(StateDescription), int *ier
02263 STR_PLEN(StateDescription)) {
02264 char *c_string;
02265 int len;
02266
02267 len = STR_LEN(StateDescription);
02268
02269 c_string = CGNS_NEW(char, len+1);
02270 string_2_C_string(STR_PTR(StateDescription), len, c_string, len, ier);
02271 if (!*ier) {
02272 #if DEBUG_FTOC
02273 printf("In cg_ftoc: C_StateDescription = '%s'",c_string);
02274 #endif
02275 *ier = cg_state_write(c_string);
02276 }
02277 free(c_string);
02278 }
02279
02280
02281
02282 CGNSDLL void FMNAME(cg_equationset_write_f, CG_EQUATIONSET_WRITE_F) (int *EquationDimension, int *ier) {
02283
02284 #if DEBUG_FTOC
02285 printf("In cg_ftoc: EquationDimension=%d\n",*EquationDimension);
02286 #endif
02287
02288 *ier = cg_equationset_write(*EquationDimension);
02289 }
02290
02291
02292
02293 CGNSDLL void FMNAME(cg_governing_write_f, CG_GOVERNING_WRITE_F) (GoverningEquationsType_t *Equationstype,
02294 int *ier) {
02295
02296 *ier = cg_governing_write(*Equationstype);
02297 }
02298
02299
02300
02301 CGNSDLL void FMNAME(cg_diffusion_write_f, CG_DIFFUSION_WRITE_F) (int *diffusion_model, int *ier) {
02302
02303 *ier = cg_diffusion_write(diffusion_model);
02304 }
02305
02306
02307
02308 CGNSDLL void FMNAME(cg_model_write_f, CG_MODEL_WRITE_F) (STR_PSTR(ModelLabel), ModelType_t *ModelType,
02309 int *ier STR_PLEN(ModelLabel)) {
02310 char c_name[CGIO_MAX_NAME_LENGTH+1];
02311
02312
02313 string_2_C_string(STR_PTR(ModelLabel), STR_LEN(ModelLabel),
02314 c_name, CGIO_MAX_NAME_LENGTH, ier);
02315 if (!*ier)
02316 *ier = cg_model_write(c_name, *ModelType);
02317 }
02318
02319
02320
02321 #ifdef WIN32_FORTRAN
02322 CGNSDLL void __stdcall cg_array_write_f(STR_PSTR(ArrayName), DataType_t *DataType,
02323 int *DataDimension, int *DimensionVector, void *Data, ...) {
02324 va_list ap;
02325 int *ier;
02326 char c_name[CGIO_MAX_NAME_LENGTH+1];
02327
02328 va_start(ap, Data);
02329 if (*DataType == Character) (void) va_arg(ap, int);
02330 ier = va_arg(ap, int *);
02331 va_end(ap);
02332 #else
02333 CGNSDLL void FMNAME(cg_array_write_f, CG_ARRAY_WRITE_F) (STR_PSTR(ArrayName), DataType_t *DataType,
02334 int *DataDimension, int *DimensionVector, void *Data, int *ier STR_PLEN(ArrayName)) {
02335 char c_name[CGIO_MAX_NAME_LENGTH+1];
02336 #endif
02337
02338
02339 string_2_C_string(STR_PTR(ArrayName), STR_LEN(ArrayName),
02340 c_name, CGIO_MAX_NAME_LENGTH, ier);
02341 if (!*ier)
02342 *ier = cg_array_write(c_name, *DataType, *DataDimension,
02343 DimensionVector, Data);
02344 }
02345
02346
02347
02348 CGNSDLL void FMNAME(cg_integral_write_f, CG_INTEGRAL_WRITE_F) (STR_PSTR(IntegralDataName), int *ier
02349 STR_PLEN(IntegralDataName)) {
02350 char c_name[CGIO_MAX_NAME_LENGTH+1];
02351
02352
02353 string_2_C_string(STR_PTR(IntegralDataName), STR_LEN(IntegralDataName),
02354 c_name, CGIO_MAX_NAME_LENGTH, ier);
02355 if (!*ier)
02356 *ier = cg_integral_write(c_name);
02357 }
02358
02359
02360
02361 CGNSDLL void FMNAME(cg_rind_write_f, CG_RIND_WRITE_F) (int *RindData, int *ier) {
02362
02363 *ier = cg_rind_write(RindData);
02364 }
02365
02366
02367
02368 CGNSDLL void FMNAME(cg_descriptor_write_f, CG_DESCRIPTOR_WRITE_F) (STR_PSTR(descr_name),
02369 STR_PSTR(descr_text), int *ier STR_PLEN(descr_name) STR_PLEN(descr_text)) {
02370 char *c_descr_text, c_descr_name[CGIO_MAX_NAME_LENGTH+1];
02371 int len;
02372
02373
02374
02375
02376
02377
02378
02379
02380
02381
02382
02383
02384
02385 string_2_C_string(STR_PTR(descr_name), STR_LEN(descr_name),
02386 c_descr_name, CGIO_MAX_NAME_LENGTH, ier);
02387 if (*ier) return;
02388
02389 len = STR_LEN(descr_text);
02390 c_descr_text = CGNS_NEW(char, len+1);
02391 string_2_C_string(STR_PTR(descr_text), len, c_descr_text, len, ier);
02392 if (!*ier) {
02393 #if DEBUG_FTOC
02394 printf("c_descr_name='%s', c_descr_text='%s'\n",c_descr_name, c_descr_text);
02395 #endif
02396
02397
02398 *ier = cg_descriptor_write(c_descr_name, c_descr_text);
02399 }
02400 free(c_descr_text);
02401 }
02402
02403
02404
02405 CGNSDLL void FMNAME(cg_units_write_f, CG_UNITS_WRITE_F) (MassUnits_t *mass, LengthUnits_t *length,
02406 TimeUnits_t *time, TemperatureUnits_t *temperature, AngleUnits_t *angle, int *ier) {
02407
02408 *ier = cg_units_write(*mass, *length, *time, *temperature, *angle);
02409 }
02410
02411
02412
02413 CGNSDLL void FMNAME(cg_unitsfull_write_f, CG_UNITSFULL_WRITE_F) (MassUnits_t *mass,
02414 LengthUnits_t *length, TimeUnits_t *time, TemperatureUnits_t *temperature,
02415 AngleUnits_t *angle, ElectricCurrentUnits_t *current,
02416 SubstanceAmountUnits_t *amount, LuminousIntensityUnits_t *intensity, int *ier) {
02417
02418 *ier = cg_unitsfull_write(*mass, *length, *time, *temperature, *angle,
02419 *current, *amount, *intensity);
02420 }
02421
02422
02423
02424 CGNSDLL void FMNAME(cg_exponents_write_f, CG_EXPONENTS_WRITE_F) (DataType_t *DataType, void *exponents,
02425 int *ier) {
02426
02427 *ier = cg_exponents_write(*DataType, exponents);
02428 }
02429
02430
02431
02432 CGNSDLL void FMNAME(cg_expfull_write_f, CG_EXPFULL_WRITE_F) (DataType_t *DataType, void *exponents, int *ier)
02433 {
02434
02435 *ier = cg_expfull_write(*DataType, exponents);
02436 }
02437
02438
02439
02440 CGNSDLL void FMNAME(cg_conversion_write_f, CG_CONVERSION_WRITE_F) (DataType_t *DataType,
02441 void *ConversionFactors, int *ier) {
02442
02443 *ier = cg_conversion_write(*DataType, ConversionFactors);
02444 }
02445
02446
02447
02448 CGNSDLL void FMNAME(cg_dataclass_write_f, CG_DATACLASS_WRITE_F) (DataClass_t *dataclass, int *ier) {
02449
02450 *ier = cg_dataclass_write(*dataclass);
02451 }
02452
02453
02454
02455 CGNSDLL void FMNAME(cg_gridlocation_write_f, CG_GRIDLOCATION_WRITE_F) (GridLocation_t *GridLocation,
02456 int *ier) {
02457
02458 *ier = cg_gridlocation_write(*GridLocation);
02459 }
02460
02461
02462
02463 CGNSDLL void FMNAME(cg_ordinal_write_f, CG_ORDINAL_WRITE_F) (int *Ordinal, int *ier) {
02464
02465 *ier = cg_ordinal_write(*Ordinal);
02466 }
02467
02468
02469
02470 CGNSDLL void FMNAME(cg_link_write_f, CG_LINK_WRITE_F) (
02471 STR_PSTR(nodename), STR_PSTR(filename), STR_PSTR(name_in_file), int *ier
02472 STR_PLEN(nodename) STR_PLEN(filename) STR_PLEN(name_in_file)) {
02473 char n_name[CGIO_MAX_NAME_LENGTH+1];
02474 char f_name[CGIO_MAX_FILE_LENGTH+1];
02475 char i_name[CGIO_MAX_LINK_LENGTH+1];
02476
02477 string_2_C_string(STR_PTR(nodename), STR_LEN(nodename),
02478 n_name, CGIO_MAX_NAME_LENGTH, ier);
02479 if (*ier) return;
02480 string_2_C_string(STR_PTR(filename), STR_LEN(filename),
02481 f_name, CGIO_MAX_FILE_LENGTH, ier);
02482 if (*ier) return;
02483 string_2_C_string(STR_PTR(name_in_file), STR_LEN(name_in_file),
02484 i_name, CGIO_MAX_LINK_LENGTH, ier);
02485 if (*ier) return;
02486
02487 *ier = cg_link_write(n_name, f_name, i_name);
02488 }
02489
02490
02491
02492 CGNSDLL void FMNAME(cg_user_data_write_f, CG_USER_DATA_WRITE_F) (
02493 STR_PSTR(dataname), int *ier
02494 STR_PLEN(dataname) ) {
02495 char d_name[CGIO_MAX_NAME_LENGTH+1];
02496
02497 string_2_C_string(STR_PTR(dataname), STR_LEN(dataname),
02498 d_name, CGIO_MAX_NAME_LENGTH, ier);
02499 if (!*ier)
02500 *ier = cg_user_data_write(d_name);
02501 }
02502
02503
02504
02505
02506
02507 CGNSDLL void FMNAME(cg_delete_node_f, CG_DELETE_NODE_F) (STR_PSTR(node_name), int *ier
02508 STR_PLEN(node_name)) {
02509
02510 char c_name[CGIO_MAX_NAME_LENGTH+1];
02511
02512
02513 string_2_C_string(STR_PTR(node_name), STR_LEN(node_name),
02514 c_name, CGIO_MAX_NAME_LENGTH, ier);
02515 if (*ier) return;
02516
02517 *ier = cg_delete_node(c_name);
02518
02519 #if DEBUG_FTOC
02520 printf("\n Deleting node ='%s'\n", c_name);
02521 #endif
02522 }
02523
02524
02525
02526
02527
02528 CGNSDLL void FMNAME(cg_get_error_f, CG_GET_ERROR_F) (STR_PSTR(errmsg) STR_PLEN(errmsg)) {
02529 int ierr;
02530
02531 string_2_F_string ((char *)cg_get_error(), STR_PTR(errmsg),
02532 STR_LEN(errmsg), &ierr);
02533 }
02534
02535
02536
02537 CGNSDLL void FMNAME(cg_error_exit_f, CG_ERROR_EXIT_F) () {
02538 cg_error_exit();
02539 }
02540
02541
02542
02543 CGNSDLL void FMNAME(cg_error_print_f, CG_ERROR_PRINT_F) () {
02544 cg_error_print();
02545 }
02546