19 #include "nc4internal.h"
21 #include "ncdispatch.h"
23 #include "H5DSpublic.h"
36 h5catch(
void* ignored)
53 int nc_log_level = NC_TURN_OFF_LOGGING;
67 set_auto(
void* func,
void *client_data)
70 return H5Eset_auto2(H5E_DEFAULT,(H5E_auto2_t)h5catch,client_data);
72 return H5Eset_auto2(H5E_DEFAULT,(H5E_auto2_t)func,client_data);
81 nc4_hdf5_initialize(
void)
83 if (set_auto(NULL, NULL) < 0)
84 LOG((0,
"Couldn't turn off HDF5 error messages!"));
85 LOG((1,
"HDF5 error messages have been turned off."));
101 nc4_check_name(
const char *name,
char *norm_name)
123 if ((retval = NC_check_name(name)))
127 retval = nc_utf8_normalize((
const unsigned char *)name,(
unsigned char**)&temp);
136 strcpy(norm_name, temp);
155 find_var_dim_max_length(NC_GRP_INFO_T *grp,
int varid,
int dimid,
size_t *maxlen)
157 hid_t datasetid = 0, spaceid = 0;
159 hsize_t *h5dimlen = NULL, *h5dimlenmax = NULL;
160 int d, dataset_ndims = 0;
166 if (varid < 0 || varid >= grp->vars.nelems)
168 var = grp->vars.value[varid];
170 assert(var->varid == varid);
180 if ((retval = nc4_open_var_grp2(grp, var->varid, &datasetid)))
182 if ((spaceid = H5Dget_space(datasetid)) < 0)
186 if (H5Sget_simple_extent_type(spaceid) == H5S_SCALAR)
188 *maxlen = (var->dimids && var->dimids[0] == dimid) ? 1 : 0;
194 if ((dataset_ndims = H5Sget_simple_extent_ndims(spaceid)) < 0)
196 if (dataset_ndims != var->ndims)
198 if (!(h5dimlen = malloc(dataset_ndims *
sizeof(hsize_t))))
200 if (!(h5dimlenmax = malloc(dataset_ndims *
sizeof(hsize_t))))
202 if ((dataset_ndims = H5Sget_simple_extent_dims(spaceid,
203 h5dimlen, h5dimlenmax)) < 0)
205 LOG((5,
"find_var_dim_max_length: varid %d len %d max: %d",
206 varid, (
int)h5dimlen[0], (
int)h5dimlenmax[0]));
207 for (d=0; d<dataset_ndims; d++) {
208 if (var->dimids[d] == dimid) {
209 *maxlen = *maxlen > h5dimlen[d] ? *maxlen : h5dimlen[d];
216 if (spaceid > 0 && H5Sclose(spaceid) < 0)
218 if (h5dimlen) free(h5dimlen);
219 if (h5dimlenmax) free(h5dimlenmax);
235 nc4_nc4f_list_add(NC *nc,
const char *path,
int mode)
237 NC_HDF5_FILE_INFO_T *h5;
239 assert(nc && !NC4_DATA(nc) && path);
243 if (!(h5 = calloc(1,
sizeof(NC_HDF5_FILE_INFO_T))))
249 h5->cmode = mode | NC_INDEF;
253 h5->next_typeid = NC_FIRSTUSERTYPEID;
258 return nc4_grp_list_add(&(h5->root_grp), h5->next_nc_grpid++,
259 NULL, nc, NC_GROUP_NAME, NULL);
276 nc4_find_nc4_grp(
int ncid, NC_GRP_INFO_T **grp)
278 NC_HDF5_FILE_INFO_T* h5;
279 NC *f = nc4_find_nc_file(ncid,&h5);
284 assert(h5->root_grp);
291 if (!(*grp = nc4_rec_find_grp(h5->root_grp, (ncid & GRP_ID_MASK))))
310 nc4_find_grp_h5(
int ncid, NC_GRP_INFO_T **grpp, NC_HDF5_FILE_INFO_T **h5p)
312 NC_HDF5_FILE_INFO_T *h5;
314 NC *f = nc4_find_nc_file(ncid,&h5);
317 assert(h5->root_grp);
319 if (!(grp = nc4_rec_find_grp(h5->root_grp, (ncid & GRP_ID_MASK))))
321 h5 = (grp)->nc4_info;
328 if(grpp) *grpp = grp;
345 nc4_find_nc_grp_h5(
int ncid, NC **nc, NC_GRP_INFO_T **grpp,
346 NC_HDF5_FILE_INFO_T **h5p)
349 NC_HDF5_FILE_INFO_T* h5;
350 NC *f = nc4_find_nc_file(ncid,&h5);
356 assert(h5->root_grp);
358 if (!(grp = nc4_rec_find_grp(h5->root_grp, (ncid & GRP_ID_MASK))))
361 h5 = (grp)->nc4_info;
368 if(grpp) *grpp = grp;
382 nc4_rec_find_grp(NC_GRP_INFO_T *start_grp,
int target_nc_grpid)
384 NC_GRP_INFO_T *g, *res;
389 if (start_grp->nc_grpid == target_nc_grpid)
393 if (start_grp->children)
394 for (g = start_grp->children; g; g = g->l.next)
395 if ((res = nc4_rec_find_grp(g, target_nc_grpid)))
415 nc4_find_g_var_nc(NC *nc,
int ncid,
int varid,
416 NC_GRP_INFO_T **grp, NC_VAR_INFO_T **var)
418 NC_HDF5_FILE_INFO_T* h5 = NC4_DATA(nc);
421 assert(grp && var && h5 && h5->root_grp);
422 *grp = nc4_rec_find_grp(h5->root_grp, (ncid & GRP_ID_MASK));
430 if (varid < 0 || varid >= (*grp)->vars.nelems)
432 (*var) = (*grp)->vars.value[varid];
450 nc4_find_dim(NC_GRP_INFO_T *grp,
int dimid, NC_DIM_INFO_T **dim,
451 NC_GRP_INFO_T **dim_grp)
453 NC_GRP_INFO_T *g, *dg = NULL;
459 for (g = grp; g && !finished; g = g->parent)
460 for ((*dim) = g->dim; (*dim); (*dim) = (*dim)->l.next)
461 if ((*dim)->dimid == dimid)
490 nc4_find_var(NC_GRP_INFO_T *grp,
const char *name, NC_VAR_INFO_T **var)
493 assert(grp && var && name);
497 for (i=0; i < grp->vars.nelems; i++)
499 if (0 == strcmp(name, grp->vars.value[i]->name))
501 *var = grp->vars.value[i];
518 nc4_rec_find_hdf_type(NC_GRP_INFO_T *start_grp, hid_t target_hdf_typeid)
521 NC_TYPE_INFO_T *type, *res;
527 for (type = start_grp->type; type; type = type->l.next)
529 if ((equal = H5Tequal(type->native_hdf_typeid ? type->native_hdf_typeid : type->hdf_typeid, target_hdf_typeid)) < 0)
536 if (start_grp->children)
537 for (g = start_grp->children; g; g = g->l.next)
538 if ((res = nc4_rec_find_hdf_type(g, target_hdf_typeid)))
555 nc4_rec_find_named_type(NC_GRP_INFO_T *start_grp,
char *name)
558 NC_TYPE_INFO_T *type, *res;
563 for (type = start_grp->type; type; type = type->l.next)
564 if (!strcmp(type->name, name))
568 if (start_grp->children)
569 for (g = start_grp->children; g; g = g->l.next)
570 if ((res = nc4_rec_find_named_type(g, name)))
587 nc4_rec_find_nc_type(
const NC_GRP_INFO_T *start_grp,
nc_type target_nc_typeid)
589 NC_TYPE_INFO_T *type;
594 for (type = start_grp->type; type; type = type->l.next)
595 if (type->nc_typeid == target_nc_typeid)
599 if (start_grp->children)
603 for (g = start_grp->children; g; g = g->l.next)
607 if ((res = nc4_rec_find_nc_type(g, target_nc_typeid)))
628 nc4_find_type(
const NC_HDF5_FILE_INFO_T *h5,
nc_type typeid, NC_TYPE_INFO_T **type)
630 if (
typeid < 0 || !type)
640 if(!(*type = nc4_rec_find_nc_type(h5->root_grp,
typeid)))
659 nc4_find_dim_len(NC_GRP_INFO_T *grp,
int dimid,
size_t **len)
667 LOG((3,
"nc4_find_dim_len: grp->name %s dimid %d", grp->name, dimid));
671 for (g = grp->children; g; g = g->l.next)
672 if ((retval = nc4_find_dim_len(g, dimid, len)))
677 for (i=0; i < grp->vars.nelems; i++)
680 var = grp->vars.value[i];
684 if ((retval = find_var_dim_max_length(grp, var->varid, dimid, &mylen)))
687 **len = **len > mylen ? **len : mylen;
708 nc4_find_grp_att(NC_GRP_INFO_T *grp,
int varid,
const char *name,
int attnum,
712 NC_ATT_INFO_T *attlist = NULL;
714 assert(grp && grp->name);
715 LOG((4,
"nc4_find_grp_att: grp->name %s varid %d name %s attnum %d",
716 grp->name, varid, name, attnum));
723 if (varid < 0 || varid >= grp->vars.nelems)
725 var = grp->vars.value[varid];
728 assert(var->varid == varid);
734 for (*att = attlist; *att; *att = (*att)->l.next) {
735 if (name && (*att)->name && !strcmp((*att)->name, name))
737 if (!name && (*att)->attnum == attnum)
761 nc4_find_nc_att(
int ncid,
int varid,
const char *name,
int attnum,
765 NC_HDF5_FILE_INFO_T *h5;
767 NC_ATT_INFO_T *attlist = NULL;
770 LOG((4,
"nc4_find_nc_att: ncid 0x%x varid %d name %s attnum %d",
771 ncid, varid, name, attnum));
774 if ((retval = nc4_find_grp_h5(ncid, &grp, &h5)))
783 if (varid < 0 || varid >= grp->vars.nelems)
785 var = grp->vars.value[varid];
788 assert(var->varid == varid);
792 for (*att = attlist; *att; *att = (*att)->l.next)
793 if ((name && !strcmp((*att)->name, name)) ||
794 (!name && (*att)->attnum == attnum))
812 nc4_find_nc_file(
int ext_ncid, NC_HDF5_FILE_INFO_T** h5p)
817 stat = NC_check_id(ext_ncid,&nc);
822 if(h5p) *h5p = (NC_HDF5_FILE_INFO_T*)nc->dispatchdata;
837 obj_list_add(NC_LIST_NODE_T **list, NC_LIST_NODE_T *obj)
845 for (o = *list; o; o = o->next)
865 obj_list_del(NC_LIST_NODE_T **list, NC_LIST_NODE_T *obj)
871 ((NC_LIST_NODE_T *)obj->prev)->next = obj->next;
874 ((NC_LIST_NODE_T *)obj->next)->prev = obj->prev;
887 nc4_var_add(NC_VAR_INFO_T **var)
889 NC_VAR_INFO_T *new_var;
892 if (!(new_var = calloc(1,
sizeof(NC_VAR_INFO_T))))
919 nc4_dim_list_add(NC_DIM_INFO_T **list, NC_DIM_INFO_T **dim)
921 NC_DIM_INFO_T *new_dim;
923 if (!(new_dim = calloc(1,
sizeof(NC_DIM_INFO_T))))
927 obj_list_add((NC_LIST_NODE_T **)list, (NC_LIST_NODE_T *)new_dim);
946 nc4_att_list_add(NC_ATT_INFO_T **list, NC_ATT_INFO_T **att)
948 NC_ATT_INFO_T *new_att;
950 if (!(new_att = calloc(1,
sizeof(NC_ATT_INFO_T))))
954 obj_list_add((NC_LIST_NODE_T **)list, (NC_LIST_NODE_T *)new_att);
978 nc4_grp_list_add(NC_GRP_INFO_T **list,
int new_nc_grpid,
979 NC_GRP_INFO_T *parent_grp, NC *nc,
980 char *name, NC_GRP_INFO_T **grp)
982 NC_GRP_INFO_T *new_grp;
984 LOG((3,
"%s: new_nc_grpid %d name %s ", __func__, new_nc_grpid, name));
987 if (!(new_grp = calloc(1,
sizeof(NC_GRP_INFO_T))))
991 new_grp->nc_grpid = new_nc_grpid;
992 new_grp->parent = parent_grp;
993 if (!(new_grp->name = strdup(name)))
998 new_grp->nc4_info = NC4_DATA(nc);
1001 obj_list_add((NC_LIST_NODE_T **)list, (NC_LIST_NODE_T *)new_grp);
1024 nc4_check_dup_name(NC_GRP_INFO_T *grp,
char *name)
1026 NC_TYPE_INFO_T *type;
1033 for (type = grp->type; type; type = type->l.next)
1034 if (!strcmp(type->name, name))
1038 for (g = grp->children; g; g = g->l.next)
1039 if (!strcmp(g->name, name))
1043 hash = hash_fast(name, strlen(name));
1044 for (i=0; i < grp->vars.nelems; i++)
1046 var = grp->vars.value[i];
1048 if (var->hash == hash && !strcmp(var->name, name))
1068 nc4_type_list_add(NC_GRP_INFO_T *grp,
size_t size,
const char *name,
1069 NC_TYPE_INFO_T **type)
1071 NC_TYPE_INFO_T *new_type;
1074 if (!(new_type = calloc(1,
sizeof(NC_TYPE_INFO_T))))
1078 obj_list_add((NC_LIST_NODE_T **)(&grp->type), (NC_LIST_NODE_T *)new_type);
1081 new_type->nc_typeid = grp->nc4_info->next_typeid++;
1082 new_type->size = size;
1083 if (!(new_type->name = strdup(name)))
1113 nc4_field_list_add(NC_FIELD_INFO_T **list,
int fieldid,
const char *name,
1114 size_t offset, hid_t field_hdf_typeid, hid_t native_typeid,
1115 nc_type xtype,
int ndims,
const int *dim_sizesp)
1117 NC_FIELD_INFO_T *field;
1124 if (!(field = calloc(1,
sizeof(NC_FIELD_INFO_T))))
1128 field->fieldid = fieldid;
1129 if (!(field->name = strdup(name)))
1134 field->hdf_typeid = field_hdf_typeid;
1135 field->native_hdf_typeid = native_typeid;
1136 field->nc_typeid = xtype;
1137 field->offset = offset;
1138 field->ndims = ndims;
1143 if (!(field->dim_size = malloc(ndims *
sizeof(
int))))
1149 for (i = 0; i < ndims; i++)
1150 field->dim_size[i] = dim_sizesp[i];
1154 obj_list_add((NC_LIST_NODE_T **)list, (NC_LIST_NODE_T *)field);
1172 nc4_enum_member_add(NC_ENUM_MEMBER_INFO_T **list,
size_t size,
1173 const char *name,
const void *value)
1175 NC_ENUM_MEMBER_INFO_T *member;
1178 assert(name && size > 0 && value);
1179 LOG((4,
"%s: size %d name %s", __func__, size, name));
1182 if (!(member = calloc(1,
sizeof(NC_ENUM_MEMBER_INFO_T))))
1184 if (!(member->value = malloc(size))) {
1188 if (!(member->name = strdup(name))) {
1189 free(member->value);
1195 memcpy(member->value, value, size);
1198 obj_list_add((NC_LIST_NODE_T **)list, (NC_LIST_NODE_T *)member);
1213 field_list_del(NC_FIELD_INFO_T **list, NC_FIELD_INFO_T *field)
1216 obj_list_del((NC_LIST_NODE_T **)list, (NC_LIST_NODE_T *)field);
1221 if (field->dim_size)
1222 free(field->dim_size);
1237 nc4_type_free(NC_TYPE_INFO_T *type)
1247 if (type->hdf_typeid && H5Tclose(type->hdf_typeid) < 0)
1249 if (type->native_hdf_typeid && H5Tclose(type->native_hdf_typeid) < 0)
1257 switch (type->nc_type_class)
1261 NC_FIELD_INFO_T *field;
1265 field = type->u.c.field;
1268 NC_FIELD_INFO_T *f = field->l.next;
1270 field_list_del(&type->u.c.field, field);
1278 NC_ENUM_MEMBER_INFO_T *enum_member;
1281 enum_member = type->u.e.enum_member;
1284 NC_ENUM_MEMBER_INFO_T *em = enum_member->l.next;
1286 free(enum_member->value);
1287 free(enum_member->name);
1292 if (H5Tclose(type->u.e.base_hdf_typeid) < 0)
1298 if (H5Tclose(type->u.v.base_hdf_typeid) < 0)
1321 nc4_var_del(NC_VAR_INFO_T *var)
1323 NC_ATT_INFO_T *a, *att;
1334 if ((ret = nc4_att_list_del(&var->att, att)))
1340 if (var->chunksizes)
1341 {free(var->chunksizes);var->chunksizes = NULL;}
1344 {free(var->hdf5_name); var->hdf5_name = NULL;}
1347 {free(var->name); var->name = NULL;}
1350 {free(var->dimids); var->dimids = NULL;}
1353 {free(var->dim); var->dim = NULL;}
1357 if (var->fill_value)
1359 if (var->hdf_datasetid)
1363 if (var->type_info->nc_type_class ==
NC_VLEN)
1365 else if (var->type_info->nc_type_class ==
NC_STRING && *(
char **)var->fill_value)
1366 free(*(
char **)var->fill_value);
1369 free(var->fill_value);
1370 var->fill_value = NULL;
1378 if ((retval = nc4_type_free(var->type_info)))
1380 var->type_info = NULL;
1384 if (var->dimscale_hdf5_objids)
1385 free(var->dimscale_hdf5_objids);
1388 if (var->dimscale_attached)
1389 free(var->dimscale_attached);
1411 type_list_del(NC_TYPE_INFO_T **list, NC_TYPE_INFO_T *type)
1414 obj_list_del((NC_LIST_NODE_T **)list, (NC_LIST_NODE_T *)type);
1417 return nc4_type_free(type);
1430 nc4_dim_list_del(NC_DIM_INFO_T **list, NC_DIM_INFO_T *dim)
1433 obj_list_del((NC_LIST_NODE_T **)list, (NC_LIST_NODE_T *)dim);
1454 grp_list_del(NC_GRP_INFO_T **list, NC_GRP_INFO_T *grp)
1457 obj_list_del((NC_LIST_NODE_T **)list, (NC_LIST_NODE_T *)grp);
1473 nc4_rec_grp_del(NC_GRP_INFO_T **list, NC_GRP_INFO_T *grp)
1475 NC_GRP_INFO_T *g, *c;
1477 NC_ATT_INFO_T *a, *att;
1478 NC_DIM_INFO_T *d, *dim;
1479 NC_TYPE_INFO_T *type, *t;
1484 LOG((3,
"%s: grp->name %s", __func__, grp->name));
1492 if ((retval = nc4_rec_grp_del(&(grp->children), g)))
1502 LOG((4,
"%s: deleting att %s", __func__, att->name));
1504 if ((retval = nc4_att_list_del(&grp->att, att)))
1510 for (i=0; i < grp->vars.nelems; i++)
1512 var = grp->vars.value[i];
1515 LOG((4,
"%s: deleting var %s", __func__, var->name));
1518 if (var->hdf_datasetid && H5Dclose(var->hdf_datasetid) < 0)
1520 if ((retval = nc4_var_del(var)))
1522 grp->vars.value[i] = NULL;
1528 if (grp->vars.nalloc != 0) {
1529 assert(grp->vars.value != NULL);
1530 free(grp->vars.value);
1531 grp->vars.value = NULL;
1532 grp->vars.nalloc = 0;
1539 LOG((4,
"%s: deleting dim %s", __func__, dim->name));
1543 if (dim->hdf_dimscaleid && H5Dclose(dim->hdf_dimscaleid) < 0)
1546 if ((retval = nc4_dim_list_del(&grp->dim, dim)))
1555 LOG((4,
"%s: deleting type %s", __func__, type->name));
1557 if ((retval = type_list_del(&grp->type, type)))
1563 LOG((4,
"%s: closing group %s", __func__, grp->name));
1564 if (grp->hdf_grpid && H5Gclose(grp->hdf_grpid) < 0)
1572 grp_list_del(list, grp);
1588 nc4_att_list_del(NC_ATT_INFO_T **list, NC_ATT_INFO_T *att)
1593 obj_list_del((NC_LIST_NODE_T **)list, (NC_LIST_NODE_T *)att);
1605 if (att->native_hdf_typeid && H5Tclose(att->native_hdf_typeid) < 0)
1616 for (i = 0; i < att->len; i++)
1618 free(att->stdata[i]);
1625 for (i = 0; i < att->len; i++)
1652 nc4_break_coord_var(NC_GRP_INFO_T *grp, NC_VAR_INFO_T *coord_var, NC_DIM_INFO_T *dim)
1657 assert(grp && coord_var && dim && dim->coord_var == coord_var &&
1658 coord_var->dim[0] == dim && coord_var->dimids[0] == dim->dimid &&
1659 !dim->hdf_dimscaleid);
1660 LOG((3,
"%s dim %s was associated with var %s, but now has different name",
1661 __func__, dim->name, coord_var->name));
1665 if ((retval = rec_detach_scales(grp->nc4_info->root_grp,
1666 dim->dimid, coord_var->hdf_datasetid)))
1671 if (coord_var->ndims)
1674 assert(!coord_var->dimscale_attached);
1677 if (!(coord_var->dimscale_attached = calloc(coord_var->ndims,
1678 sizeof(nc_bool_t))))
1687 coord_var->dimscale = NC_FALSE;
1688 dim->coord_var = NULL;
1691 coord_var->was_coord_var = NC_TRUE;
1692 coord_var->became_coord_var = NC_FALSE;
1718 delete_existing_dimscale_dataset(NC_GRP_INFO_T *grp,
int dimid, NC_DIM_INFO_T *dim)
1723 LOG((2,
"%s: deleting dimscale dataset %s dimid %d", __func__, dim->name,
1727 if ((retval = rec_detach_scales(grp, dimid, dim->hdf_dimscaleid)) < 0)
1731 if (H5Dclose(dim->hdf_dimscaleid) < 0)
1733 dim->hdf_dimscaleid = 0;
1736 if (H5Gunlink(grp->hdf_grpid, dim->name) < 0)
1754 nc4_reform_coord_var(NC_GRP_INFO_T *grp, NC_VAR_INFO_T *var, NC_DIM_INFO_T *dim)
1756 int need_to_reattach_scales = 0;
1759 assert(grp && var && dim);
1760 LOG((3,
"%s: dim->name %s var->name %s", __func__, dim->name, var->name));
1763 if(var->dimscale_attached)
1765 int dims_detached = 0;
1770 for (d = 0; d < var->ndims && !finished; d++)
1773 if(var->dimscale_attached[d])
1777 for (g = grp; g && !finished; g = g->parent)
1779 NC_DIM_INFO_T *dim1;
1781 for (dim1 = g->dim; dim1 && !finished; dim1 = dim1->l.next)
1783 if (var->dimids[d] == dim1->dimid)
1785 hid_t dim_datasetid;
1788 if (dim1->coord_var)
1789 dim_datasetid = dim1->coord_var->hdf_datasetid;
1791 dim_datasetid = dim1->hdf_dimscaleid;
1797 if (dim_datasetid > 0)
1799 LOG((3,
"detaching scale from %s", var->name));
1800 if (H5DSdetach_scale(var->hdf_datasetid, dim_datasetid, d) < 0)
1803 var->dimscale_attached[d] = NC_FALSE;
1804 if (dims_detached++ == var->ndims)
1813 free(var->dimscale_attached);
1814 var->dimscale_attached = NULL;
1815 need_to_reattach_scales++;
1819 if (dim->hdf_dimscaleid && grp != NULL)
1821 LOG((3,
"closing and unlinking dimscale dataset %s", dim->name));
1822 if (H5Dclose(dim->hdf_dimscaleid) < 0)
1824 dim->hdf_dimscaleid = 0;
1828 if (H5Gunlink(grp->hdf_grpid, dim->name) < 0)
1833 var->dimscale = NC_TRUE;
1834 dim->coord_var = var;
1837 if (need_to_reattach_scales || (var->was_coord_var && grp != NULL))
1841 if ((retval = rec_reattach_scales(grp->nc4_info->root_grp,
1842 var->dimids[0], var->hdf_datasetid)))
1846 var->was_coord_var = NC_FALSE;
1850 var->became_coord_var = NC_TRUE;
1870 nc4_normalize_name(
const char *name,
char *norm_name)
1873 int stat = nc_utf8_normalize((
const unsigned char *)name,(
unsigned char **)&temp_name);
1881 strcpy(norm_name, temp_name);
1903 nc4_hdf5_initialize();
1908 if (new_level == NC_TURN_OFF_LOGGING)
1910 set_auto(NULL,NULL);
1911 LOG((1,
"HDF5 error messages turned off!"));
1915 if (new_level > NC_TURN_OFF_LOGGING &&
1916 nc_log_level <= NC_TURN_OFF_LOGGING)
1918 if (set_auto((H5E_auto_t)&H5Eprint, stderr) < 0)
1919 LOG((0,
"H5Eset_auto failed!"));
1920 LOG((1,
"HDF5 error messages turned on."));
1924 nc_log_level = new_level;
1925 LOG((4,
"log_level changed to %d", nc_log_level));
1929 #define MAX_NESTS 10
1940 rec_print_metadata(NC_GRP_INFO_T *grp,
int tab_count)
1946 NC_TYPE_INFO_T *type;
1947 NC_FIELD_INFO_T *field;
1948 char tabs[MAX_NESTS+1] =
"";
1949 char *dims_string = NULL;
1950 char temp_string[10];
1951 int t, retval, d, i;
1954 for (t = 0; t < tab_count && t < MAX_NESTS; t++)
1958 LOG((2,
"%s GROUP - %s nc_grpid: %d nvars: %d natts: %d",
1959 tabs, grp->name, grp->nc_grpid, grp->nvars, grp->natts));
1961 for(att = grp->att; att; att = att->l.next)
1962 LOG((2,
"%s GROUP ATTRIBUTE - attnum: %d name: %s type: %d len: %d",
1963 tabs, att->attnum, att->name, att->nc_typeid, att->len));
1965 for(dim = grp->dim; dim; dim = dim->l.next)
1966 LOG((2,
"%s DIMENSION - dimid: %d name: %s len: %d unlimited: %d",
1967 tabs, dim->dimid, dim->name, dim->len, dim->unlimited));
1969 for (i=0; i < grp->vars.nelems; i++)
1971 var = grp->vars.value[i];
1975 dims_string = (
char*)malloc(
sizeof(
char)*(var->ndims*4));
1976 strcpy(dims_string,
"");
1977 for (d = 0; d < var->ndims; d++)
1979 sprintf(temp_string,
" %d", var->dimids[d]);
1980 strcat(dims_string, temp_string);
1983 LOG((2,
"%s VARIABLE - varid: %d name: %s type: %d ndims: %d dimscale: %d dimids:%s endianness: %d, hdf_typeid: %d",
1984 tabs, var->varid, var->name, var->type_info->nc_typeid, var->ndims, (
int)var->dimscale,
1985 (dims_string ? dims_string :
" -"),var->type_info->endianness, var->type_info->native_hdf_typeid));
1986 for(att = var->att; att; att = att->l.next)
1987 LOG((2,
"%s VAR ATTRIBUTE - attnum: %d name: %s type: %d len: %d",
1988 tabs, att->attnum, att->name, att->nc_typeid, att->len));
1996 for (type = grp->type; type; type = type->l.next)
1998 LOG((2,
"%s TYPE - nc_typeid: %d hdf_typeid: 0x%x size: %d committed: %d "
1999 "name: %s num_fields: %d", tabs, type->nc_typeid,
2000 type->hdf_typeid, type->size, (
int)type->committed, type->name,
2001 type->u.c.num_fields));
2005 LOG((3,
"compound type"));
2006 for (field = type->u.c.field; field; field = field->l.next)
2007 LOG((4,
"field %s offset %d nctype %d ndims %d", field->name,
2008 field->offset, field->nc_typeid, field->ndims));
2010 else if (type->nc_type_class ==
NC_VLEN)
2012 LOG((3,
"VLEN type"));
2013 LOG((4,
"base_nc_type: %d", type->u.v.base_nc_typeid));
2015 else if (type->nc_type_class ==
NC_OPAQUE)
2016 LOG((3,
"Opaque type"));
2017 else if (type->nc_type_class ==
NC_ENUM)
2019 LOG((3,
"Enum type"));
2020 LOG((4,
"base_nc_type: %d", type->u.e.base_nc_typeid));
2024 LOG((0,
"Unknown class: %d", type->nc_type_class));
2032 for (g = grp->children; g; g = g->l.next)
2033 if ((retval = rec_print_metadata(g, tab_count + 1)))
2049 log_metadata_nc(NC *nc)
2051 NC_HDF5_FILE_INFO_T *h5 = NC4_DATA(nc);
2053 LOG((2,
"*** NetCDF-4 Internal Metadata: int_ncid 0x%x ext_ncid 0x%x",
2054 nc->int_ncid, nc->ext_ncid));
2057 LOG((2,
"This is a netCDF-3 file."));
2060 LOG((2,
"FILE - hdfid: 0x%x path: %s cmode: 0x%x parallel: %d redef: %d "
2061 "fill_mode: %d no_write: %d next_nc_grpid: %d", h5->hdfid, nc->path,
2062 h5->cmode, (
int)h5->parallel, (
int)h5->redef, h5->fill_mode, (
int)h5->no_write,
2063 h5->next_nc_grpid));
2064 return rec_print_metadata(h5->root_grp, 0);
2078 NC4_show_metadata(
int ncid)
2083 int old_log_level = nc_log_level;
2086 if (!(nc = nc4_find_nc_file(ncid,NULL)))
2091 retval = log_metadata_nc(nc);
2092 nc_log_level = old_log_level;
#define NC_ENOMEM
Memory allocation (malloc) failure.
#define NC_ENOTNC4
Attempting netcdf-4 operation on netcdf-3 file.
#define NC_CLASSIC_MODEL
Enforce classic model on netCDF-4.
#define NC_EHDFERR
Error at HDF5 layer.
#define NC_OPAQUE
opaque types
#define nc_set_log_level(e)
Get rid of these calls.
size_t nc4_chunk_cache_nelems
Default chunk cache number of elements.
int nc_type
The nc_type type is just an int.
#define NC_EBADDIM
Invalid dimension id or name.
#define NC_ENAMEINUSE
String match to name in use.
#define NC_VLEN
vlen (variable-length) types
int nc4_hdf5_initialized
True if initialization has happened.
#define NC_EBADTYPE
Not a netcdf data type.
#define NC_EDIMMETA
Problem with dimension metadata.
#define NC_EINVAL
Invalid Argument.
#define NC_ESTRICTNC3
Attempting netcdf-4 operation on strict nc3 netcdf-4 file.
#define NC_MAX_NAME
Maximum for classic library.
#define NC_EBADTYPID
Bad type ID.
EXTERNL int nc_free_vlen(nc_vlen_t *vl)
Free memory in a VLEN object.
#define NC_EBADID
Not a netcdf id.
size_t nc4_chunk_cache_size
Default chunk cache size.
This is the type of arrays of vlens.
#define NC_ENOTVAR
Variable not found.
#define NC_EMAXNAME
NC_MAX_NAME exceeded.
#define NC_NOERR
No Error.
#define NC_ENUM
enum types
float nc4_chunk_cache_preemption
Default chunk cache preemption.
#define NC_COMPOUND
compound types
#define NC_GLOBAL
Attribute id to put/get a global attribute.
#define NC_ENOTATT
Attribute not found.