summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/H5T.c1
-rw-r--r--src/H5Tbit.c29
-rw-r--r--src/H5Tconv.c387
-rw-r--r--src/H5Tpkg.h4
4 files changed, 407 insertions, 14 deletions
diff --git a/src/H5T.c b/src/H5T.c
index f614d32..fa73518 100644
--- a/src/H5T.c
+++ b/src/H5T.c
@@ -954,6 +954,7 @@ H5T_init_interface(void)
status = 0;
status |= H5T_register(H5T_PERS_SOFT, "i_i", fixedpt, fixedpt, H5T_conv_i_i, H5AC_dxpl_id);
+ status |= H5T_register(H5T_PERS_SOFT, "i_f", fixedpt, floatpt, H5T_conv_i_f, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_SOFT, "f_f", floatpt, floatpt, H5T_conv_f_f, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_SOFT, "f_i", floatpt, fixedpt, H5T_conv_f_i, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_SOFT, "s_s", string, string, H5T_conv_s_s, H5AC_dxpl_id);
diff --git a/src/H5Tbit.c b/src/H5Tbit.c
index ef62f31..f3fbc3d 100644
--- a/src/H5Tbit.c
+++ b/src/H5Tbit.c
@@ -166,7 +166,8 @@ H5T_bit_copy (uint8_t *dst, size_t dst_offset, const uint8_t *src,
*
* Purpose: Simulation of hardware shifting. Shifts a bit vector
* in a way similar to shifting a variable value, like
- * value <<= 3, or value >>= 16.
+ * value <<= 3, or value >>= 16. SHIFT_DIST is positive for
+ * left shift, negative for right shift.
*
* Return: void
*
@@ -175,6 +176,9 @@ H5T_bit_copy (uint8_t *dst, size_t dst_offset, const uint8_t *src,
*
* Modifications:
*
+ * Can generalize it to handle a bit vector of any START
+ * position and any SIZE.
+ *
*-------------------------------------------------------------------------
*/
void
@@ -219,7 +223,8 @@ done:
/*-------------------------------------------------------------------------
* Function: H5T_bit_get_d
*
- * Purpose: Return a small bit sequence as a number.
+ * Purpose: Return a small bit sequence as a number. Bit vector starts
+ * at OFFSET and is SIZE bits long.
*
* Return: Success: The bit sequence interpretted as an unsigned
* integer.
@@ -369,7 +374,9 @@ H5T_bit_set (uint8_t *buf, size_t offset, size_t size, hbool_t value)
* Purpose: Finds the first bit with the specified VALUE within a region
* of a bit vector. The region begins at OFFSET and continues
* for SIZE bits, but the region can be searched from the least
- * significat end toward the most significant end with
+ * significat end toward the most significant end(H5T_BIT_MSB
+ * as DIRECTION), or from the most significant end to the least
+ * significant end(H5T_BIT_LSB as DIRECTION).
*
* Return: Success: The position of the bit found, relative to
* the offset.
@@ -473,7 +480,8 @@ done:
/*-------------------------------------------------------------------------
* Function: H5T_bit_inc
*
- * Purpose: Increment part of a bit field by adding 1.
+ * Purpose: Increment part of a bit field by adding 1. The bit field
+ * starts with bit position START and is SIZE bits long.
*
* Return: Success: The carry-out value, one if overflow zero
* otherwise.
@@ -542,8 +550,8 @@ H5T_bit_inc(uint8_t *buf, size_t start, size_t size)
* Function: H5T_bit_dec
*
* Purpose: decrement part of a bit field by 1.
- * At this moment, START is always 0 and the algorithm only
- * works from the end to the front for the buffer.
+ * At this moment, START is always 0 and SIZE is a multiply
+ * of 8(in bit). This is different from H5T_bit_inc.
*
* Return: void
*
@@ -553,6 +561,9 @@ H5T_bit_inc(uint8_t *buf, size_t start, size_t size)
*
* Modifications:
*
+ * Need to generalize it to handle random START and SIZE like
+ * H5T_bit_inc.
+ *
*-------------------------------------------------------------------------
*/
void
@@ -579,7 +590,8 @@ H5T_bit_dec(uint8_t *buf, size_t start, size_t size)
* Function: H5T_bit_neg
*
* Purpose: Bit-negate buffer.
- * At this moment, START is always 0.
+ * At this moment, START is always 0 and SIZE is always a
+ * multiply of 8 (in bit).
*
* Return: void
*
@@ -588,6 +600,9 @@ H5T_bit_dec(uint8_t *buf, size_t start, size_t size)
*
* Modifications:
*
+ * Need to generalize it to handle rand START and SIZE like
+ * H5T_bit_inc.
+ *
*-------------------------------------------------------------------------
*/
void
diff --git a/src/H5Tconv.c b/src/H5Tconv.c
index f6a51f1..e686faa 100644
--- a/src/H5Tconv.c
+++ b/src/H5Tconv.c
@@ -8472,7 +8472,7 @@ H5T_conv_f_i (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
/* Allocate enough space for the buffer holding temporary
* converted value
*/
- buf_size = (int)HDpow((double)2.0, (double)src.u.f.esize) / 8 + 1;
+ buf_size = (size_t)HDpow((double)2.0, (double)src.u.f.esize) / 8 + 1;
int_buf = (uint8_t*)H5MM_calloc(buf_size);
/* The conversion loop */
@@ -8564,7 +8564,6 @@ H5T_conv_f_i (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
* the source exponent bias.
*/
if (0==expo || H5T_NORM_NONE==src.u.f.norm) {
- /*Don't get this part*/
bitno = H5T_bit_find(s, src.u.f.mpos, src.u.f.msize,
H5T_BIT_MSB, TRUE);
assert(bitno>=0);
@@ -8607,11 +8606,7 @@ H5T_conv_f_i (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
* Shift mantissa part by exponent minus mantissa size(right shift),
* or by mantissa size minus exponent(left shift).
*/
- if( H5T_NORM_IMPLIED==src.u.f.norm) {
- H5T_bit_shift(int_buf, expo - src.u.f.msize, buf_size);
- } else if(H5T_NORM_NONE==src.u.f.norm) {
- /* How to do this? */
- }
+ H5T_bit_shift(int_buf, expo - src.u.f.msize, buf_size);
/*fprintf(stderr, "int_buf=");
for(i=0; i<buf_size; i++)
@@ -8749,3 +8744,381 @@ H5T_conv_f_i (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5T_conv_i_f
+ *
+ * Purpose: Convert one integer type to a floating-point type. This is
+ * the catch-all function for integer-float conversions and
+ * is probably not particularly fast.
+ *
+ * Return: Non-negative on success/Negative on failure
+ *
+ * Programmer: Raymond Lu
+ * Friday, Feb 6, 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5T_conv_i_f (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 dxpl_id)
+{
+ /* Traversal-related variables */
+ H5T_t *src_p; /*source data type */
+ H5T_t *dst_p; /*destination data type */
+ H5T_atomic_t src; /*atomic source info */
+ H5T_atomic_t dst; /*atomic destination info */
+ int direction; /*forward or backward traversal */
+ hsize_t elmtno; /*element number */
+ size_t half_size; /*half the type size */
+ hsize_t olap; /*num overlapping elements */
+ ssize_t bitno; /*bit number */
+ uint8_t *s, *sp, *d, *dp; /*source and dest traversal ptrs*/
+ uint8_t dbuf[64]; /*temp destination buffer */
+
+ /* Conversion-related variables */
+ hsize_t expo; /*destiny exponent */
+ hsize_t expo_max; /*maximal possible exponent value */
+ /*hsize_t sign = 0;*/ /*source sign bit value */
+ /*hsize_t is_max_neg = 0;*/ /*source is maximal negative value*/
+ /*hsize_t do_round = 0;*/ /*whether there is roundup */
+ /*hsize_t trailing = 0;*/ /*whether there is trailing after 1st roundup bit*/
+ uint8_t *int_buf; /*buffer for temporary value */
+ size_t buf_size; /*buffer size for temporary value */
+ size_t msize; /*mantissa size after restored implied 1 */
+ size_t i; /*miscellaneous counters */
+ size_t first; /*first bit(MSB) in an integer */
+ ssize_t sfirst; /*a signed version of `first' */
+ herr_t ret_value=SUCCEED; /* Return value */
+
+ FUNC_ENTER_NOAPI(H5T_conv_i_f, FAIL);
+
+ switch (cdata->command) {
+ case H5T_CONV_INIT:
+ if (NULL==(src_p=H5I_object(src_id)) ||
+ NULL==(dst_p=H5I_object(dst_id)))
+ 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!=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)
+ 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_CONV:
+ /* Get the data types */
+ if (NULL==(src_p=H5I_object(src_id)) ||
+ NULL==(dst_p=H5I_object(dst_id)))
+ HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+ src = src_p->u.atomic;
+ dst = dst_p->u.atomic;
+
+ /*
+ * 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;
+ }
+
+ /* Allocate enough space for the buffer holding temporary
+ * converted value
+ */
+ buf_size = (src.prec > dst.u.f.msize ? src.prec : dst.u.f.msize)/8 + 1;
+ int_buf = (uint8_t*)H5MM_calloc(buf_size);
+
+ /* The conversion loop */
+ for (elmtno=0; elmtno<nelmts; elmtno++) {
+ hsize_t sign = 0; /*source sign bit value */
+ hsize_t is_max_neg = 0; /*source is maximal negative value*/
+ hsize_t do_round = 0; /*whether there is roundup */
+ hsize_t trailing = 0; /*whether there is trailing after 1st roundup bit*/
+
+ /*
+ * 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));
+ }
+#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;
+ }
+ }
+
+ /*zero-set all destination bits*/
+ H5T_bit_set (d, dst.offset, dst.prec, FALSE);
+
+ /* Copy source into a temporary buffer */
+ H5T_bit_copy(int_buf, 0, s, src.offset, src.prec);
+
+
+/* For debug */
+/*HDmemset(int_buf, 0, buf_size);
+H5T_bit_set(int_buf, 0, src.prec, 1);*/
+
+/*fprintf(stderr, "\n no. %d int_buf=0x ", elmtno);
+for(i=0; i<buf_size; i++)
+ fprintf(stderr, "%02x ", int_buf[i]);*/
+/*fprintf(stderr, "\n s=0x ");
+for(i=0; i<buf_size-1; i++)
+ fprintf(stderr, "%02x ", s[i]);*/
+
+ /*
+ * Find the sign bit value of the source.
+ */
+ if (H5T_SGN_2 == src.u.i.sign)
+ sign = H5T_bit_get_d(int_buf, src.prec-1, 1);
+
+ /*
+ * What is the bit position(starting from 0 as first one) for the most significant
+ * bit(MSB) of S which is set?
+ */
+ if(H5T_SGN_2 == src.u.i.sign) {
+ sfirst = H5T_bit_find(int_buf, 0, src.prec-1, H5T_BIT_MSB, TRUE);
+ if(sign && sfirst < 0)
+ /* The case 0x80...00, which is negative with maximal value */
+ is_max_neg = 1;
+ } else if(H5T_SGN_NONE == src.u.i.sign)
+ sfirst = H5T_bit_find(int_buf, 0, src.prec, H5T_BIT_MSB, TRUE);
+/*fprintf(stderr, "\n is_max_neg=%d", is_max_neg);*/
+
+ /* Handle special cases here. Integer is zero */
+ if(!sign && sfirst < 0)
+ goto padding;
+
+ /*
+ * Convert source integer if it's negative
+ */
+ if (H5T_SGN_2 == src.u.i.sign && sign) {
+ if(!is_max_neg) {
+ /* Equivalent to ~(i - 1) */
+ H5T_bit_dec(int_buf, 0, buf_size*8);
+ H5T_bit_neg(int_buf, 0, buf_size*8);
+ sfirst = H5T_bit_find(int_buf, 0, src.prec-1, H5T_BIT_MSB, TRUE);
+ } else {
+ /* If it's maximal negative number 0x80...000, treat it as if it overflows
+ * (create a carry) to help conversion. i.e. a character type number 0x80
+ * is treated as 0x100.
+ */
+ sfirst = src.prec-1;
+ is_max_neg = 0;
+ }
+/*fprintf(stderr, "\n after negate int_buf=0x ");
+for(i=0; i<buf_size; i++)
+ fprintf(stderr, "%02x ", int_buf[i]);*/
+
+ /* Sign bit has been negated if bit vector isn't 0x80...00. Set all bits in front of
+ * sign bit to 0 in the temporary buffer because they're all negated from the previous
+ * step. */
+ H5T_bit_set(int_buf, src.prec, buf_size*8-src.prec, 0);
+/*fprintf(stderr, "\n after bits in front of sign off int_buf=0x ");
+for(i=0; i<buf_size; i++)
+ fprintf(stderr, "%02x ", int_buf[i]);*/
+
+ /* Set sign bit in destiny */
+ H5T_bit_set_d(d, dst.u.f.sign, 1, sign);
+ }
+
+ first = (size_t)sfirst;
+/*fprintf(stderr, "\n first=%d", first);*/
+
+
+ /*
+ * Calculate the true destination exponent by adjusting according to
+ * the destination exponent bias.
+ */
+ if (H5T_NORM_NONE==src.u.f.norm) {
+ expo = first + 1 + dst.u.f.ebias;
+ } else if (H5T_NORM_IMPLIED==src.u.f.norm) {
+ expo = first + dst.u.f.ebias;
+ } else {
+ assert("normalization method not implemented yet" && 0);
+ HDabort();
+ }
+
+/*fprintf(stderr, "\n expo=%d,", expo);
+fprintf(stderr, "\n expo_max=%d,", expo_max);*/
+
+ /* Handle mantissa part here */
+ if (H5T_NORM_IMPLIED==src.u.f.norm) {
+ /* Imply first bit */
+ H5T_bit_set(int_buf, first, 1, 0);
+/*fprintf(stderr, "\n after 1st bit implied int_buf=0x ");
+for(i=0; i<buf_size; i++)
+ fprintf(stderr, "%02x ", int_buf[i]);*/
+ } else if (H5T_NORM_NONE==src.u.f.norm) {
+ first++;
+ }
+
+ /* Roundup for mantissa */
+ if(first > dst.u.f.msize) {
+ /* If the bit sequence is bigger than the mantissa part, we need to drop off the
+ * extra bits at the end and do rounding. If we have .50...0(decimal) after radix
+ * point, we do roundup when the least significant digit before radix is odd, we do
+ * rounddown if it's even.
+ */
+
+ /* Check 1st dropoff bit, see if it's set. */
+ if(H5T_bit_get_d(int_buf, (first-dst.u.f.msize-1), 1)) {
+ /* Check all bits after 1st dropoff bit, see if any of them is set. */
+ if((first-dst.u.f.msize-1) > 0 && H5T_bit_get_d(int_buf, 0, (first-dst.u.f.msize-1)))
+ do_round = 1;
+ else { /* The .50...0 case */
+ /* Check if the least significant bit is odd. */
+ if(H5T_bit_get_d(int_buf, (first-dst.u.f.msize), 1))
+ do_round = 1;
+ }
+ }
+
+ /* Right shift to drop off extra bits */
+ H5T_bit_shift(int_buf, (ssize_t)(dst.u.f.msize-first), buf_size);
+
+ if(do_round) {
+ H5T_bit_inc(int_buf, 0, buf_size*8);
+ do_round = 0;
+
+ /* If integer is like 0x0ff...fff and we need to round up the
+ * last f, we get 0x100...000. Treat this special case here.
+ */
+ if(H5T_bit_get_d(int_buf, dst.u.f.msize, 1)) {
+ if (H5T_NORM_IMPLIED==src.u.f.norm) {
+ /* The bit at this 1's position was impled already, so this
+ * number should be 0x200...000. We need to increment the
+ * exponent in this case.
+ */
+ expo++;
+ } else if (H5T_NORM_NONE==src.u.f.norm) {
+ /* Right shift 1 bit to let the carried 1 fit in the mantissa,
+ * and increment exponent by 1.
+ */
+ H5T_bit_shift(int_buf, -1, buf_size);
+ expo++;
+ }
+ }
+ }
+ } else {
+ /* The bit sequence can fit mantissa part. Left shift to fit in from high-order of
+ * bit position. */
+ H5T_bit_shift(int_buf, (ssize_t)(dst.u.f.msize-first), buf_size);
+ }
+
+
+ /* Check if the exponent is too big */
+ expo_max = (hsize_t)HDpow((double)2.0, (double)dst.u.f.esize) - 1;
+ if(expo > expo_max)
+ expo = expo_max;
+
+ /* Set exponent in destiny */
+ H5T_bit_set_d(d, dst.u.f.epos, dst.u.f.esize, expo);
+
+ /* Copy mantissa into destiny */
+ H5T_bit_copy(d, dst.u.f.mpos, int_buf, 0, buf_size*8 > dst.u.f.msize ? dst.u.f.msize : buf_size*8);
+
+ padding:
+ /*
+ * Set padding areas in destination.
+ */
+ 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;
+ }
+ }
+
+ /*
+ * 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_p->size);
+ if (buf_stride) {
+ sp += direction * buf_stride;
+ dp += direction * buf_stride;
+ } else {
+ sp += direction * src_p->size;
+ dp += direction * dst_p->size;
+ }
+
+ HDmemset(int_buf, 0, buf_size);
+ }
+
+ H5MM_xfree(int_buf);
+
+ break;
+
+ default:
+ HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
+ }
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value);
+}
diff --git a/src/H5Tpkg.h b/src/H5Tpkg.h
index 147b639..ad817f3 100644
--- a/src/H5Tpkg.h
+++ b/src/H5Tpkg.h
@@ -383,6 +383,10 @@ H5_DLL herr_t H5T_conv_f_i(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride,
size_t bkg_stride, void *_buf, void *bkg,
hid_t dset_xfer_plist);
+H5_DLL herr_t H5T_conv_i_f(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
+ hsize_t nelmts, size_t buf_stride,
+ size_t bkg_stride, void *_buf, void *bkg,
+ hid_t dset_xfer_plist);
H5_DLL herr_t H5T_conv_s_s(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
hsize_t nelmts, size_t buf_stride,
size_t bkg_stride, void *_buf, void *bkg,