[svn-r9727] Purpose:

    Bug Fix/Code Cleanup/Doc Cleanup/Optimization/Branch Sync :-)

Description:
    Generally speaking, this is the "signed->unsigned" change to selections.
However, in the process of merging code back, things got stickier and stickier
until I ended up doing a big "sync the two branches up" operation.  So... I
brought back all the "infrastructure" fixes from the development branch to the
release branch (which I think were actually making some improvement in
performance) as well as fixed several bugs which had been fixed in one branch,
but not the other.

    I've also tagged the repository before making this checkin with the label
"before_signed_unsigned_changes".

Platforms tested:
    FreeBSD 4.10 (sleipnir) w/parallel & fphdf5
    FreeBSD 4.10 (sleipnir) w/threadsafe
    FreeBSD 4.10 (sleipnir) w/backward compatibility
    Solaris 2.7 (arabica) w/"purify options"
    Solaris 2.8 (sol) w/FORTRAN & C++
    AIX 5.x (copper) w/parallel & FORTRAN
    IRIX64 6.5 (modi4) w/FORTRAN
    Linux 2.4 (heping) w/FORTRAN & C++


Misc. update:

1 files changed, 168 insertions, 62 deletions

diff --git a/src/H5.c b/src/H5.c
index 44f46e1..a9829c5 100644
--- a/src/H5.c
+++ b/src/H5.c
@@ -32,8 +32,10 @@
 #include "H5Tprivate.h"		/* Datatypes				*/
 #include "H5Zprivate.h"         /* I/O pipeline filters			*/
 
+#ifdef H5_HAVE_PARALLEL
 /* datatypes of predefined drivers needed by H5_trace() */
 #include "H5FDmpio.h"
+#endif /* H5_HAVE_PARALLEL */
 
 /* we need this for the struct rusage declaration */
 #if defined(H5_HAVE_GETRUSAGE) && defined(H5_HAVE_SYS_RESOURCE_H)
@@ -53,7 +55,7 @@ hbool_t H5_MPEinit_g = FALSE;	/* MPE Library hasn't been initialized */
 #endif
 
 char			H5_lib_vers_info_g[] = H5_VERS_INFO;
-hbool_t                 dont_atexit_g = FALSE;
+static hbool_t          H5_dont_atexit_g = FALSE;
 H5_debug_t		H5_debug_g;		/*debugging info	*/
 static void		H5_debug_mask(const char*);
 
@@ -121,12 +123,12 @@ H5_init_library(void)
     /*
      * Install atexit() library cleanup routine unless the H5dont_atexit()
      * has been called.  Once we add something to the atexit() list it stays
-     * there permanently, so we set dont_atexit_g after we add it to prevent
+     * there permanently, so we set H5_dont_atexit_g after we add it to prevent
      * adding it again later if the library is cosed and reopened.
      */
-    if (!dont_atexit_g) {
+    if (!H5_dont_atexit_g) {
 	(void)HDatexit(H5_term_library);
-	dont_atexit_g = TRUE;
+	H5_dont_atexit_g = TRUE;
     }
 
     /*
@@ -319,10 +321,10 @@ H5dont_atexit(void)
     FUNC_ENTER_API_NOINIT(H5dont_atexit)
     H5TRACE0("e","");
 
-    if (dont_atexit_g)
+    if (H5_dont_atexit_g)
         ret_value=FAIL;
     else
-        dont_atexit_g = TRUE;
+        H5_dont_atexit_g = TRUE;
 
     FUNC_LEAVE_API(ret_value)
 }
@@ -464,9 +466,9 @@ H5_debug_mask(const char *s)
 	    }
 
 	    /* Get the name */
-	    for (i=0; HDisalpha(*s); i++, s++) {
-		if (i<sizeof pkg_name) pkg_name[i] = *s;
-	    }
+	    for (i=0; HDisalpha(*s); i++, s++)
+		if (i<sizeof pkg_name)
+                    pkg_name[i] = *s;
 	    pkg_name[MIN(sizeof(pkg_name)-1, i)] = '\0';
 
 	    /* Trace, all, or one? */
@@ -479,26 +481,23 @@ H5_debug_mask(const char *s)
                 H5_debug_g.trace = stream;
                 H5_debug_g.ttimes = !clear;
 	    } else if (!HDstrcmp(pkg_name, "all")) {
-		for (i=0; i<H5_NPKGS; i++) {
+		for (i=0; i<(size_t)H5_NPKGS; i++)
 		    H5_debug_g.pkg[i].stream = clear?NULL:stream;
-		}
 	    } else {
-		for (i=0; i<H5_NPKGS; i++) {
+		for (i=0; i<(size_t)H5_NPKGS; i++) {
 		    if (!HDstrcmp(H5_debug_g.pkg[i].name, pkg_name)) {
 			H5_debug_g.pkg[i].stream = clear?NULL:stream;
 			break;
 		    }
 		}
-		if (i>=H5_NPKGS) {
+		if (i>=(size_t)H5_NPKGS)
 		    fprintf(stderr, "HDF5_DEBUG: ignored %s\n", pkg_name);
-		}
 	    }
 
 	} else if (HDisdigit(*s)) {
 	    int fd = (int)HDstrtol (s, &rest, 0);
-	    if ((stream=HDfdopen(fd, "w"))) {
+	    if ((stream=HDfdopen(fd, "w"))!=NULL)
 	        (void)HDsetvbuf (stream, NULL, _IOLBF, 0);
-            }
 	    s = rest;
 	} else {
 	    s++;
@@ -1014,13 +1013,13 @@ HDfprintf(FILE *stream, const char *fmt, ...)
 		    unsigned short x = (unsigned short)va_arg (ap, unsigned int);
 		    n = fprintf (stream, format_templ, x);
 		} else if (!*modifier) {
-		    unsigned int x = va_arg (ap, unsigned int);
+		    unsigned int x = va_arg (ap, unsigned int); /*lint !e732 Loss of sign not really occuring */
 		    n = fprintf (stream, format_templ, x);
 		} else if (!HDstrcmp (modifier, "l")) {
-		    unsigned long x = va_arg (ap, unsigned long);
+		    unsigned long x = va_arg (ap, unsigned long); /*lint !e732 Loss of sign not really occuring */
 		    n = fprintf (stream, format_templ, x);
 		} else {
-		    uint64_t x = va_arg(ap, uint64_t);
+		    uint64_t x = va_arg(ap, uint64_t); /*lint !e732 Loss of sign not really occuring */
 		    n = fprintf (stream, format_templ, x);
 		}
 		break;
@@ -1053,7 +1052,7 @@ HDfprintf(FILE *stream, const char *fmt, ...)
 
 	    case 'a':
                 {
-		    haddr_t x = va_arg (ap, haddr_t);
+		    haddr_t x = va_arg (ap, haddr_t); /*lint !e732 Loss of sign not really occuring */
 		    if (H5F_addr_defined(x)) {
 			sprintf(format_templ, "%%%s%s%s%s%s",
 				leftjust?"-":"", plussign?"+":"",
@@ -1095,7 +1094,7 @@ HDfprintf(FILE *stream, const char *fmt, ...)
 	    case 's':
 	    case 'p':
                 {
-		    char *x = va_arg (ap, char*);
+		    char *x = va_arg (ap, char*); /*lint !e64 Type mismatch not really occuring */
 		    n = fprintf (stream, format_templ, x);
 		}
 		break;
@@ -1564,7 +1563,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 	 * name is the null pointer then don't print the argument or the
 	 * following `='.  This is used for return values.
 	 */
-	argname = va_arg (ap, char*);
+	argname = va_arg (ap, char*); /*lint !e64 Type mismatch not really occuring */
 	if (argname) {
 	    unsigned n = (unsigned)MAX (0, (int)HDstrlen(argname)-3); /*lint !e666 Allow expression with side effects */
 	    if (!HDstrcmp (argname+n, "_id")) {
@@ -1578,7 +1577,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 	}
 
 	/* The value */
-	if (ptr) vp = va_arg (ap, void*);
+	if (ptr) vp = va_arg (ap, void*); /*lint !e64 Type mismatch not really occuring */
 	switch (type[0]) {
 	case 'a':
 	    if (ptr) {
@@ -1588,7 +1587,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 		    fprintf(out, "NULL");
 		}
 	    } else {
-		haddr_t addr = va_arg(ap, haddr_t);
+		haddr_t addr = va_arg(ap, haddr_t); /*lint !e732 Loss of sign not really occuring */
 		HDfprintf(out, "%a", addr);
 	    }
 	    break;
@@ -1601,7 +1600,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 		    fprintf(out, "NULL");
 		}
 	    } else {
-		hbool_t bool_var = va_arg (ap, hbool_t);
+		hbool_t bool_var = va_arg (ap, hbool_t); /*lint !e732 Loss of sign not really occuring */
 		if (TRUE==bool_var) fprintf (out, "TRUE");
 		else if (!bool_var) fprintf (out, "FALSE");
 		else fprintf (out, "TRUE(%u)", (unsigned)bool_var);
@@ -1631,7 +1630,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5D_alloc_time_t alloc_time = va_arg (ap, H5D_alloc_time_t);
+		    H5D_alloc_time_t alloc_time = va_arg (ap, H5D_alloc_time_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (alloc_time) {
 		    case H5D_ALLOC_TIME_ERROR:
 			fprintf (out, "H5D_ALLOC_TIME_ERROR");
@@ -1660,7 +1659,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5D_fill_time_t fill_time = va_arg (ap, H5D_fill_time_t);
+		    H5D_fill_time_t fill_time = va_arg (ap, H5D_fill_time_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (fill_time) {
 		    case H5D_FILL_TIME_ERROR:
 			fprintf (out, "H5D_FILL_TIME_ERROR");
@@ -1686,7 +1685,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5D_fill_value_t fill_value = va_arg (ap, H5D_fill_value_t);
+		    H5D_fill_value_t fill_value = va_arg (ap, H5D_fill_value_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (fill_value) {
 		    case H5D_FILL_VALUE_ERROR:
 			fprintf (out, "H5D_FILL_VALUE_ERROR");
@@ -1712,7 +1711,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5D_layout_t layout = va_arg (ap, H5D_layout_t);
+		    H5D_layout_t layout = va_arg (ap, H5D_layout_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (layout) {
 		    case H5D_LAYOUT_ERROR:
 			fprintf (out, "H5D_LAYOUT_ERROR");
@@ -1726,6 +1725,9 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 		    case H5D_CHUNKED:
 			fprintf (out, "H5D_CHUNKED");
 			break;
+		    case H5D_NLAYOUTS:
+			fprintf (out, "H5D_NLAYOUTS");
+			break;
 		    default:
 			fprintf (out, "%ld", (long)layout);
 			break;
@@ -1741,7 +1743,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5D_space_status_t space_status = va_arg(ap, H5D_space_status_t);
+		    H5D_space_status_t space_status = va_arg(ap, H5D_space_status_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (space_status) {
 		    case H5D_SPACE_STATUS_NOT_ALLOCATED:
 			fprintf (out, "H5D_SPACE_STATUS_NOT_ALLOCATED");
@@ -1752,6 +1754,9 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 		    case H5D_SPACE_STATUS_ALLOCATED:
 			fprintf (out, "H5D_SPACE_STATUS_ALLOCATED");
 			break;
+		    case H5D_SPACE_STATUS_ERROR:
+			fprintf (out, "H5D_SPACE_STATUS_ERROR");
+			break;
 		    default:
 			fprintf (out, "%ld", (long)space_status);
 			break;
@@ -1767,7 +1772,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5FD_mpio_xfer_t transfer = va_arg(ap, H5FD_mpio_xfer_t);
+		    H5FD_mpio_xfer_t transfer = va_arg(ap, H5FD_mpio_xfer_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (transfer) {
 		    case H5FD_MPIO_INDEPENDENT:
 			fprintf (out, "H5FD_MPIO_INDEPENDENT");
@@ -1812,7 +1817,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5E_direction_t direction = va_arg (ap, H5E_direction_t);
+		    H5E_direction_t direction = va_arg (ap, H5E_direction_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (direction) {
 		    case H5E_WALK_UPWARD:
 			fprintf (out, "H5E_WALK_UPWARD");
@@ -1835,7 +1840,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5E_error_t *error = va_arg (ap, H5E_error_t*);
+		    H5E_error_t *error = va_arg (ap, H5E_error_t*); /*lint !e64 Type mismatch not really occuring */
 		    fprintf (out, "0x%lx", (unsigned long)error);
 		}
 		break;
@@ -1848,7 +1853,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5E_type_t etype = va_arg (ap, H5E_type_t);
+		    H5E_type_t etype = va_arg (ap, H5E_type_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (etype) {
 		    case H5E_MAJOR:
 			fprintf (out, "H5E_MAJOR");
@@ -1879,7 +1884,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5F_close_degree_t degree = va_arg(ap, H5F_close_degree_t);
+		    H5F_close_degree_t degree = va_arg(ap, H5F_close_degree_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (degree) {
 		    case H5F_CLOSE_DEFAULT:
 			fprintf(out, "H5F_CLOSE_DEFAULT");
@@ -1905,7 +1910,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5F_scope_t scope = va_arg(ap, H5F_scope_t);
+		    H5F_scope_t scope = va_arg(ap, H5F_scope_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (scope) {
 		    case H5F_SCOPE_LOCAL:
 			fprintf(out, "H5F_SCOPE_LOCAL");
@@ -1937,7 +1942,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5G_link_t link_type = va_arg (ap, H5G_link_t);
+		    H5G_link_t link_type = va_arg (ap, H5G_link_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (link_type) {
 		    case H5G_LINK_ERROR:
 			fprintf (out, "H5G_LINK_ERROR");
@@ -1963,7 +1968,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5G_obj_t obj_type = va_arg (ap, H5G_obj_t);
+		    H5G_obj_t obj_type = va_arg (ap, H5G_obj_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (obj_type) {
 		    case H5G_UNKNOWN:
 			fprintf (out, "H5G_UNKNOWN");
@@ -1980,6 +1985,12 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 		    case H5G_TYPE:
 			fprintf (out, "H5G_TYPE");
 			break;
+		    case H5G_RESERVED_4:
+		    case H5G_RESERVED_5:
+		    case H5G_RESERVED_6:
+		    case H5G_RESERVED_7:
+			fprintf (out, "H5G_RESERVED(%ld)",(long)obj_type);
+			break;
 		    default:
 			fprintf (out, "%ld", (long)obj_type);
 			break;
@@ -1995,7 +2006,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5G_stat_t *statbuf = va_arg (ap, H5G_stat_t*);
+		    H5G_stat_t *statbuf = va_arg (ap, H5G_stat_t*); /*lint !e64 Type mismatch not really occuring */
 		    fprintf (out, "0x%lx", (unsigned long)statbuf);
 		}
 		break;
@@ -2026,7 +2037,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 		    fprintf(out, "NULL");
 		}
 	    } else {
-		hsize_t hsize = va_arg (ap, hsize_t);
+		hsize_t hsize = va_arg (ap, hsize_t); /*lint !e732 Loss of sign not really occuring */
 		if (H5S_UNLIMITED==hsize) {
 		    HDfprintf(out, "H5S_UNLIMITED");
 		} else {
@@ -2081,12 +2092,18 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 		    fprintf (out, "FAIL");
 		} else {
 		    switch (H5I_TYPE(obj)) { /* Use internal H5I macro instead of function call */
+                        case H5I_UNINIT:
+                            fprintf (out, "%ld (uninit - error)", (long)obj);
+                            break;
                         case H5I_BADID:
                             fprintf (out, "%ld (error)", (long)obj);
                             break;
                         case H5I_FILE:
                             fprintf(out, "%ld (file)", (long)obj);
                             break;
+                        case H5I_FILE_CLOSING:
+                            fprintf(out, "%ld (file closing)", (long)obj);
+                            break;
                         case H5I_GROUP:
                             fprintf(out, "%ld (group)", (long)obj);
                             break;
@@ -2219,6 +2236,9 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
                         case H5I_ERROR_STACK:
                             fprintf(out, "%ld (err stack)", (long)obj);
                             break;
+                        case H5I_NTYPES:
+                            fprintf (out, "%ld (ntypes - error)", (long)obj);
+                            break;
                         default:
                             fprintf(out, "%ld (unknown class)", (long)obj);
                             break;
@@ -2267,7 +2287,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    unsigned iu = va_arg (ap, unsigned);
+		    unsigned iu = va_arg (ap, unsigned); /*lint !e732 Loss of sign not really occuring */
 		    fprintf (out, "%u", iu);
 		    asize[argno] = iu;
 		}
@@ -2281,14 +2301,20 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5I_type_t id_type = va_arg (ap, H5I_type_t);
+		    H5I_type_t id_type = va_arg (ap, H5I_type_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (id_type) {
+		    case H5I_UNINIT:
+			fprintf (out, "H5I_UNINIT");
+			break;
 		    case H5I_BADID:
 			fprintf (out, "H5I_BADID");
 			break;
 		    case H5I_FILE:
 			fprintf (out, "H5I_FILE");
 			break;
+		    case H5I_FILE_CLOSING:
+			fprintf (out, "H5I_FILE_CLOSING");
+			break;
 		    case H5I_GROUP:
 			fprintf (out, "H5I_GROUP");
 			break;
@@ -2379,7 +2405,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5FD_mem_t mt = va_arg(ap, H5FD_mem_t);
+		    H5FD_mem_t mt = va_arg(ap, H5FD_mem_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (mt) {
 		    case H5FD_MEM_NOLIST:
 			fprintf(out, "H5FD_MEM_NOLIST");
@@ -2405,6 +2431,9 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 		    case H5FD_MEM_OHDR:
 			fprintf(out, "H5FD_MEM_OHDR");
 			break;
+		    case H5FD_MEM_NTYPES:
+			fprintf(out, "H5FD_MEM_NTYPES");
+			break;
 		    default:
 			fprintf(out, "%ld", (long)mt);
 			break;
@@ -2463,7 +2492,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
                     fprintf(out, "NULL");
                 }
 	    } else {
-                hobj_ref_t ref = va_arg (ap, hobj_ref_t);
+                hobj_ref_t ref = va_arg (ap, hobj_ref_t); /*lint !e732 Loss of sign not really occuring */
 		HDfprintf(out, "Reference Object=%a", ref);
 	    }
 	    break;
@@ -2478,7 +2507,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
                             fprintf(out, "NULL");
                         }
                     } else {
-                        H5R_type_t reftype = va_arg(ap, H5R_type_t);
+                        H5R_type_t reftype = va_arg(ap, H5R_type_t); /*lint !e64 Type mismatch not really occuring */
                         switch (reftype) {
                             case H5R_BADTYPE:
                                 fprintf(out, "H5R_BADTYPE");
@@ -2518,7 +2547,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5S_class_t cls = va_arg(ap, H5S_class_t);
+		    H5S_class_t cls = va_arg(ap, H5S_class_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (cls) {
                         case H5S_NO_CLASS:
                             fprintf(out, "H5S_NO_CLASS");
@@ -2529,6 +2558,9 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
                         case H5S_SIMPLE:
                             fprintf(out, "H5S_SIMPLE");
                             break;
+                        case H5S_NULL:
+                            fprintf(out, "H5S_NULL");
+                            break;
                         case H5S_COMPLEX:
                             fprintf(out, "H5S_COMPLEX");
                             break;
@@ -2547,7 +2579,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5S_seloper_t so = va_arg(ap, H5S_seloper_t);
+		    H5S_seloper_t so = va_arg(ap, H5S_seloper_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (so) {
                         case H5S_SELECT_NOOP:
                             fprintf(out, "H5S_NOOP");
@@ -2558,6 +2590,27 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
                         case H5S_SELECT_OR:
                             fprintf(out, "H5S_SELECT_OR");
                             break;
+                        case H5S_SELECT_AND:
+                            fprintf(out, "H5S_SELECT_AND");
+                            break;
+                        case H5S_SELECT_XOR:
+                            fprintf(out, "H5S_SELECT_XOR");
+                            break;
+                        case H5S_SELECT_NOTB:
+                            fprintf(out, "H5S_SELECT_NOTB");
+                            break;
+                        case H5S_SELECT_NOTA:
+                            fprintf(out, "H5S_SELECT_NOTA");
+                            break;
+                        case H5S_SELECT_APPEND:
+                            fprintf(out, "H5S_SELECT_APPEND");
+                            break;
+                        case H5S_SELECT_PREPEND:
+                            fprintf(out, "H5S_SELECT_PREPEND");
+                            break;
+                        case H5S_SELECT_INVALID:
+                            fprintf(out, "H5S_SELECT_INVALID");
+                            break;
                         default:
                             fprintf(out, "%ld", (long)so);
                             break;
@@ -2573,7 +2626,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
                         fprintf(out, "NULL");
                     }
                 } else {
-                    H5S_sel_type st = va_arg(ap, H5S_sel_type);
+                    H5S_sel_type st = va_arg(ap, H5S_sel_type); /*lint !e64 Type mismatch not really occuring */
                     switch (st) {
                     case H5S_SEL_ERROR:
                         fprintf(out, "H5S_SEL_ERROR");
@@ -2590,6 +2643,9 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
                     case H5S_SEL_ALL:
                         fprintf(out, "H5S_SEL_ALL");
                         break;
+                    case H5S_SEL_N:
+                        fprintf(out, "H5S_SEL_N");
+                        break;
                     default:
                         fprintf(out, "%ld", (long)st);
                         break;
@@ -2611,7 +2667,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 		    fprintf(out, "NULL");
 		}
 	    } else {
-		const char *str = va_arg (ap, const char*);
+		const char *str = va_arg (ap, const char*); /*lint !e64 Type mismatch not really occuring */
 		fprintf (out, "\"%s\"", str);
 	    }
 	    break;
@@ -2626,7 +2682,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5T_cset_t cset = va_arg (ap, H5T_cset_t);
+		    H5T_cset_t cset = va_arg (ap, H5T_cset_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (cset) {
                         case H5T_CSET_ERROR:
                             fprintf (out, "H5T_CSET_ERROR");
@@ -2634,6 +2690,23 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
                         case H5T_CSET_ASCII:
                             fprintf (out, "H5T_CSET_ASCII");
                             break;
+                        case H5T_CSET_RESERVED_1:
+                        case H5T_CSET_RESERVED_2:
+                        case H5T_CSET_RESERVED_3:
+                        case H5T_CSET_RESERVED_4:
+                        case H5T_CSET_RESERVED_5:
+                        case H5T_CSET_RESERVED_6:
+                        case H5T_CSET_RESERVED_7:
+                        case H5T_CSET_RESERVED_8:
+                        case H5T_CSET_RESERVED_9:
+                        case H5T_CSET_RESERVED_10:
+                        case H5T_CSET_RESERVED_11:
+                        case H5T_CSET_RESERVED_12:
+                        case H5T_CSET_RESERVED_13:
+                        case H5T_CSET_RESERVED_14:
+                        case H5T_CSET_RESERVED_15:
+                            fprintf (out, "H5T_CSET_RESERVED(%ld)",(long)cset);
+                            break;
                         default:
                             fprintf (out, "%ld", (long)cset);
                             break;
@@ -2649,7 +2722,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5T_direction_t direct = va_arg (ap, H5T_direction_t);
+		    H5T_direction_t direct = va_arg (ap, H5T_direction_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (direct) {
                         case H5T_DIR_DEFAULT:
                             fprintf (out, "H5T_DIR_DEFAULT");
@@ -2675,7 +2748,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5T_pers_t pers = va_arg(ap, H5T_pers_t);
+		    H5T_pers_t pers = va_arg(ap, H5T_pers_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (pers) {
                         case H5T_PERS_DONTCARE:
                             fprintf(out, "H5T_PERS_DONTCARE");
@@ -2701,7 +2774,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5T_norm_t norm = va_arg (ap, H5T_norm_t);
+		    H5T_norm_t norm = va_arg (ap, H5T_norm_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (norm) {
                         case H5T_NORM_ERROR:
                             fprintf (out, "H5T_NORM_ERROR");
@@ -2730,7 +2803,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5T_order_t order = va_arg (ap, H5T_order_t);
+		    H5T_order_t order = va_arg (ap, H5T_order_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (order) {
                         case H5T_ORDER_ERROR:
                             fprintf (out, "H5T_ORDER_ERROR");
@@ -2762,7 +2835,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5T_pad_t pad = va_arg (ap, H5T_pad_t);
+		    H5T_pad_t pad = va_arg (ap, H5T_pad_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (pad) {
                         case H5T_PAD_ERROR:
                             fprintf (out, "H5T_PAD_ERROR");
@@ -2776,6 +2849,9 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
                         case H5T_PAD_BACKGROUND:
                             fprintf (out, "H5T_PAD_BACKGROUND");
                             break;
+                        case H5T_NPAD:
+                            fprintf (out, "H5T_NPAD");
+                            break;
                         default:
                             fprintf (out, "%ld", (long)pad);
                             break;
@@ -2791,7 +2867,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5T_sign_t sign = va_arg (ap, H5T_sign_t);
+		    H5T_sign_t sign = va_arg (ap, H5T_sign_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (sign) {
                         case H5T_SGN_ERROR:
                             fprintf (out, "H5T_SGN_ERROR");
@@ -2802,6 +2878,9 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
                         case H5T_SGN_2:
                             fprintf (out, "H5T_SGN_2");
                             break;
+                        case H5T_NSGN:
+                            fprintf (out, "H5T_NSGN");
+                            break;
                         default:
                             fprintf (out, "%ld", (long)sign);
                             break;
@@ -2817,7 +2896,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5T_class_t type_class = va_arg(ap, H5T_class_t);
+		    H5T_class_t type_class = va_arg(ap, H5T_class_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (type_class) {
                         case H5T_NO_CLASS:
                             fprintf(out, "H5T_NO_CLASS");
@@ -2843,9 +2922,21 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
                         case H5T_COMPOUND:
                             fprintf(out, "H5T_COMPOUND");
                             break;
+                        case H5T_REFERENCE:
+                            fprintf(out, "H5T_REFERENCE");
+                            break;
                         case H5T_ENUM:
                             fprintf(out, "H5T_ENUM");
                             break;
+                        case H5T_VLEN:
+                            fprintf(out, "H5T_VLEN");
+                            break;
+                        case H5T_ARRAY:
+                            fprintf(out, "H5T_ARRAY");
+                            break;
+                        case H5T_NCLASSES:
+                            fprintf(out, "H5T_NCLASSES");
+                            break;
                         default:
                             fprintf(out, "%ld", (long)type_class);
                             break;
@@ -2861,7 +2952,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 			fprintf(out, "NULL");
 		    }
 		} else {
-		    H5T_str_t str = va_arg(ap, H5T_str_t);
+		    H5T_str_t str = va_arg(ap, H5T_str_t); /*lint !e64 Type mismatch not really occuring */
 		    switch (str) {
                         case H5T_STR_ERROR:
                             fprintf(out, "H5T_STR_ERROR");
@@ -2875,6 +2966,21 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
                         case H5T_STR_SPACEPAD:
                             fprintf(out, "H5T_STR_SPACEPAD");
                             break;
+                        case H5T_STR_RESERVED_3:
+                        case H5T_STR_RESERVED_4:
+                        case H5T_STR_RESERVED_5:
+                        case H5T_STR_RESERVED_6:
+                        case H5T_STR_RESERVED_7:
+                        case H5T_STR_RESERVED_8:
+                        case H5T_STR_RESERVED_9:
+                        case H5T_STR_RESERVED_10:
+                        case H5T_STR_RESERVED_11:
+                        case H5T_STR_RESERVED_12:
+                        case H5T_STR_RESERVED_13:
+                        case H5T_STR_RESERVED_14:
+                        case H5T_STR_RESERVED_15:
+                            fprintf(out, "H5T_STR_RESERVED(%ld)",(long)str);
+                            break;
                         default:
                             fprintf(out, "%ld", (long)str);
                             break;
@@ -2924,7 +3030,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 		    fprintf(out, "NULL");
 		}
 	    } else {
-		vp = va_arg (ap, void*);
+		vp = va_arg (ap, void*); /*lint !e64 Type mismatch not really occuring */
 		if (vp) {
 		    fprintf (out, "0x%lx", (unsigned long)vp);
 		} else {
@@ -2949,7 +3055,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
 		    fprintf(out, "NULL");
 		}
 	    } else {
-		size_t size = va_arg (ap, size_t);
+		size_t size = va_arg (ap, size_t); /*lint !e732 Loss of sign not really occuring */
 
 		HDfprintf (out, "%Zu", size);
 		asize[argno] = (hssize_t)size;
@@ -2966,7 +3072,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
                             fprintf(out, "NULL");
                         }
                     } else {
-                        H5Z_class_t *filter = va_arg (ap, H5Z_class_t*);
+                        H5Z_class_t *filter = va_arg (ap, H5Z_class_t*); /*lint !e64 Type mismatch not really occuring */
                         fprintf (out, "0x%lx", (unsigned long)filter);
                     }
                     break;
@@ -2979,7 +3085,7 @@ H5_trace (const double *returning, const char *func, const char *type, ...)
                             fprintf(out, "NULL");
                         }
                     } else {
-                        H5Z_EDC_t edc = va_arg (ap, H5Z_EDC_t);
+                        H5Z_EDC_t edc = va_arg (ap, H5Z_EDC_t); /*lint !e64 Type mismatch not really occuring */
 
                         if (H5Z_DISABLE_EDC==edc) {
                             fprintf (out, "H5Z_DISABLE_EDC");