mirrors/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2026-09-25 04:09:44 +03:00
Code Issues Packages Projects Releases Wiki Activity

[svn-r4643] Purpose:

Browse Source 
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)
This commit is contained in:
Quincey Koziol
2001-11-27 11:29:13 -05:00
parent 05264c8878
commit d456c2bb82
49 changed files with 874 additions and 800 deletions
Download Patch File Download Diff File Expand all files Collapse all files
hl/tools/gif2h5/hdf2gif.c
+5 -3
View File
@@ -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];
hl/tools/gif2h5/hdfgifwr.c
+2
View File
@@ -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 */
src/H5A.c
+25 -49
View File
@@ -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));
src/H5B.c
+3 -3
View File
@@ -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*/
}
/*
src/H5D.c
+13 -10
View File
@@ -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);
src/H5Distore.c
+25 -17
View File
@@ -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");
}
src/H5Dprivate.h
+1 -1
View File
@@ -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 */
src/H5F.c
+2 -1
View File
@@ -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;
src/H5FD.c
+15 -6
View File
@@ -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) {
src/H5FDcore.c
+14 -3
View File
@@ -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;
src/H5FDdpss.c
+1 -1
View File
@@ -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);
src/H5FDfamily.c
+28 -4
View File
@@ -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)
src/H5FDlog.c
+1 -1
View File
@@ -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)
src/H5Farray.c
+5 -6
View File
@@ -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 {
src/H5Fistore.c
+25 -17
View File
@@ -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");
}
src/H5Fpkg.h
+6
View File
@@ -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 {
src/H5O.c
+1
View File
@@ -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");
src/H5Oattr.c
+14 -26
View File
@@ -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 */
src/H5Oefl.c
+31 -9
View File
@@ -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");
src/H5P.c
+3 -3
View 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 */
src/H5R.c
+6 -10
View File
@@ -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;
src/H5Sall.c
+16 -12
View File
@@ -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 */
src/H5Shyper.c
+57 -69
View File
@@ -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);
src/H5Smpio.c
+1 -1
View File
@@ -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
src/H5T.c
+7 -7
View File
@@ -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;
src/H5TB.c
+10 -2
View File
@@ -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'
src/H5Tconv.c
+455 -457
View File
@@ -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;
H5_CHECK_OVERFLOW(nelmts,hsize_t,size_t);
duff_count = ((size_t)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);
}
}
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;
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;
}
/* 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;
H5_CHECK_OVERFLOW(nelmts,hsize_t,size_t);
duff_count = ((size_t)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;
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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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);
}
}
/* 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;
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-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 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;
}
/* 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;
H5_CHECK_OVERFLOW(nelmts,hsize_t,size_t);
duff_count = ((size_t)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;
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-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 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;
/* 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;
/* 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-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 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;
/* 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;
/* 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-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 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;
/* 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;
/* 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-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 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;
/* 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;
/* 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-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 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;
/* 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;
/* 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-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 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;
/* 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;
/* 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-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 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;
/* 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;
/* 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-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 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;
/* 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);
}
}
/* 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;
H5_CHECK_OVERFLOW(nelmts,hsize_t,size_t);
duff_count = ((size_t)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;
}
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 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 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 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 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 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 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;
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);
}
}
/* 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) {
src/H5Tvlen.c
+13 -9
View File
@@ -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 */
src/H5V.c
+2 -1
View File
@@ -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);
}
test/dsets.c
+1 -1
View File
@@ -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++);
}
}
test/dtypes.c
+2 -2
View File
@@ -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);
test/external.c
+1 -1
View File
@@ -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 */
test/fillval.c
+3 -3
View File
@@ -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);
}
}
test/h5test.c
+2 -2
View File
@@ -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")) {
test/hyperslab.c
+3 -3
View File
@@ -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];
test/tarray.c
+4 -4
View File
@@ -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");
test/tattr.c
+1 -1
View File
@@ -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);
test/tgenprop.c
+1 -1
View File
@@ -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)
test/th5s.c
+2 -2
View File
@@ -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");
test/trefer.c
+9 -9
View File
@@ -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);
test/tselect.c
+6 -7
View File
@@ -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 */
test/tvltypes.c
+2 -2
View File
@@ -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++)
tools/gifconv/hdf2gif.c
+5 -3
View File
@@ -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];
tools/gifconv/hdfgifwr.c
+2
View File
@@ -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 */
tools/h5dump/h5dump.c
+4 -3
View File
@@ -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:
tools/h5dump/h5dumptst.c
+19 -19
View File
@@ -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 */
tools/h5ls/h5ls.c
+5 -1
View File
@@ -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) {
tools/lib/h5tools.c
+8 -4
View File
@@ -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,
tools/lib/h5tools_str.c
+7 -4
View File
@@ -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, "["));