From cb107c2b606c95d61bebe74d1f793abd646af5ef Mon Sep 17 00:00:00 2001 From: Ed Hartnett Date: Tue, 19 Feb 2019 05:56:04 -0700 Subject: [PATCH] cleanup of whitespace in libsrc4 directory --- libsrc4/nc4internal.c | 1508 ++++++++++++++++++++--------------------- libsrc4/nc4printer.c | 284 ++++---- 2 files changed, 896 insertions(+), 896 deletions(-) diff --git a/libsrc4/nc4internal.c b/libsrc4/nc4internal.c index 80db5bcdd..c86a48569 100644 --- a/libsrc4/nc4internal.c +++ b/libsrc4/nc4internal.c @@ -48,38 +48,38 @@ int nc_log_level = NC_TURN_OFF_LOGGING; int nc4_check_name(const char *name, char *norm_name) { - char *temp; - int retval; + char *temp; + int retval; - assert(norm_name); + assert(norm_name); - /* Check for NULL. */ - if (!name) - return NC_EINVAL; + /* Check for NULL. */ + if (!name) + return NC_EINVAL; - /* Make sure this is a valid netcdf name. This should be done - * before the name is normalized, because it gives better error - * codes for bad utf8 strings. */ - if ((retval = NC_check_name(name))) - return retval; + /* Make sure this is a valid netcdf name. This should be done + * before the name is normalized, because it gives better error + * codes for bad utf8 strings. */ + if ((retval = NC_check_name(name))) + return retval; - /* Normalize the name. */ - if ((retval = nc_utf8_normalize((const unsigned char *)name, - (unsigned char **)&temp))) - return retval; + /* Normalize the name. */ + if ((retval = nc_utf8_normalize((const unsigned char *)name, + (unsigned char **)&temp))) + return retval; - /* Check length of normalized name. */ - if (strlen(temp) > NC_MAX_NAME) - { - free(temp); - return NC_EMAXNAME; - } + /* Check length of normalized name. */ + if (strlen(temp) > NC_MAX_NAME) + { + free(temp); + return NC_EMAXNAME; + } - /* Copy the normalized name. */ - strcpy(norm_name, temp); - free(temp); + /* Copy the normalized name. */ + strcpy(norm_name, temp); + free(temp); - return NC_NOERR; + return NC_NOERR; } /** @@ -97,37 +97,37 @@ nc4_check_name(const char *name, char *norm_name) int nc4_nc4f_list_add(NC *nc, const char *path, int mode) { - NC_FILE_INFO_T *h5; - int retval; + NC_FILE_INFO_T *h5; + int retval; - assert(nc && !NC4_DATA(nc) && path); + assert(nc && !NC4_DATA(nc) && path); - /* We need to malloc and initialize the substructure - NC_HDF_FILE_INFO_T. */ - if (!(h5 = calloc(1, sizeof(NC_FILE_INFO_T)))) - return NC_ENOMEM; - nc->dispatchdata = h5; - h5->controller = nc; + /* We need to malloc and initialize the substructure + NC_HDF_FILE_INFO_T. */ + if (!(h5 = calloc(1, sizeof(NC_FILE_INFO_T)))) + return NC_ENOMEM; + nc->dispatchdata = h5; + h5->controller = nc; - /* Hang on to cmode, and note that we're in define mode. */ - h5->cmode = mode | NC_INDEF; + /* Hang on to cmode, and note that we're in define mode. */ + h5->cmode = mode | NC_INDEF; - /* The next_typeid needs to be set beyond the end of our atomic - * types. */ - h5->next_typeid = NC_FIRSTUSERTYPEID; + /* The next_typeid needs to be set beyond the end of our atomic + * types. */ + h5->next_typeid = NC_FIRSTUSERTYPEID; - /* Initialize lists for dimensions, types, and groups. */ - h5->alldims = nclistnew(); - h5->alltypes = nclistnew(); - h5->allgroups = nclistnew(); + /* Initialize lists for dimensions, types, and groups. */ + h5->alldims = nclistnew(); + h5->alltypes = nclistnew(); + h5->allgroups = nclistnew(); - /* There's always at least one open group - the root - * group. Allocate space for one group's worth of information. Set - * its hdf id, name, and a pointer to it's file structure. */ - if ((retval = nc4_grp_list_add(h5, NULL, NC_GROUP_NAME, &h5->root_grp))) - return retval; + /* There's always at least one open group - the root + * group. Allocate space for one group's worth of information. Set + * its hdf id, name, and a pointer to it's file structure. */ + if ((retval = nc4_grp_list_add(h5, NULL, NC_GROUP_NAME, &h5->root_grp))) + return retval; - return NC_NOERR; + return NC_NOERR; } /** @@ -145,7 +145,7 @@ nc4_nc4f_list_add(NC *nc, const char *path, int mode) int nc4_find_nc4_grp(int ncid, NC_GRP_INFO_T **grp) { - return nc4_find_nc_grp_h5(ncid, NULL, grp, NULL); + return nc4_find_nc_grp_h5(ncid, NULL, grp, NULL); } /** @@ -166,7 +166,7 @@ nc4_find_nc4_grp(int ncid, NC_GRP_INFO_T **grp) int nc4_find_grp_h5(int ncid, NC_GRP_INFO_T **grp, NC_FILE_INFO_T **h5) { - return nc4_find_nc_grp_h5(ncid, NULL, grp, h5); + return nc4_find_nc_grp_h5(ncid, NULL, grp, h5); } /** @@ -186,30 +186,30 @@ nc4_find_grp_h5(int ncid, NC_GRP_INFO_T **grp, NC_FILE_INFO_T **h5) int nc4_find_nc_grp_h5(int ncid, NC **nc, NC_GRP_INFO_T **grp, NC_FILE_INFO_T **h5) { - NC_GRP_INFO_T *my_grp = NULL; - NC_FILE_INFO_T *my_h5 = NULL; - NC *my_nc; - int retval; + NC_GRP_INFO_T *my_grp = NULL; + NC_FILE_INFO_T *my_h5 = NULL; + NC *my_nc; + int retval; - /* Look up file metadata. */ - if ((retval = NC_check_id(ncid, &my_nc))) - return retval; - my_h5 = my_nc->dispatchdata; - assert(my_h5 && my_h5->root_grp); + /* Look up file metadata. */ + if ((retval = NC_check_id(ncid, &my_nc))) + return retval; + my_h5 = my_nc->dispatchdata; + assert(my_h5 && my_h5->root_grp); - /* If we can't find it, the grp id part of ncid is bad. */ - if (!(my_grp = nclistget(my_h5->allgroups, (ncid & GRP_ID_MASK)))) - return NC_EBADID; + /* If we can't find it, the grp id part of ncid is bad. */ + if (!(my_grp = nclistget(my_h5->allgroups, (ncid & GRP_ID_MASK)))) + return NC_EBADID; - /* Return pointers to caller, if desired. */ - if (nc) - *nc = my_nc; - if (h5) - *h5 = my_h5; - if (grp) - *grp = my_grp; + /* Return pointers to caller, if desired. */ + if (nc) + *nc = my_nc; + if (h5) + *h5 = my_h5; + if (grp) + *grp = my_grp; - return NC_NOERR; + return NC_NOERR; } /** @@ -231,30 +231,30 @@ int nc4_find_grp_h5_var(int ncid, int varid, NC_FILE_INFO_T **h5, NC_GRP_INFO_T **grp, NC_VAR_INFO_T **var) { - NC_FILE_INFO_T *my_h5; - NC_GRP_INFO_T *my_grp; - NC_VAR_INFO_T *my_var; - int retval; + NC_FILE_INFO_T *my_h5; + NC_GRP_INFO_T *my_grp; + NC_VAR_INFO_T *my_var; + int retval; - /* Look up file and group metadata. */ - if ((retval = nc4_find_grp_h5(ncid, &my_grp, &my_h5))) - return retval; - assert(my_grp && my_h5); + /* Look up file and group metadata. */ + if ((retval = nc4_find_grp_h5(ncid, &my_grp, &my_h5))) + return retval; + assert(my_grp && my_h5); - /* Find the var. */ - if (!(my_var = (NC_VAR_INFO_T *)ncindexith(my_grp->vars, varid))) - return NC_ENOTVAR; - assert(my_var && my_var->hdr.id == varid); + /* Find the var. */ + if (!(my_var = (NC_VAR_INFO_T *)ncindexith(my_grp->vars, varid))) + return NC_ENOTVAR; + assert(my_var && my_var->hdr.id == varid); - /* Return pointers that caller wants. */ - if (h5) - *h5 = my_h5; - if (grp) - *grp = my_grp; - if (var) - *var = my_var; + /* Return pointers that caller wants. */ + if (h5) + *h5 = my_h5; + if (grp) + *grp = my_grp; + if (var) + *var = my_var; - return NC_NOERR; + return NC_NOERR; } /** @@ -274,18 +274,18 @@ int nc4_find_dim(NC_GRP_INFO_T *grp, int dimid, NC_DIM_INFO_T **dim, NC_GRP_INFO_T **dim_grp) { - assert(grp && grp->nc4_info && dim); - LOG((4, "%s: dimid %d", __func__, dimid)); + assert(grp && grp->nc4_info && dim); + LOG((4, "%s: dimid %d", __func__, dimid)); - /* Find the dim info. */ - if (!((*dim) = nclistget(grp->nc4_info->alldims, dimid))) - return NC_EBADDIM; + /* Find the dim info. */ + if (!((*dim) = nclistget(grp->nc4_info->alldims, dimid))) + return NC_EBADDIM; - /* Give the caller the group the dimension is in. */ - if (dim_grp) - *dim_grp = (*dim)->container; + /* Give the caller the group the dimension is in. */ + if (dim_grp) + *dim_grp = (*dim)->container; - return NC_NOERR; + return NC_NOERR; } /** @@ -301,11 +301,11 @@ nc4_find_dim(NC_GRP_INFO_T *grp, int dimid, NC_DIM_INFO_T **dim, int nc4_find_var(NC_GRP_INFO_T *grp, const char *name, NC_VAR_INFO_T **var) { - assert(grp && var && name); + assert(grp && var && name); - /* Find the var info. */ - *var = (NC_VAR_INFO_T*)ncindexlookup(grp->vars,name); - return NC_NOERR; + /* Find the var info. */ + *var = (NC_VAR_INFO_T*)ncindexlookup(grp->vars,name); + return NC_NOERR; } /** @@ -320,26 +320,26 @@ nc4_find_var(NC_GRP_INFO_T *grp, const char *name, NC_VAR_INFO_T **var) NC_TYPE_INFO_T * nc4_rec_find_named_type(NC_GRP_INFO_T *start_grp, char *name) { - NC_GRP_INFO_T *g; - NC_TYPE_INFO_T *type, *res; - int i; + NC_GRP_INFO_T *g; + NC_TYPE_INFO_T *type, *res; + int i; - assert(start_grp); + assert(start_grp); - /* Does this group have the type we are searching for? */ - type = (NC_TYPE_INFO_T*)ncindexlookup(start_grp->type,name); - if(type != NULL) - return type; + /* Does this group have the type we are searching for? */ + type = (NC_TYPE_INFO_T*)ncindexlookup(start_grp->type,name); + if(type != NULL) + return type; - /* Search subgroups. */ - for(i=0;ichildren);i++) { - g = (NC_GRP_INFO_T*)ncindexith(start_grp->children,i); - if(g == NULL) continue; - if ((res = nc4_rec_find_named_type(g, name))) - return res; - } - /* Can't find it. Oh, woe is me! */ - return NULL; + /* Search subgroups. */ + for(i=0;ichildren);i++) { + g = (NC_GRP_INFO_T*)ncindexith(start_grp->children,i); + if(g == NULL) continue; + if ((res = nc4_rec_find_named_type(g, name))) + return res; + } + /* Can't find it. Oh, woe is me! */ + return NULL; } /** @@ -356,22 +356,22 @@ nc4_rec_find_named_type(NC_GRP_INFO_T *start_grp, char *name) int nc4_find_type(const NC_FILE_INFO_T *h5, nc_type typeid, NC_TYPE_INFO_T **type) { - /* Check inputs. */ - assert(h5); - if (typeid < 0 || !type) - return NC_EINVAL; - *type = NULL; + /* Check inputs. */ + assert(h5); + if (typeid < 0 || !type) + return NC_EINVAL; + *type = NULL; - /* Atomic types don't have associated NC_TYPE_INFO_T struct, just - * return NOERR. */ - if (typeid <= NC_STRING) - return NC_NOERR; + /* Atomic types don't have associated NC_TYPE_INFO_T struct, just + * return NOERR. */ + if (typeid <= NC_STRING) + return NC_NOERR; - /* Find the type. */ - if (!(*type = nclistget(h5->alltypes,typeid))) - return NC_EBADTYPID; + /* Find the type. */ + if (!(*type = nclistget(h5->alltypes,typeid))) + return NC_EBADTYPID; - return NC_NOERR; + return NC_NOERR; } /** @@ -393,41 +393,41 @@ int nc4_find_grp_att(NC_GRP_INFO_T *grp, int varid, const char *name, int attnum, NC_ATT_INFO_T **att) { - NC_VAR_INFO_T *var; - NC_ATT_INFO_T *my_att; - NCindex *attlist = NULL; + NC_VAR_INFO_T *var; + NC_ATT_INFO_T *my_att; + NCindex *attlist = NULL; - assert(grp && grp->hdr.name && att); + assert(grp && grp->hdr.name && att); - LOG((4, "%s: grp->name %s varid %d attnum %d", __func__, grp->hdr.name, - varid, attnum)); + LOG((4, "%s: grp->name %s varid %d attnum %d", __func__, grp->hdr.name, + varid, attnum)); - /* Get either the global or a variable attribute list. */ - if (varid == NC_GLOBAL) - { - attlist = grp->att; - } - else - { - var = (NC_VAR_INFO_T*)ncindexith(grp->vars,varid); - if (!var) return NC_ENOTVAR; + /* Get either the global or a variable attribute list. */ + if (varid == NC_GLOBAL) + { + attlist = grp->att; + } + else + { + var = (NC_VAR_INFO_T*)ncindexith(grp->vars,varid); + if (!var) return NC_ENOTVAR; - attlist = var->att; - } - assert(attlist); + attlist = var->att; + } + assert(attlist); - /* Now find the attribute by name or number. If a name is provided, - * ignore the attnum. */ - if (name) - my_att = (NC_ATT_INFO_T *)ncindexlookup(attlist, name); - else - my_att = (NC_ATT_INFO_T *)ncindexith(attlist, attnum); + /* Now find the attribute by name or number. If a name is provided, + * ignore the attnum. */ + if (name) + my_att = (NC_ATT_INFO_T *)ncindexlookup(attlist, name); + else + my_att = (NC_ATT_INFO_T *)ncindexith(attlist, attnum); - if (!my_att) - return NC_ENOTATT; + if (!my_att) + return NC_ENOTATT; - *att = my_att; - return NC_NOERR; + *att = my_att; + return NC_NOERR; } /** @@ -450,18 +450,18 @@ int nc4_find_nc_att(int ncid, int varid, const char *name, int attnum, NC_ATT_INFO_T **att) { - NC_GRP_INFO_T *grp; - int retval; + NC_GRP_INFO_T *grp; + int retval; - LOG((4, "nc4_find_nc_att: ncid 0x%x varid %d name %s attnum %d", - ncid, varid, name, attnum)); + LOG((4, "nc4_find_nc_att: ncid 0x%x varid %d name %s attnum %d", + ncid, varid, name, attnum)); - /* Find info for this file and group, and set pointer to each. */ - if ((retval = nc4_find_grp_h5(ncid, &grp, NULL))) - return retval; - assert(grp); + /* Find info for this file and group, and set pointer to each. */ + if ((retval = nc4_find_grp_h5(ncid, &grp, NULL))) + return retval; + assert(grp); - return nc4_find_grp_att(grp, varid, name, attnum, att); + return nc4_find_grp_att(grp, varid, name, attnum, att); } /** @@ -475,17 +475,17 @@ nc4_find_nc_att(int ncid, int varid, const char *name, int attnum, static void obj_track(NC_FILE_INFO_T* file, NC_OBJ* obj) { - NClist* list = NULL; - /* record the object in the file */ - switch (obj->sort) { - case NCDIM: list = file->alldims; break; - case NCTYP: list = file->alltypes; break; - case NCGRP: list = file->allgroups; break; - default: - assert(NC_FALSE); - } - /* Insert at the appropriate point in the list */ - nclistset(list,obj->id,obj); + NClist* list = NULL; + /* record the object in the file */ + switch (obj->sort) { + case NCDIM: list = file->alldims; break; + case NCTYP: list = file->alltypes; break; + case NCGRP: list = file->allgroups; break; + default: + assert(NC_FALSE); + } + /* Insert at the appropriate point in the list */ + nclistset(list,obj->id,obj); } /** @@ -505,37 +505,37 @@ obj_track(NC_FILE_INFO_T* file, NC_OBJ* obj) int nc4_var_list_add2(NC_GRP_INFO_T *grp, const char *name, NC_VAR_INFO_T **var) { - NC_VAR_INFO_T *new_var; + NC_VAR_INFO_T *new_var; - /* Allocate storage for new variable. */ - if (!(new_var = calloc(1, sizeof(NC_VAR_INFO_T)))) - return NC_ENOMEM; - new_var->hdr.sort = NCVAR; - new_var->container = grp; + /* Allocate storage for new variable. */ + if (!(new_var = calloc(1, sizeof(NC_VAR_INFO_T)))) + return NC_ENOMEM; + new_var->hdr.sort = NCVAR; + new_var->container = grp; - /* These are the HDF5-1.8.4 defaults. */ - new_var->chunk_cache_size = nc4_chunk_cache_size; - new_var->chunk_cache_nelems = nc4_chunk_cache_nelems; - new_var->chunk_cache_preemption = nc4_chunk_cache_preemption; + /* These are the HDF5-1.8.4 defaults. */ + new_var->chunk_cache_size = nc4_chunk_cache_size; + new_var->chunk_cache_nelems = nc4_chunk_cache_nelems; + new_var->chunk_cache_preemption = nc4_chunk_cache_preemption; - /* Now fill in the values in the var info structure. */ - new_var->hdr.id = ncindexsize(grp->vars); - if (!(new_var->hdr.name = strdup(name))) - return NC_ENOMEM; - new_var->hdr.hashkey = NC_hashmapkey(new_var->hdr.name, - strlen(new_var->hdr.name)); + /* Now fill in the values in the var info structure. */ + new_var->hdr.id = ncindexsize(grp->vars); + if (!(new_var->hdr.name = strdup(name))) + return NC_ENOMEM; + new_var->hdr.hashkey = NC_hashmapkey(new_var->hdr.name, + strlen(new_var->hdr.name)); - /* Create an indexed list for the attributes. */ - new_var->att = ncindexnew(0); + /* Create an indexed list for the attributes. */ + new_var->att = ncindexnew(0); - /* Officially track it */ - ncindexadd(grp->vars, (NC_OBJ *)new_var); + /* Officially track it */ + ncindexadd(grp->vars, (NC_OBJ *)new_var); - /* Set the var pointer, if one was given */ - if (var) - *var = new_var; + /* Set the var pointer, if one was given */ + if (var) + *var = new_var; - return NC_NOERR; + return NC_NOERR; } /** @@ -553,25 +553,25 @@ nc4_var_list_add2(NC_GRP_INFO_T *grp, const char *name, NC_VAR_INFO_T **var) int nc4_var_set_ndims(NC_VAR_INFO_T *var, int ndims) { - assert(var); + assert(var); - /* Remember the number of dimensions. */ - var->ndims = ndims; + /* Remember the number of dimensions. */ + var->ndims = ndims; - /* Allocate space for dimension information. */ - if (ndims) - { - if (!(var->dim = calloc(ndims, sizeof(NC_DIM_INFO_T *)))) - return NC_ENOMEM; - if (!(var->dimids = calloc(ndims, sizeof(int)))) - return NC_ENOMEM; + /* Allocate space for dimension information. */ + if (ndims) + { + if (!(var->dim = calloc(ndims, sizeof(NC_DIM_INFO_T *)))) + return NC_ENOMEM; + if (!(var->dimids = calloc(ndims, sizeof(int)))) + return NC_ENOMEM; - /* Initialize dimids to illegal values (-1). See the comment - in nc4_rec_match_dimscales(). */ - memset(var->dimids, -1, ndims * sizeof(int)); - } + /* Initialize dimids to illegal values (-1). See the comment + in nc4_rec_match_dimscales(). */ + memset(var->dimids, -1, ndims * sizeof(int)); + } - return NC_NOERR; + return NC_NOERR; } /** @@ -592,14 +592,14 @@ int nc4_var_list_add(NC_GRP_INFO_T* grp, const char* name, int ndims, NC_VAR_INFO_T **var) { - int retval; + int retval; - if ((retval = nc4_var_list_add2(grp, name, var))) - return retval; - if ((retval = nc4_var_set_ndims(*var, ndims))) - return retval; + if ((retval = nc4_var_list_add2(grp, name, var))) + return retval; + if ((retval = nc4_var_set_ndims(*var, ndims))) + return retval; - return NC_NOERR; + return NC_NOERR; } /** @@ -619,45 +619,45 @@ int nc4_dim_list_add(NC_GRP_INFO_T *grp, const char *name, size_t len, int assignedid, NC_DIM_INFO_T **dim) { - NC_DIM_INFO_T *new_dim; + NC_DIM_INFO_T *new_dim; - assert(grp && name); + assert(grp && name); - /* Allocate memory for dim metadata. */ - if (!(new_dim = calloc(1, sizeof(NC_DIM_INFO_T)))) - return NC_ENOMEM; + /* Allocate memory for dim metadata. */ + if (!(new_dim = calloc(1, sizeof(NC_DIM_INFO_T)))) + return NC_ENOMEM; - new_dim->hdr.sort = NCDIM; + new_dim->hdr.sort = NCDIM; - /* Assign the dimension ID. */ - if (assignedid >= 0) - new_dim->hdr.id = assignedid; - else - new_dim->hdr.id = grp->nc4_info->next_dimid++; + /* Assign the dimension ID. */ + if (assignedid >= 0) + new_dim->hdr.id = assignedid; + else + new_dim->hdr.id = grp->nc4_info->next_dimid++; - /* Remember the name and create a hash. */ - if (!(new_dim->hdr.name = strdup(name))) - return NC_ENOMEM; - new_dim->hdr.hashkey = NC_hashmapkey(new_dim->hdr.name, - strlen(new_dim->hdr.name)); + /* Remember the name and create a hash. */ + if (!(new_dim->hdr.name = strdup(name))) + return NC_ENOMEM; + new_dim->hdr.hashkey = NC_hashmapkey(new_dim->hdr.name, + strlen(new_dim->hdr.name)); - /* Is dimension unlimited? */ - new_dim->len = len; - if (len == NC_UNLIMITED) - new_dim->unlimited = NC_TRUE; + /* Is dimension unlimited? */ + new_dim->len = len; + if (len == NC_UNLIMITED) + new_dim->unlimited = NC_TRUE; - /* Remember the containing group. */ - new_dim->container = grp; + /* Remember the containing group. */ + new_dim->container = grp; - /* Add object to dimension list for this group. */ - ncindexadd(grp->dim, (NC_OBJ *)new_dim); - obj_track(grp->nc4_info, (NC_OBJ *)new_dim); + /* Add object to dimension list for this group. */ + ncindexadd(grp->dim, (NC_OBJ *)new_dim); + obj_track(grp->nc4_info, (NC_OBJ *)new_dim); - /* Set the dim pointer, if one was given */ - if (dim) - *dim = new_dim; + /* Set the dim pointer, if one was given */ + if (dim) + *dim = new_dim; - return NC_NOERR; + return NC_NOERR; } /** @@ -675,30 +675,30 @@ nc4_dim_list_add(NC_GRP_INFO_T *grp, const char *name, size_t len, int nc4_att_list_add(NCindex *list, const char *name, NC_ATT_INFO_T **att) { - NC_ATT_INFO_T *new_att; + NC_ATT_INFO_T *new_att; - LOG((3, "%s: name %s ", __func__, name)); + LOG((3, "%s: name %s ", __func__, name)); - if (!(new_att = calloc(1, sizeof(NC_ATT_INFO_T)))) - return NC_ENOMEM; - new_att->hdr.sort = NCATT; + if (!(new_att = calloc(1, sizeof(NC_ATT_INFO_T)))) + return NC_ENOMEM; + new_att->hdr.sort = NCATT; - /* Fill in the information we know. */ - new_att->hdr.id = ncindexsize(list); - if (!(new_att->hdr.name = strdup(name))) - return NC_ENOMEM; + /* Fill in the information we know. */ + new_att->hdr.id = ncindexsize(list); + if (!(new_att->hdr.name = strdup(name))) + return NC_ENOMEM; - /* Create a hash of the name. */ - new_att->hdr.hashkey = NC_hashmapkey(name, strlen(name)); + /* Create a hash of the name. */ + new_att->hdr.hashkey = NC_hashmapkey(name, strlen(name)); - /* Add object to list as specified by its number */ - ncindexadd(list, (NC_OBJ *)new_att); + /* Add object to list as specified by its number */ + ncindexadd(list, (NC_OBJ *)new_att); - /* Set the attribute pointer, if one was given */ - if (att) - *att = new_att; + /* Set the attribute pointer, if one was given */ + if (att) + *att = new_att; - return NC_NOERR; + return NC_NOERR; } /** @@ -719,51 +719,51 @@ int nc4_grp_list_add(NC_FILE_INFO_T *h5, NC_GRP_INFO_T *parent, char *name, NC_GRP_INFO_T **grp) { - NC_GRP_INFO_T *new_grp; + NC_GRP_INFO_T *new_grp; - /* Check inputs. */ - assert(h5 && name); - LOG((3, "%s: name %s ", __func__, name)); + /* Check inputs. */ + assert(h5 && name); + LOG((3, "%s: name %s ", __func__, name)); - /* Get the memory to store this groups info. */ - if (!(new_grp = calloc(1, sizeof(NC_GRP_INFO_T)))) - return NC_ENOMEM; + /* Get the memory to store this groups info. */ + if (!(new_grp = calloc(1, sizeof(NC_GRP_INFO_T)))) + return NC_ENOMEM; - /* Fill in this group's information. */ - new_grp->hdr.sort = NCGRP; - new_grp->nc4_info = h5; - new_grp->parent = parent; + /* Fill in this group's information. */ + new_grp->hdr.sort = NCGRP; + new_grp->nc4_info = h5; + new_grp->parent = parent; - /* Assign the group ID. The root group will get id 0. */ - new_grp->hdr.id = h5->next_nc_grpid++; - assert(parent || !new_grp->hdr.id); + /* Assign the group ID. The root group will get id 0. */ + new_grp->hdr.id = h5->next_nc_grpid++; + assert(parent || !new_grp->hdr.id); - /* Handle the group name. */ - if (!(new_grp->hdr.name = strdup(name))) - { - free(new_grp); - return NC_ENOMEM; - } - new_grp->hdr.hashkey = NC_hashmapkey(new_grp->hdr.name, - strlen(new_grp->hdr.name)); + /* Handle the group name. */ + if (!(new_grp->hdr.name = strdup(name))) + { + free(new_grp); + return NC_ENOMEM; + } + new_grp->hdr.hashkey = NC_hashmapkey(new_grp->hdr.name, + strlen(new_grp->hdr.name)); - /* Set up new indexed lists for stuff this group can contain. */ - new_grp->children = ncindexnew(0); - new_grp->dim = ncindexnew(0); - new_grp->att = ncindexnew(0); - new_grp->type = ncindexnew(0); - new_grp->vars = ncindexnew(0); + /* Set up new indexed lists for stuff this group can contain. */ + new_grp->children = ncindexnew(0); + new_grp->dim = ncindexnew(0); + new_grp->att = ncindexnew(0); + new_grp->type = ncindexnew(0); + new_grp->vars = ncindexnew(0); - /* Add object to lists */ - if (parent) - ncindexadd(parent->children, (NC_OBJ *)new_grp); - obj_track(h5, (NC_OBJ *)new_grp); + /* Add object to lists */ + if (parent) + ncindexadd(parent->children, (NC_OBJ *)new_grp); + obj_track(h5, (NC_OBJ *)new_grp); - /* Set the group pointer, if one was given */ - if (grp) - *grp = new_grp; + /* Set the group pointer, if one was given */ + if (grp) + *grp = new_grp; - return NC_NOERR; + return NC_NOERR; } /** @@ -782,26 +782,26 @@ nc4_grp_list_add(NC_FILE_INFO_T *h5, NC_GRP_INFO_T *parent, char *name, int nc4_check_dup_name(NC_GRP_INFO_T *grp, char *name) { - NC_TYPE_INFO_T *type; - NC_GRP_INFO_T *g; - NC_VAR_INFO_T *var; + NC_TYPE_INFO_T *type; + NC_GRP_INFO_T *g; + NC_VAR_INFO_T *var; - /* Any types of this name? */ - type = (NC_TYPE_INFO_T*)ncindexlookup(grp->type,name); - if(type != NULL) - return NC_ENAMEINUSE; + /* Any types of this name? */ + type = (NC_TYPE_INFO_T*)ncindexlookup(grp->type,name); + if(type != NULL) + return NC_ENAMEINUSE; - /* Any child groups of this name? */ - g = (NC_GRP_INFO_T*)ncindexlookup(grp->children,name); - if(g != NULL) - return NC_ENAMEINUSE; + /* Any child groups of this name? */ + g = (NC_GRP_INFO_T*)ncindexlookup(grp->children,name); + if(g != NULL) + return NC_ENAMEINUSE; - /* Any variables of this name? */ - var = (NC_VAR_INFO_T*)ncindexlookup(grp->vars,name); - if(var != NULL) - return NC_ENAMEINUSE; + /* Any variables of this name? */ + var = (NC_VAR_INFO_T*)ncindexlookup(grp->vars,name); + if(var != NULL) + return NC_ENAMEINUSE; - return NC_NOERR; + return NC_NOERR; } /** @@ -821,32 +821,32 @@ int nc4_type_new(size_t size, const char *name, int assignedid, NC_TYPE_INFO_T **type) { - NC_TYPE_INFO_T *new_type; + NC_TYPE_INFO_T *new_type; - LOG((4, "%s: size %d name %s assignedid %d", __func__, size, name, assignedid)); + LOG((4, "%s: size %d name %s assignedid %d", __func__, size, name, assignedid)); - /* Check inputs. */ - assert(type); + /* Check inputs. */ + assert(type); - /* Allocate memory for the type */ - if (!(new_type = calloc(1, sizeof(NC_TYPE_INFO_T)))) - return NC_ENOMEM; - new_type->hdr.sort = NCTYP; + /* Allocate memory for the type */ + if (!(new_type = calloc(1, sizeof(NC_TYPE_INFO_T)))) + return NC_ENOMEM; + new_type->hdr.sort = NCTYP; - /* Remember info about this type. */ - new_type->hdr.id = assignedid; - new_type->size = size; - if (!(new_type->hdr.name = strdup(name))) { - free(new_type); - return NC_ENOMEM; - } + /* Remember info about this type. */ + new_type->hdr.id = assignedid; + new_type->size = size; + if (!(new_type->hdr.name = strdup(name))) { + free(new_type); + return NC_ENOMEM; + } - new_type->hdr.hashkey = NC_hashmapkey(name, strlen(name)); + new_type->hdr.hashkey = NC_hashmapkey(name, strlen(name)); - /* Return a pointer to the new type. */ - *type = new_type; + /* Return a pointer to the new type. */ + *type = new_type; - return NC_NOERR; + return NC_NOERR; } /** @@ -866,30 +866,30 @@ int nc4_type_list_add(NC_GRP_INFO_T *grp, size_t size, const char *name, NC_TYPE_INFO_T **type) { - NC_TYPE_INFO_T *new_type; - int retval; + NC_TYPE_INFO_T *new_type; + int retval; - /* Check inputs. */ - assert(grp && name && type); - LOG((4, "%s: size %d name %s", __func__, size, name)); + /* Check inputs. */ + assert(grp && name && type); + LOG((4, "%s: size %d name %s", __func__, size, name)); - /* Create the new TYPE_INFO struct. */ - if ((retval = nc4_type_new(size, name, grp->nc4_info->next_typeid, - &new_type))) - return retval; - grp->nc4_info->next_typeid++; + /* Create the new TYPE_INFO struct. */ + if ((retval = nc4_type_new(size, name, grp->nc4_info->next_typeid, + &new_type))) + return retval; + grp->nc4_info->next_typeid++; - /* Increment the ref. count on the type */ - new_type->rc++; + /* Increment the ref. count on the type */ + new_type->rc++; - /* Add object to lists */ - ncindexadd(grp->type, (NC_OBJ *)new_type); - obj_track(grp->nc4_info,(NC_OBJ*)new_type); + /* Add object to lists */ + ncindexadd(grp->type, (NC_OBJ *)new_type); + obj_track(grp->nc4_info,(NC_OBJ*)new_type); - /* Return a pointer to the new type. */ - *type = new_type; + /* Return a pointer to the new type. */ + *type = new_type; - return NC_NOERR; + return NC_NOERR; } /** @@ -910,45 +910,45 @@ nc4_field_list_add(NC_TYPE_INFO_T *parent, const char *name, size_t offset, nc_type xtype, int ndims, const int *dim_sizesp) { - NC_FIELD_INFO_T *field; + NC_FIELD_INFO_T *field; - /* Name has already been checked and UTF8 normalized. */ - if (!name) - return NC_EINVAL; + /* Name has already been checked and UTF8 normalized. */ + if (!name) + return NC_EINVAL; - /* Allocate storage for this field information. */ - if (!(field = calloc(1, sizeof(NC_FIELD_INFO_T)))) - return NC_ENOMEM; - field->hdr.sort = NCFLD; + /* Allocate storage for this field information. */ + if (!(field = calloc(1, sizeof(NC_FIELD_INFO_T)))) + return NC_ENOMEM; + field->hdr.sort = NCFLD; - /* Store the information about this field. */ - if (!(field->hdr.name = strdup(name))) - { - free(field); - return NC_ENOMEM; - } - field->hdr.hashkey = NC_hashmapkey(field->hdr.name,strlen(field->hdr.name)); - field->nc_typeid = xtype; - field->offset = offset; - field->ndims = ndims; - if (ndims) - { - int i; - if (!(field->dim_size = malloc(ndims * sizeof(int)))) - { - free(field->hdr.name); - free(field); - return NC_ENOMEM; - } - for (i = 0; i < ndims; i++) - field->dim_size[i] = dim_sizesp[i]; - } + /* Store the information about this field. */ + if (!(field->hdr.name = strdup(name))) + { + free(field); + return NC_ENOMEM; + } + field->hdr.hashkey = NC_hashmapkey(field->hdr.name,strlen(field->hdr.name)); + field->nc_typeid = xtype; + field->offset = offset; + field->ndims = ndims; + if (ndims) + { + int i; + if (!(field->dim_size = malloc(ndims * sizeof(int)))) + { + free(field->hdr.name); + free(field); + return NC_ENOMEM; + } + for (i = 0; i < ndims; i++) + field->dim_size[i] = dim_sizesp[i]; + } - /* Add object to lists */ - field->hdr.id = nclistlength(parent->u.c.field); - nclistpush(parent->u.c.field,field); + /* Add object to lists */ + field->hdr.id = nclistlength(parent->u.c.field); + nclistpush(parent->u.c.field,field); - return NC_NOERR; + return NC_NOERR; } /** @@ -967,32 +967,32 @@ int nc4_enum_member_add(NC_TYPE_INFO_T *parent, size_t size, const char *name, const void *value) { - NC_ENUM_MEMBER_INFO_T *member; + NC_ENUM_MEMBER_INFO_T *member; - /* Name has already been checked. */ - assert(name && size > 0 && value); - LOG((4, "%s: size %d name %s", __func__, size, name)); + /* Name has already been checked. */ + assert(name && size > 0 && value); + LOG((4, "%s: size %d name %s", __func__, size, name)); - /* Allocate storage for this field information. */ - if (!(member = calloc(1, sizeof(NC_ENUM_MEMBER_INFO_T)))) - return NC_ENOMEM; - if (!(member->value = malloc(size))) { - free(member); - return NC_ENOMEM; - } - if (!(member->name = strdup(name))) { - free(member->value); - free(member); - return NC_ENOMEM; - } + /* Allocate storage for this field information. */ + if (!(member = calloc(1, sizeof(NC_ENUM_MEMBER_INFO_T)))) + return NC_ENOMEM; + if (!(member->value = malloc(size))) { + free(member); + return NC_ENOMEM; + } + if (!(member->name = strdup(name))) { + free(member->value); + free(member); + return NC_ENOMEM; + } - /* Store the value for this member. */ - memcpy(member->value, value, size); + /* Store the value for this member. */ + memcpy(member->value, value, size); - /* Add object to list */ - nclistpush(parent->u.e.enum_member,member); + /* Add object to list */ + nclistpush(parent->u.e.enum_member,member); - return NC_NOERR; + return NC_NOERR; } /** @@ -1006,14 +1006,14 @@ nc4_enum_member_add(NC_TYPE_INFO_T *parent, size_t size, static void field_free(NC_FIELD_INFO_T *field) { - /* Free some stuff. */ - if (field->hdr.name) - free(field->hdr.name); - if (field->dim_size) - free(field->dim_size); + /* Free some stuff. */ + if (field->hdr.name) + free(field->hdr.name); + if (field->dim_size) + free(field->dim_size); - /* Nc_Free the memory. */ - free(field); + /* Nc_Free the memory. */ + free(field); } /** @@ -1028,66 +1028,66 @@ field_free(NC_FIELD_INFO_T *field) int nc4_type_free(NC_TYPE_INFO_T *type) { - int i; + int i; - assert(type && type->rc && type->hdr.name); + assert(type && type->rc && type->hdr.name); - /* Decrement the ref. count on the type */ - type->rc--; + /* Decrement the ref. count on the type */ + type->rc--; - /* Release the type, if the ref. count drops to zero */ - if (type->rc == 0) - { - LOG((4, "%s: deleting type %s", __func__, type->hdr.name)); + /* Release the type, if the ref. count drops to zero */ + if (type->rc == 0) + { + LOG((4, "%s: deleting type %s", __func__, type->hdr.name)); - /* Free the name. */ - free(type->hdr.name); + /* Free the name. */ + free(type->hdr.name); - /* Enums and compound types have lists of fields to clean up. */ - switch (type->nc_type_class) - { - case NC_COMPOUND: - { - NC_FIELD_INFO_T *field; + /* Enums and compound types have lists of fields to clean up. */ + switch (type->nc_type_class) + { + case NC_COMPOUND: + { + NC_FIELD_INFO_T *field; - /* Delete all the fields in this type (there will be some if its a - * compound). */ - for(i=0;iu.c.field);i++) { - field = nclistget(type->u.c.field,i); - field_free(field); - } - nclistfree(type->u.c.field); - } - break; + /* Delete all the fields in this type (there will be some if its a + * compound). */ + for(i=0;iu.c.field);i++) { + field = nclistget(type->u.c.field,i); + field_free(field); + } + nclistfree(type->u.c.field); + } + break; - case NC_ENUM: - { - NC_ENUM_MEMBER_INFO_T *enum_member; + case NC_ENUM: + { + NC_ENUM_MEMBER_INFO_T *enum_member; - /* Delete all the enum_members, if any. */ - for(i=0;iu.e.enum_member);i++) { - enum_member = nclistget(type->u.e.enum_member,i); - free(enum_member->value); - free(enum_member->name); - free(enum_member); - } - nclistfree(type->u.e.enum_member); - } - break; + /* Delete all the enum_members, if any. */ + for(i=0;iu.e.enum_member);i++) { + enum_member = nclistget(type->u.e.enum_member,i); + free(enum_member->value); + free(enum_member->name); + free(enum_member); + } + nclistfree(type->u.e.enum_member); + } + break; - default: - break; - } + default: + break; + } - /* Release any HDF5-specific type info. */ - if (type->format_type_info) - free(type->format_type_info); + /* Release any HDF5-specific type info. */ + if (type->format_type_info) + free(type->format_type_info); - /* Release the memory. */ - free(type); - } + /* Release the memory. */ + free(type); + } - return NC_NOERR; + return NC_NOERR; } /** @@ -1101,49 +1101,49 @@ nc4_type_free(NC_TYPE_INFO_T *type) static int att_free(NC_ATT_INFO_T *att) { - int i; + int i; - assert(att); - LOG((3, "%s: name %s ", __func__, att->hdr.name)); + assert(att); + LOG((3, "%s: name %s ", __func__, att->hdr.name)); - /* Free memory that was malloced to hold data for this - * attribute. */ - if (att->data) - free(att->data); + /* Free memory that was malloced to hold data for this + * attribute. */ + if (att->data) + free(att->data); - /* Free the name. */ - if (att->hdr.name) - free(att->hdr.name); + /* Free the name. */ + if (att->hdr.name) + free(att->hdr.name); - /* If this is a string array attribute, delete all members of the - * string array, then delete the array of pointers to strings. (The - * array was filled with pointers by HDF5 when the att was read, - * and memory for each string was allocated by HDF5. That's why I - * use free and not nc_free, because the netCDF library didn't - * allocate the memory that is being freed.) */ - if (att->stdata) - { - for (i = 0; i < att->len; i++) - if(att->stdata[i]) - free(att->stdata[i]); - free(att->stdata); - } + /* If this is a string array attribute, delete all members of the + * string array, then delete the array of pointers to strings. (The + * array was filled with pointers by HDF5 when the att was read, + * and memory for each string was allocated by HDF5. That's why I + * use free and not nc_free, because the netCDF library didn't + * allocate the memory that is being freed.) */ + if (att->stdata) + { + for (i = 0; i < att->len; i++) + if(att->stdata[i]) + free(att->stdata[i]); + free(att->stdata); + } - /* If this att has vlen data, release it. */ - if (att->vldata) - { - for (i = 0; i < att->len; i++) - nc_free_vlen(&att->vldata[i]); - free(att->vldata); - } + /* If this att has vlen data, release it. */ + if (att->vldata) + { + for (i = 0; i < att->len; i++) + nc_free_vlen(&att->vldata[i]); + free(att->vldata); + } - /* Free any format-sepecific info. Some formats use this (ex. HDF5) - * and some don't (ex. HDF4). So it may be NULL. */ - if (att->format_att_info) - free(att->format_att_info); + /* Free any format-sepecific info. Some formats use this (ex. HDF5) + * and some don't (ex. HDF4). So it may be NULL. */ + if (att->format_att_info) + free(att->format_att_info); - free(att); - return NC_NOERR; + free(att); + return NC_NOERR; } /** @@ -1158,59 +1158,59 @@ att_free(NC_ATT_INFO_T *att) static int var_free(NC_VAR_INFO_T *var) { - int i; - int retval; + int i; + int retval; - assert(var); - LOG((4, "%s: deleting var %s", __func__, var->hdr.name)); + assert(var); + LOG((4, "%s: deleting var %s", __func__, var->hdr.name)); - /* First delete all the attributes attached to this var. */ - for (i = 0; i < ncindexsize(var->att); i++) - if ((retval = att_free((NC_ATT_INFO_T *)ncindexith(var->att, i)))) - return retval; - ncindexfree(var->att); + /* First delete all the attributes attached to this var. */ + for (i = 0; i < ncindexsize(var->att); i++) + if ((retval = att_free((NC_ATT_INFO_T *)ncindexith(var->att, i)))) + return retval; + ncindexfree(var->att); - /* Free some things that may be allocated. */ - if (var->chunksizes) - free(var->chunksizes); + /* Free some things that may be allocated. */ + if (var->chunksizes) + free(var->chunksizes); - if (var->hdf5_name) - free(var->hdf5_name); + if (var->hdf5_name) + free(var->hdf5_name); - if (var->hdr.name) - free(var->hdr.name); + if (var->hdr.name) + free(var->hdr.name); - if (var->dimids) - free(var->dimids); + if (var->dimids) + free(var->dimids); - if (var->dim) - free(var->dim); + if (var->dim) + free(var->dim); - /* Delete any fill value allocation. */ - if (var->fill_value) - free(var->fill_value); + /* Delete any fill value allocation. */ + if (var->fill_value) + free(var->fill_value); - /* Release type information */ - if (var->type_info) - if ((retval = nc4_type_free(var->type_info))) - return retval; + /* Release type information */ + if (var->type_info) + if ((retval = nc4_type_free(var->type_info))) + return retval; - /* Delete information about the attachment status of dimscales. */ - if (var->dimscale_attached) - free(var->dimscale_attached); + /* Delete information about the attachment status of dimscales. */ + if (var->dimscale_attached) + free(var->dimscale_attached); - /* Release parameter information. */ - if (var->params) - free(var->params); + /* Release parameter information. */ + if (var->params) + free(var->params); - /* Delete any format-specific info. */ - if (var->format_var_info) - free(var->format_var_info); + /* Delete any format-specific info. */ + if (var->format_var_info) + free(var->format_var_info); - /* Delete the var. */ - free(var); + /* Delete the var. */ + free(var); - return NC_NOERR; + return NC_NOERR; } /** @@ -1225,16 +1225,16 @@ var_free(NC_VAR_INFO_T *var) int nc4_var_list_del(NC_GRP_INFO_T *grp, NC_VAR_INFO_T *var) { - int i; + int i; - assert(var && grp); + assert(var && grp); - /* Remove from lists */ - i = ncindexfind(grp->vars, (NC_OBJ *)var); - if (i >= 0) - ncindexidel(grp->vars, i); + /* Remove from lists */ + i = ncindexfind(grp->vars, (NC_OBJ *)var); + if (i >= 0) + ncindexidel(grp->vars, i); - return var_free(var); + return var_free(var); } /** @@ -1248,19 +1248,19 @@ nc4_var_list_del(NC_GRP_INFO_T *grp, NC_VAR_INFO_T *var) static int dim_free(NC_DIM_INFO_T *dim) { - assert(dim); - LOG((4, "%s: deleting dim %s", __func__, dim->hdr.name)); + assert(dim); + LOG((4, "%s: deleting dim %s", __func__, dim->hdr.name)); - /* Free memory allocated for names. */ - if (dim->hdr.name) - free(dim->hdr.name); + /* Free memory allocated for names. */ + if (dim->hdr.name) + free(dim->hdr.name); - /* Release any format-specific information. */ - if (dim->format_dim_info) - free(dim->format_dim_info); + /* Release any format-specific information. */ + if (dim->format_dim_info) + free(dim->format_dim_info); - free(dim); - return NC_NOERR; + free(dim); + return NC_NOERR; } /** @@ -1275,12 +1275,12 @@ dim_free(NC_DIM_INFO_T *dim) int nc4_dim_list_del(NC_GRP_INFO_T* grp, NC_DIM_INFO_T *dim) { - if(grp && dim) { - int pos = ncindexfind(grp->dim,(NC_OBJ*)dim); - if(pos >= 0) - ncindexidel(grp->dim,pos); - } - return dim_free(dim); + if(grp && dim) { + int pos = ncindexfind(grp->dim,(NC_OBJ*)dim); + if(pos >= 0) + ncindexidel(grp->dim,pos); + } + return dim_free(dim); } /** @@ -1295,55 +1295,55 @@ nc4_dim_list_del(NC_GRP_INFO_T* grp, NC_DIM_INFO_T *dim) int nc4_rec_grp_del(NC_GRP_INFO_T *grp) { - int i; - int retval; + int i; + int retval; - assert(grp); - LOG((3, "%s: grp->name %s", __func__, grp->hdr.name)); + assert(grp); + LOG((3, "%s: grp->name %s", __func__, grp->hdr.name)); - /* Recursively call this function for each child, if any, stopping - * if there is an error. */ - for (i = 0; i < ncindexsize(grp->children); i++) - if ((retval = nc4_rec_grp_del((NC_GRP_INFO_T *)ncindexith(grp->children, - i)))) - return retval; - ncindexfree(grp->children); + /* Recursively call this function for each child, if any, stopping + * if there is an error. */ + for (i = 0; i < ncindexsize(grp->children); i++) + if ((retval = nc4_rec_grp_del((NC_GRP_INFO_T *)ncindexith(grp->children, + i)))) + return retval; + ncindexfree(grp->children); - /* Free attributes, but leave in parent list */ - for (i = 0; i < ncindexsize(grp->att); i++) - if ((retval = att_free((NC_ATT_INFO_T *)ncindexith(grp->att, i)))) - return retval; - ncindexfree(grp->att); + /* Free attributes, but leave in parent list */ + for (i = 0; i < ncindexsize(grp->att); i++) + if ((retval = att_free((NC_ATT_INFO_T *)ncindexith(grp->att, i)))) + return retval; + ncindexfree(grp->att); - /* Delete all vars. */ - for (i = 0; i < ncindexsize(grp->vars); i++) - if ((retval = var_free((NC_VAR_INFO_T *)ncindexith(grp->vars, i)))) - return retval; - ncindexfree(grp->vars); + /* Delete all vars. */ + for (i = 0; i < ncindexsize(grp->vars); i++) + if ((retval = var_free((NC_VAR_INFO_T *)ncindexith(grp->vars, i)))) + return retval; + ncindexfree(grp->vars); - /* Delete all dims, and free the list of dims. */ - for (i = 0; i < ncindexsize(grp->dim); i++) - if ((retval = dim_free((NC_DIM_INFO_T *)ncindexith(grp->dim, i)))) - return retval; - ncindexfree(grp->dim); + /* Delete all dims, and free the list of dims. */ + for (i = 0; i < ncindexsize(grp->dim); i++) + if ((retval = dim_free((NC_DIM_INFO_T *)ncindexith(grp->dim, i)))) + return retval; + ncindexfree(grp->dim); - /* Delete all types. */ - for (i = 0; i < ncindexsize(grp->type); i++) - if ((retval = nc4_type_free((NC_TYPE_INFO_T *)ncindexith(grp->type, i)))) - return retval; - ncindexfree(grp->type); + /* Delete all types. */ + for (i = 0; i < ncindexsize(grp->type); i++) + if ((retval = nc4_type_free((NC_TYPE_INFO_T *)ncindexith(grp->type, i)))) + return retval; + ncindexfree(grp->type); - /* Free the name. */ - free(grp->hdr.name); + /* Free the name. */ + free(grp->hdr.name); - /* Release any format-specific information about this group. */ - if (grp->format_grp_info) - free(grp->format_grp_info); + /* Release any format-specific information about this group. */ + if (grp->format_grp_info) + free(grp->format_grp_info); - /* Free up this group */ - free(grp); + /* Free up this group */ + free(grp); - return NC_NOERR; + return NC_NOERR; } /** @@ -1359,9 +1359,9 @@ nc4_rec_grp_del(NC_GRP_INFO_T *grp) int nc4_att_list_del(NCindex *list, NC_ATT_INFO_T *att) { - assert(att && list); - ncindexidel(list, ((NC_OBJ *)att)->id); - return att_free(att); + assert(att && list); + ncindexidel(list, ((NC_OBJ *)att)->id); + return att_free(att); } /** @@ -1380,18 +1380,18 @@ nc4_att_list_del(NCindex *list, NC_ATT_INFO_T *att) int nc4_normalize_name(const char *name, char *norm_name) { - char *temp_name; - int stat = nc_utf8_normalize((const unsigned char *)name,(unsigned char **)&temp_name); - if(stat != NC_NOERR) - return stat; - if (strlen(temp_name) > NC_MAX_NAME) - { - free(temp_name); - return NC_EMAXNAME; - } - strcpy(norm_name, temp_name); - free(temp_name); - return NC_NOERR; + char *temp_name; + int stat = nc_utf8_normalize((const unsigned char *)name,(unsigned char **)&temp_name); + if(stat != NC_NOERR) + return stat; + if (strlen(temp_name) > NC_MAX_NAME) + { + free(temp_name); + return NC_EMAXNAME; + } + strcpy(norm_name, temp_name); + free(temp_name); + return NC_NOERR; } #ifdef ENABLE_SET_LOG_LEVEL @@ -1414,11 +1414,11 @@ int nc_set_log_level(int new_level) { #ifdef LOGGING - /* Remember the new level. */ - nc_log_level = new_level; - LOG((4, "log_level changed to %d", nc_log_level)); + /* Remember the new level. */ + nc_log_level = new_level; + LOG((4, "log_level changed to %d", nc_log_level)); #endif /*LOGGING */ - return 0; + return 0; } #endif /* ENABLE_SET_LOG_LEVEL */ @@ -1436,114 +1436,114 @@ nc_set_log_level(int new_level) static int rec_print_metadata(NC_GRP_INFO_T *grp, int tab_count) { - NC_ATT_INFO_T *att; - NC_VAR_INFO_T *var; - NC_DIM_INFO_T *dim; - NC_TYPE_INFO_T *type; - NC_FIELD_INFO_T *field; - char tabs[MAX_NESTS+1] = ""; - char *dims_string = NULL; - char temp_string[10]; - int t, retval, d, i; + NC_ATT_INFO_T *att; + NC_VAR_INFO_T *var; + NC_DIM_INFO_T *dim; + NC_TYPE_INFO_T *type; + NC_FIELD_INFO_T *field; + char tabs[MAX_NESTS+1] = ""; + char *dims_string = NULL; + char temp_string[10]; + int t, retval, d, i; - /* Come up with a number of tabs relative to the group. */ - for (t = 0; t < tab_count && t < MAX_NESTS; t++) - tabs[t] = '\t'; - tabs[t] = '\0'; + /* Come up with a number of tabs relative to the group. */ + for (t = 0; t < tab_count && t < MAX_NESTS; t++) + tabs[t] = '\t'; + tabs[t] = '\0'; - LOG((2, "%s GROUP - %s nc_grpid: %d nvars: %d natts: %d", - tabs, grp->hdr.name, grp->hdr.id, ncindexsize(grp->vars), ncindexsize(grp->att))); + LOG((2, "%s GROUP - %s nc_grpid: %d nvars: %d natts: %d", + tabs, grp->hdr.name, grp->hdr.id, ncindexsize(grp->vars), ncindexsize(grp->att))); - for (i = 0; i < ncindexsize(grp->att); i++) - { - att = (NC_ATT_INFO_T *)ncindexith(grp->att, i); - assert(att); - LOG((2, "%s GROUP ATTRIBUTE - attnum: %d name: %s type: %d len: %d", - tabs, att->hdr.id, att->hdr.name, att->nc_typeid, att->len)); - } + for (i = 0; i < ncindexsize(grp->att); i++) + { + att = (NC_ATT_INFO_T *)ncindexith(grp->att, i); + assert(att); + LOG((2, "%s GROUP ATTRIBUTE - attnum: %d name: %s type: %d len: %d", + tabs, att->hdr.id, att->hdr.name, att->nc_typeid, att->len)); + } - for (i = 0; i < ncindexsize(grp->dim); i++) - { - dim = (NC_DIM_INFO_T *)ncindexith(grp->dim, i); - assert(dim); - LOG((2, "%s DIMENSION - dimid: %d name: %s len: %d unlimited: %d", - tabs, dim->hdr.id, dim->hdr.name, dim->len, dim->unlimited)); - } + for (i = 0; i < ncindexsize(grp->dim); i++) + { + dim = (NC_DIM_INFO_T *)ncindexith(grp->dim, i); + assert(dim); + LOG((2, "%s DIMENSION - dimid: %d name: %s len: %d unlimited: %d", + tabs, dim->hdr.id, dim->hdr.name, dim->len, dim->unlimited)); + } - for (i = 0; i < ncindexsize(grp->vars); i++) - { - int j; - var = (NC_VAR_INFO_T*)ncindexith(grp->vars,i); - assert(var); - if (var->ndims > 0) - { - if (!(dims_string = malloc(sizeof(char) * var->ndims * 4))) - return NC_ENOMEM; - strcpy(dims_string, ""); - for (d = 0; d < var->ndims; d++) - { - sprintf(temp_string, " %d", var->dimids[d]); - strcat(dims_string, temp_string); - } - } - LOG((2, "%s VARIABLE - varid: %d name: %s ndims: %d dimscale: %d dimids:%s", - tabs, var->hdr.id, var->hdr.name, var->ndims, (int)var->dimscale, - (dims_string ? dims_string : " -"))); - for (j = 0; j < ncindexsize(var->att); j++) - { - att = (NC_ATT_INFO_T *)ncindexith(var->att, j); - assert(att); - LOG((2, "%s VAR ATTRIBUTE - attnum: %d name: %s type: %d len: %d", - tabs, att->hdr.id, att->hdr.name, att->nc_typeid, att->len)); - } - if (dims_string) - free(dims_string); - } + for (i = 0; i < ncindexsize(grp->vars); i++) + { + int j; + var = (NC_VAR_INFO_T*)ncindexith(grp->vars,i); + assert(var); + if (var->ndims > 0) + { + if (!(dims_string = malloc(sizeof(char) * var->ndims * 4))) + return NC_ENOMEM; + strcpy(dims_string, ""); + for (d = 0; d < var->ndims; d++) + { + sprintf(temp_string, " %d", var->dimids[d]); + strcat(dims_string, temp_string); + } + } + LOG((2, "%s VARIABLE - varid: %d name: %s ndims: %d dimscale: %d dimids:%s", + tabs, var->hdr.id, var->hdr.name, var->ndims, (int)var->dimscale, + (dims_string ? dims_string : " -"))); + for (j = 0; j < ncindexsize(var->att); j++) + { + att = (NC_ATT_INFO_T *)ncindexith(var->att, j); + assert(att); + LOG((2, "%s VAR ATTRIBUTE - attnum: %d name: %s type: %d len: %d", + tabs, att->hdr.id, att->hdr.name, att->nc_typeid, att->len)); + } + if (dims_string) + free(dims_string); + } - for (i = 0; i < ncindexsize(grp->type); i++) - { - type = (NC_TYPE_INFO_T*)ncindexith(grp->type, i); - assert(type); - LOG((2, "%s TYPE - nc_typeid: %d size: %d committed: %d name: %s", - tabs, type->hdr.id, type->size, (int)type->committed, type->hdr.name)); - /* Is this a compound type? */ - if (type->nc_type_class == NC_COMPOUND) - { - int j; - LOG((3, "compound type")); - for (j = 0; j < nclistlength(type->u.c.field); j++) - { - field = (NC_FIELD_INFO_T *)nclistget(type->u.c.field, j); - LOG((4, "field %s offset %d nctype %d ndims %d", field->hdr.name, - field->offset, field->nc_typeid, field->ndims)); - } - } - else if (type->nc_type_class == NC_VLEN) - { - LOG((3, "VLEN type")); - LOG((4, "base_nc_type: %d", type->u.v.base_nc_typeid)); - } - else if (type->nc_type_class == NC_OPAQUE) - LOG((3, "Opaque type")); - else if (type->nc_type_class == NC_ENUM) - { - LOG((3, "Enum type")); - LOG((4, "base_nc_type: %d", type->u.e.base_nc_typeid)); - } - else - { - LOG((0, "Unknown class: %d", type->nc_type_class)); - return NC_EBADTYPE; - } - } + for (i = 0; i < ncindexsize(grp->type); i++) + { + type = (NC_TYPE_INFO_T*)ncindexith(grp->type, i); + assert(type); + LOG((2, "%s TYPE - nc_typeid: %d size: %d committed: %d name: %s", + tabs, type->hdr.id, type->size, (int)type->committed, type->hdr.name)); + /* Is this a compound type? */ + if (type->nc_type_class == NC_COMPOUND) + { + int j; + LOG((3, "compound type")); + for (j = 0; j < nclistlength(type->u.c.field); j++) + { + field = (NC_FIELD_INFO_T *)nclistget(type->u.c.field, j); + LOG((4, "field %s offset %d nctype %d ndims %d", field->hdr.name, + field->offset, field->nc_typeid, field->ndims)); + } + } + else if (type->nc_type_class == NC_VLEN) + { + LOG((3, "VLEN type")); + LOG((4, "base_nc_type: %d", type->u.v.base_nc_typeid)); + } + else if (type->nc_type_class == NC_OPAQUE) + LOG((3, "Opaque type")); + else if (type->nc_type_class == NC_ENUM) + { + LOG((3, "Enum type")); + LOG((4, "base_nc_type: %d", type->u.e.base_nc_typeid)); + } + else + { + LOG((0, "Unknown class: %d", type->nc_type_class)); + return NC_EBADTYPE; + } + } - /* Call self for each child of this group. */ - for (i = 0; i < ncindexsize(grp->children); i++) - if ((retval = rec_print_metadata((NC_GRP_INFO_T *)ncindexith(grp->children, i), - tab_count + 1))) - return retval; + /* Call self for each child of this group. */ + for (i = 0; i < ncindexsize(grp->children); i++) + if ((retval = rec_print_metadata((NC_GRP_INFO_T *)ncindexith(grp->children, i), + tab_count + 1))) + return retval; - return NC_NOERR; + return NC_NOERR; } /** @@ -1559,21 +1559,21 @@ rec_print_metadata(NC_GRP_INFO_T *grp, int tab_count) int log_metadata_nc(NC_FILE_INFO_T *h5) { - LOG((2, "*** NetCDF-4 Internal Metadata: int_ncid 0x%x ext_ncid 0x%x", - h5->root_grp->nc4_info->controller->int_ncid, - h5->root_grp->nc4_info->controller->ext_ncid)); - if (!h5) - { - LOG((2, "This is a netCDF-3 file.")); - return NC_NOERR; - } - LOG((2, "FILE - path: %s cmode: 0x%x parallel: %d redef: %d " - "fill_mode: %d no_write: %d next_nc_grpid: %d", h5->root_grp->nc4_info->controller->path, - h5->cmode, (int)h5->parallel, (int)h5->redef, h5->fill_mode, (int)h5->no_write, - h5->next_nc_grpid)); - if(nc_log_level >= 2) - return rec_print_metadata(h5->root_grp, 0); - return NC_NOERR; + LOG((2, "*** NetCDF-4 Internal Metadata: int_ncid 0x%x ext_ncid 0x%x", + h5->root_grp->nc4_info->controller->int_ncid, + h5->root_grp->nc4_info->controller->ext_ncid)); + if (!h5) + { + LOG((2, "This is a netCDF-3 file.")); + return NC_NOERR; + } + LOG((2, "FILE - path: %s cmode: 0x%x parallel: %d redef: %d " + "fill_mode: %d no_write: %d next_nc_grpid: %d", h5->root_grp->nc4_info->controller->path, + h5->cmode, (int)h5->parallel, (int)h5->redef, h5->fill_mode, (int)h5->no_write, + h5->next_nc_grpid)); + if(nc_log_level >= 2) + return rec_print_metadata(h5->root_grp, 0); + return NC_NOERR; } #endif /*LOGGING */ @@ -1592,19 +1592,19 @@ log_metadata_nc(NC_FILE_INFO_T *h5) int NC4_show_metadata(int ncid) { - int retval = NC_NOERR; + int retval = NC_NOERR; #ifdef LOGGING - NC_FILE_INFO_T *h5; - int old_log_level = nc_log_level; + NC_FILE_INFO_T *h5; + int old_log_level = nc_log_level; - /* Find file metadata. */ - if ((retval = nc4_find_grp_h5(ncid, NULL, &h5))) - return retval; + /* Find file metadata. */ + if ((retval = nc4_find_grp_h5(ncid, NULL, &h5))) + return retval; - /* Log level must be 2 to see metadata. */ - nc_log_level = 2; - retval = log_metadata_nc(h5); - nc_log_level = old_log_level; + /* Log level must be 2 to see metadata. */ + nc_log_level = 2; + retval = log_metadata_nc(h5); + nc_log_level = old_log_level; #endif /*LOGGING*/ - return retval; + return retval; } diff --git a/libsrc4/nc4printer.c b/libsrc4/nc4printer.c index 641eff92b..5c13a20c8 100644 --- a/libsrc4/nc4printer.c +++ b/libsrc4/nc4printer.c @@ -4,9 +4,9 @@ *********************************************************************/ /** -This provides a simple netcdf-4 metadata -> xml printer. -Primarily for use in debugging, but could be adapted to -create other tools. + This provides a simple netcdf-4 metadata -> xml printer. + Primarily for use in debugging, but could be adapted to + create other tools. */ #include "config.h" @@ -24,13 +24,13 @@ create other tools. #define NC_MAX_IDS 8192 typedef enum NCSORT { -GROUP, -VAR, -FIELD, -DIM, -ATTR, -ATOMTYPE, -USERTYPE, + GROUP, + VAR, + FIELD, + DIM, + ATTR, + ATOMTYPE, + USERTYPE, } NCSORT; typedef struct NCID NCID; @@ -57,10 +57,10 @@ struct NCID { struct {int isroot;} group; /*sort == GROUP*/ }; -#define MAKEID(Node,Sort,Parent,Id) \ -NCID* Node = (NCID*)calloc(1,sizeof(NCID)); \ -Node->sort = Sort; Node->parent = Parent; Node->id = Id; \ -track(out,Node); +#define MAKEID(Node,Sort,Parent,Id) \ + NCID* Node = (NCID*)calloc(1,sizeof(NCID)); \ + Node->sort = Sort; Node->parent = Parent; Node->id = Id; \ + track(out,Node); union NUMVALUE { unsigned char i8[8]; @@ -130,7 +130,7 @@ NC4print(NCbytes* buf, int ncid) out->dims = nclistnew(); MAKEID(root,GROUP,NULL,ncid); - root->group.isroot = 1; + root->group.isroot = 1; buildAtomicTypes(out,root); @@ -151,17 +151,17 @@ freeNC4Printer(NC4printer* out) if(out == NULL) return; #ifdef DEBUG -fprintf(stderr,"free: |allnodes=%ld\n",nclistlength(out->allnodes)); -fflush(stderr); + fprintf(stderr,"free: |allnodes=%ld\n",nclistlength(out->allnodes)); + fflush(stderr); #endif for(i=0;iallnodes);i++) { - NCID* node = (NCID*)nclistget(out->allnodes,i); + NCID* node = (NCID*)nclistget(out->allnodes,i); #ifdef DEBUG -fprintf(stderr,"free: node=%lx\n",(unsigned long)node); -fflush(stderr); + fprintf(stderr,"free: node=%lx\n",(unsigned long)node); + fflush(stderr); #endif - if(node != NULL) free(node); + if(node != NULL) free(node); } ncbytesfree(out->tmp1); @@ -206,81 +206,81 @@ printNode(NC4printer* out, NCID* node, int depth) switch (node->sort) { case GROUP: - /* Get group name */ - if((ret=nc_inq_grpname(node->id,name))) FAIL; - SETNAME(node,name); - /* get group counts */ - if((ret=nc_inq(node->id,&ndims,&nvars,&natts,&nunlim))) FAIL; + /* Get group name */ + if((ret=nc_inq_grpname(node->id,name))) FAIL; + SETNAME(node,name); + /* get group counts */ + if((ret=nc_inq(node->id,&ndims,&nvars,&natts,&nunlim))) FAIL; if((ret=nc_inq_typeids(node->id,&ntypes,NULL))) FAIL; if((ret=nc_inq_grps(node->id,&ngroups,NULL))) FAIL; - if(ndims >= NC_MAX_IDS) FAIL; - if(nvars >= NC_MAX_IDS) FAIL; - if(nunlim >= NC_MAX_IDS) FAIL; - if(ntypes >= NC_MAX_IDS) FAIL; - if(ngroups >= NC_MAX_IDS) FAIL; + if(ndims >= NC_MAX_IDS) FAIL; + if(nvars >= NC_MAX_IDS) FAIL; + if(nunlim >= NC_MAX_IDS) FAIL; + if(ntypes >= NC_MAX_IDS) FAIL; + if(ngroups >= NC_MAX_IDS) FAIL; INDENT(depth); CAT("\n"); depth++; - { - /* Print: dims, types, vars(+attr), group-attr, subgroups */ - if((ret=nc_inq_dimids(node->id,&n,ids, 0))) FAIL; + { + /* Print: dims, types, vars(+attr), group-attr, subgroups */ + if((ret=nc_inq_dimids(node->id,&n,ids, 0))) FAIL; for(i=0;iid,&n,ids))) FAIL; + { + if((ret=nc_inq_typeids(node->id,&n,ids))) FAIL; for(i=0;iid, ids[i], name, &size, &base, NULL, &kind))) FAIL; - MAKEID(eid,USERTYPE,node,ids[i]); - SETNAME(eid,name); - eid->size = size; - eid->usertype.kind = kind; - if(base > 0) eid->base = findType(out,base); - record(out,eid); - printNode(out,eid,depth); - CAT("\n"); - } + nc_type kind; + if((ret=nc_inq_user_type(node->id, ids[i], name, &size, &base, NULL, &kind))) FAIL; + MAKEID(eid,USERTYPE,node,ids[i]); + SETNAME(eid,name); + eid->size = size; + eid->usertype.kind = kind; + if(base > 0) eid->base = findType(out,base); + record(out,eid); + printNode(out,eid,depth); + CAT("\n"); + } } - { - if((ret=nc_inq_varids(node->id,&n,ids))) FAIL; + { + if((ret=nc_inq_varids(node->id,&n,ids))) FAIL; for(i=0;iid, ids[i], name, &base, &ndims, NULL, NULL))) FAIL; - MAKEID(vid,VAR,node,ids[i]); - SETNAME(vid,name); - vid->base = findType(out,base); - vid->var.rank = ndims; - printNode(out,vid,depth); - CAT("\n"); - } + nc_type base; + if((ret=nc_inq_var(node->id, ids[i], name, &base, &ndims, NULL, NULL))) FAIL; + MAKEID(vid,VAR,node,ids[i]); + SETNAME(vid,name); + vid->base = findType(out,base); + vid->var.rank = ndims; + printNode(out,vid,depth); + CAT("\n"); + } } - { + { for(i=0;iid,NC_GLOBAL,i,name))) FAIL; - MAKEID(id,ATTR,node,NC_GLOBAL); - SETNAME(id,name); - printAttribute(out,id,depth); - CAT("\n"); - } + if((ret=nc_inq_attname(node->id,NC_GLOBAL,i,name))) FAIL; + MAKEID(id,ATTR,node,NC_GLOBAL); + SETNAME(id,name); + printAttribute(out,id,depth); + CAT("\n"); + } } - { - if((ret=nc_inq_grps(node->id,&n,ids))) FAIL; + { + if((ret=nc_inq_grps(node->id,&n,ids))) FAIL; for(i=0;i"); @@ -288,8 +288,8 @@ printNode(NC4printer* out, NCID* node, int depth) case DIM: if((ret=nc_inq_dim(GROUPOF(node),node->id,name,&len))) FAIL; - SETNAME(node,name); - node->size = len; + SETNAME(node,name); + node->size = len; INDENT(depth); CAT("usertype.kind) { - case NC_OPAQUE: - INDENT(depth); CAT("usertype.kind) { + case NC_OPAQUE: + INDENT(depth); CAT("name); printXMLAttributeSize(out, "size", node->size); CAT("/>"); - break; - case NC_ENUM: + break; + case NC_ENUM: if((ret=nc_inq_enum(GROUPOF(node),node->id,NULL,NULL,NULL,&count))) FAIL; - INDENT(depth); CAT("name); CAT(">\n"); depth++; for(i=0;iid,i,name,&numvalue))) FAIL; - value = getNumericValue(numvalue,node->base->id); + long long value; + if((ret=nc_inq_enum_member(GROUPOF(node),node->id,i,name,&numvalue))) FAIL; + value = getNumericValue(numvalue,node->base->id); INDENT(depth); CAT("\n"); + CAT("/>\n"); } depth--; INDENT(depth); CAT(""); @@ -334,53 +334,53 @@ printNode(NC4printer* out, NCID* node, int depth) for(i=0;iid,i,name,NULL,&base,NULL,NULL))) FAIL; MAKEID(id,FIELD,node->parent,node->id); - SETNAME(id,name); - id->base = findType(out,base); - id->field.fid = i; + SETNAME(id,name); + id->base = findType(out,base); + id->field.fid = i; printNode(out,id,depth); CAT("\n"); } depth--; INDENT(depth); CAT(""); break; - case NC_VLEN: - abort(); - break; - default: - abort(); - break; - } - break; + case NC_VLEN: + abort(); + break; + default: + abort(); + break; + } + break; case VAR: if((ret=nc_inq_var(GROUPOF(node), node->id, name, &base, &ndims, ids, &natts))) FAIL; - node->base = findType(out,base); - SETNAME(node,name); - node->var.rank = ndims; + node->base = findType(out,base); + SETNAME(node,name); + node->var.rank = ndims; INDENT(depth); CAT("name); makeFQN(node->base,out->tmp2); printXMLAttributeName(out, "type", ncbytescontents(out->tmp2)); - if(node->var.rank > 0) + if(node->var.rank > 0) printXMLAttributeInt(out, "rank", node->var.rank); if(ndims > 0 || natts > 0) { CAT(">\n"); depth++; for(i=0;iid,i,name))) FAIL; - if((ret=nc_inq_att(GROUPOF(node),node->id,name,&base,&count))) FAIL; + if((ret=nc_inq_att(GROUPOF(node),node->id,name,&base,&count))) FAIL; MAKEID(id,ATTR,node,node->id); - SETNAME(id,name); - id->base = findType(out,base); - id->size = count; + SETNAME(id,name); + id->base = findType(out,base); + id->size = count; printAttribute(out,id,depth); - CAT("\n"); - } + CAT("\n"); + } depth--; INDENT(depth); CAT(""); } else @@ -389,7 +389,7 @@ printNode(NC4printer* out, NCID* node, int depth) case ATOMTYPE: default: - abort(); + abort(); ret = NC_EINVAL; break; } @@ -451,8 +451,8 @@ printAttribute(NC4printer* out, NCID* attr, int depth) if((ret=readAttributeValues(attr,&values))) FAIL; depth++; for(i=0;isize;i++) { - void* value = computeOffset(attr->base,values,i); - if((ret=printValue(out,attr->base,value,depth))) FAIL; + void* value = computeOffset(attr->base,values,i); + if((ret=printValue(out,attr->base,value,depth))) FAIL; } depth--; INDENT(depth); @@ -484,7 +484,7 @@ printValue(NC4printer* out, NCID* basetype, void* value, int depth) { int ret; if(basetype->id > NC_MAX_ATOMIC_TYPE && basetype->usertype.kind == NC_ENUM) { - basetype = basetype->base; + basetype = basetype->base; } if((ret=getPrintValue(out->tmp2,basetype,value))) FAIL; INDENT(depth); @@ -554,12 +554,12 @@ getPrintValue(NCbytes* out, NCID* basetype, void* value) break; case NC_STRING: { char* s = *(char**)value; - printString(out,s,0); - } break; + printString(out,s,0); + } break; case NC_OPAQUE: { unsigned char* s = *(unsigned char**)value; - printOpaque(out,s,basetype->size,1); - } break; + printOpaque(out,s,basetype->size,1); + } break; case NC_ENUM: /* use true basetype */ ret = getPrintValue(out,basetype->base,value); @@ -614,7 +614,7 @@ findType(NC4printer* out, nc_type t) { int len = nclistlength(out->types); if(t >= len) - abort(); + abort(); return (NCID*)nclistget(out->types,t); } @@ -656,18 +656,18 @@ record(NC4printer* out, NCID* node) { switch (node->sort) { case DIM: - if(nclistlength(out->dims) <= node->id) { + if(nclistlength(out->dims) <= node->id) { nclistsetalloc(out->dims,node->id+1); - nclistsetlength(out->dims,node->id+1); - } + nclistsetlength(out->dims,node->id+1); + } nclistset(out->dims,node->id,node); break; case ATOMTYPE: case USERTYPE: - if(nclistlength(out->types) <= node->id) { + if(nclistlength(out->types) <= node->id) { nclistsetalloc(out->types,node->id+1); - nclistsetlength(out->types,node->id+1); - } + nclistsetlength(out->types,node->id+1); + } nclistset(out->types,node->id,node); break; default: break; @@ -678,7 +678,7 @@ static void track(NC4printer* out, NCID* node) { if(out == NULL || node == NULL || out->allnodes == NULL) - abort(); + abort(); #ifdef DEBUG fprintf(stderr,"track: node=%lx\n",(unsigned long)node); #endif @@ -695,16 +695,16 @@ entityEscape(NCbytes* escaped, const char* s) const char* p; ncbytesclear(escaped); for(p=s;*p;p++) { - int c = *p; - switch (c) { - case '&': ncbytescat(escaped,"&"); break; - case '<': ncbytescat(escaped,"<"); break; - case '>': ncbytescat(escaped,">"); break; - case '"': ncbytescat(escaped,"""); break; - case '\'': ncbytescat(escaped,"'"); break; + int c = *p; + switch (c) { + case '&': ncbytescat(escaped,"&"); break; + case '<': ncbytescat(escaped,"<"); break; + case '>': ncbytescat(escaped,">"); break; + case '"': ncbytescat(escaped,"""); break; + case '\'': ncbytescat(escaped,"'"); break; default: ncbytesappend(escaped,(c)); break; } - ncbytesnull(escaped); + ncbytesnull(escaped); } } @@ -716,12 +716,12 @@ buildAtomicTypes(NC4printer* out, NCID* root) char name[NC_MAX_NAME+1]; size_t size; for(tid=NC_NAT+1;tid<=NC_MAX_ATOMIC_TYPE;tid++) { - if((ret=nc_inq_type(root->id,tid,NULL,&size))) FAIL; + if((ret=nc_inq_type(root->id,tid,NULL,&size))) FAIL; getAtomicTypeName(tid,name); MAKEID(type,ATOMTYPE,root,tid); - SETNAME(type,name); - type->size = size; - type->usertype.kind = tid; + SETNAME(type,name); + type->size = size; + type->usertype.kind = tid; record(out, type); } return ret; @@ -734,8 +734,8 @@ printString(NCbytes* out, const char* s, int quotes) if(quotes) ncbytesappend(out,'"'); if(s == NULL) s = ""; for(p=s;*p;p++) { - int c = *p; - if(c == '\\') ncbytescat(out,"\\\\"); + int c = *p; + if(c == '\\') ncbytescat(out,"\\\\"); else if(c == '"') ncbytescat(out,"\\\""); else ncbytesappend(out,c); }