Merge develop

1 files changed, 532 insertions, 33 deletions

diff --git a/src/H5trace.c b/src/H5trace.c
index b1301dd..ec5c6a2 100644
--- a/src/H5trace.c
+++ b/src/H5trace.c
@@ -34,6 +34,7 @@
 #include "H5Dprivate.h"     /* Datasets                                 */
 #include "H5Eprivate.h"     /* Error handling                           */
 #include "H5FDprivate.h"    /* File drivers                             */
+#include "H5Rprivate.h"     /* References                               */
 #include "H5Ipkg.h"         /* IDs                                      */
 #include "H5MMprivate.h"    /* Memory management                        */
 #include "H5VLprivate.h"    /* Virtual Object Layer                     */
@@ -154,7 +155,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
     } /* end if */
 
     /* Get time for event */
-    if(H5_DBL_ABS_EQUAL(first_time.etime, H5_DOUBLE(0.0)))
+    if(H5_DBL_ABS_EQUAL(first_time.etime, 0.0))
         H5_timer_begin(&first_time);
     if(H5_debug_g.ttimes)
         H5_timer_begin(&event_time);
@@ -1629,6 +1630,22 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                 } /* end switch */
                 break;
 
+            case 'k':
+                if(ptr) {
+                    if(vp)
+                        HDfprintf(out, "0x%lx", (unsigned long)vp);
+                    else
+                        HDfprintf(out, "NULL");
+                } /* end if */
+                else {
+                    H5O_token_t token = HDva_arg(ap, H5O_token_t);
+                    int j;
+
+                    for (j = 0; j < H5O_MAX_TOKEN_SIZE; j++)
+                        HDfprintf(out, "%02x", token.__data[j]);
+                } /* end else */
+                break;
+
             case 'L':
                 switch(type[1]) {
                     case 'l':
@@ -1856,22 +1873,51 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                 } /* end else */
                 break;
 
-            case 'r':
-                if(ptr) {
-                    if(vp)
-                        HDfprintf(out, "0x%lx", (unsigned long)vp);
-                    else
-                        HDfprintf(out, "NULL");
-                } /* end if */
-                else {
-                    hobj_ref_t ref = HDva_arg(ap, hobj_ref_t);
-
-                    HDfprintf(out, "Reference Object=%a", ref);
-                } /* end else */
-                break;
-
             case 'R':
                 switch(type[1]) {
+
+                    case 'o':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf(out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            hobj_ref_t ref = HDva_arg(ap, hobj_ref_t);
+
+                            HDfprintf(out, "Reference Object=%a", ref);
+                        } /* end else */
+                        break;
+
+                    case 'd':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf(out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            /* Note! region references are array types */
+                            HDfprintf(out, "Reference Region");
+                            goto error;
+                        } /* end else */
+                        break;
+
+                    case 'r':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf(out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            /* Note! reference types are opaque types */
+                            HDfprintf(out, "Reference Opaque");
+                            goto error;
+                        } /* end else */
+                        break;
+
                     case 't':
                         if(ptr) {
                             if(vp)
@@ -1887,12 +1933,24 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                                     HDfprintf(out, "H5R_BADTYPE");
                                     break;
 
-                                case H5R_OBJECT:
-                                    HDfprintf(out, "H5R_OBJECT");
+                                case H5R_OBJECT1:
+                                    HDfprintf(out, "H5R_OBJECT1");
                                     break;
 
-                                case H5R_DATASET_REGION:
-                                    HDfprintf(out, "H5R_DATASET_REGION");
+                                case H5R_DATASET_REGION1:
+                                    HDfprintf(out, "H5R_DATASET_REGION1");
+                                    break;
+
+                                case H5R_OBJECT2:
+                                    HDfprintf(out, "H5R_OBJECT2");
+                                    break;
+
+                                case H5R_DATASET_REGION2:
+                                    HDfprintf(out, "H5R_DATASET_REGION2");
+                                    break;
+
+                                case H5R_ATTR:
+                                    HDfprintf(out, "H5R_ATTR");
                                     break;
 
                                 case H5R_MAXTYPE:
@@ -2563,6 +2621,25 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
+                    case 'A':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_blob_optional_t optional = (H5VL_blob_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
                     case 'b':
                         if(ptr) {
                             if(vp)
@@ -2592,6 +2669,37 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
+                    case 'B':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_blob_specific_t specific = (H5VL_blob_specific_t)HDva_arg(ap, int);
+
+                            switch(specific) {
+                                case H5VL_BLOB_DELETE:
+                                    HDfprintf(out, "H5VL_BLOB_DELETE");
+                                    break;
+                                case H5VL_BLOB_GETSIZE:
+                                    HDfprintf(out, "H5VL_BLOB_GETSIZE");
+                                    break;
+                                case H5VL_BLOB_ISNULL:
+                                    HDfprintf(out, "H5VL_BLOB_ISNULL");
+                                    break;
+                                case H5VL_BLOB_SETNULL:
+                                    HDfprintf(out, "H5VL_BLOB_SETNULL");
+                                    break;
+                                default:
+                                    HDfprintf(out, "%ld", (long)specific);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
                     case 'C':
                         if(ptr) {
                             if(vp)
@@ -2608,6 +2716,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                                 HDfprintf(out, "%ld", (long)class_val);
                         } /* end else */
                         break;
+
                     case 'c':
                         if(ptr) {
                             if(vp)
@@ -2646,6 +2755,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'd':
                         if(ptr) {
                             if(vp)
@@ -2672,6 +2782,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'e':
                         if(ptr) {
                             if(vp)
@@ -2695,6 +2806,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'f':
                         if(ptr) {
                             if(vp)
@@ -2718,6 +2830,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'g':
                         if(ptr) {
                             if(vp)
@@ -2729,18 +2842,21 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             H5VL_file_get_t get = (H5VL_file_get_t)HDva_arg(ap, int);
 
                             switch(get) {
+                                case H5VL_FILE_GET_CONT_INFO:
+                                    HDfprintf(out, "H5VL_FILE_GET_CONT_INFO");
+                                    break;
                                 case H5VL_FILE_GET_FAPL:
                                     HDfprintf(out, "H5VL_FILE_GET_FAPL");
                                     break;
                                 case H5VL_FILE_GET_FCPL:
                                     HDfprintf(out, "H5VL_FILE_GET_FCPL");
                                     break;
-                                case H5VL_FILE_GET_INTENT:
-                                    HDfprintf(out, "H5VL_FILE_GET_INTENT");
-                                    break;
                                 case H5VL_FILE_GET_FILENO:
                                     HDfprintf(out, "H5VL_FILE_GET_FILENO");
                                     break;
+                                case H5VL_FILE_GET_INTENT:
+                                    HDfprintf(out, "H5VL_FILE_GET_INTENT");
+                                    break;
                                 case H5VL_FILE_GET_NAME:
                                     HDfprintf(out, "H5VL_FILE_GET_NAME");
                                     break;
@@ -2756,6 +2872,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'h':
                         if(ptr) {
                             if(vp)
@@ -2785,12 +2902,16 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                                 case H5VL_FILE_DELETE:
                                     HDfprintf(out, "H5VL_FILE_DELETE");
                                     break;
+                                case H5VL_FILE_IS_EQUAL:
+                                    HDfprintf(out, "H5VL_FILE_IS_EQUAL");
+                                    break;
                                 default:
                                     HDfprintf(out, "%ld", (long)specific);
                                     break;
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'i':
                         if(ptr) {
                             if(vp)
@@ -2814,6 +2935,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'j':
                         if(ptr) {
                             if(vp)
@@ -2837,6 +2959,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'k':
                         if(ptr) {
                             if(vp)
@@ -2863,6 +2986,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'l':
                         if(ptr) {
                             if(vp)
@@ -2889,6 +3013,31 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
+                    case 'L':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_get_conn_lvl_t get = (H5VL_get_conn_lvl_t)HDva_arg(ap, int);
+
+                            switch(get) {
+                                case H5VL_GET_CONN_LVL_CURR:
+                                    HDfprintf(out, "H5VL_GET_CONN_LVL_CURR");
+                                    break;
+                                case H5VL_GET_CONN_LVL_TERM:
+                                    HDfprintf(out, "H5VL_GET_CONN_LVL_TERM");
+                                    break;
+                                default:
+                                    HDfprintf(out, "%ld", (long)get);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
                     case 'm':
                         if(ptr) {
                             if(vp)
@@ -2915,6 +3064,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'n':
                         if(ptr) {
                             if(vp)
@@ -2926,24 +3076,25 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             H5VL_object_get_t get = (H5VL_object_get_t)HDva_arg(ap, int);
 
                             switch(get) {
-                                case H5VL_REF_GET_REGION:
-                                    HDfprintf(out, "H5VL_REF_GET_REGION");
-                                    break;
-                                case H5VL_REF_GET_TYPE:
-                                    HDfprintf(out, "H5VL_REF_GET_TYPE");
-                                    break;
-                                case H5VL_REF_GET_NAME:
-                                    HDfprintf(out, "H5VL_REF_GET_NAME");
+                                case H5VL_OBJECT_GET_FILE:
+                                    HDfprintf(out, "H5VL_OBJECT_GET_FILE");
                                     break;
                                 case H5VL_OBJECT_GET_NAME:
                                     HDfprintf(out, "H5VL_OBJECT_GET_NAME");
                                     break;
+                                case H5VL_OBJECT_GET_TYPE:
+                                    HDfprintf(out, "H5VL_OBJECT_GET_TYPE");
+                                    break;
+                                case H5VL_OBJECT_GET_INFO:
+                                    HDfprintf(out, "H5VL_OBJECT_GET_INFO");
+                                    break;
                                 default:
                                     HDfprintf(out, "%ld", (long)get);
                                     break;
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'o':
                         if(ptr) {
                             if(vp)
@@ -2961,12 +3112,12 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                                 case H5VL_OBJECT_EXISTS:
                                     HDfprintf(out, "H5VL_OBJECT_EXISTS");
                                     break;
+                                case H5VL_OBJECT_LOOKUP:
+                                    HDfprintf(out, "H5VL_OBJECT_LOOKUP");
+                                    break;
                                 case H5VL_OBJECT_VISIT:
                                     HDfprintf(out, "H5VL_OBJECT_VISIT");
                                     break;
-                                case H5VL_REF_CREATE:
-                                    HDfprintf(out, "H5VL_REF_CREATE");
-                                    break;
                                 case H5VL_OBJECT_FLUSH:
                                     HDfprintf(out, "H5VL_OBJECT_FLUSH");
                                     break;
@@ -2979,6 +3130,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'r':
                         if(ptr) {
                             if(vp)
@@ -3005,6 +3157,353 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
+                    case 's':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_attr_optional_t optional = (H5VL_attr_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+#ifndef H5_NO_DEPRECATED_SYMBOLS
+                                case H5VL_NATIVE_ATTR_ITERATE_OLD:
+                                    HDfprintf(out, "H5VL_NATIVE_ATTR_ITERATE_OLD");
+                                    break;
+#endif /* H5_NO_DEPRECATED_SYMBOLS */
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 'S':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_subclass_t subclass = (H5VL_subclass_t)HDva_arg(ap, int);
+
+                            switch(subclass) {
+                                case H5VL_SUBCLS_NONE:
+                                    HDfprintf(out, "H5VL_SUBCLS_NONE");
+                                    break;
+                                case H5VL_SUBCLS_INFO:
+                                    HDfprintf(out, "H5VL_SUBCLS_INFO");
+                                    break;
+                                case H5VL_SUBCLS_WRAP:
+                                    HDfprintf(out, "H5VL_SUBCLS_WRAP");
+                                    break;
+                                case H5VL_SUBCLS_ATTR:
+                                    HDfprintf(out, "H5VL_SUBCLS_ATTR");
+                                    break;
+                                case H5VL_SUBCLS_DATASET:
+                                    HDfprintf(out, "H5VL_SUBCLS_DATASET");
+                                    break;
+                                case H5VL_SUBCLS_DATATYPE:
+                                    HDfprintf(out, "H5VL_SUBCLS_DATATYPE");
+                                    break;
+                                case H5VL_SUBCLS_FILE:
+                                    HDfprintf(out, "H5VL_SUBCLS_FILE");
+                                    break;
+                                case H5VL_SUBCLS_GROUP:
+                                    HDfprintf(out, "H5VL_SUBCLS_GROUP");
+                                    break;
+                                case H5VL_SUBCLS_LINK:
+                                    HDfprintf(out, "H5VL_SUBCLS_LINK");
+                                    break;
+                                case H5VL_SUBCLS_OBJECT:
+                                    HDfprintf(out, "H5VL_SUBCLS_OBJECT");
+                                    break;
+                                case H5VL_SUBCLS_REQUEST:
+                                    HDfprintf(out, "H5VL_SUBCLS_REQUEST");
+                                    break;
+                                case H5VL_SUBCLS_BLOB:
+                                    HDfprintf(out, "H5VL_SUBCLS_BLOB");
+                                    break;
+                                case H5VL_SUBCLS_TOKEN:
+                                    HDfprintf(out, "H5VL_SUBCLS_TOKEN");
+                                    break;
+                                default:
+                                    HDfprintf(out, "%ld", (long)subclass);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 't':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_dataset_optional_t optional = (H5VL_dataset_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+                                case H5VL_NATIVE_DATASET_FORMAT_CONVERT:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_FORMAT_CONVERT");
+                                    break;
+                                case H5VL_NATIVE_DATASET_GET_CHUNK_INDEX_TYPE:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_GET_CHUNK_INDEX_TYPE");
+                                    break;
+                                case H5VL_NATIVE_DATASET_GET_CHUNK_STORAGE_SIZE:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_GET_CHUNK_STORAGE_SIZE");
+                                    break;
+                                case H5VL_NATIVE_DATASET_GET_NUM_CHUNKS:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_GET_NUM_CHUNKS");
+                                    break;
+                                case H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_IDX:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_IDX");
+                                    break;
+                                case H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_COORD:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_COORD");
+                                    break;
+                                case H5VL_NATIVE_DATASET_CHUNK_READ:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_CHUNK_READ");
+                                    break;
+                                case H5VL_NATIVE_DATASET_CHUNK_WRITE:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_CHUNK_WRITE");
+                                    break;
+                                case H5VL_NATIVE_DATASET_GET_VLEN_BUF_SIZE:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_GET_VLEN_BUF_SIZE");
+                                    break;
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 'u':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_datatype_optional_t optional = (H5VL_datatype_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 'v':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_file_optional_t optional = (H5VL_file_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+                                case H5VL_NATIVE_FILE_CLEAR_ELINK_CACHE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_CLEAR_ELINK_CACHE");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_FILE_IMAGE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_FILE_IMAGE");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_FREE_SECTIONS:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_FREE_SECTIONS");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_FREE_SPACE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_FREE_SPACE");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_INFO:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_INFO");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_MDC_CONF:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_MDC_CONF");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_MDC_HR:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_MDC_HR");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_MDC_SIZE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_MDC_SIZE");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_SIZE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_SIZE");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_VFD_HANDLE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_VFD_HANDLE");
+                                    break;
+                                case H5VL_NATIVE_FILE_RESET_MDC_HIT_RATE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_RESET_MDC_HIT_RATE");
+                                    break;
+                                case H5VL_NATIVE_FILE_SET_MDC_CONFIG:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_SET_MDC_CONFIG");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_METADATA_READ_RETRY_INFO:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_METADATA_READ_RETRY_INFO");
+                                    break;
+                                case H5VL_NATIVE_FILE_START_SWMR_WRITE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_START_SWMR_WRITE");
+                                    break;
+                                case H5VL_NATIVE_FILE_START_MDC_LOGGING:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_START_MDC_LOGGING");
+                                    break;
+                                case H5VL_NATIVE_FILE_STOP_MDC_LOGGING:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_STOP_MDC_LOGGING");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_MDC_LOGGING_STATUS:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_MDC_LOGGING_STATUS");
+                                    break;
+                                case H5VL_NATIVE_FILE_FORMAT_CONVERT:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_FORMAT_CONVERT");
+                                    break;
+                                case H5VL_NATIVE_FILE_RESET_PAGE_BUFFERING_STATS:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_RESET_PAGE_BUFFERING_STATS");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_PAGE_BUFFERING_STATS:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_PAGE_BUFFERING_STATS");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_MDC_IMAGE_INFO:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_MDC_IMAGE_INFO");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_EOA:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_EOA");
+                                    break;
+                                case H5VL_NATIVE_FILE_INCR_FILESIZE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_INCR_FILESIZE");
+                                    break;
+                                case H5VL_NATIVE_FILE_SET_LIBVER_BOUNDS:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_SET_LIBVER_BOUNDS");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_MIN_DSET_OHDR_FLAG:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_MIN_DSET_OHDR_FLAG");
+                                    break;
+                                case H5VL_NATIVE_FILE_SET_MIN_DSET_OHDR_FLAG:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_SET_MIN_DSET_OHDR_FLAG");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_MPI_ATOMICITY:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_MPI_ATOMICITY");
+                                    break;
+                                case H5VL_NATIVE_FILE_SET_MPI_ATOMICITY:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_SET_MPI_ATOMICITY");
+                                    break;
+                                case H5VL_NATIVE_FILE_POST_OPEN:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_POST_OPEN");
+                                    break;
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 'w':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_group_optional_t optional = (H5VL_group_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+#ifndef H5_NO_DEPRECATED_SYMBOLS
+                                case H5VL_NATIVE_GROUP_ITERATE_OLD:
+                                    HDfprintf(out, "H5VL_NATIVE_GROUP_ITERATE_OLD");
+                                    break;
+                                case H5VL_NATIVE_GROUP_GET_OBJINFO:
+                                    HDfprintf(out, "H5VL_NATIVE_GROUP_GET_OBJINFO");
+                                    break;
+#endif /* H5_NO_DEPRECATED_SYMBOLS */
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 'x':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_link_optional_t optional = (H5VL_link_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 'y':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_object_optional_t optional = (H5VL_object_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+                                case H5VL_NATIVE_OBJECT_GET_COMMENT:
+                                    HDfprintf(out, "H5VL_NATIVE_OBJECT_GET_COMMENT");
+                                    break;
+                                case H5VL_NATIVE_OBJECT_SET_COMMENT:
+                                    HDfprintf(out, "H5VL_NATIVE_OBJECT_SET_COMMENT");
+                                    break;
+                                case H5VL_NATIVE_OBJECT_DISABLE_MDC_FLUSHES:
+                                    HDfprintf(out, "H5VL_NATIVE_OBJECT_DISABLE_MDC_FLUSHES");
+                                    break;
+                                case H5VL_NATIVE_OBJECT_ENABLE_MDC_FLUSHES:
+                                    HDfprintf(out, "H5VL_NATIVE_OBJECT_ENABLE_MDC_FLUSHES");
+                                    break;
+                                case H5VL_NATIVE_OBJECT_ARE_MDC_FLUSHES_DISABLED:
+                                    HDfprintf(out, "H5VL_NATIVE_OBJECT_ARE_MDC_FLUSHES_DISABLED");
+                                    break;
+                                case H5VL_NATIVE_OBJECT_GET_NATIVE_INFO:
+                                    HDfprintf(out, "H5VL_NATIVE_OBJECT_GET_NATIVE_INFO");
+                                    break;
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 'z':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_request_optional_t optional = (H5VL_request_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
                     default:
                         HDfprintf(out, "BADTYPE(Z%c)", type[1]);
                         goto error;