1 /*-------------------------------------------------------------------------
2 This software is provided 'as-is', without any express or implied warranty.
3 In no event will the authors be held liable for any damages arising from
4 the use of this software.
5
6 Permission is granted to anyone to use this software for any purpose,
7 including commercial applications, and to alter it and redistribute it
8 freely, subject to the following restrictions:
9
10 1. The origin of this software must not be misrepresented; you must not
11 claim that you wrote the original software. If you use this software
12 in a product, an acknowledgment in the product documentation would be
13 appreciated but is not required.
14
15 2. Altered source versions must be plainly marked as such, and must not
16 be misrepresented as being the original software.
17
18 3. This notice may not be removed or altered from any source distribution.
19 -------------------------------------------------------------------------*/
20
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <stdarg.h>
24 #include "fortran_macros.h"
25 #include "cgnslib.h"
26 #include "cgns_header.h"
27 #include <string.h>
28 #include "cgns_io.h"
29 #ifdef MEM_DEBUG
30 #include "cg_malloc.h"
31 #endif
32 #if CG_BUILD_PARALLEL
33 #include "pcgnslib.h"
34 #endif
35
36
37 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
38 * Convert between Fortran and C strings *
39 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
40
string_2_C_string(char * string,int string_length,char * c_string,int max_len,cgint_f * ierr)41 static void string_2_C_string(char *string, int string_length,
42 char *c_string, int max_len, cgint_f *ierr)
43 {
44 int i, iend;
45
46 if (string == NULL || c_string == NULL) {
47 cgi_error ("NULL string pointer");
48 *ierr = (cgint_f)CG_ERROR;
49 return;
50 }
51
52 /** Skip and trailing blanks **/
53 for (iend = string_length-1; iend >= 0; iend--) {
54 if (string[iend] != ' ') break;
55 }
56 if (iend >= max_len) iend = max_len - 1;
57
58 /** Copy the non-trailing blank portion of the string **/
59 for (i = 0; i <= iend; i++)
60 c_string[i] = string[i];
61
62 /** NULL terminate the C string **/
63 c_string[i] = '\0';
64 *ierr = (cgint_f)CG_OK;
65 }
66
67 /*-----------------------------------------------------------------------*/
68
string_2_F_string(char * c_string,char * string,int string_length,cgint_f * ierr)69 static void string_2_F_string(char *c_string, char *string,
70 int string_length, cgint_f *ierr)
71 {
72 int i, len;
73
74 if (c_string == NULL || string == NULL) {
75 cgi_error ("NULL string pointer");
76 *ierr = (cgint_f)CG_ERROR;
77 return;
78 }
79 len = (int)strlen(c_string);
80 if (len > string_length) len = string_length;
81
82 for (i = 0; i < len; i++)
83 string[i] = c_string[i];
84 while (i < string_length)
85 string[i++] = ' ';
86 *ierr = (cgint_f)CG_OK;
87 }
88
89 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
90 * LIBRARY FUNCTIONS *
91 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
92
FMNAME(cg_is_cgns_f,CG_IS_CGNS_F)93 CGNSDLL void FMNAME(cg_is_cgns_f, CG_IS_CGNS_F) (STR_PSTR(filename),
94 cgint_f *file_type, cgint_f *ier STR_PLEN(filename))
95 {
96 int length, i_file_type;
97 char *c_name;
98
99 length = (int) STR_LEN(filename);
100 c_name = CGNS_NEW(char, length+1);
101
102 string_2_C_string(STR_PTR(filename), STR_LEN(filename), c_name, length, ier);
103 if (*ier == 0) {
104 *ier = (cgint_f)cg_is_cgns(c_name, &i_file_type);
105 *file_type = (cgint_f)i_file_type;
106 }
107 CGNS_FREE(c_name);
108 }
109
110 /*-----------------------------------------------------------------------*/
111
FMNAME(cg_open_f,CG_OPEN_F)112 CGNSDLL void FMNAME(cg_open_f, CG_OPEN_F) (STR_PSTR(filename), cgint_f *mode,
113 cgint_f *fn, cgint_f *ier STR_PLEN(filename))
114 {
115 int length, i_fn;
116 char *c_name;
117
118 length = (int) STR_LEN(filename);
119 c_name = CGNS_NEW(char, length+1);
120
121 string_2_C_string(STR_PTR(filename), STR_LEN(filename), c_name, length, ier);
122 if (*ier == 0) {
123 #if DEBUG_FTOC
124 printf("filename='%s'\n",c_name);
125 #endif
126 *ier = (cgint_f)cg_open(c_name, (int)*mode, &i_fn);
127 *fn = (cgint_f)i_fn;
128 }
129 CGNS_FREE(c_name);
130 }
131
132 /*-----------------------------------------------------------------------*/
133
cg_version_f(cgint_f * fn,float * FileVersion,cgint_f * ier)134 CGNSDLL void cg_version_f(cgint_f *fn, float *FileVersion, cgint_f *ier)
135 {
136 *ier = (cgint_f)cg_version((int)*fn, FileVersion);
137 }
138
139 /*-----------------------------------------------------------------------*/
140
cg_precision_f(cgint_f * fn,cgint_f * precision,cgint_f * ier)141 CGNSDLL void cg_precision_f(cgint_f *fn, cgint_f *precision, cgint_f *ier)
142 {
143 int i_precision;
144
145 *ier = (cgint_f)cg_precision((int)*fn, &i_precision);
146 *precision = (cgint_f)i_precision;
147 }
148
149 /*-----------------------------------------------------------------------*/
150
cg_close_f(cgint_f * fn,cgint_f * ier)151 CGNSDLL void cg_close_f(cgint_f *fn, cgint_f *ier)
152 {
153 *ier = (cgint_f)cg_close((int)*fn);
154 }
155
156 /*-----------------------------------------------------------------------*/
157
FMNAME(cg_save_as_f,CG_SAVE_AS_F)158 CGNSDLL void FMNAME(cg_save_as_f, CG_SAVE_AS_F) (cgint_f *fn,
159 STR_PSTR(filename), cgint_f *file_type, cgint_f *follow_links,
160 cgint_f *ier STR_PLEN(filename))
161 {
162 int length;
163 char *c_name;
164
165 length = (int) STR_LEN(filename);
166 c_name = CGNS_NEW(char, length+1);
167
168 string_2_C_string(STR_PTR(filename), STR_LEN(filename), c_name, length, ier);
169 if (*ier == 0)
170 *ier = (cgint_f)cg_save_as((int)*fn, c_name, (int)*file_type, (int)*follow_links);
171 CGNS_FREE(c_name);
172 }
173
174 /*-----------------------------------------------------------------------*/
175
cg_set_file_type_f(cgint_f * ft,cgint_f * ier)176 CGNSDLL void cg_set_file_type_f(cgint_f *ft, cgint_f *ier)
177 {
178 *ier = (cgint_f)cg_set_file_type((int)*ft);
179 }
180
181 /*-----------------------------------------------------------------------*/
182
cg_get_file_type_f(cgint_f * fn,cgint_f * ft,cgint_f * ier)183 CGNSDLL void cg_get_file_type_f(cgint_f *fn, cgint_f *ft, cgint_f *ier)
184 {
185 int i_ft;
186
187 *ier = (cgint_f)cg_get_file_type((int)*fn, &i_ft);
188 *ft = (cgint_f)i_ft;
189 }
190
191 /*-----------------------------------------------------------------------*/
192
cg_set_compress_f(cgint_f * cmpr,cgint_f * ier)193 CGNSDLL void cg_set_compress_f(cgint_f *cmpr, cgint_f *ier)
194 {
195 *ier = (cgint_f)cg_set_compress((int)*cmpr);
196 }
197
198 /*-----------------------------------------------------------------------*/
199
cg_get_compress_f(cgint_f * cmpr,cgint_f * ier)200 CGNSDLL void cg_get_compress_f(cgint_f *cmpr, cgint_f *ier)
201 {
202 int i_cmpr;
203
204 *ier = (cgint_f)cg_get_compress(&i_cmpr);
205 *cmpr = (cgint_f)i_cmpr;
206 }
207
208 /*-----------------------------------------------------------------------*/
209
FMNAME(cg_set_path_f,CG_SET_PATH_F)210 CGNSDLL void FMNAME(cg_set_path_f, CG_SET_PATH_F) (STR_PSTR(pathname),
211 cgint_f *ier STR_PLEN(pathname))
212 {
213 int length;
214 char *c_name;
215
216 length = (int) STR_LEN(pathname);
217 c_name = CGNS_NEW(char, length+1);
218
219 string_2_C_string(STR_PTR(pathname), STR_LEN(pathname), c_name, length, ier);
220 if (*ier == 0)
221 *ier = (cgint_f)cg_set_path(c_name);
222 CGNS_FREE(c_name);
223 }
224
225 /*-----------------------------------------------------------------------*/
226
FMNAME(cg_add_path_f,CG_ADD_PATH_F)227 CGNSDLL void FMNAME(cg_add_path_f, CG_ADD_PATH_F) (STR_PSTR(pathname),
228 cgint_f *ier STR_PLEN(pathname))
229 {
230 int length;
231 char *c_name;
232
233 length = (int) STR_LEN(pathname);
234 c_name = CGNS_NEW(char, length+1);
235
236 string_2_C_string(STR_PTR(pathname), STR_LEN(pathname), c_name, length, ier);
237 if (*ier == 0)
238 *ier = (cgint_f)cg_add_path(c_name);
239 CGNS_FREE(c_name);
240 }
241
242 /*-----------------------------------------------------------------------*/
243
cg_set_rind_zero_f(cgint_f * ier)244 CGNSDLL void cg_set_rind_zero_f(cgint_f *ier)
245 {
246 *ier = (cgint_f)cg_configure(CG_CONFIG_RIND_INDEX, (void *)CG_CONFIG_RIND_ZERO);
247 }
248
249 /*-----------------------------------------------------------------------*/
250
cg_set_rind_core_f(cgint_f * ier)251 CGNSDLL void cg_set_rind_core_f(cgint_f *ier)
252 {
253 *ier = (cgint_f)cg_configure(CG_CONFIG_RIND_INDEX, (void *)CG_CONFIG_RIND_CORE);
254 }
255
256 /*-----------------------------------------------------------------------*/
257
cg_get_cgio_f(cgint_f * fn,cgint_f * cgio_num,cgint_f * ier)258 CGNSDLL void cg_get_cgio_f(cgint_f *fn, cgint_f *cgio_num, cgint_f *ier)
259 {
260 int i_cgio_num;
261
262 *ier = (cgint_f)cg_get_cgio((int)*fn, &i_cgio_num);
263 *cgio_num = (cgint_f)i_cgio_num;
264 }
265
266 /*-----------------------------------------------------------------------*/
267
cg_root_id_f(cgint_f * fn,double * rootid,cgint_f * ier)268 CGNSDLL void cg_root_id_f(cgint_f *fn, double *rootid, cgint_f *ier)
269 {
270 *ier = (cgint_f)cg_root_id((int)*fn, rootid);
271 }
272
273 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
274 * Read and write CGNSBase_t Nodes *
275 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
276
cg_nbases_f(cgint_f * fn,cgint_f * nbases,cgint_f * ier)277 CGNSDLL void cg_nbases_f(cgint_f *fn, cgint_f *nbases, cgint_f *ier)
278 {
279 int i_nbases;
280
281 *ier = (cgint_f)cg_nbases((int)*fn, &i_nbases);
282 *nbases = (cgint_f)i_nbases;
283 }
284
285 /*-----------------------------------------------------------------------*/
286
FMNAME(cg_base_read_f,CG_BASE_READ_F)287 CGNSDLL void FMNAME(cg_base_read_f, CG_BASE_READ_F) (cgint_f *fn, cgint_f *B,
288 STR_PSTR(basename), cgint_f *cell_dim, cgint_f *phys_dim,
289 cgint_f *ier STR_PLEN(basename))
290 {
291 char c_name[CGIO_MAX_NAME_LENGTH+1];
292 int i_cell_dim, i_phys_dim;
293
294 *ier = (cgint_f)cg_base_read((int)*fn, (int)*B, c_name, &i_cell_dim, &i_phys_dim);
295 if (*ier) return;
296 string_2_F_string(c_name, STR_PTR(basename), STR_LEN(basename), ier);
297 *cell_dim = (cgint_f)i_cell_dim;
298 *phys_dim = (cgint_f)i_phys_dim;
299 }
300
301 /*-----------------------------------------------------------------------*/
302
cg_base_id_f(cgint_f * fn,cgint_f * B,double * base_id,cgint_f * ier)303 CGNSDLL void cg_base_id_f(cgint_f *fn, cgint_f *B, double *base_id, cgint_f *ier)
304 {
305 *ier = (cgint_f)cg_base_id((int)*fn, (int)*B, base_id);
306 }
307
308 /*-----------------------------------------------------------------------*/
309
FMNAME(cg_base_write_f,CG_BASE_WRITE_F)310 CGNSDLL void FMNAME(cg_base_write_f, CG_BASE_WRITE_F) (cgint_f *fn,
311 STR_PSTR(basename), cgint_f *cell_dim, cgint_f *phys_dim,
312 cgint_f *B, cgint_f *ier STR_PLEN(basename))
313 {
314 char c_name[CGIO_MAX_NAME_LENGTH+1];
315 int i_B;
316
317 string_2_C_string(STR_PTR(basename), STR_LEN(basename),
318 c_name, CGIO_MAX_NAME_LENGTH, ier);
319 if (*ier) return;
320 #if DEBUG_FTOC
321 printf("\nbasename='%s'\n", c_name);
322 printf("cell_dim=%d\n",*cell_dim);
323 printf("phys_dim=%d\n",*phys_dim);
324 #endif
325 *ier = (cgint_f)cg_base_write((int)*fn, c_name, (int)*cell_dim, (int)*phys_dim, &i_B);
326 *B = (cgint_f)i_B;
327 }
328
329 /*-----------------------------------------------------------------------*/
330
cg_cell_dim_f(cgint_f * fn,cgint_f * B,cgint_f * dim,cgint_f * ier)331 CGNSDLL void cg_cell_dim_f(cgint_f *fn, cgint_f *B, cgint_f *dim, cgint_f *ier)
332 {
333 int i_dim;
334
335 *ier = (cgint_f)cg_cell_dim((int)*fn, (int)*B, &i_dim);
336 *dim = (cgint_f)i_dim;
337 }
338
339 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
340 * Read and write Zone_t Nodes *
341 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
342
cg_nzones_f(cgint_f * fn,cgint_f * B,cgint_f * nzones,cgint_f * ier)343 CGNSDLL void cg_nzones_f(cgint_f *fn, cgint_f *B, cgint_f *nzones, cgint_f *ier)
344 {
345 int i_nzones;
346
347 *ier = (cgint_f)cg_nzones((int)*fn, (int)*B, &i_nzones);
348 *nzones = (cgint_f)i_nzones;
349 }
350
351 /*-----------------------------------------------------------------------*/
352
cg_zone_type_f(cgint_f * fn,cgint_f * B,cgint_f * Z,CGNS_ENUMT (ZoneType_t)* type,cgint_f * ier)353 CGNSDLL void cg_zone_type_f(cgint_f *fn, cgint_f *B,
354 cgint_f *Z, CGNS_ENUMT(ZoneType_t)*type, cgint_f *ier)
355 {
356 CGNS_ENUMT(ZoneType_t) i_type;
357
358 *ier = (cgint_f)cg_zone_type((int)*fn, (int)*B, (int)*Z, &i_type);
359 *type = i_type;
360 }
361
362 /*-----------------------------------------------------------------------*/
363
FMNAME(cg_zone_read_f,CG_ZONE_READ_F)364 CGNSDLL void FMNAME(cg_zone_read_f, CG_ZONE_READ_F) (cgint_f *fn, cgint_f *B,
365 cgint_f *Z, STR_PSTR(zonename), cgsize_t *size,
366 cgint_f *ier STR_PLEN(zonename))
367 {
368 char c_name[CGIO_MAX_NAME_LENGTH+1];
369
370 *ier = (cgint_f)cg_zone_read((int)*fn, (int)*B, (int)*Z, c_name, size);
371 if (*ier == 0)
372 string_2_F_string(c_name, STR_PTR(zonename), STR_LEN(zonename), ier);
373 }
374
375 /*-----------------------------------------------------------------------*/
376
cg_zone_id_f(cgint_f * fn,cgint_f * B,cgint_f * Z,double * zone_id,cgint_f * ier)377 CGNSDLL void cg_zone_id_f(cgint_f *fn, cgint_f *B,
378 cgint_f *Z, double *zone_id, cgint_f *ier)
379 {
380 *ier = (cgint_f)cg_zone_id((int)*fn, (int)*B, (int)*Z, zone_id);
381 }
382
383 /*-----------------------------------------------------------------------*/
384
FMNAME(cg_zone_write_f,CG_ZONE_WRITE_F)385 CGNSDLL void FMNAME(cg_zone_write_f, CG_ZONE_WRITE_F) (cgint_f *fn, cgint_f *B,
386 STR_PSTR(zonename), cgsize_t *size, CGNS_ENUMT(ZoneType_t) *type,
387 cgint_f *Z, cgint_f *ier STR_PLEN(zonename))
388 {
389 char c_name[CGIO_MAX_NAME_LENGTH+1];
390 int i_Z;
391
392 string_2_C_string(STR_PTR(zonename), STR_LEN(zonename),
393 c_name, CGIO_MAX_NAME_LENGTH, ier);
394 if (*ier) return;
395 #if DEBUG_FTOC
396 printf("\n zonename='%s'\n", c_name);
397 #endif
398 *ier = (cgint_f)cg_zone_write((int)*fn, (int)*B, c_name, size,
399 (CGNS_ENUMT(ZoneType_t))*type, &i_Z);
400 *Z = (cgint_f)i_Z;
401 }
402
403 /*-----------------------------------------------------------------------*/
404
cg_index_dim_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * dim,cgint_f * ier)405 CGNSDLL void cg_index_dim_f(cgint_f *fn,
406 cgint_f *B, cgint_f *Z, cgint_f *dim, cgint_f *ier)
407 {
408 int i_dim;
409
410 *ier = (cgint_f)cg_index_dim((int)*fn, (int)*B, (int)*Z, &i_dim);
411 *dim = (cgint_f)i_dim;
412 }
413
414 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
415 * Read and write Family_t Nodes *
416 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
417
cg_nfamilies_f(cgint_f * fn,cgint_f * B,cgint_f * nfamilies,cgint_f * ier)418 CGNSDLL void cg_nfamilies_f(cgint_f *fn, cgint_f *B,
419 cgint_f *nfamilies, cgint_f *ier)
420 {
421 int i_nfamilies;
422
423 *ier = (cgint_f)cg_nfamilies((int)*fn, (int)*B, &i_nfamilies);
424 *nfamilies = (cgint_f)i_nfamilies;
425 }
426
cg_node_nfamilies_f(cgint_f * nfamilies,cgint_f * ier)427 CGNSDLL void cg_node_nfamilies_f(cgint_f *nfamilies, cgint_f *ier)
428 {
429 int i_nfamilies;
430
431 *ier = (cgint_f)cg_node_nfamilies(&i_nfamilies);
432 *nfamilies = (cgint_f)i_nfamilies;
433 }
434
435 /*-----------------------------------------------------------------------*/
436
FMNAME(cg_family_read_f,CG_FAMILY_READ_F)437 CGNSDLL void FMNAME(cg_family_read_f, CG_FAMILY_READ_F) (cgint_f *fn, cgint_f *B,
438 cgint_f *F, STR_PSTR(family_name), cgint_f *nboco, cgint_f *ngeos,
439 cgint_f *ier STR_PLEN(family_name))
440 {
441 char c_name[CGIO_MAX_NAME_LENGTH+1];
442 int i_nboco, i_ngeos;
443
444 *ier = (cgint_f)cg_family_read((int)*fn, (int)*B, (int)*F, c_name, &i_nboco, &i_ngeos);
445 if (*ier) return;
446 string_2_F_string(c_name, STR_PTR(family_name), STR_LEN(family_name), ier);
447
448 *nboco = (cgint_f)i_nboco;
449 *ngeos = (cgint_f)i_ngeos;
450 }
451
FMNAME(cg_node_family_read_f,CG_NODE_FAMILY_READ_F)452 CGNSDLL void FMNAME(cg_node_family_read_f, CG_NODE_FAMILY_READ_F) (
453 cgint_f *F, STR_PSTR(family_name), cgint_f *nboco, cgint_f *ngeos,
454 cgint_f *ier STR_PLEN(family_name))
455 {
456 char c_name[CGIO_MAX_NAME_LENGTH+1];
457 int i_nboco, i_ngeos;
458
459 *ier = (cgint_f)cg_node_family_read((int)*F, c_name, &i_nboco, &i_ngeos);
460 if (*ier) return;
461 string_2_F_string(c_name, STR_PTR(family_name), STR_LEN(family_name), ier);
462
463 *nboco = (cgint_f)i_nboco;
464 *ngeos = (cgint_f)i_ngeos;
465 }
466
467 /*-----------------------------------------------------------------------*/
468
FMNAME(cg_family_write_f,CG_FAMILY_WRITE_F)469 CGNSDLL void FMNAME(cg_family_write_f, CG_FAMILY_WRITE_F) (cgint_f *fn, cgint_f *B,
470 STR_PSTR(family_name), cgint_f *F, cgint_f *ier STR_PLEN(family_name))
471 {
472 char c_name[CGIO_MAX_NAME_LENGTH*CG_MAX_GOTO_DEPTH+1];
473 int i_F;
474
475 string_2_C_string(STR_PTR(family_name), STR_LEN(family_name),
476 c_name, CGIO_MAX_NAME_LENGTH*CG_MAX_GOTO_DEPTH, ier);
477 if (*ier) return;
478 *ier = (cgint_f)cg_family_write((int)*fn, (int)*B, c_name, &i_F);
479 *F = (cgint_f)i_F;
480 }
481
FMNAME(cg_node_family_write_f,CG_NODE_FAMILY_WRITE_F)482 CGNSDLL void FMNAME(cg_node_family_write_f, CG_NODE_FAMILY_WRITE_F) (
483 STR_PSTR(family_name), cgint_f *F, cgint_f *ier STR_PLEN(family_name))
484 {
485 char c_name[CGIO_MAX_NAME_LENGTH+1];
486 int i_F;
487
488 string_2_C_string(STR_PTR(family_name), STR_LEN(family_name),
489 c_name, CGIO_MAX_NAME_LENGTH, ier);
490 if (*ier) return;
491 *ier = (cgint_f)cg_node_family_write(c_name, &i_F);
492 *F = (cgint_f)i_F;
493 }
494
495 /*-----------------------------------------------------------------------*/
496
cg_nfamily_names_f(cgint_f * fn,cgint_f * B,cgint_f * F,cgint_f * nnames,cgint_f * ier)497 CGNSDLL void cg_nfamily_names_f(cgint_f *fn,
498 cgint_f *B, cgint_f *F, cgint_f *nnames, cgint_f *ier)
499 {
500 int i_nnames;
501
502 *ier = (cgint_f)cg_nfamily_names((int)*fn, (int)*B, (int)*F, &i_nnames);
503 *nnames = (cgint_f)i_nnames;
504 }
505
cg_node_nfamily_names_f(cgint_f * nnames,cgint_f * ier)506 CGNSDLL void cg_node_nfamily_names_f(cgint_f *nnames, cgint_f *ier)
507 {
508 int i_nnames;
509
510 *ier = (cgint_f)cg_node_nfamily_names(&i_nnames);
511 *nnames = (cgint_f)i_nnames;
512 }
513 /*-----------------------------------------------------------------------*/
514
FMNAME(cg_family_name_read_f,CG_FAMILY_NAME_READ_F)515 CGNSDLL void FMNAME(cg_family_name_read_f, CG_FAMILY_NAME_READ_F) (cgint_f *fn,
516 cgint_f *B, cgint_f *F, cgint_f *N, STR_PSTR(name), STR_PSTR(family),
517 cgint_f *ier STR_PLEN(name) STR_PLEN(family))
518 {
519 char c_name[CGIO_MAX_NAME_LENGTH+1];
520 char c_family[CGIO_MAX_NAME_LENGTH+1];
521
522 *ier = (cgint_f)cg_family_name_read((int)*fn, (int)*B, (int)*F, (int)*N, c_name, c_family);
523 if (*ier) return;
524 string_2_F_string(c_name, STR_PTR(name), STR_LEN(name), ier);
525 if (*ier) return;
526 string_2_F_string(c_family, STR_PTR(family), STR_LEN(family), ier);
527 }
528
FMNAME(cg_node_family_name_read_f,CG_NODE_FAMILY_NAME_READ_F)529 CGNSDLL void FMNAME(cg_node_family_name_read_f, CG_NODE_FAMILY_NAME_READ_F) (
530 cgint_f *N, STR_PSTR(name), STR_PSTR(family),
531 cgint_f *ier STR_PLEN(name) STR_PLEN(family))
532 {
533 char c_name[CGIO_MAX_NAME_LENGTH+1];
534 char c_family[CGIO_MAX_NAME_LENGTH+1];
535
536 *ier = (cgint_f)cg_node_family_name_read((int)*N, c_name, c_family);
537 if (*ier) return;
538 string_2_F_string(c_name, STR_PTR(name), STR_LEN(name), ier);
539 if (*ier) return;
540 string_2_F_string(c_family, STR_PTR(family), STR_LEN(family), ier);
541 }
542
543 /*-----------------------------------------------------------------------*/
544
FMNAME(cg_family_name_write_f,CG_FAMILY_NAME_WRITE_F)545 CGNSDLL void FMNAME(cg_family_name_write_f, CG_FAMILY_NAME_WRITE_F) (cgint_f *fn,
546 cgint_f *B, cgint_f *F, STR_PSTR(name), STR_PSTR(family),
547 cgint_f *ier STR_PLEN(name) STR_PLEN(family))
548 {
549 char c_name[CGIO_MAX_NAME_LENGTH+1];
550 char c_family[CGIO_MAX_NAME_LENGTH+1];
551
552 string_2_C_string(STR_PTR(name), STR_LEN(name),
553 c_name, CGIO_MAX_NAME_LENGTH, ier);
554 if (*ier) return;
555 string_2_C_string(STR_PTR(family), STR_LEN(family),
556 c_family, CGIO_MAX_NAME_LENGTH, ier);
557 if (*ier) return;
558 *ier = (cgint_f)cg_family_name_write((int)*fn, (int)*B, (int)*F, c_name, c_family);
559 }
560
FMNAME(cg_node_family_name_write_f,CG_NODE_FAMILY_NAME_WRITE_F)561 CGNSDLL void FMNAME(cg_node_family_name_write_f, CG_NODE_FAMILY_NAME_WRITE_F) (
562 STR_PSTR(name), STR_PSTR(family),
563 cgint_f *ier STR_PLEN(name) STR_PLEN(family))
564 {
565 char c_name[CGIO_MAX_NAME_LENGTH+1];
566 char c_family[CGIO_MAX_NAME_LENGTH+1];
567
568 string_2_C_string(STR_PTR(name), STR_LEN(name),
569 c_name, CGIO_MAX_NAME_LENGTH, ier);
570 if (*ier) return;
571 string_2_C_string(STR_PTR(family), STR_LEN(family),
572 c_family, CGIO_MAX_NAME_LENGTH, ier);
573 if (*ier) return;
574 *ier = (cgint_f)cg_node_family_name_write(c_name, c_family);
575 }
576
577 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
578 * Read and write FamBC_t Nodes *
579 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
580
FMNAME(cg_fambc_read_f,CG_FAMBC_READ_F)581 CGNSDLL void FMNAME(cg_fambc_read_f, CG_FAMBC_READ_F) (cgint_f *fn, cgint_f *B,
582 cgint_f *F, cgint_f *BC, STR_PSTR(fambc_name), CGNS_ENUMT(BCType_t) *bocotype,
583 cgint_f *ier STR_PLEN(fambc_name))
584 {
585 char c_name[CGIO_MAX_NAME_LENGTH+1];
586 CGNS_ENUMT(BCType_t) i_bocotype;
587
588 *ier = (cgint_f)cg_fambc_read((int)*fn, (int)*B, (int)*F, (int)*BC,
589 c_name, &i_bocotype);
590 if (*ier) return;
591 string_2_F_string(c_name, STR_PTR(fambc_name), STR_LEN(fambc_name), ier);
592
593 *bocotype = (CGNS_ENUMT(BCType_t))i_bocotype;
594 }
595
FMNAME(cg_node_fambc_read_f,CG_NODE_FAMBC_READ_F)596 CGNSDLL void FMNAME(cg_node_fambc_read_f, CG_NODE_FAMBC_READ_F) (
597 cgint_f *BC, STR_PSTR(fambc_name), CGNS_ENUMT(BCType_t) *bocotype,
598 cgint_f *ier STR_PLEN(fambc_name))
599 {
600 char c_name[CGIO_MAX_NAME_LENGTH+1];
601 CGNS_ENUMT(BCType_t) i_bocotype;
602
603 *ier = (cgint_f)cg_node_fambc_read((int)*BC, c_name, &i_bocotype);
604 if (*ier) return;
605 string_2_F_string(c_name, STR_PTR(fambc_name), STR_LEN(fambc_name), ier);
606
607 *bocotype = (CGNS_ENUMT(BCType_t))i_bocotype;
608 }
609
610 /*-----------------------------------------------------------------------*/
611
FMNAME(cg_fambc_write_f,CG_FAMBC_WRITE_F)612 CGNSDLL void FMNAME(cg_fambc_write_f, CG_FAMBC_WRITE_F) (cgint_f *fn,
613 cgint_f *B, cgint_f *F, STR_PSTR(fambc_name), CGNS_ENUMT(BCType_t) *bocotype,
614 cgint_f *BC, cgint_f *ier STR_PLEN(fambc_name))
615 {
616 char c_name[CGIO_MAX_NAME_LENGTH+1];
617 int i_BC;
618
619 string_2_C_string(STR_PTR(fambc_name), STR_LEN(fambc_name),
620 c_name, CGIO_MAX_NAME_LENGTH, ier);
621 if (*ier) return;
622 *ier = (cgint_f)cg_fambc_write((int)*fn, (int)*B, (int)*F, c_name,
623 (CGNS_ENUMT(BCType_t))*bocotype, &i_BC);
624 *BC = (cgint_f)i_BC;
625 }
626
FMNAME(cg_node_fambc_write_f,CG_NODE_FAMBC_WRITE_F)627 CGNSDLL void FMNAME(cg_node_fambc_write_f, CG_NODE_FAMBC_WRITE_F) (
628 STR_PSTR(fambc_name), CGNS_ENUMT(BCType_t) *bocotype,
629 cgint_f *BC, cgint_f *ier STR_PLEN(fambc_name))
630 {
631 char c_name[CGIO_MAX_NAME_LENGTH+1];
632 int i_BC;
633
634 string_2_C_string(STR_PTR(fambc_name), STR_LEN(fambc_name),
635 c_name, CGIO_MAX_NAME_LENGTH, ier);
636 if (*ier) return;
637 *ier = (cgint_f)cg_node_fambc_write(c_name,
638 (CGNS_ENUMT(BCType_t))*bocotype, &i_BC);
639 *BC = (cgint_f)i_BC;
640 }
641
642 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
643 * Read and write GeometryReference_t Nodes *
644 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
645
FMNAME(cg_geo_read_f,CG_GEO_READ_F)646 CGNSDLL void FMNAME(cg_geo_read_f, CG_GEO_READ_F) (cgint_f *fn, cgint_f *B,
647 cgint_f *F, cgint_f *G, STR_PSTR(geo_name), STR_PSTR(geo_file),
648 STR_PSTR(CAD_name), cgint_f *npart, cgint_f *ier STR_PLEN(geo_name)
649 STR_PLEN(geo_file) STR_PLEN(CAD_name))
650 {
651 char c_geo_name[CGIO_MAX_NAME_LENGTH+1];
652 char c_CAD_name[CGIO_MAX_NAME_LENGTH+1];
653 char *c_geo_file;
654 int i_npart;
655
656 *ier = (cgint_f)cg_geo_read((int)*fn, (int)*B, (int)*F, (int)*G, c_geo_name,
657 &c_geo_file, c_CAD_name, &i_npart);
658 if (*ier) return;
659 *npart = (cgint_f)i_npart;
660 string_2_F_string(c_geo_file, STR_PTR(geo_file), STR_LEN(geo_file), ier);
661 CGNS_FREE(c_geo_file);
662 if (*ier) return;
663 string_2_F_string(c_geo_name, STR_PTR(geo_name), STR_LEN(geo_name), ier);
664 if (*ier) return;
665 string_2_F_string(c_CAD_name, STR_PTR(CAD_name), STR_LEN(CAD_name), ier);
666 }
667
FMNAME(cg_node_geo_read_f,CG_NODE_GEO_READ_F)668 CGNSDLL void FMNAME(cg_node_geo_read_f, CG_NODE_GEO_READ_F) (
669 cgint_f *G, STR_PSTR(geo_name), STR_PSTR(geo_file),
670 STR_PSTR(CAD_name), cgint_f *npart, cgint_f *ier STR_PLEN(geo_name)
671 STR_PLEN(geo_file) STR_PLEN(CAD_name))
672 {
673 char c_geo_name[CGIO_MAX_NAME_LENGTH+1];
674 char c_CAD_name[CGIO_MAX_NAME_LENGTH+1];
675 char *c_geo_file;
676 int i_npart;
677
678 *ier = (cgint_f)cg_node_geo_read((int)*G, c_geo_name,
679 &c_geo_file, c_CAD_name, &i_npart);
680 if (*ier) return;
681 *npart = (cgint_f)i_npart;
682 string_2_F_string(c_geo_file, STR_PTR(geo_file), STR_LEN(geo_file), ier);
683 CGNS_FREE(c_geo_file);
684 if (*ier) return;
685 string_2_F_string(c_geo_name, STR_PTR(geo_name), STR_LEN(geo_name), ier);
686 if (*ier) return;
687 string_2_F_string(c_CAD_name, STR_PTR(CAD_name), STR_LEN(CAD_name), ier);
688 }
689
690 /*-----------------------------------------------------------------------*/
691
FMNAME(cg_geo_write_f,CG_GEO_WRITE_F)692 CGNSDLL void FMNAME(cg_geo_write_f, CG_GEO_WRITE_F) (cgint_f *fn, cgint_f *B,
693 cgint_f *F, STR_PSTR(geo_name), STR_PSTR(geo_file), STR_PSTR(CAD_name),
694 cgint_f *G, cgint_f *ier STR_PLEN(geo_name) STR_PLEN(geo_file)
695 STR_PLEN(CAD_name))
696 {
697 char c_geo_name[CGIO_MAX_NAME_LENGTH+1];
698 char c_CAD_name[CGIO_MAX_NAME_LENGTH+1];
699 char *c_geo_file;
700 int length, i_G;
701
702 /* convert Fortran-text-string to a C-string */
703 string_2_C_string(STR_PTR(geo_name), STR_LEN(geo_name),
704 c_geo_name, CGIO_MAX_NAME_LENGTH, ier);
705 if (*ier) return;
706 string_2_C_string(STR_PTR(CAD_name), STR_LEN(CAD_name),
707 c_CAD_name, CGIO_MAX_NAME_LENGTH, ier);
708 if (*ier) return;
709
710 length = STR_LEN(geo_file);
711 c_geo_file = CGNS_NEW(char, length+1);
712 string_2_C_string(STR_PTR(geo_file), STR_LEN(geo_file),
713 c_geo_file, length, ier);
714 if (*ier == 0) {
715 *ier = (cgint_f)cg_geo_write((int)*fn, (int)*B, (int)*F, c_geo_name,
716 c_geo_file, c_CAD_name, &i_G);
717 *G = (cgint_f)i_G;
718 }
719 CGNS_FREE(c_geo_file);
720 }
721
FMNAME(cg_node_geo_write_f,CG_NODE_GEO_WRITE_F)722 CGNSDLL void FMNAME(cg_node_geo_write_f, CG_NODE_GEO_WRITE_F) (
723 STR_PSTR(geo_name), STR_PSTR(geo_file), STR_PSTR(CAD_name),
724 cgint_f *G, cgint_f *ier STR_PLEN(geo_name) STR_PLEN(geo_file)
725 STR_PLEN(CAD_name))
726 {
727 char c_geo_name[CGIO_MAX_NAME_LENGTH+1];
728 char c_CAD_name[CGIO_MAX_NAME_LENGTH+1];
729 char *c_geo_file;
730 int length, i_G;
731
732 /* convert Fortran-text-string to a C-string */
733 string_2_C_string(STR_PTR(geo_name), STR_LEN(geo_name),
734 c_geo_name, CGIO_MAX_NAME_LENGTH, ier);
735 if (*ier) return;
736 string_2_C_string(STR_PTR(CAD_name), STR_LEN(CAD_name),
737 c_CAD_name, CGIO_MAX_NAME_LENGTH, ier);
738 if (*ier) return;
739
740 length = STR_LEN(geo_file);
741 c_geo_file = CGNS_NEW(char, length+1);
742 string_2_C_string(STR_PTR(geo_file), STR_LEN(geo_file),
743 c_geo_file, length, ier);
744 if (*ier == 0) {
745 *ier = (cgint_f)cg_node_geo_write(c_geo_name,
746 c_geo_file, c_CAD_name, &i_G);
747 *G = (cgint_f)i_G;
748 }
749 CGNS_FREE(c_geo_file);
750 }
751
752 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
753 * Read and write GeometryEntity_t Nodes *
754 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
755
FMNAME(cg_part_read_f,CG_PART_READ_F)756 CGNSDLL void FMNAME(cg_part_read_f, CG_PART_READ_F) (cgint_f *fn, cgint_f *B,
757 cgint_f *F,cgint_f *G, cgint_f *P, STR_PSTR(part_name),
758 cgint_f *ier STR_PLEN(part_name))
759 {
760 char c_part_name[CGIO_MAX_NAME_LENGTH+1];
761
762 *ier = (cgint_f)cg_part_read((int)*fn, (int)*B, (int)*F, (int)*G, (int)*P, c_part_name);
763 if (*ier == 0)
764 string_2_F_string(c_part_name, STR_PTR(part_name), STR_LEN(part_name), ier);
765 }
766
FMNAME(cg_node_part_read_f,CG_NODE_PART_READ_F)767 CGNSDLL void FMNAME(cg_node_part_read_f, CG_NODE_PART_READ_F) (
768 cgint_f *G, cgint_f *P, STR_PSTR(part_name),
769 cgint_f *ier STR_PLEN(part_name))
770 {
771 char c_part_name[CGIO_MAX_NAME_LENGTH+1];
772
773 *ier = (cgint_f)cg_node_part_read((int)*G, (int)*P, c_part_name);
774 if (*ier == 0)
775 string_2_F_string(c_part_name, STR_PTR(part_name), STR_LEN(part_name), ier);
776 }
777
778 /*-----------------------------------------------------------------------*/
779
FMNAME(cg_part_write_f,CG_PART_WRITE_F)780 CGNSDLL void FMNAME(cg_part_write_f, CG_PART_WRITE_F) (cgint_f *fn, cgint_f *B,
781 cgint_f *F, cgint_f *G, STR_PSTR(part_name), cgint_f *P,
782 cgint_f *ier STR_PLEN(part_name))
783 {
784 char c_part_name[CGIO_MAX_NAME_LENGTH+1];
785 int i_P;
786
787 /* convert Fortran-text-string to a C-string */
788 string_2_C_string(STR_PTR(part_name), STR_LEN(part_name),
789 c_part_name, CGIO_MAX_NAME_LENGTH, ier);
790 if (*ier) return;
791 *ier = (cgint_f)cg_part_write((int)*fn, (int)*B, (int)*F, (int)*G, c_part_name, &i_P);
792 *P = (cgint_f)i_P;
793 }
794
FMNAME(cg_node_part_write_f,CG_NODE_PART_WRITE_F)795 CGNSDLL void FMNAME(cg_node_part_write_f, CG_NODE_PART_WRITE_F) (
796 cgint_f *G, STR_PSTR(part_name), cgint_f *P,
797 cgint_f *ier STR_PLEN(part_name))
798 {
799 char c_part_name[CGIO_MAX_NAME_LENGTH+1];
800 int i_P;
801
802 /* convert Fortran-text-string to a C-string */
803 string_2_C_string(STR_PTR(part_name), STR_LEN(part_name),
804 c_part_name, CGIO_MAX_NAME_LENGTH, ier);
805 if (*ier) return;
806 *ier = (cgint_f)cg_node_part_write((int)*G, c_part_name, &i_P);
807 *P = (cgint_f)i_P;
808 }
809
810 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
811 * Read and write DiscreteData_t Nodes *
812 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
813
cg_ndiscrete_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * ndiscrete,cgint_f * ier)814 CGNSDLL void cg_ndiscrete_f(cgint_f *fn, cgint_f *B,
815 cgint_f *Z, cgint_f *ndiscrete, cgint_f *ier)
816 {
817 int i_ndiscrete;
818
819 *ier = (cgint_f)cg_ndiscrete((int)*fn, (int)*B, (int)*Z, &i_ndiscrete);
820 *ndiscrete = (cgint_f)i_ndiscrete;
821 }
822
823 /*-----------------------------------------------------------------------*/
824
FMNAME(cg_discrete_read_f,CG_DISCRETE_READ_F)825 CGNSDLL void FMNAME(cg_discrete_read_f, CG_DISCRETE_READ_F) (cgint_f *fn,
826 cgint_f *B, cgint_f *Z, cgint_f *D, STR_PSTR(discrete_name),
827 cgint_f *ier STR_PLEN(discrete_name))
828 {
829 char c_name[CGIO_MAX_NAME_LENGTH+1];
830
831 *ier = (cgint_f)cg_discrete_read((int)*fn, (int)*B, (int)*Z, (int)*D, c_name);
832 if (*ier == 0)
833 string_2_F_string(c_name, STR_PTR(discrete_name), STR_LEN(discrete_name), ier);
834 }
835
836 /*-----------------------------------------------------------------------*/
837
FMNAME(cg_discrete_write_f,CG_DISCRETE_WRITE_F)838 CGNSDLL void FMNAME(cg_discrete_write_f, CG_DISCRETE_WRITE_F) (cgint_f *fn,
839 cgint_f *B, cgint_f *Z, STR_PSTR(discrete_name), cgint_f *D,
840 cgint_f *ier STR_PLEN(discrete_name))
841 {
842 char c_name[CGIO_MAX_NAME_LENGTH+1];
843 int i_D;
844
845 string_2_C_string(STR_PTR(discrete_name), STR_LEN(discrete_name),
846 c_name, CGIO_MAX_NAME_LENGTH, ier);
847 if (*ier) return;
848 #if DEBUG_FTOC
849 printf(" discrete_name='%s'\n", c_name);
850 #endif
851 *ier = (cgint_f)cg_discrete_write((int)*fn, (int)*B, (int)*Z, c_name, &i_D);
852 *D = (cgint_f)i_D;
853 }
854
855 /*-----------------------------------------------------------------------*/
856
cg_discrete_size_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * D,cgint_f * ndim,cgsize_t * dims,cgint_f * ier)857 CGNSDLL void cg_discrete_size_f(cgint_f *fn,
858 cgint_f *B, cgint_f *Z, cgint_f *D, cgint_f *ndim,
859 cgsize_t *dims, cgint_f *ier)
860 {
861 int i_ndim;
862
863 *ier = (cgint_f)cg_discrete_size((int)*fn, (int)*B, (int)*Z, (int)*D,
864 &i_ndim, dims);
865 *ndim = (cgint_f)i_ndim;
866 }
867
868 /*-----------------------------------------------------------------------*/
869
cg_discrete_ptset_info_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * S,CGNS_ENUMT (PointSetType_t)* ptype,cgsize_t * npnts,cgint_f * ier)870 CGNSDLL void cg_discrete_ptset_info_f(
871 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S,
872 CGNS_ENUMT(PointSetType_t) *ptype, cgsize_t *npnts, cgint_f *ier)
873 {
874 CGNS_ENUMT(PointSetType_t) i_ptype;
875
876 *ier = (cgint_f)cg_discrete_ptset_info((int)*fn, (int)*B, (int)*Z,
877 (int)*S, &i_ptype, npnts);
878 *ptype = (CGNS_ENUMT(PointSetType_t))i_ptype;
879 }
880
881 /*-----------------------------------------------------------------------*/
882
cg_discrete_ptset_read_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * S,cgsize_t * pnts,cgint_f * ier)883 CGNSDLL void cg_discrete_ptset_read_f(
884 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S,
885 cgsize_t *pnts, cgint_f *ier)
886 {
887 *ier = (cgint_f)cg_discrete_ptset_read((int)*fn, (int)*B, (int)*Z,
888 (int)*S, pnts);
889 }
890
891 /*-----------------------------------------------------------------------*/
892
FMNAME(cg_discrete_ptset_write_f,CG_DISCRETE_PTSET_WRITE_F)893 CGNSDLL void FMNAME(cg_discrete_ptset_write_f, CG_DISCRETE_PTSET_WRITE_F) (
894 cgint_f *fn, cgint_f *B, cgint_f *Z, STR_PSTR(name),
895 CGNS_ENUMT(GridLocation_t) *location, CGNS_ENUMT(PointSetType_t) *ptype, cgsize_t *npnts,
896 cgsize_t *pnts, cgint_f *D, cgint_f *ier STR_PLEN(name))
897 {
898 char c_name[CGIO_MAX_NAME_LENGTH+1];
899 int i_D;
900
901 string_2_C_string(STR_PTR(name), STR_LEN(name),
902 c_name, CGIO_MAX_NAME_LENGTH, ier);
903 if (*ier) return;
904
905 *ier = (cgint_f)cg_discrete_ptset_write((int)*fn, (int)*B, (int)*Z, c_name,
906 (CGNS_ENUMT(GridLocation_t))*location,
907 (CGNS_ENUMT(PointSetType_t))*ptype, *npnts, pnts, &i_D);
908
909 *D = (cgint_f)i_D;
910 }
911
912 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
913 * Read and write GridCoordinates_t/DataArray_t Nodes *
914 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
915
cg_ncoords_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * ncoords,cgint_f * ier)916 CGNSDLL void cg_ncoords_f(cgint_f *fn, cgint_f *B,
917 cgint_f *Z, cgint_f *ncoords, cgint_f *ier)
918 {
919 int i_ncoords;
920
921 *ier = (cgint_f)cg_ncoords((int)*fn, (int)*B, (int)*Z, &i_ncoords);
922 *ncoords = (cgint_f)i_ncoords;
923 }
924
925 /*-----------------------------------------------------------------------*/
926
FMNAME(cg_coord_info_f,CG_COORD_INFO_F)927 CGNSDLL void FMNAME(cg_coord_info_f, CG_COORD_INFO_F) (cgint_f *fn, cgint_f *B,
928 cgint_f *Z, cgint_f *C, CGNS_ENUMT(DataType_t) *type, STR_PSTR(coordname),
929 cgint_f *ier STR_PLEN(coordname))
930 {
931 char c_name[CGIO_MAX_NAME_LENGTH+1];
932 CGNS_ENUMT(DataType_t) i_type;
933
934 *ier = (cgint_f)cg_coord_info((int)*fn, (int)*B, (int)*Z, (int)*C, &i_type, c_name);
935 if (*ier) return;
936 *type = (CGNS_ENUMT(DataType_t))i_type;
937 string_2_F_string(c_name, STR_PTR(coordname), STR_LEN(coordname), ier);
938
939 }
940
941 /*-----------------------------------------------------------------------*/
942
FMNAME(cg_coord_read_f,CG_COORD_READ_F)943 CGNSDLL void FMNAME(cg_coord_read_f, CG_COORD_READ_F) (cgint_f *fn, cgint_f *B,
944 cgint_f *Z, STR_PSTR(coordname), CGNS_ENUMT(DataType_t) *type, cgsize_t *rmin,
945 cgsize_t *rmax, void *coord, cgint_f *ier STR_PLEN(coordname))
946 {
947 char c_name[CGIO_MAX_NAME_LENGTH+1];
948
949 string_2_C_string(STR_PTR(coordname), STR_LEN(coordname),
950 c_name, CGIO_MAX_NAME_LENGTH, ier);
951 if (*ier) return;
952 #if DEBUG_FTOC
953 printf("coordname='%s'\n", c_name);
954 #endif
955 *ier = (cgint_f)cg_coord_read((int)*fn, (int)*B, (int)*Z, c_name,
956 *type, rmin, rmax, coord);
957 }
958
959 /*-----------------------------------------------------------------------*/
960
FMNAME(cg_coord_general_read_f,CG_COORD_GENERAL_READ_F)961 CGNSDLL void FMNAME(cg_coord_general_read_f, CG_COORD_GENERAL_READ_F) (
962 cgint_f *fn, cgint_f *B, cgint_f *Z, STR_PSTR(coordname),
963 cgsize_t *s_rmin, cgsize_t *s_rmax, CGNS_ENUMT(DataType_t) *m_type,
964 cgint_f *m_numdim, cgsize_t *m_dimvals,
965 cgsize_t *m_rmin, cgsize_t *m_rmax, void *coord,
966 cgint_f *ier STR_PLEN(coordname))
967 {
968 char c_name[CGIO_MAX_NAME_LENGTH+1];
969
970 string_2_C_string(STR_PTR(coordname), STR_LEN(coordname),
971 c_name, CGIO_MAX_NAME_LENGTH, ier);
972 if (*ier) return;
973 #if DEBUG_FTOC
974 printf("coordname='%s'\n", c_name);
975 #endif
976 *ier = (cgint_f)cg_coord_general_read(
977 (int)*fn, (int)*B, (int)*Z, c_name,
978 s_rmin, s_rmax,
979 *m_type, (int)*m_numdim, m_dimvals, m_rmin, m_rmax, coord);
980 }
981
982 /*-----------------------------------------------------------------------*/
983
cg_coord_id_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * C,double * coord_id,cgint_f * ier)984 CGNSDLL void cg_coord_id_f(cgint_f *fn, cgint_f *B,
985 cgint_f *Z, cgint_f *C, double *coord_id, cgint_f *ier)
986 {
987 *ier = (cgint_f)cg_coord_id((int)*fn, (int)*B, (int)*Z, (int)*C, coord_id);
988 }
989
990 /*-----------------------------------------------------------------------*/
991
FMNAME(cg_coord_write_f,CG_COORD_WRITE_F)992 CGNSDLL void FMNAME(cg_coord_write_f, CG_COORD_WRITE_F) (cgint_f *fn, cgint_f *B,
993 cgint_f *Z, CGNS_ENUMT(DataType_t) *type, STR_PSTR(coordname), void *coord, cgint_f *C,
994 cgint_f *ier STR_PLEN(coordname))
995 {
996 char c_name[CGIO_MAX_NAME_LENGTH+1];
997 int i_C;
998
999 string_2_C_string(STR_PTR(coordname), STR_LEN(coordname),
1000 c_name, CGIO_MAX_NAME_LENGTH, ier);
1001 if (*ier) return;
1002 #if DEBUG_FTOC
1003 printf(" coordname='%s'\n", c_name);
1004 #endif
1005 *ier = (cgint_f)cg_coord_write((int)*fn, (int)*B, (int)*Z,
1006 (CGNS_ENUMT(DataType_t))*type, c_name, coord, &i_C);
1007 *C = (cgint_f)i_C;
1008 }
1009
1010 /*-----------------------------------------------------------------------*/
1011
FMNAME(cg_coord_partial_write_f,CG_COORD_PARTIAL_WRITE_F)1012 CGNSDLL void FMNAME(cg_coord_partial_write_f, CG_COORD_PARTIAL_WRITE_F) (
1013 cgint_f *fn, cgint_f *B, cgint_f *Z, CGNS_ENUMT(DataType_t) *type, STR_PSTR(coordname),
1014 cgsize_t *rmin, cgsize_t *rmax, void *coord, cgint_f *C,
1015 cgint_f *ier STR_PLEN(coordname))
1016 {
1017 char c_name[CGIO_MAX_NAME_LENGTH+1];
1018 int i_C;
1019
1020 string_2_C_string(STR_PTR(coordname), STR_LEN(coordname),
1021 c_name, CGIO_MAX_NAME_LENGTH, ier);
1022 if (*ier) return;
1023 #if DEBUG_FTOC
1024 printf(" coordname='%s'\n", c_name);
1025 #endif
1026 *ier = (cgint_f)cg_coord_partial_write((int)*fn, (int)*B, (int)*Z,
1027 (CGNS_ENUMT(DataType_t))*type, c_name, rmin, rmax,
1028 coord, &i_C);
1029 *C = (cgint_f)i_C;
1030 }
1031
1032 /*-----------------------------------------------------------------------*/
1033
FMNAME(cg_coord_general_write_f,CG_COORD_GENERAL_WRITE_F)1034 CGNSDLL void FMNAME(cg_coord_general_write_f, CG_COORD_GENERAL_WRITE_F) (
1035 cgint_f *fn, cgint_f *B, cgint_f *Z, STR_PSTR(coordname),
1036 CGNS_ENUMT(DataType_t) *s_type, cgsize_t *s_rmin, cgsize_t *s_rmax,
1037 CGNS_ENUMT(DataType_t) *m_type, cgint_f *m_numdim, cgsize_t *m_dims,
1038 cgsize_t *m_rmin, cgsize_t *m_rmax, void *coord, cgint_f *C,
1039 cgint_f *ier STR_PLEN(coordname))
1040 {
1041 char c_name[CGIO_MAX_NAME_LENGTH+1];
1042 int i_C;
1043
1044 string_2_C_string(STR_PTR(coordname), STR_LEN(coordname),
1045 c_name, CGIO_MAX_NAME_LENGTH, ier);
1046 if (*ier) return;
1047 #if DEBUG_FTOC
1048 printf(" coordname='%s'\n", c_name);
1049 #endif
1050 *ier = (cgint_f)cg_coord_general_write((int)*fn, (int)*B, (int)*Z,
1051 c_name, *s_type, s_rmin, s_rmax,
1052 *m_type, (int)*m_numdim, m_dims,
1053 m_rmin, m_rmax, coord, &i_C);
1054 *C = (cgint_f)i_C;
1055 }
1056
1057 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
1058 * Read and write Elements_t Nodes *
1059 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1060
cg_nsections_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * nsections,cgint_f * ier)1061 CGNSDLL void cg_nsections_f(cgint_f *fn, cgint_f *B,
1062 cgint_f *Z, cgint_f *nsections, cgint_f *ier)
1063 {
1064 int i_nsections;
1065
1066 *ier = (cgint_f)cg_nsections((int)*fn, (int)*B, (int)*Z, &i_nsections);
1067 *nsections = (cgint_f)i_nsections;
1068 }
1069
1070 /*-----------------------------------------------------------------------*/
1071
FMNAME(cg_section_read_f,CG_SECTION_READ_F)1072 CGNSDLL void FMNAME(cg_section_read_f, CG_SECTION_READ_F) (cgint_f *fn,
1073 cgint_f *B, cgint_f *Z, cgint_f *E, STR_PSTR(section_name),
1074 CGNS_ENUMT(ElementType_t) *type, cgsize_t *start, cgsize_t *end, cgint_f *nbndry,
1075 cgint_f *parent_flag, cgint_f *ier STR_PLEN(section_name))
1076 {
1077 char c_name[CGIO_MAX_NAME_LENGTH+1];
1078 CGNS_ENUMT(ElementType_t) i_type;
1079 int i_nbndry, i_parent_flag;
1080
1081 *ier = (cgint_f)cg_section_read((int)*fn, (int)*B, (int)*Z, (int)*E, c_name,
1082 &i_type, start, end, &i_nbndry, &i_parent_flag);
1083 if (*ier) return;
1084 *type = (CGNS_ENUMT(ElementType_t))i_type;
1085 *nbndry = (cgint_f)i_nbndry;
1086 *parent_flag = (cgint_f)i_parent_flag;
1087 string_2_F_string(c_name, STR_PTR(section_name), STR_LEN(section_name), ier);
1088 }
1089
1090 /*-----------------------------------------------------------------------*/
1091
FMNAME(cg_elements_read_f,CG_ELEMENTS_READ_F)1092 CGNSDLL void FMNAME(cg_elements_read_f, CG_ELEMENTS_READ_F) (cgint_f *fn,
1093 cgint_f *B, cgint_f *Z, cgint_f *E, cgsize_t *elements,
1094 cgsize_t *parent_data, cgint_f *ier)
1095 {
1096 *ier = (cgint_f)cg_elements_read((int)*fn, (int)*B, (int)*Z, (int)*E,
1097 elements, parent_data);
1098 }
1099
1100 /*-----------------------------------------------------------------------*/
1101
FMNAME(cg_poly_elements_read_f,CG_POLY_ELEMENTS_READ_F)1102 CGNSDLL void FMNAME(cg_poly_elements_read_f, CG_POLY_ELEMENTS_READ_F) (cgint_f *fn,
1103 cgint_f *B, cgint_f *Z, cgint_f *E, cgsize_t *elements,
1104 cgsize_t *connect_offset, cgsize_t *parent_data, cgint_f *ier)
1105 {
1106 *ier = (cgint_f)cg_poly_elements_read((int)*fn, (int)*B, (int)*Z, (int)*E,
1107 elements, connect_offset, parent_data);
1108 }
1109
1110 /*-----------------------------------------------------------------------*/
1111
cg_elementdatasize_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * E,cgsize_t * ElementDataSize,cgint_f * ier)1112 CGNSDLL void cg_elementdatasize_f(cgint_f *fn,
1113 cgint_f *B, cgint_f *Z, cgint_f *E, cgsize_t *ElementDataSize,
1114 cgint_f *ier)
1115 {
1116 *ier = (cgint_f)cg_ElementDataSize((int)*fn, (int)*B, (int)*Z, (int)*E,
1117 ElementDataSize);
1118 }
1119
1120 /*-----------------------------------------------------------------------*/
1121
cg_elementpartialsize_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * E,cgsize_t * start,cgsize_t * end,cgsize_t * ElementDataSize,cgint_f * ier)1122 CGNSDLL void cg_elementpartialsize_f(cgint_f *fn,
1123 cgint_f *B, cgint_f *Z, cgint_f *E, cgsize_t *start, cgsize_t *end,
1124 cgsize_t *ElementDataSize, cgint_f *ier)
1125 {
1126 *ier = (cgint_f)cg_ElementPartialSize((int)*fn, (int)*B, (int)*Z, (int)*E,
1127 *start, *end, ElementDataSize);
1128 }
1129
1130 /*-----------------------------------------------------------------------*/
1131
FMNAME(cg_section_write_f,CG_SECTION_WRITE_F)1132 CGNSDLL void FMNAME(cg_section_write_f, CG_SECTION_WRITE_F) (cgint_f *fn,
1133 cgint_f *B, cgint_f *Z, STR_PSTR(section_name), CGNS_ENUMT(ElementType_t)*type,
1134 cgsize_t *start, cgsize_t *end, cgint_f *nbndry, cgsize_t *elements,
1135 cgint_f *S, cgint_f *ier STR_PLEN(section_name))
1136 {
1137 char c_name[CGIO_MAX_NAME_LENGTH+1];
1138 int i_S;
1139
1140 /* convert Fortran-text-string to a C-string */
1141 string_2_C_string(STR_PTR(section_name), STR_LEN(section_name),
1142 c_name, CGIO_MAX_NAME_LENGTH, ier);
1143 if (*ier) return;
1144
1145 *ier = (cgint_f)cg_section_write((int)*fn, (int)*B, (int)*Z, c_name,
1146 *type, *start, *end,
1147 (int)*nbndry, elements, &i_S);
1148 *S = (cgint_f)i_S;
1149 }
1150
1151 /*-----------------------------------------------------------------------*/
1152
FMNAME(cg_poly_section_write_f,CG_POLY_SECTION_WRITE_F)1153 CGNSDLL void FMNAME(cg_poly_section_write_f, CG_POLY_SECTION_WRITE_F)
1154 (cgint_f *fn, cgint_f *B, cgint_f *Z, STR_PSTR(section_name),
1155 CGNS_ENUMT(ElementType_t)*type, cgsize_t *start, cgsize_t *end,
1156 cgint_f *nbndry, cgsize_t *elements, cgsize_t *connect_offset,
1157 cgint_f *S, cgint_f *ier STR_PLEN(section_name))
1158 {
1159 char c_name[CGIO_MAX_NAME_LENGTH+1];
1160 int i_S;
1161
1162 /* convert Fortran-text-string to a C-string */
1163 string_2_C_string(STR_PTR(section_name), STR_LEN(section_name),
1164 c_name, CGIO_MAX_NAME_LENGTH, ier);
1165 if (*ier) return;
1166
1167 *ier = (cgint_f)cg_poly_section_write((int)*fn, (int)*B, (int)*Z, c_name,
1168 *type, *start, *end,
1169 (int)*nbndry, elements, connect_offset, &i_S);
1170 *S = (cgint_f)i_S;
1171 }
1172
1173 /*-----------------------------------------------------------------------*/
1174
FMNAME(cg_parent_data_write_f,CG_PARENT_DATA_WRITE_F)1175 CGNSDLL void FMNAME(cg_parent_data_write_f, CG_PARENT_DATA_WRITE_F )(cgint_f *fn,
1176 cgint_f *B, cgint_f *Z, cgint_f *S, cgsize_t *parent_data, cgint_f *ier)
1177 {
1178 *ier = (cgint_f)cg_parent_data_write((int)*fn, (int)*B, (int)*Z, (int)*S, parent_data);
1179 }
1180
1181 /*-----------------------------------------------------------------------*/
1182
FMNAME(cg_section_partial_write_f,CG_SECTION_PARTIAL_WRITE_F)1183 CGNSDLL void FMNAME(cg_section_partial_write_f, CG_SECTION_PARTIAL_WRITE_F) (
1184 cgint_f *fn, cgint_f *B, cgint_f *Z, STR_PSTR(section_name),
1185 CGNS_ENUMT(ElementType_t)*type, cgsize_t *start, cgsize_t *end, cgint_f *nbndry,
1186 cgint_f *S, cgint_f *ier STR_PLEN(section_name))
1187 {
1188 char c_name[CGIO_MAX_NAME_LENGTH+1];
1189 int i_S;
1190
1191 /* convert Fortran-text-string to a C-string */
1192 string_2_C_string(STR_PTR(section_name), STR_LEN(section_name),
1193 c_name, CGIO_MAX_NAME_LENGTH, ier);
1194 if (*ier) return;
1195 *ier = (cgint_f)cg_section_partial_write((int)*fn, (int)*B, (int)*Z, c_name,
1196 *type, *start,
1197 *end, (int)*nbndry, &i_S);
1198 *S = (cgint_f)i_S;
1199 }
1200
1201 /*-----------------------------------------------------------------------*/
1202
FMNAME(cg_elements_partial_write_f,CG_ELEMENTS_PARTIAL_WRITE_F)1203 CGNSDLL void FMNAME(cg_elements_partial_write_f, CG_ELEMENTS_PARTIAL_WRITE_F) (
1204 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S, cgsize_t *rmin,
1205 cgsize_t *rmax, cgsize_t *elements, cgint_f *ier)
1206 {
1207 *ier = (cgint_f)cg_elements_partial_write((int)*fn, (int)*B, (int)*Z, (int)*S,
1208 *rmin, *rmax, elements);
1209 }
1210
1211 /*-----------------------------------------------------------------------*/
1212
FMNAME(cg_poly_elements_partial_write_f,CG_POLY_ELEMENTS_PARTIAL_WRITE_F)1213 CGNSDLL void FMNAME(cg_poly_elements_partial_write_f, CG_POLY_ELEMENTS_PARTIAL_WRITE_F) (
1214 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S, cgsize_t *rmin,
1215 cgsize_t *rmax, cgsize_t *elements, cgsize_t *connect_offset, cgint_f *ier)
1216 {
1217 *ier = (cgint_f)cg_poly_elements_partial_write((int)*fn, (int)*B, (int)*Z, (int)*S,
1218 *rmin, *rmax, elements, connect_offset);
1219 }
1220
1221 /*-----------------------------------------------------------------------*/
1222
FMNAME(cg_parent_data_partial_write_f,CG_PARENT_DATA_PARTIAL_WRITE_F)1223 CGNSDLL void FMNAME(cg_parent_data_partial_write_f, CG_PARENT_DATA_PARTIAL_WRITE_F) (
1224 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S, cgsize_t *rmin,
1225 cgsize_t *rmax, cgsize_t *parent_data, cgint_f *ier)
1226 {
1227 *ier = (cgint_f)cg_parent_data_partial_write((int)*fn, (int)*B, (int)*Z, (int)*S,
1228 *rmin, *rmax, parent_data);
1229 }
1230
1231 /*-----------------------------------------------------------------------*/
1232
FMNAME(cg_elements_partial_read_f,CG_ELEMENTS_PARTIAL_READ_F)1233 CGNSDLL void FMNAME(cg_elements_partial_read_f, CG_ELEMENTS_PARTIAL_READ_F) (
1234 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S, cgsize_t *rmin,
1235 cgsize_t *rmax, cgsize_t *elements, cgsize_t *parent, cgint_f *ier)
1236 {
1237 *ier = (cgint_f)cg_elements_partial_read((int)*fn, (int)*B, (int)*Z, (int)*S,
1238 *rmin, *rmax, elements, parent);
1239 }
1240
1241 /*-----------------------------------------------------------------------*/
1242
FMNAME(cg_poly_elements_partial_read_f,CG_POLY_ELEMENTS_PARTIAL_READ_F)1243 CGNSDLL void FMNAME(cg_poly_elements_partial_read_f, CG_POLY_ELEMENTS_PARTIAL_READ_F) (
1244 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S, cgsize_t *rmin,
1245 cgsize_t *rmax, cgsize_t *elements, cgsize_t *connect_offset, cgsize_t *parent, cgint_f *ier)
1246 {
1247 *ier = (cgint_f)cg_poly_elements_partial_read((int)*fn, (int)*B, (int)*Z, (int)*S,
1248 *rmin, *rmax, elements, connect_offset, parent);
1249 }
1250
1251 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
1252 * Read and write FlowSolution_t Nodes *
1253 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1254
cg_nsols_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * nsols,cgint_f * ier)1255 CGNSDLL void cg_nsols_f(cgint_f *fn, cgint_f *B,
1256 cgint_f *Z, cgint_f *nsols, cgint_f *ier)
1257 {
1258 int i_nsols;
1259
1260 *ier = (cgint_f)cg_nsols((int)*fn, (int)*B, (int)*Z, &i_nsols);
1261 *nsols = (cgint_f)i_nsols;
1262 }
1263
1264 /*-----------------------------------------------------------------------*/
1265
FMNAME(cg_sol_info_f,CG_SOL_INFO_F)1266 CGNSDLL void FMNAME(cg_sol_info_f, CG_SOL_INFO_F) (cgint_f *fn, cgint_f *B,
1267 cgint_f *Z, cgint_f *S, STR_PSTR(solname), CGNS_ENUMT(GridLocation_t) *location,
1268 cgint_f *ier STR_PLEN(solname))
1269 {
1270 char c_name[CGIO_MAX_NAME_LENGTH+1];
1271 CGNS_ENUMT(GridLocation_t) i_location;
1272
1273 *ier = (cgint_f)cg_sol_info((int)*fn, (int)*B, (int)*Z, (int)*S, c_name, &i_location);
1274 if (*ier) return;
1275 *location = (cgint_f)i_location;
1276 string_2_F_string(c_name, STR_PTR(solname), STR_LEN(solname), ier);
1277 }
1278
1279 /*-----------------------------------------------------------------------*/
1280
cg_sol_id_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * S,double * sol_id,cgint_f * ier)1281 CGNSDLL void cg_sol_id_f(cgint_f *fn, cgint_f *B,
1282 cgint_f *Z, cgint_f *S, double *sol_id, cgint_f *ier)
1283 {
1284 *ier = (cgint_f)cg_sol_id((int)*fn, (int)*B, (int)*Z, (int)*S, sol_id);
1285 }
1286
1287 /*-----------------------------------------------------------------------*/
1288
FMNAME(cg_sol_write_f,CG_SOL_WRITE_F)1289 CGNSDLL void FMNAME(cg_sol_write_f, CG_SOL_WRITE_F)(cgint_f *fn, cgint_f *B,
1290 cgint_f *Z, STR_PSTR(solname), CGNS_ENUMT(GridLocation_t)*location, cgint_f *S,
1291 cgint_f *ier STR_PLEN(solname))
1292 {
1293 char c_name[CGIO_MAX_NAME_LENGTH+1];
1294 int i_S;
1295
1296 string_2_C_string(STR_PTR(solname), STR_LEN(solname),
1297 c_name, CGIO_MAX_NAME_LENGTH, ier);
1298 if (*ier) return;
1299 #if DEBUG_FTOC
1300 printf("\n solname='%s'\n", c_name);
1301 #endif
1302 *ier = (cgint_f)cg_sol_write((int)*fn, (int)*B, (int)*Z, c_name,
1303 *location, &i_S);
1304 *S = (cgint_f)i_S;
1305 }
1306
1307 /*-----------------------------------------------------------------------*/
1308
cg_sol_size_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * S,cgint_f * ndim,cgsize_t * dims,cgint_f * ier)1309 CGNSDLL void cg_sol_size_f(cgint_f *fn,
1310 cgint_f *B, cgint_f *Z, cgint_f *S, cgint_f *ndim,
1311 cgsize_t *dims, cgint_f *ier)
1312 {
1313 int i_ndim;
1314
1315 *ier = (cgint_f)cg_sol_size((int)*fn, (int)*B, (int)*Z, (int)*S,
1316 &i_ndim, dims);
1317 *ndim = (cgint_f)i_ndim;
1318 }
1319
1320 /*-----------------------------------------------------------------------*/
1321
cg_sol_ptset_info_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * S,CGNS_ENUMT (PointSetType_t)* ptype,cgsize_t * npnts,cgint_f * ier)1322 CGNSDLL void cg_sol_ptset_info_f(
1323 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S,
1324 CGNS_ENUMT(PointSetType_t) *ptype, cgsize_t *npnts, cgint_f *ier)
1325 {
1326 CGNS_ENUMT(PointSetType_t) i_ptype;
1327
1328 *ier = (cgint_f)cg_sol_ptset_info((int)*fn, (int)*B, (int)*Z,
1329 (int)*S, &i_ptype, npnts);
1330 *ptype = i_ptype;
1331 }
1332
1333 /*-----------------------------------------------------------------------*/
1334
cg_sol_ptset_read_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * S,cgsize_t * pnts,cgint_f * ier)1335 CGNSDLL void cg_sol_ptset_read_f(
1336 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S,
1337 cgsize_t *pnts, cgint_f *ier)
1338 {
1339 *ier = (cgint_f)cg_sol_ptset_read((int)*fn, (int)*B, (int)*Z,
1340 (int)*S, pnts);
1341 }
1342
1343 /*-----------------------------------------------------------------------*/
1344
FMNAME(cg_sol_ptset_write_f,CG_SOL_PTSET_WRITE_F)1345 CGNSDLL void FMNAME(cg_sol_ptset_write_f, CG_SOL_PTSET_WRITE_F) (
1346 cgint_f *fn, cgint_f *B, cgint_f *Z, STR_PSTR(name),
1347 CGNS_ENUMT(GridLocation_t) *location, CGNS_ENUMT(PointSetType_t) *ptype, cgsize_t *npnts,
1348 cgsize_t *pnts, cgint_f *S, cgint_f *ier STR_PLEN(name))
1349 {
1350 char c_name[CGIO_MAX_NAME_LENGTH+1];
1351 int i_S;
1352
1353 string_2_C_string(STR_PTR(name), STR_LEN(name),
1354 c_name, CGIO_MAX_NAME_LENGTH, ier);
1355 if (*ier) return;
1356
1357 *ier = (cgint_f)cg_sol_ptset_write((int)*fn, (int)*B, (int)*Z, c_name,
1358 *location,
1359 *ptype, *npnts, pnts, &i_S);
1360 *S = (cgint_f)i_S;
1361 }
1362
1363 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
1364 * Read and write solution DataArray_t Nodes *
1365 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1366
cg_nfields_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * S,cgint_f * nfields,cgint_f * ier)1367 CGNSDLL void cg_nfields_f(cgint_f *fn, cgint_f *B,
1368 cgint_f *Z, cgint_f *S, cgint_f *nfields, cgint_f *ier)
1369 {
1370 int i_nfields;
1371
1372 *ier = (cgint_f)cg_nfields((int)*fn, (int)*B, (int)*Z, (int)*S, &i_nfields);
1373 *nfields = (cgint_f)i_nfields;
1374 }
1375
1376 /*-----------------------------------------------------------------------*/
1377
FMNAME(cg_field_info_f,CG_FIELD_INFO_F)1378 CGNSDLL void FMNAME(cg_field_info_f, CG_FIELD_INFO_F) (cgint_f *fn, cgint_f *B,
1379 cgint_f *Z, cgint_f *S, cgint_f *F, CGNS_ENUMT(DataType_t) *type, STR_PSTR(fieldname),
1380 cgint_f *ier STR_PLEN(fieldname))
1381 {
1382 char c_name[CGIO_MAX_NAME_LENGTH+1];
1383 CGNS_ENUMT(DataType_t) i_type;
1384
1385 *ier = (cgint_f)cg_field_info((int)*fn, (int)*B, (int)*Z, (int)*S, (int)*F,
1386 &i_type, c_name);
1387 if (*ier) return;
1388 *type = i_type;
1389 string_2_F_string(c_name, STR_PTR(fieldname), STR_LEN(fieldname), ier);
1390 }
1391
1392 /*-----------------------------------------------------------------------*/
1393
FMNAME(cg_field_read_f,CG_FIELD_READ_F)1394 CGNSDLL void FMNAME(cg_field_read_f, CG_FIELD_READ_F) (cgint_f *fn, cgint_f *B,
1395 cgint_f *Z, cgint_f *S, STR_PSTR(fieldname), CGNS_ENUMT(DataType_t) *type, cgsize_t *rmin,
1396 cgsize_t *rmax, void *field_ptr, cgint_f *ier STR_PLEN(fieldname))
1397 {
1398 char c_name[CGIO_MAX_NAME_LENGTH+1];
1399
1400 string_2_C_string(STR_PTR(fieldname), STR_LEN(fieldname),
1401 c_name, CGIO_MAX_NAME_LENGTH, ier);
1402 if (*ier) return;
1403 #if DEBUG_FTOC
1404 printf("fieldname='%s'\n", c_name);
1405 #endif
1406 *ier = (cgint_f)cg_field_read((int)*fn, (int)*B, (int)*Z, (int)*S, c_name,
1407 *type, rmin, rmax, field_ptr);
1408 }
1409
1410 /*-----------------------------------------------------------------------*/
1411
FMNAME(cg_field_general_read_f,CG_FIELD_GENERAL_READ_F)1412 CGNSDLL void FMNAME(cg_field_general_read_f, CG_FIELD_GENERAL_READ_F) (
1413 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S, STR_PSTR(fieldname),
1414 cgsize_t *s_rmin, cgsize_t *s_rmax, CGNS_ENUMT(DataType_t) *m_type,
1415 cgint_f *m_numdim, cgsize_t *m_dimvals,
1416 cgsize_t *m_rmin, cgsize_t *m_rmax, void *field_ptr,
1417 cgint_f *ier STR_PLEN(fieldname))
1418 {
1419 char c_name[CGIO_MAX_NAME_LENGTH+1];
1420
1421 string_2_C_string(STR_PTR(fieldname), STR_LEN(fieldname),
1422 c_name, CGIO_MAX_NAME_LENGTH, ier);
1423 if (*ier) return;
1424 #if DEBUG_FTOC
1425 printf("fieldname='%s'\n", c_name);
1426 #endif
1427 *ier = (cgint_f)cg_field_general_read(
1428 (int)*fn, (int)*B, (int)*Z, (int)*S, c_name,
1429 s_rmin, s_rmax,
1430 *m_type, (int)*m_numdim, m_dimvals, m_rmin, m_rmax, field_ptr);
1431 }
1432
1433 /*-----------------------------------------------------------------------*/
1434
cg_field_id_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * S,cgint_f * F,double * field_id,cgint_f * ier)1435 CGNSDLL void cg_field_id_f(cgint_f *fn, cgint_f *B,
1436 cgint_f *Z, cgint_f *S, cgint_f *F, double *field_id, cgint_f *ier)
1437 {
1438 *ier = (cgint_f)cg_field_id((int)*fn, (int)*B, (int)*Z, (int)*S, (int)*F, field_id);
1439 }
1440
1441 /*-----------------------------------------------------------------------*/
1442
FMNAME(cg_field_write_f,CG_FIELD_WRITE_F)1443 CGNSDLL void FMNAME(cg_field_write_f, CG_FIELD_WRITE_F) (cgint_f *fn, cgint_f *B,
1444 cgint_f *Z, cgint_f *S, CGNS_ENUMT(DataType_t) *type, STR_PSTR(fieldname), void *field_ptr,
1445 cgint_f *F, cgint_f *ier STR_PLEN(fieldname))
1446 {
1447 char c_name[CGIO_MAX_NAME_LENGTH+1];
1448 int i_F;
1449
1450 string_2_C_string(STR_PTR(fieldname), STR_LEN(fieldname),
1451 c_name, CGIO_MAX_NAME_LENGTH, ier);
1452 if (*ier) return;
1453 #if DEBUG_FTOC
1454 printf(" fieldname='%s'\n", c_name);
1455 #endif
1456 *ier = (cgint_f)cg_field_write((int)*fn, (int)*B, (int)*Z, (int)*S,
1457 *type, c_name, field_ptr, &i_F);
1458 *F = (cgint_f)i_F;
1459 }
1460
1461 /*-----------------------------------------------------------------------*/
1462
FMNAME(cg_field_partial_write_f,CG_FIELD_PARTIAL_WRITE_F)1463 CGNSDLL void FMNAME(cg_field_partial_write_f, CG_FIELD_PARTIAL_WRITE_F) (cgint_f *fn,
1464 cgint_f *B, cgint_f *Z, cgint_f *S, CGNS_ENUMT(DataType_t) *type, STR_PSTR(fieldname),
1465 cgsize_t *rmin, cgsize_t *rmax, void *field_ptr, cgint_f *F,
1466 cgint_f *ier STR_PLEN(fieldname))
1467 {
1468 char c_name[CGIO_MAX_NAME_LENGTH+1];
1469 int i_F;
1470
1471 string_2_C_string(STR_PTR(fieldname), STR_LEN(fieldname),
1472 c_name, CGIO_MAX_NAME_LENGTH, ier);
1473 if (*ier) return;
1474 #if DEBUG_FTOC
1475 printf(" fieldname='%s'\n", c_name);
1476 #endif
1477 *ier = (cgint_f)cg_field_partial_write((int)*fn, (int)*B, (int)*Z, (int)*S,
1478 *type, c_name,
1479 rmin, rmax, field_ptr, &i_F);
1480 *F = (cgint_f)i_F;
1481 }
1482
1483 /*-----------------------------------------------------------------------*/
1484
FMNAME(cg_field_general_write_f,CG_FIELD_GENERAL_WRITE_F)1485 CGNSDLL void FMNAME(cg_field_general_write_f, CG_FIELD_GENERAL_WRITE_F) (
1486 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S, STR_PSTR(fieldname),
1487 CGNS_ENUMT(DataType_t) *s_type, cgsize_t *s_rmin, cgsize_t *s_rmax,
1488 CGNS_ENUMT(DataType_t) *m_type, cgint_f *m_numdim, cgsize_t *m_dims,
1489 cgsize_t *m_rmin, cgsize_t *m_rmax, void *field_ptr, cgint_f *F,
1490 cgint_f *ier STR_PLEN(fieldname))
1491 {
1492 char c_name[CGIO_MAX_NAME_LENGTH+1];
1493 int i_F;
1494
1495 string_2_C_string(STR_PTR(fieldname), STR_LEN(fieldname),
1496 c_name, CGIO_MAX_NAME_LENGTH, ier);
1497 if (*ier) return;
1498 #if DEBUG_FTOC
1499 printf(" fieldname='%s'\n", c_name);
1500 #endif
1501 *ier = (cgint_f)cg_field_general_write((int)*fn, (int)*B, (int)*Z, (int)*S,
1502 c_name, *s_type, s_rmin, s_rmax,
1503 *m_type, (int)*m_numdim, m_dims,
1504 m_rmin, m_rmax, field_ptr, &i_F);
1505 *F = (cgint_f)i_F;
1506 }
1507
1508 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
1509 * Read and write ZoneSubRegion_t Nodes *
1510 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1511
cg_nsubregs_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * nsubreg,cgint_f * ier)1512 CGNSDLL void cg_nsubregs_f(cgint_f *fn, cgint_f *B,
1513 cgint_f *Z, cgint_f *nsubreg, cgint_f *ier)
1514 {
1515 int i_nsub;
1516
1517 *ier = (cgint_f)cg_nsubregs((int)*fn, (int)*B, (int)*Z, &i_nsub);
1518 *nsubreg = (cgint_f)i_nsub;
1519 }
1520
FMNAME(cg_subreg_info_f,CG_SUBREG_INFO_F)1521 CGNSDLL void FMNAME(cg_subreg_info_f, CG_SUBREG_INFO_F) (cgint_f *fn,
1522 cgint_f *B, cgint_f *Z, cgint_f *S, STR_PSTR(regname),
1523 cgint_f *dimension, CGNS_ENUMT(GridLocation_t) *location,
1524 CGNS_ENUMT(PointSetType_t) *ptset_type,
1525 cgsize_t *npnts, cgint_f *bcname_len, cgint_f *gcname_len,
1526 cgint_f *ier STR_PLEN(regname))
1527 {
1528 char c_regname[CGIO_MAX_NAME_LENGTH+1];
1529 int i_dimension, i_bcname_len, i_gcname_len;
1530 CGNS_ENUMT(GridLocation_t) i_location;
1531 CGNS_ENUMT(PointSetType_t) i_ptset_type;
1532
1533 *ier = (cgint_f)cg_subreg_info((int)*fn, (int)*B, (int)*Z, (int)*S, c_regname,
1534 &i_dimension, &i_location, &i_ptset_type, npnts,
1535 &i_bcname_len, &i_gcname_len);
1536 if (*ier) return;
1537 string_2_F_string(c_regname, STR_PTR(regname), STR_LEN(regname), ier);
1538 *dimension = (cgint_f)i_dimension;
1539 *location = i_location;
1540 *ptset_type = i_ptset_type;
1541 *bcname_len = (cgint_f)i_bcname_len;
1542 *gcname_len = (cgint_f)i_gcname_len;
1543 }
1544
cg_subreg_ptset_read_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * S,cgsize_t * pnts,cgint_f * ier)1545 CGNSDLL void cg_subreg_ptset_read_f(cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S,
1546 cgsize_t *pnts, cgint_f *ier)
1547 {
1548 *ier = (cgint_f)cg_subreg_ptset_read((int)*fn, (int)*B, (int)*Z, (int)*S, pnts);
1549 }
1550
FMNAME(cg_subreg_bcname_read_f,CG_SUBREG_BCNAME_READ_F)1551 CGNSDLL void FMNAME(cg_subreg_bcname_read_f, CG_SUBREG_BCNAME_READ_F) (
1552 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S,
1553 STR_PSTR(bcname), cgint_f *ier STR_PLEN(bcname))
1554 {
1555 char *name = 0;
1556 char regname[CGIO_MAX_NAME_LENGTH+1];
1557 int dimension, bclen, gclen;
1558 CGNS_ENUMT(GridLocation_t) location;
1559 CGNS_ENUMT(PointSetType_t) ptset_type;
1560 cgsize_t npnts;
1561
1562 *ier = (cgint_f)cg_subreg_info((int)*fn, (int)*B, (int)*Z, (int)*S, regname,
1563 &dimension, &location, &ptset_type, &npnts, &bclen, &gclen);
1564 if (*ier) return;
1565 if (bclen) name = CGNS_NEW(char, bclen+1);
1566 *ier = (cgint_f)cg_subreg_bcname_read((int)*fn, (int)*B, (int)*Z, (int)*S, name);
1567 if (!*ier && name)
1568 string_2_F_string(name, STR_PTR(bcname), STR_LEN(bcname), ier);
1569 CGNS_FREE(name);
1570 }
1571
FMNAME(cg_subreg_gcname_read_f,CG_SUBREG_GCNAME_READ_F)1572 CGNSDLL void FMNAME(cg_subreg_gcname_read_f, CG_SUBREG_GCNAME_READ_F) (
1573 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S,
1574 STR_PSTR(gcname), cgint_f *ier STR_PLEN(gcname))
1575 {
1576 char *name = 0;
1577 char regname[CGIO_MAX_NAME_LENGTH+1];
1578 int dimension, bclen, gclen;
1579 CGNS_ENUMT(GridLocation_t) location;
1580 CGNS_ENUMT(PointSetType_t) ptset_type;
1581 cgsize_t npnts;
1582
1583 *ier = (cgint_f)cg_subreg_info((int)*fn, (int)*B, (int)*Z, (int)*S, regname,
1584 &dimension, &location, &ptset_type, &npnts, &bclen, &gclen);
1585 if (*ier) return;
1586 if (gclen) name = CGNS_NEW(char, gclen+1);
1587 *ier = (cgint_f)cg_subreg_gcname_read((int)*fn, (int)*B, (int)*Z, (int)*S, name);
1588 if (!*ier && name)
1589 string_2_F_string(name, STR_PTR(gcname), STR_LEN(gcname), ier);
1590 CGNS_FREE(name);
1591 }
1592
FMNAME(cg_subreg_ptset_write_f,CG_SUBREG_PTSET_WRITE_F)1593 CGNSDLL void FMNAME(cg_subreg_ptset_write_f, CG_SUBREG_PTSET_WRITE_F) (
1594 cgint_f *fn, cgint_f *B, cgint_f *Z, STR_PSTR(regname),
1595 cgint_f *dimension, CGNS_ENUMT(GridLocation_t) *location, CGNS_ENUMT(PointSetType_t) *ptset_type,
1596 cgsize_t *npnts, cgsize_t *pnts, cgint_f *S,
1597 cgint_f *ier STR_PLEN(regname))
1598 {
1599 char c_regname[CGIO_MAX_NAME_LENGTH+1];
1600 int i_S;
1601
1602 string_2_C_string(STR_PTR(regname), STR_LEN(regname),
1603 c_regname, CGIO_MAX_NAME_LENGTH, ier);
1604 if (*ier) return;
1605
1606 *ier = (cgint_f)cg_subreg_ptset_write((int)*fn, (int)*B, (int)*Z, c_regname,
1607 (int)*dimension, *location,
1608 *ptset_type, *npnts,
1609 pnts, &i_S);
1610 *S = (cgint_f)i_S;
1611 }
1612
FMNAME(cg_subreg_bcname_write_f,CG_SUBREG_BCNAME_WRITE_F)1613 CGNSDLL void FMNAME(cg_subreg_bcname_write_f, CG_SUBREG_BCNAME_WRITE_F) (
1614 cgint_f *fn, cgint_f *B, cgint_f *Z, STR_PSTR(regname),
1615 cgint_f *dimension, STR_PSTR(bcname), cgint_f *S,
1616 cgint_f *ier STR_PLEN(regname) STR_PLEN(bcname))
1617 {
1618 char c_regname[CGIO_MAX_NAME_LENGTH+1];
1619 char *name;
1620 int length, i_S;
1621
1622 string_2_C_string(STR_PTR(regname), STR_LEN(regname),
1623 c_regname, CGIO_MAX_NAME_LENGTH, ier);
1624 if (*ier) return;
1625 length = (int)STR_LEN(bcname);
1626 name = CGNS_NEW(char, length+1);
1627 string_2_C_string(STR_PTR(bcname), STR_LEN(bcname), name, length, ier);
1628 if (!*ier) {
1629 *ier = (cgint_f)cg_subreg_bcname_write((int)*fn, (int)*B, (int)*Z, c_regname,
1630 (int)*dimension, name, &i_S);
1631 *S = (cgint_f)i_S;
1632 }
1633 CGNS_FREE(name);
1634 }
1635
FMNAME(cg_subreg_gcname_write_f,CG_SUBREG_GCNAME_WRITE_F)1636 CGNSDLL void FMNAME(cg_subreg_gcname_write_f, CG_SUBREG_GCNAME_WRITE_F) (
1637 cgint_f *fn, cgint_f *B, cgint_f *Z, STR_PSTR(regname),
1638 cgint_f *dimension, STR_PSTR(gcname), cgint_f *S,
1639 cgint_f *ier STR_PLEN(regname) STR_PLEN(gcname))
1640 {
1641 char c_regname[CGIO_MAX_NAME_LENGTH+1];
1642 char *name;
1643 int length, i_S;
1644
1645 string_2_C_string(STR_PTR(regname), STR_LEN(regname),
1646 c_regname, CGIO_MAX_NAME_LENGTH, ier);
1647 if (*ier) return;
1648 length = (int)STR_LEN(gcname);
1649 name = CGNS_NEW(char, length+1);
1650 string_2_C_string(STR_PTR(gcname), STR_LEN(gcname), name, length, ier);
1651 if (!*ier) {
1652 *ier = (cgint_f)cg_subreg_gcname_write((int)*fn, (int)*B, (int)*Z, c_regname,
1653 (int)*dimension, name, &i_S);
1654 *S = (cgint_f)i_S;
1655 }
1656 CGNS_FREE(name);
1657 }
1658
1659
1660 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
1661 * Read and write ZoneGridConnectivity_t Nodes *
1662 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1663
cg_nzconns_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * nzconns,cgint_f * ier)1664 CGNSDLL void cg_nzconns_f(cgint_f *fn,
1665 cgint_f *B, cgint_f *Z, cgint_f *nzconns, cgint_f *ier)
1666 {
1667 int i_nzconns;
1668
1669 *ier = (cgint_f)cg_nzconns((int)*fn, (int)*B, (int)*Z, &i_nzconns);
1670 *nzconns = (cgint_f)i_nzconns;
1671 }
1672
1673 /*-----------------------------------------------------------------------*/
1674
FMNAME(cg_zconn_read_f,CG_ZCONN_READ_F)1675 CGNSDLL void FMNAME(cg_zconn_read_f, CG_ZCONN_READ_F) (cgint_f *fn,
1676 cgint_f *B, cgint_f *Z, cgint_f *C, STR_PSTR(name),
1677 cgint_f *ier STR_PLEN(name))
1678 {
1679 char c_name[CGIO_MAX_NAME_LENGTH+1];
1680
1681 *ier = (cgint_f)cg_zconn_read((int)*fn, (int)*B, (int)*Z, (int)*C, c_name);
1682 if (!*ier)
1683 string_2_F_string(c_name, STR_PTR(name), STR_LEN(name), ier);
1684 }
1685
1686 /*-----------------------------------------------------------------------*/
1687
FMNAME(cg_zconn_write_f,CG_ZCONN_WRITE_F)1688 CGNSDLL void FMNAME(cg_zconn_write_f, CG_ZCONN_WRITE_F) (cgint_f *fn,
1689 cgint_f *B, cgint_f *Z, STR_PSTR(name), cgint_f *C,
1690 cgint_f *ier STR_PLEN(name))
1691 {
1692 int i_C;
1693 char c_name[CGIO_MAX_NAME_LENGTH+1];
1694
1695 string_2_C_string(STR_PTR(name), STR_LEN(name),
1696 c_name, CGIO_MAX_NAME_LENGTH, ier);
1697 if (*ier) return;
1698 *ier = (cgint_f)cg_zconn_write((int)*fn, (int)*B, (int)*Z, c_name, &i_C);
1699 *C = (cgint_f)i_C;
1700 }
1701
1702 /*-----------------------------------------------------------------------*/
1703
cg_zconn_get_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * C,cgint_f * ier)1704 CGNSDLL void cg_zconn_get_f(cgint_f *fn,
1705 cgint_f *B, cgint_f *Z, cgint_f *C, cgint_f *ier)
1706 {
1707 int i_C;
1708
1709 *ier = (cgint_f)cg_zconn_get((int)*fn, (int)*B, (int)*Z, &i_C);
1710 *C = (cgint_f)i_C;
1711 }
1712
1713 /*-----------------------------------------------------------------------*/
1714
cg_zconn_set_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * C,cgint_f * ier)1715 CGNSDLL void cg_zconn_set_f(cgint_f *fn,
1716 cgint_f *B, cgint_f *Z, cgint_f *C, cgint_f *ier)
1717 {
1718 *ier = (cgint_f)cg_zconn_set((int)*fn, (int)*B, (int)*Z, (int)*C);
1719 }
1720
1721 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
1722 * Read and write OversetHoles_t Nodes *
1723 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1724
cg_nholes_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * nholes,cgint_f * ier)1725 CGNSDLL void cg_nholes_f(cgint_f *fn, cgint_f *B,
1726 cgint_f *Z, cgint_f *nholes, cgint_f *ier)
1727 {
1728 int i_nholes;
1729
1730 *ier = (cgint_f)cg_nholes((int)*fn, (int)*B, (int)*Z, &i_nholes);
1731 *nholes = (cgint_f)i_nholes;
1732 }
1733
1734 /*-----------------------------------------------------------------------*/
1735
FMNAME(cg_hole_info_f,CG_HOLE_INFO_F)1736 CGNSDLL void FMNAME(cg_hole_info_f, CG_HOLE_INFO_F) (cgint_f *fn, cgint_f *B,
1737 cgint_f *Z, cgint_f *I, STR_PSTR(holename), CGNS_ENUMT(GridLocation_t) *location,
1738 CGNS_ENUMT(PointSetType_t) *ptset_type, cgsize_t *nptsets, cgsize_t *npnts,
1739 cgint_f *ier STR_PLEN(holename))
1740 {
1741 char c_name[CGIO_MAX_NAME_LENGTH+1];
1742 CGNS_ENUMT(GridLocation_t) i_location;
1743 CGNS_ENUMT(PointSetType_t) i_ptset_type;
1744 int i_nptsets;
1745
1746 *ier = (cgint_f)cg_hole_info((int)*fn, (int)*B, (int)*Z, (int)*I, c_name,
1747 &i_location, &i_ptset_type, &i_nptsets, npnts);
1748 if (*ier) return;
1749 *location = i_location;
1750 *ptset_type = i_ptset_type;
1751 *nptsets = i_nptsets;
1752 string_2_F_string(c_name, STR_PTR(holename), STR_LEN(holename), ier);
1753 }
1754
1755 /*-----------------------------------------------------------------------*/
1756
cg_hole_read_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * I,cgsize_t * pnts,cgint_f * ier)1757 CGNSDLL void cg_hole_read_f(cgint_f *fn, cgint_f *B,
1758 cgint_f *Z, cgint_f *I, cgsize_t *pnts, cgint_f *ier)
1759 {
1760 *ier = (cgint_f)cg_hole_read((int)*fn, (int)*B, (int)*Z, (int)*I, pnts);
1761 }
1762
1763 /*-----------------------------------------------------------------------*/
1764
cg_hole_id_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * I,double * hole_id,cgint_f * ier)1765 CGNSDLL void cg_hole_id_f(cgint_f *fn, cgint_f *B,
1766 cgint_f *Z, cgint_f *I, double *hole_id, cgint_f *ier)
1767 {
1768 *ier = (cgint_f)cg_hole_id((int)*fn, (int)*B, (int)*Z, (int)*I, hole_id);
1769 }
1770
1771 /*-----------------------------------------------------------------------*/
1772
FMNAME(cg_hole_write_f,CG_HOLE_WRITE_F)1773 CGNSDLL void FMNAME(cg_hole_write_f, CG_HOLE_WRITE_F) (cgint_f *fn, cgint_f *B,
1774 cgint_f *Z, STR_PSTR(holename), CGNS_ENUMT(GridLocation_t) *location,
1775 CGNS_ENUMT(PointSetType_t) *ptset_type, cgint_f *nptsets, cgsize_t *npnts,
1776 cgsize_t *pnts, cgint_f *I, cgint_f *ier STR_PLEN(holename))
1777 {
1778 char c_name[CGIO_MAX_NAME_LENGTH+1];
1779 int i_I;
1780
1781 string_2_C_string(STR_PTR(holename), STR_LEN(holename),
1782 c_name, CGIO_MAX_NAME_LENGTH, ier);
1783 if (*ier) return;
1784 #if DEBUG_FTOC
1785 printf("holename='%s'\n", c_name);
1786 #endif
1787 *ier = (cgint_f)cg_hole_write((int)*fn, (int)*B, (int)*Z, c_name,
1788 *location,
1789 *ptset_type,
1790 (int)*nptsets, *npnts, pnts, &i_I);
1791 *I = (cgint_f)i_I;
1792 }
1793
1794 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
1795 * Read and write GridConnectivity_t Nodes *
1796 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1797
cg_nconns_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * nconns,cgint_f * ier)1798 CGNSDLL void cg_nconns_f(cgint_f *fn, cgint_f *B,
1799 cgint_f *Z, cgint_f *nconns, cgint_f *ier)
1800 {
1801 int i_nconns;
1802
1803 *ier = (cgint_f)cg_nconns((int)*fn, (int)*B, (int)*Z, &i_nconns);
1804 *nconns = (cgint_f)i_nconns;
1805 }
1806
1807 /*-----------------------------------------------------------------------*/
1808
FMNAME(cg_conn_info_f,CG_CONN_INFO_F)1809 CGNSDLL void FMNAME(cg_conn_info_f, CG_CONN_INFO_F) (cgint_f *fn, cgint_f *B,
1810 cgint_f *Z, cgint_f *I, STR_PSTR(connectname), CGNS_ENUMT(GridLocation_t) *location,
1811 CGNS_ENUMT(GridConnectivityType_t) *type, CGNS_ENUMT(PointSetType_t) *ptset_type,
1812 cgsize_t *npnts, STR_PSTR(donorname),
1813 CGNS_ENUMT(ZoneType_t) *donor_zonetype,
1814 CGNS_ENUMT(PointSetType_t) *donor_ptset_type,
1815 CGNS_ENUMT(DataType_t) *donor_datatype,
1816 cgsize_t *ndata_donor, cgint_f *ier STR_PLEN(connectname) STR_PLEN(donorname))
1817 {
1818 char cc_name[CGIO_MAX_NAME_LENGTH+1], dc_name[CGIO_MAX_NAME_LENGTH+1];
1819 CGNS_ENUMT(GridLocation_t) i_location;
1820 CGNS_ENUMT(GridConnectivityType_t) i_type;
1821 CGNS_ENUMT(PointSetType_t) i_ptset_type;
1822 CGNS_ENUMT(ZoneType_t) i_donor_zonetype;
1823 CGNS_ENUMT(PointSetType_t) i_donor_ptset_type;
1824 CGNS_ENUMT(DataType_t) i_donor_datatype;
1825
1826 *ier = (cgint_f)cg_conn_info((int)*fn, (int)*B, (int)*Z, (int)*I, cc_name, &i_location,
1827 &i_type, &i_ptset_type, npnts, dc_name,
1828 &i_donor_zonetype, &i_donor_ptset_type,
1829 &i_donor_datatype, ndata_donor);
1830 if (*ier) return;
1831 string_2_F_string(cc_name, STR_PTR(connectname), STR_LEN(connectname), ier);
1832 if (*ier) return;
1833 string_2_F_string(dc_name, STR_PTR(donorname), STR_LEN(donorname), ier);
1834 if (*ier) return;
1835 *location = i_location;
1836 *type = i_type;
1837 *ptset_type = i_ptset_type;
1838 *donor_zonetype = i_donor_zonetype;
1839 *donor_ptset_type = i_donor_ptset_type;
1840 *donor_datatype = i_donor_datatype;
1841 }
1842
1843 /*-----------------------------------------------------------------------*/
1844
cg_conn_read_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * I,cgsize_t * pnts,CGNS_ENUMT (DataType_t)* donor_datatype,cgsize_t * donor_data,cgint_f * ier)1845 CGNSDLL void cg_conn_read_f(cgint_f *fn, cgint_f *B,
1846 cgint_f *Z, cgint_f *I, cgsize_t *pnts, CGNS_ENUMT(DataType_t) *donor_datatype,
1847 cgsize_t *donor_data, cgint_f *ier)
1848 {
1849 *ier = (cgint_f)cg_conn_read((int)*fn, (int)*B, (int)*Z, (int)*I, pnts,
1850 *donor_datatype, donor_data);
1851 }
1852
1853 /*-----------------------------------------------------------------------*/
1854
cg_conn_read_short_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * I,cgsize_t * pnts,cgint_f * ier)1855 CGNSDLL void cg_conn_read_short_f(cgint_f *fn,
1856 cgint_f *B, cgint_f *Z, cgint_f *I, cgsize_t *pnts, cgint_f *ier)
1857 {
1858 *ier = (cgint_f)cg_conn_read_short((int)*fn, (int)*B, (int)*Z, (int)*I, pnts);
1859 }
1860
1861 /*-----------------------------------------------------------------------*/
1862
cg_conn_id_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * I,double * conn_id,cgint_f * ier)1863 CGNSDLL void cg_conn_id_f(cgint_f *fn, cgint_f *B,
1864 cgint_f *Z, cgint_f *I, double *conn_id, cgint_f *ier)
1865 {
1866 *ier = (cgint_f)cg_conn_id((int)*fn, (int)*B, (int)*Z, (int)*I, conn_id);
1867 }
1868
1869 /*-----------------------------------------------------------------------*/
1870
FMNAME(cg_conn_write_f,CG_CONN_WRITE_F)1871 CGNSDLL void FMNAME(cg_conn_write_f, CG_CONN_WRITE_F) (cgint_f *fn, cgint_f *B,
1872 cgint_f *Z, STR_PSTR(connectname),
1873 CGNS_ENUMT(GridLocation_t) *location,
1874 CGNS_ENUMT(GridConnectivityType_t) *type,
1875 CGNS_ENUMT(PointSetType_t) *ptset_type,
1876 cgsize_t *npnts, cgsize_t *pnts,
1877 STR_PSTR(donorname),
1878 CGNS_ENUMT(ZoneType_t)*donor_zonetype,
1879 CGNS_ENUMT(PointSetType_t)*donor_ptset_type,
1880 CGNS_ENUMT(DataType_t)*donor_datatype, cgsize_t *ndata_donor, cgsize_t *donor_data,
1881 cgint_f *I, cgint_f *ier STR_PLEN(connectname) STR_PLEN(donorname))
1882 {
1883 char cc_name[CGIO_MAX_NAME_LENGTH+1], dc_name[CGIO_MAX_NAME_LENGTH+1];
1884 int i_I;
1885
1886 string_2_C_string(STR_PTR(connectname), STR_LEN(connectname),
1887 cc_name, CGIO_MAX_NAME_LENGTH, ier);
1888 if (*ier) return;
1889 string_2_C_string(STR_PTR(donorname), STR_LEN(donorname),
1890 dc_name, CGIO_MAX_NAME_LENGTH, ier);
1891 if (*ier) return;
1892 #if DEBUG_FTOC
1893 printf("connectname='%s'\n", cc_name);
1894 printf("donorname='%s'\n", dc_name);
1895 #endif
1896 *ier = (cgint_f)cg_conn_write((int)*fn, (int)*B, (int)*Z, cc_name,
1897 *location,
1898 *type,
1899 *ptset_type,
1900 *npnts, pnts, dc_name,
1901 *donor_zonetype,
1902 *donor_ptset_type,
1903 *donor_datatype,
1904 *ndata_donor, donor_data, &i_I);
1905 *I = (cgint_f)i_I;
1906 }
1907
1908 /*-----------------------------------------------------------------------*/
1909
FMNAME(cg_conn_write_short_f,CG_CONN_WRITE_SHORT_F)1910 CGNSDLL void FMNAME(cg_conn_write_short_f, CG_CONN_WRITE_SHORT_F) (cgint_f *fn,
1911 cgint_f *B, cgint_f *Z, STR_PSTR(connectname), CGNS_ENUMT(GridLocation_t) *location,
1912 CGNS_ENUMT(GridConnectivityType_t) *type, CGNS_ENUMT(PointSetType_t) *ptset_type, cgsize_t *npnts,
1913 cgsize_t *pnts, STR_PSTR(donorname), cgint_f *I,
1914 cgint_f *ier STR_PLEN(connectname) STR_PLEN(donorname))
1915 {
1916 char cc_name[CGIO_MAX_NAME_LENGTH+1], dc_name[CGIO_MAX_NAME_LENGTH+1];
1917 int i_I;
1918
1919 string_2_C_string(STR_PTR(connectname), STR_LEN(connectname),
1920 cc_name, CGIO_MAX_NAME_LENGTH, ier);
1921 if (*ier) return;
1922 string_2_C_string(STR_PTR(donorname), STR_LEN(donorname),
1923 dc_name, CGIO_MAX_NAME_LENGTH, ier);
1924 if (*ier) return;
1925 #if DEBUG_FTOC
1926 printf("connectname='%s'\n", cc_name);
1927 printf("donorname='%s'\n", dc_name);
1928 #endif
1929 *ier = (cgint_f)cg_conn_write_short((int)*fn, (int)*B, (int)*Z, cc_name,
1930 *location,
1931 *type,
1932 *ptset_type,
1933 *npnts, pnts, dc_name, &i_I);
1934 *I = (cgint_f)i_I;
1935 }
1936
1937 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
1938 * Read and write GridConnectivity1to1_t Nodes in a zone *
1939 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1940
cg_n1to1_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * n1to1,cgint_f * ier)1941 CGNSDLL void cg_n1to1_f(cgint_f *fn, cgint_f *B,
1942 cgint_f *Z, cgint_f*n1to1, cgint_f *ier)
1943 {
1944 int i_n1to1;
1945
1946 *ier = (cgint_f)cg_n1to1((int)*fn, (int)*B, (int)*Z, &i_n1to1);
1947 *n1to1 = (cgint_f)i_n1to1;
1948 }
1949
1950 /*-----------------------------------------------------------------------*/
1951
FMNAME(cg_1to1_read_f,CG_1TO1_READ_F)1952 CGNSDLL void FMNAME(cg_1to1_read_f, CG_1TO1_READ_F) (cgint_f *fn, cgint_f *B,
1953 cgint_f *Z, cgint_f *I, STR_PSTR(connectname), STR_PSTR(donorname),
1954 cgsize_t *range, cgsize_t *donor_range, cgint_f *transform,
1955 cgint_f *ier STR_PLEN(connectname) STR_PLEN(donorname))
1956 {
1957 char cc_name[CGIO_MAX_NAME_LENGTH+1], dc_name[CGIO_MAX_NAME_LENGTH+1];
1958 int n, index_dim, i_transform[3];
1959
1960 *ier = (cgint_f)cg_index_dim((int)*fn, (int)*B, (int)*Z, &index_dim);
1961 if (*ier) return;
1962 *ier = (cgint_f)cg_1to1_read((int)*fn, (int)*B, (int)*Z, (int)*I, cc_name, dc_name,
1963 range, donor_range, i_transform);
1964 if (*ier) return;
1965 string_2_F_string(cc_name, STR_PTR(connectname), STR_LEN(connectname), ier);
1966 if (*ier) return;
1967 string_2_F_string(dc_name, STR_PTR(donorname), STR_LEN(donorname), ier);
1968 if (*ier) return;
1969 for (n = 0; n < index_dim; n++)
1970 transform[n] = (cgint_f)i_transform[n];
1971 }
1972
1973 /*-----------------------------------------------------------------------*/
1974
cg_1to1_id_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * I,double * one21_id,cgint_f * ier)1975 CGNSDLL void cg_1to1_id_f(cgint_f *fn, cgint_f *B,
1976 cgint_f *Z, cgint_f *I, double *one21_id, cgint_f *ier)
1977 {
1978 *ier = (cgint_f)cg_1to1_id((int)*fn, (int)*B, (int)*Z, (int)*I, one21_id);
1979 }
1980
1981 /*-----------------------------------------------------------------------*/
1982
FMNAME(cg_1to1_write_f,CG_1TO1_WRITE_F)1983 CGNSDLL void FMNAME(cg_1to1_write_f, CG_1TO1_WRITE_F) (cgint_f *fn, cgint_f *B,
1984 cgint_f *Z, STR_PSTR(connectname), STR_PSTR(donorname), cgsize_t *range,
1985 cgsize_t *donor_range, cgint_f *transform, cgint_f *I,
1986 cgint_f *ier STR_PLEN(connectname) STR_PLEN(donorname))
1987 {
1988 char cc_name[CGIO_MAX_NAME_LENGTH+1], dc_name[CGIO_MAX_NAME_LENGTH+1];
1989 int n, index_dim, i_I, i_transform[3];
1990
1991 *ier = (cgint_f)cg_index_dim((int)*fn, (int)*B, (int)*Z, &index_dim);
1992 if (*ier) return;
1993 string_2_C_string(STR_PTR(connectname), STR_LEN(connectname),
1994 cc_name, CGIO_MAX_NAME_LENGTH, ier);
1995 if (*ier) return;
1996 string_2_C_string(STR_PTR(donorname), STR_LEN(donorname),
1997 dc_name, CGIO_MAX_NAME_LENGTH, ier);
1998 if (*ier) return;
1999 #if DEBUG_FTOC
2000 printf("connectname='%s'\n", cc_name);
2001 printf("donorname='%s'\n", dc_name);
2002 #endif
2003 for (n = 0; n < index_dim; n++)
2004 i_transform[n] = (int)transform[n];
2005 *ier = (cgint_f)cg_1to1_write((int)*fn, (int)*B, (int)*Z, cc_name, dc_name, range,
2006 donor_range, i_transform, &i_I);
2007 *I = (cgint_f)i_I;
2008 }
2009
2010 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2011 * Read all GridConnectivity1to1_t Nodes of a base *
2012 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2013
cg_n1to1_global_f(cgint_f * fn,cgint_f * B,cgint_f * n1to1_global,cgint_f * ier)2014 CGNSDLL void cg_n1to1_global_f(cgint_f *fn,
2015 cgint_f *B, cgint_f *n1to1_global, cgint_f *ier)
2016 {
2017 int i_n1to1_global;
2018
2019 *ier = (cgint_f)cg_n1to1_global((int)*fn, (int)*B, &i_n1to1_global);
2020 *n1to1_global = (cgint_f)i_n1to1_global;
2021 }
2022
2023 /*-----------------------------------------------------------------------*/
2024
FMNAME(cg_1to1_read_global_f,CG_1TO1_READ_GLOBAL_F)2025 CGNSDLL void FMNAME(cg_1to1_read_global_f, CG_1TO1_READ_GLOBAL_F) (cgint_f *fn,
2026 cgint_f *B, STR_PSTR(connectname), STR_PSTR(zonename), STR_PSTR(donorname),
2027 cgsize_t *range, cgsize_t *donor_range, cgint_f *transform,
2028 cgint_f *ier STR_PLEN(connectname) STR_PLEN(zonename) STR_PLEN(donorname))
2029 {
2030 int n, i, step, len;
2031 int cell_dim, phys_dim; /* number of dimension for model */
2032 int Ndim; /* indexDimension */
2033 int Nglobal; /* number of 1to1 interface in base */
2034 char **c_connectname, **c_zonename, **c_donorname;
2035 char basename[CGIO_MAX_NAME_LENGTH+1];
2036 cgsize_t **c_range, **c_donor_range;
2037 int **c_transform;
2038
2039 /* get number of dimension for model: Ndim */
2040 *ier = (cgint_f)cg_base_read((int)*fn, (int)*B, basename, &cell_dim, &phys_dim);
2041 if (*ier) return;
2042
2043 /* For structured grid: */
2044 Ndim = cell_dim;
2045
2046 /* get number of 1to1 interface in base: Nglobal */
2047 *ier = (cgint_f)cg_n1to1_global((int)*fn, (int)*B, &Nglobal);
2048 if (*ier) return;
2049 if (Nglobal < 1) {
2050 cgi_error("Number of interface must equal 1 or more");
2051 *ier = 1;
2052 return;
2053 }
2054 /* allocate memory for C-arrays (ptr-to-ptr) */
2055 if ((c_connectname = (char **)malloc(Nglobal*sizeof(char *)))==NULL ||
2056 (c_zonename = (char **)malloc(Nglobal*sizeof(char *)))==NULL ||
2057 (c_donorname = (char **)malloc(Nglobal*sizeof(char *)))==NULL ||
2058 (c_range = (cgsize_t **)malloc(Nglobal*sizeof(cgsize_t *)))==NULL ||
2059 (c_donor_range = (cgsize_t **)malloc(Nglobal*sizeof(cgsize_t *)))==NULL ||
2060 (c_transform = (int **)malloc(Nglobal*sizeof(int *)))==NULL) {
2061 cgi_error("Error allocating memory...");
2062 *ier = 1;
2063 goto cleanup;
2064 }
2065 len = CGIO_MAX_NAME_LENGTH+1;
2066 for (n = 0; n < Nglobal; n++) {
2067 if ((c_connectname[n] = (char *)malloc(len*sizeof(char)))==NULL ||
2068 (c_zonename[n] = (char *)malloc(len*sizeof(char)))==NULL ||
2069 (c_donorname[n] = (char *)malloc(len*sizeof(char)))==NULL ||
2070 (c_range[n] = (cgsize_t *)malloc(6*sizeof(cgsize_t)))==NULL ||
2071 (c_donor_range[n] = (cgsize_t *)malloc(6*sizeof(cgsize_t)))==NULL ||
2072 (c_transform[n] = (int *)malloc(3*sizeof(int)))==NULL) {
2073 cgi_error("Error allocating memory...");
2074 *ier = 1;
2075 goto cleanup;
2076 }
2077 }
2078 /* get all 1to1 interfaces */
2079 *ier = (cgint_f)cg_1to1_read_global((int)*fn, (int)*B, c_connectname, c_zonename,
2080 c_donorname, c_range, c_donor_range, c_transform);
2081 /* copy C-arrays in Fortran arrays */
2082 if (*ier == 0) {
2083 for (n = 0; n < Nglobal; n++) {
2084 step = n*CGIO_MAX_NAME_LENGTH;
2085 string_2_F_string(c_connectname[n], STR_PTR(connectname)+step,
2086 CGIO_MAX_NAME_LENGTH, ier);
2087 if (*ier) break;
2088 string_2_F_string(c_zonename[n], STR_PTR(zonename) +step,
2089 CGIO_MAX_NAME_LENGTH, ier);
2090 if (*ier) break;
2091 string_2_F_string(c_donorname[n], STR_PTR(donorname) +step,
2092 CGIO_MAX_NAME_LENGTH, ier);
2093 if (*ier) break;
2094
2095 for (i = 0; i < Ndim; i++) {
2096 step = Ndim*2*n;
2097 range[step+i] = c_range[n][i];
2098 range[step+i+Ndim] = c_range[n][i+Ndim];
2099 donor_range[step+i] = c_donor_range[n][i];
2100 donor_range[step+i+Ndim] = c_donor_range[n][i+Ndim];
2101 transform[Ndim*n+i] = (cgint_f)c_transform[n][i];
2102 }
2103 #if DEBUG_FTOC
2104 printf("c_connectname[n]='%s'\n",c_connectname[n]);
2105 printf("c_zonename [n]='%s'\n",c_zonename[n]);
2106 printf("c_donorname [n]='%s'\n",c_donorname[n]);
2107 printf("..................12345678901234567890123456789012\n");
2108 #endif
2109 }
2110 #if DEBUG_FTOC
2111 printf("connectname='%s'\n",connectname);
2112 printf("zonename ='%s'\n",zonename);
2113 printf("donorname ='%s'\n",donorname);
2114 printf(".............+2345678901234567890123456789012+2345678901234567890123456789012\n");
2115 #endif
2116 }
2117
2118 cleanup:
2119 for (n = 0; n < Nglobal; n++) {
2120 CGNS_FREE(c_connectname[n]);
2121 CGNS_FREE(c_zonename[n]);
2122 CGNS_FREE(c_donorname[n]);
2123 CGNS_FREE(c_range[n]);
2124 CGNS_FREE(c_donor_range[n]);
2125 CGNS_FREE(c_transform[n]);
2126 }
2127 CGNS_FREE(c_connectname);
2128 CGNS_FREE(c_zonename);
2129 CGNS_FREE(c_donorname);
2130 CGNS_FREE(c_range);
2131 CGNS_FREE(c_donor_range);
2132 CGNS_FREE(c_transform);
2133 }
2134
2135 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2136 * Read and write BC_t Nodes *
2137 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2138
cg_nbocos_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * nbocos,cgint_f * ier)2139 CGNSDLL void cg_nbocos_f(cgint_f *fn, cgint_f *B,
2140 cgint_f *Z, cgint_f *nbocos, cgint_f *ier)
2141 {
2142 int i_nbocos;
2143
2144 *ier = (cgint_f)cg_nbocos((int)*fn, (int)*B, (int)*Z, &i_nbocos);
2145 *nbocos = (cgint_f)i_nbocos;
2146 }
2147
2148 /*-----------------------------------------------------------------------*/
2149
FMNAME(cg_boco_info_f,CG_BOCO_INFO_F)2150 CGNSDLL void FMNAME(cg_boco_info_f, CG_BOCO_INFO_F) (cgint_f *fn, cgint_f *B,
2151 cgint_f *Z, cgint_f *BC, STR_PSTR(boconame), CGNS_ENUMT(BCType_t) *bocotype,
2152 CGNS_ENUMT(PointSetType_t) *ptset_type, cgsize_t *npnts, cgint_f *NormalIndex,
2153 cgsize_t *NormalListSize, CGNS_ENUMT(DataType_t) *NormalDataType, cgint_f *ndataset,
2154 cgint_f *ier STR_PLEN(boconame))
2155 {
2156 char c_name[CGIO_MAX_NAME_LENGTH+1];
2157 CGNS_ENUMT(BCType_t) i_bocotype;
2158 CGNS_ENUMT(PointSetType_t) i_ptset_type;
2159 CGNS_ENUMT(DataType_t) i_NormalDataType;
2160 int n, i_ndataset, index_dim, i_NormalIndex[3];
2161
2162 *ier = (cgint_f)cg_index_dim((int)*fn, (int)*B, (int)*Z, &index_dim);
2163 if (*ier) return;
2164 *ier = (cgint_f)cg_boco_info((int)*fn, (int)*B, (int)*Z, (int)*BC, c_name,
2165 &i_bocotype, &i_ptset_type, npnts, i_NormalIndex,
2166 NormalListSize, &i_NormalDataType, &i_ndataset);
2167 if (*ier) return;
2168 string_2_F_string(c_name, STR_PTR(boconame), STR_LEN(boconame), ier);
2169
2170 *bocotype = i_bocotype;
2171 *ptset_type = i_ptset_type;
2172 *NormalDataType = i_NormalDataType;
2173 *ndataset = (cgint_f)i_ndataset;
2174 for (n = 0; n < index_dim; n++)
2175 NormalIndex[n] = (cgint_f)i_NormalIndex[n];
2176 }
2177
2178 /*-----------------------------------------------------------------------*/
2179
FMNAME(cg_boco_read_f,CG_BOCO_READ_F)2180 CGNSDLL void FMNAME(cg_boco_read_f,CG_BOCO_READ_F) (cgint_f *fn, cgint_f *B,
2181 cgint_f *Z, cgint_f *BC, cgsize_t *pnts, void *NormalList, cgint_f *ier)
2182 {
2183 *ier = (cgint_f)cg_boco_read((int)*fn, (int)*B, (int)*Z, (int)*BC, pnts, NormalList);
2184 }
2185
2186 /*-----------------------------------------------------------------------*/
2187
cg_boco_id_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * BC,double * boco_id,cgint_f * ier)2188 CGNSDLL void cg_boco_id_f(cgint_f *fn, cgint_f *B,
2189 cgint_f *Z, cgint_f *BC, double *boco_id, cgint_f *ier)
2190 {
2191 *ier = (cgint_f)cg_boco_id((int)*fn, (int)*B, (int)*Z, (int)*BC, boco_id);
2192 }
2193
2194 /*-----------------------------------------------------------------------*/
2195
FMNAME(cg_boco_write_f,CG_BOCO_WRITE_F)2196 CGNSDLL void FMNAME(cg_boco_write_f, CG_BOCO_WRITE_F) (cgint_f *fn,
2197 cgint_f *B, cgint_f *Z, STR_PSTR(boconame), CGNS_ENUMT(BCType_t) *bocotype,
2198 CGNS_ENUMT(PointSetType_t) *ptset_type, cgsize_t *npnts, cgsize_t *pnts,
2199 cgint_f *BC, cgint_f *ier STR_PLEN(boconame))
2200 {
2201 char c_name[CGIO_MAX_NAME_LENGTH+1];
2202 int i_BC;
2203
2204 string_2_C_string(STR_PTR(boconame), STR_LEN(boconame),
2205 c_name, CGIO_MAX_NAME_LENGTH, ier);
2206 if (*ier) return;
2207 #if DEBUG_FTOC
2208 printf("boconame='%s'\n", c_name);
2209 #endif
2210 *ier = (cgint_f)cg_boco_write((int)*fn, (int)*B, (int)*Z, c_name,
2211 *bocotype,
2212 *ptset_type,
2213 *npnts, pnts, &i_BC);
2214 *BC = (cgint_f)i_BC;
2215 }
2216
2217 /*-----------------------------------------------------------------------*/
2218
FMNAME(cg_boco_normal_write_f,CG_BOCO_NORMAL_WRITE_F)2219 CGNSDLL void FMNAME(cg_boco_normal_write_f, CG_BOCO_NORMAL_WRITE_F) (
2220 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *BC,
2221 cgsize_t *NormalIndex, cgint_f *NormalListFlag,
2222 CGNS_ENUMT(DataType_t) *NormalDataType, void *NormalList, cgint_f *ier)
2223 {
2224 int n, index_dim, i_NormalIndex[3];
2225
2226 *ier = (cgint_f)cg_index_dim((int)*fn, (int)*B, (int)*Z, &index_dim);
2227 if (*ier) return;
2228 for (n = 0; n < index_dim; n++)
2229 i_NormalIndex[n] = (int)NormalIndex[n];
2230 *ier = (cgint_f)cg_boco_normal_write((int)*fn, (int)*B, (int)*Z, (int)*BC,
2231 i_NormalIndex, (int)*NormalListFlag,
2232 *NormalDataType, NormalList);
2233 }
2234
2235 /*-----------------------------------------------------------------------*/
2236
cg_boco_gridlocation_read_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * BC,CGNS_ENUMT (GridLocation_t)* location,cgint_f * ier)2237 CGNSDLL void cg_boco_gridlocation_read_f(
2238 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *BC,
2239 CGNS_ENUMT(GridLocation_t) *location, cgint_f *ier)
2240 {
2241 CGNS_ENUMT(GridLocation_t) i_location;
2242
2243 *ier = (cgint_f)cg_boco_gridlocation_read((int)*fn, (int)*B, (int)*Z,
2244 (int)*BC, &i_location);
2245 *location = i_location;
2246 }
2247
2248 /*-----------------------------------------------------------------------*/
2249
cg_boco_gridlocation_write_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * BC,CGNS_ENUMT (GridLocation_t)* location,cgint_f * ier)2250 CGNSDLL void cg_boco_gridlocation_write_f(
2251 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *BC,
2252 CGNS_ENUMT(GridLocation_t) *location, cgint_f *ier)
2253 {
2254 *ier = (cgint_f)cg_boco_gridlocation_write((int)*fn, (int)*B, (int)*Z,
2255 (int)*BC, *location);
2256 }
2257
2258 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2259 * Read and write BCProperty_t/WallFunction_t Nodes *
2260 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2261
cg_bc_wallfunction_read_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * BC,CGNS_ENUMT (WallFunctionType_t)* WallFunctionType,cgint_f * ier)2262 CGNSDLL void cg_bc_wallfunction_read_f(
2263 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *BC,
2264 CGNS_ENUMT(WallFunctionType_t) *WallFunctionType, cgint_f *ier)
2265 {
2266 CGNS_ENUMT(WallFunctionType_t) i_WallFunctionType;
2267
2268 *ier = (cgint_f)cg_bc_wallfunction_read((int)*fn, (int)*B, (int)*Z, (int)*BC,
2269 &i_WallFunctionType);
2270 *WallFunctionType = i_WallFunctionType;
2271 }
2272
2273 /*-----------------------------------------------------------------------*/
2274
cg_bc_wallfunction_write_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * BC,CGNS_ENUMT (WallFunctionType_t)* WallFunctionType,cgint_f * ier)2275 CGNSDLL void cg_bc_wallfunction_write_f(
2276 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *BC,
2277 CGNS_ENUMT(WallFunctionType_t) *WallFunctionType, cgint_f *ier)
2278 {
2279 *ier = (cgint_f)cg_bc_wallfunction_write((int)*fn, (int)*B, (int)*Z, (int)*BC,
2280 *WallFunctionType);
2281 }
2282
2283 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2284 * Read and write BCProperty_t/Area_t Nodes *
2285 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2286
FMNAME(cg_bc_area_read_f,CG_BC_AREA_READ_F)2287 CGNSDLL void FMNAME(cg_bc_area_read_f, CG_BC_AREA_READ_F) (cgint_f *fn,
2288 cgint_f *B, cgint_f *Z, cgint_f *BC, CGNS_ENUMT(AreaType_t) *AreaType,
2289 float *SurfaceArea, STR_PSTR(RegionName),
2290 cgint_f *ier STR_PLEN(RegionName))
2291 {
2292 char c_name[CGIO_MAX_NAME_LENGTH+1];
2293 CGNS_ENUMT(AreaType_t) i_AreaType;
2294
2295 *ier = (cgint_f)cg_bc_area_read((int)*fn, (int)*B, (int)*Z, (int)*BC, &i_AreaType,
2296 SurfaceArea, c_name);
2297 if (*ier) return;
2298 string_2_F_string(c_name, STR_PTR(RegionName), STR_LEN(RegionName), ier);
2299 *AreaType = i_AreaType;
2300 }
2301
2302 /*-----------------------------------------------------------------------*/
2303
FMNAME(cg_bc_area_write_f,CG_BC_AREA_WRITE_F)2304 CGNSDLL void FMNAME(cg_bc_area_write_f, CG_BC_AREA_WRITE_F) (cgint_f *fn,
2305 cgint_f *B, cgint_f *Z, cgint_f *BC, CGNS_ENUMT(AreaType_t) *AreaType,
2306 float *SurfaceArea, STR_PSTR(RegionName),
2307 cgint_f *ier STR_PLEN(RegionName))
2308 {
2309 char c_name[CGIO_MAX_NAME_LENGTH+1];
2310 #if DEBUG_FTOC
2311 int n;
2312 #endif
2313
2314 string_2_C_string(STR_PTR(RegionName), STR_LEN(RegionName),
2315 c_name, CGIO_MAX_NAME_LENGTH, ier);
2316 if (*ier) return;
2317 #if DEBUG_FTOC
2318 printf("RegionName='");
2319 for (n=0; n<32; n++) printf("%c",*((STR_PTR(RegionName))+n));
2320 printf("', c_name='%s'\n", c_name);
2321 #endif
2322 *ier = (cgint_f)cg_bc_area_write((int)*fn, (int)*B, (int)*Z, (int)*BC,
2323 *AreaType,
2324 *SurfaceArea, c_name);
2325 }
2326
2327 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2328 * Read and write GridConnectivityProperty_t/Periodic_t Nodes *
2329 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2330
cg_conn_periodic_read_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * I,float * RotationCenter,float * RotationAngle,float * Translation,cgint_f * ier)2331 CGNSDLL void cg_conn_periodic_read_f(
2332 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *I,
2333 float *RotationCenter, float *RotationAngle, float *Translation,
2334 cgint_f *ier)
2335 {
2336 *ier = (cgint_f)cg_conn_periodic_read((int)*fn, (int)*B, (int)*Z, (int)*I,
2337 RotationCenter, RotationAngle, Translation);
2338 }
2339
2340 /*-----------------------------------------------------------------------*/
2341
cg_conn_periodic_write_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * I,float * RotationCenter,float * RotationAngle,float * Translation,cgint_f * ier)2342 CGNSDLL void cg_conn_periodic_write_f (
2343 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *I,
2344 float *RotationCenter, float *RotationAngle, float *Translation,
2345 cgint_f *ier)
2346 {
2347 *ier = (cgint_f)cg_conn_periodic_write((int)*fn, (int)*B, (int)*Z, (int)*I,
2348 RotationCenter, RotationAngle, Translation);
2349 }
2350
2351 /*-----------------------------------------------------------------------*/
2352
cg_1to1_periodic_read_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * I,float * RotationCenter,float * RotationAngle,float * Translation,cgint_f * ier)2353 CGNSDLL void cg_1to1_periodic_read_f(
2354 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *I,
2355 float *RotationCenter, float *RotationAngle, float *Translation,
2356 cgint_f *ier)
2357 {
2358 *ier = (cgint_f)cg_1to1_periodic_read((int)*fn, (int)*B, (int)*Z, (int)*I,
2359 RotationCenter, RotationAngle, Translation);
2360 }
2361
2362 /*-----------------------------------------------------------------------*/
2363
cg_1to1_periodic_write_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * I,float * RotationCenter,float * RotationAngle,float * Translation,cgint_f * ier)2364 CGNSDLL void cg_1to1_periodic_write_f(
2365 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *I,
2366 float *RotationCenter, float *RotationAngle, float *Translation,
2367 cgint_f *ier)
2368 {
2369 *ier = (cgint_f)cg_1to1_periodic_write((int)*fn, (int)*B, (int)*Z, (int)*I,
2370 RotationCenter, RotationAngle, Translation);
2371 }
2372
2373 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2374 * Read and write GridConnectivityProperty_t/AverageInterface_t Nodes *
2375 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2376
cg_conn_average_read_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * I,CGNS_ENUMT (AverageInterfaceType_t)* AverageInterfaceType,cgint_f * ier)2377 CGNSDLL void cg_conn_average_read_f(
2378 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *I,
2379 CGNS_ENUMT(AverageInterfaceType_t) *AverageInterfaceType, cgint_f *ier)
2380 {
2381 CGNS_ENUMT(AverageInterfaceType_t) i_AverageInterfaceType;
2382
2383 *ier = (cgint_f)cg_conn_average_read((int)*fn, (int)*B, (int)*Z, (int)*I,
2384 &i_AverageInterfaceType);
2385 *AverageInterfaceType = i_AverageInterfaceType;
2386 }
2387
2388 /*-----------------------------------------------------------------------*/
2389
cg_conn_average_write_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * I,CGNS_ENUMT (AverageInterfaceType_t)* AverageInterfaceType,cgint_f * ier)2390 CGNSDLL void cg_conn_average_write_f(
2391 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *I,
2392 CGNS_ENUMT(AverageInterfaceType_t) *AverageInterfaceType, cgint_f *ier)
2393 {
2394 *ier = (cgint_f)cg_conn_average_write((int)*fn, (int)*B, (int)*Z, (int)*I,
2395 *AverageInterfaceType);
2396 }
2397
2398 /*-----------------------------------------------------------------------*/
2399
cg_1to1_average_read_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * I,CGNS_ENUMT (AverageInterfaceType_t)* AverageInterfaceType,cgint_f * ier)2400 CGNSDLL void cg_1to1_average_read_f(
2401 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *I,
2402 CGNS_ENUMT(AverageInterfaceType_t) *AverageInterfaceType, cgint_f *ier)
2403 {
2404 CGNS_ENUMT(AverageInterfaceType_t) i_AverageInterfaceType;
2405
2406 *ier = (cgint_f)cg_1to1_average_read((int)*fn, (int)*B, (int)*Z, (int)*I,
2407 &i_AverageInterfaceType);
2408 *AverageInterfaceType = i_AverageInterfaceType;
2409 }
2410
2411 /*-----------------------------------------------------------------------*/
2412
cg_1to1_average_write_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * I,CGNS_ENUMT (AverageInterfaceType_t)* AverageInterfaceType,cgint_f * ier)2413 CGNSDLL void cg_1to1_average_write_f(
2414 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *I,
2415 CGNS_ENUMT(AverageInterfaceType_t) *AverageInterfaceType, cgint_f *ier)
2416 {
2417 *ier = (cgint_f)cg_1to1_average_write((int)*fn, (int)*B, (int)*Z, (int)*I,
2418 *AverageInterfaceType);
2419 }
2420
2421 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2422 * Read and write BCDataSet_t Nodes *
2423 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2424
FMNAME(cg_dataset_read_f,CG_DATASET_READ_F)2425 CGNSDLL void FMNAME(cg_dataset_read_f, CG_DATASET_READ_F) (cgint_f *fn,
2426 cgint_f *B, cgint_f *Z, cgint_f *BC, cgint_f *DSet,
2427 STR_PSTR(Dataset_name), CGNS_ENUMT(BCType_t) *BCType, cgint_f *DirichletFlag,
2428 cgint_f *NeumannFlag, cgint_f *ier STR_PLEN(Dataset_name))
2429 {
2430 char c_name[CGIO_MAX_NAME_LENGTH+1];
2431 CGNS_ENUMT(BCType_t) i_BCType;
2432 int i_DirichletFlag, i_NeumannFlag;
2433
2434 *ier = (cgint_f)cg_dataset_read((int)*fn, (int)*B, (int)*Z, (int)*BC, (int)*DSet,
2435 c_name, &i_BCType, &i_DirichletFlag, &i_NeumannFlag);
2436 if (*ier) return;
2437 string_2_F_string(c_name, STR_PTR(Dataset_name), STR_LEN(Dataset_name), ier);
2438 *BCType = i_BCType;
2439 *DirichletFlag = (cgint_f)i_DirichletFlag;
2440 *NeumannFlag = (cgint_f)i_NeumannFlag;
2441 }
2442
2443 /*-----------------------------------------------------------------------*/
2444
FMNAME(cg_dataset_write_f,CG_DATASET_WRITE_F)2445 CGNSDLL void FMNAME(cg_dataset_write_f, CG_DATASET_WRITE_F) (cgint_f *fn,
2446 cgint_f *B, cgint_f *Z, cgint_f *BC, STR_PSTR(Dataset_name),
2447 CGNS_ENUMT(BCType_t) *BCType, cgint_f *Dset, cgint_f *ier STR_PLEN(Dataset_name))
2448 {
2449 char c_name[CGIO_MAX_NAME_LENGTH+1];
2450 int i_Dset;
2451
2452 string_2_C_string(STR_PTR(Dataset_name), STR_LEN(Dataset_name),
2453 c_name, CGIO_MAX_NAME_LENGTH, ier);
2454 if (*ier) return;
2455 #if DEBUG_FTOC
2456 printf("Dataset_name='%s'\n", c_name);
2457 #endif
2458 *ier = (cgint_f)cg_dataset_write((int)*fn, (int)*B, (int)*Z, (int)*BC, c_name,
2459 *BCType, &i_Dset);
2460 *Dset = (cgint_f)i_Dset;
2461 }
2462
2463 /*-----------------------------------------------------------------------*/
2464
FMNAME(cg_bcdataset_write_f,CG_BCDATASET_WRITE_F)2465 CGNSDLL void FMNAME(cg_bcdataset_write_f, CG_BCDATASET_WRITE_F) (
2466 STR_PSTR(Dataset_name), CGNS_ENUMT(BCType_t) *BCType,
2467 CGNS_ENUMT(BCDataType_t) *BCDataType,
2468 cgint_f *ier STR_PLEN(Dataset_name))
2469 {
2470 char c_name[CGIO_MAX_NAME_LENGTH+1];
2471
2472 string_2_C_string(STR_PTR(Dataset_name), STR_LEN(Dataset_name),
2473 c_name, CGIO_MAX_NAME_LENGTH, ier);
2474 if (*ier) return;
2475 #if DEBUG_FTOC
2476 printf("Dataset_name='%s'\n", c_name);
2477 #endif
2478 *ier = (cgint_f)cg_bcdataset_write(c_name, *BCType,
2479 *BCDataType);
2480 }
2481
2482 /*-----------------------------------------------------------------------*/
2483
cg_bcdataset_info_f(cgint_f * ndataset,cgint_f * ier STR_PLEN (Dataset_name))2484 CGNSDLL void cg_bcdataset_info_f(
2485 cgint_f *ndataset, cgint_f *ier STR_PLEN(Dataset_name))
2486 {
2487 int i_ndataset;
2488
2489 *ier = (cgint_f)cg_bcdataset_info(&i_ndataset);
2490 *ndataset = (cgint_f)i_ndataset;
2491 }
2492
2493 /*-----------------------------------------------------------------------*/
2494
FMNAME(cg_bcdataset_read_f,CG_BCDATASET_READ_F)2495 CGNSDLL void FMNAME(cg_bcdataset_read_f, CG_BCDATASET_READ_F) (
2496 cgint_f *index, STR_PSTR(Dataset_name), CGNS_ENUMT(BCType_t) *BCType,
2497 cgint_f *DirichletFlag, cgint_f *NeumannFlag,
2498 cgint_f *ier STR_PLEN(Dataset_name))
2499 {
2500 char c_name[CGIO_MAX_NAME_LENGTH+1];
2501 CGNS_ENUMT(BCType_t) i_BCType;
2502 int i_DirichletFlag, i_NeumannFlag;
2503
2504 *ier = (cgint_f)cg_bcdataset_read((int)*index, c_name, &i_BCType,
2505 &i_DirichletFlag, &i_NeumannFlag);
2506 if (*ier) return;
2507 *BCType = i_BCType;
2508 *DirichletFlag = (cgint_f)i_DirichletFlag;
2509 *NeumannFlag = (cgint_f)i_NeumannFlag;
2510 string_2_F_string(c_name, STR_PTR(Dataset_name), STR_LEN(Dataset_name), ier);
2511 }
2512
2513 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2514 * Read and write BCData_t Nodes *
2515 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2516
cg_bcdata_write_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * BC,cgint_f * Dset,CGNS_ENUMT (BCDataType_t)* BCDataType,cgint_f * ier)2517 CGNSDLL void cg_bcdata_write_f(cgint_f *fn,
2518 cgint_f *B, cgint_f *Z, cgint_f *BC, cgint_f *Dset,
2519 CGNS_ENUMT(BCDataType_t) *BCDataType, cgint_f *ier)
2520 {
2521 *ier = (cgint_f)cg_bcdata_write((int)*fn, (int)*B, (int)*Z, (int)*BC,
2522 (int)*Dset, *BCDataType);
2523 }
2524
2525 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2526 * Read and write RigidGridMotion_t Nodes *
2527 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2528
cg_n_rigid_motions_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * n_rigid_motions,cgint_f * ier)2529 CGNSDLL void cg_n_rigid_motions_f(cgint_f *fn,
2530 cgint_f *B, cgint_f *Z, cgint_f *n_rigid_motions, cgint_f *ier)
2531 {
2532 int i_n_rigid_motions;
2533
2534 *ier = (cgint_f)cg_n_rigid_motions((int)*fn, (int)*B, (int)*Z, &i_n_rigid_motions);
2535 *n_rigid_motions = (cgint_f)i_n_rigid_motions;
2536 }
2537
2538 /*-----------------------------------------------------------------------*/
2539
FMNAME(cg_rigid_motion_read_f,CG_RIGID_MOTION_READ_F)2540 CGNSDLL void FMNAME(cg_rigid_motion_read_f, CG_RIGID_MOTION_READ_F) (cgint_f *fn,
2541 cgint_f *B, cgint_f *Z, cgint_f *R, STR_PSTR(rmotion_name),
2542 CGNS_ENUMT(RigidGridMotionType_t) *type, cgint_f *ier STR_PLEN(rmotion_name))
2543 {
2544 char c_name[CGIO_MAX_NAME_LENGTH+1];
2545 CGNS_ENUMT(RigidGridMotionType_t) i_type;
2546
2547 *ier = (cgint_f)cg_rigid_motion_read((int)*fn, (int)*B, (int)*Z, (int)*R,
2548 c_name, &i_type);
2549 if (*ier) return;
2550 *type = i_type;
2551 string_2_F_string(c_name, STR_PTR(rmotion_name), STR_LEN(rmotion_name), ier);
2552 }
2553
2554 /*-----------------------------------------------------------------------*/
2555
FMNAME(cg_rigid_motion_write_f,CG_RIGID_MOTION_WRITE_F)2556 CGNSDLL void FMNAME(cg_rigid_motion_write_f, CG_RIGID_MOTION_WRITE_F) (cgint_f *fn,
2557 cgint_f *B, cgint_f *Z, STR_PSTR(rmotion_name),
2558 CGNS_ENUMT(RigidGridMotionType_t) *type, cgint_f *R, cgint_f *ier STR_PLEN(rmotion_name))
2559 {
2560 char c_name[CGIO_MAX_NAME_LENGTH+1];
2561 int i_R;
2562
2563 string_2_C_string(STR_PTR(rmotion_name), STR_LEN(rmotion_name),
2564 c_name, CGIO_MAX_NAME_LENGTH, ier);
2565 if (*ier) return;
2566 *ier = (cgint_f)cg_rigid_motion_write((int)*fn, (int)*B, (int)*Z, c_name,
2567 *type, &i_R);
2568 *R = (cgint_f)i_R;
2569 }
2570
2571 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2572 * Read and write ArbitraryGridMotion_t Nodes *
2573 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2574
cg_n_arbitrary_motions_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * n_arbitrary_motions,cgint_f * ier)2575 CGNSDLL void cg_n_arbitrary_motions_f(
2576 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *n_arbitrary_motions,
2577 cgint_f *ier)
2578 {
2579 int i_n_arbitrary_motions;
2580
2581 *ier = (cgint_f)cg_n_arbitrary_motions((int)*fn, (int)*B, (int)*Z,
2582 &i_n_arbitrary_motions);
2583 *n_arbitrary_motions = (cgint_f)i_n_arbitrary_motions;
2584 }
2585
2586 /*-----------------------------------------------------------------------*/
2587
FMNAME(cg_arbitrary_motion_read_f,CG_ARBITRARY_MOTION_READ_F)2588 CGNSDLL void FMNAME(cg_arbitrary_motion_read_f, CG_ARBITRARY_MOTION_READ_F) (
2589 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *A,
2590 STR_PSTR(amotion_name), CGNS_ENUMT(ArbitraryGridMotionType_t) *type,
2591 cgint_f *ier STR_PLEN(amotion_name))
2592 {
2593 char c_name[CGIO_MAX_NAME_LENGTH+1];
2594 CGNS_ENUMT(ArbitraryGridMotionType_t) i_type;
2595
2596 *ier = (cgint_f)cg_arbitrary_motion_read((int)*fn, (int)*B, (int)*Z, (int)*A,
2597 c_name, &i_type);
2598 if (*ier) return;
2599 *type = i_type;
2600 string_2_F_string(c_name, STR_PTR(amotion_name), STR_LEN(amotion_name), ier);
2601 }
2602
2603 /*-----------------------------------------------------------------------*/
2604
FMNAME(cg_arbitrary_motion_write_f,CG_ARBITRARY_MOTION_WRITE_F)2605 CGNSDLL void FMNAME(cg_arbitrary_motion_write_f, CG_ARBITRARY_MOTION_WRITE_F) (
2606 cgint_f *fn, cgint_f *B, cgint_f *Z, STR_PSTR(amotion_name),
2607 CGNS_ENUMT(ArbitraryGridMotionType_t) *type, cgint_f *A, cgint_f *ier STR_PLEN(amotion_name))
2608 {
2609 char c_name[CGIO_MAX_NAME_LENGTH+1];
2610 int i_A;
2611
2612 string_2_C_string(STR_PTR(amotion_name), STR_LEN(amotion_name),
2613 c_name, CGIO_MAX_NAME_LENGTH, ier);
2614 if (*ier) return;
2615 *ier = (cgint_f)cg_arbitrary_motion_write((int)*fn, (int)*B, (int)*Z, c_name,
2616 *type, &i_A);
2617 *A = (cgint_f)i_A;
2618 }
2619
2620 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2621 * Read and write GridCoordinates_t Nodes *
2622 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2623
cg_ngrids_f(cgint_f * fn,cgint_f * B,cgint_f * Z,cgint_f * ngrids,cgint_f * ier)2624 CGNSDLL void cg_ngrids_f(cgint_f *fn, cgint_f *B,
2625 cgint_f *Z, cgint_f *ngrids, cgint_f *ier)
2626 {
2627 int i_ngrids;
2628
2629 *ier = (cgint_f)cg_ngrids((int)*fn, (int)*B, (int)*Z, &i_ngrids);
2630 *ngrids = (cgint_f)i_ngrids;
2631 }
2632
2633 /*-----------------------------------------------------------------------*/
2634
FMNAME(cg_grid_read_f,CG_GRID_READ_F)2635 CGNSDLL void FMNAME(cg_grid_read_f, CG_GRID_READ_F) (cgint_f *fn,
2636 cgint_f *B, cgint_f *Z, cgint_f *G, STR_PSTR(gridname),
2637 cgint_f *ier STR_PLEN(gridname))
2638 {
2639 char c_name[CGIO_MAX_NAME_LENGTH+1];
2640
2641 *ier = (cgint_f)cg_grid_read((int)*fn, (int)*B, (int)*Z, (int)*G, c_name);
2642 if (!*ier)
2643 string_2_F_string(c_name, STR_PTR(gridname), STR_LEN(gridname), ier);
2644 }
2645
2646 /*-----------------------------------------------------------------------*/
2647
FMNAME(cg_grid_write_f,CG_GRID_WRITE_F)2648 CGNSDLL void FMNAME(cg_grid_write_f, CG_GRID_WRITE_F) (cgint_f *fn,
2649 cgint_f *B, cgint_f *Z, STR_PSTR(gridname), cgint_f *G,
2650 cgint_f *ier STR_PLEN(gridname))
2651 {
2652 char c_name[CGIO_MAX_NAME_LENGTH+1];
2653 int i_G;
2654
2655 string_2_C_string(STR_PTR(gridname), STR_LEN(gridname),
2656 c_name, CGIO_MAX_NAME_LENGTH, ier);
2657 if (*ier) return;
2658 *ier = (cgint_f)cg_grid_write((int)*fn, (int)*B, (int)*Z, c_name, &i_G);
2659 *G = (cgint_f)i_G;
2660 }
2661
2662 /*-----------------------------------------------------------------------*/
2663
FMNAME(cg_grid_bounding_box_write_f,CG_GRID_BOUNDING_BOX_WRITE_F)2664 CGNSDLL void FMNAME(cg_grid_bounding_box_write_f, CG_GRID_BOUNDING_BOX_WRITE_F) (
2665 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *G,
2666 CGNS_ENUMT(DataType_t) *datatype, void *bbox_array,
2667 cgint_f *ier)
2668 {
2669 *ier = (cgint_f)cg_grid_bounding_box_write(
2670 (int)*fn, (int)*B, (int)*Z, (int)*G,
2671 *datatype, bbox_array);
2672 }
2673
2674 /*-----------------------------------------------------------------------*/
2675
FMNAME(cg_grid_bounding_box_read_f,CG_GRID_BOUNDING_BOX_READ_F)2676 CGNSDLL void FMNAME(cg_grid_bounding_box_read_f, CG_GRID_BOUNDING_BOX_READ_F) (
2677 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *G,
2678 CGNS_ENUMT(DataType_t) *datatype, void *bbox_array,
2679 cgint_f *ier)
2680 {
2681 *ier = (cgint_f)cg_grid_bounding_box_read(
2682 (int)*fn, (int)*B, (int)*Z, (int)*G,
2683 *datatype, bbox_array);
2684 }
2685
2686 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2687 * Read and write SimulationType_t Node *
2688 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2689
cg_simulation_type_read_f(cgint_f * fn,cgint_f * B,CGNS_ENUMT (SimulationType_t)* type,cgint_f * ier)2690 CGNSDLL void cg_simulation_type_read_f (
2691 cgint_f *fn, cgint_f *B, CGNS_ENUMT(SimulationType_t) *type, cgint_f *ier)
2692 {
2693 CGNS_ENUMT(SimulationType_t) i_type;
2694
2695 *ier = (cgint_f)cg_simulation_type_read((int)*fn, (int)*B, &i_type);
2696 *type = i_type;
2697 }
2698
2699 /*-----------------------------------------------------------------------*/
2700
cg_simulation_type_write_f(cgint_f * fn,cgint_f * B,CGNS_ENUMT (SimulationType_t)* type,cgint_f * ier)2701 CGNSDLL void cg_simulation_type_write_f(
2702 cgint_f *fn, cgint_f *B, CGNS_ENUMT(SimulationType_t) *type, cgint_f *ier)
2703 {
2704 *ier = (cgint_f)cg_simulation_type_write((int)*fn, (int)*B,
2705 *type);
2706 }
2707
2708 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2709 * Read and write BaseIterativeData_t Node *
2710 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2711
FMNAME(cg_biter_read_f,CG_BITER_READ_F)2712 CGNSDLL void FMNAME(cg_biter_read_f, CG_BITER_READ_F) (cgint_f *fn,
2713 cgint_f *B, STR_PSTR(bitername), cgint_f *nsteps,
2714 cgint_f *ier STR_PLEN(bitername))
2715 {
2716 char c_name[CGIO_MAX_NAME_LENGTH+1];
2717 int i_nsteps;
2718
2719 *ier = (cgint_f)cg_biter_read((int)*fn, (int)*B, c_name, &i_nsteps);
2720 if (*ier) return;
2721 *nsteps = (cgint_f)i_nsteps;
2722 string_2_F_string(c_name, STR_PTR(bitername), STR_LEN(bitername), ier);
2723 }
2724
2725 /*-----------------------------------------------------------------------*/
2726
FMNAME(cg_biter_write_f,CG_BITER_WRITE_F)2727 CGNSDLL void FMNAME(cg_biter_write_f, CG_BITER_WRITE_F) (cgint_f *fn,
2728 cgint_f *B, STR_PSTR(bitername), cgint_f *nsteps,
2729 cgint_f *ier STR_PLEN(bitername))
2730 {
2731 char c_name[CGIO_MAX_NAME_LENGTH+1];
2732
2733 string_2_C_string(STR_PTR(bitername), STR_LEN(bitername),
2734 c_name, CGIO_MAX_NAME_LENGTH, ier);
2735 if (*ier == 0)
2736 *ier = (cgint_f)cg_biter_write((int)*fn, (int)*B, c_name, (int)*nsteps);
2737 }
2738
2739 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2740 * Read and write ZoneIterativeData_t Nodes *
2741 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2742
FMNAME(cg_ziter_read_f,CG_ZITER_READ_F)2743 CGNSDLL void FMNAME(cg_ziter_read_f, CG_ZITER_READ_F) (cgint_f *fn, cgint_f *B,
2744 cgint_f *Z, STR_PSTR(zitername), cgint_f *ier STR_PLEN(zitername))
2745 {
2746 char c_name[CGIO_MAX_NAME_LENGTH+1];
2747
2748 *ier = (cgint_f)cg_ziter_read((int)*fn, (int)*B, (int)*Z, c_name);
2749 if (*ier == 0) {
2750 string_2_F_string(c_name, STR_PTR(zitername), STR_LEN(zitername), ier);
2751 }
2752 }
2753
2754 /*-----------------------------------------------------------------------*/
2755
FMNAME(cg_ziter_write_f,CG_ZITER_WRITE_F)2756 CGNSDLL void FMNAME(cg_ziter_write_f, CG_ZITER_WRITE_F) (cgint_f *fn, cgint_f *B,
2757 cgint_f *Z, STR_PSTR(zitername), cgint_f *ier STR_PLEN(zitername))
2758 {
2759 char c_name[CGIO_MAX_NAME_LENGTH+1];
2760
2761 string_2_C_string(STR_PTR(zitername), STR_LEN(zitername),
2762 c_name, CGIO_MAX_NAME_LENGTH, ier);
2763 if (*ier == 0)
2764 *ier = (cgint_f)cg_ziter_write((int)*fn, (int)*B, (int)*Z, c_name);
2765 }
2766
2767 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2768 * Read and write Gravity_t Node *
2769 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2770
cg_gravity_read_f(cgint_f * fn,cgint_f * B,float * gravity_vector,cgint_f * ier)2771 CGNSDLL void cg_gravity_read_f(cgint_f *fn,
2772 cgint_f *B, float *gravity_vector, cgint_f *ier)
2773 {
2774 *ier = (cgint_f)cg_gravity_read((int)*fn, (int)*B, gravity_vector);
2775 }
2776
2777 /*-----------------------------------------------------------------------*/
2778
cg_gravity_write_f(cgint_f * fn,cgint_f * B,float * gravity_vector,cgint_f * ier)2779 CGNSDLL void cg_gravity_write_f(cgint_f *fn,
2780 cgint_f *B, float *gravity_vector, cgint_f *ier)
2781 {
2782 *ier = (cgint_f)cg_gravity_write((int)*fn, (int)*B, gravity_vector);
2783 }
2784
2785 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2786 * Read and write Axisymmetry_t Node *
2787 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2788
cg_axisym_read_f(cgint_f * fn,cgint_f * B,float * ref_point,float * axis,cgint_f * ier)2789 CGNSDLL void cg_axisym_read_f(cgint_f *fn,
2790 cgint_f *B, float *ref_point, float *axis, cgint_f *ier)
2791 {
2792 *ier = (cgint_f)cg_axisym_read((int)*fn, (int)*B, ref_point, axis);
2793 }
2794
2795 /*-----------------------------------------------------------------------*/
2796
cg_axisym_write_f(cgint_f * fn,cgint_f * B,float * ref_point,float * axis,cgint_f * ier)2797 CGNSDLL void cg_axisym_write_f(cgint_f *fn,
2798 cgint_f *B, float *ref_point, float *axis, cgint_f *ier)
2799 {
2800 *ier = (cgint_f)cg_axisym_write((int)*fn, (int)*B, ref_point, axis);
2801 }
2802
2803 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2804 * Read and write RotatingCoordinates_t Node *
2805 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2806
cg_rotating_read_f(float * rot_rate,float * rot_center,cgint_f * ier)2807 CGNSDLL void cg_rotating_read_f(
2808 float *rot_rate, float *rot_center, cgint_f *ier)
2809 {
2810 *ier = (cgint_f)cg_rotating_read(rot_rate, rot_center);
2811 }
2812
2813 /*-----------------------------------------------------------------------*/
2814
cg_rotating_write_f(float * rot_rate,float * rot_center,cgint_f * ier)2815 CGNSDLL void cg_rotating_write_f(
2816 float *rot_rate, float *rot_center, cgint_f *ier)
2817 {
2818 *ier = (cgint_f)cg_rotating_write(rot_rate, rot_center);
2819 }
2820
2821 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2822 * Read and write IndexArray/Range_t Nodes *
2823 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2824
cg_ptset_info_f(CGNS_ENUMT (PointSetType_t)* ptset_type,cgsize_t * npnts,cgint_f * ier)2825 CGNSDLL void cg_ptset_info_f(
2826 CGNS_ENUMT(PointSetType_t) *ptset_type, cgsize_t *npnts, cgint_f *ier)
2827 {
2828 CGNS_ENUMT(PointSetType_t) i_ptset_type;
2829
2830 *ier = (cgint_f)cg_ptset_info(&i_ptset_type, npnts);
2831 *ptset_type = i_ptset_type;
2832 }
2833
2834 /*-----------------------------------------------------------------------*/
2835
FMNAME(cg_ptset_read_f,CG_PTSET_READ_F)2836 CGNSDLL void FMNAME(cg_ptset_read_f, CG_PTSET_READ_F) (cgsize_t *pnts, cgint_f *ier)
2837 {
2838 *ier = (cgint_f)cg_ptset_read(pnts);
2839 }
2840
2841 /*-----------------------------------------------------------------------*/
2842
FMNAME(cg_ptset_write_f,CG_PTSET_WRITE_F)2843 CGNSDLL void FMNAME(cg_ptset_write_f, CG_PTSET_WRITE_F) (
2844 CGNS_ENUMT(PointSetType_t) *ptset_type, cgsize_t *npnts, cgsize_t *pnts, cgint_f *ier)
2845 {
2846 *ier = (cgint_f)cg_ptset_write(*ptset_type, *npnts, pnts);
2847 }
2848
2849 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
2850 * Go - To Function *
2851 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2852
2853 #ifdef WIN32_FORTRAN
cg_goto_f(cgint_f * fn,cgint_f * B,cgint_f * ier,...)2854 CGNSDLL void __stdcall cg_goto_f(cgint_f *fn, cgint_f *B, cgint_f *ier, ...)
2855 #else
2856 CGNSDLL void FMNAME(cg_goto_f, CG_GOTO_F)(cgint_f *fn, cgint_f *B, cgint_f *ier, ...)
2857 #endif
2858 {
2859 #ifdef _CRAY
2860 _fcd cray_string;
2861 #endif
2862 char *f_label[CG_MAX_GOTO_DEPTH], *label[CG_MAX_GOTO_DEPTH];
2863 int index[CG_MAX_GOTO_DEPTH], n, i, len[CG_MAX_GOTO_DEPTH];
2864 va_list ap;
2865
2866 /* initialize ap to the last parameter before the variable argument list */
2867 /* Note: On HP, print statements btw va_start and va_end create major problems */
2868
2869 va_start(ap, ier);
2870
2871 /* read arguments */
2872 for (n = 0; n < CG_MAX_GOTO_DEPTH; n++) {
2873 #ifdef _CRAY
2874 cray_string = va_arg(ap, _fcd);
2875 f_label[n] = _fcdtocp(cray_string);
2876 len[n] = _fcdlen(cray_string);
2877 #else
2878 f_label[n] = va_arg(ap, char *);
2879 # ifdef WIN32_FORTRAN
2880 /* In Windows, the arguments appear in a different order: char*, len, index,...*/
2881 len[n] = (int)va_arg(ap, int);
2882 # endif
2883 #endif
2884 if (f_label[n][0] == ' ' || 0 == strncmp(f_label[n],"end",3) ||
2885 0 == strncmp(f_label[n],"END",3)) break;
2886
2887 index[n] = (int)*(va_arg(ap, cgint_f *));
2888 if (index[n] < 0) {
2889 cgi_error("Incorrect input to function cg_goto_f");
2890 *ier = 1;
2891 return;
2892 }
2893 }
2894
2895 #if !defined(_CRAY) && !defined(WIN32_FORTRAN)
2896 for (i=0; i<n; i++) {
2897 len[i] = va_arg(ap, int);
2898 }
2899 #endif
2900 va_end(ap);
2901
2902 /* convert strings to C-strings */
2903 for (i=0; i < n; i++) {
2904 label[i] = CGNS_NEW(char,len[i]+1);
2905 string_2_C_string(f_label[i], len[i], label[i], len[i], ier);
2906 }
2907
2908 #if DEBUG_GOTO
2909 printf("\nIn cg_ftoc.c: narguments=%d\n",n);
2910 for (i=0; i<n; i++) printf("\targ %d: '%s' #%d\n",i,label[i], index[i]);
2911 #endif
2912
2913 *ier = (cgint_f)cgi_set_posit((int)*fn, (int)*B, n, index, label);
2914
2915 for (i=0; i<n; i++) CGNS_FREE(label[i]);
2916 return;
2917 }
2918
2919 /*-----------------------------------------------------------------------*/
2920
2921 #ifdef WIN32_FORTRAN
cg_gorel_f(cgint_f * fn,cgint_f * ier,...)2922 CGNSDLL void __stdcall cg_gorel_f(cgint_f *fn, cgint_f *ier, ...)
2923 #else
2924 CGNSDLL void FMNAME(cg_gorel_f, CG_GOREL_F)(cgint_f *fn, cgint_f *ier, ...)
2925 #endif
2926 {
2927 #ifdef _CRAY
2928 _fcd cray_string;
2929 #endif
2930 char *f_label[CG_MAX_GOTO_DEPTH], *label[CG_MAX_GOTO_DEPTH];
2931 int index[CG_MAX_GOTO_DEPTH], n, i, len[CG_MAX_GOTO_DEPTH];
2932 va_list ap;
2933
2934 if (posit == 0) {
2935 cgi_error ("position not set with cg_goto");
2936 *ier = (cgint_f)CG_ERROR;
2937 return;
2938 }
2939 if ((int)*fn != posit_file) {
2940 cgi_error("current position is in the wrong file");
2941 *ier = (cgint_f)CG_ERROR;
2942 return;
2943 }
2944
2945 /* initialize ap to the last parameter before the variable argument list */
2946 /* Note: On HP, print statements btw va_start and va_end create major problems */
2947
2948 va_start(ap, ier);
2949
2950 /* read arguments */
2951 for (n = 0; n < CG_MAX_GOTO_DEPTH; n++) {
2952 #ifdef _CRAY
2953 cray_string = va_arg(ap, _fcd);
2954 f_label[n] = _fcdtocp(cray_string);
2955 len[n] = _fcdlen(cray_string);
2956 #else
2957 f_label[n] = va_arg(ap, char *);
2958 # ifdef WIN32_FORTRAN
2959 /* In Windows, the arguments appear in a different order: char*, len, index,...*/
2960 len[n] = va_arg(ap, int);
2961 # endif
2962 #endif
2963 if (f_label[n][0] == ' ' || 0 == strncmp(f_label[n],"end",3) ||
2964 0 == strncmp(f_label[n],"END",3)) break;
2965
2966 index[n] = (int)*(va_arg(ap, cgint_f *));
2967 if (index[n] < 0) {
2968 cgi_error("Incorrect input to function cg_goto_f");
2969 *ier = 1;
2970 return;
2971 }
2972 }
2973
2974 #if !defined(_CRAY) && !defined(WIN32_FORTRAN)
2975 for (i=0; i<n; i++) {
2976 len[i] = va_arg(ap, int);
2977 }
2978 #endif
2979 va_end(ap);
2980
2981 /* convert strings to C-strings */
2982 for (i=0; i < n; i++) {
2983 label[i] = CGNS_NEW(char,len[i]+1);
2984 string_2_C_string(f_label[i], len[i], label[i], len[i], ier);
2985 }
2986
2987 #if DEBUG_GOTO
2988 printf("\nIn cg_ftoc.c: narguments=%d\n",n);
2989 for (i=0; i<n; i++) printf("\targ %d: '%s' #%d\n",i,label[i], index[i]);
2990 #endif
2991
2992 *ier = (cgint_f)cgi_update_posit(n, index, label);
2993
2994 for (i=0; i<n; i++) CGNS_FREE(label[i]);
2995 return;
2996 }
2997
2998 /*-----------------------------------------------------------------------*/
2999
FMNAME(cg_gopath_f,CG_GOPATH_F)3000 CGNSDLL void FMNAME(cg_gopath_f, CG_GOPATH_F) (cgint_f *fn,
3001 STR_PSTR(path), cgint_f *ier STR_PLEN(path))
3002 {
3003 int length;
3004 char *c_path;
3005
3006 length = (int) STR_LEN(path);
3007 c_path = CGNS_NEW(char, length+1);
3008
3009 string_2_C_string(STR_PTR(path), STR_LEN(path), c_path, length, ier);
3010 if (*ier == 0)
3011 *ier = (cgint_f)cg_gopath((int)*fn, c_path);
3012 CGNS_FREE(c_path);
3013 }
3014
3015 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
3016 * Read Multiple path nodes *
3017 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
3018
FMNAME(cg_famname_read_f,CG_FAMNAME_READ_F)3019 CGNSDLL void FMNAME(cg_famname_read_f, CG_FAMNAME_READ_F) (
3020 STR_PSTR(famname), cgint_f *ier STR_PLEN(famname))
3021 {
3022 char c_name[(CGIO_MAX_NAME_LENGTH+1)*CG_MAX_GOTO_DEPTH+1];
3023
3024 *ier = (cgint_f)cg_famname_read(c_name);
3025 if (*ier == 0)
3026 string_2_F_string(c_name, STR_PTR(famname), STR_LEN(famname), ier);
3027 }
3028
3029 /*-----------------------------------------------------------------------*/
3030
cg_nmultifam_f(cgint_f * nfam,cgint_f * ier)3031 CGNSDLL void cg_nmultifam_f(cgint_f *nfam, cgint_f *ier)
3032 {
3033 int i_nfam;
3034
3035 *ier = (cgint_f)cg_nmultifam(&i_nfam);
3036 *nfam = (cgint_f)i_nfam;
3037 }
3038
3039 /*-----------------------------------------------------------------------*/
3040
FMNAME(cg_multifam_read_f,CG_MULTIFAM_READ_F)3041 CGNSDLL void FMNAME(cg_multifam_read_f, CG_MULTIFAM_READ_F) (cgint_f *N,
3042 STR_PSTR(name), STR_PSTR(family),
3043 cgint_f *ier STR_PLEN(name) STR_PLEN(family))
3044 {
3045 char c_name[CGIO_MAX_NAME_LENGTH+1];
3046 char c_family[(CGIO_MAX_NAME_LENGTH+1)*CG_MAX_GOTO_DEPTH+1];
3047
3048 *ier = (cgint_f)cg_multifam_read((int)*N, c_name, c_family);
3049 if (*ier) return;
3050 string_2_F_string(c_name, STR_PTR(name), STR_LEN(name), ier);
3051 if (*ier) return;
3052 string_2_F_string(c_family, STR_PTR(family), STR_LEN(family), ier);
3053 }
3054
3055 /*-----------------------------------------------------------------------*/
3056
FMNAME(cg_convergence_read_f,CG_CONVERGENCE_READ_F)3057 CGNSDLL void FMNAME(cg_convergence_read_f, CG_CONVERGENCE_READ_F) (
3058 cgint_f *iterations, STR_PSTR(NormDefinitions),
3059 cgint_f *ier STR_PLEN(NormDefinitions))
3060 {
3061 char *c_descr_text;
3062 int i_iterations;
3063
3064 *ier = (cgint_f)cg_convergence_read(&i_iterations, &c_descr_text);
3065 if (*ier) return;
3066 string_2_F_string(c_descr_text, STR_PTR(NormDefinitions),
3067 STR_LEN(NormDefinitions), ier);
3068 *iterations = (cgint_f)i_iterations;
3069 CGNS_FREE(c_descr_text);
3070 }
3071
3072 /*-----------------------------------------------------------------------*/
3073
cg_state_size_f(cgint_f * size,cgint_f * ier)3074 CGNSDLL void cg_state_size_f(
3075 cgint_f *size, cgint_f *ier)
3076 {
3077 char *c_descr_text;
3078
3079 *ier = (cgint_f)cg_state_read(&c_descr_text);
3080 if (*ier) return;
3081 *size = (cgint_f)strlen(c_descr_text);
3082 CGNS_FREE(c_descr_text);
3083 }
3084
3085 /*-----------------------------------------------------------------------*/
3086
FMNAME(cg_state_read_f,CG_STATE_READ_F)3087 CGNSDLL void FMNAME(cg_state_read_f, CG_STATE_READ_F) (
3088 STR_PSTR(StateDescription), cgint_f *ier STR_PLEN(StateDescription))
3089 {
3090 char *c_descr_text;
3091
3092 *ier = (cgint_f)cg_state_read(&c_descr_text);
3093 if (*ier) return;
3094 string_2_F_string(c_descr_text, STR_PTR(StateDescription),
3095 STR_LEN(StateDescription), ier);
3096 CGNS_FREE(c_descr_text);
3097 }
3098
3099 /*-----------------------------------------------------------------------*/
3100
cg_equationset_read_f(cgint_f * EquationDimension,cgint_f * GoverningEquationsFlag,cgint_f * GasModelFlag,cgint_f * ViscosityModelFlag,cgint_f * ThermalConductivityModelFlag,cgint_f * TurbulenceClosureFlag,cgint_f * TurbulenceModelFlag,cgint_f * ier)3101 CGNSDLL void cg_equationset_read_f(
3102 cgint_f *EquationDimension, cgint_f *GoverningEquationsFlag,
3103 cgint_f *GasModelFlag, cgint_f *ViscosityModelFlag,
3104 cgint_f *ThermalConductivityModelFlag,
3105 cgint_f *TurbulenceClosureFlag, cgint_f *TurbulenceModelFlag,
3106 cgint_f *ier)
3107 {
3108 int i_EquationDimension, i_GoverningEquationsFlag, i_GasModelFlag;
3109 int i_ViscosityModelFlag, i_ThermalConductivityModelFlag;
3110 int i_TurbulenceClosureFlag, i_TurbulenceModelFlag;
3111
3112 *ier = (cgint_f)cg_equationset_read(&i_EquationDimension,
3113 &i_GoverningEquationsFlag,
3114 &i_GasModelFlag, &i_ViscosityModelFlag,
3115 &i_ThermalConductivityModelFlag,
3116 &i_TurbulenceClosureFlag, &i_TurbulenceModelFlag);
3117 #if DEBUG_FTOC
3118 printf("in cg_ftoc, EquationDimension=%d\n",*EquationDimension);
3119 #endif
3120 *EquationDimension = (cgint_f)i_EquationDimension;
3121 *GoverningEquationsFlag = (cgint_f)i_GoverningEquationsFlag;
3122 *GasModelFlag = (cgint_f)i_GasModelFlag;
3123 *ViscosityModelFlag = (cgint_f)i_ViscosityModelFlag;
3124 *ThermalConductivityModelFlag = (cgint_f)i_ThermalConductivityModelFlag;
3125 *TurbulenceClosureFlag = (cgint_f)i_TurbulenceClosureFlag;
3126 *TurbulenceModelFlag = (cgint_f)i_TurbulenceModelFlag;
3127 }
3128
3129 /*-----------------------------------------------------------------------*/
3130
cg_equationset_chemistry_read_f(cgint_f * ThermalRelaxationFlag,cgint_f * ChemicalKineticsFlag,cgint_f * ier)3131 CGNSDLL void cg_equationset_chemistry_read_f(
3132 cgint_f *ThermalRelaxationFlag, cgint_f *ChemicalKineticsFlag, cgint_f *ier)
3133 {
3134 int i_ThermalRelaxationFlag, i_ChemicalKineticsFlag;
3135
3136 *ier = (cgint_f)cg_equationset_chemistry_read(&i_ThermalRelaxationFlag,
3137 &i_ChemicalKineticsFlag);
3138 *ThermalRelaxationFlag = (cgint_f)i_ThermalRelaxationFlag;
3139 *ChemicalKineticsFlag = (cgint_f)i_ChemicalKineticsFlag;
3140 }
3141
3142 /*-----------------------------------------------------------------------*/
3143
cg_equationset_elecmagn_read_f(cgint_f * ElecFldModelFlag,cgint_f * MagnFldModelFlag,cgint_f * ConductivityModelFlag,cgint_f * ier)3144 CGNSDLL void cg_equationset_elecmagn_read_f(
3145 cgint_f *ElecFldModelFlag, cgint_f *MagnFldModelFlag,
3146 cgint_f *ConductivityModelFlag, cgint_f *ier)
3147 {
3148 int i_ElecFldModelFlag, i_MagnFldModelFlag, i_ConductivityModelFlag;
3149
3150 *ier = (cgint_f)cg_equationset_elecmagn_read(&i_ElecFldModelFlag,
3151 &i_MagnFldModelFlag, &i_ConductivityModelFlag);
3152 *ElecFldModelFlag = (cgint_f)i_ElecFldModelFlag;
3153 *MagnFldModelFlag = (cgint_f)i_MagnFldModelFlag;
3154 *ConductivityModelFlag = (cgint_f)i_ConductivityModelFlag;
3155 }
3156
3157 /*-----------------------------------------------------------------------*/
3158
cg_governing_read_f(CGNS_ENUMT (GoverningEquationsType_t)* EquationsType,cgint_f * ier)3159 CGNSDLL void cg_governing_read_f(
3160 CGNS_ENUMT(GoverningEquationsType_t) *EquationsType, cgint_f *ier)
3161 {
3162 CGNS_ENUMT(GoverningEquationsType_t) i_EquationsType;
3163
3164 *ier = (cgint_f)cg_governing_read(&i_EquationsType);
3165 *EquationsType = i_EquationsType;
3166 }
3167
3168 /*-----------------------------------------------------------------------*/
3169
cg_diffusion_read_f(cgint_f * diffusion_model,cgint_f * ier)3170 CGNSDLL void cg_diffusion_read_f(cgint_f *diffusion_model, cgint_f *ier)
3171 {
3172 int n, index_dim, ndata, i_diffusion_model[6];
3173
3174 index_dim = cgi_posit_index_dim();
3175 if (index_dim == 1) ndata = 1;
3176 else if (index_dim == 2) ndata = 3;
3177 else if (index_dim == 3) ndata = 6;
3178 else {
3179 cgi_error("invalid value for IndexDimension");
3180 *ier = (cgint_f)CG_ERROR;
3181 return;
3182 }
3183 *ier = (cgint_f)cg_diffusion_read(i_diffusion_model);
3184 if (*ier) return;
3185 for (n = 0; n < ndata; n++)
3186 diffusion_model[n] = (cgint_f)i_diffusion_model[n];
3187 }
3188
3189 /*-----------------------------------------------------------------------*/
3190
FMNAME(cg_model_read_f,CG_MODEL_READ_F)3191 CGNSDLL void FMNAME(cg_model_read_f, CG_MODEL_READ_F) (STR_PSTR(ModelLabel),
3192 CGNS_ENUMT(ModelType_t) *ModelType, cgint_f *ier STR_PLEN(ModelLabel))
3193 {
3194 char c_name[CGIO_MAX_NAME_LENGTH+1];
3195 CGNS_ENUMT(ModelType_t) i_ModelType;
3196
3197 /* convert Fortran-text-string to a C-string */
3198 string_2_C_string(STR_PTR(ModelLabel), STR_LEN(ModelLabel),
3199 c_name, CGIO_MAX_NAME_LENGTH, ier);
3200 if (*ier) return;
3201 *ier = (cgint_f)cg_model_read(c_name, &i_ModelType);
3202 *ModelType = i_ModelType;
3203 }
3204
3205 /*-----------------------------------------------------------------------*/
3206
cg_narrays_f(cgint_f * narrays,cgint_f * ier)3207 CGNSDLL void cg_narrays_f(cgint_f *narrays, cgint_f *ier)
3208 {
3209 int i_narrays;
3210
3211 *ier = (cgint_f)cg_narrays(&i_narrays);
3212 *narrays = (cgint_f)i_narrays;
3213 }
3214
3215 /*-----------------------------------------------------------------------*/
3216
FMNAME(cg_array_info_f,CG_ARRAY_INFO_F)3217 CGNSDLL void FMNAME(cg_array_info_f, CG_ARRAY_INFO_F) (cgint_f *A,
3218 STR_PSTR(ArrayName), CGNS_ENUMT(DataType_t) *DataType, cgint_f *DataDimension,
3219 cgsize_t *DimensionVector, cgint_f *ier STR_PLEN(ArrayName))
3220 {
3221 char c_name[CGIO_MAX_NAME_LENGTH+1];
3222 int i_DataDimension;
3223 CGNS_ENUMT(DataType_t) i_DataType;
3224
3225 *ier = (cgint_f)cg_array_info((int)*A, c_name, &i_DataType, &i_DataDimension,
3226 DimensionVector);
3227 if (*ier) return;
3228 string_2_F_string(c_name, STR_PTR(ArrayName), STR_LEN(ArrayName), ier);
3229 *DataType = i_DataType;
3230 *DataDimension = (cgint_f)i_DataDimension;
3231 }
3232
3233 /*-----------------------------------------------------------------------*/
3234
3235 #ifdef WIN32_FORTRAN
cg_array_read_f(cgint_f * A,void * Data,...)3236 CGNSDLL void __stdcall cg_array_read_f(cgint_f *A, void *Data, ...)
3237 {
3238 va_list ap;
3239 cgint_f *ier;
3240 int DataDimension;
3241 cgsize_t DimensionVector[CGIO_MAX_DIMENSIONS];
3242 char ArrayName[CGIO_MAX_NAME_LENGTH+1];
3243 CGNS_ENUMT(DataType_t) DataType;
3244
3245 cg_array_info((int)*A, ArrayName, &DataType, &DataDimension, DimensionVector);
3246
3247 va_start(ap, Data);
3248 if (DataType == CGNS_ENUMV(Character)) (void) va_arg(ap, int);
3249 ier = va_arg(ap, cgsize_t *);
3250 va_end(ap);
3251 #else
3252 CGNSDLL void FMNAME(cg_array_read_f, CG_ARRAY_READ_F) (cgint_f *A,
3253 void *Data, cgint_f *ier)
3254 {
3255 #endif
3256 *ier = (cgint_f)cg_array_read((int)*A, Data);
3257 }
3258
3259 /*-----------------------------------------------------------------------*/
3260
3261 #ifdef WIN32_FORTRAN
3262 CGNSDLL void __stdcall cg_array_read_as_f(cgint_f *A, CGNS_ENUMT(DataType_t) *type,
3263 void *Data, ...)
3264 {
3265 va_list ap;
3266 cgint_f *ier;
3267 va_start(ap, Data);
3268 if (*type == CGNS_ENUMV(Character))
3269 (void) va_arg(ap, int);
3270 ier = va_arg(ap, cgsize_t *);
3271 va_end(ap);
3272 #else
3273 CGNSDLL void FMNAME(cg_array_read_as_f, CG_ARRAY_READ_AS_F) (cgint_f *A,
3274 CGNS_ENUMT(DataType_t) *type, void *Data, cgint_f *ier)
3275 {
3276 #endif
3277 *ier = (cgint_f)cg_array_read_as((int)*A, *type, Data);
3278 }
3279
3280 /*-----------------------------------------------------------------------*/
3281
3282 CGNSDLL void FMNAME(cg_array_general_read_f, CG_ARRAY_GENERAL_READ_F) (
3283 cgint_f *A,
3284 cgsize_t *s_rmin, cgsize_t *s_rmax, CGNS_ENUMT(DataType_t) *m_type,
3285 cgint_f *m_numdim, cgsize_t *m_dimvals,
3286 cgsize_t *m_rmin, cgsize_t *m_rmax, void *data,
3287 cgint_f *ier)
3288 {
3289 *ier = (cgint_f)cg_array_general_read(
3290 (int)*A,
3291 s_rmin, s_rmax,
3292 *m_type, (int)*m_numdim, m_dimvals, m_rmin, m_rmax, data);
3293 }
3294
3295 /*-----------------------------------------------------------------------*/
3296
3297 CGNSDLL void cg_nintegrals_f(
3298 cgint_f *nintegrals, cgint_f *ier)
3299 {
3300 int i_nintegrals;
3301
3302 *ier = (cgint_f)cg_nintegrals(&i_nintegrals);
3303 *nintegrals = (cgint_f)i_nintegrals;
3304 }
3305
3306 /*-----------------------------------------------------------------------*/
3307
3308 CGNSDLL void FMNAME(cg_integral_read_f, CG_INTEGRAL_READ_F) (
3309 cgint_f *IntegralDataIndex, STR_PSTR(IntegralDataName),
3310 cgint_f *ier STR_PLEN(IntegralDataName))
3311 {
3312 char c_name[CGIO_MAX_NAME_LENGTH+1];
3313
3314 *ier = (cgint_f)cg_integral_read((int)*IntegralDataIndex, c_name);
3315 if (!*ier)
3316 string_2_F_string(c_name, STR_PTR(IntegralDataName),
3317 STR_LEN(IntegralDataName), ier);
3318 }
3319
3320 /*-----------------------------------------------------------------------*/
3321
3322 CGNSDLL void cg_rind_read_f(
3323 cgint_f *RindData, cgint_f *ier)
3324 {
3325 int n, index_dim, i_RindData[6];
3326
3327 index_dim = cgi_posit_index_dim();
3328 *ier = (cgint_f)cg_rind_read(i_RindData);
3329 if (*ier) return;
3330 for (n = 0; n < 2*index_dim; n++)
3331 RindData[n] = (cgint_f)i_RindData[n];
3332 }
3333
3334 /*-----------------------------------------------------------------------*/
3335
3336 CGNSDLL void cg_ndescriptors_f(cgint_f *ndescriptors, cgint_f *ier)
3337 {
3338 int i_ndescriptors;
3339
3340 *ier = (cgint_f)cg_ndescriptors(&i_ndescriptors);
3341 *ndescriptors = (cgint_f)i_ndescriptors;
3342 }
3343
3344 /*-----------------------------------------------------------------------*/
3345
3346 CGNSDLL void cg_descriptor_size_f(
3347 cgint_f *descr_no, cgint_f *descr_size, cgint_f *ier)
3348 {
3349 char *c_descr_text;
3350 char descr_name[CGIO_MAX_NAME_LENGTH+1];
3351
3352 *ier = (cgint_f)cg_descriptor_read((int)*descr_no, descr_name, &c_descr_text);
3353 if (!*ier) {
3354 *descr_size = (cgint_f)strlen(c_descr_text);
3355 CGNS_FREE(c_descr_text);
3356 }
3357 }
3358
3359 /*-----------------------------------------------------------------------*/
3360
3361 CGNSDLL void FMNAME(cg_descriptor_read_f, CG_DESCRIPTOR_READ_F) (
3362 cgint_f *descr_no, STR_PSTR(descr_name), STR_PSTR(descr_text),
3363 cgint_f *ier STR_PLEN(descr_name) STR_PLEN(descr_text))
3364 {
3365 char *c_descr_text;
3366 char c_name[CGIO_MAX_NAME_LENGTH+1];
3367
3368 *ier = (cgint_f)cg_descriptor_read((int)*descr_no, c_name, &c_descr_text);
3369 if (*ier) return;
3370 #if DEBUG_FTOC
3371 printf("In cg_descriptor_read_f, descr_no=%d, descr_name='%s', c_descr_text='%s'\n",
3372 *descr_no, c_name, c_descr_text);
3373 #endif
3374 string_2_F_string(c_name, STR_PTR(descr_name), STR_LEN(descr_name), ier);
3375 if (!*ier)
3376 string_2_F_string(c_descr_text, STR_PTR(descr_text),
3377 STR_LEN(descr_text), ier);
3378 CGNS_FREE(c_descr_text);
3379 }
3380
3381 /*-----------------------------------------------------------------------*/
3382
3383 CGNSDLL void cg_nunits_f(cgint_f *nunits, cgint_f *ier)
3384 {
3385 int i_nunits;
3386
3387 *ier = (cgint_f)cg_nunits(&i_nunits);
3388 *nunits = (cgint_f)i_nunits;
3389 }
3390
3391 /*-----------------------------------------------------------------------*/
3392
3393 CGNSDLL void cg_units_read_f(
3394 CGNS_ENUMT(MassUnits_t) *mass, CGNS_ENUMT(LengthUnits_t) *length, CGNS_ENUMT(TimeUnits_t) *time,
3395 CGNS_ENUMT(TemperatureUnits_t) *temperature, CGNS_ENUMT(AngleUnits_t) *angle, cgint_f *ier)
3396 {
3397 CGNS_ENUMT(MassUnits_t) i_mass;
3398 CGNS_ENUMT(LengthUnits_t) i_length;
3399 CGNS_ENUMT(TimeUnits_t) i_time;
3400 CGNS_ENUMT(TemperatureUnits_t) i_temperature;
3401 CGNS_ENUMT(AngleUnits_t) i_angle;
3402
3403 *ier = (cgint_f)cg_units_read(&i_mass, &i_length, &i_time, &i_temperature, &i_angle);
3404 *mass = i_mass;
3405 *length = i_length;
3406 *time = i_time;
3407 *temperature = i_temperature;
3408 *angle = i_angle;
3409 }
3410
3411 /*-----------------------------------------------------------------------*/
3412
3413 CGNSDLL void cg_unitsfull_read_f(
3414 CGNS_ENUMT(MassUnits_t) *mass, CGNS_ENUMT(LengthUnits_t) *length, CGNS_ENUMT(TimeUnits_t) *time,
3415 CGNS_ENUMT(TemperatureUnits_t) *temperature, CGNS_ENUMT(AngleUnits_t) *angle, CGNS_ENUMT(ElectricCurrentUnits_t) *current,
3416 CGNS_ENUMT(SubstanceAmountUnits_t) *amount, CGNS_ENUMT(LuminousIntensityUnits_t) *intensity, cgint_f *ier)
3417 {
3418 CGNS_ENUMT(MassUnits_t) i_mass;
3419 CGNS_ENUMT(LengthUnits_t) i_length;
3420 CGNS_ENUMT(TimeUnits_t) i_time;
3421 CGNS_ENUMT(TemperatureUnits_t) i_temperature;
3422 CGNS_ENUMT(AngleUnits_t) i_angle;
3423 CGNS_ENUMT(ElectricCurrentUnits_t) i_current;
3424 CGNS_ENUMT(SubstanceAmountUnits_t) i_amount;
3425 CGNS_ENUMT(LuminousIntensityUnits_t) i_intensity;
3426
3427 *ier = (cgint_f)cg_unitsfull_read(&i_mass, &i_length, &i_time, &i_temperature,
3428 &i_angle, &i_current, &i_amount, &i_intensity);
3429 *mass = i_mass;
3430 *length = i_length;
3431 *time = i_time;
3432 *temperature = i_temperature;
3433 *angle = i_angle;
3434 *current = i_current;
3435 *amount = i_amount;
3436 *intensity = i_intensity;
3437 }
3438
3439 /*-----------------------------------------------------------------------*/
3440
3441 CGNSDLL void cg_exponents_info_f(CGNS_ENUMT(DataType_t) *DataType, cgint_f *ier)
3442 {
3443 CGNS_ENUMT(DataType_t) i_DataType;
3444
3445 *ier = (cgint_f)cg_exponents_info(&i_DataType);
3446 *DataType = i_DataType;
3447 }
3448
3449 /*-----------------------------------------------------------------------*/
3450
3451 CGNSDLL void cg_nexponents_f(cgint_f*nexps, cgint_f *ier)
3452 {
3453 int i_nexps;
3454
3455 *ier = (cgint_f)cg_nexponents(&i_nexps);
3456 *nexps = (cgint_f)i_nexps;
3457 }
3458
3459 /*-----------------------------------------------------------------------*/
3460
3461 CGNSDLL void FMNAME(cg_exponents_read_f, CG_EXPONENTS_READ_F) (void *exponents, cgint_f *ier)
3462 {
3463 *ier = (cgint_f)cg_exponents_read(exponents);
3464 }
3465
3466 /*-----------------------------------------------------------------------*/
3467
3468 CGNSDLL void FMNAME(cg_expfull_read_f, CG_EXPFULL_READ_F) (void *exponents, cgint_f *ier)
3469 {
3470 *ier = (cgint_f)cg_expfull_read(exponents);
3471 }
3472
3473 /*-----------------------------------------------------------------------*/
3474
3475 CGNSDLL void cg_conversion_info_f(CGNS_ENUMT(DataType_t) *DataType, cgint_f *ier)
3476 {
3477 CGNS_ENUMT(DataType_t) i_DataType;
3478
3479 *ier = (cgint_f)cg_conversion_info(&i_DataType);
3480 *DataType = i_DataType;
3481 }
3482
3483 /*-----------------------------------------------------------------------*/
3484
3485 CGNSDLL void FMNAME(cg_conversion_read_f,CG_CONVERSION_READ_F) (void *ConversionFactors, cgint_f *ier)
3486 {
3487 *ier = (cgint_f)cg_conversion_read(ConversionFactors);
3488 }
3489
3490 /*-----------------------------------------------------------------------*/
3491
3492 CGNSDLL void cg_dataclass_read_f(CGNS_ENUMT(DataClass_t) *dataclass, cgint_f *ier)
3493 {
3494 CGNS_ENUMT(DataClass_t) i_dataclass;
3495
3496 *ier = (cgint_f)cg_dataclass_read(&i_dataclass);
3497 *dataclass = i_dataclass;
3498 }
3499
3500 /*-----------------------------------------------------------------------*/
3501
3502 CGNSDLL void cg_gridlocation_read_f(
3503 CGNS_ENUMT(GridLocation_t) *GridLocation, cgint_f *ier)
3504 {
3505 CGNS_ENUMT(GridLocation_t) i_GridLocation;
3506
3507 *ier = (cgint_f)cg_gridlocation_read(&i_GridLocation);
3508 *GridLocation = i_GridLocation;
3509 }
3510
3511 /*-----------------------------------------------------------------------*/
3512
3513 CGNSDLL void cg_ordinal_read_f(cgint_f *Ordinal, cgint_f *ier)
3514 {
3515 int i_Ordinal;
3516
3517 *ier = (cgint_f)cg_ordinal_read(&i_Ordinal);
3518 *Ordinal = (cgint_f)i_Ordinal;
3519 }
3520
3521 /*-----------------------------------------------------------------------*/
3522
3523 CGNSDLL void cg_npe_f(CGNS_ENUMT(ElementType_t) *type,
3524 cgint_f *npe, cgint_f *ier)
3525 {
3526 int i_npe;
3527
3528 *ier = (cgint_f)cg_npe(*type, &i_npe);
3529 *npe = (cgint_f)i_npe;
3530 }
3531
3532 /*-----------------------------------------------------------------------*/
3533
3534 CGNSDLL void cg_is_link_f(cgint_f *path_length, cgint_f *ier)
3535 {
3536 int i_path_length;
3537
3538 *ier = (cgint_f)cg_is_link(&i_path_length);
3539 *path_length = (cgint_f)i_path_length;
3540 }
3541
3542 /*-----------------------------------------------------------------------*/
3543
3544 CGNSDLL void FMNAME(cg_link_read_f, CG_LINK_READ_F) (
3545 STR_PSTR(filename), STR_PSTR(link_path), cgint_f *ier
3546 STR_PLEN(filename) STR_PLEN(link_path))
3547 {
3548 char *f_name, *l_name;
3549
3550 *ier = (cgint_f)cg_link_read(&f_name, &l_name);
3551 if (*ier) return;
3552 string_2_F_string(f_name, STR_PTR(filename), STR_LEN(filename), ier);
3553 if (*ier == 0)
3554 string_2_F_string(l_name, STR_PTR(link_path), STR_LEN(link_path), ier);
3555 CGNS_FREE(f_name);
3556 CGNS_FREE(l_name);
3557 }
3558
3559 /*-----------------------------------------------------------------------*/
3560
3561 CGNSDLL void cg_nuser_data_f(
3562 cgint_f *nuser_data, cgint_f *ier)
3563 {
3564 int i_nuser_data;
3565
3566 *ier = (cgint_f)cg_nuser_data(&i_nuser_data);
3567 *nuser_data = (cgint_f)i_nuser_data;
3568 }
3569
3570 /*-----------------------------------------------------------------------*/
3571
3572 CGNSDLL void FMNAME(cg_user_data_read_f, CG_USER_DATA_READ_F) (cgint_f *index,
3573 STR_PSTR(dataname), cgint_f *ier STR_PLEN(dataname))
3574 {
3575 char c_name[CGIO_MAX_NAME_LENGTH+1];
3576
3577 *ier = (cgint_f)cg_user_data_read((int)*index, c_name);
3578 if (*ier == 0)
3579 string_2_F_string(c_name, STR_PTR(dataname), STR_LEN(dataname), ier);
3580 }
3581
3582 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
3583 * Write Multiple path nodes *
3584 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
3585
3586 CGNSDLL void FMNAME(cg_famname_write_f, CG_FAMNAME_WRITE_F) (
3587 STR_PSTR(family_name), cgint_f *ier STR_PLEN(family_name))
3588 {
3589 char c_name[(CGIO_MAX_NAME_LENGTH+1)*CG_MAX_GOTO_DEPTH+1];
3590
3591 /* convert Fortran-text-string to a C-string */
3592 string_2_C_string(STR_PTR(family_name), STR_LEN(family_name),
3593 c_name, (CGIO_MAX_NAME_LENGTH+1)*CG_MAX_GOTO_DEPTH, ier);
3594 if (*ier == 0)
3595 *ier = (cgint_f)cg_famname_write(c_name);
3596 }
3597
3598 /*-----------------------------------------------------------------------*/
3599
3600 CGNSDLL void FMNAME(cg_multifam_write_f, CG_MULTIFAM_WRITE_F) (
3601 STR_PSTR(name), STR_PSTR(family),
3602 cgint_f *ier STR_PLEN(name) STR_PLEN(family))
3603 {
3604 char c_name[CGIO_MAX_NAME_LENGTH+1];
3605 char c_family[(CGIO_MAX_NAME_LENGTH+1)*CG_MAX_GOTO_DEPTH+1];
3606
3607 string_2_C_string(STR_PTR(name), STR_LEN(name),
3608 c_name, CGIO_MAX_NAME_LENGTH, ier);
3609 if (*ier) return;
3610 string_2_C_string(STR_PTR(family), STR_LEN(family),
3611 c_family, (CGIO_MAX_NAME_LENGTH+1)*CG_MAX_GOTO_DEPTH, ier);
3612 if (*ier) return;
3613 *ier = (cgint_f)cg_multifam_write(c_name, c_family);
3614 }
3615
3616 /*-----------------------------------------------------------------------*/
3617
3618 CGNSDLL void FMNAME(cg_convergence_write_f, CG_CONVERGENCE_WRITE_F) (
3619 cgint_f *iterations, STR_PSTR(NormDefinitions),
3620 cgint_f *ier STR_PLEN(NormDefinitions))
3621 {
3622 char *c_string;
3623 int len;
3624
3625 len = STR_LEN(NormDefinitions);
3626 /* convert Fortran-text-string to a C-string */
3627 c_string = CGNS_NEW(char, len+1);
3628 string_2_C_string(STR_PTR(NormDefinitions), len, c_string, len, ier);
3629 if (*ier == 0) {
3630 #if DEBUG_FTOC
3631 printf("In cg_ftoc: c_NormDefinitions = '%s'",c_string);
3632 #endif
3633 *ier = (cgint_f)cg_convergence_write((int)*iterations, c_string);
3634 }
3635 CGNS_FREE(c_string);
3636 }
3637
3638 /*-----------------------------------------------------------------------*/
3639
3640 CGNSDLL void FMNAME(cg_state_write_f, CG_STATE_WRITE_F) (STR_PSTR(StateDescription),
3641 cgint_f *ier STR_PLEN(StateDescription))
3642 {
3643 char *c_string;
3644 int len;
3645
3646 len = STR_LEN(StateDescription);
3647 /* convert Fortran-text-string to a C-string */
3648 c_string = CGNS_NEW(char, len+1);
3649 string_2_C_string(STR_PTR(StateDescription), len, c_string, len, ier);
3650 if (*ier == 0) {
3651 #if DEBUG_FTOC
3652 printf("In cg_ftoc: C_StateDescription = '%s'",c_string);
3653 #endif
3654 *ier = (cgint_f)cg_state_write(c_string);
3655 }
3656 CGNS_FREE(c_string);
3657 }
3658
3659 /*-----------------------------------------------------------------------*/
3660
3661 CGNSDLL void cg_equationset_write_f(cgint_f *EquationDimension, cgint_f *ier)
3662 {
3663 #if DEBUG_FTOC
3664 printf("In cg_ftoc: EquationDimension=%d\n",*EquationDimension);
3665 #endif
3666 *ier = (cgint_f)cg_equationset_write((int)*EquationDimension);
3667 }
3668
3669 /*-----------------------------------------------------------------------*/
3670
3671 CGNSDLL void cg_governing_write_f(
3672 CGNS_ENUMT(GoverningEquationsType_t) *Equationstype, cgint_f *ier)
3673 {
3674 *ier = (cgint_f)cg_governing_write(*Equationstype);
3675 }
3676
3677 /*-----------------------------------------------------------------------*/
3678
3679 CGNSDLL void cg_diffusion_write_f(
3680 cgint_f *diffusion_model, cgint_f *ier)
3681 {
3682 int n, index_dim, ndata, i_diffusion_model[6];
3683
3684 index_dim = cgi_posit_index_dim();
3685 if (index_dim == 1) ndata = 1;
3686 else if (index_dim == 2) ndata = 3;
3687 else if (index_dim == 3) ndata = 6;
3688 else {
3689 cgi_error("invalid value for IndexDimension");
3690 *ier = (cgint_f)CG_ERROR;
3691 return;
3692 }
3693 for (n = 0; n < ndata; n++)
3694 i_diffusion_model[n] = (int)diffusion_model[n];
3695 *ier = (cgint_f)cg_diffusion_write(i_diffusion_model);
3696 }
3697
3698 /*-----------------------------------------------------------------------*/
3699
3700 CGNSDLL void FMNAME(cg_model_write_f, CG_MODEL_WRITE_F) (STR_PSTR(ModelLabel),
3701 CGNS_ENUMT(ModelType_t) *ModelType, cgint_f *ier STR_PLEN(ModelLabel))
3702 {
3703 char c_name[CGIO_MAX_NAME_LENGTH+1];
3704
3705 /* convert Fortran-text-string to a C-string */
3706 string_2_C_string(STR_PTR(ModelLabel), STR_LEN(ModelLabel),
3707 c_name, CGIO_MAX_NAME_LENGTH, ier);
3708 if (*ier == 0)
3709 *ier = (cgint_f)cg_model_write(c_name, *ModelType);
3710 }
3711
3712 /*-----------------------------------------------------------------------*/
3713
3714 #ifdef WIN32_FORTRAN
3715 CGNSDLL void __stdcall cg_array_write_f(STR_PSTR(ArrayName),
3716 CGNS_ENUMT(DataType_t) *DataType, cgint_f *DataDimension,
3717 cgsize_t *DimensionVector, void *Data, ...)
3718 {
3719 va_list ap;
3720 cgint_f *ier;
3721 char c_name[CGIO_MAX_NAME_LENGTH+1];
3722
3723 va_start(ap, Data);
3724 if ((CGNS_ENUMT(DataType_t))*DataType == CGNS_ENUMV(Character))
3725 (void) va_arg(ap, int);
3726 ier = va_arg(ap, cgsize_t *);
3727 va_end(ap);
3728 #else
3729 CGNSDLL void FMNAME(cg_array_write_f, CG_ARRAY_WRITE_F) (STR_PSTR(ArrayName),
3730 CGNS_ENUMT(DataType_t) *DataType, cgint_f *DataDimension, cgsize_t *DimensionVector,
3731 void *Data, cgint_f *ier STR_PLEN(ArrayName))
3732 {
3733 char c_name[CGIO_MAX_NAME_LENGTH+1];
3734 #endif
3735
3736 /* convert Fortran-text-string to a C-string */
3737 string_2_C_string(STR_PTR(ArrayName), STR_LEN(ArrayName),
3738 c_name, CGIO_MAX_NAME_LENGTH, ier);
3739 if (*ier == 0)
3740 *ier = (cgint_f)cg_array_write(c_name, *DataType,
3741 (int)*DataDimension, DimensionVector, Data);
3742 }
3743
3744 /* CGNSDLL void cg_array_write_f03 (ArrayName, */
3745 /* CGNS_ENUMT(DataType_t) *DataType, cgint_f *DataDimension, cgsize_t *DimensionVector, */
3746 /* void *Data, cgint_f *ier STR_PLEN(ArrayName)) */
3747 /* { */
3748 /* char c_name[CGIO_MAX_NAME_LENGTH+1]; */
3749
3750 /* /\* convert Fortran-text-string to a C-string *\/ */
3751 /* string_2_C_string(STR_PTR(ArrayName), STR_LEN(ArrayName), */
3752 /* c_name, CGIO_MAX_NAME_LENGTH, ier); */
3753 /* if (*ier == 0) */
3754 /* *ier = (cgint_f)cg_array_write(c_name, *DataType, */
3755 /* (int)*DataDimension, DimensionVector, Data); */
3756 /* } */
3757
3758 /*-----------------------------------------------------------------------*/
3759
3760 CGNSDLL void FMNAME(cg_array_general_write_f, CG_ARRAY_GENERAL_WRITE_F) (
3761 STR_PSTR(arrayname), CGNS_ENUMT(DataType_t) *s_type, cgint_f *s_numdim, cgsize_t *s_dimvals,
3762 cgsize_t *s_rmin, cgsize_t *s_rmax,
3763 CGNS_ENUMT(DataType_t) *m_type, cgint_f *m_numdim, cgsize_t *m_dimvals,
3764 cgsize_t *m_rmin, cgsize_t *m_rmax,
3765 void *data, cgint_f *ier STR_PLEN(arrayname))
3766 {
3767 char c_name[CGIO_MAX_NAME_LENGTH+1];
3768
3769 string_2_C_string(STR_PTR(arrayname), STR_LEN(arrayname),
3770 c_name, CGIO_MAX_NAME_LENGTH, ier);
3771 if (*ier) return;
3772 #if DEBUG_FTOC
3773 printf(" arrayname='%s'\n", c_name);
3774 #endif
3775 *ier = (cgint_f)cg_array_general_write(c_name, *s_type, (int)*s_numdim,
3776 s_dimvals, s_rmin, s_rmax,
3777 *m_type, (int)*m_numdim,
3778 m_dimvals, m_rmin, m_rmax, data);
3779 }
3780
3781 /*-----------------------------------------------------------------------*/
3782
3783 CGNSDLL void FMNAME(cg_integral_write_f, CG_INTEGRAL_WRITE_F) (
3784 STR_PSTR(IntegralDataName), cgint_f *ier STR_PLEN(IntegralDataName))
3785 {
3786 char c_name[CGIO_MAX_NAME_LENGTH+1];
3787
3788 /* convert Fortran-text-string to a C-string */
3789 string_2_C_string(STR_PTR(IntegralDataName), STR_LEN(IntegralDataName),
3790 c_name, CGIO_MAX_NAME_LENGTH, ier);
3791 if (*ier == 0)
3792 *ier = (cgint_f)cg_integral_write(c_name);
3793 }
3794
3795 /*-----------------------------------------------------------------------*/
3796
3797 CGNSDLL void cg_rind_write_f(cgint_f *RindData, cgint_f *ier)
3798 {
3799 int n, index_dim, i_RindData[6];
3800
3801 index_dim = cgi_posit_index_dim();
3802 for (n = 0; n < 2*index_dim; n++)
3803 i_RindData[n] = (int)RindData[n];
3804 *ier = (cgint_f)cg_rind_write(i_RindData);
3805 }
3806
3807 /*-----------------------------------------------------------------------*/
3808
3809 CGNSDLL void FMNAME(cg_descriptor_write_f, CG_DESCRIPTOR_WRITE_F) (
3810 STR_PSTR(descr_name), STR_PSTR(descr_text),
3811 cgint_f *ier STR_PLEN(descr_name) STR_PLEN(descr_text))
3812 {
3813 char *c_descr_text, c_descr_name[CGIO_MAX_NAME_LENGTH+1];
3814 int len;
3815
3816 /* On Linux, the string found in STR_PTR(descr_text) is not terminated.
3817 Therefore it can be much longer and can't be used as is. The value returned
3818 by STR_LEN(descr_text) is correct. So the string can be terminatted properly:
3819 char *terminated_descr_text;
3820 terminated_descr_text=(char*)malloc(strlen(STR_PTR(descr_text))+1);
3821 strcpy(terminated_descr_text,STR_PTR(descr_text));
3822 terminated_descr_text[STR_LEN(descr_text)]='\0';
3823 It's not necessary to do this here since we're always calling get_adf_c_name()
3824 which truncates the string to STR_LEN(descr_name) or shorter.
3825 */
3826
3827 /* convert Fortran-text-string to a C-string */
3828 string_2_C_string(STR_PTR(descr_name), STR_LEN(descr_name),
3829 c_descr_name, CGIO_MAX_NAME_LENGTH, ier);
3830 if (*ier) return;
3831
3832 len = STR_LEN(descr_text);
3833 c_descr_text = CGNS_NEW(char, len+1);
3834 string_2_C_string(STR_PTR(descr_text), len, c_descr_text, len, ier);
3835 if (*ier == 0) {
3836 #if DEBUG_FTOC
3837 printf("c_descr_name='%s', c_descr_text='%s'\n",c_descr_name, c_descr_text);
3838 #endif
3839
3840 /* Call C-routine */
3841 *ier = (cgint_f)cg_descriptor_write(c_descr_name, c_descr_text);
3842 }
3843 CGNS_FREE(c_descr_text);
3844 }
3845
3846 /*-----------------------------------------------------------------------*/
3847
3848 CGNSDLL void cg_units_write_f(
3849 CGNS_ENUMT(MassUnits_t) *mass, CGNS_ENUMT(LengthUnits_t) *length, CGNS_ENUMT(TimeUnits_t) *time,
3850 CGNS_ENUMT(TemperatureUnits_t) *temperature, CGNS_ENUMT(AngleUnits_t) *angle, cgint_f *ier)
3851 {
3852 *ier = (cgint_f)cg_units_write(*mass,
3853 *length,
3854 *time,
3855 *temperature,
3856 *angle);
3857 }
3858
3859 /*-----------------------------------------------------------------------*/
3860
3861 CGNSDLL void cg_unitsfull_write_f(
3862 CGNS_ENUMT(MassUnits_t) *mass, CGNS_ENUMT(LengthUnits_t) *length, CGNS_ENUMT(TimeUnits_t) *time,
3863 CGNS_ENUMT(TemperatureUnits_t) *temperature, CGNS_ENUMT(AngleUnits_t) *angle, CGNS_ENUMT(ElectricCurrentUnits_t) *current,
3864 CGNS_ENUMT(SubstanceAmountUnits_t) *amount, CGNS_ENUMT(LuminousIntensityUnits_t) *intensity, cgint_f *ier)
3865 {
3866 *ier = (cgint_f)cg_unitsfull_write(*mass,
3867 *length,
3868 *time,
3869 *temperature,
3870 *angle,
3871 *current,
3872 *amount,
3873 *intensity);
3874 }
3875
3876 /*-----------------------------------------------------------------------*/
3877
3878 CGNSDLL void FMNAME(cg_exponents_write_f,CG_EXPONENTS_WRITE_F) (
3879 CGNS_ENUMT(DataType_t)*DataType, void *exponents, cgint_f *ier)
3880 {
3881 *ier = (cgint_f)cg_exponents_write(*DataType, exponents);
3882 }
3883
3884 /*-----------------------------------------------------------------------*/
3885
3886 CGNSDLL void FMNAME(cg_expfull_write_f, CG_EXPFULL_WRITE_F) (
3887 CGNS_ENUMT(DataType_t) *DataType, void *exponents, cgint_f *ier)
3888 {
3889 *ier = (cgint_f)cg_expfull_write(*DataType, exponents);
3890 }
3891
3892 /*-----------------------------------------------------------------------*/
3893
3894 CGNSDLL void FMNAME(cg_conversion_write_f, CG_CONVERSION_WRITE_F) (
3895 CGNS_ENUMT(DataType_t) *DataType, void *ConversionFactors, cgint_f *ier)
3896 {
3897 *ier = (cgint_f)cg_conversion_write(*DataType,
3898 ConversionFactors);
3899 }
3900
3901 /*-----------------------------------------------------------------------*/
3902
3903 CGNSDLL void cg_dataclass_write_f(
3904 CGNS_ENUMT(DataClass_t) *dataclass, cgint_f *ier)
3905 {
3906 *ier = (cgint_f)cg_dataclass_write(*dataclass);
3907 }
3908
3909 /*-----------------------------------------------------------------------*/
3910
3911 CGNSDLL void cg_gridlocation_write_f(
3912 CGNS_ENUMT(GridLocation_t) *GridLocation, cgint_f *ier)
3913 {
3914 *ier = (cgint_f)cg_gridlocation_write(*GridLocation);
3915 }
3916
3917 /*-----------------------------------------------------------------------*/
3918
3919 CGNSDLL void cg_ordinal_write_f(cgint_f *Ordinal, cgint_f *ier)
3920 {
3921 *ier = (cgint_f)cg_ordinal_write((int)*Ordinal);
3922 }
3923
3924 /*-----------------------------------------------------------------------*/
3925
3926 CGNSDLL void FMNAME(cg_link_write_f, CG_LINK_WRITE_F) (
3927 STR_PSTR(nodename), STR_PSTR(filename), STR_PSTR(name_in_file), cgint_f *ier
3928 STR_PLEN(nodename) STR_PLEN(filename) STR_PLEN(name_in_file))
3929 {
3930 char n_name[CGIO_MAX_NAME_LENGTH+1];
3931 char f_name[CGIO_MAX_FILE_LENGTH+1];
3932 char i_name[CGIO_MAX_LINK_LENGTH+1];
3933
3934 string_2_C_string(STR_PTR(nodename), STR_LEN(nodename),
3935 n_name, CGIO_MAX_NAME_LENGTH, ier);
3936 if (*ier) return;
3937 string_2_C_string(STR_PTR(filename), STR_LEN(filename),
3938 f_name, CGIO_MAX_FILE_LENGTH, ier);
3939 if (*ier) return;
3940 string_2_C_string(STR_PTR(name_in_file), STR_LEN(name_in_file),
3941 i_name, CGIO_MAX_LINK_LENGTH, ier);
3942 if (*ier) return;
3943
3944 *ier = (cgint_f)cg_link_write(n_name, f_name, i_name);
3945 }
3946
3947 /*-----------------------------------------------------------------------*/
3948
3949 CGNSDLL void FMNAME(cg_user_data_write_f, CG_USER_DATA_WRITE_F) (
3950 STR_PSTR(dataname), cgint_f *ier STR_PLEN(dataname))
3951 {
3952 char d_name[CGIO_MAX_NAME_LENGTH+1];
3953
3954 string_2_C_string(STR_PTR(dataname), STR_LEN(dataname),
3955 d_name, CGIO_MAX_NAME_LENGTH, ier);
3956 if (*ier == 0)
3957 *ier = (cgint_f)cg_user_data_write(d_name);
3958 }
3959
3960 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
3961 * General Delete Function *
3962 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
3963
3964 CGNSDLL void FMNAME(cg_delete_node_f, CG_DELETE_NODE_F) (STR_PSTR(node_name),
3965 cgint_f *ier STR_PLEN(node_name))
3966 {
3967 /* ici */
3968 char c_name[CGIO_MAX_NAME_LENGTH+1];
3969
3970 /* convert Fortran-text-string to a C-string */
3971 string_2_C_string(STR_PTR(node_name), STR_LEN(node_name),
3972 c_name, CGIO_MAX_NAME_LENGTH, ier);
3973 if (*ier) return;
3974 *ier = (cgint_f)cg_delete_node(c_name);
3975 #if DEBUG_FTOC
3976 printf("\n Deleting node ='%s'\n", c_name);
3977 #endif
3978 }
3979
3980 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
3981 * Error Handling Functions *
3982 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
3983
3984 CGNSDLL void FMNAME(cg_get_error_f, CG_GET_ERROR_F) (
3985 STR_PSTR(errmsg) STR_PLEN(errmsg))
3986 {
3987 cgint_f ierr;
3988
3989 string_2_F_string ((char *)cg_get_error(), STR_PTR(errmsg),
3990 STR_LEN(errmsg), &ierr);
3991 }
3992
3993 /*-----------------------------------------------------------------------*/
3994
3995 CGNSDLL void cg_error_exit_f()
3996 {
3997 cg_error_exit();
3998 }
3999
4000 /*-----------------------------------------------------------------------*/
4001
4002 CGNSDLL void cg_error_print_f()
4003 {
4004 cg_error_print();
4005 }
4006
4007 /*-----------------------------------------------------------------------*/
4008
4009 static void exit_on_error(int is_fatal, char *errmsg)
4010 {
4011 if (is_fatal) {
4012 fprintf(stderr, "FATAL ERROR:%s\n", errmsg);
4013 exit(1);
4014 }
4015 }
4016
4017 CGNSDLL void cg_exit_on_error_f(cgint_f *flag)
4018 {
4019 cg_error_handler((int)*flag ? exit_on_error : NULL);
4020 }
4021
4022 /*-----------------------------------------------------------------------*/
4023
4024 CGNSDLL void FMNAME(cgio_set_dimensions_f_0, CGIO_SET_DIMENSIONS_F_0) (
4025 cgint_f *cgio_num, double *id, STR_PSTR(data_type), cgint_f *ndims,
4026 cgsize_t *dims, cgint_f *ier STR_PLEN(data_type) )
4027 {
4028 char c_type[CGIO_MAX_DATATYPE_LENGTH+1];
4029
4030 string_2_C_string(STR_PTR(data_type), STR_LEN(data_type),
4031 c_type, CGIO_MAX_DATATYPE_LENGTH, ier);
4032 if (*ier) return;
4033
4034 *ier = (cgint_f)cgio_set_dimensions((int)*cgio_num, *id, c_type, (int)*ndims, dims);
4035 }
4036
4037 CGNSDLL void FMNAME(cgio_set_dimensions_f_1, CGIO_SET_DIMENSIONS_F_1) (
4038 cgint_f *cgio_num, double *id, STR_PSTR(data_type), cgint_f *ndims,
4039 cgsize_t *dims, cgint_f *ier STR_PLEN(data_type) )
4040 {
4041 char c_type[CGIO_MAX_DATATYPE_LENGTH+1];
4042
4043 string_2_C_string(STR_PTR(data_type), STR_LEN(data_type),
4044 c_type, CGIO_MAX_DATATYPE_LENGTH, ier);
4045 if (*ier) return;
4046
4047 *ier = (cgint_f)cgio_set_dimensions((int)*cgio_num, *id, c_type, (int)*ndims, dims);
4048 }
4049
4050 CGNSDLL void cgio_get_dimensions_f_0(
4051 cgint_f *cgio_num, double *id, cgint_f *ndims, cgsize_t *dims,
4052 cgint_f *ier)
4053 {
4054 int i_ndims;
4055
4056 *ier = (cgint_f)cgio_get_dimensions((int)*cgio_num, *id, &i_ndims, dims);
4057 *ndims = (cgint_f)i_ndims;
4058 }
4059
4060 CGNSDLL void cgio_get_dimensions_f_1(
4061 cgint_f *cgio_num, double *id, cgint_f *ndims, cgsize_t *dims,
4062 cgint_f *ier)
4063 {
4064 int i_ndims;
4065
4066 *ier = (cgint_f)cgio_get_dimensions((int)*cgio_num, *id, &i_ndims, dims);
4067 *ndims = (cgint_f)i_ndims;
4068 }
4069
4070 #if CG_BUILD_PARALLEL
4071
4072 /*======================================================================
4073 * parallel IO interface
4074 *======================================================================*/
4075
4076 CGNSDLL void cgp_mpi_comm_f(cgint_f *mpi_comm_f, cgint_f *ier)
4077 {
4078 MPI_Comm mpi_comm_c;
4079 mpi_comm_c = MPI_Comm_f2c((int)*mpi_comm_f);
4080 *ier = (cgint_f)cgp_mpi_comm(mpi_comm_c);
4081 }
4082
4083 CGNSDLL void cgp_mpi_info_f(int *pcg_mpi_info_f, cgint_f *ier)
4084 {
4085 MPI_Info pcg_mpi_info_c;
4086 pcg_mpi_info_c = MPI_Info_f2c((int)*pcg_mpi_info_f);
4087 *ier = (cgint_f)cgp_mpi_info(pcg_mpi_info_c);
4088 }
4089
4090 /*-----------------------------------------------------------------------*/
4091
4092 CGNSDLL void cgp_pio_mode_f(CGNS_ENUMT(PIOmode_t) *mode, cgint_f *ier)
4093 {
4094 *ier = (cgint_f)cgp_pio_mode(*mode);
4095 }
4096
4097 /*-----------------------------------------------------------------------*/
4098
4099 CGNSDLL void FMNAME(cgp_open_f, CGP_OPEN_F) (STR_PSTR(filename), int *mode,
4100 cgint_f *fn, cgint_f *ier STR_PLEN(filename))
4101
4102 {
4103 int length, i_fn;
4104 char *c_name;
4105
4106 length = (int) STR_LEN(filename);
4107 c_name = CGNS_NEW(char, length+1);
4108
4109 string_2_C_string(STR_PTR(filename), STR_LEN(filename), c_name, length, ier);
4110 if (*ier == 0) {
4111 #if DEBUG_FTOC
4112 printf("filename='%s'\n",c_name);
4113 #endif
4114 *ier = (cgint_f)cgp_open(c_name, *mode, &i_fn);
4115 *fn = (cgint_f)i_fn;
4116 }
4117 CGNS_FREE(c_name);
4118 }
4119
4120 /*-----------------------------------------------------------------------*/
4121
4122 CGNSDLL void cgp_close_f(cgint_f *fn, cgint_f *ier)
4123 {
4124 *ier = (cgint_f)cgp_close((int)*fn);
4125 }
4126
4127 /*-----------------------------------------------------------------------*/
4128
4129 CGNSDLL void FMNAME(cgp_coord_write_f, CGP_COORD_WRITE_F) (cgint_f *fn,
4130 cgint_f *B, cgint_f *Z, CGNS_ENUMT(DataType_t) *type, STR_PSTR(coordname),
4131 cgint_f *C, cgint_f *ier STR_PLEN(coordname))
4132 {
4133 char c_name[CGIO_MAX_NAME_LENGTH+1];
4134 int i_C;
4135
4136 string_2_C_string(STR_PTR(coordname), STR_LEN(coordname),
4137 c_name, CGIO_MAX_NAME_LENGTH, ier);
4138 if (*ier) return;
4139 *ier = (cgint_f)cgp_coord_write((int)*fn, (int)*B, (int)*Z,
4140 *type, c_name, &i_C);
4141 *C = (cgint_f)i_C;
4142 }
4143
4144 /*-----------------------------------------------------------------------*/
4145
4146 CGNSDLL void FMNAME(cgp_coord_write_data_f,CGP_COORD_WRITE_DATA_F)(
4147 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *C,
4148 cgsize_t *rmin, cgsize_t *rmax, void *data, cgint_f *ier)
4149 {
4150 *ier = (cgint_f)cgp_coord_write_data((int)*fn, (int)*B, (int)*Z, (int)*C,
4151 rmin, rmax, data);
4152 }
4153
4154 /*-----------------------------------------------------------------------*/
4155
4156 CGNSDLL void FMNAME(cgp_coord_read_data_f,CGP_COORD_READ_DATA_F)(
4157 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *C,
4158 cgsize_t *rmin, cgsize_t *rmax, void *data, cgint_f *ier)
4159 {
4160 *ier = (cgint_f)cgp_coord_read_data((int)*fn, (int)*B, (int)*Z, (int)*C,
4161 rmin, rmax, data);
4162 }
4163
4164 /*-----------------------------------------------------------------------*/
4165
4166 CGNSDLL void FMNAME(cgp_section_write_f, CGP_SECTION_WRITE_F) (
4167 cgint_f *fn, cgint_f *B, cgint_f *Z, STR_PSTR(section_name),
4168 CGNS_ENUMT(ElementType_t)*type, cgsize_t *start, cgsize_t *end, cgint_f *nbndry,
4169 cgint_f *S, cgint_f *ier STR_PLEN(section_name))
4170 {
4171 char c_name[CGIO_MAX_NAME_LENGTH+1];
4172 int i_S;
4173
4174 /* convert Fortran-text-string to a C-string */
4175 string_2_C_string(STR_PTR(section_name), STR_LEN(section_name),
4176 c_name, CGIO_MAX_NAME_LENGTH, ier);
4177 if (*ier) return;
4178 *ier = (cgint_f)cgp_section_write((int)*fn, (int)*B, (int)*Z, c_name,
4179 *type, *start, *end, (int)*nbndry, &i_S);
4180 *S = (cgint_f)i_S;
4181 }
4182
4183 /*-----------------------------------------------------------------------*/
4184
4185 CGNSDLL void FMNAME(cgp_elements_write_data_f,CGP_ELEMENTS_WRITE_DATA_F)(
4186 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S, cgsize_t *start,
4187 cgsize_t *end, cgsize_t *elements, cgint_f *ier)
4188 {
4189 *ier = (cgint_f)cgp_elements_write_data((int)*fn, (int)*B, (int)*Z, (int)*S,
4190 *start, *end, elements);
4191 }
4192
4193 /*-----------------------------------------------------------------------*/
4194
4195 CGNSDLL void FMNAME(cgp_elements_read_data_f,CGP_ELEMENTS_READ_DATA_F)(
4196 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S, cgsize_t *start,
4197 cgsize_t *end, cgsize_t *elements, cgint_f *ier)
4198 {
4199 *ier = (cgint_f)cgp_elements_read_data((int)*fn, (int)*B, (int)*Z, (int)*S,
4200 *start, *end, elements);
4201 }
4202
4203 /*-----------------------------------------------------------------------*/
4204
4205 CGNSDLL void FMNAME(cgp_field_write_f, CGP_FIELD_WRITE_F) (cgint_f *fn,
4206 cgint_f *B, cgint_f *Z, cgint_f *S, CGNS_ENUMT(DataType_t) *type,
4207 STR_PSTR(fieldname), cgint_f *F, cgint_f *ier STR_PLEN(fieldname))
4208 {
4209 char c_name[CGIO_MAX_NAME_LENGTH+1];
4210 int i_F;
4211
4212 string_2_C_string(STR_PTR(fieldname), STR_LEN(fieldname),
4213 c_name, CGIO_MAX_NAME_LENGTH, ier);
4214 if (*ier) return;
4215 *ier = (cgint_f)cgp_field_write((int)*fn, (int)*B, (int)*Z, (int)*S,
4216 *type, c_name, &i_F);
4217 *F = (cgint_f)i_F;
4218 }
4219
4220 /*-----------------------------------------------------------------------*/
4221
4222 CGNSDLL void FMNAME(cgp_field_write_data_f,CGP_FIELD_WRITE_DATA_F)(
4223 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S,
4224 cgint_f *F, cgsize_t *rmin, cgsize_t *rmax, void *field_ptr,
4225 cgint_f *ier)
4226 {
4227 *ier = (cgint_f)cgp_field_write_data((int)*fn, (int)*B, (int)*Z, (int)*S,
4228 (int)*F, rmin, rmax, field_ptr);
4229 }
4230
4231 /*-----------------------------------------------------------------------*/
4232
4233 CGNSDLL void FMNAME(cgp_field_read_data_f,CGP_FIELD_READ_DATA_F)(
4234 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S,
4235 cgint_f *F, cgsize_t *rmin, cgsize_t *rmax, void *field_ptr,
4236 cgint_f *ier)
4237 {
4238 *ier = (cgint_f)cgp_field_read_data((int)*fn, (int)*B, (int)*Z, (int)*S,
4239 (int)*F, rmin, rmax, field_ptr);
4240 }
4241
4242 /*-----------------------------------------------------------------------*/
4243
4244 CGNSDLL void FMNAME(cgp_array_write_f, CGP_ARRAY_WRITE_F) (STR_PSTR(ArrayName),
4245 CGNS_ENUMT(DataType_t) *DataType, cgint_f *DataDimension, cgsize_t *DimensionVector,
4246 cgint_f *A, cgint_f *ier STR_PLEN(ArrayName))
4247 {
4248 char c_name[CGIO_MAX_NAME_LENGTH+1];
4249 int i_A;
4250
4251 /* convert Fortran-text-string to a C-string */
4252 string_2_C_string(STR_PTR(ArrayName), STR_LEN(ArrayName),
4253 c_name, CGIO_MAX_NAME_LENGTH, ier);
4254 if (*ier) return;
4255 *ier = (cgint_f)cgp_array_write(c_name, *DataType,
4256 (int)*DataDimension, DimensionVector, &i_A);
4257 *A = (cgint_f)i_A;
4258 }
4259
4260 /*-----------------------------------------------------------------------*/
4261
4262 #ifdef WIN32_FORTRAN
4263 CGNSDLL void __stdcall cgp_array_write_data_f(cgint_f *A,
4264 cgsize_t *rmin, cgsize_t *rmax, void *data, ...)
4265 {
4266 va_list ap;
4267 int ierr;
4268 cgint_f *ier;
4269 cgns_array *array;
4270
4271 int have_dup = 0;
4272 array = cgi_array_address(CG_MODE_READ, 0, (int)*A, "dummy", &have_dup,
4273 &ierr);
4274 *ier = (cgint_f)ierr;
4275 if (array == NULL || (*ier) == (cgint_f)CG_ERROR ) return;
4276 va_start(ap, data);
4277 if (0 == strcmp(array->data_type, "C1"))
4278 (void) va_arg(ap, int);
4279 ier = va_arg(ap, cgsize_t *);
4280 va_end(ap);
4281 #else
4282 CGNSDLL void FMNAME(cgp_array_write_data_f, CGP_ARRAY_WRITE_DATA_F) (
4283 cgint_f *A, cgsize_t *rmin, cgsize_t *rmax, void *data,
4284 cgint_f *ier)
4285 {
4286 #endif
4287 *ier = (cgint_f)cgp_array_write_data((int)*A, rmin, rmax, data);
4288 }
4289
4290 /*-----------------------------------------------------------------------*/
4291
4292 #ifdef WIN32_FORTRAN
4293 CGNSDLL void __stdcall cgp_array_read_data_f(cgint_f *A,
4294 cgsize_t *rmin, cgsize_t *rmax, void *data, ...)
4295 {
4296 va_list ap;
4297 int ierr;
4298 cgint_f *ier;
4299 cgns_array *array;
4300
4301 int have_dup = 0;
4302 array = cgi_array_address(CG_MODE_READ, 0, (int)*A, "dummy", &have_dup,
4303 &ierr);
4304 if (array == NULL) return;
4305 va_start(ap, data);
4306 if (0 == strcmp(array->data_type, "C1"))
4307 (void) va_arg(ap, int);
4308 ier = va_arg(ap, cgsize_t *);
4309 va_end(ap);
4310 #else
4311 CGNSDLL void FMNAME(cgp_array_read_data_f, CGP_ARRAY_READ_DATA_F) (
4312 cgint_f *A, cgsize_t *rmin, cgsize_t *rmax, void *data,
4313 cgint_f *ier)
4314 {
4315 #endif
4316 *ier = (cgint_f)cgp_array_read_data((int)*A, rmin, rmax, data);
4317 }
4318
4319 /*-----------------------------------------------------------------------*/
4320
4321 CGNSDLL void cgp_error_exit_f()
4322 {
4323 cgp_error_exit();
4324 }
4325
4326 #if HDF5_HAVE_MULTI_DATASETS
4327
4328 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
4329 * cgp_coord_multi_read_data Function *
4330 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
4331
4332 #ifdef WIN32_FORTRAN
4333 CGNSDLL void __stdcall cgp_coord_multi_read_data_f(cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *C,
4334 cgsize_t *rmin, cgsize_t *rmax,
4335 void *coordsX, void *coordsY, void *coordsZ, cgint_f *ier)
4336 #else
4337 CGNSDLL void cgp_coord_multi_read_data_f(cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *C,
4338 cgsize_t *rmin, cgsize_t *rmax,
4339 void *coordsX, void *coordsY, void *coordsZ, cgint_f *ier)
4340 #endif
4341 {
4342 *ier = (cgint_f)cgp_coord_multi_read_data((int)*fn, (int)*B, (int)*Z, (int*)C, rmin, rmax, coordsX, coordsY, coordsZ);
4343
4344 }
4345
4346 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
4347 * cgp_coord_multi_write_data Function *
4348 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
4349
4350 #ifdef WIN32_FORTRAN
4351 CGNSDLL void __stdcall cgp_coord_multi_write_data_f(cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *C,
4352 cgsize_t *rmin, cgsize_t *rmax,
4353 void *coordsX, void *coordsY, void *coordsZ, cgint_f *ier)
4354 #else
4355 CGNSDLL void cgp_coord_multi_write_data_f(cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *C,
4356 cgsize_t *rmin, cgsize_t *rmax,
4357 void *coordsX, void *coordsY, void *coordsZ, cgint_f *ier)
4358 #endif
4359 {
4360 *ier = (cgint_f)cgp_coord_multi_write_data((int)*fn, (int)*B, (int)*Z, (int*)C, rmin, rmax, coordsX, coordsY, coordsZ);
4361 }
4362
4363 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
4364 * cgp_field_multi_write_data Function *
4365 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
4366
4367 CGNSDLL void FMNAME(cgp_field_multi_write_data_f, CGP_FIELD_MULTI_WRITE_DATA_F) (
4368 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S,
4369 cgint_f *F, cgsize_t *rmin, cgsize_t *rmax, cgint_f *ier, cgsize_t *nsets, ...)
4370 {
4371 va_list ap; /* argument list passed from the API call */
4372 int *F_c;
4373 int n;
4374
4375 va_start(ap, nsets);
4376
4377 if(sizeof(cgsize_t)!=sizeof(int)) {
4378 /* type cast F from cgsize_t to an int */
4379 if ((F_c = (int *)malloc(*nsets*sizeof(int)))==NULL) {
4380 cgi_error("Error allocating memory...");
4381 *ier = 1;
4382 return;
4383 }
4384 for (n = 0; n < *nsets; n++) {
4385 F_c[n] = (int)F[n];
4386 }
4387 *ier = vcgp_field_multi_write_data((int)*fn, (int)*B, (int)*Z, (int)*S,
4388 F_c, rmin, rmax, (int)*nsets, ap);
4389 CGNS_FREE(F_c);
4390 } else {
4391 *ier = vcgp_field_multi_write_data((int)*fn, (int)*B, (int)*Z, (int)*S,
4392 F, rmin, rmax, (int)*nsets, ap);
4393 }
4394
4395
4396 }
4397
4398 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
4399 * cgp_field_multi_read_data Function *
4400 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
4401
4402 CGNSDLL void FMNAME(cgp_field_multi_read_data_f, CGP_FIELD_MULTI_READ_DATA_F) (
4403 cgint_f *fn, cgint_f *B, cgint_f *Z, cgint_f *S,
4404 cgint_f *F, cgsize_t *rmin, cgsize_t *rmax, cgint_f *ier, cgint_f *nsets, ...)
4405 {
4406 va_list ap; /* argument list passed from the API call */
4407 int *F_c;
4408 int n;
4409
4410 va_start(ap, nsets);
4411
4412 if(sizeof(cgsize_t)!=sizeof(int)) {
4413 /* type cast F from cgsize_t to an int */
4414 if ((F_c = (int *)malloc(*nsets*sizeof(int)))==NULL) {
4415 cgi_error("Error allocating memory...");
4416 *ier = 1;
4417 return;
4418 }
4419 for (n = 0; n < *nsets; n++) {
4420 F_c[n] = (int)F[n];
4421 }
4422 *ier = (cgint_f)vcgp_field_multi_read_data((int)*fn, (int)*B, (int)*Z, (int)*S,
4423 F_c, rmin, rmax, (int)*nsets, ap);
4424 } else {
4425 *ier = (cgint_f)vcgp_field_multi_read_data((int)*fn, (int)*B, (int)*Z, (int)*S,
4426 F, rmin, rmax, (int)*nsets, ap);
4427 }
4428
4429 }
4430
4431 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
4432 * cgp_array_multi_write_data Function *
4433 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
4434
4435 CGNSDLL void FMNAME(cgp_array_multi_write_data_f, CGP_ARRAY_MULTI_WRITE_DATA_F) (
4436 cgint_f *fn, cgint_f *A, cgsize_t *rmin, cgsize_t *rmax,
4437 cgint_f *ier, cgint_f *nsets, ...)
4438 {
4439
4440 va_list ap; /* argument list passed from the API call */
4441 int *A_c;
4442 int n;
4443
4444 va_start(ap, nsets);
4445
4446 if(sizeof(cgsize_t)!=sizeof(int)) {
4447 /* type cast F from cgsize_t to an int */
4448 if ((A_c = (int *)malloc(*nsets*sizeof(int)))==NULL) {
4449 cgi_error("Error allocating memory...");
4450 *ier = 1;
4451 return;
4452 }
4453 for (n = 0; n < *nsets; n++) {
4454 A_c[n] = (int)A[n];
4455 }
4456 *ier = (cgint_f)vcgp_array_multi_write_data((int)*fn, A_c, rmin, rmax, (int)*nsets, ap);
4457 }else {
4458 *ier = (cgint_f)vcgp_array_multi_write_data((int)*fn, A, rmin, rmax, (int)*nsets, ap);
4459 }
4460 }
4461
4462 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *\
4463 * cgp_array_multi_read_data Function *
4464 \* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
4465
4466 CGNSDLL void FMNAME(cgp_array_multi_read_data_f, CGP_ARRAY_MULTI_READ_DATA_F) (
4467 cgint_f *fn, cgint_f *A, cgsize_t *rmin, cgsize_t *rmax,
4468 cgint_f *ier, cgint_f *nsets, ...)
4469 {
4470
4471 va_list ap; /* argument list passed from the API call */
4472 int *A_c;
4473 int n;
4474
4475
4476 va_start(ap, nsets);
4477 if(sizeof(cgsize_t)!=sizeof(int)) {
4478 /* type cast F from cgsize_t to an int */
4479 if ((A_c = (int *)malloc(*nsets*sizeof(int)))==NULL) {
4480 cgi_error("Error allocating memory...");
4481 *ier = 1;
4482 return;
4483 }
4484 for (n = 0; n < *nsets; n++) {
4485 A_c[n] = (int)A[n];
4486 }
4487 *ier = (cgint_f)vcgp_array_multi_read_data((int)*fn, A_c, rmin, rmax, (int)*nsets, ap);
4488 }else {
4489 *ier = (cgint_f)vcgp_array_multi_read_data((int)*fn, A, rmin, rmax, (int)*nsets, ap);
4490 }
4491
4492 }
4493 #endif /*HDF5_HAVE_MULTI_DATASETS*/
4494 #endif /*CG_BUILD_PARALLEL*/
4495
4496