summaryrefslogtreecommitdiffstats
path: root/src/H5Tconv.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/H5Tconv.c')
-rw-r--r--src/H5Tconv.c3586
1 files changed, 1818 insertions, 1768 deletions
diff --git a/src/H5Tconv.c b/src/H5Tconv.c
index f15acf7..43d9dd2 100644
--- a/src/H5Tconv.c
+++ b/src/H5Tconv.c
@@ -285,11 +285,11 @@ H5FL_BLK_DEFINE_STATIC(array_seq);
cdata->need_bkg = H5T_BKG_NO; \
if (NULL==(st=H5I_object_verify(src_id,H5I_DATATYPE)) || \
NULL==(dt=H5I_object_verify(dst_id,H5I_DATATYPE))) { \
- HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, \
+ HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, \
"unable to dereference data type object ID"); \
} \
if (st->size!=sizeof(ST) || dt->size!=sizeof(DT)) { \
- HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, \
+ HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, \
"disagreement about data type size"); \
} \
CI_ALLOC_PRIV \
@@ -355,7 +355,7 @@ H5FL_BLK_DEFINE_STATIC(array_seq);
break; \
\
default: \
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, \
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, \
"unknown conversion command"); \
} \
}
@@ -381,7 +381,7 @@ H5FL_BLK_DEFINE_STATIC(array_seq);
/* Allocate private alignment structure for atomic types */
# define CI_ALLOC_PRIV \
if (NULL==(cdata->priv=H5MM_calloc(sizeof(H5T_conv_hw_t)))) { \
- HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, \
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, \
"memory allocation failed"); \
}
@@ -395,17 +395,18 @@ H5FL_BLK_DEFINE_STATIC(array_seq);
/* Increment destination alignment counter */
# define CI_INC_DST(d) if (d) ((H5T_conv_hw_t *)cdata->priv)->d_aligned += nelmts;
-#else
+#else /* H5T_DEBUG */
# define CI_PRINT_STATS(STYPE,DTYPE) /*void*/
# define CI_ALLOC_PRIV cdata->priv=NULL;
# define CI_FREE_PRIV /* void */
# define CI_INC_SRC(s) /* void */
# define CI_INC_DST(d) /* void */
-#endif
+#endif /* H5T_DEBUG */
/* Swap two elements (I & J) of an array using a temporary variable */
#define H5_SWAP_BYTES(ARRAY,I,J) {uint8_t _tmp; _tmp=ARRAY[I]; ARRAY[I]=ARRAY[J]; ARRAY[J]=_tmp;}
+
/*-------------------------------------------------------------------------
* Function: H5T_conv_noop
*
@@ -427,6 +428,8 @@ H5T_conv_noop(hid_t UNUSED src_id, hid_t UNUSED dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void UNUSED *buf,
void UNUSED *background, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_noop, FAIL);
switch (cdata->command) {
@@ -442,13 +445,14 @@ H5T_conv_noop(hid_t UNUSED src_id, hid_t UNUSED dst_id, H5T_cdata_t *cdata,
break;
default:
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unknown conversion command");
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
}
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
+
/*-------------------------------------------------------------------------
* Function: H5T_conv_order_opt
*
@@ -477,6 +481,7 @@ H5T_conv_order_opt(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
H5T_t *src = NULL;
H5T_t *dst = NULL;
hsize_t i;
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5T_conv_order_opt, FAIL);
@@ -485,45 +490,38 @@ H5T_conv_order_opt(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
/* Capability query */
if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
if (src->size != dst->size ||
- 0 != src->u.atomic.offset ||
- 0 != dst->u.atomic.offset ||
- !((H5T_ORDER_BE == src->u.atomic.order &&
- H5T_ORDER_LE == dst->u.atomic.order) ||
- (H5T_ORDER_LE == src->u.atomic.order &&
- H5T_ORDER_BE == dst->u.atomic.order))) {
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "conversion not supported");
- }
+ 0 != src->u.atomic.offset ||
+ 0 != dst->u.atomic.offset ||
+ !((H5T_ORDER_BE == src->u.atomic.order &&
+ H5T_ORDER_LE == dst->u.atomic.order) ||
+ (H5T_ORDER_LE == src->u.atomic.order &&
+ H5T_ORDER_BE == dst->u.atomic.order)))
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "conversion not supported");
if (src->size!=1 && src->size!=2 && src->size!=4 &&
- src->size!=8 && src->size!=16) {
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "conversion not supported");
- }
+ src->size!=8 && src->size!=16)
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "conversion not supported");
switch (src->type) {
- case H5T_INTEGER:
- case H5T_BITFIELD:
- /* nothing to check */
- break;
-
- case H5T_FLOAT:
- if (src->u.atomic.u.f.sign != dst->u.atomic.u.f.sign ||
- src->u.atomic.u.f.epos != dst->u.atomic.u.f.epos ||
- src->u.atomic.u.f.esize != dst->u.atomic.u.f.esize ||
- src->u.atomic.u.f.ebias != dst->u.atomic.u.f.ebias ||
- src->u.atomic.u.f.mpos != dst->u.atomic.u.f.mpos ||
- src->u.atomic.u.f.msize != dst->u.atomic.u.f.msize ||
- src->u.atomic.u.f.norm != dst->u.atomic.u.f.norm ||
- src->u.atomic.u.f.pad != dst->u.atomic.u.f.pad) {
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "conversion not supported");
- }
- break;
-
- default:
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "conversion not supported");
+ case H5T_INTEGER:
+ case H5T_BITFIELD:
+ /* nothing to check */
+ break;
+
+ case H5T_FLOAT:
+ if (src->u.atomic.u.f.sign != dst->u.atomic.u.f.sign ||
+ src->u.atomic.u.f.epos != dst->u.atomic.u.f.epos ||
+ src->u.atomic.u.f.esize != dst->u.atomic.u.f.esize ||
+ src->u.atomic.u.f.ebias != dst->u.atomic.u.f.ebias ||
+ src->u.atomic.u.f.mpos != dst->u.atomic.u.f.mpos ||
+ src->u.atomic.u.f.msize != dst->u.atomic.u.f.msize ||
+ src->u.atomic.u.f.norm != dst->u.atomic.u.f.norm ||
+ src->u.atomic.u.f.pad != dst->u.atomic.u.f.pad)
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "conversion not supported");
+ break;
+
+ default:
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "conversion not supported");
}
cdata->need_bkg = H5T_BKG_NO;
break;
@@ -532,7 +530,7 @@ H5T_conv_order_opt(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
/* The conversion */
if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
buf_stride = buf_stride ? buf_stride : src->size;
switch (src->size) {
@@ -826,11 +824,11 @@ H5T_conv_order_opt(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
break;
default:
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unknown conversion command");
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
}
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -867,6 +865,7 @@ H5T_conv_order(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
H5T_t *dst = NULL;
hsize_t i;
size_t j, md;
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5T_conv_order, FAIL);
@@ -875,40 +874,35 @@ H5T_conv_order(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
/* Capability query */
if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
- if (src->size != dst->size ||
- 0 != src->u.atomic.offset ||
- 0 != dst->u.atomic.offset ||
- !((H5T_ORDER_BE == src->u.atomic.order &&
- H5T_ORDER_LE == dst->u.atomic.order) ||
- (H5T_ORDER_LE == src->u.atomic.order &&
- H5T_ORDER_BE == dst->u.atomic.order))) {
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "conversion not supported");
- }
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ if (src->size != dst->size || 0 != src->u.atomic.offset ||
+ 0 != dst->u.atomic.offset ||
+ !((H5T_ORDER_BE == src->u.atomic.order &&
+ H5T_ORDER_LE == dst->u.atomic.order) ||
+ (H5T_ORDER_LE == src->u.atomic.order &&
+ H5T_ORDER_BE == dst->u.atomic.order)))
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "conversion not supported");
switch (src->type) {
- case H5T_INTEGER:
- case H5T_BITFIELD:
- /* nothing to check */
- break;
-
- case H5T_FLOAT:
- if (src->u.atomic.u.f.sign != dst->u.atomic.u.f.sign ||
- src->u.atomic.u.f.epos != dst->u.atomic.u.f.epos ||
- src->u.atomic.u.f.esize != dst->u.atomic.u.f.esize ||
- src->u.atomic.u.f.ebias != dst->u.atomic.u.f.ebias ||
- src->u.atomic.u.f.mpos != dst->u.atomic.u.f.mpos ||
- src->u.atomic.u.f.msize != dst->u.atomic.u.f.msize ||
- src->u.atomic.u.f.norm != dst->u.atomic.u.f.norm ||
- src->u.atomic.u.f.pad != dst->u.atomic.u.f.pad) {
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "conversion not supported");
- }
- break;
+ case H5T_INTEGER:
+ case H5T_BITFIELD:
+ /* nothing to check */
+ break;
+
+ case H5T_FLOAT:
+ if (src->u.atomic.u.f.sign != dst->u.atomic.u.f.sign ||
+ src->u.atomic.u.f.epos != dst->u.atomic.u.f.epos ||
+ src->u.atomic.u.f.esize != dst->u.atomic.u.f.esize ||
+ src->u.atomic.u.f.ebias != dst->u.atomic.u.f.ebias ||
+ src->u.atomic.u.f.mpos != dst->u.atomic.u.f.mpos ||
+ src->u.atomic.u.f.msize != dst->u.atomic.u.f.msize ||
+ src->u.atomic.u.f.norm != dst->u.atomic.u.f.norm ||
+ src->u.atomic.u.f.pad != dst->u.atomic.u.f.pad) {
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "conversion not supported");
+ }
+ break;
- default:
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "conversion not supported");
+ default:
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "conversion not supported");
}
cdata->need_bkg = H5T_BKG_NO;
break;
@@ -917,14 +911,13 @@ H5T_conv_order(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
/* The conversion */
if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
buf_stride = buf_stride ? buf_stride : src->size;
md = src->size / 2;
for (i=0; i<nelmts; i++, buf+=buf_stride) {
- for (j=0; j<md; j++) {
+ for (j=0; j<md; j++)
H5_SWAP_BYTES(buf, j, src->size-(j+1));
- }
}
break;
@@ -933,13 +926,14 @@ H5T_conv_order(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
break;
default:
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unknown conversion command");
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
}
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
+
/*-------------------------------------------------------------------------
* Function: H5T_conv_b_b
*
@@ -973,184 +967,179 @@ H5T_conv_b_b(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
uint8_t dbuf[256]; /*temp destination buffer */
size_t msb_pad_offset; /*offset for dest MSB padding */
size_t i;
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5T_conv_b_b, FAIL);
switch(cdata->command) {
- case H5T_CONV_INIT:
- /* Capability query */
- if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
- NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
- if (H5T_ORDER_LE!=src->u.atomic.order &&
- H5T_ORDER_BE!=src->u.atomic.order) {
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unsupported byte order");
- }
- if (H5T_ORDER_LE!=dst->u.atomic.order &&
- H5T_ORDER_BE!=dst->u.atomic.order) {
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unsupported byte order");
- }
- cdata->need_bkg = H5T_BKG_NO;
- break;
+ case H5T_CONV_INIT:
+ /* Capability query */
+ if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
+ NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ if (H5T_ORDER_LE!=src->u.atomic.order &&
+ H5T_ORDER_BE!=src->u.atomic.order)
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unsupported byte order");
+ if (H5T_ORDER_LE!=dst->u.atomic.order &&
+ H5T_ORDER_BE!=dst->u.atomic.order)
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unsupported byte order");
+ cdata->need_bkg = H5T_BKG_NO;
+ break;
- case H5T_CONV_FREE:
- break;
+ case H5T_CONV_FREE:
+ break;
- case H5T_CONV_CONV:
- /* Get the data types */
- if (NULL==(src=H5I_object_verify(src_id,H5I_DATATYPE)) ||
- NULL==(dst=H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
-
- /*
- * Do we process the values from beginning to end or vice versa? Also,
- * how many of the elements have the source and destination areas
- * overlapping?
- */
- if (src->size==dst->size || buf_stride) {
- sp = dp = (uint8_t*)buf;
- direction = 1;
- olap = nelmts;
- } else if (src->size>=dst->size) {
- double olap_d = HDceil((double)(dst->size)/
- (double)(src->size-dst->size));
-
- olap = (size_t)olap_d;
- sp = dp = (uint8_t*)buf;
- direction = 1;
- } else {
- double olap_d = HDceil((double)(src->size)/
- (double)(dst->size-src->size));
- olap = (size_t)olap_d;
- sp = (uint8_t*)buf + (nelmts-1) * src->size;
- dp = (uint8_t*)buf + (nelmts-1) * dst->size;
- direction = -1;
- }
+ case H5T_CONV_CONV:
+ /* Get the data types */
+ if (NULL==(src=H5I_object_verify(src_id,H5I_DATATYPE)) ||
+ NULL==(dst=H5I_object_verify(dst_id,H5I_DATATYPE)))
+ HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+
+ /*
+ * Do we process the values from beginning to end or vice versa? Also,
+ * how many of the elements have the source and destination areas
+ * overlapping?
+ */
+ if (src->size==dst->size || buf_stride) {
+ sp = dp = (uint8_t*)buf;
+ direction = 1;
+ olap = nelmts;
+ } else if (src->size>=dst->size) {
+ double olap_d = HDceil((double)(dst->size)/
+ (double)(src->size-dst->size));
+
+ olap = (size_t)olap_d;
+ sp = dp = (uint8_t*)buf;
+ direction = 1;
+ } else {
+ double olap_d = HDceil((double)(src->size)/
+ (double)(dst->size-src->size));
+ olap = (size_t)olap_d;
+ sp = (uint8_t*)buf + (nelmts-1) * src->size;
+ dp = (uint8_t*)buf + (nelmts-1) * dst->size;
+ direction = -1;
+ }
- /* The conversion loop */
- for (elmtno=0; elmtno<nelmts; elmtno++) {
+ /* The conversion loop */
+ for (elmtno=0; elmtno<nelmts; elmtno++) {
- /*
- * If the source and destination buffers overlap then use a
- * temporary buffer for the destination.
- */
- if (direction>0) {
- s = sp;
- d = elmtno<olap ? dbuf : dp;
- } else {
- s = sp;
- d = elmtno+olap >= nelmts ? dbuf : dp;
- }
+ /*
+ * If the source and destination buffers overlap then use a
+ * temporary buffer for the destination.
+ */
+ if (direction>0) {
+ s = sp;
+ d = elmtno<olap ? dbuf : dp;
+ } else {
+ s = sp;
+ d = elmtno+olap >= nelmts ? dbuf : dp;
+ }
#ifndef NDEBUG
- /* I don't quite trust the overlap calculations yet --rpm */
- if (d==dbuf) {
- assert ((dp>=sp && dp<sp+src->size) ||
- (sp>=dp && sp<dp+dst->size));
- } else {
- assert ((dp<sp && dp+dst->size<=sp) ||
- (sp<dp && sp+src->size<=dp));
- }
+ /* I don't quite trust the overlap calculations yet --rpm */
+ if (d==dbuf) {
+ assert ((dp>=sp && dp<sp+src->size) ||
+ (sp>=dp && sp<dp+dst->size));
+ } else {
+ assert ((dp<sp && dp+dst->size<=sp) ||
+ (sp<dp && sp+src->size<=dp));
+ }
#endif
-
- /*
- * Put the data in little endian order so our loops aren't so
- * complicated. We'll do all the conversion stuff assuming
- * little endian and then we'll fix the order at the end.
- */
- if (H5T_ORDER_BE==src->u.atomic.order) {
- half_size = src->size/2;
- for (i=0; i<half_size; i++) {
- uint8_t tmp = s[src->size-(i+1)];
- s[src->size-(i+1)] = s[i];
- s[i] = tmp;
- }
- }
+
+ /*
+ * Put the data in little endian order so our loops aren't so
+ * complicated. We'll do all the conversion stuff assuming
+ * little endian and then we'll fix the order at the end.
+ */
+ if (H5T_ORDER_BE==src->u.atomic.order) {
+ half_size = src->size/2;
+ for (i=0; i<half_size; i++) {
+ uint8_t tmp = s[src->size-(i+1)];
+ s[src->size-(i+1)] = s[i];
+ s[i] = tmp;
+ }
+ }
- /*
- * Copy the significant part of the value. If the source is larger
- * than the destination then invoke the overflow function or copy
- * as many bits as possible. Zero extra bits in the destination.
- */
- if (src->u.atomic.prec>dst->u.atomic.prec) {
- if (!H5T_overflow_g ||
- (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
- H5T_bit_copy(d, dst->u.atomic.offset,
- s, src->u.atomic.offset, dst->u.atomic.prec);
- }
- } else {
- H5T_bit_copy(d, dst->u.atomic.offset,
- s, src->u.atomic.offset,
- src->u.atomic.prec);
- H5T_bit_set(d, dst->u.atomic.offset+src->u.atomic.prec,
- dst->u.atomic.prec-src->u.atomic.prec, FALSE);
- }
+ /*
+ * Copy the significant part of the value. If the source is larger
+ * than the destination then invoke the overflow function or copy
+ * as many bits as possible. Zero extra bits in the destination.
+ */
+ if (src->u.atomic.prec>dst->u.atomic.prec) {
+ if (!H5T_overflow_g ||
+ (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
+ H5T_bit_copy(d, dst->u.atomic.offset,
+ s, src->u.atomic.offset, dst->u.atomic.prec);
+ }
+ } else {
+ H5T_bit_copy(d, dst->u.atomic.offset,
+ s, src->u.atomic.offset,
+ src->u.atomic.prec);
+ H5T_bit_set(d, dst->u.atomic.offset+src->u.atomic.prec,
+ dst->u.atomic.prec-src->u.atomic.prec, FALSE);
+ }
- /*
- * Fill the destination padding areas.
- */
- switch (dst->u.atomic.lsb_pad) {
- case H5T_PAD_ZERO:
- H5T_bit_set(d, 0, dst->u.atomic.offset, FALSE);
- break;
- case H5T_PAD_ONE:
- H5T_bit_set(d, 0, dst->u.atomic.offset, TRUE);
- break;
- default:
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unsupported LSB padding");
- }
- msb_pad_offset = dst->u.atomic.offset + dst->u.atomic.prec;
- switch (dst->u.atomic.msb_pad) {
- case H5T_PAD_ZERO:
- H5T_bit_set(d, msb_pad_offset, 8*dst->size-msb_pad_offset,
- FALSE);
- break;
- case H5T_PAD_ONE:
- H5T_bit_set(d, msb_pad_offset, 8*dst->size-msb_pad_offset,
- TRUE);
- break;
- default:
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unsupported MSB padding");
- }
+ /*
+ * Fill the destination padding areas.
+ */
+ switch (dst->u.atomic.lsb_pad) {
+ case H5T_PAD_ZERO:
+ H5T_bit_set(d, 0, dst->u.atomic.offset, FALSE);
+ break;
+ case H5T_PAD_ONE:
+ H5T_bit_set(d, 0, dst->u.atomic.offset, TRUE);
+ break;
+ default:
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unsupported LSB padding");
+ }
+ msb_pad_offset = dst->u.atomic.offset + dst->u.atomic.prec;
+ switch (dst->u.atomic.msb_pad) {
+ case H5T_PAD_ZERO:
+ H5T_bit_set(d, msb_pad_offset, 8*dst->size-msb_pad_offset,
+ FALSE);
+ break;
+ case H5T_PAD_ONE:
+ H5T_bit_set(d, msb_pad_offset, 8*dst->size-msb_pad_offset,
+ TRUE);
+ break;
+ default:
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unsupported MSB padding");
+ }
- /*
- * Put the destination in the correct byte order. See note at
- * beginning of loop.
- */
- if (H5T_ORDER_BE==dst->u.atomic.order) {
- half_size = dst->size/2;
- for (i=0; i<half_size; i++) {
- uint8_t tmp = d[dst->size-(i+1)];
- d[dst->size-(i+1)] = d[i];
- d[i] = tmp;
- }
- }
+ /*
+ * Put the destination in the correct byte order. See note at
+ * beginning of loop.
+ */
+ if (H5T_ORDER_BE==dst->u.atomic.order) {
+ half_size = dst->size/2;
+ for (i=0; i<half_size; i++) {
+ uint8_t tmp = d[dst->size-(i+1)];
+ d[dst->size-(i+1)] = d[i];
+ d[i] = tmp;
+ }
+ }
- /*
- * If we had used a temporary buffer for the destination then we
- * should copy the value to the true destination buffer.
- */
- if (d==dbuf) HDmemcpy (dp, d, dst->size);
- if (buf_stride) {
- sp += direction * buf_stride;
- dp += direction * buf_stride;
- } else {
- sp += direction * src->size;
- dp += direction * dst->size;
- }
- }
-
- break;
+ /*
+ * If we had used a temporary buffer for the destination then we
+ * should copy the value to the true destination buffer.
+ */
+ if (d==dbuf) HDmemcpy (dp, d, dst->size);
+ if (buf_stride) {
+ sp += direction * buf_stride;
+ dp += direction * buf_stride;
+ } else {
+ sp += direction * src->size;
+ dp += direction * dst->size;
+ }
+ }
+
+ break;
- default:
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unknown conversion command");
+ default:
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
}
- FUNC_LEAVE (SUCCEED);
+done:
+ FUNC_LEAVE (ret_value);
}
@@ -1188,6 +1177,7 @@ H5T_conv_struct_init (H5T_t *src, H5T_t *dst, H5T_cdata_t *cdata)
int i, j, *src2dst = NULL;
H5T_t *type = NULL;
hid_t tid;
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOINIT(H5T_conv_struct_init);
@@ -1196,15 +1186,13 @@ H5T_conv_struct_init (H5T_t *src, H5T_t *dst, H5T_cdata_t *cdata)
* Allocate private data structure and arrays.
*/
if (NULL==(priv=cdata->priv=H5MM_calloc(sizeof(H5T_conv_struct_t))) ||
- NULL==(priv->src2dst=H5MM_malloc(src->u.compnd.nmembs *
- sizeof(int))) ||
- NULL==(priv->src_memb_id=H5MM_malloc(src->u.compnd.nmembs *
- sizeof(hid_t))) ||
- NULL==(priv->dst_memb_id=H5MM_malloc(dst->u.compnd.nmembs *
- sizeof(hid_t)))) {
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
- "memory allocation failed");
- }
+ NULL==(priv->src2dst=H5MM_malloc(src->u.compnd.nmembs *
+ sizeof(int))) ||
+ NULL==(priv->src_memb_id=H5MM_malloc(src->u.compnd.nmembs *
+ sizeof(hid_t))) ||
+ NULL==(priv->dst_memb_id=H5MM_malloc(dst->u.compnd.nmembs *
+ sizeof(hid_t))))
+ HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
src2dst = priv->src2dst;
/*
@@ -1251,10 +1239,8 @@ H5T_conv_struct_init (H5T_t *src, H5T_t *dst, H5T_cdata_t *cdata)
src2dst = priv->src2dst;
H5MM_xfree(priv->memb_path);
if (NULL==(priv->memb_path=H5MM_malloc(src->u.compnd.nmembs *
- sizeof(H5T_path_t*)))) {
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
- "memory allocation failed");
- }
+ sizeof(H5T_path_t*))))
+ HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
for (i=0; i<src->u.compnd.nmembs; i++) {
if (src2dst[i]>=0) {
@@ -1267,8 +1253,7 @@ H5T_conv_struct_init (H5T_t *src, H5T_t *dst, H5T_cdata_t *cdata)
H5MM_xfree(priv->dst_memb_id);
H5MM_xfree(priv->memb_path);
cdata->priv = priv = H5MM_xfree (priv);
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unable to convert member data type");
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unable to convert member data type");
}
}
}
@@ -1278,9 +1263,12 @@ H5T_conv_struct_init (H5T_t *src, H5T_t *dst, H5T_cdata_t *cdata)
cdata->need_bkg = H5T_BKG_YES;
cdata->recalc = FALSE;
- FUNC_LEAVE (SUCCEED);
+
+done:
+ FUNC_LEAVE (ret_value);
}
+
/*-------------------------------------------------------------------------
* Function: H5T_conv_struct
*
@@ -1339,174 +1327,167 @@ H5T_conv_struct(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
hsize_t elmtno;
int i; /*counters */
H5T_conv_struct_t *priv = (H5T_conv_struct_t *)(cdata->priv);
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5T_conv_struct, FAIL);
switch (cdata->command) {
- case H5T_CONV_INIT:
- /*
- * First, determine if this conversion function applies to the
- * conversion path SRC_ID-->DST_ID. If not, return failure;
- * otherwise initialize the `priv' field of `cdata' with information
- * that remains (almost) constant for this conversion path.
- */
- if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
- NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
- assert (H5T_COMPOUND==src->type);
- assert (H5T_COMPOUND==dst->type);
+ case H5T_CONV_INIT:
+ /*
+ * First, determine if this conversion function applies to the
+ * conversion path SRC_ID-->DST_ID. If not, return failure;
+ * otherwise initialize the `priv' field of `cdata' with information
+ * that remains (almost) constant for this conversion path.
+ */
+ if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
+ NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ assert (H5T_COMPOUND==src->type);
+ assert (H5T_COMPOUND==dst->type);
- if (H5T_conv_struct_init (src, dst, cdata)<0) {
- HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL,
- "unable to initialize conversion data");
- }
- break;
+ if (H5T_conv_struct_init (src, dst, cdata)<0)
+ HGOTO_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to initialize conversion data");
+ break;
- case H5T_CONV_FREE:
- /*
- * Free the private conversion data.
- */
- H5MM_xfree(priv->src2dst);
- H5MM_xfree(priv->src_memb_id);
- H5MM_xfree(priv->dst_memb_id);
- H5MM_xfree(priv->memb_path);
- cdata->priv = priv = H5MM_xfree (priv);
- break;
+ case H5T_CONV_FREE:
+ /*
+ * Free the private conversion data.
+ */
+ H5MM_xfree(priv->src2dst);
+ H5MM_xfree(priv->src_memb_id);
+ H5MM_xfree(priv->dst_memb_id);
+ H5MM_xfree(priv->memb_path);
+ cdata->priv = priv = H5MM_xfree (priv);
+ break;
- case H5T_CONV_CONV:
- /*
- * Conversion.
- */
- if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
- NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
- assert (priv);
- assert (bkg && cdata->need_bkg);
+ case H5T_CONV_CONV:
+ /*
+ * Conversion.
+ */
+ if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
+ NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ assert (priv);
+ assert (bkg && cdata->need_bkg);
- if (cdata->recalc && H5T_conv_struct_init (src, dst, cdata)<0) {
- HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL,
- "unable to initialize conversion data");
- }
+ if (cdata->recalc && H5T_conv_struct_init (src, dst, cdata)<0)
+ HGOTO_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to initialize conversion data");
+
+ /*
+ * Insure that members are sorted.
+ */
+ H5T_sort_value(src, NULL);
+ H5T_sort_value(dst, NULL);
+ src2dst = priv->src2dst;
- /*
- * Insure that members are sorted.
- */
- H5T_sort_value(src, NULL);
- H5T_sort_value(dst, NULL);
- src2dst = priv->src2dst;
-
- /*
- * Direction of conversion and striding through background.
- */
- if (buf_stride) {
- src_delta = buf_stride;
- if (!bkg_stride)
+ /*
+ * Direction of conversion and striding through background.
+ */
+ if (buf_stride) {
+ src_delta = buf_stride;
+ if (!bkg_stride)
+ bkg_stride = dst->size;
+ } else if (dst->size <= src->size) {
+ src_delta = src->size;
bkg_stride = dst->size;
- } else if (dst->size <= src->size) {
- src_delta = src->size;
- bkg_stride = dst->size;
- } else {
- 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;
- }
+ } else {
+ 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;
+ }
- /* Conversion loop... */
- for (elmtno=0; elmtno<nelmts; elmtno++) {
- /*
- * For each source member which will be present in the
- * destination, convert the member to the destination type unless
- * it is larger than the source type. Then move the member to the
- * left-most unoccupied position in the buffer. This makes the
- * data point as small as possible with all the free space on the
- * right side.
- */
- for (i=0, offset=0; i<src->u.compnd.nmembs; i++) {
- if (src2dst[i]<0) continue; /*subsetting*/
- src_memb = src->u.compnd.memb + i;
- dst_memb = dst->u.compnd.memb + src2dst[i];
-
- if (dst_memb->size <= src_memb->size) {
- if (H5T_convert(priv->memb_path[i], priv->src_memb_id[i],
- priv->dst_memb_id[src2dst[i]],
- (hsize_t)1, 0, 0, /*no striding (packed array)*/
- xbuf+src_memb->offset, xbkg+dst_memb->offset,
- dset_xfer_plist)<0) {
- HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
- "unable to convert compound data type member");
- }
- HDmemmove (xbuf+offset, xbuf+src_memb->offset,
- dst_memb->size);
- offset += dst_memb->size;
- } else {
- HDmemmove (xbuf+offset, xbuf+src_memb->offset,
- src_memb->size);
- offset += src_memb->size;
- }
- }
+ /* Conversion loop... */
+ for (elmtno=0; elmtno<nelmts; elmtno++) {
+ /*
+ * For each source member which will be present in the
+ * destination, convert the member to the destination type unless
+ * it is larger than the source type. Then move the member to the
+ * left-most unoccupied position in the buffer. This makes the
+ * data point as small as possible with all the free space on the
+ * right side.
+ */
+ for (i=0, offset=0; i<src->u.compnd.nmembs; i++) {
+ if (src2dst[i]<0) continue; /*subsetting*/
+ src_memb = src->u.compnd.memb + i;
+ dst_memb = dst->u.compnd.memb + src2dst[i];
+
+ if (dst_memb->size <= src_memb->size) {
+ if (H5T_convert(priv->memb_path[i], priv->src_memb_id[i],
+ priv->dst_memb_id[src2dst[i]],
+ (hsize_t)1, 0, 0, /*no striding (packed array)*/
+ xbuf+src_memb->offset, xbkg+dst_memb->offset,
+ dset_xfer_plist)<0)
+ HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to convert compound data type member");
+ HDmemmove (xbuf+offset, xbuf+src_memb->offset,
+ dst_memb->size);
+ offset += dst_memb->size;
+ } else {
+ HDmemmove (xbuf+offset, xbuf+src_memb->offset,
+ src_memb->size);
+ offset += src_memb->size;
+ }
+ }
- /*
- * For each source member which will be present in the
- * destination, convert the member to the destination type if it
- * is larger than the source type (that is, has not been converted
- * yet). Then copy the member to the destination offset in the
- * background buffer.
- */
- for (i=src->u.compnd.nmembs-1; i>=0; --i) {
- if (src2dst[i]<0) continue; /*subsetting*/
- src_memb = src->u.compnd.memb + i;
- dst_memb = dst->u.compnd.memb + src2dst[i];
-
- if (dst_memb->size > src_memb->size) {
- offset -= src_memb->size;
- if (H5T_convert(priv->memb_path[i],
- priv->src_memb_id[i], priv->dst_memb_id[src2dst[i]],
- (hsize_t)1, 0, 0, /*no striding (packed array)*/
- xbuf+offset, xbkg+dst_memb->offset,
- dset_xfer_plist)<0) {
- HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
- "unable to convert compound data type member");
- }
- } else {
- offset -= dst_memb->size;
- }
- HDmemmove (xbkg+dst_memb->offset, xbuf+offset, dst_memb->size);
- }
- assert (0==offset);
+ /*
+ * For each source member which will be present in the
+ * destination, convert the member to the destination type if it
+ * is larger than the source type (that is, has not been converted
+ * yet). Then copy the member to the destination offset in the
+ * background buffer.
+ */
+ for (i=src->u.compnd.nmembs-1; i>=0; --i) {
+ if (src2dst[i]<0) continue; /*subsetting*/
+ src_memb = src->u.compnd.memb + i;
+ dst_memb = dst->u.compnd.memb + src2dst[i];
+
+ if (dst_memb->size > src_memb->size) {
+ offset -= src_memb->size;
+ if (H5T_convert(priv->memb_path[i],
+ priv->src_memb_id[i], priv->dst_memb_id[src2dst[i]],
+ (hsize_t)1, 0, 0, /*no striding (packed array)*/
+ xbuf+offset, xbkg+dst_memb->offset,
+ dset_xfer_plist)<0)
+ HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to convert compound data type member");
+ } else {
+ offset -= dst_memb->size;
+ }
+ HDmemmove (xbkg+dst_memb->offset, xbuf+offset, dst_memb->size);
+ }
+ assert (0==offset);
- /*
- * Update pointers
- */
- xbuf += src_delta;
- xbkg += bkg_stride;
- }
+ /*
+ * Update pointers
+ */
+ xbuf += src_delta;
+ xbkg += bkg_stride;
+ }
- /* If the bkg_stride was set to -(dst->size), make it positive now */
- if(buf_stride==0 && dst->size>src->size)
- bkg_stride=dst->size;
-
- /*
- * Copy the background buffer back into the in-place conversion
- * buffer.
- */
- for (xbuf=buf, xbkg=bkg, elmtno=0; elmtno<nelmts; elmtno++) {
- HDmemmove(xbuf, xbkg, dst->size);
- xbuf += buf_stride ? buf_stride : dst->size;
- xbkg += bkg_stride;
- }
- break;
+ /* If the bkg_stride was set to -(dst->size), make it positive now */
+ if(buf_stride==0 && dst->size>src->size)
+ bkg_stride=dst->size;
- default:
- /* Some other command we don't know about yet.*/
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unknown conversion command");
+ /*
+ * Copy the background buffer back into the in-place conversion
+ * buffer.
+ */
+ for (xbuf=buf, xbkg=bkg, elmtno=0; elmtno<nelmts; elmtno++) {
+ HDmemmove(xbuf, xbkg, dst->size);
+ xbuf += buf_stride ? buf_stride : dst->size;
+ xbkg += bkg_stride;
+ }
+ break;
+
+ default:
+ /* Some other command we don't know about yet.*/
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
}
- FUNC_LEAVE (SUCCEED);
+done:
+ FUNC_LEAVE (ret_value);
}
-
+
/*-------------------------------------------------------------------------
* Function: H5T_conv_struct_opt
*
@@ -1578,209 +1559,198 @@ H5T_conv_struct_opt(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t elmtno; /*element counter */
int i; /*counters */
H5T_conv_struct_t *priv = NULL; /*private data */
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5T_conv_struct_opt, FAIL);
switch (cdata->command) {
- case H5T_CONV_INIT:
- /*
- * First, determine if this conversion function applies to the
- * conversion path SRC_ID-->DST_ID. If not, return failure;
- * otherwise initialize the `priv' field of `cdata' with information
- * that remains (almost) constant for this conversion path.
- */
- if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
- NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
- assert (H5T_COMPOUND==src->type);
- assert (H5T_COMPOUND==dst->type);
-
- /* Initialize data which is relatively constant */
- if (H5T_conv_struct_init (src, dst, cdata)<0) {
- HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL,
- "unable to initialize conversion data");
- }
- priv = (H5T_conv_struct_t *)(cdata->priv);
- src2dst = priv->src2dst;
-
- /*
- * If the destination type is not larger than the source type then
- * this conversion function is guaranteed to work (provided all
- * members can be converted also). Otherwise the determination is
- * quite a bit more complicated. Essentially we have to make sure
- * that there is always room in the source buffer to do the
- * conversion of a member in place. This is basically the same pair
- * of loops as in the actual conversion except it checks that there
- * is room for each conversion instead of actually doing anything.
- */
- if (dst->size > src->size) {
- for (i=0, offset=0; i<src->u.compnd.nmembs; i++) {
- if (src2dst[i]<0)
- continue;
- src_memb = src->u.compnd.memb + i;
- dst_memb = dst->u.compnd.memb + src2dst[i];
- if (dst_memb->size > src_memb->size)
- offset += src_memb->size;
- }
- for (i=src->u.compnd.nmembs-1; i>=0; --i) {
- if (src2dst[i]<0)
- continue;
- src_memb = src->u.compnd.memb + i;
- dst_memb = dst->u.compnd.memb + src2dst[i];
- if (dst_memb->size > src_memb->size) {
- offset -= src_memb->size;
- if (dst_memb->size > src->size-offset) {
- H5MM_xfree(priv->src2dst);
- H5MM_xfree(priv->src_memb_id);
- H5MM_xfree(priv->dst_memb_id);
- H5MM_xfree(priv->memb_path);
- cdata->priv = priv = H5MM_xfree (priv);
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "convertion is unsupported by this "
- "function");
+ case H5T_CONV_INIT:
+ /*
+ * First, determine if this conversion function applies to the
+ * conversion path SRC_ID-->DST_ID. If not, return failure;
+ * otherwise initialize the `priv' field of `cdata' with information
+ * that remains (almost) constant for this conversion path.
+ */
+ if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
+ NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ assert (H5T_COMPOUND==src->type);
+ assert (H5T_COMPOUND==dst->type);
+
+ /* Initialize data which is relatively constant */
+ if (H5T_conv_struct_init (src, dst, cdata)<0)
+ HGOTO_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to initialize conversion data");
+ priv = (H5T_conv_struct_t *)(cdata->priv);
+ src2dst = priv->src2dst;
+
+ /*
+ * If the destination type is not larger than the source type then
+ * this conversion function is guaranteed to work (provided all
+ * members can be converted also). Otherwise the determination is
+ * quite a bit more complicated. Essentially we have to make sure
+ * that there is always room in the source buffer to do the
+ * conversion of a member in place. This is basically the same pair
+ * of loops as in the actual conversion except it checks that there
+ * is room for each conversion instead of actually doing anything.
+ */
+ if (dst->size > src->size) {
+ for (i=0, offset=0; i<src->u.compnd.nmembs; i++) {
+ if (src2dst[i]<0)
+ continue;
+ src_memb = src->u.compnd.memb + i;
+ dst_memb = dst->u.compnd.memb + src2dst[i];
+ if (dst_memb->size > src_memb->size)
+ offset += src_memb->size;
+ }
+ for (i=src->u.compnd.nmembs-1; i>=0; --i) {
+ if (src2dst[i]<0)
+ continue;
+ src_memb = src->u.compnd.memb + i;
+ dst_memb = dst->u.compnd.memb + src2dst[i];
+ if (dst_memb->size > src_memb->size) {
+ offset -= src_memb->size;
+ if (dst_memb->size > src->size-offset) {
+ H5MM_xfree(priv->src2dst);
+ H5MM_xfree(priv->src_memb_id);
+ H5MM_xfree(priv->dst_memb_id);
+ H5MM_xfree(priv->memb_path);
+ cdata->priv = priv = H5MM_xfree (priv);
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "convertion is unsupported by this function");
+ }
+ }
}
}
- }
- }
- break;
+ break;
- case H5T_CONV_FREE:
- /*
- * Free the private conversion data.
- */
- priv = (H5T_conv_struct_t *)(cdata->priv);
- H5MM_xfree(priv->src2dst);
- H5MM_xfree(priv->src_memb_id);
- H5MM_xfree(priv->dst_memb_id);
- H5MM_xfree(priv->memb_path);
- cdata->priv = priv = H5MM_xfree (priv);
- break;
+ case H5T_CONV_FREE:
+ /*
+ * Free the private conversion data.
+ */
+ priv = (H5T_conv_struct_t *)(cdata->priv);
+ H5MM_xfree(priv->src2dst);
+ H5MM_xfree(priv->src_memb_id);
+ H5MM_xfree(priv->dst_memb_id);
+ H5MM_xfree(priv->memb_path);
+ cdata->priv = priv = H5MM_xfree (priv);
+ break;
- case H5T_CONV_CONV:
- /*
- * Conversion.
- */
- if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
- NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ case H5T_CONV_CONV:
+ /*
+ * Conversion.
+ */
+ if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
+ NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
- /* Update cached data if necessary */
- if (cdata->recalc && H5T_conv_struct_init (src, dst, cdata)<0) {
- HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL,
- "unable to initialize conversion data");
- }
- priv = (H5T_conv_struct_t *)(cdata->priv);
- src2dst = priv->src2dst;
- assert(priv);
- assert(bkg && cdata->need_bkg);
-
- /*
- * Insure that members are sorted.
- */
- H5T_sort_value(src, NULL);
- H5T_sort_value(dst, NULL);
-
- /*
- * Calculate strides. If BUF_STRIDE is non-zero then convert one
- * data element at every BUF_STRIDE bytes through the main buffer
- * (BUF), leaving the result of each conversion at the same
- * location; otherwise assume the source and destination data are
- * packed tightly based on src->size and dst->size. Also, if
- * BUF_STRIDE and BKG_STRIDE are both non-zero then place
- * background data into the BKG buffer at multiples of BKG_STRIDE;
- * otherwise assume BKG buffer is the packed destination datatype.
- */
- if (!buf_stride || !bkg_stride) bkg_stride = dst->size;
-
- /*
- * For each member where the destination is not larger than the
- * source, stride through all the elements converting only that member
- * in each element and then copying the element to its final
- * destination in the bkg buffer. Otherwise move the element as far
- * left as possible in the buffer.
- */
- for (i=0, offset=0; i<src->u.compnd.nmembs; i++) {
- if (src2dst[i]<0) continue; /*subsetting*/
- src_memb = src->u.compnd.memb + i;
- dst_memb = dst->u.compnd.memb + src2dst[i];
-
- if (dst_memb->size <= src_memb->size) {
- xbuf = buf + src_memb->offset;
- xbkg = bkg + dst_memb->offset;
- if (H5T_convert(priv->memb_path[i],
- priv->src_memb_id[i],
- priv->dst_memb_id[src2dst[i]], nelmts,
- buf_stride ? buf_stride : src->size,
- bkg_stride, xbuf, xbkg,
- dset_xfer_plist)<0) {
- HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
- "unable to convert compound data "
- "type member");
- }
- for (elmtno=0; elmtno<nelmts; elmtno++) {
- HDmemmove(xbkg, xbuf, dst_memb->size);
- xbuf += buf_stride ? buf_stride : src->size;
- xbkg += bkg_stride;
- }
- } else {
- for (xbuf=buf, elmtno=0; elmtno<nelmts; elmtno++) {
- HDmemmove(xbuf+offset, xbuf+src_memb->offset,
- src_memb->size);
- xbuf += buf_stride ? buf_stride : src->size;
+ /* Update cached data if necessary */
+ if (cdata->recalc && H5T_conv_struct_init (src, dst, cdata)<0)
+ HGOTO_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to initialize conversion data");
+ priv = (H5T_conv_struct_t *)(cdata->priv);
+ src2dst = priv->src2dst;
+ assert(priv);
+ assert(bkg && cdata->need_bkg);
+
+ /*
+ * Insure that members are sorted.
+ */
+ H5T_sort_value(src, NULL);
+ H5T_sort_value(dst, NULL);
+
+ /*
+ * Calculate strides. If BUF_STRIDE is non-zero then convert one
+ * data element at every BUF_STRIDE bytes through the main buffer
+ * (BUF), leaving the result of each conversion at the same
+ * location; otherwise assume the source and destination data are
+ * packed tightly based on src->size and dst->size. Also, if
+ * BUF_STRIDE and BKG_STRIDE are both non-zero then place
+ * background data into the BKG buffer at multiples of BKG_STRIDE;
+ * otherwise assume BKG buffer is the packed destination datatype.
+ */
+ if (!buf_stride || !bkg_stride) bkg_stride = dst->size;
+
+ /*
+ * For each member where the destination is not larger than the
+ * source, stride through all the elements converting only that member
+ * in each element and then copying the element to its final
+ * destination in the bkg buffer. Otherwise move the element as far
+ * left as possible in the buffer.
+ */
+ for (i=0, offset=0; i<src->u.compnd.nmembs; i++) {
+ if (src2dst[i]<0) continue; /*subsetting*/
+ src_memb = src->u.compnd.memb + i;
+ dst_memb = dst->u.compnd.memb + src2dst[i];
+
+ if (dst_memb->size <= src_memb->size) {
+ xbuf = buf + src_memb->offset;
+ xbkg = bkg + dst_memb->offset;
+ if (H5T_convert(priv->memb_path[i],
+ priv->src_memb_id[i],
+ priv->dst_memb_id[src2dst[i]], nelmts,
+ buf_stride ? buf_stride : src->size,
+ bkg_stride, xbuf, xbkg,
+ dset_xfer_plist)<0)
+ HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to convert compound data type member");
+ for (elmtno=0; elmtno<nelmts; elmtno++) {
+ HDmemmove(xbkg, xbuf, dst_memb->size);
+ xbuf += buf_stride ? buf_stride : src->size;
+ xbkg += bkg_stride;
+ }
+ } else {
+ for (xbuf=buf, elmtno=0; elmtno<nelmts; elmtno++) {
+ HDmemmove(xbuf+offset, xbuf+src_memb->offset,
+ src_memb->size);
+ xbuf += buf_stride ? buf_stride : src->size;
+ }
+ offset += src_memb->size;
+ }
}
- offset += src_memb->size;
- }
- }
- /*
- * Work from right to left, converting those members that weren't
- * converted in the previous loop (those members where the destination
- * is larger than the source) and them to their final position in the
- * bkg buffer.
- */
- for (i=src->u.compnd.nmembs-1; i>=0; --i) {
- if (src2dst[i]<0)
- continue;
- src_memb = src->u.compnd.memb + i;
- dst_memb = dst->u.compnd.memb + src2dst[i];
-
- if (dst_memb->size > src_memb->size) {
- offset -= src_memb->size;
- xbuf = buf + offset;
- xbkg = bkg + dst_memb->offset;
- if (H5T_convert(priv->memb_path[i],
- priv->src_memb_id[i],
- priv->dst_memb_id[src2dst[i]], nelmts,
+ /*
+ * Work from right to left, converting those members that weren't
+ * converted in the previous loop (those members where the destination
+ * is larger than the source) and them to their final position in the
+ * bkg buffer.
+ */
+ for (i=src->u.compnd.nmembs-1; i>=0; --i) {
+ if (src2dst[i]<0)
+ continue;
+ src_memb = src->u.compnd.memb + i;
+ dst_memb = dst->u.compnd.memb + src2dst[i];
+
+ if (dst_memb->size > src_memb->size) {
+ offset -= src_memb->size;
+ xbuf = buf + offset;
+ xbkg = bkg + dst_memb->offset;
+ if (H5T_convert(priv->memb_path[i],
+ priv->src_memb_id[i],
+ priv->dst_memb_id[src2dst[i]], nelmts,
buf_stride ? buf_stride : src->size,
bkg_stride, xbuf, xbkg,
- dset_xfer_plist)<0) {
- HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
- "unable to convert compound data type "
- "member");
- }
- for (elmtno=0; elmtno<nelmts; elmtno++) {
- HDmemmove(xbkg, xbuf, dst_memb->size);
- xbuf += buf_stride ? buf_stride : src->size;
- xbkg += bkg_stride;
- }
- }
- }
+ dset_xfer_plist)<0)
+ HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to convert compound data type member");
+ for (elmtno=0; elmtno<nelmts; elmtno++) {
+ HDmemmove(xbkg, xbuf, dst_memb->size);
+ xbuf += buf_stride ? buf_stride : src->size;
+ xbkg += bkg_stride;
+ }
+ }
+ }
- /* Move background buffer into result buffer */
- for (xbuf=buf, xbkg=bkg, elmtno=0; elmtno<nelmts; elmtno++) {
- HDmemmove(xbuf, xbkg, dst->size);
- xbuf += buf_stride ? buf_stride : dst->size;
- xbkg += bkg_stride;
- }
- break;
+ /* Move background buffer into result buffer */
+ for (xbuf=buf, xbkg=bkg, elmtno=0; elmtno<nelmts; elmtno++) {
+ HDmemmove(xbuf, xbkg, dst->size);
+ xbuf += buf_stride ? buf_stride : dst->size;
+ xbkg += bkg_stride;
+ }
+ break;
- default:
- /* Some other command we don't know about yet.*/
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unknown conversion command");
+ default:
+ /* Some other command we don't know about yet.*/
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
}
- FUNC_LEAVE (SUCCEED);
+done:
+ FUNC_LEAVE (ret_value);
}
@@ -1808,19 +1778,16 @@ H5T_conv_enum_init(H5T_t *src, H5T_t *dst, H5T_cdata_t *cdata)
int domain[2]; /*min and max source values */
int *map=NULL; /*map from src value to dst idx */
int length; /*nelmts in map array */
- herr_t ret_value=FAIL; /*return value */
int i, j; /*counters */
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOINIT(H5T_conv_enum_init);
cdata->need_bkg = H5T_BKG_NO;
- if (NULL==(priv=cdata->priv=H5MM_calloc(sizeof(*priv)))) {
- HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
- "memory allocation failed");
- }
- if (0==src->u.enumer.nmembs) {
- HRETURN(SUCCEED);
- }
+ if (NULL==(priv=cdata->priv=H5MM_calloc(sizeof(*priv))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
+ if (0==src->u.enumer.nmembs)
+ HGOTO_DONE(SUCCEED);
/*
* Check that the source symbol names are a subset of the destination
@@ -1829,19 +1796,16 @@ H5T_conv_enum_init(H5T_t *src, H5T_t *dst, H5T_cdata_t *cdata)
*/
H5T_sort_name(src, NULL);
H5T_sort_name(dst, NULL);
- if (NULL==(priv->src2dst=H5MM_malloc(src->u.enumer.nmembs*sizeof(int)))) {
- HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
- "memory allocation failed");;
- }
+ if (NULL==(priv->src2dst=H5MM_malloc(src->u.enumer.nmembs*sizeof(int))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");;
for (i=0, j=0;
- i<src->u.enumer.nmembs && j<dst->u.enumer.nmembs;
- i++, j++) {
+ i<src->u.enumer.nmembs && j<dst->u.enumer.nmembs;
+ i++, j++) {
while (j<dst->u.enumer.nmembs &&
- HDstrcmp(src->u.enumer.name[i], dst->u.enumer.name[j])) j++;
- if (j>=dst->u.enumer.nmembs) {
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "source type is not a subset of destination type");
- }
+ HDstrcmp(src->u.enumer.name[i], dst->u.enumer.name[j]))
+ j++;
+ if (j>=dst->u.enumer.nmembs)
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "source type is not a subset of destination type");
priv->src2dst[i] = j;
}
@@ -1884,11 +1848,10 @@ H5T_conv_enum_init(H5T_t *src, H5T_t *dst, H5T_cdata_t *cdata)
(double)length/src->u.enumer.nmembs<1.2) {
priv->base = domain[0];
priv->length = length;
- if (NULL==(map=H5MM_malloc(length*sizeof(int)))) {
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
- "memory allocation failed");
- }
- for (i=0; i<length; i++) map[i] = -1; /*entry unused*/
+ if (NULL==(map=H5MM_malloc(length*sizeof(int))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
+ for (i=0; i<length; i++)
+ map[i] = -1; /*entry unused*/
for (i=0; i<src->u.enumer.nmembs; i++) {
if (1==src->size) {
n = *((signed char*)(src->u.enumer.value+i));
@@ -1916,9 +1879,8 @@ H5T_conv_enum_init(H5T_t *src, H5T_t *dst, H5T_cdata_t *cdata)
H5T_sort_value(src, priv->src2dst);
}
}
- ret_value = SUCCEED;
- done:
+done:
if (ret_value<0 && priv) {
H5MM_xfree(priv->src2dst);
H5MM_xfree(priv);
@@ -1960,135 +1922,135 @@ H5T_conv_enum(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
int n; /*src value cast as native int */
hsize_t i; /*counters */
H5T_enum_struct_t *priv = (H5T_enum_struct_t*)(cdata->priv);
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5T_conv_enum, FAIL);
switch (cdata->command) {
- case H5T_CONV_INIT:
- /*
- * Determine if this conversion function applies to the conversion
- * path SRC_ID->DST_ID. If not return failure; otherwise initialize
- * the `priv' field of `cdata' with information about the underlying
- * integer conversion.
- */
- if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
- NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
- assert (H5T_ENUM==src->type);
- assert (H5T_ENUM==dst->type);
- if (H5T_conv_enum_init(src, dst, cdata)<0) {
- HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
- "unable to initialize private data");
- }
- break;
+ case H5T_CONV_INIT:
+ /*
+ * Determine if this conversion function applies to the conversion
+ * path SRC_ID->DST_ID. If not return failure; otherwise initialize
+ * the `priv' field of `cdata' with information about the underlying
+ * integer conversion.
+ */
+ if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
+ NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ assert (H5T_ENUM==src->type);
+ assert (H5T_ENUM==dst->type);
+ if (H5T_conv_enum_init(src, dst, cdata)<0)
+ HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to initialize private data");
+ break;
- case H5T_CONV_FREE:
+ case H5T_CONV_FREE:
#ifdef H5T_DEBUG
- if (H5DEBUG(T)) {
- fprintf(H5DEBUG(T), " Using %s mapping function%s\n",
- priv->length?"O(1)":"O(log N)",
- priv->length?"":", where N is the number of enum members");
- }
+ if (H5DEBUG(T)) {
+ fprintf(H5DEBUG(T), " Using %s mapping function%s\n",
+ priv->length?"O(1)":"O(log N)",
+ priv->length?"":", where N is the number of enum members");
+ }
#endif
- if (priv) {
- H5MM_xfree(priv->src2dst);
- H5MM_xfree(priv);
- }
- cdata->priv = NULL;
- break;
+ if (priv) {
+ H5MM_xfree(priv->src2dst);
+ H5MM_xfree(priv);
+ }
+ cdata->priv = NULL;
+ break;
- case H5T_CONV_CONV:
- if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
- NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
- assert (H5T_ENUM==src->type);
- assert (H5T_ENUM==dst->type);
-
- if (priv->length) {
- /* Use O(1) lookup */
- H5T_sort_name(src, NULL);
- H5T_sort_name(dst, NULL);
- } else {
- /* Use O(log N) lookup */
- H5T_sort_value(src, NULL); /*yes, by value*/
- H5T_sort_name(dst, NULL); /*yes, by name*/
- }
-
- /*
- * Direction of conversion.
- */
- if (buf_stride) {
- src_delta = dst_delta = (int)buf_stride;
- s = d = buf;
- } else if (dst->size <= src->size) {
- src_delta = (int)src->size; /*overflow shouldn't be possible*/
- dst_delta = (int)dst->size; /*overflow shouldn't be possible*/
- s = d = buf;
- } else {
- src_delta = -(int)src->size; /*overflow shouldn't be possible*/
- dst_delta = -(int)dst->size; /*overflow shouldn't be possible*/
- s = buf + (nelmts-1) * src->size;
- d = buf + (nelmts-1) * dst->size;
- }
+ case H5T_CONV_CONV:
+ if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
+ NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ assert (H5T_ENUM==src->type);
+ assert (H5T_ENUM==dst->type);
- for (i=0; i<nelmts; i++, s+=src_delta, d+=dst_delta) {
- if (priv->length) {
- /* Use O(1) lookup */
- if (1==src->size) {
- n = *((signed char*)s);
- } else if (sizeof(short)==src->size) {
- n = *((short*)s);
- } else {
- n = *((int*)s);
- }
- n -= priv->base;
- if (n<0 || n>=priv->length || priv->src2dst[n]<0) {
- if (!H5T_overflow_g ||
- (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
- HDmemset(d, 0xff, dst->size);
- }
- } else {
- HDmemcpy(d,
- dst->u.enumer.value+priv->src2dst[n]*dst->size,
- dst->size);
- }
- } else {
- /* Use O(log N) lookup */
- int lt = 0;
- int rt = src->u.enumer.nmembs;
- int md, cmp;
- while (lt<rt) {
- md = (lt+rt)/2;
- cmp = HDmemcmp(s, src->u.enumer.value+md*src->size,
- src->size);
- if (cmp<0) {
- rt = md;
- } else if (cmp>0) {
- lt = md+1;
- } else {
- break;
- }
- }
- if (lt>=rt) {
- if (!H5T_overflow_g ||
- (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
- HDmemset(d, 0xff, dst->size);
- }
- } else {
- HDmemcpy(d,
- dst->u.enumer.value+priv->src2dst[md]*dst->size,
- dst->size);
- }
- }
- }
- break;
+ if (priv->length) {
+ /* Use O(1) lookup */
+ H5T_sort_name(src, NULL);
+ H5T_sort_name(dst, NULL);
+ } else {
+ /* Use O(log N) lookup */
+ H5T_sort_value(src, NULL); /*yes, by value*/
+ H5T_sort_name(dst, NULL); /*yes, by name*/
+ }
+
+ /*
+ * Direction of conversion.
+ */
+ if (buf_stride) {
+ src_delta = dst_delta = (int)buf_stride;
+ s = d = buf;
+ } else if (dst->size <= src->size) {
+ src_delta = (int)src->size; /*overflow shouldn't be possible*/
+ dst_delta = (int)dst->size; /*overflow shouldn't be possible*/
+ s = d = buf;
+ } else {
+ src_delta = -(int)src->size; /*overflow shouldn't be possible*/
+ dst_delta = -(int)dst->size; /*overflow shouldn't be possible*/
+ s = buf + (nelmts-1) * src->size;
+ d = buf + (nelmts-1) * dst->size;
+ }
- default:
- /* Some other command we don't know about yet.*/
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unknown conversion command");
+ for (i=0; i<nelmts; i++, s+=src_delta, d+=dst_delta) {
+ if (priv->length) {
+ /* Use O(1) lookup */
+ if (1==src->size) {
+ n = *((signed char*)s);
+ } else if (sizeof(short)==src->size) {
+ n = *((short*)s);
+ } else {
+ n = *((int*)s);
+ }
+ n -= priv->base;
+ if (n<0 || n>=priv->length || priv->src2dst[n]<0) {
+ if (!H5T_overflow_g ||
+ (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
+ HDmemset(d, 0xff, dst->size);
+ }
+ } else {
+ HDmemcpy(d,
+ dst->u.enumer.value+priv->src2dst[n]*dst->size,
+ dst->size);
+ }
+ } else {
+ /* Use O(log N) lookup */
+ int lt = 0;
+ int rt = src->u.enumer.nmembs;
+ int md, cmp;
+ while (lt<rt) {
+ md = (lt+rt)/2;
+ cmp = HDmemcmp(s, src->u.enumer.value+md*src->size,
+ src->size);
+ if (cmp<0) {
+ rt = md;
+ } else if (cmp>0) {
+ lt = md+1;
+ } else {
+ break;
+ }
+ }
+ if (lt>=rt) {
+ if (!H5T_overflow_g ||
+ (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
+ HDmemset(d, 0xff, dst->size);
+ }
+ } else {
+ HDmemcpy(d,
+ dst->u.enumer.value+priv->src2dst[md]*dst->size,
+ dst->size);
+ }
+ }
+ }
+ break;
+
+ default:
+ /* Some other command we don't know about yet.*/
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
}
- FUNC_LEAVE(SUCCEED);
+
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -2157,6 +2119,7 @@ H5T_conv_vlen(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
int nested=0; /*flag of nested VL case */
hsize_t elmtno; /*element number counter */
hsize_t i;
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5T_conv_vlen, FAIL);
@@ -2171,7 +2134,7 @@ H5T_conv_vlen(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
*/
if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
assert (H5T_VLEN==src->type);
assert (H5T_VLEN==dst->type);
@@ -2190,7 +2153,7 @@ H5T_conv_vlen(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
*/
if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
/*
* Do we process the values from beginning to end or vice
@@ -2247,16 +2210,15 @@ H5T_conv_vlen(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
/* Get initial conversion buffer */
conv_buf_size=MAX(src_base_size,dst_base_size);
if ((conv_buf=H5FL_BLK_ALLOC(vlen_seq,conv_buf_size,1))==NULL)
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for type conversion");
+ HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for type conversion");
/* Set up conversion path for base elements */
if (NULL==(tpath=H5T_path_find(src->parent, dst->parent, NULL, NULL))) {
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unable to convert between src and dest datatypes");
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unable to convert between src and dest datatypes");
} else if (!H5T_IS_NOOP(tpath)) {
if ((tsrc_id = H5I_register(H5I_DATATYPE, H5T_copy(src->parent, H5T_COPY_ALL)))<0 ||
- (tdst_id = H5I_register(H5I_DATATYPE, H5T_copy(dst->parent, H5T_COPY_ALL)))<0) {
- HRETURN_ERROR(H5E_DATASET, H5E_CANTREGISTER, FAIL, "unable to register types for conversion");
- }
+ (tdst_id = H5I_register(H5I_DATATYPE, H5T_copy(dst->parent, H5T_COPY_ALL)))<0)
+ HGOTO_ERROR(H5E_DATASET, H5E_CANTREGISTER, FAIL, "unable to register types for conversion");
}
/* Check if we need a temporary buffer for this conversion */
@@ -2264,7 +2226,7 @@ H5T_conv_vlen(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
/* Set up initial background buffer */
tmp_buf_size=MAX(src_base_size,dst_base_size);
if ((tmp_buf=H5FL_BLK_ALLOC(vlen_seq,tmp_buf_size,1))==NULL)
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for type conversion");
+ HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for type conversion");
} /* end if */
/* Set the flag for nested VL case */
@@ -2287,14 +2249,12 @@ H5T_conv_vlen(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
if(conv_buf_size<MAX(src_size,dst_size)) {
conv_buf_size=MAX(src_size,dst_size);
if((conv_buf=H5FL_BLK_REALLOC(vlen_seq,conv_buf, conv_buf_size))==NULL)
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
- "memory allocation failed for type conversion");
+ HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for type conversion");
} /* end if */
/* Read in VL sequence */
if((*(src->u.vlen.read))(src->u.vlen.f,s,conv_buf,src_size)<0)
- HRETURN_ERROR(H5E_DATATYPE, H5E_READERROR, FAIL,
- "can't read VL data");
+ HGOTO_ERROR(H5E_DATATYPE, H5E_READERROR, FAIL, "can't read VL data");
/* Check if temporary buffer is large enough, resize if necessary */
/* (Chain off the conversion buffer size) */
@@ -2303,7 +2263,7 @@ H5T_conv_vlen(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
/* Set up initial background buffer */
tmp_buf_size=conv_buf_size;
if((tmp_buf=H5FL_BLK_REALLOC(vlen_seq,tmp_buf,tmp_buf_size))==NULL)
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for type conversion");
+ HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for type conversion");
} /* end if */
/* If we are writing and there is a nested VL type, read
@@ -2317,16 +2277,14 @@ H5T_conv_vlen(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
tmp_buf_size=bg_seq_len*MAX(src_base_size,
dst_base_size);
if((tmp_buf=H5FL_BLK_REALLOC(vlen_seq,tmp_buf,
- tmp_buf_size))==NULL)
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
- "memory allocation failed for type conversion");
+ tmp_buf_size))==NULL)
+ HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for type conversion");
}
H5F_addr_decode(dst->u.vlen.f, (const uint8_t **)&tmp,
&(bg_hobjid.addr));
INT32DECODE(tmp, bg_hobjid.idx);
if(H5HG_read(dst->u.vlen.f,&bg_hobjid,tmp_buf)==NULL)
- HRETURN_ERROR (H5E_DATATYPE, H5E_READERROR, FAIL,
- "can't read VL sequence into background buffer");
+ HGOTO_ERROR (H5E_DATATYPE, H5E_READERROR, FAIL, "can't read VL sequence into background buffer");
} /* end if */
/* If the sequence gets shorter, pad out the original sequence with zeros */
@@ -2340,13 +2298,11 @@ H5T_conv_vlen(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
/* Convert VL sequence */
H5_CHECK_OVERFLOW(seq_len,hssize_t,hsize_t);
if (H5T_convert(tpath, tsrc_id, tdst_id, (hsize_t)seq_len, 0, bkg_stride, conv_buf, tmp_buf, dset_xfer_plist)<0)
- HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
- "datatype conversion failed");
+ HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "datatype conversion failed");
/* Write sequence to destination location */
if((*(dst->u.vlen.write))(dset_xfer_plist,dst->u.vlen.f,d,conv_buf, bg_ptr, (hsize_t)seq_len,(hsize_t)dst_base_size)<0)
- HRETURN_ERROR(H5E_DATATYPE, H5E_WRITEERROR, FAIL,
- "can't write VL data");
+ HGOTO_ERROR(H5E_DATATYPE, H5E_WRITEERROR, FAIL, "can't write VL data");
/* For nested VL case, free leftover heap objects from the deeper level if the length of new data elements is shorted than the old data elements.*/
H5_CHECK_OVERFLOW(bg_seq_len,hsize_t,hssize_t);
@@ -2359,7 +2315,7 @@ H5T_conv_vlen(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
H5F_addr_decode(dst->u.vlen.f, (const uint8_t **)&tmp_p, &(parent_hobjid.addr));
INT32DECODE(tmp_p, parent_hobjid.idx);
if(H5HG_remove(dst->u.vlen.f, &parent_hobjid)<0)
- HRETURN_ERROR(H5E_DATATYPE, H5E_WRITEERROR, FAIL, "Unable to remove heap object");
+ HGOTO_ERROR(H5E_DATATYPE, H5E_WRITEERROR, FAIL, "Unable to remove heap object");
}
}
}
@@ -2399,11 +2355,11 @@ H5T_conv_vlen(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
break;
default: /* Some other command we don't know about yet.*/
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unknown conversion command");
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
} /* end switch */
- FUNC_LEAVE (SUCCEED);
+done:
+ FUNC_LEAVE (ret_value);
}
@@ -2438,6 +2394,7 @@ H5T_conv_array(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
int i; /* local index variable */
void *bkg_buf=NULL; /*temporary background buffer */
size_t bkg_buf_size=0; /*size of background buffer in bytes */
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5T_conv_array, FAIL);
@@ -2452,20 +2409,20 @@ H5T_conv_array(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
*/
if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
assert (H5T_ARRAY==src->type);
assert (H5T_ARRAY==dst->type);
/* Check the number and sizes of the dimensions */
if(src->u.array.ndims!=dst->u.array.ndims)
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "array datatypes do not have the same number of dimensions");
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "array datatypes do not have the same number of dimensions");
for(i=0; i<src->u.array.ndims; i++)
if(src->u.array.dim[i]!=dst->u.array.dim[i])
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "array datatypes do not have the same sizes of dimensions");
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "array datatypes do not have the same sizes of dimensions");
#ifdef LATER
for(i=0; i<src->u.array.ndims; i++)
if(src->u.array.perm[i]!=dst->u.array.perm[i])
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "array datatypes do not have the same dimension permutations");
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "array datatypes do not have the same dimension permutations");
#endif /* LATER */
/* Array datatypes don't need a background buffer */
@@ -2483,7 +2440,7 @@ H5T_conv_array(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
*/
if (NULL == (src = H5I_object_verify(src_id,H5I_DATATYPE)) ||
NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
/*
* Do we process the values from beginning to end or vice
@@ -2509,12 +2466,11 @@ H5T_conv_array(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
/* Set up conversion path for base elements */
if (NULL==(tpath=H5T_path_find(src->parent, dst->parent, NULL, NULL))) {
- HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unable to convert between src and dest datatypes");
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unable to convert between src and dest datatypes");
} else if (!H5T_IS_NOOP(tpath)) {
if ((tsrc_id = H5I_register(H5I_DATATYPE, H5T_copy(src->parent, H5T_COPY_ALL)))<0 ||
- (tdst_id = H5I_register(H5I_DATATYPE, H5T_copy(dst->parent, H5T_COPY_ALL)))<0) {
- HRETURN_ERROR(H5E_DATASET, H5E_CANTREGISTER, FAIL, "unable to register types for conversion");
- }
+ (tdst_id = H5I_register(H5I_DATATYPE, H5T_copy(dst->parent, H5T_COPY_ALL)))<0)
+ HGOTO_ERROR(H5E_DATASET, H5E_CANTREGISTER, FAIL, "unable to register types for conversion");
}
/* Check if we need a background buffer for this conversion */
@@ -2522,7 +2478,7 @@ H5T_conv_array(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
/* Allocate background buffer */
bkg_buf_size=src->u.array.nelem*MAX(src->size,dst->size);
if ((bkg_buf=H5FL_BLK_ALLOC(array_seq,bkg_buf_size,0))==NULL)
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for type conversion");
+ HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for type conversion");
} /* end if */
/* Perform the actual conversion */
@@ -2532,7 +2488,7 @@ H5T_conv_array(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
/* Convert array */
if (H5T_convert(tpath, tsrc_id, tdst_id, (hsize_t)src->u.array.nelem, 0, bkg_stride, dp, bkg_buf, dset_xfer_plist)<0)
- HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "datatype conversion failed");
+ HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "datatype conversion failed");
/* Advance the source & destination pointers */
sp += src_delta;
@@ -2551,11 +2507,11 @@ H5T_conv_array(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
break;
default: /* Some other command we don't know about yet.*/
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unknown conversion command");
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
} /* end switch */
- FUNC_LEAVE (SUCCEED);
+done:
+ FUNC_LEAVE (ret_value);
} /* end H5T_conv_array() */
@@ -2598,291 +2554,286 @@ H5T_conv_i_i (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
size_t first;
ssize_t sfirst; /*a signed version of `first' */
size_t i;
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5T_conv_i_i, FAIL);
switch (cdata->command) {
- case H5T_CONV_INIT:
- if (NULL==(src=H5I_object_verify(src_id,H5I_DATATYPE)) ||
- NULL==(dst=H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
- if (H5T_ORDER_LE!=src->u.atomic.order &&
- H5T_ORDER_BE!=src->u.atomic.order) {
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unsupported byte order");
- }
- if (H5T_ORDER_LE!=dst->u.atomic.order &&
- H5T_ORDER_BE!=dst->u.atomic.order) {
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unsupported byte order");
- }
- if (dst->size>sizeof dbuf) {
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "destination size is too large");
- }
- cdata->need_bkg = H5T_BKG_NO;
- break;
-
- case H5T_CONV_FREE:
- break;
-
- case H5T_CONV_CONV:
- /* Get the data types */
- if (NULL==(src=H5I_object_verify(src_id,H5I_DATATYPE)) ||
- NULL==(dst=H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
-
- /*
- * Do we process the values from beginning to end or vice versa? Also,
- * how many of the elements have the source and destination areas
- * overlapping?
- */
- if (src->size==dst->size || buf_stride) {
- sp = dp = (uint8_t*)buf;
- direction = 1;
- olap = nelmts;
- } else if (src->size>=dst->size) {
- double olap_d = HDceil((double)(dst->size)/
- (double)(src->size-dst->size));
-
- olap = (size_t)olap_d;
- sp = dp = (uint8_t*)buf;
- direction = 1;
- } else {
- double olap_d = HDceil((double)(src->size)/
- (double)(dst->size-src->size));
- olap = (size_t)olap_d;
- sp = (uint8_t*)buf + (nelmts-1) * src->size;
- dp = (uint8_t*)buf + (nelmts-1) * dst->size;
- direction = -1;
- }
-
- /* The conversion loop */
- for (elmtno=0; elmtno<nelmts; elmtno++) {
-
- /*
- * If the source and destination buffers overlap then use a
- * temporary buffer for the destination.
- */
- if (direction>0) {
- s = sp;
- d = elmtno<olap ? dbuf : dp;
- } else {
- s = sp;
- d = elmtno+olap >= nelmts ? dbuf : dp;
- }
-#ifndef NDEBUG
- /* I don't quite trust the overlap calculations yet --rpm */
- if (d==dbuf) {
- assert ((dp>=sp && dp<sp+src->size) || (sp>=dp && sp<dp+dst->size));
- } else {
- assert ((dp<sp && dp+dst->size<=sp) || (sp<dp && sp+src->size<=dp));
- }
-#endif
-
- /*
- * Put the data in little endian order so our loops aren't so
- * complicated. We'll do all the conversion stuff assuming
- * little endian and then we'll fix the order at the end.
- */
- if (H5T_ORDER_BE==src->u.atomic.order) {
- half_size = src->size/2;
- for (i=0; i<half_size; i++) {
- uint8_t tmp = s[src->size-(i+1)];
- s[src->size-(i+1)] = s[i];
- s[i] = tmp;
- }
- }
+ case H5T_CONV_INIT:
+ if (NULL==(src=H5I_object_verify(src_id,H5I_DATATYPE)) ||
+ NULL==(dst=H5I_object_verify(dst_id,H5I_DATATYPE)))
+ HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ if (H5T_ORDER_LE!=src->u.atomic.order &&
+ H5T_ORDER_BE!=src->u.atomic.order)
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unsupported byte order");
+ if (H5T_ORDER_LE!=dst->u.atomic.order &&
+ H5T_ORDER_BE!=dst->u.atomic.order)
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unsupported byte order");
+ if (dst->size>sizeof dbuf)
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "destination size is too large");
+ cdata->need_bkg = H5T_BKG_NO;
+ break;
+
+ case H5T_CONV_FREE:
+ break;
- /*
- * What is the bit number for the msb bit of S which is set? The
- * bit number is relative to the significant part of the number.
- */
- sfirst = H5T_bit_find (s, src->u.atomic.offset, src->u.atomic.prec,
- H5T_BIT_MSB, TRUE);
- first = (size_t)sfirst;
+ case H5T_CONV_CONV:
+ /* Get the data types */
+ if (NULL==(src=H5I_object_verify(src_id,H5I_DATATYPE)) ||
+ NULL==(dst=H5I_object_verify(dst_id,H5I_DATATYPE)))
+ HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
- if (sfirst<0) {
/*
- * The source has no bits set and must therefore be zero.
- * Set the destination to zero.
- */
- H5T_bit_set (d, dst->u.atomic.offset, dst->u.atomic.prec, FALSE);
-
- } else if (H5T_SGN_NONE==src->u.atomic.u.i.sign &&
- H5T_SGN_NONE==dst->u.atomic.u.i.sign) {
- /*
- * Source and destination are both unsigned, but if the
- * source has more precision bits than the destination then
- * it's possible to overflow. When overflow occurs the
- * destination will be set to the maximum possible value.
+ * Do we process the values from beginning to end or vice versa? Also,
+ * how many of the elements have the source and destination areas
+ * overlapping?
*/
- if (src->u.atomic.prec <= dst->u.atomic.prec) {
- H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
- src->u.atomic.prec);
- H5T_bit_set (d, dst->u.atomic.offset+src->u.atomic.prec,
- dst->u.atomic.prec-src->u.atomic.prec, FALSE);
- } else if (first>=dst->u.atomic.prec) {
- /*overflow*/
- if (!H5T_overflow_g || (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
- H5T_bit_set (d, dst->u.atomic.offset, dst->u.atomic.prec, TRUE);
- }
+ if (src->size==dst->size || buf_stride) {
+ sp = dp = (uint8_t*)buf;
+ direction = 1;
+ olap = nelmts;
+ } else if (src->size>=dst->size) {
+ double olap_d = HDceil((double)(dst->size)/
+ (double)(src->size-dst->size));
+
+ olap = (size_t)olap_d;
+ sp = dp = (uint8_t*)buf;
+ direction = 1;
} else {
- H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
- dst->u.atomic.prec);
+ double olap_d = HDceil((double)(src->size)/
+ (double)(dst->size-src->size));
+ olap = (size_t)olap_d;
+ sp = (uint8_t*)buf + (nelmts-1) * src->size;
+ dp = (uint8_t*)buf + (nelmts-1) * dst->size;
+ direction = -1;
}
-
- } else if (H5T_SGN_2==src->u.atomic.u.i.sign &&
- H5T_SGN_NONE==dst->u.atomic.u.i.sign) {
- /*
- * If the source is signed and the destination isn't then we
- * can have overflow if the source contains more bits than
- * the destination (destination is set to the maximum
- * possible value) or overflow if the source is negative
- * (destination is set to zero).
- */
- if (first+1 == src->u.atomic.prec) {
- /*overflow*/
- if (!H5T_overflow_g || (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
- H5T_bit_set (d, dst->u.atomic.offset, dst->u.atomic.prec, FALSE);
+
+ /* The conversion loop */
+ for (elmtno=0; elmtno<nelmts; elmtno++) {
+
+ /*
+ * If the source and destination buffers overlap then use a
+ * temporary buffer for the destination.
+ */
+ if (direction>0) {
+ s = sp;
+ d = elmtno<olap ? dbuf : dp;
+ } else {
+ s = sp;
+ d = elmtno+olap >= nelmts ? dbuf : dp;
}
- } else if (src->u.atomic.prec < dst->u.atomic.prec) {
- H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
- src->u.atomic.prec-1);
- H5T_bit_set (d, dst->u.atomic.offset+src->u.atomic.prec-1,
- (dst->u.atomic.prec-src->u.atomic.prec)+1, FALSE);
- } else if (first>=dst->u.atomic.prec) {
- /*overflow*/
- if (!H5T_overflow_g || (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
- H5T_bit_set (d, dst->u.atomic.offset, dst->u.atomic.prec, TRUE);
+#ifndef NDEBUG
+ /* I don't quite trust the overlap calculations yet --rpm */
+ if (d==dbuf) {
+ assert ((dp>=sp && dp<sp+src->size) || (sp>=dp && sp<dp+dst->size));
+ } else {
+ assert ((dp<sp && dp+dst->size<=sp) || (sp<dp && sp+src->size<=dp));
}
- } else {
- H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
- dst->u.atomic.prec);
- }
-
- } else if (H5T_SGN_NONE==src->u.atomic.u.i.sign &&
- H5T_SGN_2==dst->u.atomic.u.i.sign) {
- /*
- * If the source is not signed but the destination is then
- * overflow can occur in which case the destination is set to
- * the largest possible value (all bits set except the msb).
- */
- if (first+1 >= dst->u.atomic.prec) {
- /*overflow*/
- if (!H5T_overflow_g || (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
- H5T_bit_set (d, dst->u.atomic.offset, dst->u.atomic.prec-1, TRUE);
- H5T_bit_set (d, (dst->u.atomic.offset + dst->u.atomic.prec-1), 1, FALSE);
+#endif
+
+ /*
+ * Put the data in little endian order so our loops aren't so
+ * complicated. We'll do all the conversion stuff assuming
+ * little endian and then we'll fix the order at the end.
+ */
+ if (H5T_ORDER_BE==src->u.atomic.order) {
+ half_size = src->size/2;
+ for (i=0; i<half_size; i++) {
+ uint8_t tmp = s[src->size-(i+1)];
+ s[src->size-(i+1)] = s[i];
+ s[i] = tmp;
+ }
}
- } else if (src->u.atomic.prec<dst->u.atomic.prec) {
- H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
- src->u.atomic.prec);
- H5T_bit_set (d, dst->u.atomic.offset+src->u.atomic.prec,
- dst->u.atomic.prec-src->u.atomic.prec, FALSE);
- } else {
- H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
- dst->u.atomic.prec);
- }
-
- } else if (first+1 == src->u.atomic.prec) {
- /*
- * Both the source and the destination are signed and the
- * source value is negative. We could experience overflow
- * if the destination isn't wide enough in which case the
- * destination is set to a negative number with the largest
- * possible magnitude.
- */
- ssize_t sfz = H5T_bit_find (s, src->u.atomic.offset,
- src->u.atomic.prec-1, H5T_BIT_MSB, FALSE);
- size_t fz = (size_t)sfz;
-
- if (sfz>=0 && fz+1>=dst->u.atomic.prec) {
- /*overflow*/
- if (!H5T_overflow_g || (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
- H5T_bit_set (d, dst->u.atomic.offset, dst->u.atomic.prec-1, FALSE);
- H5T_bit_set (d, (dst->u.atomic.offset + dst->u.atomic.prec-1), 1, TRUE);
+
+ /*
+ * What is the bit number for the msb bit of S which is set? The
+ * bit number is relative to the significant part of the number.
+ */
+ sfirst = H5T_bit_find (s, src->u.atomic.offset, src->u.atomic.prec,
+ H5T_BIT_MSB, TRUE);
+ first = (size_t)sfirst;
+
+ if (sfirst<0) {
+ /*
+ * The source has no bits set and must therefore be zero.
+ * Set the destination to zero.
+ */
+ H5T_bit_set (d, dst->u.atomic.offset, dst->u.atomic.prec, FALSE);
+
+ } else if (H5T_SGN_NONE==src->u.atomic.u.i.sign &&
+ H5T_SGN_NONE==dst->u.atomic.u.i.sign) {
+ /*
+ * Source and destination are both unsigned, but if the
+ * source has more precision bits than the destination then
+ * it's possible to overflow. When overflow occurs the
+ * destination will be set to the maximum possible value.
+ */
+ if (src->u.atomic.prec <= dst->u.atomic.prec) {
+ H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
+ src->u.atomic.prec);
+ H5T_bit_set (d, dst->u.atomic.offset+src->u.atomic.prec,
+ dst->u.atomic.prec-src->u.atomic.prec, FALSE);
+ } else if (first>=dst->u.atomic.prec) {
+ /*overflow*/
+ if (!H5T_overflow_g || (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
+ H5T_bit_set (d, dst->u.atomic.offset, dst->u.atomic.prec, TRUE);
+ }
+ } else {
+ H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
+ dst->u.atomic.prec);
+ }
+
+ } else if (H5T_SGN_2==src->u.atomic.u.i.sign &&
+ H5T_SGN_NONE==dst->u.atomic.u.i.sign) {
+ /*
+ * If the source is signed and the destination isn't then we
+ * can have overflow if the source contains more bits than
+ * the destination (destination is set to the maximum
+ * possible value) or overflow if the source is negative
+ * (destination is set to zero).
+ */
+ if (first+1 == src->u.atomic.prec) {
+ /*overflow*/
+ if (!H5T_overflow_g || (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
+ H5T_bit_set (d, dst->u.atomic.offset, dst->u.atomic.prec, FALSE);
+ }
+ } else if (src->u.atomic.prec < dst->u.atomic.prec) {
+ H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
+ src->u.atomic.prec-1);
+ H5T_bit_set (d, dst->u.atomic.offset+src->u.atomic.prec-1,
+ (dst->u.atomic.prec-src->u.atomic.prec)+1, FALSE);
+ } else if (first>=dst->u.atomic.prec) {
+ /*overflow*/
+ if (!H5T_overflow_g || (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
+ H5T_bit_set (d, dst->u.atomic.offset, dst->u.atomic.prec, TRUE);
+ }
+ } else {
+ H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
+ dst->u.atomic.prec);
+ }
+
+ } else if (H5T_SGN_NONE==src->u.atomic.u.i.sign &&
+ H5T_SGN_2==dst->u.atomic.u.i.sign) {
+ /*
+ * If the source is not signed but the destination is then
+ * overflow can occur in which case the destination is set to
+ * the largest possible value (all bits set except the msb).
+ */
+ if (first+1 >= dst->u.atomic.prec) {
+ /*overflow*/
+ if (!H5T_overflow_g || (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
+ H5T_bit_set (d, dst->u.atomic.offset, dst->u.atomic.prec-1, TRUE);
+ H5T_bit_set (d, (dst->u.atomic.offset + dst->u.atomic.prec-1), 1, FALSE);
+ }
+ } else if (src->u.atomic.prec<dst->u.atomic.prec) {
+ H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
+ src->u.atomic.prec);
+ H5T_bit_set (d, dst->u.atomic.offset+src->u.atomic.prec,
+ dst->u.atomic.prec-src->u.atomic.prec, FALSE);
+ } else {
+ H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
+ dst->u.atomic.prec);
+ }
+
+ } else if (first+1 == src->u.atomic.prec) {
+ /*
+ * Both the source and the destination are signed and the
+ * source value is negative. We could experience overflow
+ * if the destination isn't wide enough in which case the
+ * destination is set to a negative number with the largest
+ * possible magnitude.
+ */
+ ssize_t sfz = H5T_bit_find (s, src->u.atomic.offset,
+ src->u.atomic.prec-1, H5T_BIT_MSB, FALSE);
+ size_t fz = (size_t)sfz;
+
+ if (sfz>=0 && fz+1>=dst->u.atomic.prec) {
+ /*overflow*/
+ if (!H5T_overflow_g || (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
+ H5T_bit_set (d, dst->u.atomic.offset, dst->u.atomic.prec-1, FALSE);
+ H5T_bit_set (d, (dst->u.atomic.offset + dst->u.atomic.prec-1), 1, TRUE);
+ }
+ } else if (src->u.atomic.prec<dst->u.atomic.prec) {
+ H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset, src->u.atomic.prec);
+ H5T_bit_set (d, dst->u.atomic.offset+src->u.atomic.prec, dst->u.atomic.prec-src->u.atomic.prec, TRUE);
+ } else {
+ H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset, dst->u.atomic.prec);
+ }
+
+ } else {
+ /*
+ * Source and destination are both signed but the source
+ * value is positive. We could have an overflow in which
+ * case the destination is set to the largest possible
+ * positive value.
+ */
+ if (first+1>=dst->u.atomic.prec) {
+ /*overflow*/
+ if (!H5T_overflow_g || (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
+ H5T_bit_set (d, dst->u.atomic.offset, dst->u.atomic.prec-1, TRUE);
+ H5T_bit_set (d, (dst->u.atomic.offset + dst->u.atomic.prec-1), 1, FALSE);
+ }
+ } else if (src->u.atomic.prec<dst->u.atomic.prec) {
+ H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
+ src->u.atomic.prec);
+ H5T_bit_set (d, dst->u.atomic.offset+src->u.atomic.prec,
+ dst->u.atomic.prec-src->u.atomic.prec, FALSE);
+ } else {
+ H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
+ dst->u.atomic.prec);
+ }
}
- } else if (src->u.atomic.prec<dst->u.atomic.prec) {
- H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset, src->u.atomic.prec);
- H5T_bit_set (d, dst->u.atomic.offset+src->u.atomic.prec, dst->u.atomic.prec-src->u.atomic.prec, TRUE);
- } else {
- H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset, dst->u.atomic.prec);
- }
-
- } else {
- /*
- * Source and destination are both signed but the source
- * value is positive. We could have an overflow in which
- * case the destination is set to the largest possible
- * positive value.
- */
- if (first+1>=dst->u.atomic.prec) {
- /*overflow*/
- if (!H5T_overflow_g || (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
- H5T_bit_set (d, dst->u.atomic.offset, dst->u.atomic.prec-1, TRUE);
- H5T_bit_set (d, (dst->u.atomic.offset + dst->u.atomic.prec-1), 1, FALSE);
+
+ /*
+ * Set padding areas in destination.
+ */
+ if (dst->u.atomic.offset>0) {
+ assert (H5T_PAD_ZERO==dst->u.atomic.lsb_pad || H5T_PAD_ONE==dst->u.atomic.lsb_pad);
+ H5T_bit_set (d, 0, dst->u.atomic.offset, (hbool_t)(H5T_PAD_ONE==dst->u.atomic.lsb_pad));
+ }
+ if (dst->u.atomic.offset+dst->u.atomic.prec!=8*dst->size) {
+ assert (H5T_PAD_ZERO==dst->u.atomic.msb_pad || H5T_PAD_ONE==dst->u.atomic.msb_pad);
+ H5T_bit_set (d, dst->u.atomic.offset+dst->u.atomic.prec,
+ 8*dst->size - (dst->u.atomic.offset+ dst->u.atomic.prec),
+ (hbool_t)(H5T_PAD_ONE==dst->u.atomic.msb_pad));
}
- } else if (src->u.atomic.prec<dst->u.atomic.prec) {
- H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
- src->u.atomic.prec);
- H5T_bit_set (d, dst->u.atomic.offset+src->u.atomic.prec,
- dst->u.atomic.prec-src->u.atomic.prec, FALSE);
- } else {
- H5T_bit_copy (d, dst->u.atomic.offset, s, src->u.atomic.offset,
- dst->u.atomic.prec);
- }
- }
- /*
- * Set padding areas in destination.
- */
- if (dst->u.atomic.offset>0) {
- assert (H5T_PAD_ZERO==dst->u.atomic.lsb_pad || H5T_PAD_ONE==dst->u.atomic.lsb_pad);
- H5T_bit_set (d, 0, dst->u.atomic.offset, (hbool_t)(H5T_PAD_ONE==dst->u.atomic.lsb_pad));
- }
- if (dst->u.atomic.offset+dst->u.atomic.prec!=8*dst->size) {
- assert (H5T_PAD_ZERO==dst->u.atomic.msb_pad || H5T_PAD_ONE==dst->u.atomic.msb_pad);
- H5T_bit_set (d, dst->u.atomic.offset+dst->u.atomic.prec,
- 8*dst->size - (dst->u.atomic.offset+ dst->u.atomic.prec),
- (hbool_t)(H5T_PAD_ONE==dst->u.atomic.msb_pad));
- }
+ /*
+ * Put the destination in the correct byte order. See note at
+ * beginning of loop.
+ */
+ if (H5T_ORDER_BE==dst->u.atomic.order) {
+ half_size = dst->size/2;
+ for (i=0; i<half_size; i++) {
+ uint8_t tmp = d[dst->size-(i+1)];
+ d[dst->size-(i+1)] = d[i];
+ d[i] = tmp;
+ }
+ }
- /*
- * Put the destination in the correct byte order. See note at
- * beginning of loop.
- */
- if (H5T_ORDER_BE==dst->u.atomic.order) {
- half_size = dst->size/2;
- for (i=0; i<half_size; i++) {
- uint8_t tmp = d[dst->size-(i+1)];
- d[dst->size-(i+1)] = d[i];
- d[i] = tmp;
+ /*
+ * If we had used a temporary buffer for the destination then we
+ * should copy the value to the true destination buffer.
+ */
+ if (d==dbuf)
+ HDmemcpy (dp, d, dst->size);
+ if (buf_stride) {
+ sp += direction * buf_stride;
+ dp += direction * buf_stride;
+ } else {
+ sp += direction * src->size;
+ dp += direction * dst->size;
+ }
}
- }
-
- /*
- * If we had used a temporary buffer for the destination then we
- * should copy the value to the true destination buffer.
- */
- if (d==dbuf)
- HDmemcpy (dp, d, dst->size);
- if (buf_stride) {
- sp += direction * buf_stride;
- dp += direction * buf_stride;
- } else {
- sp += direction * src->size;
- dp += direction * dst->size;
- }
- }
-
- break;
+
+ break;
- default:
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unknown conversion command");
+ default:
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
}
- FUNC_LEAVE (SUCCEED);
+done:
+ FUNC_LEAVE (ret_value);
}
@@ -2941,313 +2892,224 @@ H5T_conv_f_f (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
hbool_t carry=0; /*carry after rounding mantissa */
size_t i; /*miscellaneous counters */
hsize_t implied; /*destination implied bits */
+
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5T_conv_f_f, FAIL);
switch (cdata->command) {
- case H5T_CONV_INIT:
- if (NULL==(src_p=H5I_object_verify(src_id,H5I_DATATYPE)) ||
- NULL==(dst_p=H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
- src = src_p->u.atomic;
- dst = dst_p->u.atomic;
- if (H5T_ORDER_LE!=src.order &&
- H5T_ORDER_BE!=src.order) {
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unsupported byte order");
- }
- if (H5T_ORDER_LE!=dst.order &&
- H5T_ORDER_BE!=dst.order) {
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unsupported byte order");
- }
- if (dst_p->size>sizeof(dbuf)) {
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "destination size is too large");
- }
- if (8*sizeof(expo)-1<src.u.f.esize ||
- 8*sizeof(expo)-1<dst.u.f.esize) {
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "exponent field is too large");
- }
- cdata->need_bkg = H5T_BKG_NO;
- break;
+ case H5T_CONV_INIT:
+ if (NULL==(src_p=H5I_object_verify(src_id,H5I_DATATYPE)) ||
+ NULL==(dst_p=H5I_object_verify(dst_id,H5I_DATATYPE)))
+ HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ src = src_p->u.atomic;
+ dst = dst_p->u.atomic;
+ if (H5T_ORDER_LE!=src.order && H5T_ORDER_BE!=src.order)
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unsupported byte order");
+ if (H5T_ORDER_LE!=dst.order && H5T_ORDER_BE!=dst.order)
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unsupported byte order");
+ if (dst_p->size>sizeof(dbuf))
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "destination size is too large");
+ if (8*sizeof(expo)-1<src.u.f.esize || 8*sizeof(expo)-1<dst.u.f.esize)
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "exponent field is too large");
+ cdata->need_bkg = H5T_BKG_NO;
+ break;
- case H5T_CONV_FREE:
- break;
+ case H5T_CONV_FREE:
+ break;
- case H5T_CONV_CONV:
- /* Get the data types */
- if (NULL==(src_p=H5I_object_verify(src_id,H5I_DATATYPE)) ||
- NULL==(dst_p=H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
- src = src_p->u.atomic;
- dst = dst_p->u.atomic;
- expo_max = ((hssize_t)1 << dst.u.f.esize) - 1;
-
- /*
- * Do we process the values from beginning to end or vice versa? Also,
- * how many of the elements have the source and destination areas
- * overlapping?
- */
- if (src_p->size==dst_p->size || buf_stride) {
- sp = dp = (uint8_t*)buf;
- direction = 1;
- olap = nelmts;
- } else if (src_p->size>=dst_p->size) {
- double olap_d = HDceil((double)(dst_p->size)/
- (double)(src_p->size-dst_p->size));
- olap = (size_t)olap_d;
- sp = dp = (uint8_t*)buf;
- direction = 1;
- } else {
- double olap_d = HDceil((double)(src_p->size)/
- (double)(dst_p->size-src_p->size));
- olap = (size_t)olap_d;
- sp = (uint8_t*)buf + (nelmts-1) * src_p->size;
- dp = (uint8_t*)buf + (nelmts-1) * dst_p->size;
- direction = -1;
- }
+ case H5T_CONV_CONV:
+ /* Get the data types */
+ if (NULL==(src_p=H5I_object_verify(src_id,H5I_DATATYPE)) ||
+ NULL==(dst_p=H5I_object_verify(dst_id,H5I_DATATYPE)))
+ HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ src = src_p->u.atomic;
+ dst = dst_p->u.atomic;
+ expo_max = ((hssize_t)1 << dst.u.f.esize) - 1;
- /* The conversion loop */
- for (elmtno=0; elmtno<nelmts; elmtno++) {
- /*
- * If the source and destination buffers overlap then use a
- * temporary buffer for the destination.
- */
- if (direction>0) {
- s = sp;
- d = elmtno<olap ? dbuf : dp;
- } else {
- s = sp;
- d = elmtno+olap >= nelmts ? dbuf : dp;
- }
+ /*
+ * Do we process the values from beginning to end or vice versa? Also,
+ * how many of the elements have the source and destination areas
+ * overlapping?
+ */
+ if (src_p->size==dst_p->size || buf_stride) {
+ sp = dp = (uint8_t*)buf;
+ direction = 1;
+ olap = nelmts;
+ } else if (src_p->size>=dst_p->size) {
+ double olap_d = HDceil((double)(dst_p->size)/
+ (double)(src_p->size-dst_p->size));
+ olap = (size_t)olap_d;
+ sp = dp = (uint8_t*)buf;
+ direction = 1;
+ } else {
+ double olap_d = HDceil((double)(src_p->size)/
+ (double)(dst_p->size-src_p->size));
+ olap = (size_t)olap_d;
+ sp = (uint8_t*)buf + (nelmts-1) * src_p->size;
+ dp = (uint8_t*)buf + (nelmts-1) * dst_p->size;
+ direction = -1;
+ }
+
+ /* The conversion loop */
+ for (elmtno=0; elmtno<nelmts; elmtno++) {
+ /*
+ * If the source and destination buffers overlap then use a
+ * temporary buffer for the destination.
+ */
+ if (direction>0) {
+ s = sp;
+ d = elmtno<olap ? dbuf : dp;
+ } else {
+ s = sp;
+ d = elmtno+olap >= nelmts ? dbuf : dp;
+ }
#ifndef NDEBUG
- /* I don't quite trust the overlap calculations yet --rpm */
- if (d==dbuf) {
- assert ((dp>=sp && dp<sp+src_p->size) ||
- (sp>=dp && sp<dp+dst_p->size));
- } else {
- assert ((dp<sp && dp+dst_p->size<=sp) ||
- (sp<dp && sp+src_p->size<=dp));
- }
+ /* I don't quite trust the overlap calculations yet --rpm */
+ if (d==dbuf) {
+ assert ((dp>=sp && dp<sp+src_p->size) ||
+ (sp>=dp && sp<dp+dst_p->size));
+ } else {
+ assert ((dp<sp && dp+dst_p->size<=sp) ||
+ (sp<dp && sp+src_p->size<=dp));
+ }
#endif
-
- /*
- * Put the data in little endian order so our loops aren't so
- * complicated. We'll do all the conversion stuff assuming
- * little endian and then we'll fix the order at the end.
- */
- if (H5T_ORDER_BE==src.order) {
- half_size = src_p->size/2;
- for (i=0; i<half_size; i++) {
- uint8_t tmp = s[src_p->size-(i+1)];
- s[src_p->size-(i+1)] = s[i];
- s[i] = tmp;
- }
- }
-
- /*
- * Check for special cases: +0, -0, +Inf, -Inf, NaN
- */
- if (H5T_bit_find (s, src.u.f.mpos, src.u.f.msize,
- H5T_BIT_LSB, TRUE)<0) {
- if (H5T_bit_find (s, src.u.f.epos, src.u.f.esize,
- H5T_BIT_LSB, TRUE)<0) {
- /* +0 or -0 */
- H5T_bit_copy (d, dst.u.f.sign, s, src.u.f.sign, 1);
- H5T_bit_set (d, dst.u.f.epos, dst.u.f.esize, FALSE);
- H5T_bit_set (d, dst.u.f.mpos, dst.u.f.msize, FALSE);
- goto padding;
- } else if (H5T_bit_find (s, src.u.f.epos, src.u.f.esize,
- H5T_BIT_LSB, FALSE)<0) {
- /* +Inf or -Inf */
- H5T_bit_copy (d, dst.u.f.sign, s, src.u.f.sign, 1);
- H5T_bit_set (d, dst.u.f.epos, dst.u.f.esize, TRUE);
- H5T_bit_set (d, dst.u.f.mpos, dst.u.f.msize, FALSE);
- goto padding;
- }
- } else if (H5T_bit_find (s, src.u.f.epos, src.u.f.esize,
- H5T_BIT_LSB, FALSE)<0) {
- /*
- * NaN. There are many NaN values, so we just set all bits of
- * the significand.
- */
- H5T_bit_copy (d, dst.u.f.sign, s, src.u.f.sign, 1);
- H5T_bit_set (d, dst.u.f.epos, dst.u.f.esize, TRUE);
- H5T_bit_set(d, dst.u.f.mpos, dst.u.f.msize, TRUE);
- goto padding;
- }
+
+ /*
+ * Put the data in little endian order so our loops aren't so
+ * complicated. We'll do all the conversion stuff assuming
+ * little endian and then we'll fix the order at the end.
+ */
+ if (H5T_ORDER_BE==src.order) {
+ half_size = src_p->size/2;
+ for (i=0; i<half_size; i++) {
+ uint8_t tmp = s[src_p->size-(i+1)];
+ s[src_p->size-(i+1)] = s[i];
+ s[i] = tmp;
+ }
+ }
- /*
- * Get the exponent as an unsigned quantity from the section of
- * the source bit field where it's located. Don't worry about
- * the exponent bias yet.
- */
- expo = H5T_bit_get_d(s, src.u.f.epos, src.u.f.esize);
-
- /*
- * Set markers for the source mantissa, excluding the leading `1'
- * (might be implied).
- */
- implied = 1;
- mpos = src.u.f.mpos;
- mrsh = 0;
- if (0==expo || H5T_NORM_NONE==src.u.f.norm) {
- if ((bitno=H5T_bit_find(s, src.u.f.mpos, src.u.f.msize,
- H5T_BIT_MSB, TRUE))>0) {
- msize = bitno;
- } else if (0==bitno) {
- msize = 1;
- H5T_bit_set(s, src.u.f.mpos, 1, FALSE);
- }
- } else if (H5T_NORM_IMPLIED==src.u.f.norm) {
- msize = src.u.f.msize;
- } else {
- assert("normalization method not implemented yet" && 0);
- HDabort();
- }
-
- /*
- * The sign for the destination is the same as the sign for the
- * source in all cases.
- */
- H5T_bit_copy (d, dst.u.f.sign, s, src.u.f.sign, 1);
+ /*
+ * Check for special cases: +0, -0, +Inf, -Inf, NaN
+ */
+ if (H5T_bit_find (s, src.u.f.mpos, src.u.f.msize,
+ H5T_BIT_LSB, TRUE)<0) {
+ if (H5T_bit_find (s, src.u.f.epos, src.u.f.esize,
+ H5T_BIT_LSB, TRUE)<0) {
+ /* +0 or -0 */
+ H5T_bit_copy (d, dst.u.f.sign, s, src.u.f.sign, 1);
+ H5T_bit_set (d, dst.u.f.epos, dst.u.f.esize, FALSE);
+ H5T_bit_set (d, dst.u.f.mpos, dst.u.f.msize, FALSE);
+ goto padding;
+ } else if (H5T_bit_find (s, src.u.f.epos, src.u.f.esize,
+ H5T_BIT_LSB, FALSE)<0) {
+ /* +Inf or -Inf */
+ H5T_bit_copy (d, dst.u.f.sign, s, src.u.f.sign, 1);
+ H5T_bit_set (d, dst.u.f.epos, dst.u.f.esize, TRUE);
+ H5T_bit_set (d, dst.u.f.mpos, dst.u.f.msize, FALSE);
+ goto padding;
+ }
+ } else if (H5T_bit_find (s, src.u.f.epos, src.u.f.esize,
+ H5T_BIT_LSB, FALSE)<0) {
+ /*
+ * NaN. There are many NaN values, so we just set all bits of
+ * the significand.
+ */
+ H5T_bit_copy (d, dst.u.f.sign, s, src.u.f.sign, 1);
+ H5T_bit_set (d, dst.u.f.epos, dst.u.f.esize, TRUE);
+ H5T_bit_set(d, dst.u.f.mpos, dst.u.f.msize, TRUE);
+ goto padding;
+ }
- /*
- * Calculate the true source exponent by adjusting according to
- * the source exponent bias.
- */
- if (0==expo || H5T_NORM_NONE==src.u.f.norm) {
- bitno = H5T_bit_find(s, src.u.f.mpos, src.u.f.msize,
- H5T_BIT_MSB, TRUE);
- assert(bitno>=0);
- expo -= (src.u.f.ebias-1) + (src.u.f.msize-bitno);
- } else if (H5T_NORM_IMPLIED==src.u.f.norm) {
- expo -= src.u.f.ebias;
- } else {
- assert("normalization method not implemented yet" && 0);
- HDabort();
- }
+ /*
+ * Get the exponent as an unsigned quantity from the section of
+ * the source bit field where it's located. Don't worry about
+ * the exponent bias yet.
+ */
+ expo = H5T_bit_get_d(s, src.u.f.epos, src.u.f.esize);
+
+ /*
+ * Set markers for the source mantissa, excluding the leading `1'
+ * (might be implied).
+ */
+ implied = 1;
+ mpos = src.u.f.mpos;
+ mrsh = 0;
+ if (0==expo || H5T_NORM_NONE==src.u.f.norm) {
+ if ((bitno=H5T_bit_find(s, src.u.f.mpos, src.u.f.msize,
+ H5T_BIT_MSB, TRUE))>0) {
+ msize = bitno;
+ } else if (0==bitno) {
+ msize = 1;
+ H5T_bit_set(s, src.u.f.mpos, 1, FALSE);
+ }
+ } else if (H5T_NORM_IMPLIED==src.u.f.norm) {
+ msize = src.u.f.msize;
+ } else {
+ assert("normalization method not implemented yet" && 0);
+ HDabort();
+ }
+
+ /*
+ * The sign for the destination is the same as the sign for the
+ * source in all cases.
+ */
+ H5T_bit_copy (d, dst.u.f.sign, s, src.u.f.sign, 1);
- /*
- * If the destination is not normalized then right shift the
- * mantissa by one.
- */
- if (H5T_NORM_NONE==dst.u.f.norm) {
- mrsh++;
- }
+ /*
+ * Calculate the true source exponent by adjusting according to
+ * the source exponent bias.
+ */
+ if (0==expo || H5T_NORM_NONE==src.u.f.norm) {
+ bitno = H5T_bit_find(s, src.u.f.mpos, src.u.f.msize,
+ H5T_BIT_MSB, TRUE);
+ assert(bitno>=0);
+ expo -= (src.u.f.ebias-1) + (src.u.f.msize-bitno);
+ } else if (H5T_NORM_IMPLIED==src.u.f.norm) {
+ expo -= src.u.f.ebias;
+ } else {
+ assert("normalization method not implemented yet" && 0);
+ HDabort();
+ }
- /*
- * Calculate the destination exponent by adding the destination
- * bias and clipping by the minimum and maximum possible
- * destination exponent values.
- */
- expo += dst.u.f.ebias;
- if (expo < -(hssize_t)(dst.u.f.msize)) {
- /* The exponent is way too small. Result is zero. */
- expo = 0;
- H5T_bit_set(d, dst.u.f.mpos, dst.u.f.msize, FALSE);
- msize = 0;
-
- } else if (expo<=0) {
- /*
- * The exponent is too small to fit in the exponent field,
- * but by shifting the mantissa to the right we can
- * accomodate that value. The mantissa of course is no
- * longer normalized.
- */
- H5_ASSIGN_OVERFLOW(mrsh,(mrsh+1-expo),hssize_t,size_t);
- /*mrsh += 1-expo;*/
- expo = 0;
-
- } else if (expo>=expo_max) {
- /*
- * The exponent is too large to fit in the available region
- * or it results in the maximum possible value. Use positive
- * or negative infinity instead unless the application
- * specifies something else. Before calling the overflow
- * handler make sure the source buffer we hand it is in the
- * original byte order.
- */
- if (H5T_overflow_g) {
- uint8_t over_src[256];
- assert(src_p->size<=sizeof over_src);
- if (H5T_ORDER_BE==src.order) {
- for (i=0; i<src_p->size; i++) {
- over_src[src_p->size-(i+1)] = s[i];
- }
- } else {
- for (i=0; i<src_p->size; i++) {
- over_src[i] = s[i];
- }
- }
- if ((H5T_overflow_g)(src_id, dst_id, over_src, d)>=0) {
- goto next;
- }
- }
- expo = expo_max;
- H5T_bit_set(d, dst.u.f.mpos, dst.u.f.msize, FALSE);
- msize = 0;
- }
+ /*
+ * If the destination is not normalized then right shift the
+ * mantissa by one.
+ */
+ if (H5T_NORM_NONE==dst.u.f.norm)
+ mrsh++;
- /*
- * If the destination mantissa is smaller than the source
- * mantissa then round the source mantissa. Rounding may cause a
- * carry in which case the exponent has to be re-evaluated for
- * overflow. That is, if `carry' is clear then the implied
- * mantissa bit is `1', else it is `10' binary.
- */
- if (msize>0 && mrsh<=dst.u.f.msize && mrsh+msize>dst.u.f.msize) {
- bitno = (ssize_t)(mrsh+msize - dst.u.f.msize);
- assert(bitno>=0 && (size_t)bitno<=msize);
- carry = H5T_bit_inc(s, mpos+bitno-1, 1+msize-bitno);
- if (carry) implied = 2;
- }
- else
- carry=0;
+ /*
+ * Calculate the destination exponent by adding the destination
+ * bias and clipping by the minimum and maximum possible
+ * destination exponent values.
+ */
+ expo += dst.u.f.ebias;
+ if (expo < -(hssize_t)(dst.u.f.msize)) {
+ /* The exponent is way too small. Result is zero. */
+ expo = 0;
+ H5T_bit_set(d, dst.u.f.mpos, dst.u.f.msize, FALSE);
+ msize = 0;
- /*
- * Write the mantissa to the destination
- */
- if (mrsh>dst.u.f.msize+1) {
- H5T_bit_set(d, dst.u.f.mpos, dst.u.f.msize, FALSE);
- } else if (mrsh==dst.u.f.msize+1) {
- H5T_bit_set(d, dst.u.f.mpos+1, dst.u.f.msize-1, FALSE);
- H5T_bit_set(d, dst.u.f.mpos, 1, TRUE);
- } else if (mrsh==dst.u.f.msize) {
- H5T_bit_set(d, dst.u.f.mpos, dst.u.f.msize, FALSE);
- H5T_bit_set_d(d, dst.u.f.mpos, MIN(2, dst.u.f.msize), implied);
- } else {
- if (mrsh>0) {
- H5T_bit_set(d, dst.u.f.mpos+dst.u.f.msize-mrsh, mrsh,
- FALSE);
- H5T_bit_set_d(d, dst.u.f.mpos+dst.u.f.msize-mrsh, 2,
- implied);
- }
- if (mrsh+msize>=dst.u.f.msize) {
- H5T_bit_copy(d, dst.u.f.mpos,
- s, (mpos+msize+mrsh-dst.u.f.msize),
- dst.u.f.msize-mrsh);
- } else {
- H5T_bit_copy(d, dst.u.f.mpos+dst.u.f.msize-(mrsh+msize),
- s, mpos, msize);
- H5T_bit_set(d, dst.u.f.mpos, dst.u.f.msize-(mrsh+msize),
- FALSE);
- }
- }
-
- /* Write the exponent */
- if (carry) {
- expo++;
- if (expo>=expo_max) {
+ } else if (expo<=0) {
+ /*
+ * The exponent is too small to fit in the exponent field,
+ * but by shifting the mantissa to the right we can
+ * accomodate that value. The mantissa of course is no
+ * longer normalized.
+ */
+ H5_ASSIGN_OVERFLOW(mrsh,(mrsh+1-expo),hssize_t,size_t);
+ /*mrsh += 1-expo;*/
+ expo = 0;
+
+ } else if (expo>=expo_max) {
/*
- * The exponent is too large to fit in the available
- * region or it results in the maximum possible value.
- * Use positive or negative infinity instead unless the
- * application specifies something else. Before
- * calling the overflow handler make sure the source
- * buffer we hand it is in the original byte order.
+ * The exponent is too large to fit in the available region
+ * or it results in the maximum possible value. Use positive
+ * or negative infinity instead unless the application
+ * specifies something else. Before calling the overflow
+ * handler make sure the source buffer we hand it is in the
+ * original byte order.
*/
if (H5T_overflow_g) {
uint8_t over_src[256];
@@ -3267,67 +3129,145 @@ H5T_conv_f_f (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
}
expo = expo_max;
H5T_bit_set(d, dst.u.f.mpos, dst.u.f.msize, FALSE);
+ msize = 0;
}
- }
- H5_CHECK_OVERFLOW(expo,hssize_t,hsize_t);
- H5T_bit_set_d(d, dst.u.f.epos, dst.u.f.esize, (hsize_t)expo);
- padding:
+ /*
+ * If the destination mantissa is smaller than the source
+ * mantissa then round the source mantissa. Rounding may cause a
+ * carry in which case the exponent has to be re-evaluated for
+ * overflow. That is, if `carry' is clear then the implied
+ * mantissa bit is `1', else it is `10' binary.
+ */
+ if (msize>0 && mrsh<=dst.u.f.msize && mrsh+msize>dst.u.f.msize) {
+ bitno = (ssize_t)(mrsh+msize - dst.u.f.msize);
+ assert(bitno>=0 && (size_t)bitno<=msize);
+ carry = H5T_bit_inc(s, mpos+bitno-1, 1+msize-bitno);
+ if (carry)
+ implied = 2;
+ }
+ else
+ carry=0;
+
+ /*
+ * Write the mantissa to the destination
+ */
+ if (mrsh>dst.u.f.msize+1) {
+ H5T_bit_set(d, dst.u.f.mpos, dst.u.f.msize, FALSE);
+ } else if (mrsh==dst.u.f.msize+1) {
+ H5T_bit_set(d, dst.u.f.mpos+1, dst.u.f.msize-1, FALSE);
+ H5T_bit_set(d, dst.u.f.mpos, 1, TRUE);
+ } else if (mrsh==dst.u.f.msize) {
+ H5T_bit_set(d, dst.u.f.mpos, dst.u.f.msize, FALSE);
+ H5T_bit_set_d(d, dst.u.f.mpos, MIN(2, dst.u.f.msize), implied);
+ } else {
+ if (mrsh>0) {
+ H5T_bit_set(d, dst.u.f.mpos+dst.u.f.msize-mrsh, mrsh,
+ FALSE);
+ H5T_bit_set_d(d, dst.u.f.mpos+dst.u.f.msize-mrsh, 2,
+ implied);
+ }
+ if (mrsh+msize>=dst.u.f.msize) {
+ H5T_bit_copy(d, dst.u.f.mpos,
+ s, (mpos+msize+mrsh-dst.u.f.msize),
+ dst.u.f.msize-mrsh);
+ } else {
+ H5T_bit_copy(d, dst.u.f.mpos+dst.u.f.msize-(mrsh+msize),
+ s, mpos, msize);
+ H5T_bit_set(d, dst.u.f.mpos, dst.u.f.msize-(mrsh+msize),
+ FALSE);
+ }
+ }
+
+ /* Write the exponent */
+ if (carry) {
+ expo++;
+ if (expo>=expo_max) {
+ /*
+ * The exponent is too large to fit in the available
+ * region or it results in the maximum possible value.
+ * Use positive or negative infinity instead unless the
+ * application specifies something else. Before
+ * calling the overflow handler make sure the source
+ * buffer we hand it is in the original byte order.
+ */
+ if (H5T_overflow_g) {
+ uint8_t over_src[256];
+ assert(src_p->size<=sizeof over_src);
+ if (H5T_ORDER_BE==src.order) {
+ for (i=0; i<src_p->size; i++)
+ over_src[src_p->size-(i+1)] = s[i];
+ } else {
+ for (i=0; i<src_p->size; i++)
+ over_src[i] = s[i];
+ }
+ if ((H5T_overflow_g)(src_id, dst_id, over_src, d)>=0)
+ goto next;
+ }
+ expo = expo_max;
+ H5T_bit_set(d, dst.u.f.mpos, dst.u.f.msize, FALSE);
+ }
+ }
+ H5_CHECK_OVERFLOW(expo,hssize_t,hsize_t);
+ H5T_bit_set_d(d, dst.u.f.epos, dst.u.f.esize, (hsize_t)expo);
+
+ padding:
#ifndef LATER
- /*
- * Set internal padding areas
- */
+ /*
+ * Set internal padding areas
+ */
#endif
- /*
- * Set external padding areas
- */
- if (dst.offset>0) {
- assert (H5T_PAD_ZERO==dst.lsb_pad || H5T_PAD_ONE==dst.lsb_pad);
- H5T_bit_set (d, 0, dst.offset, (hbool_t)(H5T_PAD_ONE==dst.lsb_pad));
- }
- if (dst.offset+dst.prec!=8*dst_p->size) {
- assert (H5T_PAD_ZERO==dst.msb_pad || H5T_PAD_ONE==dst.msb_pad);
- H5T_bit_set (d, dst.offset+dst.prec, 8*dst_p->size - (dst.offset+dst.prec),
- (hbool_t)(H5T_PAD_ONE==dst.msb_pad));
- }
+ /*
+ * Set external padding areas
+ */
+ if (dst.offset>0) {
+ assert (H5T_PAD_ZERO==dst.lsb_pad || H5T_PAD_ONE==dst.lsb_pad);
+ H5T_bit_set (d, 0, dst.offset, (hbool_t)(H5T_PAD_ONE==dst.lsb_pad));
+ }
+ if (dst.offset+dst.prec!=8*dst_p->size) {
+ assert (H5T_PAD_ZERO==dst.msb_pad || H5T_PAD_ONE==dst.msb_pad);
+ H5T_bit_set (d, dst.offset+dst.prec, 8*dst_p->size - (dst.offset+dst.prec),
+ (hbool_t)(H5T_PAD_ONE==dst.msb_pad));
+ }
- /*
- * Put the destination in the correct byte order. See note at
- * beginning of loop.
- */
- if (H5T_ORDER_BE==dst.order) {
- half_size = dst_p->size/2;
- for (i=0; i<half_size; i++) {
- uint8_t tmp = d[dst_p->size-(i+1)];
- d[dst_p->size-(i+1)] = d[i];
- d[i] = tmp;
- }
- }
+ /*
+ * Put the destination in the correct byte order. See note at
+ * beginning of loop.
+ */
+ if (H5T_ORDER_BE==dst.order) {
+ half_size = dst_p->size/2;
+ for (i=0; i<half_size; i++) {
+ uint8_t tmp = d[dst_p->size-(i+1)];
+ d[dst_p->size-(i+1)] = d[i];
+ d[i] = tmp;
+ }
+ }
- /*
- * If we had used a temporary buffer for the destination then we
- * should copy the value to the true destination buffer.
- */
- next:
- if (d==dbuf) HDmemcpy (dp, d, dst_p->size);
- if (buf_stride) {
- sp += direction * buf_stride;
- dp += direction * buf_stride;
- } else {
- sp += direction * src_p->size;
- dp += direction * dst_p->size;
- }
- }
-
- break;
-
- default:
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unknown conversion command");
+ /*
+ * If we had used a temporary buffer for the destination then we
+ * should copy the value to the true destination buffer.
+ */
+ next:
+ if (d==dbuf)
+ HDmemcpy (dp, d, dst_p->size);
+ if (buf_stride) {
+ sp += direction * buf_stride;
+ dp += direction * buf_stride;
+ } else {
+ sp += direction * src_p->size;
+ dp += direction * dst_p->size;
+ }
+ }
+
+ break;
+
+ default:
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
}
- FUNC_LEAVE (SUCCEED);
+done:
+ FUNC_LEAVE (ret_value);
}
@@ -3362,7 +3302,7 @@ H5T_conv_s_s (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
size_t nchars=0; /*number of characters copied */
uint8_t *s, *sp, *d, *dp; /*src and dst traversal pointers*/
uint8_t *dbuf=NULL; /*temp buf for overlap convers. */
- herr_t ret_value=FAIL; /*return value */
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5T_conv_s_s, FAIL);
@@ -3371,22 +3311,15 @@ H5T_conv_s_s (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
if (NULL==(src=H5I_object_verify(src_id,H5I_DATATYPE)) ||
NULL==(dst=H5I_object_verify(dst_id,H5I_DATATYPE)))
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
- if (8*src->size != src->u.atomic.prec ||
- 8*dst->size != dst->u.atomic.prec) {
+ if (8*src->size != src->u.atomic.prec || 8*dst->size != dst->u.atomic.prec)
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "bad precision");
- }
- if (0 != src->u.atomic.offset ||
- 0 != dst->u.atomic.offset) {
+ if (0 != src->u.atomic.offset || 0 != dst->u.atomic.offset)
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "bad offset");
- }
- if (H5T_CSET_ASCII != src->u.atomic.u.s.cset ||
- H5T_CSET_ASCII != dst->u.atomic.u.s.cset) {
+ if (H5T_CSET_ASCII != src->u.atomic.u.s.cset || H5T_CSET_ASCII != dst->u.atomic.u.s.cset)
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "bad character set");
- }
if (src->u.atomic.u.s.pad<0 || src->u.atomic.u.s.pad>=H5T_NPAD ||
- dst->u.atomic.u.s.pad<0 || dst->u.atomic.u.s.pad>=H5T_NPAD) {
+ dst->u.atomic.u.s.pad<0 || dst->u.atomic.u.s.pad>=H5T_NPAD)
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "bad character padding");
- }
cdata->need_bkg = H5T_BKG_NO;
break;
@@ -3428,10 +3361,8 @@ H5T_conv_s_s (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
}
/* Allocate the overlap buffer */
- if (NULL==(dbuf=H5MM_malloc(dst->size))) {
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
- "memory allocation failed for string conversion");
- }
+ if (NULL==(dbuf=H5MM_malloc(dst->size)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for string conversion");
/* The conversion loop. */
for (elmtno=0; elmtno<nelmts; elmtno++) {
@@ -3441,21 +3372,21 @@ H5T_conv_s_s (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
* temporary buffer for the destination.
*/
if (direction>0) {
- s = sp;
- d = elmtno<olap ? dbuf : dp;
+ s = sp;
+ d = elmtno<olap ? dbuf : dp;
} else {
- s = sp;
- d = elmtno+olap >= nelmts ? dbuf : dp;
+ s = sp;
+ d = elmtno+olap >= nelmts ? dbuf : dp;
}
#ifndef NDEBUG
/* I don't quite trust the overlap calculations yet --rpm */
if (src->size==dst->size || buf_stride) {
- assert(s==d);
+ assert(s==d);
} else if (d==dbuf) {
- assert((dp>=sp && dp<sp+src->size) ||
+ assert((dp>=sp && dp<sp+src->size) ||
(sp>=dp && sp<dp+dst->size));
} else {
- assert((dp<sp && dp+dst->size<=sp) ||
+ assert((dp<sp && dp+dst->size<=sp) ||
(sp<dp && sp+src->size<=dp));
}
#endif
@@ -3500,8 +3431,7 @@ H5T_conv_s_s (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
case H5T_STR_RESERVED_14:
case H5T_STR_RESERVED_15:
case H5T_STR_ERROR:
- HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "source string padding method not supported");
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "source string padding method not supported");
}
/* Terminate or pad the destination */
@@ -3536,8 +3466,7 @@ H5T_conv_s_s (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
case H5T_STR_RESERVED_14:
case H5T_STR_RESERVED_15:
case H5T_STR_ERROR:
- HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "destination string padding method not supported");
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "destination string padding method not supported");
}
/*
@@ -3557,12 +3486,10 @@ H5T_conv_s_s (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
break;
default:
- HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unknown converson command");
+ HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown converson command");
}
- ret_value = SUCCEED;
- done:
+done:
H5MM_xfree(dbuf);
FUNC_LEAVE(ret_value);
}
@@ -3590,12 +3517,14 @@ H5T_conv_schar_uchar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_schar_uchar, FAIL);
- H5T_CONV_su(SCHAR, UCHAR,
- signed char, unsigned char);
+ H5T_CONV_su(SCHAR, UCHAR, signed char, unsigned char);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -3621,13 +3550,14 @@ H5T_conv_uchar_schar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uchar_schar, FAIL);
- H5T_CONV_us(UCHAR, SCHAR,
- unsigned char, signed char,
- SCHAR_MAX);
+ H5T_CONV_us(UCHAR, SCHAR, unsigned char, signed char, SCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -3653,12 +3583,14 @@ H5T_conv_schar_short(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_schar_short, FAIL);
- H5T_CONV_sS(SCHAR, SHORT,
- signed char, short);
+ H5T_CONV_sS(SCHAR, SHORT, signed char, short);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -3684,12 +3616,14 @@ H5T_conv_schar_ushort(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_schar_ushort, FAIL);
- H5T_CONV_sU(SCHAR, USHORT,
- signed char, unsigned short);
+ H5T_CONV_sU(SCHAR, USHORT, signed char, unsigned short);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -3715,13 +3649,14 @@ H5T_conv_uchar_short(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uchar_short, FAIL);
- H5T_CONV_uS(UCHAR, SHORT,
- unsigned char, short,
- SHRT_MAX);
+ H5T_CONV_uS(UCHAR, SHORT, unsigned char, short, SHRT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -3747,12 +3682,14 @@ H5T_conv_uchar_ushort(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uchar_ushort, FAIL);
- H5T_CONV_uU(UCHAR, USHORT,
- unsigned char, unsigned short);
+ H5T_CONV_uU(UCHAR, USHORT, unsigned char, unsigned short);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -3777,12 +3714,14 @@ H5T_conv_schar_int(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_schar_int, FAIL);
- H5T_CONV_sS(SCHAR, INT,
- signed char, int);
+ H5T_CONV_sS(SCHAR, INT, signed char, int);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -3807,12 +3746,14 @@ H5T_conv_schar_uint(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_schar_uint, FAIL);
- H5T_CONV_sU(SCHAR, UINT,
- signed char, unsigned);
+ H5T_CONV_sU(SCHAR, UINT, signed char, unsigned);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -3837,13 +3778,14 @@ H5T_conv_uchar_int(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uchar_int, FAIL);
- H5T_CONV_uS(UCHAR, INT,
- unsigned char, int,
- INT_MAX);
+ H5T_CONV_uS(UCHAR, INT, unsigned char, int, INT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -3868,12 +3810,14 @@ H5T_conv_uchar_uint(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uchar_uint, FAIL);
- H5T_CONV_uU(UCHAR, UINT,
- unsigned char, unsigned);
+ H5T_CONV_uU(UCHAR, UINT, unsigned char, unsigned);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -3898,12 +3842,14 @@ H5T_conv_schar_long(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_schar_long, FAIL);
- H5T_CONV_sS(SCHAR, LONG,
- signed char, long);
+ H5T_CONV_sS(SCHAR, LONG, signed char, long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -3929,12 +3875,14 @@ H5T_conv_schar_ulong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_schar_ulong, FAIL);
- H5T_CONV_sU(SCHAR, ULONG,
- signed char, unsigned long);
+ H5T_CONV_sU(SCHAR, ULONG, signed char, unsigned long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -3959,13 +3907,14 @@ H5T_conv_uchar_long(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uchar_long, FAIL);
- H5T_CONV_uS(UCHAR, LONG,
- unsigned char, long,
- LONG_MAX);
+ H5T_CONV_uS(UCHAR, LONG, unsigned char, long, LONG_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -3991,12 +3940,14 @@ H5T_conv_uchar_ulong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uchar_ulong, FAIL);
- H5T_CONV_uU(UCHAR, ULONG,
- unsigned char, unsigned long);
+ H5T_CONV_uU(UCHAR, ULONG, unsigned char, unsigned long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4022,12 +3973,14 @@ H5T_conv_schar_llong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_schar_llong, FAIL);
- H5T_CONV_sS(SCHAR, LLONG,
- signed char, long_long);
+ H5T_CONV_sS(SCHAR, LLONG, signed char, long_long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4053,12 +4006,14 @@ H5T_conv_schar_ullong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_schar_ullong, FAIL);
- H5T_CONV_sU(SCHAR, ULLONG,
- signed char, unsigned long_long);
+ H5T_CONV_sU(SCHAR, ULLONG, signed char, unsigned long_long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4084,13 +4039,14 @@ H5T_conv_uchar_llong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uchar_llong, FAIL);
- H5T_CONV_uS(UCHAR, LLONG,
- unsigned char, long_long,
- LLONG_MAX);
+ H5T_CONV_uS(UCHAR, LLONG, unsigned char, long_long, LLONG_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4116,12 +4072,14 @@ H5T_conv_uchar_ullong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uchar_ullong, FAIL);
- H5T_CONV_uU(UCHAR, ULLONG,
- unsigned char, unsigned long_long);
+ H5T_CONV_uU(UCHAR, ULLONG, unsigned char, unsigned long_long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4147,13 +4105,14 @@ H5T_conv_short_schar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_short_schar, FAIL);
- H5T_CONV_Ss(SHORT, SCHAR,
- short, signed char,
- SCHAR_MIN, SCHAR_MAX);
+ H5T_CONV_Ss(SHORT, SCHAR, short, signed char, SCHAR_MIN, SCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4179,13 +4138,14 @@ H5T_conv_short_uchar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_short_uchar, FAIL);
- H5T_CONV_Su(SHORT, UCHAR,
- short, unsigned char,
- UCHAR_MAX);
+ H5T_CONV_Su(SHORT, UCHAR, short, unsigned char, UCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4211,13 +4171,14 @@ H5T_conv_ushort_schar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ushort_schar, FAIL);
- H5T_CONV_Us(USHORT, SCHAR,
- unsigned short, signed char,
- SCHAR_MAX);
+ H5T_CONV_Us(USHORT, SCHAR, unsigned short, signed char, SCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4243,13 +4204,14 @@ H5T_conv_ushort_uchar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ushort_uchar, FAIL);
- H5T_CONV_Uu(USHORT, UCHAR,
- unsigned short, unsigned char,
- UCHAR_MAX);
+ H5T_CONV_Uu(USHORT, UCHAR, unsigned short, unsigned char, UCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4275,12 +4237,14 @@ H5T_conv_short_ushort(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_short_ushort, FAIL);
- H5T_CONV_su(SHORT, USHORT,
- short, unsigned short);
+ H5T_CONV_su(SHORT, USHORT, short, unsigned short);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4306,13 +4270,14 @@ H5T_conv_ushort_short(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ushort_short, FAIL);
- H5T_CONV_us(USHORT, SHORT,
- unsigned short, short,
- SHRT_MAX);
+ H5T_CONV_us(USHORT, SHORT, unsigned short, short, SHRT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4338,12 +4303,14 @@ H5T_conv_short_int(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_short_int, FAIL);
- H5T_CONV_sS(SHORT, INT,
- short, int);
+ H5T_CONV_sS(SHORT, INT, short, int);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4369,12 +4336,14 @@ H5T_conv_short_uint(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_short_uint, FAIL);
- H5T_CONV_sU(SHORT, UINT,
- short, unsigned);
+ H5T_CONV_sU(SHORT, UINT, short, unsigned);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4400,13 +4369,14 @@ H5T_conv_ushort_int(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ushort_int, FAIL);
- H5T_CONV_uS(USHORT, INT,
- unsigned short, int,
- INT_MAX);
+ H5T_CONV_uS(USHORT, INT, unsigned short, int, INT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4432,12 +4402,14 @@ H5T_conv_ushort_uint(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ushort_uint, FAIL);
- H5T_CONV_uU(USHORT, UINT,
- unsigned short, unsigned);
+ H5T_CONV_uU(USHORT, UINT, unsigned short, unsigned);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4463,12 +4435,14 @@ H5T_conv_short_long(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_short_long, FAIL);
- H5T_CONV_sS(SHORT, LONG,
- short, long);
+ H5T_CONV_sS(SHORT, LONG, short, long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4494,12 +4468,14 @@ H5T_conv_short_ulong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_short_ulong, FAIL);
- H5T_CONV_sU(SHORT, ULONG,
- short, unsigned long);
+ H5T_CONV_sU(SHORT, ULONG, short, unsigned long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4525,13 +4501,14 @@ H5T_conv_ushort_long(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ushort_long, FAIL);
- H5T_CONV_uS(USHORT, LONG,
- unsigned short, long,
- LONG_MAX);
+ H5T_CONV_uS(USHORT, LONG, unsigned short, long, LONG_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4557,12 +4534,14 @@ H5T_conv_ushort_ulong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ushort_ulong, FAIL);
- H5T_CONV_uU(USHORT, ULONG,
- unsigned short, unsigned long);
+ H5T_CONV_uU(USHORT, ULONG, unsigned short, unsigned long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4588,12 +4567,14 @@ H5T_conv_short_llong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_short_llong, FAIL);
- H5T_CONV_sS(SHORT, LLONG,
- short, long_long);
+ H5T_CONV_sS(SHORT, LLONG, short, long_long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4619,12 +4600,14 @@ H5T_conv_short_ullong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_short_ullong, FAIL);
- H5T_CONV_sU(SHORT, ULLONG,
- short, unsigned long_long);
+ H5T_CONV_sU(SHORT, ULLONG, short, unsigned long_long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4650,13 +4633,14 @@ H5T_conv_ushort_llong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ushort_llong, FAIL);
- H5T_CONV_uS(USHORT, LLONG,
- unsigned short, long_long,
- LLONG_MAX);
+ H5T_CONV_uS(USHORT, LLONG, unsigned short, long_long, LLONG_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4682,12 +4666,14 @@ H5T_conv_ushort_ullong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ushort_ullong, FAIL);
- H5T_CONV_uU(USHORT, ULLONG,
- unsigned short, unsigned long_long);
+ H5T_CONV_uU(USHORT, ULLONG, unsigned short, unsigned long_long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4713,13 +4699,14 @@ H5T_conv_int_schar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_int_schar, FAIL);
- H5T_CONV_Ss(INT, SCHAR,
- int, signed char,
- SCHAR_MIN, SCHAR_MAX);
+ H5T_CONV_Ss(INT, SCHAR, int, signed char, SCHAR_MIN, SCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4745,13 +4732,14 @@ H5T_conv_int_uchar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_int_uchar, FAIL);
- H5T_CONV_Su(INT, UCHAR,
- int, unsigned char,
- UCHAR_MAX);
+ H5T_CONV_Su(INT, UCHAR, int, unsigned char, UCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4777,13 +4765,14 @@ H5T_conv_uint_schar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uint_schar, FAIL);
- H5T_CONV_Us(UINT, SCHAR,
- unsigned, signed char,
- SCHAR_MAX);
+ H5T_CONV_Us(UINT, SCHAR, unsigned, signed char, SCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4809,13 +4798,14 @@ H5T_conv_uint_uchar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uint_uchar, FAIL);
- H5T_CONV_Uu(UINT, UCHAR,
- unsigned, unsigned char,
- UCHAR_MAX);
+ H5T_CONV_Uu(UINT, UCHAR, unsigned, unsigned char, UCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4841,13 +4831,14 @@ H5T_conv_int_short(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_int_short, FAIL);
- H5T_CONV_Ss(INT, SHORT,
- int, short,
- SHRT_MIN, SHRT_MAX);
+ H5T_CONV_Ss(INT, SHORT, int, short, SHRT_MIN, SHRT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4873,13 +4864,14 @@ H5T_conv_int_ushort(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_int_ushort, FAIL);
- H5T_CONV_Su(INT, USHORT,
- int, unsigned short,
- USHRT_MAX);
+ H5T_CONV_Su(INT, USHORT, int, unsigned short, USHRT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4905,13 +4897,14 @@ H5T_conv_uint_short(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uint_short, FAIL);
- H5T_CONV_Us(UINT, SHORT,
- unsigned, short,
- SHRT_MAX);
+ H5T_CONV_Us(UINT, SHORT, unsigned, short, SHRT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4937,13 +4930,14 @@ H5T_conv_uint_ushort(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uint_ushort, FAIL);
- H5T_CONV_Uu(UINT, USHORT,
- unsigned, unsigned short,
- USHRT_MAX);
+ H5T_CONV_Uu(UINT, USHORT, unsigned, unsigned short, USHRT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4968,12 +4962,14 @@ H5T_conv_int_uint(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_int_uint, FAIL);
- H5T_CONV_su(INT, UINT,
- int, unsigned);
+ H5T_CONV_su(INT, UINT, int, unsigned);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -4998,13 +4994,14 @@ H5T_conv_uint_int(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uint_int, FAIL);
- H5T_CONV_us(UINT, INT,
- unsigned, int,
- INT_MAX);
+ H5T_CONV_us(UINT, INT, unsigned, int, INT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5029,12 +5026,14 @@ H5T_conv_int_long(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_int_long, FAIL);
- H5T_CONV_sS(INT, LONG,
- int, long);
+ H5T_CONV_sS(INT, LONG, int, long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5059,12 +5058,14 @@ H5T_conv_int_ulong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_int_ulong, FAIL);
- H5T_CONV_sU(INT, LONG,
- int, unsigned long);
+ H5T_CONV_sU(INT, LONG, int, unsigned long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5089,13 +5090,14 @@ H5T_conv_uint_long(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uint_long, FAIL);
- H5T_CONV_uS(UINT, LONG,
- unsigned, long,
- LONG_MAX);
+ H5T_CONV_uS(UINT, LONG, unsigned, long, LONG_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5120,12 +5122,14 @@ H5T_conv_uint_ulong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uint_ulong, FAIL);
- H5T_CONV_uU(UINT, ULONG,
- unsigned, unsigned long);
+ H5T_CONV_uU(UINT, ULONG, unsigned, unsigned long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5150,12 +5154,14 @@ H5T_conv_int_llong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_int_llong, FAIL);
- H5T_CONV_sS(INT, LLONG,
- int, long_long);
+ H5T_CONV_sS(INT, LLONG, int, long_long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5180,12 +5186,14 @@ H5T_conv_int_ullong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_int_ullong, FAIL);
- H5T_CONV_sU(INT, ULLONG,
- int, unsigned long_long);
+ H5T_CONV_sU(INT, ULLONG, int, unsigned long_long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5210,13 +5218,14 @@ H5T_conv_uint_llong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uint_llong, FAIL);
- H5T_CONV_uS(UINT, LLONG,
- unsigned, long_long,
- LLONG_MAX);
+ H5T_CONV_uS(UINT, LLONG, unsigned, long_long, LLONG_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5242,12 +5251,14 @@ H5T_conv_uint_ullong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_uint_ullong, FAIL);
- H5T_CONV_uU(UINT, ULLONG,
- unsigned, unsigned long_long);
+ H5T_CONV_uU(UINT, ULLONG, unsigned, unsigned long_long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5272,13 +5283,14 @@ H5T_conv_long_schar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_long_schar, FAIL);
- H5T_CONV_Ss(LONG, SCHAR,
- long, signed char,
- SCHAR_MIN, SCHAR_MAX);
+ H5T_CONV_Ss(LONG, SCHAR, long, signed char, SCHAR_MIN, SCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5303,13 +5315,14 @@ H5T_conv_long_uchar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_long_uchar, FAIL);
- H5T_CONV_Su(LONG, UCHAR,
- long, unsigned char,
- UCHAR_MAX);
+ H5T_CONV_Su(LONG, UCHAR, long, unsigned char, UCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5335,13 +5348,14 @@ H5T_conv_ulong_schar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ulong_schar, FAIL);
- H5T_CONV_Us(ULONG, SCHAR,
- unsigned long, signed char,
- SCHAR_MAX);
+ H5T_CONV_Us(ULONG, SCHAR, unsigned long, signed char, SCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5367,13 +5381,14 @@ H5T_conv_ulong_uchar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ulong_uchar, FAIL);
- H5T_CONV_Uu(ULONG, UCHAR,
- unsigned long, unsigned char,
- UCHAR_MAX);
+ H5T_CONV_Uu(ULONG, UCHAR, unsigned long, unsigned char, UCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5398,13 +5413,14 @@ H5T_conv_long_short(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_long_short, FAIL);
- H5T_CONV_Ss(LONG, SHORT,
- long, short,
- SHRT_MIN, SHRT_MAX);
+ H5T_CONV_Ss(LONG, SHORT, long, short, SHRT_MIN, SHRT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5430,13 +5446,14 @@ H5T_conv_long_ushort(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_long_ushort, FAIL);
- H5T_CONV_Su(LONG, USHORT,
- long, unsigned short,
- USHRT_MAX);
+ H5T_CONV_Su(LONG, USHORT, long, unsigned short, USHRT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5461,13 +5478,14 @@ H5T_conv_ulong_short(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ulong_short, FAIL);
- H5T_CONV_Us(ULONG, SHORT,
- unsigned long, short,
- SHRT_MAX);
+ H5T_CONV_Us(ULONG, SHORT, unsigned long, short, SHRT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5493,13 +5511,14 @@ H5T_conv_ulong_ushort(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ulong_ushort, FAIL);
- H5T_CONV_Uu(ULONG, USHORT,
- unsigned long, unsigned short,
- USHRT_MAX);
+ H5T_CONV_Uu(ULONG, USHORT, unsigned long, unsigned short, USHRT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5524,13 +5543,14 @@ H5T_conv_long_int(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_long_int, FAIL);
- H5T_CONV_Ss(LONG, INT,
- long, int,
- INT_MIN, INT_MAX);
+ H5T_CONV_Ss(LONG, INT, long, int, INT_MIN, INT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5555,13 +5575,14 @@ H5T_conv_long_uint(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_long_uint, FAIL);
- H5T_CONV_Su(LONG, UINT,
- long, unsigned,
- UINT_MAX);
+ H5T_CONV_Su(LONG, UINT, long, unsigned, UINT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5586,13 +5607,14 @@ H5T_conv_ulong_int(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ulong_int, FAIL);
- H5T_CONV_Us(ULONG, INT,
- unsigned long, int,
- INT_MAX);
+ H5T_CONV_Us(ULONG, INT, unsigned long, int, INT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5617,13 +5639,14 @@ H5T_conv_ulong_uint(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ulong_uint, FAIL);
- H5T_CONV_Uu(ULONG, UINT,
- unsigned long, unsigned,
- UINT_MAX);
+ H5T_CONV_Uu(ULONG, UINT, unsigned long, unsigned, UINT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5648,12 +5671,14 @@ H5T_conv_long_ulong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_long_ulong, FAIL);
- H5T_CONV_su(LONG, ULONG,
- long, unsigned long);
+ H5T_CONV_su(LONG, ULONG, long, unsigned long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5678,13 +5703,14 @@ H5T_conv_ulong_long(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ulong_long, FAIL);
- H5T_CONV_us(ULONG, LONG,
- unsigned long, long,
- LONG_MAX);
+ H5T_CONV_us(ULONG, LONG, unsigned long, long, LONG_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5709,12 +5735,14 @@ H5T_conv_long_llong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_long_llong, FAIL);
- H5T_CONV_sS(LONG, LLONG,
- long, long_long);
+ H5T_CONV_sS(LONG, LLONG, long, long_long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5740,12 +5768,14 @@ H5T_conv_long_ullong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_long_ullong, FAIL);
- H5T_CONV_sU(LONG, ULLONG,
- long, unsigned long_long);
+ H5T_CONV_sU(LONG, ULLONG, long, unsigned long_long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5771,13 +5801,14 @@ H5T_conv_ulong_llong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_long_llong, FAIL);
- H5T_CONV_uS(ULONG, LLONG,
- unsigned long, long_long,
- LLONG_MAX);
+ H5T_CONV_uS(ULONG, LLONG, unsigned long, long_long, LLONG_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5803,12 +5834,14 @@ H5T_conv_ulong_ullong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ulong_ullong, FAIL);
- H5T_CONV_uU(ULONG, ULLONG,
- unsigned long, unsigned long_long);
+ H5T_CONV_uU(ULONG, ULLONG, unsigned long, unsigned long_long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5834,13 +5867,14 @@ H5T_conv_llong_schar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_llong_schar, FAIL);
- H5T_CONV_Ss(LLONG, SCHAR,
- long_long, signed char,
- SCHAR_MIN, SCHAR_MAX);
+ H5T_CONV_Ss(LLONG, SCHAR, long_long, signed char, SCHAR_MIN, SCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5866,13 +5900,14 @@ H5T_conv_llong_uchar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_llong_uchar, FAIL);
- H5T_CONV_Su(LLONG, UCHAR,
- long_long, unsigned char,
- UCHAR_MAX);
+ H5T_CONV_Su(LLONG, UCHAR, long_long, unsigned char, UCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5898,13 +5933,14 @@ H5T_conv_ullong_schar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ullong_schar, FAIL);
- H5T_CONV_Us(ULLONG, SCHAR,
- unsigned long_long, signed char,
- SCHAR_MAX);
+ H5T_CONV_Us(ULLONG, SCHAR, unsigned long_long, signed char, SCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5930,13 +5966,14 @@ H5T_conv_ullong_uchar(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ullong_uchar, FAIL);
- H5T_CONV_Uu(ULLONG, UCHAR,
- unsigned long_long, unsigned char,
- UCHAR_MAX);
+ H5T_CONV_Uu(ULLONG, UCHAR, unsigned long_long, unsigned char, UCHAR_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5962,13 +5999,14 @@ H5T_conv_llong_short(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_llong_short, FAIL);
- H5T_CONV_Ss(LLONG, SHORT,
- long_long, short,
- SHRT_MIN, SHRT_MAX);
+ H5T_CONV_Ss(LLONG, SHORT, long_long, short, SHRT_MIN, SHRT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -5994,13 +6032,14 @@ H5T_conv_llong_ushort(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_llong_ushort, FAIL);
- H5T_CONV_Su(LLONG, USHORT,
- long_long, unsigned short,
- USHRT_MAX);
+ H5T_CONV_Su(LLONG, USHORT, long_long, unsigned short, USHRT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -6026,13 +6065,14 @@ H5T_conv_ullong_short(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ullong_short, FAIL);
- H5T_CONV_Us(ULLONG, SHORT,
- unsigned long_long, short,
- SHRT_MAX);
+ H5T_CONV_Us(ULLONG, SHORT, unsigned long_long, short, SHRT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -6058,13 +6098,14 @@ H5T_conv_ullong_ushort(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ullong_ushort, FAIL);
- H5T_CONV_Uu(ULLONG, USHORT,
- unsigned long_long, unsigned short,
- USHRT_MAX);
+ H5T_CONV_Uu(ULLONG, USHORT, unsigned long_long, unsigned short, USHRT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -6089,13 +6130,14 @@ H5T_conv_llong_int(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_llong_int, FAIL);
- H5T_CONV_Ss(LLONG, INT,
- long_long, int,
- INT_MIN, INT_MAX);
+ H5T_CONV_Ss(LLONG, INT, long_long, int, INT_MIN, INT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -6120,13 +6162,14 @@ H5T_conv_llong_uint(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_llong_uint, FAIL);
- H5T_CONV_Su(LLONG, UINT,
- long_long, unsigned,
- UINT_MAX);
+ H5T_CONV_Su(LLONG, UINT, long_long, unsigned, UINT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -6151,13 +6194,14 @@ H5T_conv_ullong_int(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ullong_int, FAIL);
- H5T_CONV_Us(ULLONG, INT,
- unsigned long_long, int,
- INT_MAX);
+ H5T_CONV_Us(ULLONG, INT, unsigned long_long, int, INT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -6183,13 +6227,14 @@ H5T_conv_ullong_uint(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ullong_uint, FAIL);
- H5T_CONV_Uu(ULLONG, UINT,
- unsigned long_long, unsigned,
- UINT_MAX);
+ H5T_CONV_Uu(ULLONG, UINT, unsigned long_long, unsigned, UINT_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -6214,13 +6259,14 @@ H5T_conv_llong_long(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride, size_t UNUSED bkg_stride,
void *buf, void UNUSED *bkg, hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_llong_long, FAIL);
- H5T_CONV_Ss(LLONG, LONG,
- long_long, long,
- LONG_MIN, LONG_MAX);
+ H5T_CONV_Ss(LLONG, LONG, long_long, long, LONG_MIN, LONG_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -6246,13 +6292,14 @@ H5T_conv_llong_ulong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_llong_ulong, FAIL);
- H5T_CONV_Su(LLONG, ULONG,
- long_long, unsigned long,
- ULONG_MAX);
+ H5T_CONV_Su(LLONG, ULONG, long_long, unsigned long, ULONG_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -6278,13 +6325,14 @@ H5T_conv_ullong_long(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ullong_long, FAIL);
- H5T_CONV_Us(ULLONG, LONG,
- unsigned long_long, long,
- LONG_MAX);
+ H5T_CONV_Us(ULLONG, LONG, unsigned long_long, long, LONG_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -6310,13 +6358,14 @@ H5T_conv_ullong_ulong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ullong_ulong, FAIL);
- H5T_CONV_Uu(ULLONG, ULONG,
- unsigned long_long, unsigned long,
- ULONG_MAX);
+ H5T_CONV_Uu(ULLONG, ULONG, unsigned long_long, unsigned long, ULONG_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -6342,12 +6391,14 @@ H5T_conv_llong_ullong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_llong_ullong, FAIL);
- H5T_CONV_su(LLONG, ULLONG,
- long_long, unsigned long_long);
+ H5T_CONV_su(LLONG, ULLONG, long_long, unsigned long_long);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -6373,13 +6424,14 @@ H5T_conv_ullong_llong(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
hid_t UNUSED dset_xfer_plist)
{
+ herr_t ret_value=SUCCEED; /* Return value */
+
FUNC_ENTER_NOAPI(H5T_conv_ullong_llong, FAIL);
- H5T_CONV_us(ULLONG, LLONG,
- unsigned long_long, long_long,
- LLONG_MAX);
+ H5T_CONV_us(ULLONG, LLONG, unsigned long_long, long_long, LLONG_MAX);
- FUNC_LEAVE(SUCCEED);
+done:
+ FUNC_LEAVE(ret_value);
}
@@ -6414,6 +6466,7 @@ H5T_conv_float_double (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
H5T_t *st, *dt; /*type descriptors */
hbool_t src_mv, dst_mv; /*align data? */
double aligned; /*aligned data */
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5T_conv_float_double, FAIL);
@@ -6422,11 +6475,9 @@ H5T_conv_float_double (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
cdata->need_bkg = H5T_BKG_NO;
if (NULL==(st=H5I_object_verify(src_id,H5I_DATATYPE)) ||
NULL==(dt=H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to dereference data type object ID");
- if (st->size!=sizeof(float) || dt->size!=sizeof(double)) {
- HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
- "disagreement about data type size");
- }
+ HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to dereference data type object ID");
+ if (st->size!=sizeof(float) || dt->size!=sizeof(double))
+ HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "disagreement about data type size");
CI_ALLOC_PRIV
break;
@@ -6493,11 +6544,11 @@ H5T_conv_float_double (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
break;
default:
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unknown conversion command");
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
}
- FUNC_LEAVE (SUCCEED);
+done:
+ FUNC_LEAVE (ret_value);
}
@@ -6535,6 +6586,7 @@ H5T_conv_double_float (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
H5T_t *st, *dt; /*type descriptors */
hbool_t src_mv, dst_mv; /*align data? */
double aligned; /*aligned data */
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5T_conv_double_float, FAIL);
@@ -6543,11 +6595,9 @@ H5T_conv_double_float (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
cdata->need_bkg = H5T_BKG_NO;
if (NULL==(st=H5I_object_verify(src_id,H5I_DATATYPE)) ||
NULL==(dt=H5I_object_verify(dst_id,H5I_DATATYPE)))
- HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to dereference data type object ID");
- if (st->size!=sizeof(double) || dt->size!=sizeof(float)) {
- HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
- "disagreement about data type size");
- }
+ HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to dereference data type object ID");
+ if (st->size!=sizeof(double) || dt->size!=sizeof(float))
+ HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "disagreement about data type size");
CI_ALLOC_PRIV
break;
@@ -6622,11 +6672,11 @@ H5T_conv_double_float (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
break;
default:
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unknown conversion command");
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
}
- FUNC_LEAVE (SUCCEED);
+done:
+ FUNC_LEAVE (ret_value);
}
@@ -6665,6 +6715,7 @@ H5T_conv_i32le_f64le (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
unsigned mbits=0; /*mantissa bits */
unsigned exponent; /*exponent */
int i; /*counter */
+ herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5T_conv_i32le_f64le, FAIL);
@@ -6682,7 +6733,7 @@ H5T_conv_i32le_f64le (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
/* The conversion */
if (NULL==(src=H5I_object_verify(src_id,H5I_DATATYPE)) ||
NULL==H5I_object_verify(dst_id,H5I_DATATYPE))
- HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
s = (uint8_t*)buf + (buf_stride?buf_stride:4)*(nelmts-1);
d = (uint8_t*)buf + (buf_stride?buf_stride:8)*(nelmts-1);
@@ -6716,8 +6767,7 @@ H5T_conv_i32le_f64le (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
break;
default:
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unsupported integer sign method");
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unsupported integer sign method");
}
/*
@@ -7013,9 +7063,9 @@ H5T_conv_i32le_f64le (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
default:
/* Some other command we don't know about yet.*/
- HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
- "unknown conversion command");
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
}
- FUNC_LEAVE (SUCCEED);
+done:
+ FUNC_LEAVE (ret_value);
}