[svn-r7842] Purpose:

    Bug fix

Description:
    Variable length strings and sequences with NULL pointers were not handled
by library, causing problems access the data.  This also affected fill values
for variable-length datatypes.

Solution:
    Address the issues in the library by detecting NULL sequences/strings
and avoid trying to convert them.

    Patched up dumper to display NULL sequences/strings.

Platforms tested:
    FreeBSD 4.9 (sleipnir)
    h5committest

1 files changed, 80 insertions, 72 deletions

diff --git a/src/H5Tconv.c b/src/H5Tconv.c
index 897f20b..4950371 100644
--- a/src/H5Tconv.c
+++ b/src/H5Tconv.c
@@ -2384,86 +2384,94 @@ H5T_conv_vlen(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
                 s = sp;
                 d = *dptr;
 
-                /* Get length of element sequences */
-                if((seq_len=(*(src->u.vlen.getlen))(src->u.vlen.f,s))<0)
-                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "incorrect length");
-                H5_CHECK_OVERFLOW(seq_len,hssize_t,size_t);
-                src_size=(size_t)seq_len*src_base_size;
-                dst_size=(size_t)seq_len*dst_base_size;
-
-                /* Check if conversion buffer is large enough, resize if
-                 * necessary */      
-                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)
-                        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,dxpl_id,s,conv_buf,src_size)<0)
-                    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) */
-                if((tpath->cdata.need_bkg || H5T_detect_class(dst->parent, H5T_VLEN))
-                        && tmp_buf_size<conv_buf_size) {
-                    /* 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)
-                        HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for type conversion");
+                /* Check for "nil" source sequence */
+                if((*(src->u.vlen.isnull))(src->u.vlen.f,s)) {
+                    /* Write "nil" sequence to destination location */
+                    if((*(dst->u.vlen.setnull))(dst->u.vlen.f,dxpl_id,d,bg_ptr)<0)
+                        HGOTO_ERROR(H5E_DATATYPE, H5E_WRITEERROR, FAIL, "can't set VL data to 'nil'");
                 } /* end if */
+                else {
+                    /* Get length of element sequences */
+                    if((seq_len=(*(src->u.vlen.getlen))(s))<0)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "incorrect length");
+                    H5_CHECK_OVERFLOW(seq_len,hssize_t,size_t);
+                    src_size=(size_t)seq_len*src_base_size;
+                    dst_size=(size_t)seq_len*dst_base_size;
+
+                    /* Check if conversion buffer is large enough, resize if
+                     * necessary */      
+                    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)
+                            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 
-		 * the sequence into the background buffer */
-		if(nested) {
-                    uint8_t *tmp=bg_ptr;
-		    UINT32DECODE(tmp, bg_seq_len);
-		    if(bg_seq_len>0) {
-                        H5_CHECK_OVERFLOW( bg_seq_len*MAX(src_base_size,dst_base_size) ,hsize_t,size_t);
-			if(tmp_buf_size<(size_t)(bg_seq_len*MAX(src_base_size, dst_base_size))) {
-			    tmp_buf_size=(size_t)(bg_seq_len*MAX(src_base_size, dst_base_size));
-                    	    if((tmp_buf=H5FL_BLK_REALLOC(vlen_seq,tmp_buf, 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,dxpl_id,&bg_hobjid,tmp_buf)==NULL)
-			    HGOTO_ERROR (H5E_DATATYPE, H5E_READERROR, FAIL, "can't read VL sequence into background buffer");
-		    } /* end if */
+                    /* Read in VL sequence */
+                    if((*(src->u.vlen.read))(src->u.vlen.f,dxpl_id,s,conv_buf,src_size)<0)
+                        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) */
+                    if((tpath->cdata.need_bkg || H5T_detect_class(dst->parent, H5T_VLEN))
+                            && tmp_buf_size<conv_buf_size) {
+                        /* 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)
+                            HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for type conversion");
+                    } /* end if */
 
-                    /* If the sequence gets shorter, pad out the original sequence with zeros */
-                    H5_CHECK_OVERFLOW(bg_seq_len,hsize_t,hssize_t);
-                    if((hssize_t)bg_seq_len<seq_len) {
-                        H5_CHECK_OVERFLOW((seq_len-bg_seq_len),hsize_t,size_t);
-                        HDmemset((uint8_t *)tmp_buf+dst_base_size*bg_seq_len,0,(size_t)(seq_len-bg_seq_len)*dst_base_size);
+                    /* If we are writing and there is a nested VL type, read 
+                     * the sequence into the background buffer */
+                    if(nested) {
+                        uint8_t *tmp=bg_ptr;
+                        UINT32DECODE(tmp, bg_seq_len);
+                        if(bg_seq_len>0) {
+                            H5_CHECK_OVERFLOW( bg_seq_len*MAX(src_base_size,dst_base_size) ,hsize_t,size_t);
+                            if(tmp_buf_size<(size_t)(bg_seq_len*MAX(src_base_size, dst_base_size))) {
+                                tmp_buf_size=(size_t)(bg_seq_len*MAX(src_base_size, dst_base_size));
+                                if((tmp_buf=H5FL_BLK_REALLOC(vlen_seq,tmp_buf, 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,dxpl_id,&bg_hobjid,tmp_buf)==NULL)
+                                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 */
+                        H5_CHECK_OVERFLOW(bg_seq_len,hsize_t,hssize_t);
+                        if((hssize_t)bg_seq_len<seq_len) {
+                            H5_CHECK_OVERFLOW((seq_len-bg_seq_len),hsize_t,size_t);
+                            HDmemset((uint8_t *)tmp_buf+dst_base_size*bg_seq_len,0,(size_t)(seq_len-bg_seq_len)*dst_base_size);
+                        } /* end if */
                     } /* end if */
-		} /* end if */
 
-                /* 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, dxpl_id)<0)
-                    HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "datatype conversion failed");
+                    /* 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, dxpl_id)<0)
+                        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "datatype conversion failed");
+
+                    /* Write sequence to destination location */
+                    if((*(dst->u.vlen.write))(dst->u.vlen.f,dxpl_id,d,conv_buf, bg_ptr, (hsize_t)seq_len,(hsize_t)dst_base_size)<0)
+                        HGOTO_ERROR(H5E_DATATYPE, H5E_WRITEERROR, FAIL, "can't write VL data");
 
-                /* Write sequence to destination location */
-                if((*(dst->u.vlen.write))(dst->u.vlen.f,dxpl_id,d,conv_buf, bg_ptr, (hsize_t)seq_len,(hsize_t)dst_base_size)<0)
-                    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);
-                if(nested && seq_len<(hssize_t)bg_seq_len) {
-                    uint8_t *tmp_p=tmp_buf;
-		    tmp_p += seq_len*dst_base_size;
-                    for(i=0; i<(bg_seq_len-seq_len); i++) {
-                        UINT32DECODE(tmp_p, parent_seq_len);
-                        if(parent_seq_len>0) {
-                            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, dxpl_id,&parent_hobjid)<0)
-                                HGOTO_ERROR(H5E_DATATYPE, H5E_WRITEERROR, FAIL, "Unable to remove heap object");
+                    /* 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);
+                    if(nested && seq_len<(hssize_t)bg_seq_len) {
+                        uint8_t *tmp_p=tmp_buf;
+                        tmp_p += seq_len*dst_base_size;
+                        for(i=0; i<(bg_seq_len-seq_len); i++) {
+                            UINT32DECODE(tmp_p, parent_seq_len);
+                            if(parent_seq_len>0) {
+                                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, dxpl_id,&parent_hobjid)<0)
+                                    HGOTO_ERROR(H5E_DATATYPE, H5E_WRITEERROR, FAIL, "Unable to remove heap object");
+                            }
                         }
                     }
-                }
-                
+                } /* end else */
+                    
                 /*
                  * If we had used a temporary buffer for the destination
                  * then we should copy the value to the true destination