20 #include "netcdf_filter.h"
21 #include "nc4internal.h"
23 #include "ncdispatch.h"
31 static void freefilterlist(NClist* filters);
37 int nc_log_level = NC_TURN_OFF_LOGGING;
53 nc4_check_name(
const char *name,
char *norm_name)
67 if ((retval = NC_check_name(name)))
71 if ((retval = nc_utf8_normalize((
const unsigned char *)name,
72 (
unsigned char **)&temp)))
83 strcpy(norm_name, temp);
110 nc4_file_list_add(
int ncid,
const char *path,
int mode,
void **dispatchdata)
116 if ((ret = NC_check_id(ncid, &nc)))
121 if ((ret = nc4_nc4f_list_add(nc, path, mode)))
127 *dispatchdata = nc->dispatchdata;
146 nc4_file_change_ncid(
int ncid,
unsigned short new_ncid_index)
151 LOG((2,
"%s: ncid %d new_ncid_index %d", __func__, ncid, new_ncid_index));
154 if ((ret = NC_check_id(ncid, &nc)))
159 LOG((3,
"moving nc->ext_ncid %d nc->ext_ncid >> ID_SHIFT %d",
160 nc->ext_ncid, nc->ext_ncid >> ID_SHIFT));
161 if (move_in_NCList(nc, new_ncid_index))
163 LOG((3,
"moved to new_ncid_index %d new nc->ext_ncid %d", new_ncid_index,
189 nc4_file_list_get(
int ncid,
char **path,
int *mode,
void **dispatchdata)
195 if ((ret = NC_check_id(ncid, &nc)))
208 *dispatchdata = nc->dispatchdata;
228 nc4_nc4f_list_add(NC *nc,
const char *path,
int mode)
233 assert(nc && !NC4_DATA(nc) && path);
237 if (!(h5 = calloc(1,
sizeof(NC_FILE_INFO_T))))
239 nc->dispatchdata = h5;
243 h5->cmode = mode | NC_INDEF;
247 h5->next_typeid = NC_FIRSTUSERTYPEID;
250 h5->alldims = nclistnew();
251 h5->alltypes = nclistnew();
252 h5->allgroups = nclistnew();
257 if ((retval = nc4_grp_list_add(h5, NULL, NC_GROUP_NAME, &h5->root_grp)))
276 nc4_find_nc4_grp(
int ncid, NC_GRP_INFO_T **grp)
278 return nc4_find_nc_grp_h5(ncid, NULL, grp, NULL);
297 nc4_find_grp_h5(
int ncid, NC_GRP_INFO_T **grp, NC_FILE_INFO_T **h5)
299 return nc4_find_nc_grp_h5(ncid, NULL, grp, h5);
317 nc4_find_nc_grp_h5(
int ncid, NC **nc, NC_GRP_INFO_T **grp, NC_FILE_INFO_T **h5)
319 NC_GRP_INFO_T *my_grp = NULL;
320 NC_FILE_INFO_T *my_h5 = NULL;
325 if ((retval = NC_check_id(ncid, &my_nc)))
327 my_h5 = my_nc->dispatchdata;
328 assert(my_h5 && my_h5->root_grp);
331 if (!(my_grp = nclistget(my_h5->allgroups, (ncid & GRP_ID_MASK))))
361 nc4_find_grp_h5_var(
int ncid,
int varid, NC_FILE_INFO_T **h5, NC_GRP_INFO_T **grp,
364 NC_FILE_INFO_T *my_h5;
365 NC_GRP_INFO_T *my_grp;
366 NC_VAR_INFO_T *my_var;
370 if ((retval = nc4_find_grp_h5(ncid, &my_grp, &my_h5)))
372 assert(my_grp && my_h5);
375 if (!(my_var = (NC_VAR_INFO_T *)ncindexith(my_grp->vars, varid)))
377 assert(my_var && my_var->hdr.id == varid);
404 nc4_find_dim(NC_GRP_INFO_T *grp,
int dimid, NC_DIM_INFO_T **dim,
405 NC_GRP_INFO_T **dim_grp)
407 assert(grp && grp->nc4_info && dim);
408 LOG((4,
"%s: dimid %d", __func__, dimid));
411 if (!((*dim) = nclistget(grp->nc4_info->alldims, dimid)))
416 *dim_grp = (*dim)->container;
432 nc4_find_var(NC_GRP_INFO_T *grp,
const char *name, NC_VAR_INFO_T **var)
434 assert(grp && var && name);
437 *var = (NC_VAR_INFO_T*)ncindexlookup(grp->vars,name);
451 nc4_rec_find_named_type(NC_GRP_INFO_T *start_grp,
char *name)
454 NC_TYPE_INFO_T *type, *res;
460 type = (NC_TYPE_INFO_T*)ncindexlookup(start_grp->type,name);
465 for(i=0;i<ncindexsize(start_grp->children);i++) {
466 g = (NC_GRP_INFO_T*)ncindexith(start_grp->children,i);
467 if(g == NULL)
continue;
468 if ((res = nc4_rec_find_named_type(g, name)))
487 nc4_find_type(
const NC_FILE_INFO_T *h5,
nc_type typeid, NC_TYPE_INFO_T **type)
491 if (
typeid < 0 || !type)
501 if (!(*type = nclistget(h5->alltypes,
typeid)))
523 nc4_find_grp_att(NC_GRP_INFO_T *grp,
int varid,
const char *name,
int attnum,
527 NC_ATT_INFO_T *my_att;
528 NCindex *attlist = NULL;
530 assert(grp && grp->hdr.name && att);
532 LOG((4,
"%s: grp->name %s varid %d attnum %d", __func__, grp->hdr.name,
542 var = (NC_VAR_INFO_T*)ncindexith(grp->vars,varid);
552 my_att = (NC_ATT_INFO_T *)ncindexlookup(attlist, name);
554 my_att = (NC_ATT_INFO_T *)ncindexith(attlist, attnum);
580 nc4_find_nc_att(
int ncid,
int varid,
const char *name,
int attnum,
586 LOG((4,
"nc4_find_nc_att: ncid 0x%x varid %d name %s attnum %d",
587 ncid, varid, name, attnum));
590 if ((retval = nc4_find_grp_h5(ncid, &grp, NULL)))
594 return nc4_find_grp_att(grp, varid, name, attnum, att);
606 obj_track(NC_FILE_INFO_T* file, NC_OBJ* obj)
611 case NCDIM: list = file->alldims;
break;
612 case NCTYP: list = file->alltypes;
break;
613 case NCGRP: list = file->allgroups;
break;
618 nclistset(list,obj->id,obj);
636 nc4_var_list_add2(NC_GRP_INFO_T *grp,
const char *name, NC_VAR_INFO_T **var)
638 NC_VAR_INFO_T *new_var = NULL;
641 if (!(new_var = calloc(1,
sizeof(NC_VAR_INFO_T))))
643 new_var->hdr.sort = NCVAR;
644 new_var->container = grp;
652 new_var->hdr.id = ncindexsize(grp->vars);
653 if (!(new_var->hdr.name = strdup(name))) {
659 new_var->hdr.hashkey = NC_hashmapkey(new_var->hdr.name,
660 strlen(new_var->hdr.name));
663 new_var->att = ncindexnew(0);
666 ncindexadd(grp->vars, (NC_OBJ *)new_var);
688 nc4_var_set_ndims(NC_VAR_INFO_T *var,
int ndims)
698 if (!(var->dim = calloc(ndims,
sizeof(NC_DIM_INFO_T *))))
700 if (!(var->dimids = calloc(ndims,
sizeof(
int))))
705 memset(var->dimids, -1, ndims *
sizeof(
int));
726 nc4_var_list_add(NC_GRP_INFO_T* grp,
const char* name,
int ndims,
731 if ((retval = nc4_var_list_add2(grp, name, var)))
733 if ((retval = nc4_var_set_ndims(*var, ndims)))
753 nc4_dim_list_add(NC_GRP_INFO_T *grp,
const char *name,
size_t len,
754 int assignedid, NC_DIM_INFO_T **dim)
756 NC_DIM_INFO_T *new_dim = NULL;
761 if (!(new_dim = calloc(1,
sizeof(NC_DIM_INFO_T))))
764 new_dim->hdr.sort = NCDIM;
768 new_dim->hdr.id = assignedid;
770 new_dim->hdr.id = grp->nc4_info->next_dimid++;
773 if (!(new_dim->hdr.name = strdup(name))) {
779 new_dim->hdr.hashkey = NC_hashmapkey(new_dim->hdr.name,
780 strlen(new_dim->hdr.name));
785 new_dim->unlimited = NC_TRUE;
788 new_dim->container = grp;
791 ncindexadd(grp->dim, (NC_OBJ *)new_dim);
792 obj_track(grp->nc4_info, (NC_OBJ *)new_dim);
814 nc4_att_list_add(NCindex *list,
const char *name, NC_ATT_INFO_T **att)
816 NC_ATT_INFO_T *new_att = NULL;
818 LOG((3,
"%s: name %s ", __func__, name));
820 if (!(new_att = calloc(1,
sizeof(NC_ATT_INFO_T))))
822 new_att->hdr.sort = NCATT;
825 new_att->hdr.id = ncindexsize(list);
826 if (!(new_att->hdr.name = strdup(name))) {
832 new_att->hdr.hashkey = NC_hashmapkey(name, strlen(name));
835 ncindexadd(list, (NC_OBJ *)new_att);
859 nc4_grp_list_add(NC_FILE_INFO_T *h5, NC_GRP_INFO_T *parent,
char *name,
862 NC_GRP_INFO_T *new_grp;
866 LOG((3,
"%s: name %s ", __func__, name));
869 if (!(new_grp = calloc(1,
sizeof(NC_GRP_INFO_T))))
873 new_grp->hdr.sort = NCGRP;
874 new_grp->nc4_info = h5;
875 new_grp->parent = parent;
878 new_grp->hdr.id = h5->next_nc_grpid++;
879 assert(parent || !new_grp->hdr.id);
882 if (!(new_grp->hdr.name = strdup(name)))
887 new_grp->hdr.hashkey = NC_hashmapkey(new_grp->hdr.name,
888 strlen(new_grp->hdr.name));
891 new_grp->children = ncindexnew(0);
892 new_grp->dim = ncindexnew(0);
893 new_grp->att = ncindexnew(0);
894 new_grp->type = ncindexnew(0);
895 new_grp->vars = ncindexnew(0);
899 ncindexadd(parent->children, (NC_OBJ *)new_grp);
900 obj_track(h5, (NC_OBJ *)new_grp);
923 nc4_check_dup_name(NC_GRP_INFO_T *grp,
char *name)
925 NC_TYPE_INFO_T *type;
930 type = (NC_TYPE_INFO_T*)ncindexlookup(grp->type,name);
935 g = (NC_GRP_INFO_T*)ncindexlookup(grp->children,name);
940 var = (NC_VAR_INFO_T*)ncindexlookup(grp->vars,name);
961 nc4_type_new(
size_t size,
const char *name,
int assignedid,
962 NC_TYPE_INFO_T **type)
964 NC_TYPE_INFO_T *new_type;
966 LOG((4,
"%s: size %d name %s assignedid %d", __func__, size, name, assignedid));
972 if (!(new_type = calloc(1,
sizeof(NC_TYPE_INFO_T))))
974 new_type->hdr.sort = NCTYP;
977 new_type->hdr.id = assignedid;
978 new_type->size = size;
979 if (!(new_type->hdr.name = strdup(name))) {
984 new_type->hdr.hashkey = NC_hashmapkey(name, strlen(name));
1006 nc4_type_list_add(NC_GRP_INFO_T *grp,
size_t size,
const char *name,
1007 NC_TYPE_INFO_T **type)
1009 NC_TYPE_INFO_T *new_type;
1013 assert(grp && name && type);
1014 LOG((4,
"%s: size %d name %s", __func__, size, name));
1017 if ((retval = nc4_type_new(size, name, grp->nc4_info->next_typeid,
1020 grp->nc4_info->next_typeid++;
1026 ncindexadd(grp->type, (NC_OBJ *)new_type);
1027 obj_track(grp->nc4_info,(NC_OBJ*)new_type);
1049 nc4_field_list_add(NC_TYPE_INFO_T *parent,
const char *name,
1050 size_t offset,
nc_type xtype,
int ndims,
1051 const int *dim_sizesp)
1053 NC_FIELD_INFO_T *field;
1060 if (!(field = calloc(1,
sizeof(NC_FIELD_INFO_T))))
1062 field->hdr.sort = NCFLD;
1065 if (!(field->hdr.name = strdup(name)))
1070 field->hdr.hashkey = NC_hashmapkey(field->hdr.name,strlen(field->hdr.name));
1071 field->nc_typeid = xtype;
1072 field->offset = offset;
1073 field->ndims = ndims;
1077 if (!(field->dim_size = malloc(ndims *
sizeof(
int))))
1079 free(field->hdr.name);
1083 for (i = 0; i < ndims; i++)
1084 field->dim_size[i] = dim_sizesp[i];
1088 field->hdr.id = nclistlength(parent->u.c.field);
1089 nclistpush(parent->u.c.field,field);
1107 nc4_enum_member_add(NC_TYPE_INFO_T *parent,
size_t size,
1108 const char *name,
const void *value)
1110 NC_ENUM_MEMBER_INFO_T *member;
1113 assert(name && size > 0 && value);
1114 LOG((4,
"%s: size %d name %s", __func__, size, name));
1117 if (!(member = calloc(1,
sizeof(NC_ENUM_MEMBER_INFO_T))))
1119 if (!(member->value = malloc(size))) {
1123 if (!(member->name = strdup(name))) {
1124 free(member->value);
1130 memcpy(member->value, value, size);
1133 nclistpush(parent->u.e.enum_member,member);
1147 field_free(NC_FIELD_INFO_T *field)
1150 if (field->hdr.name)
1151 free(field->hdr.name);
1152 if (field->dim_size)
1153 free(field->dim_size);
1169 nc4_type_free(NC_TYPE_INFO_T *type)
1173 assert(type && type->rc && type->hdr.name);
1181 LOG((4,
"%s: deleting type %s", __func__, type->hdr.name));
1184 free(type->hdr.name);
1187 switch (type->nc_type_class)
1191 NC_FIELD_INFO_T *field;
1195 for(i=0;i<nclistlength(type->u.c.field);i++) {
1196 field = nclistget(type->u.c.field,i);
1199 nclistfree(type->u.c.field);
1205 NC_ENUM_MEMBER_INFO_T *enum_member;
1208 for(i=0;i<nclistlength(type->u.e.enum_member);i++) {
1209 enum_member = nclistget(type->u.e.enum_member,i);
1210 free(enum_member->value);
1211 free(enum_member->name);
1214 nclistfree(type->u.e.enum_member);
1223 if (type->format_type_info)
1224 free(type->format_type_info);
1242 att_free(NC_ATT_INFO_T *att)
1247 LOG((3,
"%s: name %s ", __func__, att->hdr.name));
1256 free(att->hdr.name);
1266 for (i = 0; i < att->len; i++)
1268 free(att->stdata[i]);
1275 for (i = 0; i < att->len; i++)
1282 if (att->format_att_info)
1283 free(att->format_att_info);
1299 var_free(NC_VAR_INFO_T *var)
1305 LOG((4,
"%s: deleting var %s", __func__, var->hdr.name));
1308 for (i = 0; i < ncindexsize(var->att); i++)
1309 if ((retval = att_free((NC_ATT_INFO_T *)ncindexith(var->att, i))))
1311 ncindexfree(var->att);
1314 if (var->chunksizes)
1315 free(var->chunksizes);
1318 free(var->hdf5_name);
1321 free(var->hdr.name);
1330 if (var->fill_value)
1331 free(var->fill_value);
1335 if ((retval = nc4_type_free(var->type_info)))
1339 if (var->dimscale_attached)
1340 free(var->dimscale_attached);
1343 freefilterlist(var->filters);
1346 if (var->format_var_info)
1347 free(var->format_var_info);
1365 nc4_var_list_del(NC_GRP_INFO_T *grp, NC_VAR_INFO_T *var)
1372 i = ncindexfind(grp->vars, (NC_OBJ *)var);
1374 ncindexidel(grp->vars, i);
1376 return var_free(var);
1388 dim_free(NC_DIM_INFO_T *dim)
1391 LOG((4,
"%s: deleting dim %s", __func__, dim->hdr.name));
1395 free(dim->hdr.name);
1398 if (dim->format_dim_info)
1399 free(dim->format_dim_info);
1415 nc4_dim_list_del(NC_GRP_INFO_T *grp, NC_DIM_INFO_T *dim)
1419 int pos = ncindexfind(grp->dim, (NC_OBJ *)dim);
1421 ncindexidel(grp->dim, pos);
1424 return dim_free(dim);
1437 nc4_rec_grp_del(NC_GRP_INFO_T *grp)
1443 LOG((3,
"%s: grp->name %s", __func__, grp->hdr.name));
1447 for (i = 0; i < ncindexsize(grp->children); i++)
1448 if ((retval = nc4_rec_grp_del((NC_GRP_INFO_T *)ncindexith(grp->children,
1451 ncindexfree(grp->children);
1454 for (i = 0; i < ncindexsize(grp->att); i++)
1455 if ((retval = att_free((NC_ATT_INFO_T *)ncindexith(grp->att, i))))
1457 ncindexfree(grp->att);
1460 for (i = 0; i < ncindexsize(grp->vars); i++) {
1461 NC_VAR_INFO_T* v = (NC_VAR_INFO_T *)ncindexith(grp->vars, i);
1462 if ((retval = var_free(v)))
1465 ncindexfree(grp->vars);
1468 for (i = 0; i < ncindexsize(grp->dim); i++)
1469 if ((retval = dim_free((NC_DIM_INFO_T *)ncindexith(grp->dim, i))))
1471 ncindexfree(grp->dim);
1474 for (i = 0; i < ncindexsize(grp->type); i++)
1475 if ((retval = nc4_type_free((NC_TYPE_INFO_T *)ncindexith(grp->type, i))))
1477 ncindexfree(grp->type);
1480 free(grp->hdr.name);
1483 if (grp->format_grp_info)
1484 free(grp->format_grp_info);
1503 nc4_att_list_del(NCindex *list, NC_ATT_INFO_T *att)
1505 assert(att && list);
1506 ncindexidel(list, ((NC_OBJ *)att)->
id);
1507 return att_free(att);
1524 nc4_file_list_del(
int ncid)
1530 if ((retval = nc4_find_grp_h5(ncid, NULL, &h5)))
1535 if ((retval = nc4_nc4f_list_del(h5)))
1551 nc4_nc4f_list_del(NC_FILE_INFO_T *h5)
1559 if ((retval = nc4_rec_grp_del(h5->root_grp)))
1563 nclistfree(h5->alldims);
1564 nclistfree(h5->allgroups);
1565 nclistfree(h5->alltypes);
1587 nc4_normalize_name(
const char *name,
char *norm_name)
1590 int stat = nc_utf8_normalize((
const unsigned char *)name,(
unsigned char **)&temp_name);
1598 strcpy(norm_name, temp_name);
1603 #ifdef ENABLE_SET_LOG_LEVEL
1620 nc_set_log_level(
int new_level)
1624 nc_log_level = new_level;
1625 LOG((4,
"log_level changed to %d", nc_log_level));
1632 #define MAX_NESTS 10
1643 rec_print_metadata(NC_GRP_INFO_T *grp,
int tab_count)
1648 NC_TYPE_INFO_T *type;
1649 NC_FIELD_INFO_T *field;
1650 char tabs[MAX_NESTS+1] =
"";
1651 char temp_string[10];
1652 int t, retval, d, i;
1655 for (t = 0; t < tab_count && t < MAX_NESTS; t++)
1659 LOG((2,
"%s GROUP - %s nc_grpid: %d nvars: %d natts: %d",
1660 tabs, grp->hdr.name, grp->hdr.id, ncindexsize(grp->vars), ncindexsize(grp->att)));
1662 for (i = 0; i < ncindexsize(grp->att); i++)
1664 att = (NC_ATT_INFO_T *)ncindexith(grp->att, i);
1666 LOG((2,
"%s GROUP ATTRIBUTE - attnum: %d name: %s type: %d len: %d",
1667 tabs, att->hdr.id, att->hdr.name, att->nc_typeid, att->len));
1670 for (i = 0; i < ncindexsize(grp->dim); i++)
1672 dim = (NC_DIM_INFO_T *)ncindexith(grp->dim, i);
1674 LOG((2,
"%s DIMENSION - dimid: %d name: %s len: %d unlimited: %d",
1675 tabs, dim->hdr.id, dim->hdr.name, dim->len, dim->unlimited));
1678 for (i = 0; i < ncindexsize(grp->vars); i++)
1682 char *dims_string = NULL;
1684 var = (NC_VAR_INFO_T*)ncindexith(grp->vars,i);
1688 if (!(dims_string = malloc(
sizeof(
char) * var->ndims * 4)))
1690 strcpy(dims_string,
"");
1691 for (d = 0; d < var->ndims; d++)
1693 sprintf(temp_string,
" %d", var->dimids[d]);
1694 strcat(dims_string, temp_string);
1697 if (!var->meta_read)
1698 strcat(storage_str,
"unknown");
1700 strcat(storage_str,
"contiguous");
1702 strcat(storage_str,
"compact");
1704 strcat(storage_str,
"chunked");
1705 LOG((2,
"%s VARIABLE - varid: %d name: %s ndims: %d dimscale: %d "
1706 "dimids:%s storage: %s", tabs, var->hdr.id, var->hdr.name,
1707 var->ndims, (
int)var->dimscale,
1708 (dims_string ? dims_string :
" -"), storage_str));
1709 for (j = 0; j < ncindexsize(var->att); j++)
1711 att = (NC_ATT_INFO_T *)ncindexith(var->att, j);
1713 LOG((2,
"%s VAR ATTRIBUTE - attnum: %d name: %s type: %d len: %d",
1714 tabs, att->hdr.id, att->hdr.name, att->nc_typeid, att->len));
1720 for (i = 0; i < ncindexsize(grp->type); i++)
1722 type = (NC_TYPE_INFO_T*)ncindexith(grp->type, i);
1724 LOG((2,
"%s TYPE - nc_typeid: %d size: %d committed: %d name: %s",
1725 tabs, type->hdr.id, type->size, (
int)type->committed, type->hdr.name));
1730 LOG((3,
"compound type"));
1731 for (j = 0; j < nclistlength(type->u.c.field); j++)
1733 field = (NC_FIELD_INFO_T *)nclistget(type->u.c.field, j);
1734 LOG((4,
"field %s offset %d nctype %d ndims %d", field->hdr.name,
1735 field->offset, field->nc_typeid, field->ndims));
1738 else if (type->nc_type_class ==
NC_VLEN)
1740 LOG((3,
"VLEN type"));
1741 LOG((4,
"base_nc_type: %d", type->u.v.base_nc_typeid));
1743 else if (type->nc_type_class ==
NC_OPAQUE)
1744 LOG((3,
"Opaque type"));
1745 else if (type->nc_type_class ==
NC_ENUM)
1747 LOG((3,
"Enum type"));
1748 LOG((4,
"base_nc_type: %d", type->u.e.base_nc_typeid));
1752 LOG((0,
"Unknown class: %d", type->nc_type_class));
1758 for (i = 0; i < ncindexsize(grp->children); i++)
1759 if ((retval = rec_print_metadata((NC_GRP_INFO_T *)ncindexith(grp->children, i),
1777 log_metadata_nc(NC_FILE_INFO_T *h5)
1779 LOG((2,
"*** NetCDF-4 Internal Metadata: int_ncid 0x%x ext_ncid 0x%x",
1780 h5->root_grp->nc4_info->controller->int_ncid,
1781 h5->root_grp->nc4_info->controller->ext_ncid));
1784 LOG((2,
"This is a netCDF-3 file."));
1787 LOG((2,
"FILE - path: %s cmode: 0x%x parallel: %d redef: %d "
1788 "fill_mode: %d no_write: %d next_nc_grpid: %d", h5->root_grp->nc4_info->controller->path,
1789 h5->cmode, (
int)h5->parallel, (
int)h5->redef, h5->fill_mode, (
int)h5->no_write,
1790 h5->next_nc_grpid));
1791 if(nc_log_level >= 2)
1792 return rec_print_metadata(h5->root_grp, 0);
1810 NC4_show_metadata(
int ncid)
1815 int old_log_level = nc_log_level;
1818 if ((retval = nc4_find_grp_h5(ncid, NULL, &h5)))
1823 retval = log_metadata_nc(h5);
1824 nc_log_level = old_log_level;
1830 freefilterlist(NClist* filters)
1833 if(filters == NULL)
return;
1834 for(i=0;i<nclistlength(filters);i++) {
1835 NC_FILTER_SPEC_HDF5* f = nclistget(filters,i);
1836 NC4_freefilterspec(f);
1838 nclistfree(filters);