diff options
| author | Quincey Koziol <koziol@hdfgroup.org> | 2001-11-27 16:29:13 (GMT) |
|---|---|---|
| committer | Quincey Koziol <koziol@hdfgroup.org> | 2001-11-27 16:29:13 (GMT) |
| commit | d456c2bb82be98bc2b7c1039927eb52258d1a0eb (patch) | |
| tree | a7d8a65aef5d962c89b0965c86eb535917c023ad | |
| parent | 05264c88788f9bd9b04a58673ded246904210235 (diff) | |
| download | hdf5-d456c2bb82be98bc2b7c1039927eb52258d1a0eb.zip hdf5-d456c2bb82be98bc2b7c1039927eb52258d1a0eb.tar.gz hdf5-d456c2bb82be98bc2b7c1039927eb52258d1a0eb.tar.bz2 | |
[svn-r4643] Purpose:
Code cleanup
Description:
Windows is generating hundreds of warnings from some of the practices in
the library. Mostly, they are because size_t is 32-bit and hsize_t is
64-bit on Windows and we were carelessly casting the larger values down to
the smaller ones without checking for overflow.
Also, some other small code cleanups,etc.
Solution:
Re-worked some algorithms to eliminate the casts and also added more
overflow checking for assignments and function parameters which needed
casts.
Kent did most of the work, I just went over his changes and fit them into
the the library code a bit better.
Platforms tested:
FreeBSD 4.4 (hawkwind)
49 files changed, 938 insertions, 864 deletions
diff --git a/hl/tools/gif2h5/hdf2gif.c b/hl/tools/gif2h5/hdf2gif.c index c2ddb10..cc7bab4 100644 --- a/hl/tools/gif2h5/hdf2gif.c +++ b/hl/tools/gif2h5/hdf2gif.c @@ -16,7 +16,7 @@ */ #include <stdio.h> - +#include <assert.h> #include "gif.h" #define MAX_FILE_LEN 256 @@ -208,8 +208,10 @@ int main(int argc , char **argv) return -1; } - RWidth = dim_sizes[1]; - RHeight = dim_sizes[0]; + assert(dim_sizes[0]==(hsize_t)((int)dim_sizes[0])); + assert(dim_sizes[1]==(hsize_t)((int)dim_sizes[1])); + RWidth = (int)dim_sizes[1]; + RHeight = (int)dim_sizes[0]; #ifdef UNUSED w = dim_sizes[1]; h = dim_sizes[0]; diff --git a/hl/tools/gif2h5/hdfgifwr.c b/hl/tools/gif2h5/hdfgifwr.c index b13b79a..9804098 100644 --- a/hl/tools/gif2h5/hdfgifwr.c +++ b/hl/tools/gif2h5/hdfgifwr.c @@ -152,7 +152,9 @@ static unsigned long cur_accum = 0; static int cur_bits = 0; #define MAXCODE(n_bits) ( (1 << (n_bits)) - 1) +#ifndef WIN32 #define min(a,b) ((a>b) ? b : a) +#endif #define XV_BITS 12 /* BITS was already defined on some systems */ #define MSDOS 1 #define HSIZE 5003 /* 80% occupancy */ @@ -247,12 +247,11 @@ H5A_create(const H5G_entry_t *ent, const char *name, const H5T_t *type, /* Compute the internal sizes */ attr->dt_size=(H5O_DTYPE[0].raw_size)(attr->ent.file,type); attr->ds_size=(H5O_SDSPACE[0].raw_size)(attr->ent.file,&(space->extent.u.simple)); - attr->data_size=H5S_get_simple_extent_npoints(space)*H5T_get_size(type); + H5_ASSIGN_OVERFLOW(attr->data_size,H5S_get_simple_extent_npoints(space)*H5T_get_size(type),hssize_t,size_t); /* Hold the symbol table entry (and file) open */ - if (H5O_open(&(attr->ent)) < 0) { + if (H5O_open(&(attr->ent)) < 0) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open"); - } attr->ent_opened=1; /* Read in the existing attributes to check for duplicates */ @@ -503,10 +502,8 @@ H5A_open(H5G_entry_t *ent, unsigned idx) /* Read in attribute with H5O_read() */ H5_CHECK_OVERFLOW(idx,unsigned,int); - if (NULL==(attr=H5O_read(ent, H5O_ATTR, (int)idx, attr))) { - HGOTO_ERROR(H5E_ATTR, H5E_CANTINIT, FAIL, - "unable to load attribute info from dataset header"); - } + if (NULL==(attr=H5O_read(ent, H5O_ATTR, (int)idx, attr))) + HGOTO_ERROR(H5E_ATTR, H5E_CANTINIT, FAIL, "unable to load attribute info from dataset header"); attr->initialized=1; /* Copy the symbol table entry */ @@ -612,7 +609,7 @@ H5A_write(H5A_t *attr, const H5T_t *mem_type, const void *buf) hid_t src_id = -1, dst_id = -1;/* temporary type atoms */ size_t src_type_size; /* size of source type */ size_t dst_type_size; /* size of destination type*/ - hsize_t buf_size; /* desired buffer size */ + size_t buf_size; /* desired buffer size */ int idx; /* index of attribute in object header */ herr_t ret_value = FAIL; @@ -630,31 +627,22 @@ H5A_write(H5A_t *attr, const H5T_t *mem_type, const void *buf) dst_type_size = H5T_get_size(attr->dt); /* Get the maximum buffer size needed and allocate it */ - buf_size = nelmts*MAX(src_type_size,dst_type_size); - assert(buf_size==(hsize_t)((size_t)buf_size)); /*check for overflow*/ - if (NULL==(tconv_buf = H5MM_malloc ((size_t)buf_size)) || - NULL==(bkg_buf = H5MM_calloc((size_t)buf_size))) { - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, - "memory allocation failed"); - } + H5_ASSIGN_OVERFLOW(buf_size,nelmts*MAX(src_type_size,dst_type_size),hsize_t,size_t); + if (NULL==(tconv_buf = H5MM_malloc (buf_size)) || NULL==(bkg_buf = H5MM_calloc(buf_size))) + HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed"); /* Copy the user's data into the buffer for conversion */ - assert((src_type_size*nelmts)==(hsize_t)((size_t)(src_type_size*nelmts))); /*check for overflow*/ + H5_CHECK_OVERFLOW((src_type_size*nelmts),hsize_t,size_t); HDmemcpy(tconv_buf,buf,(size_t)(src_type_size*nelmts)); /* Convert memory buffer into disk buffer */ /* Set up type conversion function */ if (NULL == (tpath = H5T_path_find(mem_type, attr->dt, NULL, NULL))) { - HGOTO_ERROR(H5E_ATTR, H5E_UNSUPPORTED, FAIL, - "unable to convert between src and dest data types"); + HGOTO_ERROR(H5E_ATTR, H5E_UNSUPPORTED, FAIL, "unable to convert between src and dest data types"); } else if (!H5T_IS_NOOP(tpath)) { - if ((src_id = H5I_register(H5I_DATATYPE, - H5T_copy(mem_type, H5T_COPY_ALL)))<0 || - (dst_id = H5I_register(H5I_DATATYPE, - H5T_copy(attr->dt, H5T_COPY_ALL)))<0) { - HGOTO_ERROR(H5E_ATTR, H5E_CANTREGISTER, FAIL, - "unable to register types for conversion"); - } + if ((src_id = H5I_register(H5I_DATATYPE, H5T_copy(mem_type, H5T_COPY_ALL)))<0 || + (dst_id = H5I_register(H5I_DATATYPE, H5T_copy(attr->dt, H5T_COPY_ALL)))<0) + HGOTO_ERROR(H5E_ATTR, H5E_CANTREGISTER, FAIL, "unable to register types for conversion"); } /* Perform data type conversion */ @@ -775,7 +763,7 @@ H5A_read(H5A_t *attr, const H5T_t *mem_type, void *buf) hid_t src_id = -1, dst_id = -1;/* temporary type atoms*/ size_t src_type_size; /* size of source type */ size_t dst_type_size; /* size of destination type */ - hsize_t buf_size; /* desired buffer size */ + size_t buf_size; /* desired buffer size */ herr_t ret_value = FAIL; FUNC_ENTER(H5A_read, FAIL); @@ -792,45 +780,33 @@ H5A_read(H5A_t *attr, const H5T_t *mem_type, void *buf) dst_type_size = H5T_get_size(mem_type); /* Check if the attribute has any data yet, if not, fill with zeroes */ - assert((dst_type_size*nelmts)==(hsize_t)((size_t)(dst_type_size*nelmts))); /*check for overflow*/ + H5_CHECK_OVERFLOW((dst_type_size*nelmts),hsize_t,size_t); if(attr->ent_opened && !attr->initialized) { HDmemset(buf,0,(size_t)(dst_type_size*nelmts)); } /* end if */ else { /* Attribute exists and has a value */ /* Get the maximum buffer size needed and allocate it */ - buf_size = nelmts*MAX(src_type_size,dst_type_size); - assert(buf_size==(hsize_t)((size_t)buf_size)); /*check for overflow*/ - if (NULL==(tconv_buf = H5MM_malloc ((size_t)buf_size)) || - NULL==(bkg_buf = H5MM_calloc((size_t)buf_size))) { - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, - "memory allocation failed"); - } + H5_ASSIGN_OVERFLOW(buf_size,(nelmts*MAX(src_type_size,dst_type_size)),hsize_t,size_t); + if (NULL==(tconv_buf = H5MM_malloc (buf_size)) || NULL==(bkg_buf = H5MM_calloc(buf_size))) + HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed"); /* Copy the attribute data into the buffer for conversion */ - assert((src_type_size*nelmts)==(hsize_t)((size_t)(src_type_size*nelmts))); /*check for overflow*/ + H5_CHECK_OVERFLOW((src_type_size*nelmts),hsize_t,size_t); HDmemcpy(tconv_buf,attr->data,(size_t)(src_type_size*nelmts)); /* Convert memory buffer into disk buffer */ /* Set up type conversion function */ if (NULL == (tpath = H5T_path_find(attr->dt, mem_type, NULL, NULL))) { - HGOTO_ERROR(H5E_ATTR, H5E_UNSUPPORTED, FAIL, - "unable to convert between src and dest data types"); + HGOTO_ERROR(H5E_ATTR, H5E_UNSUPPORTED, FAIL, "unable to convert between src and dest data types"); } else if (!H5T_IS_NOOP(tpath)) { - if ((src_id = H5I_register(H5I_DATATYPE, - H5T_copy(attr->dt, H5T_COPY_ALL)))<0 || - (dst_id = H5I_register(H5I_DATATYPE, - H5T_copy(mem_type, H5T_COPY_ALL)))<0) { - HGOTO_ERROR(H5E_ATTR, H5E_CANTREGISTER, FAIL, - "unable to register types for conversion"); - } + if ((src_id = H5I_register(H5I_DATATYPE, H5T_copy(attr->dt, H5T_COPY_ALL)))<0 || + (dst_id = H5I_register(H5I_DATATYPE, H5T_copy(mem_type, H5T_COPY_ALL)))<0) + HGOTO_ERROR(H5E_ATTR, H5E_CANTREGISTER, FAIL, "unable to register types for conversion"); } /* Perform data type conversion. */ - if (H5T_convert(tpath, src_id, dst_id, nelmts, 0, 0, tconv_buf, bkg_buf, - H5P_DEFAULT)<0) { - HGOTO_ERROR(H5E_ATTR, H5E_CANTENCODE, FAIL, - "data type conversion failed"); - } + if (H5T_convert(tpath, src_id, dst_id, nelmts, 0, 0, tconv_buf, bkg_buf, H5P_DEFAULT)<0) + HGOTO_ERROR(H5E_ATTR, H5E_CANTENCODE, FAIL, "data type conversion failed"); /* Copy the converted data into the user's buffer */ HDmemcpy(buf,tconv_buf,(size_t)(dst_type_size*nelmts)); @@ -724,11 +724,11 @@ H5B_split(H5F_t *f, const H5B_class_t *type, H5B_t *old_bt, haddr_t old_addr, * and the new node. */ if (!H5F_addr_defined(old_bt->right)) { - nleft = 2 * k * split_ratios[2]; /*right*/ + nleft = (int)(2 * k * split_ratios[2]); /*right*/ } else if (!H5F_addr_defined(old_bt->left)) { - nleft = 2 * k * split_ratios[0]; /*left*/ + nleft = (int)(2 * k * split_ratios[0]); /*left*/ } else { - nleft = 2 * k * split_ratios[1]; /*middle*/ + nleft = (int)(2 * k * split_ratios[1]); /*middle*/ } /* @@ -152,7 +152,7 @@ H5D_init_interface(void) hid_t def_vfl_id = H5D_XFER_VFL_ID_DEF; void *def_vfl_info = H5D_XFER_VFL_INFO_DEF; #ifdef COALESCE_READS - unsigned def_gather_reads = H5D_XFER_GATHER_READS_DEF; + hsize_t def_gather_reads = H5D_XFER_GATHER_READS_DEF; #endif /* COALESCE_READS */ size_t def_hyp_vec_size = H5D_XFER_HYPER_VECTOR_SIZE_DEF; @@ -3087,7 +3087,9 @@ H5D_get_file (const H5D_t *dset) static herr_t H5D_init_storage(H5D_t *dset, const H5S_t *space) { - hssize_t npoints, ptsperbuf; + hssize_t snpoints; /* Number of points in space (for error checking) */ + size_t npoints; /* Number of points in space */ + size_t ptsperbuf; size_t bufsize=8*1024; size_t size; haddr_t addr; @@ -3119,23 +3121,25 @@ H5D_init_storage(H5D_t *dset, const H5S_t *space) * even if it is all zero. This allows the application to force * filling when the underlying storage isn't initialized to zero. */ - npoints = H5S_get_simple_extent_npoints(space); + snpoints = H5S_get_simple_extent_npoints(space); + assert(snpoints>=0); + H5_ASSIGN_OVERFLOW(npoints,snpoints,hssize_t,size_t); - if (fill.buf && npoints==H5S_get_select_npoints(space)) { + if (fill.buf && npoints==(size_t)H5S_get_select_npoints(space)) { /* * Fill the entire current extent with the fill value. We can do * this quite efficiently by making sure we copy the fill value * in relatively large pieces. */ - ptsperbuf = (hssize_t)MAX(1, bufsize/fill.size); - bufsize = ptsperbuf * fill.size; + + ptsperbuf = MAX(1, bufsize/fill.size); + bufsize = ptsperbuf*fill.size; /* Allocate temporary buffer */ if ((buf=H5FL_BLK_ALLOC(fill_conv,bufsize,0))==NULL) HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for fill buffer"); - assert(ptsperbuf==(hssize_t)((size_t)ptsperbuf)); /*check for overflow*/ - H5V_array_fill(buf, fill.buf, fill.size, (size_t)ptsperbuf); + H5V_array_fill(buf, fill.buf, fill.size, ptsperbuf); if (efl.nused) { addr = 0; } else { @@ -3148,8 +3152,7 @@ H5D_init_storage(H5D_t *dset, const H5S_t *space) if(H5O_efl_write(dset->ent.file, &efl, addr, size, buf) < 0) HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to write fill value to dataset"); } else { - if (H5F_block_write(dset->ent.file, H5FD_MEM_DRAW, addr, - size, H5P_DATASET_XFER_DEFAULT, buf)<0) + if (H5F_block_write(dset->ent.file, H5FD_MEM_DRAW, addr, size, H5P_DATASET_XFER_DEFAULT, buf)<0) HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to write fill value to dataset"); } npoints -= MIN(ptsperbuf, npoints); diff --git a/src/H5Distore.c b/src/H5Distore.c index ed3c673..d016961 100644 --- a/src/H5Distore.c +++ b/src/H5Distore.c @@ -1216,7 +1216,7 @@ H5F_istore_prune (H5F_t *f, size_t size) H5F_rdcc_t *rdcc = &(f->shared->rdcc); size_t total = f->shared->rdcc_nbytes; const int nmeth=2; /*number of methods */ - int w[1]; /*weighting as an interval */ + int w[1]; /*weighting as an interval */ H5F_rdcc_ent_t *p[2], *cur; /*list pointers */ H5F_rdcc_ent_t *n[2]; /*list next pointers */ @@ -1232,7 +1232,7 @@ H5F_istore_prune (H5F_t *f, size_t size) * begins. The pointers participating in the list traversal are each * given a chance at preemption before any of the pointers are advanced. */ - w[0] = rdcc->nused * f->shared->rdcc_w0; + w[0] = (int)(rdcc->nused * f->shared->rdcc_w0); p[0] = rdcc->head; p[1] = NULL; @@ -1337,13 +1337,14 @@ H5F_istore_lock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, unsigned *idx_hint/*in,out*/) { int idx=0; /*hash index number */ - unsigned temp_idx=0; /* temporary index number */ + hsize_t temp_idx=0; /* temporary index number */ hbool_t found = FALSE; /*already in cache? */ H5F_rdcc_t *rdcc = &(f->shared->rdcc);/*raw data chunk cache*/ H5F_rdcc_ent_t *ent = NULL; /*cache entry */ unsigned u; /*counters */ H5F_istore_ud1_t udata; /*B-tree pass-through */ size_t chunk_size=0; /*size of a chunk */ + hsize_t tempchunk_size; size_t chunk_alloc=0; /*allocated chunk size */ herr_t status; /*func return status */ void *chunk=NULL; /*the file chunk */ @@ -1358,7 +1359,7 @@ H5F_istore_lock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, temp_idx *= layout->dim[u]; temp_idx += offset[u]; } - temp_idx += (unsigned)(layout->addr); + temp_idx += (hsize_t)(layout->addr); idx=H5F_HASH(f,temp_idx); ent = rdcc->slot[idx]; @@ -1391,9 +1392,10 @@ H5F_istore_lock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, HDfflush(stderr); #endif rdcc->nhits++; - for (u=0, chunk_size=1; u<layout->ndims; u++) { - chunk_size *= layout->dim[u]; + for (u=0, tempchunk_size=1; u<layout->ndims; u++) { + tempchunk_size *= layout->dim[u]; } + H5_ASSIGN_OVERFLOW(chunk_size,tempchunk_size,hsize_t,size_t); chunk_alloc = chunk_size; if (NULL==(chunk=H5F_istore_chunk_alloc (chunk_alloc))) { HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, @@ -1405,10 +1407,11 @@ H5F_istore_lock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, * Not in the cache. Read it from the file and count this as a miss * if it's in the file or an init if it isn't. */ - for (u=0, chunk_size=1; u<layout->ndims; u++) { + for (u=0, tempchunk_size=1; u<layout->ndims; u++) { udata.key.offset[u] = offset[u]; - chunk_size *= layout->dim[u]; + tempchunk_size *= layout->dim[u]; } + H5_ASSIGN_OVERFLOW(chunk_size,tempchunk_size,hsize_t,size_t); chunk_alloc = chunk_size; udata.mesg = *layout; udata.addr = HADDR_UNDEF; @@ -1634,15 +1637,17 @@ H5F_istore_unlock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, */ if (dirty) { H5F_rdcc_ent_t x; + hsize_t tempchunk_size; HDmemset (&x, 0, sizeof x); x.dirty = TRUE; x.layout = H5O_copy (H5O_LAYOUT, layout, NULL); x.pline = H5O_copy (H5O_PLINE, pline, NULL); - for (u=0, x.chunk_size=1; u<layout->ndims; u++) { + for (u=0, tempchunk_size=1; u<layout->ndims; u++) { x.offset[u] = offset[u]; - x.chunk_size *= layout->dim[u]; + tempchunk_size *= layout->dim[u]; } + H5_ASSIGN_OVERFLOW(x.chunk_size,tempchunk_size,hsize_t,size_t); x.alloc_size = x.chunk_size; x.chunk = chunk; @@ -1708,7 +1713,7 @@ H5F_istore_read(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, hssize_t chunk_offset[H5O_LAYOUT_NDIMS]; int i, carry; unsigned u; - size_t naccessed; /*bytes accessed in chnk*/ + hsize_t naccessed; /*bytes accessed in chnk*/ uint8_t *chunk=NULL; /*ptr to a chunk buffer */ unsigned idx_hint=0; /*cache index hint */ @@ -1823,9 +1828,10 @@ H5F_istore_read(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, } H5V_hyper_copy(layout->ndims, sub_size, size_m, sub_offset_m, (void*)buf, layout->dim, offset_wrt_chunk, chunk); + H5_CHECK_OVERFLOW(naccessed,hsize_t,size_t); if (H5F_istore_unlock(f, dxpl_id, layout, pline, FALSE, chunk_offset, &idx_hint, chunk, - naccessed)<0) { + (size_t)naccessed)<0) { HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to unlock raw data chunk"); } @@ -1883,7 +1889,7 @@ H5F_istore_write(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, hssize_t sub_offset_m[H5O_LAYOUT_NDIMS]; uint8_t *chunk=NULL; unsigned idx_hint=0; - size_t chunk_size, naccessed; + hsize_t chunk_size, naccessed; FUNC_ENTER(H5F_istore_write, FAIL); @@ -1942,7 +1948,7 @@ H5F_istore_write(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, offset_f[u]+size[u]) - (chunk_offset[u] + offset_wrt_chunk[u]); naccessed *= sub_size[u]; - + /* Offset into mem buffer */ sub_offset_m[u] = chunk_offset[u] + offset_wrt_chunk[u] + offset_m[u] - offset_f[u]; @@ -2001,9 +2007,10 @@ H5F_istore_write(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, } H5V_hyper_copy(layout->ndims, sub_size, layout->dim, offset_wrt_chunk, chunk, size_m, sub_offset_m, buf); + H5_CHECK_OVERFLOW(naccessed,hsize_t,size_t); if (H5F_istore_unlock(f, dxpl_id, layout, pline, TRUE, chunk_offset, &idx_hint, chunk, - naccessed)<0) { + (size_t)naccessed)<0) { HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "uanble to unlock raw data chunk"); } @@ -2330,7 +2337,7 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, hssize_t chunk_offset[H5O_LAYOUT_NDIMS]; uint8_t *chunk=NULL; unsigned idx_hint=0; - size_t chunk_size; + hsize_t chunk_size; #ifdef AKC H5F_istore_ud1_t udata; #endif @@ -2395,8 +2402,9 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "unable to read raw data chunk"); } + H5_CHECK_OVERFLOW(chunk_size,hsize_t,size_t); if (H5F_istore_unlock(f, dxpl_id, layout, pline, TRUE, - chunk_offset, &idx_hint, chunk, chunk_size)<0) { + chunk_offset, &idx_hint, chunk, (size_t)chunk_size)<0) { HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "uanble to unlock raw data chunk"); } diff --git a/src/H5Dprivate.h b/src/H5Dprivate.h index a66db7b..0e51a4b 100644 --- a/src/H5Dprivate.h +++ b/src/H5Dprivate.h @@ -132,7 +132,7 @@ #ifdef COALESCE_READS /* Definitions for 'gather reads' property */ #define H5D_XFER_GATHER_READS_NAME "gather_reads" -#define H5D_XFER_GATHER_READS_SIZE sizeof(unsigned) +#define H5D_XFER_GATHER_READS_SIZE sizeof(hsize_t) #define H5D_XFER_GATHER_READS_DEF 0 #endif /* COALESCE_READS */ /* Definitions for hyperslab vector size property */ @@ -2043,7 +2043,8 @@ H5F_flush(H5F_t *f, H5F_scope_t scope, hbool_t invalidate, /* * Encode the driver information block. */ - if ((driver_size=H5FD_sb_size(f->shared->lf))) { + H5_ASSIGN_OVERFLOW(driver_size,H5FD_sb_size(f->shared->lf),hsize_t,size_t); + if (driver_size>0) { driver_size += 16; /*driver block header */ assert(driver_size<=sizeof(dbuf)); p = dbuf; @@ -2035,7 +2035,10 @@ H5FD_read(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t siz unsigned char *read_buf=(unsigned char *)buf; /* Pointer to the buffer being read in */ size_t amount_read; /* Amount to read at a time */ - haddr_t read_off; /* Offset to read from */ +#ifndef NDEBUG + hsize_t tempamount_read; /* Amount to read at a time */ +#endif /* NDEBUG */ + hsize_t read_off; /* Offset to read from */ /* Double check that we aren't reading raw data */ assert(type!=H5FD_MEM_DRAW); @@ -2043,7 +2046,7 @@ H5FD_read(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t siz /* Read the part before the metadata accumulator */ if(addr<file->accum_loc) { /* Set the amount to read */ - amount_read=file->accum_loc-addr; + H5_ASSIGN_OVERFLOW(amount_read,file->accum_loc-addr,hsize_t,size_t); /* Dispatch to driver */ if ((file->cls->read)(file, type, dxpl_id, addr, amount_read, read_buf)<0) @@ -2061,7 +2064,13 @@ H5FD_read(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t siz read_off=addr-file->accum_loc; /* Set the amount to "read" */ - amount_read=MIN((file->accum_size-read_off),size); +#ifndef NDEBUG + tempamount_read = file->accum_size-read_off; + H5_CHECK_OVERFLOW(tempamount_read,hsize_t,size_t); + amount_read = MIN(size, (size_t)tempamount_read); +#else /* NDEBUG */ + amount_read = MIN(size, (size_t)tempamount_read); +#endif /* NDEBUG */ /* Copy the data out of the buffer */ HDmemcpy(read_buf,file->meta_accum+read_off,amount_read); @@ -2249,7 +2258,7 @@ H5FD_write(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t si /* Check if the new metadata overlaps the beginning of the current accumulator */ else if(addr<file->accum_loc && (addr+size)<=(file->accum_loc+file->accum_size)) { /* Calculate the new accumulator size, based on the amount of overlap */ - new_size=(file->accum_loc-addr)+file->accum_size; + H5_ASSIGN_OVERFLOW(new_size,(file->accum_loc-addr)+file->accum_size,hsize_t,size_t); /* Check if we need more buffer space */ if(new_size>file->accum_buf_size) { @@ -2262,7 +2271,7 @@ H5FD_write(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t si } /* end if */ /* Calculate the proper offset of the existing metadata */ - old_offset=(addr+size)-file->accum_loc; + H5_ASSIGN_OVERFLOW(old_offset,(addr+size)-file->accum_loc,hsize_t,size_t); /* Move the existing metadata to the proper location */ HDmemmove(file->meta_accum+size,file->meta_accum+old_offset,(file->accum_size-old_offset)); @@ -2280,7 +2289,7 @@ H5FD_write(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t si /* Check if the new metadata overlaps the end of the current accumulator */ else if(addr>=file->accum_loc && (addr+size)>(file->accum_loc+file->accum_size)) { /* Calculate the new accumulator size, based on the amount of overlap */ - new_size=(addr-file->accum_loc)+size; + H5_ASSIGN_OVERFLOW(new_size,(addr-file->accum_loc)+size,hsize_t,size_t); /* Check if we need more buffer space */ if(new_size>file->accum_buf_size) { diff --git a/src/H5FDcore.c b/src/H5FDcore.c index 6986a74..206f5e6 100644 --- a/src/H5FDcore.c +++ b/src/H5FDcore.c @@ -382,7 +382,7 @@ H5FD_core_flush(H5FD_t *_file) while (size) { ssize_t n; - assert(size==(hsize_t)((size_t)size)); /*check for overflow*/ + H5_CHECK_OVERFLOW(size,hsize_t,size_t); n = HDwrite(file->fd, ptr, (size_t)size); if (n<0 && EINTR==errno) continue; if (n<0) @@ -613,7 +613,16 @@ H5FD_core_read(H5FD_t *_file, H5FD_mem_t UNUSED type, hid_t UNUSED dxpl_id, hadd /* Read the part which is before the EOF marker */ if (addr < file->eof) { - size_t nbytes = MIN(size, file->eof-addr); + size_t nbytes; +#ifndef NDEBUG + hsize_t temp_nbytes; + + temp_nbytes = file->eof-addr; + H5_CHECK_OVERFLOW(temp_nbytes,hsize_t,size_t); + nbytes = MIN(size,(size_t)temp_nbytes); +#else /* NDEBUG */ + nbytes = MIN(size,(size_t)(file->eof-addr)); +#endif /* NDEBUG */ HDmemcpy(buf, file->mem + addr, nbytes); size -= nbytes; @@ -673,7 +682,9 @@ H5FD_core_write(H5FD_t *_file, H5FD_mem_t UNUSED type, hid_t UNUSED dxpl_id, had */ if (addr+size>file->eof) { unsigned char *x; - size_t new_eof = file->increment * ((addr+size)/file->increment); + size_t new_eof; + + H5_ASSIGN_OVERFLOW(new_eof,file->increment*((addr+size)/file->increment),hsize_t,size_t); if ((addr+size) % file->increment) new_eof += file->increment; diff --git a/src/H5FDdpss.c b/src/H5FDdpss.c index 539f9ec..87f86f5 100644 --- a/src/H5FDdpss.c +++ b/src/H5FDdpss.c @@ -553,7 +553,7 @@ H5FD_dpss_read (H5FD_t *_file, H5FD_mem_t UNUSED type, hid_t dxpl_id, haddr_t ad H5P_genplist_t *plist; /* Property list pointer */ globus_result_t globus_result; #ifdef COALESCE_READS - static int count = 0; /* counter for single reads */ + static hsize_t count = 0; /* counter for single reads */ #endif FUNC_ENTER (H5FD_dpss_read, FAIL); diff --git a/src/H5FDfamily.c b/src/H5FDfamily.c index 0ecf171..80feac2 100644 --- a/src/H5FDfamily.c +++ b/src/H5FDfamily.c @@ -863,6 +863,9 @@ H5FD_family_read(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, si int i; haddr_t sub; size_t req; +#ifndef NDEBUG + hsize_t tempreq; +#endif /* NDEBUG */ H5P_genplist_t *plist; /* Property list pointer */ FUNC_ENTER(H5FD_family_read, FAIL); @@ -883,9 +886,18 @@ H5FD_family_read(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, si /* Read from each member */ while (size>0) { - i = addr / file->memb_size; + H5_ASSIGN_OVERFLOW(i,addr /file->memb_size,hsize_t,int); + sub = addr % file->memb_size; - req = MIN(size, file->memb_size-sub); + +#ifndef NDEBUG + tempreq = file->memb_size-sub; + H5_CHECK_OVERFLOW(tempreq,hsize_t,size_t); + req = MIN(size, (size_t)tempreq); +#else /* NDEBUG */ + req = MIN(size, (size_t)(file->memb_size-sub)); +#endif /* NDEBUG */ + assert(i<file->nmembs); if (H5FDread(file->memb[i], type, memb_dxpl_id, sub, req, buf)<0) @@ -929,6 +941,9 @@ H5FD_family_write(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, s int i; haddr_t sub; size_t req; +#ifndef NDEBUG + hsize_t tempreq; +#endif /* NDEBUG */ H5P_genplist_t *plist; /* Property list pointer */ FUNC_ENTER(H5FD_family_write, FAIL); @@ -949,9 +964,18 @@ H5FD_family_write(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, s /* Write to each member */ while (size>0) { - i = addr / file->memb_size; + H5_ASSIGN_OVERFLOW(i,addr /file->memb_size,hsize_t,int); + sub = addr % file->memb_size; - req = MIN(size, file->memb_size-sub); + +#ifndef NDEBUG + tempreq = file->memb_size-sub; + H5_CHECK_OVERFLOW(tempreq,hsize_t,size_t); + req = MIN(size, (size_t)tempreq); +#else /* NDEBUG */ + req = MIN(size, (size_t)(file->memb_size-sub)); +#endif /* NDEBUG */ + assert(i<file->nmembs); if (H5FDwrite(file->memb[i], type, memb_dxpl_id, sub, req, buf)<0) diff --git a/src/H5FDlog.c b/src/H5FDlog.c index aa2bcb2..a9f76af 100644 --- a/src/H5FDlog.c +++ b/src/H5FDlog.c @@ -749,7 +749,7 @@ printf("%s: flavor=%s, size=%lu\n",FUNC,flavors[type],(unsigned long)size); /* Retain the (first) flavor of the information written to the file */ if(file->fa.verbosity>=0) { assert(addr<file->iosize); - assert(size==(hsize_t)((size_t)size)); /*check for overflow*/ + H5_CHECK_OVERFLOW(size,hsize_t,size_t); HDmemset(&file->flavor[addr],type,(size_t)size); if(file->fa.verbosity>1) diff --git a/src/H5Farray.c b/src/H5Farray.c index 5874b67..6b4155c 100644 --- a/src/H5Farray.c +++ b/src/H5Farray.c @@ -142,7 +142,7 @@ H5F_arr_read(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout, hsize_t file_start; /*byte offset to start */ hsize_t max_data = 0; /*bytes in dataset */ hsize_t elmt_size = 1; /*bytes per element */ - size_t nelmts, z; /*number of elements */ + hsize_t nelmts, z; /*number of elements */ unsigned ndims; /*stride dimensionality */ haddr_t addr; /*address in file */ int j; /*counters */ @@ -153,7 +153,7 @@ H5F_arr_read(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout, H5P_genplist_t *plist=NULL; /* Property list */ #endif #ifdef COALESCE_READS - unsigned gather_reads; /* # of MPIO reads to gather */ + hsize_t gather_reads; /* # of MPIO reads to gather */ #endif FUNC_ENTER(H5F_arr_read, FAIL); @@ -242,8 +242,7 @@ H5F_arr_read(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout, * and memory. Optimize the strides to result in the fewest number of * I/O requests. */ - mem_start = H5V_hyper_stride(ndims, hslab_size, mem_size, - mem_offset, mem_stride/*out*/); + H5_ASSIGN_OVERFLOW(mem_start,H5V_hyper_stride(ndims, hslab_size, mem_size, mem_offset, mem_stride/*out*/),hsize_t,size_t); file_start = H5V_hyper_stride(ndims, hslab_size, layout->dim, file_offset, file_stride/*out*/); H5V_stride_optimize2(&ndims, &elmt_size, hslab_size, @@ -311,7 +310,6 @@ H5F_arr_read(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout, /* Track the number of reads to gather */ if(H5P_set(plist, H5D_XFER_GATHER_READS_NAME, &gather_reads)<0) HRETURN_ERROR (H5E_PLIST, H5E_CANTGET, FAIL, "Can't retrieve gather reads"); - #else for (z=0; z<nelmts; z++) { #endif @@ -433,7 +431,7 @@ H5F_arr_write(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout, hsize_t file_start; /*byte offset to start */ hsize_t max_data = 0; /*bytes in dataset */ hsize_t elmt_size = 1; /*bytes per element */ - size_t nelmts, z; /*number of elements */ + hsize_t nelmts, z; /*number of elements */ unsigned ndims; /*dimensionality */ haddr_t addr; /*address in file */ int j; /*counters */ @@ -548,6 +546,7 @@ H5F_arr_write(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout, */ H5V_vector_cpy(ndims, idx, hslab_size); nelmts = H5V_vector_reduce_product(ndims, hslab_size); + if (efl && efl->nused>0) { addr = 0; } else { diff --git a/src/H5Fistore.c b/src/H5Fistore.c index ed3c673..d016961 100644 --- a/src/H5Fistore.c +++ b/src/H5Fistore.c @@ -1216,7 +1216,7 @@ H5F_istore_prune (H5F_t *f, size_t size) H5F_rdcc_t *rdcc = &(f->shared->rdcc); size_t total = f->shared->rdcc_nbytes; const int nmeth=2; /*number of methods */ - int w[1]; /*weighting as an interval */ + int w[1]; /*weighting as an interval */ H5F_rdcc_ent_t *p[2], *cur; /*list pointers */ H5F_rdcc_ent_t *n[2]; /*list next pointers */ @@ -1232,7 +1232,7 @@ H5F_istore_prune (H5F_t *f, size_t size) * begins. The pointers participating in the list traversal are each * given a chance at preemption before any of the pointers are advanced. */ - w[0] = rdcc->nused * f->shared->rdcc_w0; + w[0] = (int)(rdcc->nused * f->shared->rdcc_w0); p[0] = rdcc->head; p[1] = NULL; @@ -1337,13 +1337,14 @@ H5F_istore_lock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, unsigned *idx_hint/*in,out*/) { int idx=0; /*hash index number */ - unsigned temp_idx=0; /* temporary index number */ + hsize_t temp_idx=0; /* temporary index number */ hbool_t found = FALSE; /*already in cache? */ H5F_rdcc_t *rdcc = &(f->shared->rdcc);/*raw data chunk cache*/ H5F_rdcc_ent_t *ent = NULL; /*cache entry */ unsigned u; /*counters */ H5F_istore_ud1_t udata; /*B-tree pass-through */ size_t chunk_size=0; /*size of a chunk */ + hsize_t tempchunk_size; size_t chunk_alloc=0; /*allocated chunk size */ herr_t status; /*func return status */ void *chunk=NULL; /*the file chunk */ @@ -1358,7 +1359,7 @@ H5F_istore_lock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, temp_idx *= layout->dim[u]; temp_idx += offset[u]; } - temp_idx += (unsigned)(layout->addr); + temp_idx += (hsize_t)(layout->addr); idx=H5F_HASH(f,temp_idx); ent = rdcc->slot[idx]; @@ -1391,9 +1392,10 @@ H5F_istore_lock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, HDfflush(stderr); #endif rdcc->nhits++; - for (u=0, chunk_size=1; u<layout->ndims; u++) { - chunk_size *= layout->dim[u]; + for (u=0, tempchunk_size=1; u<layout->ndims; u++) { + tempchunk_size *= layout->dim[u]; } + H5_ASSIGN_OVERFLOW(chunk_size,tempchunk_size,hsize_t,size_t); chunk_alloc = chunk_size; if (NULL==(chunk=H5F_istore_chunk_alloc (chunk_alloc))) { HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, @@ -1405,10 +1407,11 @@ H5F_istore_lock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, * Not in the cache. Read it from the file and count this as a miss * if it's in the file or an init if it isn't. */ - for (u=0, chunk_size=1; u<layout->ndims; u++) { + for (u=0, tempchunk_size=1; u<layout->ndims; u++) { udata.key.offset[u] = offset[u]; - chunk_size *= layout->dim[u]; + tempchunk_size *= layout->dim[u]; } + H5_ASSIGN_OVERFLOW(chunk_size,tempchunk_size,hsize_t,size_t); chunk_alloc = chunk_size; udata.mesg = *layout; udata.addr = HADDR_UNDEF; @@ -1634,15 +1637,17 @@ H5F_istore_unlock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, */ if (dirty) { H5F_rdcc_ent_t x; + hsize_t tempchunk_size; HDmemset (&x, 0, sizeof x); x.dirty = TRUE; x.layout = H5O_copy (H5O_LAYOUT, layout, NULL); x.pline = H5O_copy (H5O_PLINE, pline, NULL); - for (u=0, x.chunk_size=1; u<layout->ndims; u++) { + for (u=0, tempchunk_size=1; u<layout->ndims; u++) { x.offset[u] = offset[u]; - x.chunk_size *= layout->dim[u]; + tempchunk_size *= layout->dim[u]; } + H5_ASSIGN_OVERFLOW(x.chunk_size,tempchunk_size,hsize_t,size_t); x.alloc_size = x.chunk_size; x.chunk = chunk; @@ -1708,7 +1713,7 @@ H5F_istore_read(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, hssize_t chunk_offset[H5O_LAYOUT_NDIMS]; int i, carry; unsigned u; - size_t naccessed; /*bytes accessed in chnk*/ + hsize_t naccessed; /*bytes accessed in chnk*/ uint8_t *chunk=NULL; /*ptr to a chunk buffer */ unsigned idx_hint=0; /*cache index hint */ @@ -1823,9 +1828,10 @@ H5F_istore_read(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, } H5V_hyper_copy(layout->ndims, sub_size, size_m, sub_offset_m, (void*)buf, layout->dim, offset_wrt_chunk, chunk); + H5_CHECK_OVERFLOW(naccessed,hsize_t,size_t); if (H5F_istore_unlock(f, dxpl_id, layout, pline, FALSE, chunk_offset, &idx_hint, chunk, - naccessed)<0) { + (size_t)naccessed)<0) { HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to unlock raw data chunk"); } @@ -1883,7 +1889,7 @@ H5F_istore_write(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, hssize_t sub_offset_m[H5O_LAYOUT_NDIMS]; uint8_t *chunk=NULL; unsigned idx_hint=0; - size_t chunk_size, naccessed; + hsize_t chunk_size, naccessed; FUNC_ENTER(H5F_istore_write, FAIL); @@ -1942,7 +1948,7 @@ H5F_istore_write(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, offset_f[u]+size[u]) - (chunk_offset[u] + offset_wrt_chunk[u]); naccessed *= sub_size[u]; - + /* Offset into mem buffer */ sub_offset_m[u] = chunk_offset[u] + offset_wrt_chunk[u] + offset_m[u] - offset_f[u]; @@ -2001,9 +2007,10 @@ H5F_istore_write(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, } H5V_hyper_copy(layout->ndims, sub_size, layout->dim, offset_wrt_chunk, chunk, size_m, sub_offset_m, buf); + H5_CHECK_OVERFLOW(naccessed,hsize_t,size_t); if (H5F_istore_unlock(f, dxpl_id, layout, pline, TRUE, chunk_offset, &idx_hint, chunk, - naccessed)<0) { + (size_t)naccessed)<0) { HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "uanble to unlock raw data chunk"); } @@ -2330,7 +2337,7 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, hssize_t chunk_offset[H5O_LAYOUT_NDIMS]; uint8_t *chunk=NULL; unsigned idx_hint=0; - size_t chunk_size; + hsize_t chunk_size; #ifdef AKC H5F_istore_ud1_t udata; #endif @@ -2395,8 +2402,9 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "unable to read raw data chunk"); } + H5_CHECK_OVERFLOW(chunk_size,hsize_t,size_t); if (H5F_istore_unlock(f, dxpl_id, layout, pline, TRUE, - chunk_offset, &idx_hint, chunk, chunk_size)<0) { + chunk_offset, &idx_hint, chunk, (size_t)chunk_size)<0) { HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "uanble to unlock raw data chunk"); } diff --git a/src/H5Fpkg.h b/src/H5Fpkg.h index 22cae65..0bff2a8 100644 --- a/src/H5Fpkg.h +++ b/src/H5Fpkg.h @@ -61,6 +61,12 @@ #else # define H5F_OVERFLOW_SIZET2OFFT(X) 0 #endif +#if (H5_SIZEOF_HSIZE_T >= SIZEOF_OFF_T) +# define H5F_OVERFLOW_HSIZET2OFFT(X) \ + ((hsize_t)(X)>=(hsize_t)((hsize_t)1<<(8*sizeof(off_t)-1))) +#else +# define H5F_OVERFLOW_SIZET2OFFT(X) 0 +#endif /* The raw data chunk cache */ typedef struct H5F_rdcc_t { @@ -379,6 +379,7 @@ H5O_load(H5F_t *f, haddr_t addr, const void * UNUSED _udata1, /* read fixed-lenth part of object header */ hdr_size = H5O_SIZEOF_HDR(f); + assert(hdr_size<=sizeof(buf)); if (H5F_block_read(f, H5FD_MEM_OHDR, addr, hdr_size, H5P_DATASET_XFER_DEFAULT, buf) < 0) { HGOTO_ERROR(H5E_OHDR, H5E_READERROR, NULL, "unable to read object header"); diff --git a/src/H5Oattr.c b/src/H5Oattr.c index c96a2ce..951ffbb 100644 --- a/src/H5Oattr.c +++ b/src/H5Oattr.c @@ -94,7 +94,7 @@ H5O_attr_decode(H5F_t *f, const uint8_t *p, H5O_shared_t UNUSED *sh) H5A_t *attr = NULL; H5S_simple_t *simple; /*simple dimensionality information */ size_t name_len; /*attribute name length */ - int version; /*message version number*/ + int version; /*message version number*/ FUNC_ENTER(H5O_attr_decode, NULL); @@ -102,17 +102,13 @@ H5O_attr_decode(H5F_t *f, const uint8_t *p, H5O_shared_t UNUSED *sh) assert(f); assert(p); - if (NULL==(attr = H5MM_calloc(sizeof(H5A_t)))) { - HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, - "memory allocation failed"); - } + if (NULL==(attr = H5MM_calloc(sizeof(H5A_t)))) + HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); /* Version number */ version = *p++; - if (version!=H5O_ATTR_VERSION) { - HRETURN_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, - "bad version number for attribute message"); - } + if (version!=H5O_ATTR_VERSION) + HRETURN_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "bad version number for attribute message"); /* Reserved */ p++; @@ -126,25 +122,19 @@ H5O_attr_decode(H5F_t *f, const uint8_t *p, H5O_shared_t UNUSED *sh) UINT16DECODE(p, attr->ds_size); /* Decode and store the name */ - if (NULL==(attr->name=H5MM_malloc(name_len))) { - HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, - "memory allocation failed"); - } + if (NULL==(attr->name=H5MM_malloc(name_len))) + HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); HDmemcpy(attr->name,p,name_len); p += H5O_ALIGN(name_len); /* advance the memory pointer */ /* decode the attribute datatype */ - if((attr->dt=(H5O_DTYPE->decode)(f,p,NULL))==NULL) { - HRETURN_ERROR(H5E_ATTR, H5E_CANTDECODE, NULL, - "can't decode attribute datatype"); - } + if((attr->dt=(H5O_DTYPE->decode)(f,p,NULL))==NULL) + HRETURN_ERROR(H5E_ATTR, H5E_CANTDECODE, NULL, "can't decode attribute datatype"); p += H5O_ALIGN(attr->dt_size); /* decode the attribute dataspace */ - if (NULL==(attr->ds = H5FL_ALLOC(H5S_t,1))) { - HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, - "memory allocation failed"); - } + if (NULL==(attr->ds = H5FL_ALLOC(H5S_t,1))) + HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); if((simple=(H5O_SDSPACE->decode)(f,p,NULL))!=NULL) { attr->ds->extent.type = H5S_SIMPLE; HDmemcpy(&(attr->ds->extent.u.simple),simple, sizeof(H5S_simple_t)); @@ -155,13 +145,11 @@ H5O_attr_decode(H5F_t *f, const uint8_t *p, H5O_shared_t UNUSED *sh) p += H5O_ALIGN(attr->ds_size); /* Compute the size of the data */ - attr->data_size=H5S_get_simple_extent_npoints(attr->ds)*H5T_get_size(attr->dt); + H5_ASSIGN_OVERFLOW(attr->data_size,H5S_get_simple_extent_npoints(attr->ds)*H5T_get_size(attr->dt),hsize_t,size_t); /* Go get the data */ - if (NULL==(attr->data = H5MM_malloc(attr->data_size))) { - HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, - "memory allocation failed"); - } + if (NULL==(attr->data = H5MM_malloc(attr->data_size))) + HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); HDmemcpy(attr->data,p,attr->data_size); /* Indicate that the fill values aren't to be written out */ diff --git a/src/H5Oefl.c b/src/H5Oefl.c index 26cb732..451efbe 100644 --- a/src/H5Oefl.c +++ b/src/H5Oefl.c @@ -407,7 +407,12 @@ H5O_efl_read (H5F_t UNUSED *f, const H5O_efl_t *efl, haddr_t addr, size_t size, uint8_t *buf) { int i, fd=-1; - size_t to_read, cur, skip=0; + size_t to_read; +#ifndef NDEBUG + hsize_t tempto_read; +#endif /* NDEBUG */ + hsize_t skip; + haddr_t cur; ssize_t n; herr_t ret_value = FAIL; @@ -422,11 +427,11 @@ H5O_efl_read (H5F_t UNUSED *f, const H5O_efl_t *efl, haddr_t addr, /* Find the first efl member from which to read */ for (i=0, cur=0; i<efl->nused; i++) { if (H5O_EFL_UNLIMITED==efl->slot[i].size || - addr < cur+efl->slot[i].size) { + addr < cur+efl->slot[i].size) { skip = addr - cur; break; } - cur += efl->slot[i].size; + cur += efl->slot[i].size; } /* Read the data */ @@ -435,7 +440,7 @@ H5O_efl_read (H5F_t UNUSED *f, const H5O_efl_t *efl, haddr_t addr, HGOTO_ERROR (H5E_EFL, H5E_OVERFLOW, FAIL, "read past logical end of file"); } - if (H5F_OVERFLOW_SIZET2OFFT (efl->slot[i].offset+skip)) { + if (H5F_OVERFLOW_HSIZET2OFFT (efl->slot[i].offset+skip)) { HGOTO_ERROR (H5E_EFL, H5E_OVERFLOW, FAIL, "external file address overflowed"); } @@ -447,7 +452,13 @@ H5O_efl_read (H5F_t UNUSED *f, const H5O_efl_t *efl, haddr_t addr, HGOTO_ERROR (H5E_EFL, H5E_SEEKERROR, FAIL, "unable to seek in external raw data file"); } - to_read = MIN(efl->slot[i].size-skip, size); +#ifndef NDEBUG + tempto_read = MIN(efl->slot[i].size-skip,(hsize_t)size); + H5_CHECK_OVERFLOW(tempto_read,hsize_t,size_t); + to_read = (size_t)tempto_read; +#else /* NDEBUG */ + to_read = MIN((size_t)(efl->slot[i].size-skip), size); +#endif /* NDEBUG */ if ((n=HDread (fd, buf, to_read))<0) { HGOTO_ERROR (H5E_EFL, H5E_READERROR, FAIL, "read error in external raw data file"); @@ -492,7 +503,12 @@ H5O_efl_write (H5F_t UNUSED *f, const H5O_efl_t *efl, haddr_t addr, size_t size, const uint8_t *buf) { int i, fd=-1; - size_t to_write, cur, skip=0; + size_t to_write; +#ifndef NDEBUG + hsize_t tempto_write; +#endif /* NDEBUG */ + haddr_t cur; + hsize_t skip; herr_t ret_value = FAIL; FUNC_ENTER (H5O_efl_write, FAIL); @@ -506,7 +522,7 @@ H5O_efl_write (H5F_t UNUSED *f, const H5O_efl_t *efl, haddr_t addr, /* Find the first efl member in which to write */ for (i=0, cur=0; i<efl->nused; i++) { if (H5O_EFL_UNLIMITED==efl->slot[i].size || - addr < cur+efl->slot[i].size) { + addr < cur+efl->slot[i].size) { skip = addr - cur; break; } @@ -519,7 +535,7 @@ H5O_efl_write (H5F_t UNUSED *f, const H5O_efl_t *efl, haddr_t addr, HGOTO_ERROR (H5E_EFL, H5E_OVERFLOW, FAIL, "write past logical end of file"); } - if (H5F_OVERFLOW_SIZET2OFFT (efl->slot[i].offset+skip)) { + if (H5F_OVERFLOW_HSIZET2OFFT (efl->slot[i].offset+skip)) { HGOTO_ERROR (H5E_EFL, H5E_OVERFLOW, FAIL, "external file address overflowed"); } @@ -536,7 +552,13 @@ H5O_efl_write (H5F_t UNUSED *f, const H5O_efl_t *efl, haddr_t addr, HGOTO_ERROR (H5E_EFL, H5E_SEEKERROR, FAIL, "unable to seek in external raw data file"); } - to_write = MIN(efl->slot[i].size-skip, size); +#ifndef NDEBUG + tempto_write = MIN(efl->slot[i].size-skip,(hsize_t)size); + H5_CHECK_OVERFLOW(tempto_write,hsize_t,size_t); + to_write = (size_t)tempto_write; +#else /* NDEBUG */ + to_write = MIN((size_t)(efl->slot[i].size-skip), size); +#endif /* NDEBUG */ if ((size_t)HDwrite (fd, buf, to_write)!=to_write) { HGOTO_ERROR (H5E_EFL, H5E_READERROR, FAIL, "write error in external raw data file"); @@ -1452,7 +1452,7 @@ herr_t H5Pset_external(hid_t plist_id, const char *name, off_t offset, hsize_t size) { int idx; - size_t total, tmp; + hsize_t total, tmp; H5O_efl_t efl; H5P_genplist_t *plist; /* Property list pointer */ herr_t ret_value=FAIL; /* return value */ @@ -1484,8 +1484,8 @@ H5Pset_external(hid_t plist_id, const char *name, off_t offset, hsize_t size) tmp = total + efl.slot[idx].size; if (tmp <= total) HGOTO_ERROR (H5E_EFL, H5E_OVERFLOW, FAIL, "total external data size overflowed"); - } - } + } /* end for */ + } /* end if */ /* Add to the list */ @@ -200,11 +200,9 @@ H5R_create(void *_ref, H5G_entry_t *loc, const char *name, H5R_type_t ref_type, buf_size+=sizeof(haddr_t); /* Allocate the space to store the serialized information */ - assert(buf_size==(hssize_t)((size_t)buf_size)); /*check for overflow*/ - if (NULL==(buf = H5MM_malloc((size_t)buf_size))) { - HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, - "memory allocation failed"); - } + H5_CHECK_OVERFLOW(buf_size,hssize_t,size_t); + if (NULL==(buf = H5MM_malloc((size_t)buf_size))) + HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed"); /* Serialize information for dataset OID */ p=(uint8_t *)buf; @@ -213,14 +211,12 @@ H5R_create(void *_ref, H5G_entry_t *loc, const char *name, H5R_type_t ref_type, /* Serialize the selection */ if (H5S_select_serialize(space,p) < 0) - HGOTO_ERROR(H5E_REFERENCE, H5E_CANTCOPY, FAIL, - "Unable to serialize selection"); + HGOTO_ERROR(H5E_REFERENCE, H5E_CANTCOPY, FAIL, "Unable to serialize selection"); /* Save the serialized buffer for later */ - assert(buf_size==(hssize_t)((size_t)buf_size)); /*check for overflow*/ + H5_CHECK_OVERFLOW(buf_size,hssize_t,size_t); if(H5HG_insert(loc->file,(size_t)buf_size,buf,&hobjid)<0) - HGOTO_ERROR(H5E_REFERENCE, H5E_WRITEERROR, FAIL, - "Unable to serialize selection"); + HGOTO_ERROR(H5E_REFERENCE, H5E_WRITEERROR, FAIL, "Unable to serialize selection"); /* Serialize the heap ID and index for storage in the file */ p=(uint8_t *)ref->heapid; diff --git a/src/H5Sall.c b/src/H5Sall.c index 0e896d9..99349cc 100644 --- a/src/H5Sall.c +++ b/src/H5Sall.c @@ -165,7 +165,7 @@ H5S_all_fgath (H5F_t *f, const struct H5O_layout_t *layout, H5S_sel_iter_t *file_iter, hsize_t nelmts, hid_t dxpl_id, void *buf/*out*/) { - size_t actual_bytes; /* The actual number of bytes to read */ + hsize_t actual_bytes; /* The actual number of bytes to read */ hsize_t buf_off; /* Dataset offset for copying memory */ FUNC_ENTER (H5S_all_fgath, 0); @@ -186,8 +186,9 @@ H5S_all_fgath (H5F_t *f, const struct H5O_layout_t *layout, /* * Read piece from file. */ + H5_CHECK_OVERFLOW(actual_bytes,hsize_t,size_t); if (H5F_seq_read(f, dxpl_id, layout, pline, fill, efl, file_space, - elmt_size, actual_bytes, buf_off, buf/*out*/)<0) { + elmt_size, (size_t)actual_bytes, buf_off, buf/*out*/)<0) { HRETURN_ERROR(H5E_DATASPACE, H5E_READERROR, 0, "read error"); } @@ -226,7 +227,7 @@ H5S_all_fscat (H5F_t *f, const struct H5O_layout_t *layout, const H5S_t *file_space, H5S_sel_iter_t *file_iter, hsize_t nelmts, hid_t dxpl_id, const void *buf) { - size_t actual_bytes; /* The actual number of bytes to write */ + hsize_t actual_bytes; /* The actual number of bytes to write */ hsize_t buf_off; /* Dataset offset for copying memory */ FUNC_ENTER (H5S_all_fscat, FAIL); @@ -247,8 +248,9 @@ H5S_all_fscat (H5F_t *f, const struct H5O_layout_t *layout, /* * Write piece from file. */ + H5_CHECK_OVERFLOW(actual_bytes,hsize_t,size_t); if (H5F_seq_write(f, dxpl_id, layout, pline, fill, efl, file_space, - elmt_size, actual_bytes, buf_off, buf/*out*/)<0) { + elmt_size, (size_t)actual_bytes, buf_off, buf/*out*/)<0) { HRETURN_ERROR(H5E_DATASPACE, H5E_WRITEERROR, 0, "write error"); } @@ -286,7 +288,7 @@ H5S_all_mgath (const void *_buf, size_t elmt_size, hsize_t nelmts, void *tconv_buf/*out*/) { const uint8_t *buf=(const uint8_t*)_buf; /* Get local copies for address arithmetic */ - size_t actual_bytes; /* The actual number of bytes to read */ + hsize_t actual_bytes; /* The actual number of bytes to read */ FUNC_ENTER (H5S_all_mgath, 0); @@ -303,7 +305,8 @@ H5S_all_mgath (const void *_buf, size_t elmt_size, actual_bytes=elmt_size*nelmts; /* "read" in the bytes from the source (buf) to the destination (tconv_buf) */ - HDmemcpy(tconv_buf,buf,actual_bytes); + H5_CHECK_OVERFLOW(actual_bytes,hsize_t,size_t); + HDmemcpy(tconv_buf,buf,(size_t)actual_bytes); /* Advance iterator */ mem_iter->all.elmt_left-=nelmts; @@ -336,7 +339,7 @@ H5S_all_mscat (const void *tconv_buf, size_t elmt_size, hsize_t nelmts, void *_buf/*out*/) { uint8_t *buf=(uint8_t *)_buf; - size_t actual_bytes; /* The actual number of bytes to write */ + hsize_t actual_bytes; /* The actual number of bytes to write */ FUNC_ENTER (H5S_all_mscat, FAIL); @@ -353,7 +356,8 @@ H5S_all_mscat (const void *tconv_buf, size_t elmt_size, actual_bytes=elmt_size*nelmts; /* "write" the bytes from the source (tconv_buf) to the destination (buf) */ - HDmemcpy(buf,tconv_buf,actual_bytes); + H5_CHECK_OVERFLOW(actual_bytes,hsize_t,size_t); + HDmemcpy(buf,tconv_buf,(size_t)actual_bytes); /* Advance iterator */ mem_iter->all.elmt_left-=nelmts; @@ -406,7 +410,7 @@ H5S_all_read(H5F_t *f, const H5O_layout_t *layout, const H5O_pline_t *pline, large_contiguous=0; int i; size_t down_size[H5O_LAYOUT_NDIMS]; - size_t acc; + hsize_t acc; FUNC_ENTER(H5S_all_read, FAIL); *must_convert = TRUE; @@ -592,7 +596,7 @@ printf("%s: check 1.0\n",FUNC); if(small_contiguous || large_contiguous) { /* Compute the "down sizes" for each dimension */ for (acc=elmt_size, i=(mem_space->extent.u.simple.rank-1); i>=0; i--) { - down_size[i]=acc; + H5_ASSIGN_OVERFLOW(down_size[i],acc,hsize_t,size_t); acc*=mem_space->extent.u.simple.size[i]; } /* end for */ @@ -674,7 +678,7 @@ H5S_all_write(H5F_t *f, const struct H5O_layout_t *layout, large_contiguous=0; int i; size_t down_size[H5O_LAYOUT_NDIMS]; - size_t acc; + hsize_t acc; FUNC_ENTER(H5S_all_write, FAIL); *must_convert = TRUE; @@ -857,7 +861,7 @@ H5S_all_write(H5F_t *f, const struct H5O_layout_t *layout, if(small_contiguous || large_contiguous) { /* Compute the "down sizes" for each dimension */ for (acc=elmt_size, i=(mem_space->extent.u.simple.rank-1); i>=0; i--) { - down_size[i]=acc; + H5_ASSIGN_OVERFLOW(down_size[i],acc,hsize_t,size_t); acc*=mem_space->extent.u.simple.size[i]; } /* end for */ diff --git a/src/H5Shyper.c b/src/H5Shyper.c index b72020e..77000e5 100644 --- a/src/H5Shyper.c +++ b/src/H5Shyper.c @@ -449,8 +449,7 @@ printf("%s: Called!\n",FUNC); ispan=iter->hyp.span; /* Set the amount of elements to perform I/O on, etc. */ - assert(nelem==(hsize_t)((size_t)(nelem))); /*check for overflow*/ - io_bytes_left=nelem*elmt_size; + H5_ASSIGN_OVERFLOW(io_bytes_left,(nelem*elmt_size),hsize_t,size_t); /* Compute the cumulative size of dataspace dimensions */ for(i=fast_dim, acc=elmt_size; i>=0; i--) { @@ -484,7 +483,7 @@ printf("%s: Called!\n",FUNC); /* Finish the span in the fastest changing dimension */ /* Compute the number of bytes to attempt in this span */ - span_size=((curr_span->high-abs_arr[fast_dim])+1)*elmt_size; + H5_ASSIGN_OVERFLOW(span_size,((curr_span->high-abs_arr[fast_dim])+1)*elmt_size,hsize_t,size_t); /* Check number of bytes against upper bounds allowed */ if(span_size>io_bytes_left) @@ -632,8 +631,7 @@ partial_done: /* Yes, goto's are evil, so sue me... :-) */ loc_off+=curr_span->pstride; /* Compute the number of elements to attempt in this span */ - assert(curr_span->nelem==(hsize_t)((size_t)(curr_span->nelem))); /*check for overflow*/ - span_size=curr_span->nelem; + H5_ASSIGN_OVERFLOW(span_size,curr_span->nelem,hsize_t,size_t); /* Check number of elements against upper bounds allowed */ if(span_size>=io_bytes_left) { @@ -868,9 +866,9 @@ H5S_hyper_fread_opt (H5F_t *f, const struct H5O_layout_t *layout, fast_dim_offset; hsize_t fast_dim_stride, /* Local copies of fastest changing dimension info */ fast_dim_block, - fast_dim_count, fast_dim_buf_off; - hsize_t tot_blk_count; /* Total number of blocks left to output */ + size_t fast_dim_count; + size_t tot_blk_count; /* Total number of blocks left to output */ size_t act_blk_count; /* Actual number of blocks to output */ int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ int temp_dim; /* Temporary rank holder */ @@ -931,8 +929,7 @@ for(i=0; i<file_space->extent.u.simple.rank; i++) } /* end for */ /* Set the number of elements left for I/O */ - assert(nelmts==(hsize_t)((size_t)nelmts)); /*check for overflow*/ - io_left=(size_t)nelmts; + H5_ASSIGN_OVERFLOW(io_left,nelmts,hsize_t,size_t); #ifdef QAK printf("%s: fast_dim=%d\n",FUNC,(int)fast_dim); @@ -954,7 +951,7 @@ printf("%s: Check 1.0\n",FUNC); leftover=file_space->select.sel_info.hslab.diminfo[fast_dim].block-((file_iter->hyp.pos[fast_dim]-file_space->select.sel_info.hslab.diminfo[fast_dim].start)%file_space->select.sel_info.hslab.diminfo[fast_dim].stride); /* Make certain that we don't read too many */ - actual_read=MIN(leftover,nelmts); + actual_read=MIN(leftover,io_left); actual_bytes=actual_read*elmt_size; /* Copy the location of the point to get */ @@ -1042,7 +1039,7 @@ for(i=0; i<ndims; i++) { buf_off+=offset[i]*slab[i]; /* Set the number of elements to read each time */ - actual_read=file_space->select.sel_info.hslab.diminfo[fast_dim].block; + H5_ASSIGN_OVERFLOW(actual_read,file_space->select.sel_info.hslab.diminfo[fast_dim].block,hsize_t,size_t); /* Set the number of actual bytes */ actual_bytes=actual_read*elmt_size; @@ -1087,7 +1084,7 @@ for(i=0; i<file_space->extent.u.simple.rank; i++) /* Read in data until an entire sequence can't be read in any longer */ while(io_left>0) { /* Reset copy of number of blocks in fastest dimension */ - fast_dim_count=tdiminfo[fast_dim].count-tmp_count[fast_dim]; + H5_ASSIGN_OVERFLOW(fast_dim_count,tdiminfo[fast_dim].count-tmp_count[fast_dim],hsize_t,size_t); /* Check if this entire row will fit into buffer */ if(fast_dim_count<=tot_blk_count) { @@ -1551,8 +1548,7 @@ printf("%s: Called!\n",FUNC); ispan=iter->hyp.span; /* Set the amount of elements to perform I/O on, etc. */ - assert(nelem==(hsize_t)((size_t)(nelem))); /*check for overflow*/ - io_bytes_left=nelem*elmt_size; + H5_ASSIGN_OVERFLOW(io_bytes_left,(nelem*elmt_size),hsize_t,size_t); /* Compute the cumulative size of dataspace dimensions */ for(i=fast_dim, acc=elmt_size; i>=0; i--) { @@ -1586,7 +1582,7 @@ printf("%s: Called!\n",FUNC); /* Finish the span in the fastest changing dimension */ /* Compute the number of bytes to attempt in this span */ - span_size=((curr_span->high-abs_arr[fast_dim])+1)*elmt_size; + H5_ASSIGN_OVERFLOW(span_size,((curr_span->high-abs_arr[fast_dim])+1)*elmt_size,hsize_t,size_t); /* Check number of bytes against upper bounds allowed */ if(span_size>io_bytes_left) @@ -1734,8 +1730,7 @@ partial_done: /* Yes, goto's are evil, so sue me... :-) */ loc_off+=curr_span->pstride; /* Compute the number of elements to attempt in this span */ - assert(curr_span->nelem==(hsize_t)((size_t)(curr_span->nelem))); /*check for overflow*/ - span_size=curr_span->nelem; + H5_ASSIGN_OVERFLOW(span_size,curr_span->nelem,hsize_t,size_t); /* Check number of elements against upper bounds allowed */ if(span_size>=io_bytes_left) { @@ -1970,9 +1965,9 @@ H5S_hyper_fwrite_opt (H5F_t *f, const struct H5O_layout_t *layout, fast_dim_offset; hsize_t fast_dim_stride, /* Local copies of fastest changing dimension info */ fast_dim_block, - fast_dim_count, fast_dim_buf_off; - hsize_t tot_blk_count; /* Total number of blocks left to output */ + size_t fast_dim_count; + size_t tot_blk_count; /* Total number of blocks left to output */ size_t act_blk_count; /* Actual number of blocks to output */ int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ int temp_dim; /* Temporary rank holder */ @@ -2033,8 +2028,7 @@ for(i=0; i<file_space->extent.u.simple.rank; i++) } /* end for */ /* Set the number of elements left for I/O */ - assert(nelmts==(hsize_t)((size_t)nelmts)); /*check for overflow*/ - io_left=(size_t)nelmts; + H5_ASSIGN_OVERFLOW(io_left,nelmts,hsize_t,size_t); #ifdef QAK printf("%s: fast_dim=%d\n",FUNC,(int)fast_dim); @@ -2056,7 +2050,7 @@ printf("%s: Check 1.0\n",FUNC); leftover=file_space->select.sel_info.hslab.diminfo[fast_dim].block-((file_iter->hyp.pos[fast_dim]-file_space->select.sel_info.hslab.diminfo[fast_dim].start)%file_space->select.sel_info.hslab.diminfo[fast_dim].stride); /* Make certain that we don't write too many */ - actual_write=MIN(leftover,nelmts); + actual_write=MIN(leftover,io_left); actual_bytes=actual_write*elmt_size; /* Copy the location of the point to get */ @@ -2144,7 +2138,7 @@ for(i=0; i<ndims; i++) { buf_off+=offset[i]*slab[i]; /* Set the number of elements to write each time */ - actual_write=file_space->select.sel_info.hslab.diminfo[fast_dim].block; + H5_ASSIGN_OVERFLOW(actual_write,file_space->select.sel_info.hslab.diminfo[fast_dim].block,hsize_t,size_t); /* Set the number of actual bytes */ actual_bytes=actual_write*elmt_size; @@ -2189,7 +2183,7 @@ for(i=0; i<file_space->extent.u.simple.rank; i++) /* Write out data until an entire sequence can't be written any longer */ while(io_left>0) { /* Reset copy of number of blocks in fastest dimension */ - fast_dim_count=tdiminfo[fast_dim].count-tmp_count[fast_dim]; + H5_ASSIGN_OVERFLOW(fast_dim_count,tdiminfo[fast_dim].count-tmp_count[fast_dim],hsize_t,size_t); /* Check if this entire row will fit into buffer */ if(fast_dim_count<=tot_blk_count) { @@ -2634,8 +2628,7 @@ printf("%s: Called!\n",FUNC); ispan=iter->hyp.span; /* Set the amount of elements to perform I/O on, etc. */ - assert(nelem==(hsize_t)((size_t)(nelem))); /*check for overflow*/ - io_bytes_left=nelem*elmt_size; + H5_ASSIGN_OVERFLOW(io_bytes_left,nelem*elmt_size,hsize_t,size_t); /* Compute the cumulative size of dataspace dimensions */ for(i=fast_dim, acc=elmt_size; i>=0; i--) { @@ -2657,13 +2650,13 @@ printf("%s: Called!\n",FUNC); /* Finish the span in the fastest changing dimension */ /* Compute the number of bytes to attempt in this span */ - span_size=((curr_span->high-abs_arr[fast_dim])+1)*elmt_size; + H5_ASSIGN_OVERFLOW(span_size,((curr_span->high-abs_arr[fast_dim])+1)*elmt_size,hsize_t,size_t); /* Check number of elements against upper bounds allowed */ if(span_size>io_bytes_left) span_size=io_bytes_left; - HDmemcpy(dst,tmp_src,(size_t)span_size); + HDmemcpy(dst,tmp_src,span_size); /* Increment offset in destination */ dst+=span_size; @@ -2800,8 +2793,7 @@ partial_done: /* Yes, goto's are evil, so sue me... :-) */ tmp_src+=curr_span->pstride; /* Compute the number of elements to attempt in this span */ - assert(curr_span->nelem==(hsize_t)((size_t)(curr_span->nelem))); /*check for overflow*/ - span_size=curr_span->nelem; + H5_ASSIGN_OVERFLOW(span_size,curr_span->nelem,hsize_t,size_t); /* Check number of elements against upper bounds allowed */ if(span_size>=io_bytes_left) { @@ -2811,7 +2803,7 @@ partial_done: /* Yes, goto's are evil, so sue me... :-) */ /* COMMON */ /* "Read" the data from the source buffer */ - HDmemcpy(dst,tmp_src,(size_t)span_size); + HDmemcpy(dst,tmp_src,span_size); /* Increment offset in destination */ dst+=span_size; @@ -2826,7 +2818,7 @@ partial_done: /* Yes, goto's are evil, so sue me... :-) */ /* COMMON */ /* "Read" the data from the source buffer */ - HDmemcpy(dst,tmp_src,(size_t)span_size); + HDmemcpy(dst,tmp_src,span_size); /* Increment offset in destination */ dst+=span_size; @@ -2983,10 +2975,10 @@ H5S_hyper_mread_opt (const void *_buf, size_t elmt_size, hssize_t fast_dim_start, /* Local copies of fastest changing dimension info */ fast_dim_offset; hsize_t fast_dim_stride, /* Local copies of fastest changing dimension info */ - fast_dim_block, - fast_dim_count; - hsize_t tot_blk_count; /* Total number of blocks left to output */ - size_t act_blk_count; /* Actual number of blocks to output */ + fast_dim_block; + size_t fast_dim_count; + size_t tot_blk_count; /* Total number of blocks left to output */ + size_t act_blk_count; /* Actual number of blocks to output */ size_t fast_dim_buf_off; /* Local copy of amount to move fastest dimension buffer offset */ int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ int temp_dim; /* Temporary rank holder */ @@ -2998,7 +2990,7 @@ H5S_hyper_mread_opt (const void *_buf, size_t elmt_size, size_t actual_bytes; /* The actual number of bytes to copy */ size_t io_left; /* The number of elements left in I/O operation */ #ifndef NO_DUFFS_DEVICE - hsize_t duffs_index; /* Counting index for Duff's device */ + size_t duffs_index; /* Counting index for Duff's device */ #endif /* NO_DUFFS_DEVICE */ FUNC_ENTER (H5S_hyper_mread_opt, 0); @@ -3036,13 +3028,12 @@ for(i=0; i<ndims; i++) #endif /* QAK */ /* Set the number of elements left for I/O */ - assert(nelmts==(hsize_t)((size_t)nelmts)); /*check for overflow*/ - io_left=(size_t)nelmts; + H5_ASSIGN_OVERFLOW(io_left,nelmts,hsize_t,size_t); /* Check if we stopped in the middle of a sequence of elements */ if((mem_iter->hyp.pos[fast_dim]-mem_space->select.sel_info.hslab.diminfo[fast_dim].start)%mem_space->select.sel_info.hslab.diminfo[fast_dim].stride!=0 || - ((mem_iter->hyp.pos[fast_dim]!=mem_space->select.sel_info.hslab.diminfo[fast_dim].start) && mem_space->select.sel_info.hslab.diminfo[fast_dim].stride==1)) { - unsigned leftover; /* The number of elements left over from the last sequence */ + ((mem_iter->hyp.pos[fast_dim]!=mem_space->select.sel_info.hslab.diminfo[fast_dim].start) && mem_space->select.sel_info.hslab.diminfo[fast_dim].stride==1)) { + size_t leftover; /* The number of elements left over from the last sequence */ #ifdef QAK printf("%s: Check 1.0, io_left=%lu\n",FUNC,(unsigned long)io_left); @@ -3054,7 +3045,7 @@ printf("%s: Check 1.0, io_left=%lu\n",FUNC,(unsigned long)io_left); leftover=mem_space->select.sel_info.hslab.diminfo[fast_dim].block-((mem_iter->hyp.pos[fast_dim]-mem_space->select.sel_info.hslab.diminfo[fast_dim].start)%mem_space->select.sel_info.hslab.diminfo[fast_dim].stride); /* Make certain that we don't write too many */ - actual_read=MIN(leftover,nelmts); + actual_read=MIN(leftover,io_left); actual_bytes=actual_read*elmt_size; /* Copy the location of the point to get */ @@ -3122,7 +3113,7 @@ printf("%s: Check 2.0, io_left=%lu\n",FUNC,(unsigned long)io_left); src+=offset[i]*slab[i]; /* Set the number of elements to write each time */ - actual_read=mem_space->select.sel_info.hslab.diminfo[fast_dim].block; + H5_ASSIGN_OVERFLOW(actual_read,mem_space->select.sel_info.hslab.diminfo[fast_dim].block,hsize_t,size_t); /* Set the number of actual bytes */ actual_bytes=actual_read*elmt_size; @@ -3147,7 +3138,7 @@ for(i=0; i<ndims; i++) fast_dim_start=tdiminfo[fast_dim].start; fast_dim_stride=tdiminfo[fast_dim].stride; fast_dim_block=tdiminfo[fast_dim].block; - fast_dim_buf_off=slab[fast_dim]*fast_dim_stride; + H5_ASSIGN_OVERFLOW(fast_dim_buf_off,(slab[fast_dim]*fast_dim_stride),hsize_t,size_t); fast_dim_offset=fast_dim_start+mem_space->select.offset[fast_dim]; /* Compute the number of blocks which would fit into the buffer */ @@ -3164,7 +3155,7 @@ for(i=0; i<ndims; i++) /* Read in data until an entire sequence can't be written out any longer */ while(io_left>0) { /* Reset copy of number of blocks in fastest dimension */ - fast_dim_count=tdiminfo[fast_dim].count-tmp_count[fast_dim]; + H5_ASSIGN_OVERFLOW(fast_dim_count,tdiminfo[fast_dim].count-tmp_count[fast_dim],hsize_t,size_t); /* Check if this entire row will fit into buffer */ if(fast_dim_count<=tot_blk_count) { @@ -3193,7 +3184,7 @@ for(i=0; i<ndims; i++) * order to make the system compuiler happy. It can be * removed when we are no longer supporting that platform. -QAK */ - switch (((size_t)fast_dim_count) % 8) { + switch (fast_dim_count % 8) { case 0: do { @@ -3510,8 +3501,7 @@ printf("%s: Called!\n",FUNC); ispan=iter->hyp.span; /* Set the amount of elements to perform I/O on, etc. */ - assert(nelem==(hsize_t)((size_t)(nelem))); /*check for overflow*/ - io_bytes_left=nelem*elmt_size; + H5_ASSIGN_OVERFLOW(io_bytes_left,nelem*elmt_size,hsize_t,size_t); /* Compute the cumulative size of dataspace dimensions */ for(i=fast_dim, acc=elmt_size; i>=0; i--) { @@ -3533,13 +3523,13 @@ printf("%s: Called!\n",FUNC); /* Finish the span in the fastest changing dimension */ /* Compute the number of bytes to attempt in this span */ - span_size=((curr_span->high-abs_arr[fast_dim])+1)*elmt_size; + H5_ASSIGN_OVERFLOW(span_size,((curr_span->high-abs_arr[fast_dim])+1)*elmt_size,hsize_t,size_t); /* Check number of elements against upper bounds allowed */ if(span_size>io_bytes_left) span_size=io_bytes_left; - HDmemcpy(tmp_dst,src,(size_t)span_size); + HDmemcpy(tmp_dst,src,span_size); /* Increment offset in destination */ src+=span_size; @@ -3676,8 +3666,7 @@ partial_done: /* Yes, goto's are evil, so sue me... :-) */ tmp_dst+=(size_t)curr_span->pstride; /* Compute the number of elements to attempt in this span */ - assert(curr_span->nelem==(hsize_t)((size_t)(curr_span->nelem))); /*check for overflow*/ - span_size=curr_span->nelem; + H5_ASSIGN_OVERFLOW(span_size,curr_span->nelem,hsize_t,size_t); /* Check number of elements against upper bounds allowed */ if(span_size>=io_bytes_left) { @@ -3687,7 +3676,7 @@ partial_done: /* Yes, goto's are evil, so sue me... :-) */ /* COMMON */ /* "Write" the data into the destination buffer */ - HDmemcpy(tmp_dst,src,(size_t)span_size); + HDmemcpy(tmp_dst,src,span_size); /* Increment offset in destination */ src+=span_size; @@ -3702,7 +3691,7 @@ partial_done: /* Yes, goto's are evil, so sue me... :-) */ /* COMMON */ /* "Write" the data into the destination buffer */ - HDmemcpy(tmp_dst,src,(size_t)span_size); + HDmemcpy(tmp_dst,src,span_size); /* Increment offset in destination */ src+=span_size; @@ -3850,7 +3839,7 @@ H5S_hyper_mwrite_opt (const void *_tconv_buf, size_t elmt_size, hsize_t slab[H5O_LAYOUT_NDIMS]; /* Hyperslab size */ hssize_t wrap[H5O_LAYOUT_NDIMS]; /* Bytes to wrap around at the end of a row */ hsize_t skip[H5O_LAYOUT_NDIMS]; /* Bytes to skip between blocks */ - hssize_t offset[H5O_LAYOUT_NDIMS]; /* Offset on disk */ + hssize_t offset[H5O_LAYOUT_NDIMS]; /* Offset on disk */ hsize_t tmp_count[H5O_LAYOUT_NDIMS]; /* Temporary block count */ hsize_t tmp_block[H5O_LAYOUT_NDIMS]; /* Temporary block offset */ const uint8_t *src=(const uint8_t *)_tconv_buf; /* Alias for pointer arithmetic */ @@ -3859,9 +3848,9 @@ H5S_hyper_mwrite_opt (const void *_tconv_buf, size_t elmt_size, hssize_t fast_dim_start, /* Local copies of fastest changing dimension info */ fast_dim_offset; hsize_t fast_dim_stride, /* Local copies of fastest changing dimension info */ - fast_dim_block, - fast_dim_count; - hsize_t tot_blk_count; /* Total number of blocks left to output */ + fast_dim_block; + size_t fast_dim_count; + size_t tot_blk_count; /* Total number of blocks left to output */ size_t act_blk_count; /* Actual number of blocks to output */ size_t fast_dim_buf_off; /* Local copy of amount to move fastest dimension buffer offset */ int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ @@ -3874,7 +3863,7 @@ H5S_hyper_mwrite_opt (const void *_tconv_buf, size_t elmt_size, size_t actual_bytes; /* The actual number of bytes to copy */ size_t io_left; /* The number of elements left in I/O operation */ #ifndef NO_DUFFS_DEVICE - hsize_t duffs_index; /* Counting index for Duff's device */ + size_t duffs_index; /* Counting index for Duff's device */ #endif /* NO_DUFFS_DEVICE */ FUNC_ENTER (H5S_hyper_mwrite_opt, 0); @@ -3912,13 +3901,12 @@ for(i=0; i<ndims; i++) #endif /* QAK */ /* Set the number of elements left for I/O */ - assert(nelmts==(hsize_t)((size_t)nelmts)); /*check for overflow*/ - io_left=(size_t)nelmts; + H5_ASSIGN_OVERFLOW(io_left,nelmts,hsize_t,size_t); /* Check if we stopped in the middle of a sequence of elements */ if((mem_iter->hyp.pos[fast_dim]-mem_space->select.sel_info.hslab.diminfo[fast_dim].start)%mem_space->select.sel_info.hslab.diminfo[fast_dim].stride!=0 || - ((mem_iter->hyp.pos[fast_dim]!=mem_space->select.sel_info.hslab.diminfo[fast_dim].start) && mem_space->select.sel_info.hslab.diminfo[fast_dim].stride==1)) { - unsigned leftover; /* The number of elements left over from the last sequence */ + ((mem_iter->hyp.pos[fast_dim]!=mem_space->select.sel_info.hslab.diminfo[fast_dim].start) && mem_space->select.sel_info.hslab.diminfo[fast_dim].stride==1)) { + size_t leftover; /* The number of elements left over from the last sequence */ #ifdef QAK printf("%s: Check 1.0, io_left=%lu\n",FUNC,(unsigned long)io_left); @@ -3930,7 +3918,7 @@ printf("%s: Check 1.0, io_left=%lu\n",FUNC,(unsigned long)io_left); leftover=mem_space->select.sel_info.hslab.diminfo[fast_dim].block-((mem_iter->hyp.pos[fast_dim]-mem_space->select.sel_info.hslab.diminfo[fast_dim].start)%mem_space->select.sel_info.hslab.diminfo[fast_dim].stride); /* Make certain that we don't write too many */ - actual_write=MIN(leftover,nelmts); + actual_write=MIN(leftover,io_left); actual_bytes=actual_write*elmt_size; /* Copy the location of the point to get */ @@ -3998,7 +3986,7 @@ printf("%s: Check 2.0, io_left=%lu\n",FUNC,(unsigned long)io_left); dst+=offset[i]*slab[i]; /* Set the number of elements to write each time */ - actual_write=mem_space->select.sel_info.hslab.diminfo[fast_dim].block; + H5_ASSIGN_OVERFLOW(actual_write,mem_space->select.sel_info.hslab.diminfo[fast_dim].block,hsize_t,size_t); /* Set the number of actual bytes */ actual_bytes=actual_write*elmt_size; @@ -4023,7 +4011,7 @@ for(i=0; i<ndims; i++) fast_dim_start=tdiminfo[fast_dim].start; fast_dim_stride=tdiminfo[fast_dim].stride; fast_dim_block=tdiminfo[fast_dim].block; - fast_dim_buf_off=slab[fast_dim]*fast_dim_stride; + H5_ASSIGN_OVERFLOW(fast_dim_buf_off,slab[fast_dim]*fast_dim_stride,hsize_t,size_t); fast_dim_offset=fast_dim_start+mem_space->select.offset[fast_dim]; /* Compute the number of blocks which would fit into the buffer */ @@ -4040,7 +4028,7 @@ for(i=0; i<ndims; i++) /* Read in data until an entire sequence can't be written out any longer */ while(io_left>0) { /* Reset copy of number of blocks in fastest dimension */ - fast_dim_count=tdiminfo[fast_dim].count-tmp_count[fast_dim]; + H5_ASSIGN_OVERFLOW(fast_dim_count,tdiminfo[fast_dim].count-tmp_count[fast_dim],hsize_t,size_t); /* Check if this entire row will fit into buffer */ if(fast_dim_count<=tot_blk_count) { @@ -4069,7 +4057,7 @@ for(i=0; i<ndims; i++) * order to make the system compuiler happy. It can be * removed when we are no longer supporting that platform. -QAK */ - switch (((size_t)fast_dim_count) % 8) { + switch (fast_dim_count % 8) { case 0: do { @@ -5901,7 +5889,7 @@ H5S_hyper_select_iterate_helper(H5S_hyper_iter_info_t *iter_info) hsize_t loc_off; /* Element offset in the dataspace */ int i; /* Index variable */ unsigned u; /* Index variable */ - hssize_t ret_value=FAIL; + herr_t ret_value=FAIL; FUNC_ENTER (H5S_hyper_select_iterate_helper, FAIL); diff --git a/src/H5Smpio.c b/src/H5Smpio.c index 73afb72..89eadd6 100644 --- a/src/H5Smpio.c +++ b/src/H5Smpio.c @@ -106,7 +106,7 @@ H5S_mpio_all_type( const H5S_t *space, const size_t elmt_size, /* fill in the return values */ *new_type = MPI_BYTE; H5_CHECK_OVERFLOW(total_bytes, hsize_t, size_t); - *count = total_bytes; + *count = (size_t)total_bytes; *is_derived_type = 0; #ifdef H5Smpi_DEBUG @@ -3473,7 +3473,7 @@ H5Tget_ebias(hid_t type_id) } /* bias */ - ebias = dt->u.atomic.u.f.ebias; + H5_ASSIGN_OVERFLOW(ebias,dt->u.atomic.u.f.ebias,uint64_t,size_t); FUNC_LEAVE(ebias); } @@ -7765,7 +7765,7 @@ H5T_array_create(H5T_t *base, int ndims, const hsize_t dim[/* ndims */], { H5T_t *ret_value = NULL; /*new array data type */ int i; /* local index variable */ - + FUNC_ENTER(H5T_array_create, NULL); assert(base); @@ -7787,8 +7787,8 @@ H5T_array_create(H5T_t *base, int ndims, const hsize_t dim[/* ndims */], /* Copy the array dimensions & compute the # of elements in the array */ for(i=0, ret_value->u.array.nelem=1; i<ndims; i++) { - ret_value->u.array.dim[i] = dim[i]; - ret_value->u.array.nelem *= dim[i]; + H5_ASSIGN_OVERFLOW(ret_value->u.array.dim[i],dim[i],hsize_t,size_t); + ret_value->u.array.nelem *= (size_t)dim[i]; } /* end for */ /* Copy the dimension permutations */ @@ -8103,12 +8103,12 @@ H5T_debug(const H5T_t *dt, FILE *stream) (unsigned long) (dt->u.atomic.u.f.esize)); tmp = dt->u.atomic.u.f.ebias >> 32; if (tmp) { - size_t hi = tmp; - size_t lo = dt->u.atomic.u.f.ebias & 0xffffffff; + size_t hi=(size_t)tmp; + size_t lo =(size_t)(dt->u.atomic.u.f.ebias & 0xffffffff); fprintf(stream, " bias=0x%08lx%08lx", (unsigned long)hi, (unsigned long)lo); } else { - size_t lo = dt->u.atomic.u.f.ebias & 0xffffffff; + size_t lo = (size_t)(dt->u.atomic.u.f.ebias & 0xffffffff); fprintf(stream, " bias=0x%08lx", (unsigned long)lo); } break; @@ -1154,13 +1154,15 @@ H5TB_ffind(H5TB_NODE * root, void * key, unsigned fast_compare, H5TB_NODE ** pp) H5TB_NODE *parent = NULL; int side; int cmp = 1; + haddr_t cmp_addr = 1; + H5TB_NODE *ret_value = NULL; FUNC_ENTER (H5TB_ffind, NULL); switch(fast_compare) { case H5TB_FAST_HADDR_COMPARE: if (ptr) { - while (0 != (cmp = (*(haddr_t *)key - *(haddr_t *)ptr->key))) { + while (0 != (cmp_addr = (*(haddr_t *)key - *(haddr_t *)ptr->key))) { parent = ptr; side = (cmp < 0) ? LEFT : RIGHT; if (!HasChild(ptr, side)) @@ -1170,6 +1172,9 @@ H5TB_ffind(H5TB_NODE * root, void * key, unsigned fast_compare, H5TB_NODE ** pp) } /* end if */ if (NULL != pp) *pp = parent; + + /* Set return value */ + ret_value= (0 == cmp_addr) ? ptr : NULL; break; case H5TB_FAST_INTN_COMPARE: @@ -1184,13 +1189,16 @@ H5TB_ffind(H5TB_NODE * root, void * key, unsigned fast_compare, H5TB_NODE ** pp) } /* end if */ if (NULL != pp) *pp = parent; + + /* Set return value */ + ret_value= (0 == cmp) ? ptr : NULL; break; default: break; } /* end switch */ - FUNC_LEAVE((0 == cmp) ? ptr : NULL); + FUNC_LEAVE(ret_value); } /* H5TB_ffind() */ /* swapkid -- Often refered to as "rotating" nodes. ptr and ptr's `side' diff --git a/src/H5Tconv.c b/src/H5Tconv.c index d339266..b9b94e9 100644 --- a/src/H5Tconv.c +++ b/src/H5Tconv.c @@ -477,6 +477,8 @@ H5T_conv_order(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts, H5T_t *dst = NULL; #ifdef NO_DUFFS_DEVICE hsize_t i; +#else /* NO_DUFFS_DEVICE */ + size_t duff_count; #endif /* NO_DUFFS_DEVICE */ size_t j, md; @@ -541,538 +543,532 @@ H5T_conv_order(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts, buf_stride = buf_stride ? buf_stride : src->size; /* Optimize for popular sizes */ - if(nelmts>0) { - switch(md) { - case 1: /* Swap 2-byte objects */ + switch(md) { + case 1: /* Swap 2-byte objects */ #ifdef NO_DUFFS_DEVICE - for (i=0; i<nelmts; i++, buf+=buf_stride) { - /* Swap the byte pair */ - tmp = buf[0]; - buf[0] = buf[1]; - buf[1] = tmp; - } + for (i=0; i<nelmts; i++, buf+=buf_stride) { + /* Swap the byte pair */ + tmp = buf[0]; + buf[0] = buf[1]; + buf[1] = tmp; + } #else /* NO_DUFFS_DEVICE */ - { - size_t duff_count = (nelmts + 7) / 8; - - switch ((long)(nelmts % 8)) - { - case 0: - do - { - /* Swap the byte pair */ - tmp = buf[0]; - buf[0] = buf[1]; - buf[1] = tmp; - buf+=buf_stride; - case 7: - /* Swap the byte pair */ - tmp = buf[0]; - buf[0] = buf[1]; - buf[1] = tmp; - buf+=buf_stride; - case 6: - /* Swap the byte pair */ - tmp = buf[0]; - buf[0] = buf[1]; - buf[1] = tmp; - buf+=buf_stride; - case 5: - /* Swap the byte pair */ - tmp = buf[0]; - buf[0] = buf[1]; - buf[1] = tmp; - buf+=buf_stride; - case 4: - /* Swap the byte pair */ - tmp = buf[0]; - buf[0] = buf[1]; - buf[1] = tmp; - buf+=buf_stride; - case 3: - /* Swap the byte pair */ - tmp = buf[0]; - buf[0] = buf[1]; - buf[1] = tmp; - buf+=buf_stride; - case 2: - /* Swap the byte pair */ - tmp = buf[0]; - buf[0] = buf[1]; - buf[1] = tmp; - buf+=buf_stride; - case 1: - /* Swap the byte pair */ - tmp = buf[0]; - buf[0] = buf[1]; - buf[1] = tmp; - buf+=buf_stride; - } - while (--duff_count > 0); - } - } + H5_CHECK_OVERFLOW(nelmts,hsize_t,size_t); + duff_count = ((size_t)nelmts + 7) / 8; + + switch ((size_t)(nelmts % 8)) + { + case 0: + do + { + /* Swap the byte pair */ + tmp = buf[0]; + buf[0] = buf[1]; + buf[1] = tmp; + buf+=buf_stride; + case 7: + /* Swap the byte pair */ + tmp = buf[0]; + buf[0] = buf[1]; + buf[1] = tmp; + buf+=buf_stride; + case 6: + /* Swap the byte pair */ + tmp = buf[0]; + buf[0] = buf[1]; + buf[1] = tmp; + buf+=buf_stride; + case 5: + /* Swap the byte pair */ + tmp = buf[0]; + buf[0] = buf[1]; + buf[1] = tmp; + buf+=buf_stride; + case 4: + /* Swap the byte pair */ + tmp = buf[0]; + buf[0] = buf[1]; + buf[1] = tmp; + buf+=buf_stride; + case 3: + /* Swap the byte pair */ + tmp = buf[0]; + buf[0] = buf[1]; + buf[1] = tmp; + buf+=buf_stride; + case 2: + /* Swap the byte pair */ + tmp = buf[0]; + buf[0] = buf[1]; + buf[1] = tmp; + buf+=buf_stride; + case 1: + /* Swap the byte pair */ + tmp = buf[0]; + buf[0] = buf[1]; + buf[1] = tmp; + buf+=buf_stride; + } + while (--duff_count > 0); + } #endif /* NO_DUFFS_DEVICE */ - break; + break; - case 2: /* Swap 4-byte objects */ + case 2: /* Swap 4-byte objects */ #ifdef NO_DUFFS_DEVICE - for (i=0; i<nelmts; i++, buf+=buf_stride) { - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[3]; - buf[3] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[1]; - buf[1] = buf[2]; - buf[2] = tmp; - } + for (i=0; i<nelmts; i++, buf+=buf_stride) { + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[3]; + buf[3] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[1]; + buf[1] = buf[2]; + buf[2] = tmp; + } #else /* NO_DUFFS_DEVICE */ - { - size_t duff_count = (nelmts + 7) / 8; - - switch ((long)(nelmts % 8)) - { - case 0: - do - { - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[3]; - buf[3] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[1]; - buf[1] = buf[2]; - buf[2] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - case 7: - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[3]; - buf[3] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[1]; - buf[1] = buf[2]; - buf[2] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - case 6: - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[3]; - buf[3] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[1]; - buf[1] = buf[2]; - buf[2] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - case 5: - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[3]; - buf[3] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[1]; - buf[1] = buf[2]; - buf[2] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - case 4: - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[3]; - buf[3] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[1]; - buf[1] = buf[2]; - buf[2] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - case 3: - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[3]; - buf[3] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[1]; - buf[1] = buf[2]; - buf[2] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - case 2: - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[3]; - buf[3] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[1]; - buf[1] = buf[2]; - buf[2] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - case 1: - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[3]; - buf[3] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[1]; - buf[1] = buf[2]; - buf[2] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - } - while (--duff_count > 0); - } - } + H5_CHECK_OVERFLOW(nelmts,hsize_t,size_t); + duff_count = ((size_t)nelmts + 7) / 8; + + switch ((size_t)(nelmts % 8)) + { + case 0: + do + { + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[3]; + buf[3] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[1]; + buf[1] = buf[2]; + buf[2] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + case 7: + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[3]; + buf[3] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[1]; + buf[1] = buf[2]; + buf[2] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + case 6: + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[3]; + buf[3] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[1]; + buf[1] = buf[2]; + buf[2] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + case 5: + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[3]; + buf[3] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[1]; + buf[1] = buf[2]; + buf[2] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + case 4: + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[3]; + buf[3] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[1]; + buf[1] = buf[2]; + buf[2] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + case 3: + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[3]; + buf[3] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[1]; + buf[1] = buf[2]; + buf[2] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + case 2: + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[3]; + buf[3] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[1]; + buf[1] = buf[2]; + buf[2] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + case 1: + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[3]; + buf[3] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[1]; + buf[1] = buf[2]; + buf[2] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + } + while (--duff_count > 0); + } #endif /* NO_DUFFS_DEVICE */ - break; + break; - case 4: /* Swap 8-byte objects */ + case 4: /* Swap 8-byte objects */ #ifdef NO_DUFFS_DEVICE - for (i=0; i<nelmts; i++, buf+=buf_stride) { - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[7]; - buf[7] = tmp; - - /* Swap the next-outer pair of bytes */ - tmp = buf[1]; - buf[1] = buf[6]; - buf[6] = tmp; - - /* Swap the next-next-outer pair of bytes */ - tmp = buf[2]; - buf[2] = buf[5]; - buf[5] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[3]; - buf[3] = buf[4]; - buf[4] = tmp; - } + for (i=0; i<nelmts; i++, buf+=buf_stride) { + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[7]; + buf[7] = tmp; + + /* Swap the next-outer pair of bytes */ + tmp = buf[1]; + buf[1] = buf[6]; + buf[6] = tmp; + + /* Swap the next-next-outer pair of bytes */ + tmp = buf[2]; + buf[2] = buf[5]; + buf[5] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[3]; + buf[3] = buf[4]; + buf[4] = tmp; + } #else /* NO_DUFFS_DEVICE */ - { - size_t duff_count = (nelmts + 7) / 8; - - switch ((long)(nelmts % 8)) - { - case 0: - do - { - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[7]; - buf[7] = tmp; - - /* Swap the next-outer pair of bytes */ - tmp = buf[1]; - buf[1] = buf[6]; - buf[6] = tmp; - - /* Swap the next-next-outer pair of bytes */ - tmp = buf[2]; - buf[2] = buf[5]; - buf[5] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[3]; - buf[3] = buf[4]; - buf[4] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - case 7: - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[7]; - buf[7] = tmp; - - /* Swap the next-outer pair of bytes */ - tmp = buf[1]; - buf[1] = buf[6]; - buf[6] = tmp; - - /* Swap the next-next-outer pair of bytes */ - tmp = buf[2]; - buf[2] = buf[5]; - buf[5] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[3]; - buf[3] = buf[4]; - buf[4] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - case 6: - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[7]; - buf[7] = tmp; - - /* Swap the next-outer pair of bytes */ - tmp = buf[1]; - buf[1] = buf[6]; - buf[6] = tmp; - - /* Swap the next-next-outer pair of bytes */ - tmp = buf[2]; - buf[2] = buf[5]; - buf[5] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[3]; - buf[3] = buf[4]; - buf[4] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - case 5: - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[7]; - buf[7] = tmp; - - /* Swap the next-outer pair of bytes */ - tmp = buf[1]; - buf[1] = buf[6]; - buf[6] = tmp; - - /* Swap the next-next-outer pair of bytes */ - tmp = buf[2]; - buf[2] = buf[5]; - buf[5] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[3]; - buf[3] = buf[4]; - buf[4] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - case 4: - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[7]; - buf[7] = tmp; - - /* Swap the next-outer pair of bytes */ - tmp = buf[1]; - buf[1] = buf[6]; - buf[6] = tmp; - - /* Swap the next-next-outer pair of bytes */ - tmp = buf[2]; - buf[2] = buf[5]; - buf[5] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[3]; - buf[3] = buf[4]; - buf[4] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - case 3: - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[7]; - buf[7] = tmp; - - /* Swap the next-outer pair of bytes */ - tmp = buf[1]; - buf[1] = buf[6]; - buf[6] = tmp; - - /* Swap the next-next-outer pair of bytes */ - tmp = buf[2]; - buf[2] = buf[5]; - buf[5] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[3]; - buf[3] = buf[4]; - buf[4] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - case 2: - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[7]; - buf[7] = tmp; - - /* Swap the next-outer pair of bytes */ - tmp = buf[1]; - buf[1] = buf[6]; - buf[6] = tmp; - - /* Swap the next-next-outer pair of bytes */ - tmp = buf[2]; - buf[2] = buf[5]; - buf[5] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[3]; - buf[3] = buf[4]; - buf[4] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - case 1: - /* Swap the outer pair of bytes */ - tmp = buf[0]; - buf[0] = buf[7]; - buf[7] = tmp; - - /* Swap the next-outer pair of bytes */ - tmp = buf[1]; - buf[1] = buf[6]; - buf[6] = tmp; - - /* Swap the next-next-outer pair of bytes */ - tmp = buf[2]; - buf[2] = buf[5]; - buf[5] = tmp; - - /* Swap the inner pair of bytes */ - tmp = buf[3]; - buf[3] = buf[4]; - buf[4] = tmp; - - /* Advance the pointer */ - buf+=buf_stride; - } - while (--duff_count > 0); - } - } + H5_CHECK_OVERFLOW(nelmts,hsize_t,size_t); + duff_count = ((size_t)nelmts + 7) / 8; + + switch ((size_t)(nelmts % 8)) + { + case 0: + do + { + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[7]; + buf[7] = tmp; + + /* Swap the next-outer pair of bytes */ + tmp = buf[1]; + buf[1] = buf[6]; + buf[6] = tmp; + + /* Swap the next-next-outer pair of bytes */ + tmp = buf[2]; + buf[2] = buf[5]; + buf[5] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[3]; + buf[3] = buf[4]; + buf[4] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + case 7: + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[7]; + buf[7] = tmp; + + /* Swap the next-outer pair of bytes */ + tmp = buf[1]; + buf[1] = buf[6]; + buf[6] = tmp; + + /* Swap the next-next-outer pair of bytes */ + tmp = buf[2]; + buf[2] = buf[5]; + buf[5] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[3]; + buf[3] = buf[4]; + buf[4] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + case 6: + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[7]; + buf[7] = tmp; + + /* Swap the next-outer pair of bytes */ + tmp = buf[1]; + buf[1] = buf[6]; + buf[6] = tmp; + + /* Swap the next-next-outer pair of bytes */ + tmp = buf[2]; + buf[2] = buf[5]; + buf[5] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[3]; + buf[3] = buf[4]; + buf[4] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + case 5: + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[7]; + buf[7] = tmp; + + /* Swap the next-outer pair of bytes */ + tmp = buf[1]; + buf[1] = buf[6]; + buf[6] = tmp; + + /* Swap the next-next-outer pair of bytes */ + tmp = buf[2]; + buf[2] = buf[5]; + buf[5] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[3]; + buf[3] = buf[4]; + buf[4] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + case 4: + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[7]; + buf[7] = tmp; + + /* Swap the next-outer pair of bytes */ + tmp = buf[1]; + buf[1] = buf[6]; + buf[6] = tmp; + + /* Swap the next-next-outer pair of bytes */ + tmp = buf[2]; + buf[2] = buf[5]; + buf[5] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[3]; + buf[3] = buf[4]; + buf[4] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + case 3: + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[7]; + buf[7] = tmp; + + /* Swap the next-outer pair of bytes */ + tmp = buf[1]; + buf[1] = buf[6]; + buf[6] = tmp; + + /* Swap the next-next-outer pair of bytes */ + tmp = buf[2]; + buf[2] = buf[5]; + buf[5] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[3]; + buf[3] = buf[4]; + buf[4] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + case 2: + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[7]; + buf[7] = tmp; + + /* Swap the next-outer pair of bytes */ + tmp = buf[1]; + buf[1] = buf[6]; + buf[6] = tmp; + + /* Swap the next-next-outer pair of bytes */ + tmp = buf[2]; + buf[2] = buf[5]; + buf[5] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[3]; + buf[3] = buf[4]; + buf[4] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + case 1: + /* Swap the outer pair of bytes */ + tmp = buf[0]; + buf[0] = buf[7]; + buf[7] = tmp; + + /* Swap the next-outer pair of bytes */ + tmp = buf[1]; + buf[1] = buf[6]; + buf[6] = tmp; + + /* Swap the next-next-outer pair of bytes */ + tmp = buf[2]; + buf[2] = buf[5]; + buf[5] = tmp; + + /* Swap the inner pair of bytes */ + tmp = buf[3]; + buf[3] = buf[4]; + buf[4] = tmp; + + /* Advance the pointer */ + buf+=buf_stride; + } + while (--duff_count > 0); + } #endif /* NO_DUFFS_DEVICE */ - break; + break; - default: /* Swap n-byte objects */ + default: /* Swap n-byte objects */ #ifdef NO_DUFFS_DEVICE - for (i=0; i<nelmts; i++, buf+=buf_stride) { - for (j=0; j<md; j++) { - tmp = buf[j]; - buf[j] = buf[src->size-(j+1)]; - buf[src->size-(j+1)] = tmp; - } + for (i=0; i<nelmts; i++, buf+=buf_stride) { + for (j=0; j<md; j++) { + tmp = buf[j]; + buf[j] = buf[src->size-(j+1)]; + buf[src->size-(j+1)] = tmp; } + } #else /* NO_DUFFS_DEVICE */ - { - size_t duff_count = (nelmts + 7) / 8; - - switch ((long)(nelmts % 8)) - { - case 0: - do - { - /* Generic byte-swapping loop */ - for (j=0; j<md; j++) { - tmp = buf[j]; - buf[j] = buf[src->size-(j+1)]; - buf[src->size-(j+1)] = tmp; - } - - /* Advance the pointer */ - buf+=buf_stride; - case 7: - /* Generic byte-swapping loop */ - for (j=0; j<md; j++) { - tmp = buf[j]; - buf[j] = buf[src->size-(j+1)]; - buf[src->size-(j+1)] = tmp; - } - - /* Advance the pointer */ - buf+=buf_stride; - case 6: - /* Generic byte-swapping loop */ - for (j=0; j<md; j++) { - tmp = buf[j]; - buf[j] = buf[src->size-(j+1)]; - buf[src->size-(j+1)] = tmp; - } - - /* Advance the pointer */ - buf+=buf_stride; - case 5: - /* Generic byte-swapping loop */ - for (j=0; j<md; j++) { - tmp = buf[j]; - buf[j] = buf[src->size-(j+1)]; - buf[src->size-(j+1)] = tmp; - } - - /* Advance the pointer */ - buf+=buf_stride; - case 4: - /* Generic byte-swapping loop */ - for (j=0; j<md; j++) { - tmp = buf[j]; - buf[j] = buf[src->size-(j+1)]; - buf[src->size-(j+1)] = tmp; - } - - /* Advance the pointer */ - buf+=buf_stride; - case 3: - /* Generic byte-swapping loop */ - for (j=0; j<md; j++) { - tmp = buf[j]; - buf[j] = buf[src->size-(j+1)]; - buf[src->size-(j+1)] = tmp; - } - - /* Advance the pointer */ - buf+=buf_stride; - case 2: - /* Generic byte-swapping loop */ - for (j=0; j<md; j++) { - tmp = buf[j]; - buf[j] = buf[src->size-(j+1)]; - buf[src->size-(j+1)] = tmp; - } - - /* Advance the pointer */ - buf+=buf_stride; - case 1: - /* Generic byte-swapping loop */ - for (j=0; j<md; j++) { - tmp = buf[j]; - buf[j] = buf[src->size-(j+1)]; - buf[src->size-(j+1)] = tmp; - } - - /* Advance the pointer */ - buf+=buf_stride; - } - while (--duff_count > 0); - } - } + H5_CHECK_OVERFLOW(nelmts,hsize_t,size_t); + duff_count = ((size_t)nelmts + 7) / 8; + + switch ((size_t)(nelmts % 8)) + { + case 0: + do + { + /* Generic byte-swapping loop */ + for (j=0; j<md; j++) { + tmp = buf[j]; + buf[j] = buf[src->size-(j+1)]; + buf[src->size-(j+1)] = tmp; + } + + /* Advance the pointer */ + buf+=buf_stride; + case 7: + /* Generic byte-swapping loop */ + for (j=0; j<md; j++) { + tmp = buf[j]; + buf[j] = buf[src->size-(j+1)]; + buf[src->size-(j+1)] = tmp; + } + + /* Advance the pointer */ + buf+=buf_stride; + case 6: + /* Generic byte-swapping loop */ + for (j=0; j<md; j++) { + tmp = buf[j]; + buf[j] = buf[src->size-(j+1)]; + buf[src->size-(j+1)] = tmp; + } + + /* Advance the pointer */ + buf+=buf_stride; + case 5: + /* Generic byte-swapping loop */ + for (j=0; j<md; j++) { + tmp = buf[j]; + buf[j] = buf[src->size-(j+1)]; + buf[src->size-(j+1)] = tmp; + } + + /* Advance the pointer */ + buf+=buf_stride; + case 4: + /* Generic byte-swapping loop */ + for (j=0; j<md; j++) { + tmp = buf[j]; + buf[j] = buf[src->size-(j+1)]; + buf[src->size-(j+1)] = tmp; + } + + /* Advance the pointer */ + buf+=buf_stride; + case 3: + /* Generic byte-swapping loop */ + for (j=0; j<md; j++) { + tmp = buf[j]; + buf[j] = buf[src->size-(j+1)]; + buf[src->size-(j+1)] = tmp; + } + + /* Advance the pointer */ + buf+=buf_stride; + case 2: + /* Generic byte-swapping loop */ + for (j=0; j<md; j++) { + tmp = buf[j]; + buf[j] = buf[src->size-(j+1)]; + buf[src->size-(j+1)] = tmp; + } + + /* Advance the pointer */ + buf+=buf_stride; + case 1: + /* Generic byte-swapping loop */ + for (j=0; j<md; j++) { + tmp = buf[j]; + buf[j] = buf[src->size-(j+1)]; + buf[src->size-(j+1)] = tmp; + } + + /* Advance the pointer */ + buf+=buf_stride; + } + while (--duff_count > 0); + } #endif /* NO_DUFFS_DEVICE */ - break; - } /* end switch */ - } /* end if */ + break; + } /* end switch */ break; case H5T_CONV_FREE: @@ -1607,8 +1603,8 @@ H5T_conv_struct(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts, src_delta = src->size; bkg_stride = dst->size; } else { - src_delta = -(src->size); - bkg_stride = -(dst->size); + src_delta = -(int)src->size; /*overflow shouldn't be possible*/ + bkg_stride = -(int)dst->size; /*overflow shouldn't be possible*/ xbuf += (nelmts-1) * src->size; xbkg += (nelmts-1) * dst->size; } @@ -2469,8 +2465,9 @@ H5T_conv_vlen(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts, /* Get length of sequences in bytes */ seq_len=(*(src->u.vlen.getlen))(src->u.vlen.f,s); assert(seq_len>=0); - src_size=seq_len*src_base_size; - dst_size=seq_len*dst_base_size; + H5_CHECK_OVERFLOW(seq_len,hssize_t,size_t); + src_size=(size_t)seq_len*src_base_size; + dst_size=(size_t)seq_len*dst_base_size; /* Check if conversion buffer is large enough, resize if * necessary */ @@ -3301,7 +3298,8 @@ H5T_conv_f_f (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts, * accomodate that value. The mantissa of course is no * longer normalized. */ - mrsh += 1-expo; + H5_ASSIGN_OVERFLOW(mrsh,(mrsh+1-expo),hssize_t,size_t); + /*mrsh += 1-expo;*/ expo = 0; } else if (expo>=expo_max) { diff --git a/src/H5Tvlen.c b/src/H5Tvlen.c index 2c305b7..0556078 100644 --- a/src/H5Tvlen.c +++ b/src/H5Tvlen.c @@ -208,7 +208,7 @@ herr_t H5T_vlen_seq_mem_write(hid_t plist_id, H5F_t UNUSED *f, void *vl_addr, vo H5MM_allocate_t alloc_func; /* Vlen allocation function */ void *alloc_info; /* Vlen allocation information */ hvl_t *vl=(hvl_t *)vl_addr; /* Pointer to the user's hvl_t information */ - size_t len=seq_len*base_size; + size_t len; H5P_genplist_t *plist; /* Property list */ FUNC_ENTER (H5T_vlen_seq_mem_write, FAIL); @@ -218,8 +218,9 @@ herr_t H5T_vlen_seq_mem_write(hid_t plist_id, H5F_t UNUSED *f, void *vl_addr, vo assert(buf); if(seq_len!=0) { + H5_ASSIGN_OVERFLOW(len,(seq_len*base_size),hsize_t,size_t); + /* Use the user's memory allocation routine is one is defined */ - assert((seq_len*base_size)==(hsize_t)((size_t)(seq_len*base_size))); /*check for overflow*/ /* Get the allocation function & info */ if(TRUE!=H5P_isa_class(plist_id,H5P_DATASET_XFER) || NULL == (plist = H5I_object(plist_id))) @@ -230,11 +231,11 @@ herr_t H5T_vlen_seq_mem_write(hid_t plist_id, H5F_t UNUSED *f, void *vl_addr, vo HRETURN_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "unable to get value"); if(alloc_func!=NULL) { - if(NULL==(vl->p=(alloc_func)((size_t)(seq_len*base_size),alloc_info))) + if(NULL==(vl->p=(alloc_func)(len,alloc_info))) HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for VL data"); } /* end if */ else { /* Default to system malloc */ - if(NULL==(vl->p=H5MM_malloc((size_t)(seq_len*base_size)))) + if(NULL==(vl->p=H5MM_malloc(len))) HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for VL data"); } /* end else */ @@ -246,7 +247,7 @@ herr_t H5T_vlen_seq_mem_write(hid_t plist_id, H5F_t UNUSED *f, void *vl_addr, vo vl->p=NULL; /* Set the sequence length */ - vl->len=seq_len; + H5_ASSIGN_OVERFLOW(vl->len,seq_len,hsize_t,size_t); FUNC_LEAVE (SUCCEED); } /* end H5T_vlen_seq_mem_write() */ @@ -331,16 +332,16 @@ herr_t H5T_vlen_str_mem_write(hid_t plist_id, H5F_t UNUSED *f, void *vl_addr, vo H5MM_allocate_t alloc_func; /* Vlen allocation function */ void *alloc_info; /* Vlen allocation information */ char **s=(char **)vl_addr; /* Pointer to the user's hvl_t information */ - size_t len=seq_len*base_size; + size_t len; H5P_genplist_t *plist; /* Property list */ FUNC_ENTER (H5T_vlen_str_mem_write, FAIL); /* check parameters */ assert(buf); + H5_CHECK_OVERFLOW(((seq_len+1)*base_size),hsize_t,size_t); - /* Use the user's memory allocation routine is one is defined */ - assert(((seq_len+1)*base_size)==(hsize_t)((size_t)((seq_len+1)*base_size))); /*check for overflow*/ + /* Use the user's memory allocation routine if one is defined */ /* Get the allocation function & info */ if(TRUE!=H5P_isa_class(plist_id,H5P_DATASET_XFER) || NULL == (plist = H5I_object(plist_id))) @@ -359,6 +360,7 @@ herr_t H5T_vlen_str_mem_write(hid_t plist_id, H5F_t UNUSED *f, void *vl_addr, vo HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for VL data"); } /* end else */ + len=(size_t)seq_len*base_size; HDmemcpy(*s,buf,len); (*s)[len]='\0'; @@ -459,7 +461,7 @@ herr_t H5T_vlen_disk_write(hid_t UNUSED plist_id, H5F_t *f, void *vl_addr, void { uint8_t *vl=(uint8_t *)vl_addr; /* Pointer to the user's hvl_t information */ H5HG_t hobjid; - size_t len=seq_len*base_size; + size_t len; FUNC_ENTER (H5T_vlen_disk_write, FAIL); @@ -469,11 +471,13 @@ herr_t H5T_vlen_disk_write(hid_t UNUSED plist_id, H5F_t *f, void *vl_addr, void assert(f); /* Set the length of the sequence */ + H5_CHECK_OVERFLOW(seq_len,hsize_t,size_t); UINT32ENCODE(vl, seq_len); /* Check if this sequence actually has any data */ if(seq_len!=0) { /* Write the VL information to disk (allocates space also) */ + H5_ASSIGN_OVERFLOW(len,(seq_len*base_size),hsize_t,size_t); if(H5HG_insert(f,len,buf,&hobjid)<0) HRETURN_ERROR(H5E_DATATYPE, H5E_WRITEERROR, FAIL, "Unable to write VL information"); } /* end if */ @@ -751,6 +751,7 @@ H5V_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *size, for (i=0; i<nelmts; i++) { /* Copy an element */ + H5_CHECK_OVERFLOW(elmt_size,hsize_t,size_t); HDmemcpy(dst, src, (size_t)elmt_size); /* Decrement indices and advance pointers */ @@ -765,7 +766,7 @@ H5V_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *size, } } } else { - assert(elmt_size==(hsize_t)((size_t)elmt_size)); /*check for overflow*/ + H5_CHECK_OVERFLOW(elmt_size,hsize_t,size_t); HDmemcpy (dst, src, (size_t)elmt_size); HRETURN (SUCCEED); } diff --git a/test/dsets.c b/test/dsets.c index 1c2956a..80ca27d 100644 --- a/test/dsets.c +++ b/test/dsets.c @@ -438,7 +438,7 @@ test_compression(hid_t file) for (i=n=0; i<size[0]; i++) { for (j=0; j<size[1]; j++) { - points[i][j] = n++; + points[i][j] = (int)(n++); } } diff --git a/test/dtypes.c b/test/dtypes.c index aa7d5cc..a170027 100644 --- a/test/dtypes.c +++ b/test/dtypes.c @@ -1174,7 +1174,7 @@ test_named (hid_t fapl) /* It should be possible to define an attribute for the named type */ if ((attr1=H5Acreate (type, "attr1", H5T_NATIVE_UCHAR, space, H5P_DEFAULT))<0) goto error; - for (i=0; i<ds_size[0]*ds_size[1]; i++) attr_data[0][i] = i;/*tricky*/ + for (i=0; i<ds_size[0]*ds_size[1]; i++) attr_data[0][i] = (int)i;/*tricky*/ if (H5Awrite(attr1, H5T_NATIVE_UINT, attr_data)<0) goto error; if (H5Aclose (attr1)<0) goto error; @@ -3375,7 +3375,7 @@ test_conv_flt_1 (const char *name, hid_t src, hid_t dst) } else if (FLT_DOUBLE==src_type) { memcpy(aligned, saved+j*sizeof(double), sizeof(double)); if (FLT_FLOAT==dst_type) { - hw_f = *((double*)aligned); + hw_f = (float)(*((double*)aligned)); hw = (unsigned char*)&hw_f; } else if (FLT_DOUBLE==dst_type) { hw_d = *((double*)aligned); diff --git a/test/external.c b/test/external.c index ce1afe0..dfb11b1 100644 --- a/test/external.c +++ b/test/external.c @@ -703,7 +703,7 @@ test_3 (hid_t fapl) hid_t dset=-1; /*dataset */ unsigned i; /*miscellaneous counters */ int fd; /*external file descriptor */ - int part[25], whole[100]; /*raw data buffers */ + int part[25],whole[100]; /*raw data buffers */ hsize_t cur_size=100; /*current data space size */ hsize_t max_size=200; /*maximum data space size */ hssize_t hs_start=100; /*hyperslab starting offset */ diff --git a/test/fillval.c b/test/fillval.c index c794ff9..693bdc6 100644 --- a/test/fillval.c +++ b/test/fillval.c @@ -396,7 +396,7 @@ test_rdwr(hid_t fapl, const char *base_name, H5D_layout_t layout) for (i=0; i<1000; i++) { for (j=0, odd=0; j<5; j++) { hs_offset[j] = rand() % cur_size[j]; - odd += hs_offset[j]%2; + odd += (int)(hs_offset[j]%2); } should_be = odd ? fillval : 9999; if (H5Sselect_hyperslab(fspace, H5S_SELECT_SET, hs_offset, NULL, @@ -594,7 +594,7 @@ test_extend(hid_t fapl, const char *base_name, H5D_layout_t layout) for (i=0; i<1000; i++) { for (j=0, odd=0; j<5; j++) { hs_offset[j] = rand() % cur_size[j]; - odd += hs_offset[j]%2; + odd += (int)(hs_offset[j]%2); } should_be = odd ? fillval : 9999; if (H5Sselect_hyperslab(fspace, H5S_SELECT_SET, hs_offset, NULL, @@ -628,7 +628,7 @@ test_extend(hid_t fapl, const char *base_name, H5D_layout_t layout) if ((hsize_t)hs_offset[j]>=cur_size[j]) { odd = 1; } else { - odd += hs_offset[j]%2; + odd += (int)(hs_offset[j]%2); } } diff --git a/test/h5test.c b/test/h5test.c index 4fae090..05df6c1 100644 --- a/test/h5test.c +++ b/test/h5test.c @@ -434,7 +434,7 @@ h5_fileaccess(void) HDmemset(memb_map, 0, sizeof memb_map); HDmemset(memb_fapl, 0, sizeof memb_fapl); - HDmemset(memb_name, 0, sizeof memb_name); + HDmemset((void*)(&memb_name[0]), 0, sizeof memb_name); HDmemset(memb_addr, 0, sizeof memb_addr); assert(HDstrlen(multi_letters)==H5FD_MEM_NTYPES); @@ -452,7 +452,7 @@ h5_fileaccess(void) } else if (!HDstrcmp(name, "family")) { /* Family of files, each 1MB and using the default driver */ if ((val=HDstrtok(NULL, " \t\n\r"))) { - fam_size = HDstrtod(val, NULL) * 1024*1024; + fam_size = (hsize_t)(HDstrtod(val, NULL) * 1024*1024); } if (H5Pset_fapl_family(fapl, fam_size, H5P_DEFAULT)<0) return -1; } else if (!HDstrcmp(name, "log")) { diff --git a/test/hyperslab.c b/test/hyperslab.c index ea11436..2fd1de5 100644 --- a/test/hyperslab.c +++ b/test/hyperslab.c @@ -212,13 +212,13 @@ test_fill(size_t nx, size_t ny, size_t nz, * original * fill values and add the new ones. */ ref_value = init_full(dst, nx, ny, nz); - for (u=dst_offset[0]; + for (u=(size_t)dst_offset[0]; u<dst_offset[0]+dx; u++) { - for (v = dst_offset[1]; + for (v = (size_t)dst_offset[1]; v < dst_offset[1] + dy; v++) { - for (w = dst_offset[2]; + for (w = (size_t)dst_offset[2]; w < dst_offset[2] + dz; w++) { ref_value -= dst[u*ny*nz+v*nz+w]; diff --git a/test/tarray.c b/test/tarray.c index 4b0943c..6b5e556 100644 --- a/test/tarray.c +++ b/test/tarray.c @@ -507,7 +507,7 @@ test_array_compound_atomic(void) for(i=0; i<SPACE1_DIM1; i++) for(j=0; j<ARRAY1_DIM1; j++) { wdata[i][j].i=i*10+j; - wdata[i][j].f=i*2.5+j; + wdata[i][j].f=(float)(i*2.5+j); } /* end for */ /* Create file */ @@ -724,7 +724,7 @@ test_array_compound_array(void) for(j=0; j<ARRAY1_DIM1; j++) { wdata[i][j].i=i*10+j; for(k=0; k<ARRAY1_DIM1; k++) - wdata[i][j].f[k]=i*10+j*2.5+k; + wdata[i][j].f[k]=(float)(i*10+j*2.5+k); } /* end for */ /* Create file */ @@ -1536,7 +1536,7 @@ test_array_bkg(void) for (j = 0; j < ALEN; j++) { cf[i].a[j] = 100*(i+1) + j; - cf[i].b[j] = 100.*(i+1) + 0.01*j; + cf[i].b[j] = (float)(100.*(i+1) + 0.01*j); cf[i].c[j] = 100.*(i+1) + 0.02*j; } } @@ -1679,7 +1679,7 @@ test_array_bkg(void) /* -------------------------------- */ for (i=0; i< LENGTH; i++) for (j = 0; j < ALEN; j++) - cf[i].b[j]=fld[i].b[j] = 1.313; + cf[i].b[j]=fld[i].b[j] = (float)1.313; status = H5Dwrite (dataset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, fld); CHECK(status, FAIL, "H5Dwrite"); diff --git a/test/tattr.c b/test/tattr.c index c9f2de2..43c87dd 100644 --- a/test/tattr.c +++ b/test/tattr.c @@ -75,7 +75,7 @@ struct attr4_struct { #define ATTR5_NAME "Attr5" #define ATTR5_RANK 0 -float attr_data5=-5.123; /* Test data for 5th attribute */ +float attr_data5=(float)-5.123; /* Test data for 5th attribute */ herr_t attr_op1(hid_t loc_id, const char *name, void *op_data); diff --git a/test/tgenprop.c b/test/tgenprop.c index 9adf1a4..c302e81 100644 --- a/test/tgenprop.c +++ b/test/tgenprop.c @@ -39,7 +39,7 @@ int prop1_def=10; /* Property 1 default value */ #define PROP1_DEF_VALUE (&prop1_def) #define PROP2_NAME "Property 2" -float prop2_def=3.14; /* Property 2 default value */ +float prop2_def=(float)3.14; /* Property 2 default value */ #define PROP2_SIZE sizeof(prop2_def) #define PROP2_DEF_VALUE (&prop2_def) diff --git a/test/th5s.c b/test/th5s.c index 54c45ac..64142ac 100644 --- a/test/th5s.c +++ b/test/th5s.c @@ -70,7 +70,7 @@ struct space4_struct { unsigned u; float f; char c2; - } space4_data={'v',987123,-3.14,'g'}; /* Test data for 4th dataspace */ + } space4_data={'v',987123,(float)-3.14,'g'}; /* Test data for 4th dataspace */ /**************************************************************** ** @@ -509,7 +509,7 @@ test_h5s_chunk(void) /* Initialize float array */ for(i=0; i<50000; i++) for(j=0; j<3; j++) - chunk_data_flt[i][j]=i*2.5-j*100.3; + chunk_data_flt[i][j]=(float)(i*2.5-j*100.3); status= H5Dwrite(dsetID,H5T_NATIVE_FLOAT,H5S_ALL,H5S_ALL,H5P_DEFAULT,chunk_data_flt); CHECK(status, FAIL, "H5Dwrite"); diff --git a/test/trefer.c b/test/trefer.c index 340ef0c..4d852d9 100644 --- a/test/trefer.c +++ b/test/trefer.c @@ -211,8 +211,8 @@ test_reference_obj(void) /* Check information in referenced dataset */ sid1 = H5Dget_space(dset2); CHECK(sid1, FAIL, "H5Dget_space"); - - ret=H5Sget_simple_extent_npoints(sid1); + + ret=(int)H5Sget_simple_extent_npoints(sid1); VERIFY(ret, 4, "H5Sget_simple_extent_npoints"); /* Read from disk */ @@ -359,7 +359,7 @@ test_reference_region(void) ret = H5Sselect_hyperslab(sid2,H5S_SELECT_SET,start,stride,count,block); CHECK(ret, FAIL, "H5Sselect_hyperslab"); - ret = H5Sget_select_npoints(sid2); + ret = (int)H5Sget_select_npoints(sid2); VERIFY(ret, 36, "H5Sget_select_npoints"); /* Store first dataset region */ @@ -380,7 +380,7 @@ test_reference_region(void) ret = H5Sselect_elements(sid2,H5S_SELECT_SET,POINT1_NPOINTS,(const hssize_t **)coord1); CHECK(ret, FAIL, "H5Sselect_elements"); - ret = H5Sget_select_npoints(sid2); + ret = (int)H5Sget_select_npoints(sid2); VERIFY(ret, 10, "H5Sget_select_npoints"); /* Store second dataset region */ @@ -431,7 +431,7 @@ test_reference_region(void) sid1 = H5Dget_space(dset2); CHECK(sid1, FAIL, "H5Dget_space"); - ret=H5Sget_simple_extent_npoints(sid1); + ret=(int)H5Sget_simple_extent_npoints(sid1); VERIFY(ret, 100, "H5Sget_simple_extent_npoints"); /* Read from disk */ @@ -446,9 +446,9 @@ test_reference_region(void) CHECK(sid2, FAIL, "H5Rget_region"); /* Verify correct hyperslab selected */ - ret = H5Sget_select_npoints(sid2); + ret = (int)H5Sget_select_npoints(sid2); VERIFY(ret, 36, "H5Sget_select_npoints"); - ret = H5Sget_select_hyper_nblocks(sid2); + ret = (int)H5Sget_select_hyper_nblocks(sid2); VERIFY(ret, 1, "H5Sget_select_hyper_nblocks"); coords=HDmalloc(ret*SPACE2_RANK*sizeof(hsize_t)*2); /* allocate space for the hyperslab blocks */ ret = H5Sget_select_hyper_blocklist(sid2,(hsize_t)0,(hsize_t)ret,coords); @@ -474,9 +474,9 @@ test_reference_region(void) CHECK(sid2, FAIL, "H5Rget_region"); /* Verify correct elements selected */ - ret = H5Sget_select_npoints(sid2); + ret = (int)H5Sget_select_npoints(sid2); VERIFY(ret, 10, "H5Sget_select_npoints"); - ret = H5Sget_select_elem_npoints(sid2); + ret = (int)H5Sget_select_elem_npoints(sid2); VERIFY(ret, 10, "H5Sget_select_elem_npoints"); coords=HDmalloc(ret*SPACE2_RANK*sizeof(hsize_t)); /* allocate space for the element points */ ret = H5Sget_select_elem_pointlist(sid2,(hsize_t)0,(hsize_t)ret,coords); diff --git a/test/tselect.c b/test/tselect.c index 32b7226..785d8be 100644 --- a/test/tselect.c +++ b/test/tselect.c @@ -348,7 +348,7 @@ test_select_point(hid_t xfer_plist) VERIFY(temp_coord1[i][2],coord1[i][2],"H5Sget_select_elem_pointlist"); } /* end for */ - ret = H5Sget_select_npoints(sid1); + ret = (int)H5Sget_select_npoints(sid1); VERIFY(ret, 10, "H5Sget_select_npoints"); /* Append another sequence of ten points to disk dataset */ @@ -373,7 +373,7 @@ test_select_point(hid_t xfer_plist) VERIFY(temp_coord1[i][2],coord1[i][2],"H5Sget_select_elem_pointlist"); } /* end for */ - ret = H5Sget_select_npoints(sid1); + ret = (int)H5Sget_select_npoints(sid1); VERIFY(ret, 20, "H5Sget_select_npoints"); /* Select sequence of ten points for memory dataset */ @@ -402,7 +402,7 @@ test_select_point(hid_t xfer_plist) /* the next list of points to the beginning of the point selection list) */ HDmemcpy(((char *)pi.coord)+sizeof(coord2),coord2,sizeof(coord2)); - ret = H5Sget_select_npoints(sid2); + ret = (int)H5Sget_select_npoints(sid2); VERIFY(ret, 10, "H5Sget_select_npoints"); /* Append another sequence of ten points to memory dataset */ @@ -426,7 +426,7 @@ test_select_point(hid_t xfer_plist) VERIFY(temp_coord2[i][1],coord2[i][1],"H5Sget_select_elem_pointlist"); } /* end for */ - ret = H5Sget_select_npoints(sid2); + ret = (int)H5Sget_select_npoints(sid2); VERIFY(ret, 20, "H5Sget_select_npoints"); /* Save points for later iteration */ @@ -468,7 +468,7 @@ test_select_point(hid_t xfer_plist) VERIFY(temp_coord3[i][1],coord3[i][1],"H5Sget_select_elem_pointlist"); } /* end for */ - ret = H5Sget_select_npoints(sid2); + ret = (int)H5Sget_select_npoints(sid2); VERIFY(ret, 10, "H5Sget_select_npoints"); /* Append another sequence of ten points to disk dataset */ @@ -491,8 +491,7 @@ test_select_point(hid_t xfer_plist) VERIFY(temp_coord3[i][0],coord3[i][0],"H5Sget_select_elem_pointlist"); VERIFY(temp_coord3[i][1],coord3[i][1],"H5Sget_select_elem_pointlist"); } /* end for */ - - ret = H5Sget_select_npoints(sid2); + ret = (int)H5Sget_select_npoints(sid2); VERIFY(ret, 20, "H5Sget_select_npoints"); /* Read selection from disk */ diff --git a/test/tvltypes.c b/test/tvltypes.c index 8e59bd2..bfda390 100644 --- a/test/tvltypes.c +++ b/test/tvltypes.c @@ -254,7 +254,7 @@ test_vltypes_vlen_compound(void) wdata[i].len=i+1; for(j=0; j<(i+1); j++) { ((s1 *)wdata[i].p)[j].i=i*10+j; - ((s1 *)wdata[i].p)[j].f=(i*20+j)/3.0; + ((s1 *)wdata[i].p)[j].f=(float)((i*20+j)/3.0); } /* end for */ } /* end for */ @@ -401,7 +401,7 @@ test_vltypes_compound_vlen_atomic(void) /* Allocate and initialize VL data to write */ for(i=0; i<SPACE1_DIM1; i++) { wdata[i].i=i*10; - wdata[i].f=(i*20)/3.0; + wdata[i].f=(float)((i*20)/3.0); wdata[i].v.p=malloc((i+1)*sizeof(unsigned int)); wdata[i].v.len=i+1; for(j=0; j<(i+1); j++) diff --git a/tools/gifconv/hdf2gif.c b/tools/gifconv/hdf2gif.c index c2ddb10..cc7bab4 100644 --- a/tools/gifconv/hdf2gif.c +++ b/tools/gifconv/hdf2gif.c @@ -16,7 +16,7 @@ */ #include <stdio.h> - +#include <assert.h> #include "gif.h" #define MAX_FILE_LEN 256 @@ -208,8 +208,10 @@ int main(int argc , char **argv) return -1; } - RWidth = dim_sizes[1]; - RHeight = dim_sizes[0]; + assert(dim_sizes[0]==(hsize_t)((int)dim_sizes[0])); + assert(dim_sizes[1]==(hsize_t)((int)dim_sizes[1])); + RWidth = (int)dim_sizes[1]; + RHeight = (int)dim_sizes[0]; #ifdef UNUSED w = dim_sizes[1]; h = dim_sizes[0]; diff --git a/tools/gifconv/hdfgifwr.c b/tools/gifconv/hdfgifwr.c index b13b79a..9804098 100644 --- a/tools/gifconv/hdfgifwr.c +++ b/tools/gifconv/hdfgifwr.c @@ -152,7 +152,9 @@ static unsigned long cur_accum = 0; static int cur_bits = 0; #define MAXCODE(n_bits) ( (1 << (n_bits)) - 1) +#ifndef WIN32 #define min(a,b) ((a>b) ? b : a) +#endif #define XV_BITS 12 /* BITS was already defined on some systems */ #define MSDOS 1 #define HSIZE 5003 /* 80% occupancy */ diff --git a/tools/h5dump/h5dump.c b/tools/h5dump/h5dump.c index 82b67ca..efb0e42 100644 --- a/tools/h5dump/h5dump.c +++ b/tools/h5dump/h5dump.c @@ -4670,6 +4670,7 @@ xml_dump_dataset(hid_t did, const char *name, struct subset_t * UNUSED sset) hsize_t *chsize; int ndims; int i; + hsize_t tempi; char *tmp; char *t_name, *t_tmp, *t_prefix; @@ -4735,9 +4736,9 @@ xml_dump_dataset(hid_t did, const char *name, struct subset_t * UNUSED sset) indent += COL; H5Aiterate(did, NULL, dump_function_table->dump_attribute_function, NULL); indent -= COL; - i = H5Dget_storage_size(did); - - if (display_data && (i > 0)) { + tempi = H5Dget_storage_size(did); + + if (display_data && (tempi > 0)) { switch (H5Tget_class(type)) { case H5T_INTEGER: case H5T_FLOAT: diff --git a/tools/h5dump/h5dumptst.c b/tools/h5dump/h5dumptst.c index 9ad987f..4399859 100644 --- a/tools/h5dump/h5dumptst.c +++ b/tools/h5dump/h5dumptst.c @@ -393,17 +393,17 @@ static void test_compound_dt(void) { /* test compound data type */ for (i = 0; i < (int)sdim; i++) { dset1[i].a = i; - dset1[i].b = i*i; - dset1[i].c = 1./(i+1); + dset1[i].b = (float)(i*i); + dset1[i].c = (float)(1./(i+1)); dset2[i].a = i; - dset2[i].b = i+ i*0.1; + dset2[i].b = (float)(i+ i*0.1); dset4[i].a = i; - dset4[i].b = i+3; + dset4[i].b = (float)(i+3); dset5[i].a = i; - dset5[i].b = i*0.1; + dset5[i].b = (float)(i*0.1); } @@ -478,7 +478,7 @@ static void test_compound_dt(void) { /* test compound data type */ dset3[i][j].a[k] = k+j+i; for (k = 0; k < 5; k++) for (l = 0; l < 6; l++) - dset3[i][j].b[k][l] = (k+1)+l+j+i; + dset3[i][j].b[k][l] = (float)((k+1)+l+j+i); } } H5Dwrite(dataset, type2, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset3); @@ -580,17 +580,17 @@ static void test_compound_dt2(void) { /* test compound data type */ sdim = 10; for (i = 0; i < (int)sdim; i++) { dset1[i].a = i; - dset1[i].b = i*i; - dset1[i].c = 1./(i+1); + dset1[i].b = (float)(i*i); + dset1[i].c = (float)(1./(i+1)); dset2[i].a = i; - dset2[i].b = i+ i*0.1; + dset2[i].b = (float)(i+ i*0.1); dset4[i].a = i; - dset4[i].b = i*1.0; + dset4[i].b = (float)(i*1.0); dset5[i].a = i; - dset5[i].b = i*1.0; + dset5[i].b = (float)(i*1.0); } fid = H5Fcreate(FILE9, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); @@ -826,7 +826,7 @@ float dset2_1[10], dset2_2[3][5]; space = H5Screate_simple(1, dims, NULL); dataset = H5Dcreate(group, "dset2.1", H5T_IEEE_F32BE, space, H5P_DEFAULT); for (i = 0; i < 10; i++) - dset2_1[i] = i*0.1+1; + dset2_1[i] = (float)(i*0.1+1); H5Dwrite(dataset, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2_1); H5Sclose(space); H5Dclose(dataset); @@ -837,7 +837,7 @@ float dset2_1[10], dset2_2[3][5]; dataset = H5Dcreate(group, "dset2.2", H5T_IEEE_F32BE, space, H5P_DEFAULT); for (i = 0; i < 3; i++) for (j = 0; j < 5; j++) - dset2_2[i][j] = (i+1)*j*0.1; + dset2_2[i][j] = (float)((i+1)*j*0.1); H5Dwrite(dataset, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2_2); H5Sclose(space); H5Dclose(dataset); @@ -1693,7 +1693,7 @@ static void test_nestcomp(void) */ for (i = 0; i< 10; i++) { s1[i].a = i; - s1[i].b = i*i; + s1[i].b = (float)(i*i); s1[i].c = 1./(i+1); s1[i].d.a = 65 + i; s1[i].d.b[0] = -100.; @@ -1896,7 +1896,7 @@ static void test_vldatatypes(void) wdata[i].len = i + 1; for (j = 0; j < i + 1; j++) - ((float *)wdata[i].p)[j] = i * 10 + ((float)j) / 10.0; + ((float *)wdata[i].p)[j] = (float)(i * 10 + ((float)j) / 10.0); } /* write out the floats in little-endian format */ @@ -2029,7 +2029,7 @@ static void test_vldatatypes3(void) /* Allocate and initialize VL data to write */ for(i=0; i<SPACE1_DIM1; i++) { wdata[i].i=i*10; - wdata[i].f=(i*20)/3.0; + wdata[i].f=(float)((i*20)/3.0); wdata[i].v.p=malloc((i+1)*sizeof(unsigned int)); wdata[i].v.len=i+1; for(j=0; j<(i+1); j++) @@ -2101,7 +2101,7 @@ static void test_vldatatypes4(void) wdata[i].len=i+1; for(j=0; j<(i+1); j++) { ((s1 *)wdata[i].p)[j].i=i*10+j; - ((s1 *)wdata[i].p)[j].f=(i*20+j)/3.0; + ((s1 *)wdata[i].p)[j].f=(float)((i*20+j)/3.0); } /* end for */ } /* end for */ @@ -2311,7 +2311,7 @@ static void test_array4(void) for(i=0; i<SPACE1_DIM1; i++) for(j=0; j<ARRAY1_DIM1; j++) { wdata[i][j].i=i*10+j; - wdata[i][j].f=i*2.5+j; + wdata[i][j].f=(float)(i*2.5+j); } /* end for */ /* Create file */ @@ -2379,7 +2379,7 @@ static void test_array5(void) for(j=0; j<ARRAY1_DIM1; j++) { wdata[i][j].i=i*10+j; for(k=0; k<ARRAY1_DIM1; k++) - wdata[i][j].f[k]=i*10+j*2.5+k; + wdata[i][j].f[k]=(float)(i*10+j*2.5+k); } /* end for */ /* Create file */ diff --git a/tools/h5ls/h5ls.c b/tools/h5ls/h5ls.c index 8aa69f9..bfbe251 100644 --- a/tools/h5ls/h5ls.c +++ b/tools/h5ls/h5ls.c @@ -1252,6 +1252,7 @@ list_attr (hid_t obj, const char *attr_name, void * UNUSED op_data) hsize_t size[64], nelmts=1; int ndims, i, n; size_t need; + hsize_t temp_need; void *buf; h5dump_t info; @@ -1314,7 +1315,10 @@ list_attr (hid_t obj, const char *attr_name, void * UNUSED op_data) p_type = h5tools_fixtype(type); } if (p_type>=0) { - need = nelmts * MAX(H5Tget_size(type), H5Tget_size(p_type)); + temp_need= nelmts * MAX(H5Tget_size(type), H5Tget_size(p_type)); + assert(temp_need==(hsize_t)((size_t)temp_need)); + need = (size_t)temp_need; + /*need = nelmts * MAX(H5Tget_size(type), H5Tget_size(p_type));*/ buf = malloc(need); assert(buf); if (H5Aread(attr, p_type, buf)>=0) { diff --git a/tools/lib/h5tools.c b/tools/lib/h5tools.c index 569fe2f..c97914a 100644 --- a/tools/lib/h5tools.c +++ b/tools/lib/h5tools.c @@ -649,7 +649,8 @@ h5tools_dump_simple_subset(FILE *stream, const h5dump_t *info, hid_t dset, ctx.p_min_idx[i] = 0; H5Sget_simple_extent_dims(f_space, total_size, NULL); - ctx.size_last_dim = total_size[ctx.ndims - 1]; + assert(total_size[ctx.ndims - 1]==(hsize_t)((int)(total_size[ctx.ndims - 1]))); + ctx.size_last_dim = (int)(total_size[ctx.ndims - 1]); count = sset->count[ctx.ndims - 1]; sset->count[ctx.ndims - 1] = 1; @@ -819,7 +820,10 @@ h5tools_dump_simple_dset(FILE *stream, const h5dump_t *info, hid_t dset, ctx.p_min_idx[i] = 0; H5Sget_simple_extent_dims(f_space, total_size, NULL); - ctx.size_last_dim = total_size[ctx.ndims - 1]; + /* printf("total_size[ctx.ndims-1]%d\n",total_size[ctx.ndims-1]); + printf("total_size cast %d\n",(int)(total_size[ctx.ndims-1])); */ + /*assert(total_size[ctx.ndims - 1]==(hsize_t)((int)(total_size[ctx.ndims - 1])));*/ + ctx.size_last_dim = (total_size[ctx.ndims - 1]); /* calculate the number of elements we're going to print */ p_nelmts = 1; @@ -975,8 +979,8 @@ h5tools_dump_simple_mem(FILE *stream, const h5dump_t *info, hid_t obj_id, if (nelmts == 0) return SUCCEED; /*nothing to print*/ - - ctx.size_last_dim = ctx.p_max_idx[ctx.ndims - 1]; + assert(ctx.p_max_idx[ctx.ndims - 1]==(hsize_t)((int)ctx.p_max_idx[ctx.ndims - 1])); + ctx.size_last_dim = (int)(ctx.p_max_idx[ctx.ndims - 1]); /* Print it */ h5tools_dump_simple_data(stream, info, obj_id, &ctx, diff --git a/tools/lib/h5tools_str.c b/tools/lib/h5tools_str.c index 0e3c5c7..2bc6305 100644 --- a/tools/lib/h5tools_str.c +++ b/tools/lib/h5tools_str.c @@ -786,7 +786,7 @@ h5tools_str_sprint(h5tools_str_t *str, const h5dump_t *info, hid_t container, } } else if (H5Tget_class(type) == H5T_ARRAY) { int k, ndims; - hsize_t i, dims[H5S_MAX_RANK]; + hsize_t i, dims[H5S_MAX_RANK],temp_nelmts; /* Get the array's base datatype for each element */ memb = H5Tget_super(type); @@ -796,9 +796,12 @@ h5tools_str_sprint(h5tools_str_t *str, const h5dump_t *info, hid_t container, assert(ndims >= 1 && ndims <= H5S_MAX_RANK); /* Calculate the number of array elements */ - for (k = 0, nelmts = 1; k < ndims; k++) - nelmts *= dims[k]; - + for (k = 0, nelmts = 1; k < ndims; k++){ + temp_nelmts = nelmts; + temp_nelmts *= dims[k]; + assert(temp_nelmts==(hsize_t)((size_t)temp_nelmts)); + nelmts = (size_t)temp_nelmts; + } /* Print the opening bracket */ h5tools_str_append(str, "%s", OPT(info->arr_pre, "[")); |