[svn-r8153] *** empty log message ***

1 files changed, 382 insertions, 0 deletions

diff --git a/src/H5Tconv.c b/src/H5Tconv.c
index 862c19a..cd7a301 100644
--- a/src/H5Tconv.c
+++ b/src/H5Tconv.c
@@ -2935,6 +2935,7 @@ H5T_conv_i_i (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
                         }
                     } 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);
+                        /* Why is it set to TRUE? */
                         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);
@@ -8363,3 +8364,384 @@ H5T_conv_i32le_f64le (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
 done:
     FUNC_LEAVE_NOAPI(ret_value);
 }
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5T_conv_f_i
+ *
+ * Purpose:	Convert one floating-point type to an integer.  This is 
+ *              the catch-all function for float-integer conversions and 
+ *              is probably not particularly fast.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Raymond Lu
+ *		Wednesday, Jan 21, 2004
+ *
+ * Modifications:
+ *		
+ *-------------------------------------------------------------------------
+ */
+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 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 */
+    hssize_t	expo;			/*source exponent		*/
+    hssize_t	mant;			/*source mantissa		*/
+    hssize_t    sign;                   /*source sign bit value         */
+    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_f_i, 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!=src.order && H5T_ORDER_BE!=src.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 = (int)pow(2, src.u.f.esize) / 8 + 1;          
+            int_buf = (uint8_t*)HDcalloc(buf_size, 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));
+                }
+#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);
+                
+                /*
+                 * Find the sign bit value of the source.
+                 */
+                sign = H5T_bit_get_d(s, src.prec-1, 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 */
+                        /* Set all bits to zero */
+                        goto padding;
+                    } else if (H5T_bit_find (s, src.u.f.epos, src.u.f.esize,
+                                             H5T_BIT_LSB, FALSE)<0) {
+                        /* +Infinity or -Infinity */
+                        if(sign) { /* -Infinity */
+                            if (H5T_SGN_2==dst.u.i.sign) 
+                                H5T_bit_set (d, dst.prec-1, 1, TRUE);
+                        } else { /* +Infinity */
+                            if (H5T_SGN_NONE==dst.u.i.sign) 
+                                H5T_bit_set (d, dst.offset, dst.prec, TRUE);
+                            else if (H5T_SGN_2==dst.u.i.sign) 
+                                H5T_bit_set (d, dst.offset, dst.prec-1, TRUE);
+                        }        
+                        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 to zero. 
+                     */
+                    goto padding;
+                }
+                
+                /*
+                 * Get the exponent as an unsigned quantity from the section of
+                 * the source bit field where it's located.   Not expecting 
+                 * exponent to be greater than the maximal value of hssize_t.
+                 */
+                expo = H5T_bit_get_d(s, src.u.f.epos, src.u.f.esize);
+                
+                /*
+                 * Calculate the true source exponent by adjusting according to
+                 * 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);
+                    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 mantissa as bit vector from the section of
+                 * the source bit field where it's located.
+                 * Keep the little-endian order in the buffer.  
+                 * A sequence 0x01020304 will be like in the buffer,
+                 *      04      03      02      01
+                 *      |       |       |       |
+                 *      V       V       V       V
+                 *    buf[0]  buf[1]  buf[2]  buf[3]           
+                 */
+                H5T_bit_copy(int_buf, 0, s, src.u.f.mpos, src.u.f.msize);
+                
+                /*
+                 * Restore the implicit bit for mantissa if it's implied.
+                 * Equivalent to mantissa |= (hsize_t)1<<src.u.f.msize.
+                 */
+                if (H5T_NORM_IMPLIED==src.u.f.norm) {
+                    H5T_bit_inc(int_buf, src.u.f.msize, 8*buf_size-src.u.f.msize);
+                    msize = src.u.f.msize + 1;
+                } else 
+                    msize = src.u.f.msize;
+
+                /* Keep the print commands for future debugging */
+                /*fprintf(stderr, "expo=%ld     ", expo);
+                fprintf(stderr, "src.u.f.msize=%d      ", src.u.f.msize);
+                fprintf(stderr, "mant=0x%016x\n", mant);*/
+              
+                /* 
+                 * 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? */
+                }
+
+                /*fprintf(stderr, "int_buf=");
+                for(i=0; i<buf_size; i++)
+                        fprintf(stderr, "%02x ", int_buf[i]);
+                fprintf(stderr, "\n");*/
+
+                /* Convert to integer representation if negative. 
+                 * equivalent to ~(value - 1).
+                 */
+                if(sign) {
+                    H5T_bit_dec(int_buf, 0, 8*buf_size);
+                        /*fprintf(stderr, "decremented int_buf=");
+                        for(i=0; i<buf_size; i++)
+                            fprintf(stderr, "%02x ", int_buf[i]);
+                        fprintf(stderr, "\n");*/
+
+                    H5T_bit_neg(int_buf, 0, 8*buf_size);
+                        /*fprintf(stderr, "negated int_buf=");
+                        for(i=0; i<buf_size; i++)
+                            fprintf(stderr, "%02x ", int_buf[i]);
+                        fprintf(stderr, "\n");*/
+                }
+                
+                /*
+                 * What is the bit position for the most significant bit(MSB) of S
+                 * which is set?
+                 */
+                sfirst = H5T_bit_find(int_buf, 0, 8*buf_size, H5T_BIT_MSB, TRUE);
+                first = (size_t)sfirst;
+                /*fprintf(stderr, "      first=%d\n", first);*/
+                
+                if(sfirst < 0) {
+                    /*
+                     * The source has no bits set and must therefore be zero.
+                     * Set the destination to zero - nothing to do.
+                     */
+                } else if (H5T_SGN_NONE==dst.u.i.sign) {
+                    /*
+                     * Destination is unsigned.  If the source value is greater 
+                     * than the maximal destination value then it overflows, the 
+                     * destination will be set to the maximum possible value.  When the
+                     * source is negative, underflow happens.  Set the destination to be
+                     * zero. 
+                     */
+                    if(!sign) {
+                        if (first>=dst.prec) {
+                            /*overflow*/
+                            if (!H5T_overflow_g || (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
+                                H5T_bit_set (d, dst.offset, dst.prec, TRUE);
+                            }
+                        } else if (first <dst.prec) {
+                            /*copy source value into it*/    
+                            H5T_bit_copy (d, dst.offset, int_buf, 0, first+1);
+                        }
+                    } 
+                } else if (H5T_SGN_2==dst.u.i.sign) {
+                    if(sign) { /*negative*/
+                        /* if overflows, do nothing except turn on the sign bit
+                         * because 0x80...00 is the biggest negative value.
+                         */
+                        if(first < dst.prec-1)
+                            H5T_bit_copy (d, dst.offset, int_buf, 0, first+1);
+
+                        H5T_bit_set (d, (dst.offset + dst.prec-1), 1, TRUE);
+                    } else { /*positive*/
+                        if (first >= dst.prec-1) {
+                            /*overflow*/
+                            if (!H5T_overflow_g || (H5T_overflow_g)(src_id, dst_id, s, d)<0) {
+                                H5T_bit_set (d, dst.offset, dst.prec-1, TRUE);
+                            }
+                        } else if(first < dst.prec-1) {
+                            H5T_bit_copy (d, dst.offset, int_buf, 0, first+1);
+                        }
+                    }
+                }
+
+                /*fprintf(stderr, "dst.offset=%d, d=0x", dst.offset);
+                for(i=0; i<dst.prec/8; i++)
+                   fprintf(stderr, "%02x ", d[i]);
+                fprintf(stderr, "\n");*/
+
+            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);
+            }
+           
+            HDfree(int_buf);
+
+            break;
+                
+        default:
+            HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
+    }
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value);
+}