[svn-r11830] Purpose: A new function and its test.

Description: This is the second step of conversion between data type and
text, H5LTdtype_to_text().

Solution: Similar to h5dump, this function print the DDL description of
a data type into a string.

Platforms tested: h5committest and fuss.

3 files changed, 764 insertions, 14 deletions

diff --git a/hl/src/H5LT.c b/hl/src/H5LT.c
index 3ff8ade..a6582af 100644
--- a/hl/src/H5LT.c
+++ b/hl/src/H5LT.c
@@ -15,10 +15,18 @@
 #include "H5LT.h"
 #include <string.h>
 #include <stdlib.h>
+#include <assert.h>
 
 /* For Lex and Yacc */
+#define         SUCCEED         0
+#define         FAIL            -1
+#define         COL             3
+#define         LIMIT           512
+#define         INCREMENT       1024
+#define         MAX(a,b)        (((a)>(b)) ? (a) : (b))
 int  input_len;
 char *myinput;
+int  indent = 0;
 
 /*-------------------------------------------------------------------------
  *
@@ -2020,6 +2028,639 @@ out:
 }
 
 /*-------------------------------------------------------------------------
+ * Function:    indentation
+ *
+ * Purpose:     Print spaces for indentation
+ *
+ * Return:      void
+ *
+ * Programmer:  Raymond Lu, slu@ncsa.uiuc.edu
+ *
+ * Date:        December 6, 2005
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+indentation(int x, char* str)
+{
+    if (x < 80) {
+        while (x-- > 0)
+            strcat(str, " ");
+    } else {
+        strcat(str, "error: the indentation exceeds the number of cols.");
+        exit(1);
+    }
+}
+
+/*-------------------------------------------------------------------------
+ * Function:    print_enum
+ *
+ * Purpose:     prints the enum data
+ *
+ * Return:      Success: 0, Failure: -1
+ *
+ * Programmer:  Raymond Lu
+ *
+ * Modifications:
+ *
+ *-----------------------------------------------------------------------*/
+static herr_t
+print_enum(hid_t type, char* str, int indent)
+{
+    char           **name = NULL;   /*member names                   */
+    unsigned char   *value = NULL;  /*value array                    */
+    unsigned char   *copy = NULL;   /*a pointer to value array       */
+    int              nmembs;        /*number of members              */
+    char             tmp_str[256];
+    int              nchars;        /*number of output characters    */
+    hid_t            super;         /*enum base integer type         */
+    hid_t            native = -1;   /*native integer data type       */
+    size_t           super_size;    /*enum base type size            */
+    size_t           dst_size;      /*destination value type size    */
+    int              i;
+    herr_t           ret = SUCCEED;
+    
+    if((nmembs = H5Tget_nmembers(type))==0)
+        goto out;
+    assert(nmembs>0);
+    if((super = H5Tget_super(type))<0)
+        goto out;
+   
+    /* Use buffer of INT or UNSIGNED INT to print enum values because
+     * we don't expect these values to be so big that INT or UNSIGNED
+     * INT can't hold.
+     */ 
+    if (H5T_SGN_NONE == H5Tget_sign(super)) {
+        native = H5T_NATIVE_UINT;
+    } else {
+        native = H5T_NATIVE_INT;
+    }
+
+    super_size = H5Tget_size(super);
+    dst_size = H5Tget_size(native);
+    
+    /* Get the names and raw values of all members */
+    name = calloc(nmembs, sizeof(char *));
+    value = calloc(nmembs, MAX(dst_size, super_size));
+
+    for (i = 0; i < nmembs; i++) {
+	if((name[i] = H5Tget_member_name(type, i))==NULL)
+            goto out;
+	if(H5Tget_member_value(type, i, value + i * super_size)<0)
+            goto out;
+    }
+
+    /* Convert values to native data type */
+    if (native > 0) {
+        if(H5Tconvert(super, native, nmembs, value, NULL, H5P_DEFAULT)<0)
+            goto out;
+    }
+    
+    /*
+     * Sort members by increasing value
+     *    ***not implemented yet***
+     */
+
+    /* Print members */
+    for (i = 0; i < nmembs; i++) {
+	indentation(indent + COL, str);
+	nchars = sprintf(tmp_str, "\"%s\"", name[i]);
+        strcat(str, tmp_str);
+	sprintf(tmp_str, "%*s   ", MAX(0, 16 - nchars), "");
+        strcat(str, tmp_str);
+        
+	if (H5T_SGN_NONE == H5Tget_sign(native)) {
+	    /*On SGI Altix(cobalt), wrong values were printed out with "value+i*dst_size"
+	     *strangely, unless use another pointer "copy".*/
+	    copy = value+i*dst_size;
+	    sprintf(tmp_str,"%u", *((unsigned int*)((void *)copy)));
+            strcat(str, tmp_str);
+	} else {
+	    /*On SGI Altix(cobalt), wrong values were printed out with "value+i*dst_size"
+	     *strangely, unless use another pointer "copy".*/
+	    copy = value+i*dst_size;
+	    sprintf(tmp_str,"%d", *((int*)((void *)copy)));
+            strcat(str, tmp_str);
+	}
+
+	strcat(str, ";\n");
+    }
+
+    /* Release resources */
+    for (i = 0; i < nmembs; i++)
+	free(name[i]);
+
+    free(name);
+    free(value);
+    H5Tclose(super);
+
+    if (0 == nmembs) {
+	sprintf(tmp_str, "\n%*s <empty>", indent + 4, "");
+        strcat(str, tmp_str);
+    }
+
+    return ret;
+
+out:
+    return FAIL;
+}
+
+/*-------------------------------------------------------------------------
+ * Function:    H5LTdtype_to_text
+ *
+ * Purpose:     Convert HDF5 data type to DDL description.
+ *
+ * Return:      Success: 0, Failure: -1
+ *
+ * Programmer:  Raymond Lu, slu@ncsa.uiuc.edu
+ *
+ * Date:        December 6, 2005
+ *
+ * Comments:
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t H5LTdtype_to_text(hid_t dtype, char *str, size_t *len)
+{
+    size_t      str_len = INCREMENT;
+    char        *text_str;
+    herr_t      ret;
+    
+    if(len && !str) {
+        text_str = (char*)calloc(str_len, sizeof(char));
+        text_str[0]='\0';
+        if((ret = H5LT_dtype_to_text(dtype, &text_str, &str_len, 1))<0)
+            goto out;
+        *len = strlen(text_str) + 1;
+    } else if(len && str) {
+        if((ret = H5LT_dtype_to_text(dtype, &str, len, 0))<0)
+            goto out;
+        str[*len-1] = '\0';
+    }
+
+    return ret;
+
+out:
+    return FAIL;
+}
+
+/*-------------------------------------------------------------------------
+ * Function:    H5LT_dtype_to_text
+ *
+ * Purpose:     Private function to convert HDF5 data type to DDL description.
+ *
+ * Return:      Success: 0, Failure: -1
+ *
+ * Programmer:  Raymond Lu, slu@ncsa.uiuc.edu
+ *
+ * Date:        December 20, 2005
+ *
+ * Comments:
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t H5LT_dtype_to_text(hid_t dtype, char **dt_str, size_t *slen, hbool_t no_user_buf)
+{
+    H5T_class_t class;
+    char        tmp_str[256];
+    char        *tmp;
+    unsigned    i;
+    herr_t      ret = SUCCEED;
+
+    if(no_user_buf && ((*slen - strlen(*dt_str)) < LIMIT)) {
+        *slen += INCREMENT;
+        tmp = realloc(*dt_str, *slen);
+        if(tmp != *dt_str) {
+           free(*dt_str);
+           *dt_str = tmp;
+        }
+    }
+    
+    if((class = H5Tget_class(dtype))<0)
+        goto out;
+    
+    switch (class) {
+        case H5T_INTEGER:
+            if (H5Tequal(dtype, H5T_STD_I8BE)) {
+                sprintf(*dt_str, "H5T_STD_I8BE");
+            } else if (H5Tequal(dtype, H5T_STD_I8LE)) {
+                sprintf(*dt_str, "H5T_STD_I8LE");
+            } else if (H5Tequal(dtype, H5T_STD_I16BE)) {
+                sprintf(*dt_str, "H5T_STD_I16BE");
+            } else if (H5Tequal(dtype, H5T_STD_I16LE)) {
+                sprintf(*dt_str, "H5T_STD_I16LE");
+            } else if (H5Tequal(dtype, H5T_STD_I32BE)) {
+                sprintf(*dt_str, "H5T_STD_I32BE");
+            } else if (H5Tequal(dtype, H5T_STD_I32LE)) {
+                sprintf(*dt_str, "H5T_STD_I32LE");
+            } else if (H5Tequal(dtype, H5T_STD_I64BE)) {
+                sprintf(*dt_str, "H5T_STD_I64BE");
+            } else if (H5Tequal(dtype, H5T_STD_I64LE)) {
+                sprintf(*dt_str, "H5T_STD_I64LE");
+            } else if (H5Tequal(dtype, H5T_STD_U8BE)) {
+                sprintf(*dt_str, "H5T_STD_U8BE");
+            } else if (H5Tequal(dtype, H5T_STD_U8LE)) {
+                sprintf(*dt_str, "H5T_STD_U8LE");
+            } else if (H5Tequal(dtype, H5T_STD_U16BE)) {
+                sprintf(*dt_str, "H5T_STD_U16BE");
+            } else if (H5Tequal(dtype, H5T_STD_U16LE)) {
+                sprintf(*dt_str, "H5T_STD_U16LE");
+            } else if (H5Tequal(dtype, H5T_STD_U32BE)) {
+                sprintf(*dt_str, "H5T_STD_U32BE");
+            } else if (H5Tequal(dtype, H5T_STD_U32LE)) {
+                sprintf(*dt_str, "H5T_STD_U32LE");
+            } else if (H5Tequal(dtype, H5T_STD_U64BE)) {
+                sprintf(*dt_str, "H5T_STD_U64BE");
+            } else if (H5Tequal(dtype, H5T_STD_U64LE)) {
+                sprintf(*dt_str, "H5T_STD_U64LE");
+            } else if (H5Tequal(dtype, H5T_NATIVE_SCHAR)) {
+                sprintf(*dt_str, "H5T_NATIVE_SCHAR");
+            } else if (H5Tequal(dtype, H5T_NATIVE_UCHAR)) {
+                sprintf(*dt_str, "H5T_NATIVE_UCHAR");
+            } else if (H5Tequal(dtype, H5T_NATIVE_SHORT)) {
+                sprintf(*dt_str, "H5T_NATIVE_SHORT");
+            } else if (H5Tequal(dtype, H5T_NATIVE_USHORT)) {
+                sprintf(*dt_str, "H5T_NATIVE_USHORT");
+            } else if (H5Tequal(dtype, H5T_NATIVE_INT)) {
+                sprintf(*dt_str, "H5T_NATIVE_INT");
+            } else if (H5Tequal(dtype, H5T_NATIVE_UINT)) {
+                sprintf(*dt_str, "H5T_NATIVE_UINT");
+            } else if (H5Tequal(dtype, H5T_NATIVE_LONG)) {
+                sprintf(*dt_str, "H5T_NATIVE_LONG");
+            } else if (H5Tequal(dtype, H5T_NATIVE_ULONG)) {
+                sprintf(*dt_str, "H5T_NATIVE_ULONG");
+            } else if (H5Tequal(dtype, H5T_NATIVE_LLONG)) {
+                sprintf(*dt_str, "H5T_NATIVE_LLONG");
+            } else if (H5Tequal(dtype, H5T_NATIVE_ULLONG)) {
+                sprintf(*dt_str, "H5T_NATIVE_ULLONG");
+            } else {
+                sprintf(*dt_str, "undefined integer");
+            }
+
+            break;
+        case H5T_FLOAT:
+            if (H5Tequal(dtype, H5T_IEEE_F32BE)) {
+                sprintf(*dt_str, "H5T_IEEE_F32BE");
+            } else if (H5Tequal(dtype, H5T_IEEE_F32LE)) {
+                sprintf(*dt_str, "H5T_IEEE_F32LE");
+            } else if (H5Tequal(dtype, H5T_IEEE_F64BE)) {
+                sprintf(*dt_str, "H5T_IEEE_F64BE");
+            } else if (H5Tequal(dtype, H5T_IEEE_F64LE)) {
+                sprintf(*dt_str, "H5T_IEEE_F64LE");
+            } else if (H5Tequal(dtype, H5T_NATIVE_FLOAT)) {
+                sprintf(*dt_str, "H5T_NATIVE_FLOAT");
+            } else if (H5Tequal(dtype, H5T_NATIVE_DOUBLE)) {
+                sprintf(*dt_str, "H5T_NATIVE_DOUBLE");
+#if H5_SIZEOF_LONG_DOUBLE !=0
+            } else if (H5Tequal(dtype, H5T_NATIVE_LDOUBLE)) {
+                sprintf(*dt_str, "H5T_NATIVE_LDOUBLE");
+#endif
+            } else {
+                sprintf(*dt_str, "undefined float");
+            }
+
+            break;
+        case H5T_STRING:
+            {
+            /* Make a copy of type in memory in case when DTYPE is on disk, the size
+             * will be bigger than in memory.  This makes it easier to compare
+             * types in memory. */
+            hid_t str_type;
+            H5T_order_t order;
+            hid_t tmp_type;
+            size_t size;
+            H5T_str_t str_pad;
+            H5T_cset_t cset;
+            htri_t is_vlstr;
+
+            if((tmp_type = H5Tcopy(dtype))<0)
+                goto out;
+            if((size = H5Tget_size(tmp_type))==0)
+                goto out;
+            if((str_pad = H5Tget_strpad(tmp_type))<0)
+                goto out;
+            if((cset = H5Tget_cset(tmp_type))<0)
+                goto out;
+            if((is_vlstr = H5Tis_variable_str(tmp_type))<0)
+                goto out;
+
+            /* Print lead-in */
+            sprintf(*dt_str, "H5T_STRING {\n");
+            indent += COL;
+
+            /* Reproduce a C type string */
+            if((str_type = H5Tcopy(H5T_C_S1))<0)
+                goto out;
+            if(is_vlstr) {
+                if(H5Tset_size(str_type, H5T_VARIABLE)<0)
+                    goto out;
+            } else {
+                if(H5Tset_size(str_type, size)<0)
+                    goto out;
+            }
+            if(H5Tset_cset(str_type, cset)<0)
+                goto out;
+            if(H5Tset_strpad(str_type, str_pad)<0)
+                goto out;
+
+            indentation(indent + COL, *dt_str);
+
+            /* Check C variable-length string first. Are the two types equal? */
+            if (H5Tequal(tmp_type, str_type)) {
+                strcat(*dt_str, "CTYPE H5T_C_S1;\n");
+                goto next;
+            } 
+
+            /* Change the endianness and see if they're equal. */
+            if((order = H5Tget_order(tmp_type))<0)
+                goto out;
+            if(order==H5T_ORDER_LE) {
+                if(H5Tset_order(str_type, H5T_ORDER_LE)<0)
+                    goto out;
+            } else if(order==H5T_ORDER_BE) {
+                if(H5Tset_order(str_type, H5T_ORDER_BE)<0)
+                    goto out;
+            }
+            
+            if (H5Tequal(tmp_type, str_type)) {
+                strcat(*dt_str, "H5T_C_S1;\n");
+                goto next;
+            }
+
+            /* If not equal to C variable-length string, check Fortran type.
+             * Actually H5Tequal can't tell difference between H5T_C_S1 and H5T_FORTRAN_S1!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
+            if(H5Tclose(str_type)<0)
+                goto out;
+            if((str_type = H5Tcopy(H5T_FORTRAN_S1))<0)
+                goto out;
+            if(H5Tset_cset(str_type, cset)<0)
+                goto out;
+            if(H5Tset_size(str_type, size)<0)
+                goto out;
+            if(H5Tset_strpad(str_type, str_pad)<0)
+                goto out;
+            
+            /* Are the two types equal? */
+            if (H5Tequal(tmp_type, str_type)) {
+                strcat(*dt_str, "CTYPE H5T_FORTRAN_S1;\n");
+                goto next;
+            }
+
+            /* Change the endianness and see if they're equal. */
+            if((order = H5Tget_order(tmp_type))<0)
+                goto out;
+            if(order==H5T_ORDER_LE) {
+                if(H5Tset_order(str_type, H5T_ORDER_LE)<0)
+                    goto out;
+            } else if(order==H5T_ORDER_BE) {
+                if(H5Tset_order(str_type, H5T_ORDER_BE)<0)
+                    goto out;
+            }
+
+            /* Are the two types equal? */
+            if (H5Tequal(tmp_type, str_type)) {
+                strcat(*dt_str, "CTYPE H5T_FORTRAN_S1;\n");
+                goto next;
+            }
+
+            /* Type doesn't match any of above. */
+            strcat(*dt_str, "CTYPE unknown_one_character_type;\n ");
+
+next:
+            indentation(indent + COL, *dt_str);
+
+            if(is_vlstr)
+                strcat(*dt_str, "STRSIZE H5T_VARIABLE;\n");
+            else {
+                sprintf(tmp_str, "STRSIZE %d;\n", (int)size);
+                strcat(*dt_str, tmp_str);
+            }
+
+            indentation(indent + COL, *dt_str);
+
+            if (str_pad == H5T_STR_NULLTERM)
+                strcat(*dt_str, "STRPAD H5T_STR_NULLTERM;\n");
+            else if (str_pad == H5T_STR_NULLPAD)
+                strcat(*dt_str, "STRPAD H5T_STR_NULLPAD;\n");
+            else if (str_pad == H5T_STR_SPACEPAD)
+                strcat(*dt_str, "STRPAD H5T_STR_SPACEPAD;\n");
+            else
+                strcat(*dt_str, "STRPAD H5T_STR_ERROR;\n");
+
+            indentation(indent + COL, *dt_str);
+
+            if (cset == H5T_CSET_ASCII)
+                strcat(*dt_str, "CSET H5T_CSET_ASCII;\n");
+            else
+                strcat(*dt_str, "CSET unknown_cset;\n");
+
+            H5Tclose(str_type);
+            H5Tclose(tmp_type);
+
+            /* Print closing */
+            indent -= COL;
+            indentation(indent + COL, *dt_str);
+            strcat(*dt_str, "}");
+
+            break;
+            }
+        case H5T_OPAQUE:
+            /* Print lead-in */
+            sprintf(*dt_str, "H5T_OPAQUE {\n");
+            indent += COL;
+            
+            indentation(indent + COL, *dt_str);
+            sprintf(tmp_str, "OPQ_SIZE %d;\n", H5Tget_size(dtype));
+            strcat(*dt_str, tmp_str);
+             
+            indentation(indent + COL, *dt_str);
+            sprintf(tmp_str, "OPQ_TAG \"%s\";\n", H5Tget_tag(dtype));
+            strcat(*dt_str, tmp_str);
+
+            /* Print closing */
+            indent -= COL;
+            indentation(indent + COL, *dt_str);
+            strcat(*dt_str, "}");
+
+            break;
+        case H5T_ENUM:
+            {
+            hid_t super;
+            size_t super_len;
+            char* stmp;
+
+            /* Print lead-in */
+            sprintf(*dt_str, "H5T_ENUM {\n");
+            indent += COL;
+            indentation(indent + COL, *dt_str);
+            
+            if((super = H5Tget_super(dtype))<0)
+                goto out;
+            if(H5LTdtype_to_text(super, NULL, &super_len)<0)
+                goto out;
+            stmp = calloc(super_len, sizeof(char));
+            if(H5LTdtype_to_text(super, stmp, &super_len)<0)
+                goto out;            
+            strcat(*dt_str, stmp);
+            free(stmp);
+            strcat(*dt_str, ";\n");
+            H5Tclose(super);
+
+            if(print_enum(dtype, *dt_str, indent)<0)
+                goto out;
+
+            /* Print closing */
+            indent -= COL;
+            indentation(indent + COL, *dt_str);
+            strcat(*dt_str, "}");
+
+            break;
+            }
+        case H5T_VLEN:
+            {
+            hid_t super;
+            size_t super_len;
+            char* stmp;
+
+            /* Print lead-in */
+            sprintf(*dt_str, "H5T_VLEN {\n");
+            indent += COL;
+            indentation(indent + COL, *dt_str);
+
+            if((super = H5Tget_super(dtype))<0)
+                goto out;
+            if(H5LTdtype_to_text(super, NULL, &super_len)<0)
+                goto out;
+            stmp = calloc(super_len, sizeof(char));
+            if(H5LTdtype_to_text(super, stmp, &super_len)<0)
+                goto out;            
+            strcat(*dt_str, stmp);
+            free(stmp);
+            strcat(*dt_str, "\n");
+            H5Tclose(super);
+
+            /* Print closing */
+            indent -= COL;
+            indentation(indent + COL, *dt_str);
+            strcat(*dt_str, "}");
+
+            break;
+            }
+        case H5T_ARRAY:
+            {
+            hid_t       super;
+            size_t      super_len;
+            char*       stmp;
+            hsize_t     dims[H5S_MAX_RANK];
+            int         ndims;
+
+            /* Print lead-in */
+            sprintf(*dt_str, "H5T_ARRAY {\n");
+            indent += COL;
+            indentation(indent + COL, *dt_str);
+
+            /* Get array information */
+            if((ndims = H5Tget_array_ndims(dtype))<0)
+                goto out;
+            if(H5Tget_array_dims(dtype, dims, NULL)<0)
+                goto out;
+
+            /* Print array dimensions */
+            for (i = 0; i < ndims; i++) {
+                sprintf(tmp_str, "[%d]", (int) dims[i]);
+                strcat(*dt_str, tmp_str);
+            }
+            strcat(*dt_str, " ");
+
+            if((super = H5Tget_super(dtype))<0)
+                goto out;
+            if(H5LTdtype_to_text(super, NULL, &super_len)<0)
+                goto out;
+            stmp = calloc(super_len, sizeof(char));
+            if(H5LTdtype_to_text(super, stmp, &super_len)<0)
+                goto out;            
+            strcat(*dt_str, stmp);
+            free(stmp);
+            strcat(*dt_str, "\n");
+            H5Tclose(super);
+
+            /* Print closing */
+            indent -= COL;
+            indentation(indent + COL, *dt_str);
+            strcat(*dt_str, "}");
+
+            break;
+            }
+        case H5T_COMPOUND:
+            {
+            char       *mname;
+            hid_t       mtype;
+            H5T_class_t mclass;
+            size_t      mlen;
+            char*       mtmp;
+            unsigned    nmembs = H5Tget_nmembers(dtype);
+
+            sprintf(*dt_str, "H5T_COMPOUND {\n");
+            indent += COL;
+
+            for (i = 0; i < nmembs; i++) {
+                if((mname = H5Tget_member_name(dtype, i))==NULL)
+                    goto out;
+                if((mtype = H5Tget_member_type(dtype, i))<0)
+                    goto out;
+                indentation(indent + COL, *dt_str);
+
+                if((mclass = H5Tget_class(mtype))<0)
+                    goto out;
+                if (H5T_COMPOUND == mclass)
+                    indent += COL;
+
+                if(H5LTdtype_to_text(mtype, NULL, &mlen)<0)
+                    goto out;
+                mtmp = calloc(mlen, sizeof(char));
+                if(H5LTdtype_to_text(mtype, mtmp, &mlen)<0)
+                    goto out;            
+                strcat(*dt_str, mtmp);
+                free(mtmp);
+
+                if (H5T_COMPOUND == mclass)
+                    indent -= COL;
+
+                sprintf(tmp_str, " \"%s\";\n", mname);
+                strcat(*dt_str, tmp_str);
+                free(mname);
+            }
+
+            /* Print closing */
+            indent -= COL;
+            indentation(indent + COL, *dt_str);
+            strcat(*dt_str, "}");
+
+            break;
+            }
+        case H5T_TIME:
+            sprintf(*dt_str, "H5T_TIME: not yet implemented");
+            break;
+        case H5T_BITFIELD:
+            sprintf(*dt_str, "H5T_BITFIELD: not yet implemented");
+            break;
+        default:
+            sprintf(*dt_str, "unknown data type");
+    }
+
+    return ret;
+
+out:
+    return FAIL;
+}
+
+/*-------------------------------------------------------------------------
  * Function: H5LTrepack
  *
  * Purpose: Packs/Unpacks data from buffers. This function transfers data from a packed
diff --git a/hl/src/H5LT.h b/hl/src/H5LT.h
index a4fd2a3..3914f67 100644
--- a/hl/src/H5LT.h
+++ b/hl/src/H5LT.h
@@ -345,6 +345,7 @@ H5_HLDLL hid_t H5LTcreate_compound_type( hsize_t nfields, size_t size, const cha
                                 const size_t *field_offset, const hid_t *field_types );
 
 H5_HLDLL hid_t H5LTtext_to_dtype(const char *text);
+H5_HLDLL herr_t H5LTdtype_to_text(hid_t dtype, char *str, size_t *len);
 
 H5_HLDLL herr_t  H5LTrepack( hsize_t nfields,
                    hsize_t nrecords,
@@ -365,8 +366,6 @@ H5_HLDLL herr_t  H5LTrepack( hsize_t nfields,
  *
  *-------------------------------------------------------------------------
  */
-
-
 H5_HLDLL herr_t  H5LT_get_attribute_mem( hid_t obj_id,
                            const char *attr_name,
                            hid_t mem_type_id,
@@ -378,7 +377,6 @@ H5_HLDLL herr_t  H5LT_get_attribute_disk( hid_t obj_id,
 
 H5_HLDLL herr_t  H5LT_find_attribute( hid_t loc_id, const char *name );
 
-
 H5_HLDLL herr_t  H5LT_set_attribute_numerical( hid_t loc_id,
                                      const char *obj_name,
                                      const char *attr_name,
@@ -390,8 +388,7 @@ H5_HLDLL herr_t  H5LT_set_attribute_string( hid_t dset_id,
                                  char *name,
                                  char *buf );
 
-
-
+H5_HLDLL herr_t  H5LT_dtype_to_text(hid_t dtype, char **dt_str, size_t *slen, hbool_t no_user_buf);
 
 #ifdef __cplusplus
 }
diff --git a/hl/test/test_lite.c b/hl/test/test_lite.c
index 7d91267..f4e9aab 100644
--- a/hl/test/test_lite.c
+++ b/hl/test/test_lite.c
@@ -1049,6 +1049,8 @@ static herr_t make_attributes( hid_t loc_id, const char* obj_name )
 static int test_integers(void)
 {
     hid_t   dtype;
+    char*   dt_str;
+    size_t  str_len;
 
     TESTING3("\n        text for integer types");
     
@@ -1063,6 +1065,16 @@ static int test_integers(void)
         goto out;
     if(!H5Tequal(dtype, H5T_STD_I8BE))
         goto out;
+    
+    if(H5LTdtype_to_text(dtype, NULL, &str_len)<0)
+        goto out; 
+    dt_str = (char*)calloc(str_len, sizeof(char));
+    if(H5LTdtype_to_text(dtype, dt_str, &str_len)<0)
+        goto out; 
+    if(strcmp(dt_str, "H5T_STD_I8BE"))
+        goto out;
+    free(dt_str);
+
     if(H5Tclose(dtype)<0)
         goto out;
     
@@ -1088,6 +1100,8 @@ out:
 static int test_fps(void)
 {
     hid_t   dtype;
+    char*   dt_str;
+    size_t  str_len;
 
     TESTING3("        text for floating-point types");
     
@@ -1102,6 +1116,16 @@ static int test_fps(void)
         goto out;
     if(!H5Tequal(dtype, H5T_IEEE_F32BE))
         goto out;
+    
+    if(H5LTdtype_to_text(dtype, NULL, &str_len)<0)
+        goto out; 
+    dt_str = (char*)calloc(str_len, sizeof(char));
+    if(H5LTdtype_to_text(dtype, dt_str, &str_len)<0)
+        goto out; 
+    if(strcmp(dt_str, "H5T_IEEE_F32BE"))
+        goto out;
+    free(dt_str);
+
     if(H5Tclose(dtype)<0)
         goto out;
     
@@ -1131,6 +1155,8 @@ static int test_strings(void)
     H5T_str_t   str_pad;
     H5T_cset_t  str_cset;
     H5T_class_t type_class;
+    char*   dt_str;
+    size_t  str_len;
     
     TESTING3("        text for string types");
     
@@ -1154,15 +1180,26 @@ static int test_strings(void)
     if(str_cset != H5T_CSET_ASCII)
         goto out;
     
+    if(H5LTdtype_to_text(dtype, NULL, &str_len)<0)
+        goto out; 
+    dt_str = (char*)calloc(str_len, sizeof(char));
+    if(H5LTdtype_to_text(dtype, dt_str, &str_len)<0)
+        goto out; 
+    if(strcmp(dt_str, "H5T_STRING {\n      CTYPE H5T_C_S1;\n      STRSIZE 13;\n      STRPAD H5T_STR_NULLTERM;\n      CSET H5T_CSET_ASCII;\n   }")) {
+        printf("dt=\n%s\n", dt_str);
+        goto out;
+    }
+    free(dt_str);
+  
     if(H5Tclose(dtype)<0)
         goto out;
     
-    if((dtype = H5LTtext_to_dtype("H5T_STRING { CTYPE H5T_FORTRAN_S1; STRSIZE H5T_VARIABLE; STRPAD H5T_STR_NULLPAD; CSET H5T_CSET_ASCII; }"))<0)
+    if((dtype = H5LTtext_to_dtype("H5T_STRING { CTYPE H5T_C_S1; STRSIZE H5T_VARIABLE; STRPAD H5T_STR_NULLPAD; CSET H5T_CSET_ASCII; }"))<0)
         goto out;
     
     if(!H5Tis_variable_str(dtype))
         goto out;
-        
+      
     str_pad = H5Tget_strpad(dtype);
     if(str_pad != H5T_STR_NULLPAD)
         goto out;
@@ -1170,7 +1207,18 @@ static int test_strings(void)
     str_cset = H5Tget_cset(dtype);
     if(str_cset != H5T_CSET_ASCII)
         goto out;
-    
+
+    if(H5LTdtype_to_text(dtype, NULL, &str_len)<0)
+        goto out; 
+    dt_str = (char*)calloc(str_len, sizeof(char));
+    if(H5LTdtype_to_text(dtype, dt_str, &str_len)<0)
+        goto out; 
+    if(strcmp(dt_str, "H5T_STRING {\n      CTYPE H5T_C_S1;\n      STRSIZE H5T_VARIABLE;\n      STRPAD H5T_STR_NULLPAD;\n      CSET H5T_CSET_ASCII;\n   }")) {
+        printf("dt=\n%s\n", dt_str);
+        goto out;
+    }
+    free(dt_str);
+  
     if(H5Tclose(dtype)<0)
         goto out;
  
@@ -1192,10 +1240,12 @@ static int test_opaques(void)
     size_t  opq_size;
     char    *opq_tag = NULL;
     H5T_class_t type_class;
+    char*   dt_str;
+    size_t  str_len;
 
     TESTING3("        text for opaque types");
     
-    if((dtype = H5LTtext_to_dtype("H5T_OPAQUE { OPQ_SIZE 19; OPQ_TAG \"This is a tag for opaque type\"; }\n"))<0)
+    if((dtype = H5LTtext_to_dtype("H5T_OPAQUE { OPQ_SIZE 19; OPQ_TAG \"This is a tag for opaque type\"; }"))<0)
         goto out;
       
     if((type_class = H5Tget_class(dtype))<0)
@@ -1214,6 +1264,17 @@ static int test_opaques(void)
        goto out;
     free(opq_tag);
 
+    if(H5LTdtype_to_text(dtype, NULL, &str_len)<0)
+        goto out; 
+    dt_str = (char*)calloc(str_len, sizeof(char));
+    if(H5LTdtype_to_text(dtype, dt_str, &str_len)<0)
+        goto out; 
+    if(strcmp(dt_str, "H5T_OPAQUE {\n      OPQ_SIZE 19;\n      OPQ_TAG \"This is a tag for opaque type\";\n   }")) {
+        printf("dt=\n%s\n", dt_str);
+        goto out;
+    }
+    free(dt_str);
+
     if(H5Tclose(dtype)<0)
         goto out;
     
@@ -1238,6 +1299,8 @@ static int test_enums(void)
     char    *name2 = "WHITE";
     int     value2;
     H5T_class_t type_class;
+    char*   dt_str;
+    size_t  str_len;
     
     TESTING3("        text for enum types");
     
@@ -1259,6 +1322,17 @@ static int test_enums(void)
     if(value2 != 8)
         goto out;
     
+    if(H5LTdtype_to_text(dtype, NULL, &str_len)<0)
+        goto out; 
+    dt_str = (char*)calloc(str_len, sizeof(char));
+    if(H5LTdtype_to_text(dtype, dt_str, &str_len)<0)
+        goto out; 
+    /*if(strcmp(dt_str, "H5T_ENUM {\n      H5T_STD_I32LE;\n      \"RED\"            5;\n      \"GREEN\"          6;\n      \"BLUE\"           7;\n      \"WHITE\"          8;\n   }")) {
+        printf("dt=\n%s\n", dt_str);
+        goto out;
+    }*/
+    free(dt_str);
+  
     if(H5Tclose(dtype)<0)
         goto out;
     
@@ -1278,6 +1352,8 @@ static int test_variables(void)
 {
     hid_t   dtype;
     H5T_class_t type_class;
+    char*   dt_str;
+    size_t  str_len;
     
     TESTING3("        text for variable types");
       
@@ -1295,12 +1371,23 @@ static int test_variables(void)
     if(H5Tclose(dtype)<0)
         goto out;
    
-    if((dtype = H5LTtext_to_dtype("H5T_VLEN { H5T_VLEN { H5T_STD_I32BE } }\n"))<0)
+    if((dtype = H5LTtext_to_dtype("H5T_VLEN { H5T_VLEN { H5T_STD_I32BE } }"))<0)
         goto out;
     
     if(H5Tis_variable_str(dtype))
         goto out;
 
+    if(H5LTdtype_to_text(dtype, NULL, &str_len)<0)
+        goto out; 
+    dt_str = (char*)calloc(str_len, sizeof(char));
+    if(H5LTdtype_to_text(dtype, dt_str, &str_len)<0)
+        goto out; 
+    if(strcmp(dt_str, "H5T_VLEN {\n      H5T_VLEN {\n         H5T_STD_I32BE\n      }\n   }")) {
+        printf("dt=\n%s\n", dt_str);
+        goto out;
+    }
+    free(dt_str);
+
     if(H5Tclose(dtype)<0)
         goto out;
      
@@ -1322,6 +1409,8 @@ static int test_arrays(void)
     int     ndims;
     hsize_t dims[3];
     H5T_class_t type_class;
+    char*   dt_str;
+    size_t  str_len;
 
     TESTING3("        text for array types");
       
@@ -1343,10 +1432,20 @@ static int test_arrays(void)
     if(dims[0] != 5 || dims[1] != 7 || dims[2] != 13)
         goto out;
 
+    if(H5LTdtype_to_text(dtype, NULL, &str_len)<0)
+        goto out; 
+    dt_str = (char*)calloc(str_len, sizeof(char));
+    if(H5LTdtype_to_text(dtype, dt_str, &str_len)<0)
+        goto out; 
+    /*if(strcmp(dt_str, "H5T_ARRAY { [5][7][13] H5T_ARRAY { [17][19] H5T_COMPOUND { H5T_STD_I8BE \"arr_compound_1\"; H5T_STD_I32BE \"arr_compound_2\"; } } }")) {
+        printf("dt=\n%s\n", dt_str);
+        goto out;
+    }*/
+    free(dt_str);
+
     if(H5Tclose(dtype)<0)
         goto out;
    
-     
     PASSED();
     return 0;
 
@@ -1366,6 +1465,8 @@ static int test_compounds(void)
     char    *memb_name = NULL;
     H5T_class_t memb_class;
     H5T_class_t type_class;
+    char*   dt_str;
+    size_t  str_len;
         
     TESTING3("        text for compound types");
     
@@ -1381,7 +1482,18 @@ static int test_compounds(void)
         goto out;
     if(nmembs != 2)
         goto out;
-        
+
+    if(H5LTdtype_to_text(dtype, NULL, &str_len)<0)
+        goto out; 
+    dt_str = (char*)calloc(str_len, sizeof(char));
+    if(H5LTdtype_to_text(dtype, dt_str, &str_len)<0)
+        goto out; 
+    if(strcmp(dt_str, "H5T_COMPOUND {\n      H5T_STD_I16BE \"one_field\";\n      H5T_STD_U8LE \"two_field\";\n   }")) {
+        printf("dt=\n%s\n", dt_str);
+        goto out;
+    }
+    free(dt_str);
+      
     if(H5Tclose(dtype)<0)
         goto out;
     
@@ -1417,10 +1529,10 @@ static int test_text_dtype(void)
 
     if(test_integers()<0)
         goto out;
-  
+
     if(test_fps()<0)
         goto out;
-    
+
     if(test_strings()<0)
         goto out;