[svn-r1689] Mainly adding support for "native" variable-length strings (C only currently),

but I fixed lots of misc. compiler warnings in other code and also tracked down
the memory overwrite bug that was causing the development branch to core dump
on most machines.

1 files changed, 504 insertions, 497 deletions

diff --git a/src/H5Odtype.c b/src/H5Odtype.c
index 214782c..569c635 100644
--- a/src/H5Odtype.c
+++ b/src/H5Odtype.c
@@ -101,220 +101,223 @@ H5O_dtype_decode_helper(H5F_t *f, const uint8_t **pp, H5T_t *dt)
     UINT32DECODE(*pp, dt->size);
 
     switch (dt->type) {
-    case H5T_INTEGER:
-	/*
-	 * Integer types...
-	 */
-	dt->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
-	dt->u.atomic.lsb_pad = (flags & 0x2) ? H5T_PAD_ONE : H5T_PAD_ZERO;
-	dt->u.atomic.msb_pad = (flags & 0x4) ? H5T_PAD_ONE : H5T_PAD_ZERO;
-	dt->u.atomic.u.i.sign = (flags & 0x8) ? H5T_SGN_2 : H5T_SGN_NONE;
-	UINT16DECODE(*pp, dt->u.atomic.offset);
-	UINT16DECODE(*pp, dt->u.atomic.prec);
-	break;
-
-    case H5T_BITFIELD:
-	/*
-         * Bit fields...
-         */
-	dt->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
-	dt->u.atomic.lsb_pad = (flags & 0x2) ? H5T_PAD_ONE : H5T_PAD_ZERO;
-	dt->u.atomic.msb_pad = (flags & 0x4) ? H5T_PAD_ONE : H5T_PAD_ZERO;
-	UINT16DECODE(*pp, dt->u.atomic.offset);
-	UINT16DECODE(*pp, dt->u.atomic.prec);
-	break;
-
-    case H5T_OPAQUE:
-	/*
-         * Opaque types...
-         */
-	z = flags & 0xff;
-	assert(0==(z&0x7)); /*must be aligned*/
-	if (NULL==(dt->u.opaque.tag=H5MM_malloc(z+1))) {
-	    HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
-			  "memory allocation failed");
-	}
-	HDmemcpy(dt->u.opaque.tag, *pp, z);
-	dt->u.opaque.tag[z] = '\0';
-	*pp += z;
-	break;
-
-    case H5T_STRING:
-	/*
-	 * Character string types...
-	 */
-	dt->u.atomic.order = H5T_ORDER_NONE;
-	dt->u.atomic.prec = 8 * dt->size;
-	dt->u.atomic.offset = 0;
-	dt->u.atomic.lsb_pad = H5T_PAD_ZERO;
-	dt->u.atomic.msb_pad = H5T_PAD_ZERO;
-
-	dt->u.atomic.u.s.pad = (H5T_str_t)(flags & 0x0f);
-	dt->u.atomic.u.s.cset = (H5T_cset_t)((flags>>4) & 0x0f);
-	break;
-
-    case H5T_FLOAT:
-	/*
-	 * Floating-point types...
-	 */
-	dt->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
-	dt->u.atomic.lsb_pad = (flags & 0x2) ? H5T_PAD_ONE : H5T_PAD_ZERO;
-	dt->u.atomic.msb_pad = (flags & 0x4) ? H5T_PAD_ONE : H5T_PAD_ZERO;
-	dt->u.atomic.u.f.pad = (flags & 0x8) ? H5T_PAD_ONE : H5T_PAD_ZERO;
-	switch ((flags >> 4) & 0x03) {
-	case 0:
-	    dt->u.atomic.u.f.norm = H5T_NORM_NONE;
-	    break;
-	case 1:
-	    dt->u.atomic.u.f.norm = H5T_NORM_MSBSET;
-	    break;
-	case 2:
-	    dt->u.atomic.u.f.norm = H5T_NORM_IMPLIED;
-	    break;
-	default:
-	    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
-			  "unknown floating-point normalization");
-	}
-	dt->u.atomic.u.f.sign = (flags >> 8) & 0xff;
-	UINT16DECODE(*pp, dt->u.atomic.offset);
-	UINT16DECODE(*pp, dt->u.atomic.prec);
-	dt->u.atomic.u.f.epos = *(*pp)++;
-	dt->u.atomic.u.f.esize = *(*pp)++;
-	assert(dt->u.atomic.u.f.esize > 0);
-	dt->u.atomic.u.f.mpos = *(*pp)++;
-	dt->u.atomic.u.f.msize = *(*pp)++;
-	assert(dt->u.atomic.u.f.msize > 0);
-	UINT32DECODE(*pp, dt->u.atomic.u.f.ebias);
-	break;
-
-    case H5T_COMPOUND:
-	/*
-	 * Compound data types...
-	 */
-	dt->u.compnd.nmembs = flags & 0xffff;
-	assert(dt->u.compnd.nmembs > 0);
-	dt->u.compnd.nalloc = dt->u.compnd.nmembs;
-	dt->u.compnd.memb = H5MM_calloc(dt->u.compnd.nalloc*
-					sizeof(H5T_cmemb_t));
-	if (NULL==dt->u.compnd.memb) {
-	    HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
-			   "memory allocation failed");
-	}
-	for (i = 0; i < dt->u.compnd.nmembs; i++) {
-	    dt->u.compnd.memb[i].name = H5MM_xstrdup((const char *)*pp);
-	    /*multiple of 8 w/ null terminator */
-	    *pp += ((HDstrlen((const char *)*pp) + 8) / 8) * 8;
-	    UINT32DECODE(*pp, dt->u.compnd.memb[i].offset);
-	    dt->u.compnd.memb[i].ndims = *(*pp)++;
-	    assert(dt->u.compnd.memb[i].ndims <= 4);
-	    *pp += 3;		/*reserved bytes */
-
-	    /* Dimension permutation */
-	    UINT32DECODE(*pp, perm_word);
-	    dt->u.compnd.memb[i].perm[0] = (perm_word >> 0) & 0xff;
-	    dt->u.compnd.memb[i].perm[1] = (perm_word >> 8) & 0xff;
-	    dt->u.compnd.memb[i].perm[2] = (perm_word >> 16) & 0xff;
-	    dt->u.compnd.memb[i].perm[3] = (perm_word >> 24) & 0xff;
-	    dt->u.compnd.memb[i].type = H5MM_calloc (sizeof(H5T_t));
-
-	    /* Reserved */
-	    *pp += 4;
-	    
-	    /* Dimension sizes */
-	    for (j=0; j<4; j++) {
-		UINT32DECODE(*pp, dt->u.compnd.memb[i].dim[j]);
-	    }
-	    if (NULL==dt->u.compnd.memb[i].type) {
-		HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
-			       "memory allocation failed");
-	    }
-	    dt->u.compnd.memb[i].type->ent.header = HADDR_UNDEF;
-	    if (H5O_dtype_decode_helper(f, pp, dt->u.compnd.memb[i].type)<0) {
-		for (j=0; j<=i; j++) H5MM_xfree(dt->u.compnd.memb[j].name);
-		H5MM_xfree(dt->u.compnd.memb);
-		HRETURN_ERROR(H5E_DATATYPE, H5E_CANTDECODE, FAIL,
-			      "unable to decode member type");
-	    }
+        case H5T_INTEGER:
+            /*
+             * Integer types...
+             */
+            dt->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
+            dt->u.atomic.lsb_pad = (flags & 0x2) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+            dt->u.atomic.msb_pad = (flags & 0x4) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+            dt->u.atomic.u.i.sign = (flags & 0x8) ? H5T_SGN_2 : H5T_SGN_NONE;
+            UINT16DECODE(*pp, dt->u.atomic.offset);
+            UINT16DECODE(*pp, dt->u.atomic.prec);
+            break;
+
+        case H5T_BITFIELD:
+            /*
+             * Bit fields...
+             */
+            dt->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
+            dt->u.atomic.lsb_pad = (flags & 0x2) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+            dt->u.atomic.msb_pad = (flags & 0x4) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+            UINT16DECODE(*pp, dt->u.atomic.offset);
+            UINT16DECODE(*pp, dt->u.atomic.prec);
+            break;
+
+        case H5T_OPAQUE:
+            /*
+             * Opaque types...
+             */
+            z = flags & 0xff;
+            assert(0==(z&0x7)); /*must be aligned*/
+            if (NULL==(dt->u.opaque.tag=H5MM_malloc(z+1))) {
+                HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
+                      "memory allocation failed");
+            }
+            HDmemcpy(dt->u.opaque.tag, *pp, z);
+            dt->u.opaque.tag[z] = '\0';
+            *pp += z;
+            break;
+
+        case H5T_FLOAT:
+            /*
+             * Floating-point types...
+             */
+            dt->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
+            dt->u.atomic.lsb_pad = (flags & 0x2) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+            dt->u.atomic.msb_pad = (flags & 0x4) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+            dt->u.atomic.u.f.pad = (flags & 0x8) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+            switch ((flags >> 4) & 0x03) {
+                case 0:
+                    dt->u.atomic.u.f.norm = H5T_NORM_NONE;
+                    break;
+                case 1:
+                    dt->u.atomic.u.f.norm = H5T_NORM_MSBSET;
+                    break;
+                case 2:
+                    dt->u.atomic.u.f.norm = H5T_NORM_IMPLIED;
+                    break;
+                default:
+                    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+                          "unknown floating-point normalization");
+            }
+            dt->u.atomic.u.f.sign = (flags >> 8) & 0xff;
+            UINT16DECODE(*pp, dt->u.atomic.offset);
+            UINT16DECODE(*pp, dt->u.atomic.prec);
+            dt->u.atomic.u.f.epos = *(*pp)++;
+            dt->u.atomic.u.f.esize = *(*pp)++;
+            assert(dt->u.atomic.u.f.esize > 0);
+            dt->u.atomic.u.f.mpos = *(*pp)++;
+            dt->u.atomic.u.f.msize = *(*pp)++;
+            assert(dt->u.atomic.u.f.msize > 0);
+            UINT32DECODE(*pp, dt->u.atomic.u.f.ebias);
+            break;
+
+        case H5T_COMPOUND:
+            /*
+             * Compound data types...
+             */
+            dt->u.compnd.nmembs = flags & 0xffff;
+            assert(dt->u.compnd.nmembs > 0);
+            dt->u.compnd.nalloc = dt->u.compnd.nmembs;
+            dt->u.compnd.memb = H5MM_calloc(dt->u.compnd.nalloc*
+                            sizeof(H5T_cmemb_t));
+            if (NULL==dt->u.compnd.memb) {
+                HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+                       "memory allocation failed");
+            }
+            for (i = 0; i < dt->u.compnd.nmembs; i++) {
+                dt->u.compnd.memb[i].name = H5MM_xstrdup((const char *)*pp);
+                /*multiple of 8 w/ null terminator */
+                *pp += ((HDstrlen((const char *)*pp) + 8) / 8) * 8;
+                UINT32DECODE(*pp, dt->u.compnd.memb[i].offset);
+                dt->u.compnd.memb[i].ndims = *(*pp)++;
+                assert(dt->u.compnd.memb[i].ndims <= 4);
+                *pp += 3;		/*reserved bytes */
+
+                /* Dimension permutation */
+                UINT32DECODE(*pp, perm_word);
+                dt->u.compnd.memb[i].perm[0] = (perm_word >> 0) & 0xff;
+                dt->u.compnd.memb[i].perm[1] = (perm_word >> 8) & 0xff;
+                dt->u.compnd.memb[i].perm[2] = (perm_word >> 16) & 0xff;
+                dt->u.compnd.memb[i].perm[3] = (perm_word >> 24) & 0xff;
+                dt->u.compnd.memb[i].type = H5MM_calloc (sizeof(H5T_t));
+
+                /* Reserved */
+                *pp += 4;
+                
+                /* Dimension sizes */
+                for (j=0; j<4; j++) {
+                UINT32DECODE(*pp, dt->u.compnd.memb[i].dim[j]);
+                }
+                if (NULL==dt->u.compnd.memb[i].type) {
+                HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+                           "memory allocation failed");
+                }
+                dt->u.compnd.memb[i].type->ent.header = HADDR_UNDEF;
+                if (H5O_dtype_decode_helper(f, pp, dt->u.compnd.memb[i].type)<0) {
+                for (j=0; j<=i; j++) H5MM_xfree(dt->u.compnd.memb[j].name);
+                H5MM_xfree(dt->u.compnd.memb);
+                HRETURN_ERROR(H5E_DATATYPE, H5E_CANTDECODE, FAIL,
+                          "unable to decode member type");
+                }
+
+                /*
+                 * Set the "force conversion" flag if VL datatype fields exist in this
+                 * type or any component types
+                 */
+                if(dt->u.compnd.memb[i].type->type==H5T_VLEN || dt->u.compnd.memb[i].type->force_conv==TRUE)
+                    dt->force_conv=TRUE;
+                
+                /* Total member size */
+                dt->u.compnd.memb[i].size = dt->u.compnd.memb[i].type->size;
+                for (j=0; j<dt->u.compnd.memb[i].ndims; j++) {
+                    dt->u.compnd.memb[i].size *= dt->u.compnd.memb[i].dim[j];
+                }
+            }
+            break;
+
+        case H5T_ENUM:
+            /*
+             * Enumeration data types...
+             */
+            dt->u.enumer.nmembs = dt->u.enumer.nalloc = flags & 0xffff;
+            assert(dt->u.enumer.nmembs>=0);
+            if (NULL==(dt->parent=H5MM_calloc(sizeof(H5T_t)))) {
+                HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
+                      "memory allocation failed");
+            }
+            dt->parent->ent.header = HADDR_UNDEF;
+            if (H5O_dtype_decode_helper(f, pp, dt->parent)<0) {
+                HRETURN_ERROR(H5E_DATATYPE, H5E_CANTDECODE, FAIL,
+                      "unable to decode parent data type");
+            }
+            if (NULL==(dt->u.enumer.name=H5MM_calloc(dt->u.enumer.nalloc *
+                                 sizeof(char*))) ||
+                NULL==(dt->u.enumer.value=H5MM_calloc(dt->u.enumer.nalloc *
+                                  dt->parent->size))) {
+                HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
+                      "memory allocation failed");
+            }
+
+            /* Names, each a multiple of 8 with null termination */
+            for (i=0; i<dt->u.enumer.nmembs; i++) {
+                dt->u.enumer.name[i] = H5MM_xstrdup((const char*)*pp);
+                *pp += ((HDstrlen((const char*)*pp)+8)/8)*8;
+            }
+
+            /* Values */
+            HDmemcpy(dt->u.enumer.value, *pp,
+                 dt->u.enumer.nmembs * dt->parent->size);
+            *pp += dt->u.enumer.nmembs * dt->parent->size;
+            break;
+
+        case H5T_REFERENCE: /* Reference data types...  */
+            dt->u.atomic.order = H5T_ORDER_NONE;
+            dt->u.atomic.prec = 8 * dt->size;
+            dt->u.atomic.offset = 0;
+            dt->u.atomic.lsb_pad = H5T_PAD_ZERO;
+            dt->u.atomic.msb_pad = H5T_PAD_ZERO;
+            dt->u.atomic.u.r.rtype = (H5R_type_t)(flags & 0x0f);
+            break;
+
+        case H5T_STRING:
+            /*
+             * Character string types...
+             */
+            dt->u.atomic.order = H5T_ORDER_NONE;
+            dt->u.atomic.prec = 8 * dt->size;
+            dt->u.atomic.offset = 0;
+            dt->u.atomic.lsb_pad = H5T_PAD_ZERO;
+            dt->u.atomic.msb_pad = H5T_PAD_ZERO;
+
+            dt->u.atomic.u.s.pad = (H5T_str_t)(flags & 0x0f);
+            dt->u.atomic.u.s.cset = (H5T_cset_t)((flags>>4) & 0x0f);
+            break;
+
+        case H5T_VLEN:  /* Variable length datatypes...  */
+            /* Set the type of VL information, either sequence or string */
+            dt->u.vlen.type = (H5T_vlen_type_t)(flags & 0x0f);
+
+            /* Decode base type of VL information */
+            dt->parent->ent.header = HADDR_UNDEF;
+            if (H5O_dtype_decode_helper(f, pp, dt->parent)<0) {
+                HRETURN_ERROR(H5E_DATATYPE, H5E_CANTDECODE, FAIL, "unable to decode VL parent type");
+            }
 
-        /*
-         * Set the "force conversion" flag if VL datatype fields exist in this
-         * type or any component types
-         */
-        if(dt->u.compnd.memb[i].type->type==H5T_VLEN || dt->u.compnd.memb[i].type->force_conv==TRUE)
             dt->force_conv=TRUE;
-	    
-	    /* Total member size */
-	    dt->u.compnd.memb[i].size = dt->u.compnd.memb[i].type->size;
-	    for (j=0; j<dt->u.compnd.memb[i].ndims; j++) {
-		dt->u.compnd.memb[i].size *= dt->u.compnd.memb[i].dim[j];
-	    }
-	}
-	break;
-
-    case H5T_ENUM:
-	/*
-	 * Enumeration data types...
-	 */
-	dt->u.enumer.nmembs = dt->u.enumer.nalloc = flags & 0xffff;
-	assert(dt->u.enumer.nmembs>=0);
-	if (NULL==(dt->parent=H5MM_calloc(sizeof(H5T_t)))) {
-	    HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
-			  "memory allocation failed");
-	}
-	dt->parent->ent.header = HADDR_UNDEF;
-	if (H5O_dtype_decode_helper(f, pp, dt->parent)<0) {
-	    HRETURN_ERROR(H5E_DATATYPE, H5E_CANTDECODE, FAIL,
-			  "unable to decode parent data type");
-	}
-	if (NULL==(dt->u.enumer.name=H5MM_calloc(dt->u.enumer.nalloc *
-						 sizeof(char*))) ||
-	    NULL==(dt->u.enumer.value=H5MM_calloc(dt->u.enumer.nalloc *
-						  dt->parent->size))) {
-	    HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
-			  "memory allocation failed");
-	}
-
-	/* Names, each a multiple of 8 with null termination */
-	for (i=0; i<dt->u.enumer.nmembs; i++) {
-	    dt->u.enumer.name[i] = H5MM_xstrdup((const char*)*pp);
-	    *pp += ((HDstrlen((const char*)*pp)+8)/8)*8;
-	}
-
-	/* Values */
-	HDmemcpy(dt->u.enumer.value, *pp,
-		 dt->u.enumer.nmembs * dt->parent->size);
-	*pp += dt->u.enumer.nmembs * dt->parent->size;
-	break;
-
-    case H5T_REFERENCE:
-	dt->u.atomic.order = H5T_ORDER_NONE;
-	dt->u.atomic.prec = 8 * dt->size;
-	dt->u.atomic.offset = 0;
-	dt->u.atomic.lsb_pad = H5T_PAD_ZERO;
-	dt->u.atomic.msb_pad = H5T_PAD_ZERO;
-	dt->u.atomic.u.r.rtype = (H5R_type_t)(flags & 0x0f);
-	break;
-
-    case H5T_VLEN:  /* Variable length datatypes...  */
-        /* Decode base type of VL information */
-        dt->parent->ent.header = HADDR_UNDEF;
-	    if (H5O_dtype_decode_helper(f, pp, dt->parent)<0) {
-            HRETURN_ERROR(H5E_DATATYPE, H5E_CANTDECODE, FAIL, "unable to decode VL parent type");
-        }
-
-        dt->force_conv=TRUE;
-        /* Mark this type as on disk */
-	    if (H5T_vlen_mark(dt, f, H5T_VLEN_DISK)<0) {
-            HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "invalid VL location");
-        }
-        break;
-
-    default:
-	if (flags) {
-	    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
-			  "class flags are non-zero");
-	}
-	break;
+            /* Mark this type as on disk */
+            if (H5T_vlen_mark(dt, f, H5T_VLEN_DISK)<0) {
+                HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "invalid VL location");
+            }
+            break;
+
+        default:
+            if (flags) {
+                HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+                      "class flags are non-zero");
+            }
+            break;
     }
 
     FUNC_LEAVE(SUCCEED);
@@ -356,292 +359,296 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
     UINT32ENCODE(*pp, dt->size);
 
     switch (dt->type) {
-    case H5T_INTEGER:
-	/*
-	 * Integer data types...
-	 */
-	switch (dt->u.atomic.order) {
-	case H5T_ORDER_LE:
-	    break;		/*nothing */
-	case H5T_ORDER_BE:
-	    flags |= 0x01;
-	    break;
-	default:
-	    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
-			  "byte order is not supported in file format yet");
-	}
-
-	switch (dt->u.atomic.lsb_pad) {
-	case H5T_PAD_ZERO:
-	    break;		/*nothing */
-	case H5T_PAD_ONE:
-	    flags |= 0x02;
-	    break;
-	default:
-	    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
-			  "bit padding is not supported in file format yet");
-	}
-
-	switch (dt->u.atomic.msb_pad) {
-	case H5T_PAD_ZERO:
-	    break;		/*nothing */
-	case H5T_PAD_ONE:
-	    flags |= 0x04;
-	    break;
-	default:
-	    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
-			  "bit padding is not supported in file format yet");
-	}
-
-	switch (dt->u.atomic.u.i.sign) {
-	case H5T_SGN_NONE:
-	    break;		/*nothing */
-	case H5T_SGN_2:
-	    flags |= 0x08;
-	    break;
-	default:
-	    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
-			  "sign scheme is not supported in file format yet");
-	}
-
-	UINT16ENCODE(*pp, dt->u.atomic.offset);
-	UINT16ENCODE(*pp, dt->u.atomic.prec);
-	break;
-
-    case H5T_BITFIELD:
-	/*
-	 * Bitfield data types...
-	 */
-	switch (dt->u.atomic.order) {
-	case H5T_ORDER_LE:
-	    break;		/*nothing */
-	case H5T_ORDER_BE:
-	    flags |= 0x01;
-	    break;
-	default:
-	    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
-			  "byte order is not supported in file format yet");
-	}
-
-	switch (dt->u.atomic.lsb_pad) {
-	case H5T_PAD_ZERO:
-	    break;		/*nothing */
-	case H5T_PAD_ONE:
-	    flags |= 0x02;
-	    break;
-	default:
-	    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
-			  "bit padding is not supported in file format yet");
-	}
-
-	switch (dt->u.atomic.msb_pad) {
-	case H5T_PAD_ZERO:
-	    break;		/*nothing */
-	case H5T_PAD_ONE:
-	    flags |= 0x04;
-	    break;
-	default:
-	    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
-			  "bit padding is not supported in file format yet");
-	}
-
-	UINT16ENCODE(*pp, dt->u.atomic.offset);
-	UINT16ENCODE(*pp, dt->u.atomic.prec);
-	break;
-
-    case H5T_OPAQUE:
-	/*
-         * Opaque data types...  The tag is stored in a field which is a
-         * multiple of eight characters and null padded (not necessarily
-         * null terminated).
-         */
-	z = HDstrlen(dt->u.opaque.tag);
-	aligned = (z+7) & 0xf8;
-	flags |= aligned;
-	HDmemcpy(*pp, dt->u.opaque.tag, MIN(z,aligned));
-	for (n=MIN(z,aligned); n<aligned; n++) (*pp)[n] = 0;
-	*pp += aligned;
-	break;
-
-    case H5T_STRING:
-	/*
-	 * Character string types... (not fully implemented)
-	 */
-	assert (dt->u.atomic.order == H5T_ORDER_NONE);
-	assert (dt->u.atomic.prec == 8 * dt->size);
-	assert (dt->u.atomic.offset == 0);
-	assert (dt->u.atomic.lsb_pad == H5T_PAD_ZERO);
-	assert (dt->u.atomic.msb_pad == H5T_PAD_ZERO);
-
-	flags |= (dt->u.atomic.u.s.pad & 0x0f);
-	flags |= (dt->u.atomic.u.s.cset & 0x0f) << 4;
-	break;
-
-    case H5T_FLOAT:
-	/*
-	 * Floating-point types...
-	 */
-	switch (dt->u.atomic.order) {
-	case H5T_ORDER_LE:
-	    break;		/*nothing */
-	case H5T_ORDER_BE:
-	    flags |= 0x01;
-	    break;
-	default:
-	    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
-			  "byte order is not supported in file format yet");
-	}
-
-	switch (dt->u.atomic.lsb_pad) {
-	case H5T_PAD_ZERO:
-	    break;		/*nothing */
-	case H5T_PAD_ONE:
-	    flags |= 0x02;
-	    break;
-	default:
-	    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
-			  "bit padding is not supported in file format yet");
-	}
-
-	switch (dt->u.atomic.msb_pad) {
-	case H5T_PAD_ZERO:
-	    break;		/*nothing */
-	case H5T_PAD_ONE:
-	    flags |= 0x04;
-	    break;
-	default:
-	    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
-			  "bit padding is not supported in file format yet");
-	}
-
-	switch (dt->u.atomic.u.f.pad) {
-	case H5T_PAD_ZERO:
-	    break;		/*nothing */
-	case H5T_PAD_ONE:
-	    flags |= 0x08;
-	    break;
-	default:
-	    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
-			  "bit padding is not supported in file format yet");
-	}
-
-	switch (dt->u.atomic.u.f.norm) {
-	case H5T_NORM_NONE:
-	    break;		/*nothing */
-	case H5T_NORM_MSBSET:
-	    flags |= 0x10;
-	    break;
-	case H5T_NORM_IMPLIED:
-	    flags |= 0x20;
-	    break;
-	default:
-	    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
-			  "normalization scheme is not supported in file "
-			  "format yet");
-	}
-
-	flags |= (dt->u.atomic.u.f.sign << 8) & 0xff00;
-	UINT16ENCODE(*pp, dt->u.atomic.offset);
-	UINT16ENCODE(*pp, dt->u.atomic.prec);
-	assert (dt->u.atomic.u.f.epos<=255);
-	*(*pp)++ = (uint8_t)(dt->u.atomic.u.f.epos);
-	assert (dt->u.atomic.u.f.esize<=255);
-	*(*pp)++ = (uint8_t)(dt->u.atomic.u.f.esize);
-	assert (dt->u.atomic.u.f.mpos<=255);
-	*(*pp)++ = (uint8_t)(dt->u.atomic.u.f.mpos);
-	assert (dt->u.atomic.u.f.msize<=255);
-	*(*pp)++ = (uint8_t)(dt->u.atomic.u.f.msize);
-	UINT32ENCODE(*pp, dt->u.atomic.u.f.ebias);
-	break;
-
-    case H5T_COMPOUND:
-	/*
-	 * Compound data types...
-	 */
-	flags = dt->u.compnd.nmembs & 0xffff;
-	for (i=0; i<dt->u.compnd.nmembs; i++) {
-	    /* Name, multiple of eight bytes */
-	    HDstrcpy((char*)(*pp), dt->u.compnd.memb[i].name);
-	    n = HDstrlen(dt->u.compnd.memb[i].name);
-	    for (z=n+1; z%8; z++) (*pp)[z] = '\0';
-	    *pp += z;
-
-	    /* Member offset */
-	    UINT32ENCODE(*pp, dt->u.compnd.memb[i].offset);
-
-	    /* Dimensionality */
-	    *(*pp)++ = dt->u.compnd.memb[i].ndims;
-	    assert(dt->u.compnd.memb[i].ndims <= 4);
-
-	    /* Reserved */
-	    *(*pp)++ = '\0';
-	    *(*pp)++ = '\0';
-	    *(*pp)++ = '\0';
-
-	    /* Dimension permutation */
-	    for (j = 0, perm_word = 0; j < dt->u.compnd.memb[i].ndims; j++) {
-		perm_word |= dt->u.compnd.memb[i].perm[j] << (8 * j);
-	    }
-	    UINT32ENCODE(*pp, perm_word);
-
-	    /* Reserved */
-	    UINT32ENCODE(*pp, 0);
-
-	    /* Dimensions */
-	    for (j=0; j<dt->u.compnd.memb[i].ndims; j++) {
-		UINT32ENCODE(*pp, dt->u.compnd.memb[i].dim[j]);
-	    }
-	    for (/*void*/; j<4; j++) {
-		UINT32ENCODE(*pp, 0);
-	    }
-
-	    /* Subtype */
-	    if (H5O_dtype_encode_helper(pp, dt->u.compnd.memb[i].type)<0) {
-		HRETURN_ERROR(H5E_DATATYPE, H5E_CANTENCODE, FAIL,
-			      "unable to encode member type");
-	    }
-	}
-	break;
-
-    case H5T_ENUM:
-        /*
-         * Enumeration data types...
-         */
-        flags = dt->u.enumer.nmembs & 0xffff;
-
-        /* Parent type */
-        if (H5O_dtype_encode_helper(pp, dt->parent)<0) {
-            HRETURN_ERROR(H5E_DATATYPE, H5E_CANTENCODE, FAIL,
-                  "unable to encode parent data type");
-        }
-        
-        /* Names, each a multiple of eight bytes */
-        for (i=0; i<dt->u.enumer.nmembs; i++) {
-            HDstrcpy((char*)(*pp), dt->u.enumer.name[i]);
-            n = HDstrlen(dt->u.enumer.name[i]);
-            for (z=n+1; z%8; z++) (*pp)[z] = '\0';
-            *pp += z;
-        }
-
-        /* Values */
-        HDmemcpy(*pp, dt->u.enumer.value, dt->u.enumer.nmembs * dt->parent->size);
-        *pp += dt->u.enumer.nmembs * dt->parent->size;
-        break;
-	
-    case H5T_REFERENCE:
-        flags |= (dt->u.atomic.u.r.rtype & 0x0f);
-        break;
+        case H5T_INTEGER:
+            /*
+             * Integer data types...
+             */
+            switch (dt->u.atomic.order) {
+                case H5T_ORDER_LE:
+                    break;		/*nothing */
+                case H5T_ORDER_BE:
+                    flags |= 0x01;
+                    break;
+                default:
+                    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+                          "byte order is not supported in file format yet");
+            }
+
+            switch (dt->u.atomic.lsb_pad) {
+                case H5T_PAD_ZERO:
+                    break;		/*nothing */
+                case H5T_PAD_ONE:
+                    flags |= 0x02;
+                    break;
+                default:
+                    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+                          "bit padding is not supported in file format yet");
+            }
+
+            switch (dt->u.atomic.msb_pad) {
+                case H5T_PAD_ZERO:
+                    break;		/*nothing */
+                case H5T_PAD_ONE:
+                    flags |= 0x04;
+                    break;
+                default:
+                    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+                          "bit padding is not supported in file format yet");
+            }
+
+            switch (dt->u.atomic.u.i.sign) {
+                case H5T_SGN_NONE:
+                    break;		/*nothing */
+                case H5T_SGN_2:
+                    flags |= 0x08;
+                    break;
+                default:
+                    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+                          "sign scheme is not supported in file format yet");
+            }
+
+            UINT16ENCODE(*pp, dt->u.atomic.offset);
+            UINT16ENCODE(*pp, dt->u.atomic.prec);
+            break;
+
+        case H5T_BITFIELD:
+            /*
+             * Bitfield data types...
+             */
+            switch (dt->u.atomic.order) {
+                case H5T_ORDER_LE:
+                    break;		/*nothing */
+                case H5T_ORDER_BE:
+                    flags |= 0x01;
+                    break;
+                default:
+                    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+                          "byte order is not supported in file format yet");
+            }
+
+            switch (dt->u.atomic.lsb_pad) {
+                case H5T_PAD_ZERO:
+                    break;		/*nothing */
+                case H5T_PAD_ONE:
+                    flags |= 0x02;
+                    break;
+                default:
+                    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+                          "bit padding is not supported in file format yet");
+            }
+
+            switch (dt->u.atomic.msb_pad) {
+                case H5T_PAD_ZERO:
+                    break;		/*nothing */
+                case H5T_PAD_ONE:
+                    flags |= 0x04;
+                    break;
+                default:
+                    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+                          "bit padding is not supported in file format yet");
+            }
+
+            UINT16ENCODE(*pp, dt->u.atomic.offset);
+            UINT16ENCODE(*pp, dt->u.atomic.prec);
+            break;
+
+        case H5T_OPAQUE:
+            /*
+             * Opaque data types...  The tag is stored in a field which is a
+             * multiple of eight characters and null padded (not necessarily
+             * null terminated).
+             */
+            z = HDstrlen(dt->u.opaque.tag);
+            aligned = (z+7) & 0xf8;
+            flags |= aligned;
+            HDmemcpy(*pp, dt->u.opaque.tag, MIN(z,aligned));
+            for (n=MIN(z,aligned); n<aligned; n++) (*pp)[n] = 0;
+            *pp += aligned;
+            break;
+
+        case H5T_FLOAT:
+            /*
+             * Floating-point types...
+             */
+            switch (dt->u.atomic.order) {
+                case H5T_ORDER_LE:
+                    break;		/*nothing */
+                case H5T_ORDER_BE:
+                    flags |= 0x01;
+                    break;
+                default:
+                    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+                          "byte order is not supported in file format yet");
+            }
+
+            switch (dt->u.atomic.lsb_pad) {
+                case H5T_PAD_ZERO:
+                    break;		/*nothing */
+                case H5T_PAD_ONE:
+                    flags |= 0x02;
+                    break;
+                default:
+                    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+                          "bit padding is not supported in file format yet");
+            }
+
+            switch (dt->u.atomic.msb_pad) {
+                case H5T_PAD_ZERO:
+                    break;		/*nothing */
+                case H5T_PAD_ONE:
+                    flags |= 0x04;
+                    break;
+                default:
+                    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+                          "bit padding is not supported in file format yet");
+            }
+
+            switch (dt->u.atomic.u.f.pad) {
+                case H5T_PAD_ZERO:
+                    break;		/*nothing */
+                case H5T_PAD_ONE:
+                    flags |= 0x08;
+                    break;
+                default:
+                    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+                          "bit padding is not supported in file format yet");
+            }
+
+            switch (dt->u.atomic.u.f.norm) {
+                case H5T_NORM_NONE:
+                    break;		/*nothing */
+                case H5T_NORM_MSBSET:
+                    flags |= 0x10;
+                    break;
+                case H5T_NORM_IMPLIED:
+                    flags |= 0x20;
+                    break;
+                default:
+                    HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+                          "normalization scheme is not supported in file format yet");
+            }
+
+            flags |= (dt->u.atomic.u.f.sign << 8) & 0xff00;
+            UINT16ENCODE(*pp, dt->u.atomic.offset);
+            UINT16ENCODE(*pp, dt->u.atomic.prec);
+            assert (dt->u.atomic.u.f.epos<=255);
+            *(*pp)++ = (uint8_t)(dt->u.atomic.u.f.epos);
+            assert (dt->u.atomic.u.f.esize<=255);
+            *(*pp)++ = (uint8_t)(dt->u.atomic.u.f.esize);
+            assert (dt->u.atomic.u.f.mpos<=255);
+            *(*pp)++ = (uint8_t)(dt->u.atomic.u.f.mpos);
+            assert (dt->u.atomic.u.f.msize<=255);
+            *(*pp)++ = (uint8_t)(dt->u.atomic.u.f.msize);
+            UINT32ENCODE(*pp, dt->u.atomic.u.f.ebias);
+            break;
+
+        case H5T_COMPOUND:
+            /*
+             * Compound data types...
+             */
+            flags = dt->u.compnd.nmembs & 0xffff;
+            for (i=0; i<dt->u.compnd.nmembs; i++) {
+
+                /* Name, multiple of eight bytes */
+                HDstrcpy((char*)(*pp), dt->u.compnd.memb[i].name);
+                n = HDstrlen(dt->u.compnd.memb[i].name);
+                for (z=n+1; z%8; z++)
+                    (*pp)[z] = '\0';
+                *pp += z;
+
+                /* Member offset */
+                UINT32ENCODE(*pp, dt->u.compnd.memb[i].offset);
+
+                /* Dimensionality */
+                *(*pp)++ = dt->u.compnd.memb[i].ndims;
+                assert(dt->u.compnd.memb[i].ndims <= 4);
+
+                /* Reserved */
+                *(*pp)++ = '\0';
+                *(*pp)++ = '\0';
+                *(*pp)++ = '\0';
+
+                /* Dimension permutation */
+                for (j = 0, perm_word = 0; j < dt->u.compnd.memb[i].ndims; j++) {
+                    perm_word |= dt->u.compnd.memb[i].perm[j] << (8 * j);
+                }
+                UINT32ENCODE(*pp, perm_word);
+
+                /* Reserved */
+                UINT32ENCODE(*pp, 0);
+
+                /* Dimensions */
+                for (j=0; j<dt->u.compnd.memb[i].ndims; j++) {
+                    UINT32ENCODE(*pp, dt->u.compnd.memb[i].dim[j]);
+                }
+                for (/*void*/; j<4; j++) {
+                    UINT32ENCODE(*pp, 0);
+                }
+
+                /* Subtype */
+                if (H5O_dtype_encode_helper(pp, dt->u.compnd.memb[i].type)<0) {
+                    HRETURN_ERROR(H5E_DATATYPE, H5E_CANTENCODE, FAIL,
+                          "unable to encode member type");
+                }
+            }
+            break;
+
+        case H5T_ENUM:
+            /*
+             * Enumeration data types...
+             */
+            flags = dt->u.enumer.nmembs & 0xffff;
+
+            /* Parent type */
+            if (H5O_dtype_encode_helper(pp, dt->parent)<0) {
+                HRETURN_ERROR(H5E_DATATYPE, H5E_CANTENCODE, FAIL,
+                      "unable to encode parent data type");
+            }
+            
+            /* Names, each a multiple of eight bytes */
+            for (i=0; i<dt->u.enumer.nmembs; i++) {
+                HDstrcpy((char*)(*pp), dt->u.enumer.name[i]);
+                n = HDstrlen(dt->u.enumer.name[i]);
+                for (z=n+1; z%8; z++)
+                    (*pp)[z] = '\0';
+                *pp += z;
+            }
+
+            /* Values */
+            HDmemcpy(*pp, dt->u.enumer.value, dt->u.enumer.nmembs * dt->parent->size);
+            *pp += dt->u.enumer.nmembs * dt->parent->size;
+            break;
         
-    case H5T_VLEN:  /* Variable length datatypes...  */
-        /* Encode base type of VL information */
-        if (H5O_dtype_encode_helper(pp, dt->parent)<0) {
-            HRETURN_ERROR(H5E_DATATYPE, H5E_CANTENCODE, FAIL, "unable to encode VL parent type");
-        }
-        break;
-
-    default:
-        /*nothing */
-        break;
+        case H5T_REFERENCE:
+            flags |= (dt->u.atomic.u.r.rtype & 0x0f);
+            break;
+            
+        case H5T_STRING:
+            /*
+             * Character string types... (not fully implemented)
+             */
+            assert (dt->u.atomic.order == H5T_ORDER_NONE);
+            assert (dt->u.atomic.prec == 8 * dt->size);
+            assert (dt->u.atomic.offset == 0);
+            assert (dt->u.atomic.lsb_pad == H5T_PAD_ZERO);
+            assert (dt->u.atomic.msb_pad == H5T_PAD_ZERO);
+
+            flags |= (dt->u.atomic.u.s.pad & 0x0f);
+            flags |= (dt->u.atomic.u.s.cset & 0x0f) << 4;
+            break;
+
+        case H5T_VLEN:  /* Variable length datatypes...  */
+            flags |= (dt->u.vlen.type & 0x0f);
+
+            /* Encode base type of VL information */
+            if (H5O_dtype_encode_helper(pp, dt->parent)<0) {
+                HRETURN_ERROR(H5E_DATATYPE, H5E_CANTENCODE, FAIL, "unable to encode VL parent type");
+            }
+            break;
+
+        default:
+            /*nothing */
+            break;
     }
 
     *hdr++ = ((uintn)(dt->type) & 0x0f) | (H5O_DTYPE_VERSION<<4);