mirror/netcdf-c
2
0
Fork 0
mirror of https://github.com/Unidata/netcdf-c.git synced 2024-11-21 03:13:42 +08:00
Code Issues Packages Projects Releases Wiki Activity
f6447ee94c
netcdf-c/libsrc4/tst_xplatform2.c
Ed Hartnett 18f4bca367 moving to trunk subdir
2010-06-03 13:24:43 +00:00

562 lines
20 KiB
C
Raw Blame History

/* This is part of the netCDF package. Copyright 2005 University
Corporation for Atmospheric Research/Unidata See COPYRIGHT file for
conditions of use. See www.unidata.ucar.edu for more info.
Test netcdf-4 cross platform compound type.
$Id: tst_xplatform2.c,v 1.18 2009/10/26 18:44:59 russ Exp $
*/
#include <nc_tests.h>
#include "netcdf.h"
#define FILE_NAME_1 "tst_xplatform2_1.nc"
#define REF_FILE_NAME_1 "ref_tst_xplatform2_1.nc"
#define FILE_NAME_2 "tst_xplatform2_2.nc"
#define REF_FILE_NAME_2 "ref_tst_xplatform2_2.nc"
#define FILE_NAME_3 "tst_xplatform2_3.nc"
#define REF_FILE_NAME_3 "ref_tst_xplatform2_3.nc"
#define FILE_NAME_4 "tst_xplatform2_4.nc"
#define REF_FILE_NAME_4 "ref_tst_xplatform2_4.nc"
#define S1_TYPE_NAME "cmp_t"
#define X_NAME "x"
#define Y_NAME "y"
#define S1_NAME "s1"
#define S2_ATT_NAME "Runnymede"
#define S2_TYPE_NAME "date_1215"
#define DIM1_LEN 5
#define DIM2_LEN 3
#define VLEN_NAME "Magna_Carta_VLEN"
#define VLEN_ATT_NAME "We_will_sell_to_no_man_we_will_not_deny_or_defer_to_any_man_either_Justice_or_Right"
#define TWO_TYPES 2
#define NUM_S1 4
#define DIM3_LEN 1
#define DIM3_NAME "DIMENSION->The city of London shall enjoy all its ancient liberties and free customs, both by land and by water."
#define VAR3_NAME "VARIABLE->In future we will allow no one to levy an `aid' from his free men, except to ransom his person, to make his eldest son a knight, and (once) to marry his eldest daughter."
#define NUM_VL 1
#define S3_ATT_NAME "King_John"
#define S3_TYPE_NAME "barons"
#define VL_NAME "No scutage or aid may be levied in our kingdom without its general consent"
#define THREE_TYPES 3
struct s1
{
float x;
double y;
};
struct s2
{
struct s1 data[NUM_S1];
};
struct s3
{
nc_vlen_t data[NUM_VL];
};
int
check_file_1(int ncid, nc_vlen_t *data_out)
{
int ntypes_in, ndims_in;
char name_in[NC_MAX_NAME + 1];
size_t size_in, nfields_in, offset_in;
nc_type field_type_in;
nc_type typeids_in[TWO_TYPES], base_nc_type_in;
nc_vlen_t data_in[DIM1_LEN];
int i, j;
/* There should be two types. */
if (nc_inq_typeids(ncid, &ntypes_in, typeids_in)) ERR;
if (ntypes_in != 2) ERR;
/* The compound type is first: check it out. */
if (nc_inq_compound(ncid, typeids_in[0], name_in, &size_in, &nfields_in)) ERR;
if (nfields_in != 2 || strcmp(name_in, S1_TYPE_NAME) || size_in != sizeof(struct s1)) ERR;
if (nc_inq_compound_field(ncid, typeids_in[0], 0, name_in, &offset_in,
&field_type_in, &ndims_in, NULL)) ERR;
if (strcmp(name_in, X_NAME) || offset_in != 0 || field_type_in != NC_FLOAT ||
ndims_in) ERR;
if (nc_inq_compound_field(ncid, typeids_in[0], 1, name_in, &offset_in,
&field_type_in, &ndims_in, NULL)) ERR;
if (strcmp(name_in, Y_NAME) || offset_in != NC_COMPOUND_OFFSET(struct s1, y) || field_type_in != NC_DOUBLE ||
ndims_in) ERR;
/* How does the vlen type look? */
if (nc_inq_vlen(ncid, typeids_in[1], name_in, &size_in, &base_nc_type_in)) ERR;
if (strcmp(name_in, VLEN_NAME) || size_in != sizeof(nc_vlen_t) ||
base_nc_type_in != typeids_in[0]) ERR;
/* Now read the attribute. */
if (nc_get_att(ncid, NC_GLOBAL, VLEN_ATT_NAME, data_in)) ERR;
/* Did we get the correct data? */
for (i = 0; i < DIM1_LEN; i++)
{
if (data_in[i].len != data_out[i].len) ERR;
for (j = 0; j < data_in[i].len; j++)
if (((struct s1 *)data_in[i].p)->x != ((struct s1 *)data_out[i].p)->x ||
((struct s1 *)data_in[i].p)->y != ((struct s1 *)data_out[i].p)->y) ERR_RET;
}
/* Free the memory that was malloced when the VLEN was read. */
for (i = 0; i < DIM1_LEN; i++)
free(data_in[i].p);
/* We're done! */
return NC_NOERR;
}
int
check_file_2(int ncid, struct s2 *data_out)
{
int ntypes_in, ndims_in;
char name_in[NC_MAX_NAME + 1];
size_t size_in, nfields_in, offset_in;
nc_type field_type_in;
nc_type typeids_in[TWO_TYPES];
struct s2 data_in[DIM2_LEN];
int field_dims_in[1];
int i, j;
/* There should be two types. */
if (nc_inq_typeids(ncid, &ntypes_in, typeids_in)) ERR;
if (ntypes_in != TWO_TYPES) ERR;
/* The compound type is first: check it out. */
if (nc_inq_compound(ncid, typeids_in[0], name_in, &size_in, &nfields_in)) ERR;
if (nfields_in != 2 || strcmp(name_in, S1_TYPE_NAME) || size_in != sizeof(struct s1)) ERR;
if (nc_inq_compound_field(ncid, typeids_in[0], 0, name_in, &offset_in,
&field_type_in, &ndims_in, NULL)) ERR;
if (strcmp(name_in, X_NAME) || offset_in != 0 || field_type_in != NC_FLOAT ||
ndims_in) ERR;
if (nc_inq_compound_field(ncid, typeids_in[0], 1, name_in, &offset_in,
&field_type_in, &ndims_in, NULL)) ERR;
if (strcmp(name_in, Y_NAME) || offset_in != NC_COMPOUND_OFFSET(struct s1, y) || field_type_in != NC_DOUBLE ||
ndims_in) ERR;
/* How does the containing compound type look? */
if (nc_inq_compound(ncid, typeids_in[1], name_in, &size_in, &nfields_in)) ERR;
if (strcmp(name_in, S2_TYPE_NAME) || size_in != sizeof(struct s2) ||
nfields_in != 1) ERR;
if (nc_inq_compound_field(ncid, typeids_in[1], 0, name_in, &offset_in, &field_type_in,
&ndims_in, field_dims_in)) ERR;
if (strcmp(name_in, S1_NAME) || offset_in != NC_COMPOUND_OFFSET(struct s2, data) ||
field_type_in != typeids_in[0] || ndims_in != 1 || field_dims_in[0] != NUM_S1) ERR;
/* Now read the attribute. */
if (nc_get_att(ncid, NC_GLOBAL, S2_ATT_NAME, data_in)) ERR;
/* Did we get the correct data? */
for (i = 0; i < DIM2_LEN; i++)
for (j = 0; j < NUM_S1; j++)
if (data_out[i].data[j].x != data_in[i].data[j].x ||
data_out[i].data[j].y != data_in[i].data[j].y) ERR;
/* We're done! */
return NC_NOERR;
}
int
check_file_3(int ncid, struct s3 *data_out)
{
int ntypes_in, ndims_in;
char name_in[NC_MAX_NAME + 1];
size_t size_in, nfields_in, offset_in;
nc_type field_type_in, base_nc_type_in;
nc_type typeids_in[THREE_TYPES];
struct s3 data_in[DIM3_LEN];
int field_dims_in[1];
int i, j, k;
/* There should be three types. */
if (nc_inq_typeids(ncid, &ntypes_in, typeids_in)) ERR;
if (ntypes_in != THREE_TYPES) ERR;
/* The s1 compound type is first: check it out. */
if (nc_inq_compound(ncid, typeids_in[0], name_in, &size_in, &nfields_in)) ERR;
if (nfields_in != 2 || strcmp(name_in, S1_TYPE_NAME) || size_in != sizeof(struct s1)) ERR;
if (nc_inq_compound_field(ncid, typeids_in[0], 0, name_in, &offset_in,
&field_type_in, &ndims_in, NULL)) ERR;
if (strcmp(name_in, X_NAME) || offset_in != 0 || field_type_in != NC_FLOAT ||
ndims_in) ERR;
if (nc_inq_compound_field(ncid, typeids_in[0], 1, name_in, &offset_in,
&field_type_in, &ndims_in, NULL)) ERR;
if (strcmp(name_in, Y_NAME) || offset_in != NC_COMPOUND_OFFSET(struct s1, y) || field_type_in != NC_DOUBLE ||
ndims_in) ERR;
/* How does the vlen type look? */
if (nc_inq_vlen(ncid, typeids_in[1], name_in, &size_in, &base_nc_type_in)) ERR;
if (strcmp(name_in, VLEN_NAME) || size_in != sizeof(struct s1) ||
base_nc_type_in != typeids_in[0]) ERR;
/* How does the containing compound type look? */
if (nc_inq_compound(ncid, typeids_in[2], name_in, &size_in, &nfields_in)) ERR;
if (strcmp(name_in, S3_TYPE_NAME) || size_in != sizeof(struct s3) ||
nfields_in != 1) ERR;
if (nc_inq_compound_field(ncid, typeids_in[2], 0, name_in, &offset_in, &field_type_in,
&ndims_in, field_dims_in)) ERR;
if (strcmp(name_in, VL_NAME) || offset_in != NC_COMPOUND_OFFSET(struct s3, data) ||
field_type_in != typeids_in[1] || ndims_in != 1 || field_dims_in[0] != NUM_VL) ERR;
/* Now read the attribute. */
if (nc_get_att(ncid, NC_GLOBAL, S3_ATT_NAME, data_in)) ERR;
/* Did we get the correct data? */
for (i = 0; i < DIM3_LEN; i++)
for (j = 0; j < NUM_VL; j++)
{
if (data_in[i].data[j].len != data_in[i].data[j].len) ERR;
for (k = 0; k < data_out[i].data[j].len; k++)
if (((struct s1 *)data_in[i].data[j].p)[k].x != ((struct s1 *)data_out[i].data[j].p)[k].x ||
((struct s1 *)data_in[i].data[j].p)[k].y != ((struct s1 *)data_out[i].data[j].p)[k].y) ERR;
}
/* Free our vlens. */
/* for (i = 0; i < DIM3_LEN; i++) */
/* for (j = 0; j < NUM_VL; j++) */
/* nc_free_vlen(&(data_in[i].data[j])); */
/* We're done! */
return NC_NOERR;
}
int
check_file_4(int ncid, struct s3 *data_out)
{
int ntypes_in, ndims_in;
char name_in[NC_MAX_NAME + 1];
size_t size_in, nfields_in, offset_in;
nc_type field_type_in, base_nc_type_in;
nc_type typeids_in[THREE_TYPES];
struct s3 data_in[DIM3_LEN];
int field_dims_in[1];
int i, j, k;
/* There should be three types. */
if (nc_inq_typeids(ncid, &ntypes_in, typeids_in)) ERR;
if (ntypes_in != THREE_TYPES) ERR;
/* The s1 compound type is first: check it out. */
if (nc_inq_compound(ncid, typeids_in[0], name_in, &size_in, &nfields_in)) ERR;
if (nfields_in != 2 || strcmp(name_in, S1_TYPE_NAME) || size_in != sizeof(struct s1)) ERR;
if (nc_inq_compound_field(ncid, typeids_in[0], 0, name_in, &offset_in,
&field_type_in, &ndims_in, NULL)) ERR;
if (strcmp(name_in, X_NAME) || offset_in != 0 || field_type_in != NC_FLOAT ||
ndims_in) ERR;
if (nc_inq_compound_field(ncid, typeids_in[0], 1, name_in, &offset_in,
&field_type_in, &ndims_in, NULL)) ERR;
if (strcmp(name_in, Y_NAME) || offset_in != NC_COMPOUND_OFFSET(struct s1, y) || field_type_in != NC_DOUBLE ||
ndims_in) ERR;
/* How does the vlen type look? */
if (nc_inq_vlen(ncid, typeids_in[1], name_in, &size_in, &base_nc_type_in)) ERR;
if (strcmp(name_in, VLEN_NAME) || size_in != sizeof(struct s1) ||
base_nc_type_in != typeids_in[0]) ERR;
/* How does the containing compound type look? */
if (nc_inq_compound(ncid, typeids_in[2], name_in, &size_in, &nfields_in)) ERR;
if (strcmp(name_in, S3_TYPE_NAME) || size_in != sizeof(struct s3) ||
nfields_in != 1) ERR;
if (nc_inq_compound_field(ncid, typeids_in[2], 0, name_in, &offset_in, &field_type_in,
&ndims_in, field_dims_in)) ERR;
if (strcmp(name_in, VL_NAME) || offset_in != NC_COMPOUND_OFFSET(struct s3, data) ||
field_type_in != typeids_in[1] || ndims_in != 1 || field_dims_in[0] != NUM_VL) ERR;
/* Now read the variable. */
if (nc_get_var(ncid, 0, data_in)) ERR;
/* Did we get the correct data? */
for (i = 0; i < DIM3_LEN; i++)
for (j = 0; j < NUM_VL; j++)
{
if (data_in[i].data[j].len != data_in[i].data[j].len) ERR;
for (k = 0; k < data_out[i].data[j].len; k++)
if (((struct s1 *)data_in[i].data[j].p)[k].x != ((struct s1 *)data_out[i].data[j].p)[k].x ||
((struct s1 *)data_in[i].data[j].p)[k].y != ((struct s1 *)data_out[i].data[j].p)[k].y) ERR;
}
/* Free our vlens. */
/* for (i = 0; i < DIM3_LEN; i++) */
/* for (j = 0; j < NUM_VL; j++) */
/* nc_free_vlen(&(data_in[i].data[j])); */
/* We're done! */
return NC_NOERR;
}
int
main(int argc, char **argv)
{
int ncid;
int i, j, k;
nc_vlen_t vlen_of_comp_out[DIM1_LEN];
struct s2 comp_array_of_comp_out[DIM2_LEN];
struct s3 comp_array_of_vlen_of_comp_out[DIM3_LEN];
printf("\nTesting nested types across platforms.\n");
/* Create some output data: a vlen of struct s1. */
for (i = 0; i < DIM1_LEN; i++)
{
vlen_of_comp_out[i].len = i + 1;
if (!(vlen_of_comp_out[i].p = malloc(sizeof(struct s1) * vlen_of_comp_out[i].len)))
return NC_ENOMEM;
for (j = 0; j < vlen_of_comp_out[i].len; j++)
{
((struct s1 *)vlen_of_comp_out[i].p)[j].x = 42.42;
((struct s1 *)vlen_of_comp_out[i].p)[j].y = 2.0;
}
}
/* Create some output data: a struct which holds an array of
* struct s1. */
for (i = 0; i < DIM2_LEN; i++)
for (j = 0; j < NUM_S1; j++)
{
comp_array_of_comp_out[i].data[j].x = 42.42;
comp_array_of_comp_out[i].data[j].y = 2.0;
}
/* Create some output data: a struct which holds an array of
* vlen of struct s1. */
for (i = 0; i < DIM3_LEN; i++)
for (j = 0; j < NUM_VL; j++)
{
comp_array_of_vlen_of_comp_out[i].data[j].len = i + 1;
if (!(comp_array_of_vlen_of_comp_out[i].data[j].p = malloc(sizeof(struct s1) * comp_array_of_vlen_of_comp_out[i].data[j].len)))
return NC_ENOMEM;
for (k = 0; k < comp_array_of_vlen_of_comp_out[i].data[j].len; k++)
{
((struct s1 *)comp_array_of_vlen_of_comp_out[i].data[j].p)[k].x = 42.42;
((struct s1 *)comp_array_of_vlen_of_comp_out[i].data[j].p)[k].y = 2.0;
}
}
printf("*** testing of vlen of compound type...");
{
nc_type s1_typeid, vlen_typeid;
/* Create a netCDF-4 file. */
if (nc_create(FILE_NAME_1, NC_NETCDF4, &ncid)) ERR;
/* Create a simple compound type which has different sizes on
* different platforms - our old friend struct s1. */
if (nc_def_compound(ncid, sizeof(struct s1), S1_TYPE_NAME, &s1_typeid)) ERR;
if (nc_insert_compound(ncid, s1_typeid, X_NAME,
NC_COMPOUND_OFFSET(struct s1, x), NC_FLOAT)) ERR;
if (nc_insert_compound(ncid, s1_typeid, Y_NAME,
NC_COMPOUND_OFFSET(struct s1, y), NC_DOUBLE)) ERR;
/* Now make a new type: a vlen of our compound type. */
if (nc_def_vlen(ncid, VLEN_NAME, s1_typeid, &vlen_typeid)) ERR;
/* Write the output data as an attribute. */
if (nc_put_att(ncid, NC_GLOBAL, VLEN_ATT_NAME, vlen_typeid,
DIM1_LEN, vlen_of_comp_out)) ERR;
/* How does it look? */
if (check_file_1(ncid, vlen_of_comp_out)) ERR;
/* We're done - wasn't that easy? */
if (nc_close(ncid)) ERR;
/* Check it out. */
if (nc_open(FILE_NAME_1, NC_NOWRITE, &ncid)) ERR;
if (check_file_1(ncid, vlen_of_comp_out)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing Solaris-written vlen of compound type...");
{
char file_in[NC_MAX_NAME + 1];
strcpy(file_in, "");
if (getenv("srcdir"))
{
strcat(file_in, getenv("srcdir"));
strcat(file_in, "/");
}
strcat(file_in, REF_FILE_NAME_1);
/* Check out the same file, generated on buddy and included with
* the distribution. */
if (nc_open(file_in, NC_NOWRITE, &ncid)) ERR;
if (check_file_1(ncid, vlen_of_comp_out)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing compound type containing array of compound type...");
{
nc_type s1_typeid, s2_typeid;
int dimsizes[1] = {NUM_S1};
/* Create a netCDF-4 file. */
if (nc_create(FILE_NAME_2, NC_NETCDF4, &ncid)) ERR;
/* Create a simple compound type which has different sizes on
* different platforms - our old friend struct s1. */
if (nc_def_compound(ncid, sizeof(struct s1), S1_TYPE_NAME, &s1_typeid)) ERR;
if (nc_insert_compound(ncid, s1_typeid, X_NAME,
NC_COMPOUND_OFFSET(struct s1, x), NC_FLOAT)) ERR;
if (nc_insert_compound(ncid, s1_typeid, Y_NAME,
NC_COMPOUND_OFFSET(struct s1, y), NC_DOUBLE)) ERR;
/* Now make a compound type that holds an array of the struct s1
* type. */
if (nc_def_compound(ncid, sizeof(struct s2), S2_TYPE_NAME, &s2_typeid)) ERR;
if (nc_insert_array_compound(ncid, s2_typeid, S1_NAME,
NC_COMPOUND_OFFSET(struct s2, data),
s1_typeid, 1, dimsizes)) ERR;
/* Write the output data as an attribute. */
if (nc_put_att(ncid, NC_GLOBAL, S2_ATT_NAME, s2_typeid,
DIM2_LEN, comp_array_of_comp_out)) ERR;
/* How does it look? */
if (check_file_2(ncid, comp_array_of_comp_out)) ERR;
/* We're done - wasn't that easy? */
if (nc_close(ncid)) ERR;
/* Check it out. */
if (nc_open(FILE_NAME_2, NC_NOWRITE, &ncid)) ERR;
if (check_file_2(ncid, comp_array_of_comp_out)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing Solaris-written compound type containing array of compound type...");
{
char file_in[NC_MAX_NAME + 1];
strcpy(file_in, "");
if (getenv("srcdir"))
{
strcat(file_in, getenv("srcdir"));
strcat(file_in, "/");
}
strcat(file_in, REF_FILE_NAME_2);
/* Check out the same file, generated on buddy and included with
* the distribution. */
if (nc_open(file_in, NC_NOWRITE, &ncid)) ERR;
if (check_file_2(ncid, comp_array_of_comp_out)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#ifdef EXTRA_TESTS
printf("*** testing compound attribute containing array of vlen of compound type...");
{
nc_type vlen_typeid, s3_typeid, s1_typeid;
int dimsizes[1] = {NUM_VL};
/* Create a netCDF-4 file. */
if (nc_create(FILE_NAME_3, NC_NETCDF4, &ncid)) ERR;
/* Create a simple compound type which has different sizes on
* different platforms - our old friend struct s1. */
if (nc_def_compound(ncid, sizeof(struct s1), S1_TYPE_NAME, &s1_typeid)) ERR;
if (nc_insert_compound(ncid, s1_typeid, X_NAME,
NC_COMPOUND_OFFSET(struct s1, x), NC_FLOAT)) ERR;
if (nc_insert_compound(ncid, s1_typeid, Y_NAME,
NC_COMPOUND_OFFSET(struct s1, y), NC_DOUBLE)) ERR;
/* Now make a new type: a vlen of our s1 compound type. */
if (nc_def_vlen(ncid, VLEN_NAME, s1_typeid, &vlen_typeid)) ERR;
/* Now make a compound type that holds an array of the VLEN
* type. */
if (nc_def_compound(ncid, sizeof(struct s3), S3_TYPE_NAME, &s3_typeid)) ERR;
if (nc_insert_array_compound(ncid, s3_typeid, VL_NAME,
NC_COMPOUND_OFFSET(struct s3, data),
vlen_typeid, 1, dimsizes)) ERR;
/* Write the output data as an attribute. */
if (nc_put_att(ncid, NC_GLOBAL, S3_ATT_NAME, s3_typeid,
DIM3_LEN, comp_array_of_vlen_of_comp_out)) ERR;
/* How does it look? */
if (check_file_3(ncid, comp_array_of_vlen_of_comp_out)) ERR;
/* We're done - wasn't that easy? */
if (nc_close(ncid)) ERR;
/* Check it out. */
if (nc_open(FILE_NAME_3, NC_NOWRITE, &ncid)) ERR;
if (check_file_3(ncid, comp_array_of_vlen_of_comp_out)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
/* printf("*** testing Solaris-written compound containing array of vlen of compound type..."); */
/* { */
/* /\* Check out the same file, generated on buddy and included with */
/* * the distribution. *\/ */
/* if (nc_open(REF_FILE_NAME_3, NC_NOWRITE, &ncid)) ERR; */
/* if (check_file_3(ncid, comp_array_of_vlen_of_comp_out)) ERR; */
/* if (nc_close(ncid)) ERR; */
/* } */
/* SUMMARIZE_ERR; */
printf("*** testing compound variable containing array of vlen of compound type...");
{
nc_type vlen_typeid, s3_typeid, s1_typeid;
int varid, dimid;
int dimsizes[1] = {NUM_VL};
/* Create a netCDF-4 file. */
if (nc_create(FILE_NAME_4, NC_NETCDF4, &ncid)) ERR;
/* Create a simple compound type which has different sizes on
* different platforms - our old friend struct s1. */
if (nc_def_compound(ncid, sizeof(struct s1), S1_TYPE_NAME, &s1_typeid)) ERR;
if (nc_insert_compound(ncid, s1_typeid, X_NAME,
NC_COMPOUND_OFFSET(struct s1, x), NC_FLOAT)) ERR;
if (nc_insert_compound(ncid, s1_typeid, Y_NAME,
NC_COMPOUND_OFFSET(struct s1, y), NC_DOUBLE)) ERR;
/* Now make a new type: a vlen of our s1 compound type. */
if (nc_def_vlen(ncid, VLEN_NAME, s1_typeid, &vlen_typeid)) ERR;
/* Now make a compound type that holds an array of the VLEN
* type. */
if (nc_def_compound(ncid, sizeof(struct s3), S3_TYPE_NAME, &s3_typeid)) ERR;
if (nc_insert_array_compound(ncid, s3_typeid, VL_NAME,
NC_COMPOUND_OFFSET(struct s3, data),
vlen_typeid, 1, dimsizes)) ERR;
/* Create a dimension and a var of s3 type, then write the
* data. */
if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimid)) ERR;
if (nc_def_var(ncid, VAR3_NAME, s3_typeid, 1, &dimid, &varid)) ERR;
if (nc_put_var(ncid, varid, comp_array_of_vlen_of_comp_out)) ERR;
/* How does it look? */
if (check_file_4(ncid, comp_array_of_vlen_of_comp_out)) ERR;
/* We're done - wasn't that easy? */
if (nc_close(ncid)) ERR;
/* Check it out. */
if (nc_open(FILE_NAME_4, NC_NOWRITE, &ncid)) ERR;
if (check_file_4(ncid, comp_array_of_vlen_of_comp_out)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#endif
/* Free our mallocs. */
for (i = 0; i < DIM1_LEN; i++)
free(vlen_of_comp_out[i].p);
for (i = 0; i < DIM3_LEN; i++)
for (j = 0; j < NUM_VL; j++)
free(comp_array_of_vlen_of_comp_out[i].data[j].p);
FINAL_RESULTS;
}
Reference in New Issue View Git Blame Copy Permalink