layers: Actual auto-gen of print helper code used by layers

7 files changed, 38 insertions, 2799 deletions

diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt
index 5f5e9595..c37fd921 100644
--- a/layers/CMakeLists.txt
+++ b/layers/CMakeLists.txt
@@ -1,9 +1,12 @@
 cmake_minimum_required (VERSION 2.8.11)
 
-add_custom_command(OUTPUT generic_layer.c
+add_custom_command(OUTPUT generic_layer.c xgl_enum_string_helper.h xgl_struct_string_helper.h
 	COMMAND ${PROJECT_SOURCE_DIR}/xgl-generate.py generic-layer > generic_layer.c
+        COMMAND ${PROJECT_SOURCE_DIR}/xgl-helper.py --gen_enum_string_helper ${PROJECT_SOURCE_DIR}/include/xgl.h --abs_out_dir ${PROJECT_SOURCE_DIR}/layers
+        COMMAND ${PROJECT_SOURCE_DIR}/xgl-helper.py --gen_struct_wrappers ${PROJECT_SOURCE_DIR}/include/xgl.h --abs_out_dir ${PROJECT_SOURCE_DIR}/layers
 	           DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py
-	                   ${PROJECT_SOURCE_DIR}/xgl.py)
+	                   ${PROJECT_SOURCE_DIR}/xgl-helper.py
+                           ${PROJECT_SOURCE_DIR}/xgl.py)
 
 # TODO : With standard settings below we get warnings as error due to unused functions.
 #set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I ../include")
@@ -11,7 +14,8 @@ set (CMAKE_C_FLAGS "-std=c99 -Wextra -Wno-sign-compare -Wno-unused-parameter -I
 
 add_library (XGLLayerBasic SHARED basic_plugin.c)
 add_library (XGLLayerGeneric SHARED generic_layer.c)
-add_library (XGLLayerObjectTrack SHARED object_track.c)
-add_library (XGLLayerAPIDump SHARED api_dump.c)
+add_library (XGLLayerObjectTracker SHARED object_track.c)
+add_library (XGLLayerAPIDump SHARED api_dump.c xgl_enum_string_helper.h xgl_struct_string_helper.h)
+add_library (XGLLayerAPIFileDump SHARED api_file_dump.c)
 add_library (XGLLayerDrawState SHARED draw_state.c)
-
+add_library (XGLLayerMemTracker SHARED mem_tracker.c)
diff --git a/layers/api_dump.c b/layers/api_dump.c
index 7896544d..40cd497a 100644
--- a/layers/api_dump.c
+++ b/layers/api_dump.c
@@ -28,7 +28,6 @@
 #include <assert.h>
 #include <pthread.h>
 #include "xglLayer.h"
-#include "xgl_string_helper.h"
 #include "xgl_struct_string_helper.h"
 
 static XGL_LAYER_DISPATCH_TABLE nextTable;
diff --git a/layers/api_file_dump.c b/layers/api_file_dump.c
index 721d12b6..8ac75572 100644
--- a/layers/api_file_dump.c
+++ b/layers/api_file_dump.c
@@ -30,7 +30,6 @@
 #include <assert.h>
 #include <pthread.h>
 #include "xglLayer.h"
-#include "xgl_string_helper.h"
 #include "xgl_struct_string_helper.h"
 
 static XGL_LAYER_DISPATCH_TABLE nextTable;
diff --git a/layers/draw_state.c b/layers/draw_state.c
index 8a2e4c78..3da17624 100644
--- a/layers/draw_state.c
+++ b/layers/draw_state.c
@@ -28,7 +28,6 @@
 #include <assert.h>
 #include <pthread.h>
 #include "xglLayer.h"
-#include "xgl_string_helper.h"
 #include "xgl_struct_string_helper.h"
 
 static XGL_LAYER_DISPATCH_TABLE nextTable;
diff --git a/layers/xgl_string_helper.h b/layers/xgl_string_helper.h
deleted file mode 100644
index f1edc905..00000000
--- a/layers/xgl_string_helper.h
+++ /dev/null
@@ -1,1770 +0,0 @@
-#pragma once
-
-#include <xgl.h>
-
-static const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
-{
-    switch ((XGL_MEMORY_PRIORITY)input_value)
-    {
-
-    case XGL_MEMORY_PRIORITY_HIGH:
-        return "XGL_MEMORY_PRIORITY_HIGH";
-
-    case XGL_MEMORY_PRIORITY_LOW:
-        return "XGL_MEMORY_PRIORITY_LOW";
-
-    case XGL_MEMORY_PRIORITY_NORMAL:
-        return "XGL_MEMORY_PRIORITY_NORMAL";
-
-    case XGL_MEMORY_PRIORITY_UNUSED:
-        return "XGL_MEMORY_PRIORITY_UNUSED";
-
-    case XGL_MEMORY_PRIORITY_VERY_HIGH:
-        return "XGL_MEMORY_PRIORITY_VERY_HIGH";
-
-    case XGL_MEMORY_PRIORITY_VERY_LOW:
-        return "XGL_MEMORY_PRIORITY_VERY_LOW";
-
-    default:
-        return "Unhandled XGL_MEMORY_PRIORITY";
-    }
-    return "Unhandled XGL_MEMORY_PRIORITY";
-}
-
-
-static const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
-{
-    switch ((XGL_IMAGE_ASPECT)input_value)
-    {
-
-    case XGL_IMAGE_ASPECT_COLOR:
-        return "XGL_IMAGE_ASPECT_COLOR";
-
-    case XGL_IMAGE_ASPECT_DEPTH:
-        return "XGL_IMAGE_ASPECT_DEPTH";
-
-    case XGL_IMAGE_ASPECT_STENCIL:
-        return "XGL_IMAGE_ASPECT_STENCIL";
-
-    default:
-        return "Unhandled XGL_IMAGE_ASPECT";
-    }
-    return "Unhandled XGL_IMAGE_ASPECT";
-}
-
-
-static const char* string_XGL_NUM_FORMAT(XGL_NUM_FORMAT input_value)
-{
-    switch ((XGL_NUM_FORMAT)input_value)
-    {
-
-    case XGL_NUM_FMT_DS:
-        return "XGL_NUM_FMT_DS";
-
-    case XGL_NUM_FMT_FLOAT:
-        return "XGL_NUM_FMT_FLOAT";
-
-    case XGL_NUM_FMT_SINT:
-        return "XGL_NUM_FMT_SINT";
-
-    case XGL_NUM_FMT_SNORM:
-        return "XGL_NUM_FMT_SNORM";
-
-    case XGL_NUM_FMT_SRGB:
-        return "XGL_NUM_FMT_SRGB";
-
-    case XGL_NUM_FMT_UINT:
-        return "XGL_NUM_FMT_UINT";
-
-    case XGL_NUM_FMT_UNDEFINED:
-        return "XGL_NUM_FMT_UNDEFINED";
-
-    case XGL_NUM_FMT_UNORM:
-        return "XGL_NUM_FMT_UNORM";
-
-    default:
-        return "Unhandled XGL_NUM_FORMAT";
-    }
-    return "Unhandled XGL_NUM_FORMAT";
-}
-
-
-static const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
-{
-    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
-    {
-
-    case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
-        return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
-
-    default:
-        return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
-    }
-    return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
-}
-
-
-static const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
-{
-    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
-    {
-
-    case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
-        return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
-
-    case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
-        return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
-
-    case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
-        return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
-
-    case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
-        return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
-
-    default:
-        return "Unhandled XGL_IMAGE_USAGE_FLAGS";
-    }
-    return "Unhandled XGL_IMAGE_USAGE_FLAGS";
-}
-
-
-static const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
-{
-    switch ((XGL_TEX_FILTER)input_value)
-    {
-
-    case XGL_TEX_FILTER_LINEAR:
-        return "XGL_TEX_FILTER_LINEAR";
-
-    case XGL_TEX_FILTER_NEAREST:
-        return "XGL_TEX_FILTER_NEAREST";
-
-    default:
-        return "Unhandled XGL_TEX_FILTER";
-    }
-    return "Unhandled XGL_TEX_FILTER";
-}
-
-
-static const char* string_XGL_DESCRIPTOR_SET_SLOT_TYPE(XGL_DESCRIPTOR_SET_SLOT_TYPE input_value)
-{
-    switch ((XGL_DESCRIPTOR_SET_SLOT_TYPE)input_value)
-    {
-
-    case XGL_SLOT_NEXT_DESCRIPTOR_SET:
-        return "XGL_SLOT_NEXT_DESCRIPTOR_SET";
-
-    case XGL_SLOT_SHADER_RESOURCE:
-        return "XGL_SLOT_SHADER_RESOURCE";
-
-    case XGL_SLOT_SHADER_SAMPLER:
-        return "XGL_SLOT_SHADER_SAMPLER";
-
-    case XGL_SLOT_SHADER_UAV:
-        return "XGL_SLOT_SHADER_UAV";
-
-    case XGL_SLOT_UNUSED:
-        return "XGL_SLOT_UNUSED";
-
-    default:
-        return "Unhandled XGL_DESCRIPTOR_SET_SLOT_TYPE";
-    }
-    return "Unhandled XGL_DESCRIPTOR_SET_SLOT_TYPE";
-}
-
-
-static const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
-{
-    switch ((XGL_TEX_ADDRESS)input_value)
-    {
-
-    case XGL_TEX_ADDRESS_CLAMP:
-        return "XGL_TEX_ADDRESS_CLAMP";
-
-    case XGL_TEX_ADDRESS_CLAMP_BORDER:
-        return "XGL_TEX_ADDRESS_CLAMP_BORDER";
-
-    case XGL_TEX_ADDRESS_MIRROR:
-        return "XGL_TEX_ADDRESS_MIRROR";
-
-    case XGL_TEX_ADDRESS_MIRROR_ONCE:
-        return "XGL_TEX_ADDRESS_MIRROR_ONCE";
-
-    case XGL_TEX_ADDRESS_WRAP:
-        return "XGL_TEX_ADDRESS_WRAP";
-
-    default:
-        return "Unhandled XGL_TEX_ADDRESS";
-    }
-    return "Unhandled XGL_TEX_ADDRESS";
-}
-
-
-static const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
-{
-    switch ((XGL_QUERY_TYPE)input_value)
-    {
-
-    case XGL_QUERY_OCCLUSION:
-        return "XGL_QUERY_OCCLUSION";
-
-    case XGL_QUERY_PIPELINE_STATISTICS:
-        return "XGL_QUERY_PIPELINE_STATISTICS";
-
-    default:
-        return "Unhandled XGL_QUERY_TYPE";
-    }
-    return "Unhandled XGL_QUERY_TYPE";
-}
-
-
-static const char* string_XGL_ATOMIC_OP(XGL_ATOMIC_OP input_value)
-{
-    switch ((XGL_ATOMIC_OP)input_value)
-    {
-
-    case XGL_ATOMIC_ADD_INT32:
-        return "XGL_ATOMIC_ADD_INT32";
-
-    case XGL_ATOMIC_ADD_INT64:
-        return "XGL_ATOMIC_ADD_INT64";
-
-    case XGL_ATOMIC_AND_INT32:
-        return "XGL_ATOMIC_AND_INT32";
-
-    case XGL_ATOMIC_AND_INT64:
-        return "XGL_ATOMIC_AND_INT64";
-
-    case XGL_ATOMIC_DEC_UINT32:
-        return "XGL_ATOMIC_DEC_UINT32";
-
-    case XGL_ATOMIC_DEC_UINT64:
-        return "XGL_ATOMIC_DEC_UINT64";
-
-    case XGL_ATOMIC_INC_UINT32:
-        return "XGL_ATOMIC_INC_UINT32";
-
-    case XGL_ATOMIC_INC_UINT64:
-        return "XGL_ATOMIC_INC_UINT64";
-
-    case XGL_ATOMIC_MAX_SINT32:
-        return "XGL_ATOMIC_MAX_SINT32";
-
-    case XGL_ATOMIC_MAX_SINT64:
-        return "XGL_ATOMIC_MAX_SINT64";
-
-    case XGL_ATOMIC_MAX_UINT32:
-        return "XGL_ATOMIC_MAX_UINT32";
-
-    case XGL_ATOMIC_MAX_UINT64:
-        return "XGL_ATOMIC_MAX_UINT64";
-
-    case XGL_ATOMIC_MIN_SINT32:
-        return "XGL_ATOMIC_MIN_SINT32";
-
-    case XGL_ATOMIC_MIN_SINT64:
-        return "XGL_ATOMIC_MIN_SINT64";
-
-    case XGL_ATOMIC_MIN_UINT32:
-        return "XGL_ATOMIC_MIN_UINT32";
-
-    case XGL_ATOMIC_MIN_UINT64:
-        return "XGL_ATOMIC_MIN_UINT64";
-
-    case XGL_ATOMIC_OR_INT32:
-        return "XGL_ATOMIC_OR_INT32";
-
-    case XGL_ATOMIC_OR_INT64:
-        return "XGL_ATOMIC_OR_INT64";
-
-    case XGL_ATOMIC_SUB_INT32:
-        return "XGL_ATOMIC_SUB_INT32";
-
-    case XGL_ATOMIC_SUB_INT64:
-        return "XGL_ATOMIC_SUB_INT64";
-
-    case XGL_ATOMIC_XOR_INT32:
-        return "XGL_ATOMIC_XOR_INT32";
-
-    case XGL_ATOMIC_XOR_INT64:
-        return "XGL_ATOMIC_XOR_INT64";
-
-    default:
-        return "Unhandled XGL_ATOMIC_OP";
-    }
-    return "Unhandled XGL_ATOMIC_OP";
-}
-
-
-static const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
-{
-    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
-    {
-
-    case XGL_PROVOKING_VERTEX_FIRST:
-        return "XGL_PROVOKING_VERTEX_FIRST";
-
-    case XGL_PROVOKING_VERTEX_LAST:
-        return "XGL_PROVOKING_VERTEX_LAST";
-
-    default:
-        return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
-    }
-    return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
-}
-
-
-static const char* string_XGL_MEMORY_HEAP_INFO_TYPE(XGL_MEMORY_HEAP_INFO_TYPE input_value)
-{
-    switch ((XGL_MEMORY_HEAP_INFO_TYPE)input_value)
-    {
-
-    case XGL_INFO_TYPE_MEMORY_HEAP_PROPERTIES:
-        return "XGL_INFO_TYPE_MEMORY_HEAP_PROPERTIES";
-
-    default:
-        return "Unhandled XGL_MEMORY_HEAP_INFO_TYPE";
-    }
-    return "Unhandled XGL_MEMORY_HEAP_INFO_TYPE";
-}
-
-
-static const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
-{
-    switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
-    {
-
-    case XGL_TOPOLOGY_LINE_LIST:
-        return "XGL_TOPOLOGY_LINE_LIST";
-
-    case XGL_TOPOLOGY_LINE_LIST_ADJ:
-        return "XGL_TOPOLOGY_LINE_LIST_ADJ";
-
-    case XGL_TOPOLOGY_LINE_STRIP:
-        return "XGL_TOPOLOGY_LINE_STRIP";
-
-    case XGL_TOPOLOGY_LINE_STRIP_ADJ:
-        return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
-
-    case XGL_TOPOLOGY_PATCH:
-        return "XGL_TOPOLOGY_PATCH";
-
-    case XGL_TOPOLOGY_POINT_LIST:
-        return "XGL_TOPOLOGY_POINT_LIST";
-
-    case XGL_TOPOLOGY_QUAD_LIST:
-        return "XGL_TOPOLOGY_QUAD_LIST";
-
-    case XGL_TOPOLOGY_QUAD_STRIP:
-        return "XGL_TOPOLOGY_QUAD_STRIP";
-
-    case XGL_TOPOLOGY_RECT_LIST:
-        return "XGL_TOPOLOGY_RECT_LIST";
-
-    case XGL_TOPOLOGY_TRIANGLE_LIST:
-        return "XGL_TOPOLOGY_TRIANGLE_LIST";
-
-    case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
-        return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
-
-    case XGL_TOPOLOGY_TRIANGLE_STRIP:
-        return "XGL_TOPOLOGY_TRIANGLE_STRIP";
-
-    case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
-        return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
-
-    default:
-        return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
-    }
-    return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
-}
-
-
-static const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
-{
-    switch ((XGL_BLEND_FUNC)input_value)
-    {
-
-    case XGL_BLEND_FUNC_ADD:
-        return "XGL_BLEND_FUNC_ADD";
-
-    case XGL_BLEND_FUNC_MAX:
-        return "XGL_BLEND_FUNC_MAX";
-
-    case XGL_BLEND_FUNC_MIN:
-        return "XGL_BLEND_FUNC_MIN";
-
-    case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
-        return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
-
-    case XGL_BLEND_FUNC_SUBTRACT:
-        return "XGL_BLEND_FUNC_SUBTRACT";
-
-    default:
-        return "Unhandled XGL_BLEND_FUNC";
-    }
-    return "Unhandled XGL_BLEND_FUNC";
-}
-
-
-static const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
-{
-    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
-    {
-
-    case XGL_SYSTEM_ALLOC_API_OBJECT:
-        return "XGL_SYSTEM_ALLOC_API_OBJECT";
-
-    case XGL_SYSTEM_ALLOC_DEBUG:
-        return "XGL_SYSTEM_ALLOC_DEBUG";
-
-    case XGL_SYSTEM_ALLOC_INTERNAL:
-        return "XGL_SYSTEM_ALLOC_INTERNAL";
-
-    case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
-        return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
-
-    case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
-        return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
-
-    default:
-        return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
-    }
-    return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
-}
-
-
-static const char* string_XGL_MEMORY_STATE(XGL_MEMORY_STATE input_value)
-{
-    switch ((XGL_MEMORY_STATE)input_value)
-    {
-
-    case XGL_MEMORY_STATE_COMPUTE_SHADER_READ_ONLY:
-        return "XGL_MEMORY_STATE_COMPUTE_SHADER_READ_ONLY";
-
-    case XGL_MEMORY_STATE_COMPUTE_SHADER_READ_WRITE:
-        return "XGL_MEMORY_STATE_COMPUTE_SHADER_READ_WRITE";
-
-    case XGL_MEMORY_STATE_COMPUTE_SHADER_WRITE_ONLY:
-        return "XGL_MEMORY_STATE_COMPUTE_SHADER_WRITE_ONLY";
-
-    case XGL_MEMORY_STATE_DATA_TRANSFER:
-        return "XGL_MEMORY_STATE_DATA_TRANSFER";
-
-    case XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY:
-        return "XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY";
-
-    case XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_WRITE:
-        return "XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_WRITE";
-
-    case XGL_MEMORY_STATE_GRAPHICS_SHADER_WRITE_ONLY:
-        return "XGL_MEMORY_STATE_GRAPHICS_SHADER_WRITE_ONLY";
-
-    case XGL_MEMORY_STATE_INDEX_DATA:
-        return "XGL_MEMORY_STATE_INDEX_DATA";
-
-    case XGL_MEMORY_STATE_INDIRECT_ARG:
-        return "XGL_MEMORY_STATE_INDIRECT_ARG";
-
-    case XGL_MEMORY_STATE_MULTI_SHADER_READ_ONLY:
-        return "XGL_MEMORY_STATE_MULTI_SHADER_READ_ONLY";
-
-    case XGL_MEMORY_STATE_QUEUE_ATOMIC:
-        return "XGL_MEMORY_STATE_QUEUE_ATOMIC";
-
-    case XGL_MEMORY_STATE_WRITE_TIMESTAMP:
-        return "XGL_MEMORY_STATE_WRITE_TIMESTAMP";
-
-    default:
-        return "Unhandled XGL_MEMORY_STATE";
-    }
-    return "Unhandled XGL_MEMORY_STATE";
-}
-
-
-static const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
-{
-    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
-    {
-
-    case XGL_QUERY_IMPRECISE_DATA_BIT:
-        return "XGL_QUERY_IMPRECISE_DATA_BIT";
-
-    default:
-        return "Unhandled XGL_QUERY_CONTROL_FLAGS";
-    }
-    return "Unhandled XGL_QUERY_CONTROL_FLAGS";
-}
-
-
-static const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
-{
-    switch ((XGL_FORMAT_INFO_TYPE)input_value)
-    {
-
-    case XGL_INFO_TYPE_FORMAT_PROPERTIES:
-        return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
-
-    default:
-        return "Unhandled XGL_FORMAT_INFO_TYPE";
-    }
-    return "Unhandled XGL_FORMAT_INFO_TYPE";
-}
-
-
-static const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
-{
-    switch ((XGL_STATE_BIND_POINT)input_value)
-    {
-
-    case XGL_STATE_BIND_COLOR_BLEND:
-        return "XGL_STATE_BIND_COLOR_BLEND";
-
-    case XGL_STATE_BIND_DEPTH_STENCIL:
-        return "XGL_STATE_BIND_DEPTH_STENCIL";
-
-    case XGL_STATE_BIND_MSAA:
-        return "XGL_STATE_BIND_MSAA";
-
-    case XGL_STATE_BIND_RASTER:
-        return "XGL_STATE_BIND_RASTER";
-
-    case XGL_STATE_BIND_VIEWPORT:
-        return "XGL_STATE_BIND_VIEWPORT";
-
-    default:
-        return "Unhandled XGL_STATE_BIND_POINT";
-    }
-    return "Unhandled XGL_STATE_BIND_POINT";
-}
-
-
-static const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
-{
-    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
-    {
-
-    case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
-        return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
-
-    case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
-        return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
-
-    case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
-        return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
-
-    case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
-        return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
-
-    default:
-        return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
-    }
-    return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
-}
-
-
-static const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
-{
-    switch ((XGL_MEMORY_REF_FLAGS)input_value)
-    {
-
-    case XGL_MEMORY_REF_READ_ONLY_BIT:
-        return "XGL_MEMORY_REF_READ_ONLY_BIT";
-
-    default:
-        return "Unhandled XGL_MEMORY_REF_FLAGS";
-    }
-    return "Unhandled XGL_MEMORY_REF_FLAGS";
-}
-
-
-static const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
-{
-    switch ((XGL_TIMESTAMP_TYPE)input_value)
-    {
-
-    case XGL_TIMESTAMP_BOTTOM:
-        return "XGL_TIMESTAMP_BOTTOM";
-
-    case XGL_TIMESTAMP_TOP:
-        return "XGL_TIMESTAMP_TOP";
-
-    default:
-        return "Unhandled XGL_TIMESTAMP_TYPE";
-    }
-    return "Unhandled XGL_TIMESTAMP_TYPE";
-}
-
-
-static const char* string_XGL_MEMORY_HEAP_FLAGS(XGL_MEMORY_HEAP_FLAGS input_value)
-{
-    switch ((XGL_MEMORY_HEAP_FLAGS)input_value)
-    {
-
-    case XGL_MEMORY_HEAP_CPU_GPU_COHERENT_BIT:
-        return "XGL_MEMORY_HEAP_CPU_GPU_COHERENT_BIT";
-
-    case XGL_MEMORY_HEAP_CPU_UNCACHED_BIT:
-        return "XGL_MEMORY_HEAP_CPU_UNCACHED_BIT";
-
-    case XGL_MEMORY_HEAP_CPU_VISIBLE_BIT:
-        return "XGL_MEMORY_HEAP_CPU_VISIBLE_BIT";
-
-    case XGL_MEMORY_HEAP_CPU_WRITE_COMBINED_BIT:
-        return "XGL_MEMORY_HEAP_CPU_WRITE_COMBINED_BIT";
-
-    case XGL_MEMORY_HEAP_HOLDS_PINNED_BIT:
-        return "XGL_MEMORY_HEAP_HOLDS_PINNED_BIT";
-
-    case XGL_MEMORY_HEAP_SHAREABLE_BIT:
-        return "XGL_MEMORY_HEAP_SHAREABLE_BIT";
-
-    default:
-        return "Unhandled XGL_MEMORY_HEAP_FLAGS";
-    }
-    return "Unhandled XGL_MEMORY_HEAP_FLAGS";
-}
-
-
-static const char* string_XGL_MEMORY_ALLOC_FLAGS(XGL_MEMORY_ALLOC_FLAGS input_value)
-{
-    switch ((XGL_MEMORY_ALLOC_FLAGS)input_value)
-    {
-
-    case XGL_MEMORY_ALLOC_SHAREABLE_BIT:
-        return "XGL_MEMORY_ALLOC_SHAREABLE_BIT";
-
-    case XGL_MEMORY_ALLOC_VIRTUAL_BIT:
-        return "XGL_MEMORY_ALLOC_VIRTUAL_BIT";
-
-    default:
-        return "Unhandled XGL_MEMORY_ALLOC_FLAGS";
-    }
-    return "Unhandled XGL_MEMORY_ALLOC_FLAGS";
-}
-
-
-static const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
-{
-    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
-    {
-
-    case XGL_GPU_TYPE_DISCRETE:
-        return "XGL_GPU_TYPE_DISCRETE";
-
-    case XGL_GPU_TYPE_INTEGRATED:
-        return "XGL_GPU_TYPE_INTEGRATED";
-
-    case XGL_GPU_TYPE_OTHER:
-        return "XGL_GPU_TYPE_OTHER";
-
-    case XGL_GPU_TYPE_VIRTUAL:
-        return "XGL_GPU_TYPE_VIRTUAL";
-
-    default:
-        return "Unhandled XGL_PHYSICAL_GPU_TYPE";
-    }
-    return "Unhandled XGL_PHYSICAL_GPU_TYPE";
-}
-
-
-static const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
-{
-    switch ((XGL_BORDER_COLOR_TYPE)input_value)
-    {
-
-    case XGL_BORDER_COLOR_OPAQUE_BLACK:
-        return "XGL_BORDER_COLOR_OPAQUE_BLACK";
-
-    case XGL_BORDER_COLOR_OPAQUE_WHITE:
-        return "XGL_BORDER_COLOR_OPAQUE_WHITE";
-
-    case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
-        return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
-
-    default:
-        return "Unhandled XGL_BORDER_COLOR_TYPE";
-    }
-    return "Unhandled XGL_BORDER_COLOR_TYPE";
-}
-
-
-static const char* string_XGL_IMAGE_STATE(XGL_IMAGE_STATE input_value)
-{
-    switch ((XGL_IMAGE_STATE)input_value)
-    {
-
-    case XGL_IMAGE_STATE_CLEAR:
-        return "XGL_IMAGE_STATE_CLEAR";
-
-    case XGL_IMAGE_STATE_COMPUTE_SHADER_READ_ONLY:
-        return "XGL_IMAGE_STATE_COMPUTE_SHADER_READ_ONLY";
-
-    case XGL_IMAGE_STATE_COMPUTE_SHADER_READ_WRITE:
-        return "XGL_IMAGE_STATE_COMPUTE_SHADER_READ_WRITE";
-
-    case XGL_IMAGE_STATE_COMPUTE_SHADER_WRITE_ONLY:
-        return "XGL_IMAGE_STATE_COMPUTE_SHADER_WRITE_ONLY";
-
-    case XGL_IMAGE_STATE_DATA_TRANSFER:
-        return "XGL_IMAGE_STATE_DATA_TRANSFER";
-
-    case XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_ONLY:
-        return "XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_ONLY";
-
-    case XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_WRITE:
-        return "XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_WRITE";
-
-    case XGL_IMAGE_STATE_GRAPHICS_SHADER_WRITE_ONLY:
-        return "XGL_IMAGE_STATE_GRAPHICS_SHADER_WRITE_ONLY";
-
-    case XGL_IMAGE_STATE_MULTI_SHADER_READ_ONLY:
-        return "XGL_IMAGE_STATE_MULTI_SHADER_READ_ONLY";
-
-    case XGL_IMAGE_STATE_RESOLVE_DESTINATION:
-        return "XGL_IMAGE_STATE_RESOLVE_DESTINATION";
-
-    case XGL_IMAGE_STATE_RESOLVE_SOURCE:
-        return "XGL_IMAGE_STATE_RESOLVE_SOURCE";
-
-    case XGL_IMAGE_STATE_TARGET_AND_SHADER_READ_ONLY:
-        return "XGL_IMAGE_STATE_TARGET_AND_SHADER_READ_ONLY";
-
-    case XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL:
-        return "XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL";
-
-    case XGL_IMAGE_STATE_TARGET_SHADER_ACCESS_OPTIMAL:
-        return "XGL_IMAGE_STATE_TARGET_SHADER_ACCESS_OPTIMAL";
-
-    case XGL_IMAGE_STATE_UNINITIALIZED_TARGET:
-        return "XGL_IMAGE_STATE_UNINITIALIZED_TARGET";
-
-    default:
-        return "Unhandled XGL_IMAGE_STATE";
-    }
-    return "Unhandled XGL_IMAGE_STATE";
-}
-
-
-static const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
-    switch ((XGL_TEX_MIPMAP_MODE)input_value)
-    {
-
-    case XGL_TEX_MIPMAP_BASE:
-        return "XGL_TEX_MIPMAP_BASE";
-
-    case XGL_TEX_MIPMAP_LINEAR:
-        return "XGL_TEX_MIPMAP_LINEAR";
-
-    case XGL_TEX_MIPMAP_NEAREST:
-        return "XGL_TEX_MIPMAP_NEAREST";
-
-    default:
-        return "Unhandled XGL_TEX_MIPMAP_MODE";
-    }
-    return "Unhandled XGL_TEX_MIPMAP_MODE";
-}
-
-
-static const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
-{
-    switch ((XGL_LOGIC_OP)input_value)
-    {
-
-    case XGL_LOGIC_OP_AND:
-        return "XGL_LOGIC_OP_AND";
-
-    case XGL_LOGIC_OP_AND_INVERTED:
-        return "XGL_LOGIC_OP_AND_INVERTED";
-
-    case XGL_LOGIC_OP_AND_REVERSE:
-        return "XGL_LOGIC_OP_AND_REVERSE";
-
-    case XGL_LOGIC_OP_CLEAR:
-        return "XGL_LOGIC_OP_CLEAR";
-
-    case XGL_LOGIC_OP_COPY:
-        return "XGL_LOGIC_OP_COPY";
-
-    case XGL_LOGIC_OP_COPY_INVERTED:
-        return "XGL_LOGIC_OP_COPY_INVERTED";
-
-    case XGL_LOGIC_OP_EQUIV:
-        return "XGL_LOGIC_OP_EQUIV";
-
-    case XGL_LOGIC_OP_INVERT:
-        return "XGL_LOGIC_OP_INVERT";
-
-    case XGL_LOGIC_OP_NAND:
-        return "XGL_LOGIC_OP_NAND";
-
-    case XGL_LOGIC_OP_NOOP:
-        return "XGL_LOGIC_OP_NOOP";
-
-    case XGL_LOGIC_OP_NOR:
-        return "XGL_LOGIC_OP_NOR";
-
-    case XGL_LOGIC_OP_OR:
-        return "XGL_LOGIC_OP_OR";
-
-    case XGL_LOGIC_OP_OR_INVERTED:
-        return "XGL_LOGIC_OP_OR_INVERTED";
-
-    case XGL_LOGIC_OP_OR_REVERSE:
-        return "XGL_LOGIC_OP_OR_REVERSE";
-
-    case XGL_LOGIC_OP_SET:
-        return "XGL_LOGIC_OP_SET";
-
-    case XGL_LOGIC_OP_XOR:
-        return "XGL_LOGIC_OP_XOR";
-
-    default:
-        return "Unhandled XGL_LOGIC_OP";
-    }
-    return "Unhandled XGL_LOGIC_OP";
-}
-
-
-static const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
-{
-    switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
-    {
-
-    case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
-        return "XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT";
-
-    case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
-        return "XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT";
-
-    case XGL_FORMAT_CONVERSION_BIT:
-        return "XGL_FORMAT_CONVERSION_BIT";
-
-    case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
-        return "XGL_FORMAT_DEPTH_ATTACHMENT_BIT";
-
-    case XGL_FORMAT_IMAGE_COPY_BIT:
-        return "XGL_FORMAT_IMAGE_COPY_BIT";
-
-    case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
-        return "XGL_FORMAT_IMAGE_SHADER_READ_BIT";
-
-    case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
-        return "XGL_FORMAT_IMAGE_SHADER_WRITE_BIT";
-
-    case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
-        return "XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT";
-
-    case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
-        return "XGL_FORMAT_MSAA_ATTACHMENT_BIT";
-
-    case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
-        return "XGL_FORMAT_STENCIL_ATTACHMENT_BIT";
-
-    default:
-        return "Unhandled XGL_FORMAT_FEATURE_FLAGS";
-    }
-    return "Unhandled XGL_FORMAT_FEATURE_FLAGS";
-}
-
-
-static const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
-{
-    switch ((XGL_VALIDATION_LEVEL)input_value)
-    {
-
-    case XGL_VALIDATION_LEVEL_0:
-        return "XGL_VALIDATION_LEVEL_0";
-
-    case XGL_VALIDATION_LEVEL_1:
-        return "XGL_VALIDATION_LEVEL_1";
-
-    case XGL_VALIDATION_LEVEL_2:
-        return "XGL_VALIDATION_LEVEL_2";
-
-    case XGL_VALIDATION_LEVEL_3:
-        return "XGL_VALIDATION_LEVEL_3";
-
-    case XGL_VALIDATION_LEVEL_4:
-        return "XGL_VALIDATION_LEVEL_4";
-
-    default:
-        return "Unhandled XGL_VALIDATION_LEVEL";
-    }
-    return "Unhandled XGL_VALIDATION_LEVEL";
-}
-
-
-static const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
-    switch ((XGL_CULL_MODE)input_value)
-    {
-
-    case XGL_CULL_BACK:
-        return "XGL_CULL_BACK";
-
-    case XGL_CULL_FRONT:
-        return "XGL_CULL_FRONT";
-
-    case XGL_CULL_FRONT_AND_BACK:
-        return "XGL_CULL_FRONT_AND_BACK";
-
-    case XGL_CULL_NONE:
-        return "XGL_CULL_NONE";
-
-    default:
-        return "Unhandled XGL_CULL_MODE";
-    }
-    return "Unhandled XGL_CULL_MODE";
-}
-
-
-static const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
-{
-    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
-    {
-
-    case XGL_SHADER_STAGE_COMPUTE:
-        return "XGL_SHADER_STAGE_COMPUTE";
-
-    case XGL_SHADER_STAGE_FRAGMENT:
-        return "XGL_SHADER_STAGE_FRAGMENT";
-
-    case XGL_SHADER_STAGE_GEOMETRY:
-        return "XGL_SHADER_STAGE_GEOMETRY";
-
-    case XGL_SHADER_STAGE_TESS_CONTROL:
-        return "XGL_SHADER_STAGE_TESS_CONTROL";
-
-    case XGL_SHADER_STAGE_TESS_EVALUATION:
-        return "XGL_SHADER_STAGE_TESS_EVALUATION";
-
-    case XGL_SHADER_STAGE_VERTEX:
-        return "XGL_SHADER_STAGE_VERTEX";
-
-    default:
-        return "Unhandled XGL_PIPELINE_SHADER_STAGE";
-    }
-    return "Unhandled XGL_PIPELINE_SHADER_STAGE";
-}
-
-
-static const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
-{
-    switch ((XGL_CHANNEL_SWIZZLE)input_value)
-    {
-
-    case XGL_CHANNEL_SWIZZLE_A:
-        return "XGL_CHANNEL_SWIZZLE_A";
-
-    case XGL_CHANNEL_SWIZZLE_B:
-        return "XGL_CHANNEL_SWIZZLE_B";
-
-    case XGL_CHANNEL_SWIZZLE_G:
-        return "XGL_CHANNEL_SWIZZLE_G";
-
-    case XGL_CHANNEL_SWIZZLE_ONE:
-        return "XGL_CHANNEL_SWIZZLE_ONE";
-
-    case XGL_CHANNEL_SWIZZLE_R:
-        return "XGL_CHANNEL_SWIZZLE_R";
-
-    case XGL_CHANNEL_SWIZZLE_ZERO:
-        return "XGL_CHANNEL_SWIZZLE_ZERO";
-
-    default:
-        return "Unhandled XGL_CHANNEL_SWIZZLE";
-    }
-    return "Unhandled XGL_CHANNEL_SWIZZLE";
-}
-
-
-static const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
-    {
-
-    case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
-        return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
-
-    case XGL_DEVICE_CREATE_VALIDATION_BIT:
-        return "XGL_DEVICE_CREATE_VALIDATION_BIT";
-
-    default:
-        return "Unhandled XGL_DEVICE_CREATE_FLAGS";
-    }
-    return "Unhandled XGL_DEVICE_CREATE_FLAGS";
-}
-
-
-static const char* string_XGL_RESULT(XGL_RESULT input_value)
-{
-    switch ((XGL_RESULT)input_value)
-    {
-
-    case XGL_EVENT_RESET:
-        return "XGL_EVENT_RESET";
-
-    case XGL_EVENT_SET:
-        return "XGL_EVENT_SET";
-
-    case XGL_NOT_READY:
-        return "XGL_NOT_READY";
-
-    case XGL_SUCCESS:
-        return "XGL_SUCCESS";
-
-    case XGL_TIMEOUT:
-        return "XGL_TIMEOUT";
-
-    case XGL_UNSUPPORTED:
-        return "XGL_UNSUPPORTED";
-
-    default:
-        return "Unhandled XGL_RESULT";
-    }
-    return "Unhandled XGL_RESULT";
-}
-
-
-static const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
-    {
-
-    case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
-        return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
-
-    default:
-        return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
-    }
-    return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
-}
-
-
-static const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
-    {
-
-    case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
-        return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
-
-    default:
-        return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
-    }
-    return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
-}
-
-
-static const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
-{
-    switch ((XGL_STRUCTURE_TYPE)input_value)
-    {
-
-    case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
-        return "XGL_STRUCTURE_TYPE_APPLICATION_INFO";
-
-    case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
-        return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
-
-    case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
-        return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
-
-    case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
-        return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
-
-    case XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION:
-        return "XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION";
-
-    case XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO:
-        return "XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO";
-
-    case XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
-        return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
-
-    case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO";
-
-    case XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO:
-        return "XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO";
-
-    case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
-        return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO";
-
-    default:
-        return "Unhandled XGL_STRUCTURE_TYPE";
-    }
-    return "Unhandled XGL_STRUCTURE_TYPE";
-}
-
-
-static const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
-{
-    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
-    {
-
-    case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
-        return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
-
-    case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
-        return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
-
-    default:
-        return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
-    }
-    return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
-}
-
-
-static const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
-{
-    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
-    {
-
-    case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
-        return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
-
-    case XGL_GPU_COMPAT_IQ_MATCH_BIT:
-        return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
-
-    case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
-        return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
-
-    case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
-        return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
-
-    case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
-        return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
-
-    case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
-        return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
-
-    case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
-        return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
-
-    default:
-        return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
-    }
-    return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
-}
-
-
-static const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
-{
-    switch ((XGL_FILL_MODE)input_value)
-    {
-
-    case XFL_FILL_POINTS:
-        return "XFL_FILL_POINTS";
-
-    case XGL_FILL_SOLID:
-        return "XGL_FILL_SOLID";
-
-    case XGL_FILL_WIREFRAME:
-        return "XGL_FILL_WIREFRAME";
-
-    default:
-        return "Unhandled XGL_FILL_MODE";
-    }
-    return "Unhandled XGL_FILL_MODE";
-}
-
-
-static const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
-{
-    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
-    {
-
-    case XGL_IMAGE_VIEW_1D:
-        return "XGL_IMAGE_VIEW_1D";
-
-    case XGL_IMAGE_VIEW_2D:
-        return "XGL_IMAGE_VIEW_2D";
-
-    case XGL_IMAGE_VIEW_3D:
-        return "XGL_IMAGE_VIEW_3D";
-
-    case XGL_IMAGE_VIEW_CUBE:
-        return "XGL_IMAGE_VIEW_CUBE";
-
-    default:
-        return "Unhandled XGL_IMAGE_VIEW_TYPE";
-    }
-    return "Unhandled XGL_IMAGE_VIEW_TYPE";
-}
-
-
-static const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
-{
-    switch ((XGL_IMAGE_TYPE)input_value)
-    {
-
-    case XGL_IMAGE_1D:
-        return "XGL_IMAGE_1D";
-
-    case XGL_IMAGE_2D:
-        return "XGL_IMAGE_2D";
-
-    case XGL_IMAGE_3D:
-        return "XGL_IMAGE_3D";
-
-    default:
-        return "Unhandled XGL_IMAGE_TYPE";
-    }
-    return "Unhandled XGL_IMAGE_TYPE";
-}
-
-
-static const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
-{
-    switch ((XGL_INDEX_TYPE)input_value)
-    {
-
-    case XGL_INDEX_16:
-        return "XGL_INDEX_16";
-
-    case XGL_INDEX_32:
-        return "XGL_INDEX_32";
-
-    case XGL_INDEX_8:
-        return "XGL_INDEX_8";
-
-    default:
-        return "Unhandled XGL_INDEX_TYPE";
-    }
-    return "Unhandled XGL_INDEX_TYPE";
-}
-
-
-static const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
-    {
-
-    case XGL_IMAGE_CREATE_CLONEABLE_BIT:
-        return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
-
-    case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
-        return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
-
-    case XGL_IMAGE_CREATE_SHAREABLE_BIT:
-        return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
-
-    default:
-        return "Unhandled XGL_IMAGE_CREATE_FLAGS";
-    }
-    return "Unhandled XGL_IMAGE_CREATE_FLAGS";
-}
-
-
-static const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
-{
-    switch ((XGL_QUEUE_TYPE)input_value)
-    {
-
-    case XGL_QUEUE_TYPE_COMPUTE:
-        return "XGL_QUEUE_TYPE_COMPUTE";
-
-    case XGL_QUEUE_TYPE_DMA:
-        return "XGL_QUEUE_TYPE_DMA";
-
-    case XGL_QUEUE_TYPE_GRAPHICS:
-        return "XGL_QUEUE_TYPE_GRAPHICS";
-
-    default:
-        return "Unhandled XGL_QUEUE_TYPE";
-    }
-    return "Unhandled XGL_QUEUE_TYPE";
-}
-
-
-static const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
-{
-    switch ((XGL_STENCIL_OP)input_value)
-    {
-
-    case XGL_STENCIL_OP_DEC_CLAMP:
-        return "XGL_STENCIL_OP_DEC_CLAMP";
-
-    case XGL_STENCIL_OP_DEC_WRAP:
-        return "XGL_STENCIL_OP_DEC_WRAP";
-
-    case XGL_STENCIL_OP_INC_CLAMP:
-        return "XGL_STENCIL_OP_INC_CLAMP";
-
-    case XGL_STENCIL_OP_INC_WRAP:
-        return "XGL_STENCIL_OP_INC_WRAP";
-
-    case XGL_STENCIL_OP_INVERT:
-        return "XGL_STENCIL_OP_INVERT";
-
-    case XGL_STENCIL_OP_KEEP:
-        return "XGL_STENCIL_OP_KEEP";
-
-    case XGL_STENCIL_OP_REPLACE:
-        return "XGL_STENCIL_OP_REPLACE";
-
-    case XGL_STENCIL_OP_ZERO:
-        return "XGL_STENCIL_OP_ZERO";
-
-    default:
-        return "Unhandled XGL_STENCIL_OP";
-    }
-    return "Unhandled XGL_STENCIL_OP";
-}
-
-
-static const char* string_XGL_CHANNEL_FORMAT(XGL_CHANNEL_FORMAT input_value)
-{
-    switch ((XGL_CHANNEL_FORMAT)input_value)
-    {
-
-    case XGL_CH_FMT_B5G6R5:
-        return "XGL_CH_FMT_B5G6R5";
-
-    case XGL_CH_FMT_B8G8R8A8:
-        return "XGL_CH_FMT_B8G8R8A8";
-
-    case XGL_CH_FMT_BC1:
-        return "XGL_CH_FMT_BC1";
-
-    case XGL_CH_FMT_BC2:
-        return "XGL_CH_FMT_BC2";
-
-    case XGL_CH_FMT_BC3:
-        return "XGL_CH_FMT_BC3";
-
-    case XGL_CH_FMT_BC4:
-        return "XGL_CH_FMT_BC4";
-
-    case XGL_CH_FMT_BC5:
-        return "XGL_CH_FMT_BC5";
-
-    case XGL_CH_FMT_BC6S:
-        return "XGL_CH_FMT_BC6S";
-
-    case XGL_CH_FMT_BC6U:
-        return "XGL_CH_FMT_BC6U";
-
-    case XGL_CH_FMT_BC7:
-        return "XGL_CH_FMT_BC7";
-
-    case XGL_CH_FMT_R10G10B10A2:
-        return "XGL_CH_FMT_R10G10B10A2";
-
-    case XGL_CH_FMT_R10G11B11:
-        return "XGL_CH_FMT_R10G11B11";
-
-    case XGL_CH_FMT_R11G11B10:
-        return "XGL_CH_FMT_R11G11B10";
-
-    case XGL_CH_FMT_R16:
-        return "XGL_CH_FMT_R16";
-
-    case XGL_CH_FMT_R16G16:
-        return "XGL_CH_FMT_R16G16";
-
-    case XGL_CH_FMT_R16G16B16:
-        return "XGL_CH_FMT_R16G16B16";
-
-    case XGL_CH_FMT_R16G16B16A16:
-        return "XGL_CH_FMT_R16G16B16A16";
-
-    case XGL_CH_FMT_R16G8:
-        return "XGL_CH_FMT_R16G8";
-
-    case XGL_CH_FMT_R32:
-        return "XGL_CH_FMT_R32";
-
-    case XGL_CH_FMT_R32G32:
-        return "XGL_CH_FMT_R32G32";
-
-    case XGL_CH_FMT_R32G32B32:
-        return "XGL_CH_FMT_R32G32B32";
-
-    case XGL_CH_FMT_R32G32B32A32:
-        return "XGL_CH_FMT_R32G32B32A32";
-
-    case XGL_CH_FMT_R32G8:
-        return "XGL_CH_FMT_R32G8";
-
-    case XGL_CH_FMT_R4G4:
-        return "XGL_CH_FMT_R4G4";
-
-    case XGL_CH_FMT_R4G4B4A4:
-        return "XGL_CH_FMT_R4G4B4A4";
-
-    case XGL_CH_FMT_R5G5B5A1:
-        return "XGL_CH_FMT_R5G5B5A1";
-
-    case XGL_CH_FMT_R5G6B5:
-        return "XGL_CH_FMT_R5G6B5";
-
-    case XGL_CH_FMT_R8:
-        return "XGL_CH_FMT_R8";
-
-    case XGL_CH_FMT_R8G8:
-        return "XGL_CH_FMT_R8G8";
-
-    case XGL_CH_FMT_R8G8B8:
-        return "XGL_CH_FMT_R8G8B8";
-
-    case XGL_CH_FMT_R8G8B8A8:
-        return "XGL_CH_FMT_R8G8B8A8";
-
-    case XGL_CH_FMT_R9G9B9E5:
-        return "XGL_CH_FMT_R9G9B9E5";
-
-    case XGL_CH_FMT_UNDEFINED:
-        return "XGL_CH_FMT_UNDEFINED";
-
-    default:
-        return "Unhandled XGL_CHANNEL_FORMAT";
-    }
-    return "Unhandled XGL_CHANNEL_FORMAT";
-}
-
-
-static const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
-{
-    switch ((XGL_COMPARE_FUNC)input_value)
-    {
-
-    case XGL_COMPARE_ALWAYS:
-        return "XGL_COMPARE_ALWAYS";
-
-    case XGL_COMPARE_EQUAL:
-        return "XGL_COMPARE_EQUAL";
-
-    case XGL_COMPARE_GREATER:
-        return "XGL_COMPARE_GREATER";
-
-    case XGL_COMPARE_GREATER_EQUAL:
-        return "XGL_COMPARE_GREATER_EQUAL";
-
-    case XGL_COMPARE_LESS:
-        return "XGL_COMPARE_LESS";
-
-    case XGL_COMPARE_LESS_EQUAL:
-        return "XGL_COMPARE_LESS_EQUAL";
-
-    case XGL_COMPARE_NEVER:
-        return "XGL_COMPARE_NEVER";
-
-    case XGL_COMPARE_NOT_EQUAL:
-        return "XGL_COMPARE_NOT_EQUAL";
-
-    default:
-        return "Unhandled XGL_COMPARE_FUNC";
-    }
-    return "Unhandled XGL_COMPARE_FUNC";
-}
-
-
-static const char* string_XGL_HEAP_MEMORY_TYPE(XGL_HEAP_MEMORY_TYPE input_value)
-{
-    switch ((XGL_HEAP_MEMORY_TYPE)input_value)
-    {
-
-    case XGL_HEAP_MEMORY_EMBEDDED:
-        return "XGL_HEAP_MEMORY_EMBEDDED";
-
-    case XGL_HEAP_MEMORY_LOCAL:
-        return "XGL_HEAP_MEMORY_LOCAL";
-
-    case XGL_HEAP_MEMORY_OTHER:
-        return "XGL_HEAP_MEMORY_OTHER";
-
-    case XGL_HEAP_MEMORY_REMOTE:
-        return "XGL_HEAP_MEMORY_REMOTE";
-
-    default:
-        return "Unhandled XGL_HEAP_MEMORY_TYPE";
-    }
-    return "Unhandled XGL_HEAP_MEMORY_TYPE";
-}
-
-
-static const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
-{
-    switch ((XGL_OBJECT_INFO_TYPE)input_value)
-    {
-
-    case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
-        return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
-
-    default:
-        return "Unhandled XGL_OBJECT_INFO_TYPE";
-    }
-    return "Unhandled XGL_OBJECT_INFO_TYPE";
-}
-
-
-static const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
-{
-    switch ((XGL_IMAGE_TILING)input_value)
-    {
-
-    case XGL_LINEAR_TILING:
-        return "XGL_LINEAR_TILING";
-
-    case XGL_OPTIMAL_TILING:
-        return "XGL_OPTIMAL_TILING";
-
-    default:
-        return "Unhandled XGL_IMAGE_TILING";
-    }
-    return "Unhandled XGL_IMAGE_TILING";
-}
-
-
-static const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
-    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
-    {
-
-    case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
-        return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
-
-    case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
-        return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
-
-    case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
-        return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
-
-    case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
-        return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
-
-    default:
-        return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
-    }
-    return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
-}
-
-
-static const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
-{
-    switch ((XGL_FACE_ORIENTATION)input_value)
-    {
-
-    case XGL_FRONT_FACE_CCW:
-        return "XGL_FRONT_FACE_CCW";
-
-    case XGL_FRONT_FACE_CW:
-        return "XGL_FRONT_FACE_CW";
-
-    default:
-        return "Unhandled XGL_FACE_ORIENTATION";
-    }
-    return "Unhandled XGL_FACE_ORIENTATION";
-}
-
-
-static const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
-{
-    switch ((XGL_QUEUE_FLAGS)input_value)
-    {
-
-    case XGL_QUEUE_COMPUTE_BIT:
-        return "XGL_QUEUE_COMPUTE_BIT";
-
-    case XGL_QUEUE_DMA_BIT:
-        return "XGL_QUEUE_DMA_BIT";
-
-    case XGL_QUEUE_EXTENDED_BIT:
-        return "XGL_QUEUE_EXTENDED_BIT";
-
-    case XGL_QUEUE_GRAPHICS_BIT:
-        return "XGL_QUEUE_GRAPHICS_BIT";
-
-    default:
-        return "Unhandled XGL_QUEUE_FLAGS";
-    }
-    return "Unhandled XGL_QUEUE_FLAGS";
-}
-
-
-static const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
-{
-    switch ((XGL_PIPELINE_BIND_POINT)input_value)
-    {
-
-    case XGL_PIPELINE_BIND_POINT_COMPUTE:
-        return "XGL_PIPELINE_BIND_POINT_COMPUTE";
-
-    case XGL_PIPELINE_BIND_POINT_GRAPHICS:
-        return "XGL_PIPELINE_BIND_POINT_GRAPHICS";
-
-    default:
-        return "Unhandled XGL_PIPELINE_BIND_POINT";
-    }
-    return "Unhandled XGL_PIPELINE_BIND_POINT";
-}
-
-
-static const char* string_XGL_BLEND(XGL_BLEND input_value)
-{
-    switch ((XGL_BLEND)input_value)
-    {
-
-    case XGL_BLEND_CONSTANT_ALPHA:
-        return "XGL_BLEND_CONSTANT_ALPHA";
-
-    case XGL_BLEND_CONSTANT_COLOR:
-        return "XGL_BLEND_CONSTANT_COLOR";
-
-    case XGL_BLEND_DEST_ALPHA:
-        return "XGL_BLEND_DEST_ALPHA";
-
-    case XGL_BLEND_DEST_COLOR:
-        return "XGL_BLEND_DEST_COLOR";
-
-    case XGL_BLEND_ONE:
-        return "XGL_BLEND_ONE";
-
-    case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
-        return "XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA";
-
-    case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
-        return "XGL_BLEND_ONE_MINUS_CONSTANT_COLOR";
-
-    case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
-        return "XGL_BLEND_ONE_MINUS_DEST_ALPHA";
-
-    case XGL_BLEND_ONE_MINUS_DEST_COLOR:
-        return "XGL_BLEND_ONE_MINUS_DEST_COLOR";
-
-    case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
-        return "XGL_BLEND_ONE_MINUS_SRC1_ALPHA";
-
-    case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
-        return "XGL_BLEND_ONE_MINUS_SRC1_COLOR";
-
-    case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
-        return "XGL_BLEND_ONE_MINUS_SRC_ALPHA";
-
-    case XGL_BLEND_ONE_MINUS_SRC_COLOR:
-        return "XGL_BLEND_ONE_MINUS_SRC_COLOR";
-
-    case XGL_BLEND_SRC1_ALPHA:
-        return "XGL_BLEND_SRC1_ALPHA";
-
-    case XGL_BLEND_SRC1_COLOR:
-        return "XGL_BLEND_SRC1_COLOR";
-
-    case XGL_BLEND_SRC_ALPHA:
-        return "XGL_BLEND_SRC_ALPHA";
-
-    case XGL_BLEND_SRC_ALPHA_SATURATE:
-        return "XGL_BLEND_SRC_ALPHA_SATURATE";
-
-    case XGL_BLEND_SRC_COLOR:
-        return "XGL_BLEND_SRC_COLOR";
-
-    case XGL_BLEND_ZERO:
-        return "XGL_BLEND_ZERO";
-
-    default:
-        return "Unhandled XGL_BLEND";
-    }
-    return "Unhandled XGL_BLEND";
-}
-
-
-static const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
-{
-    switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
-    {
-
-    case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
-        return "XGL_VERTEX_INPUT_STEP_RATE_DRAW";
-
-    case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
-        return "XGL_VERTEX_INPUT_STEP_RATE_INSTANCE";
-
-    case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
-        return "XGL_VERTEX_INPUT_STEP_RATE_VERTEX";
-
-    default:
-        return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
-    }
-    return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
-}
-
diff --git a/layers/xgl_struct_string_helper.h b/layers/xgl_struct_string_helper.h
deleted file mode 100644
index a5d82342..00000000
--- a/layers/xgl_struct_string_helper.h
+++ /dev/null
@@ -1,1015 +0,0 @@
-//This is the copyright
-//#includes, #defines, globals and such...
-#include <xgl.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include "xgl_string_helper.h"
-
-// Prototype for dynamic print function
-char* dynamic_display(const XGL_VOID* pStruct, const char* prefix);
-char* xgl_print_xgl_raster_state_create_info(const XGL_RASTER_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sfillMode = %s\n%scullMode = %s\n%sfrontFace = %s\n%sdepthBias = %i\n%sdepthBiasClamp = %f\n%sslopeScaledDepthBias = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_FILL_MODE(pStruct->fillMode), prefix, string_XGL_CULL_MODE(pStruct->cullMode), prefix, string_XGL_FACE_ORIENTATION(pStruct->frontFace), prefix, (pStruct->depthBias), prefix, (pStruct->depthBiasClamp), prefix, (pStruct->slopeScaledDepthBias));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sfillMode = %s\n%scullMode = %s\n%sfrontFace = %s\n%sdepthBias = %i\n%sdepthBiasClamp = %f\n%sslopeScaledDepthBias = %f\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_FILL_MODE(pStruct->fillMode), prefix, string_XGL_CULL_MODE(pStruct->cullMode), prefix, string_XGL_FACE_ORIENTATION(pStruct->frontFace), prefix, (pStruct->depthBias), prefix, (pStruct->depthBiasClamp), prefix, (pStruct->slopeScaledDepthBias), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
-    return str;
-}
-char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sviewType = %s\n%sformat = %p\n%schannels = %p\n%ssubresourceRange = %p\n%sminLod = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, string_XGL_IMAGE_VIEW_TYPE(pStruct->viewType), prefix, (void*)&(pStruct->format), prefix, (void*)&(pStruct->channels), prefix, (void*)&(pStruct->subresourceRange), prefix, (pStruct->minLod));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sviewType = %s\n%sformat = %p\n%schannels = %p\n%ssubresourceRange = %p\n%sminLod = %f\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, string_XGL_IMAGE_VIEW_TYPE(pStruct->viewType), prefix, (void*)&(pStruct->format), prefix, (void*)&(pStruct->channels), prefix, (void*)&(pStruct->subresourceRange), prefix, (pStruct->minLod), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%ssharedMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedMem));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%ssharedMem = %p\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedMem), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_memory_heap_properties(const XGL_MEMORY_HEAP_PROPERTIES* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sstructSize = %u\n%sheapMemoryType = %s\n%sheapSize = %u\n%spageSize = %u\n%sflags = %u\n%sgpuReadPerfRating = %f\n%sgpuWritePerfRating = %f\n%scpuReadPerfRating = %f\n%scpuWritePerfRating = %f\n", prefix, (pStruct->structSize), prefix, string_XGL_HEAP_MEMORY_TYPE(pStruct->heapMemoryType), prefix, (pStruct->heapSize), prefix, (pStruct->pageSize), prefix, (pStruct->flags), prefix, (pStruct->gpuReadPerfRating), prefix, (pStruct->gpuWritePerfRating), prefix, (pStruct->cpuReadPerfRating), prefix, (pStruct->cpuWritePerfRating));
-    return str;
-}
-char* xgl_print_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%saspect = %s\n%smipLevel = %u\n%sarraySlice = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->mipLevel), prefix, (pStruct->arraySlice));
-    return str;
-}
-char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%smaxGpuClock = %f\n%saluPerClock = %f\n%stexPerClock = %f\n%sprimsPerClock = %f\n%spixelsPerClock = %f\n", prefix, (pStruct->maxGpuClock), prefix, (pStruct->aluPerClock), prefix, (pStruct->texPerClock), prefix, (pStruct->primsPerClock), prefix, (pStruct->pixelsPerClock));
-    return str;
-}
-char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sstructSize = %u\n%ssupportsMigration = %s\n%ssupportsVirtualMemoryRemapping = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->structSize), prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsVirtualMemoryRemapping) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
-    return str;
-}
-char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sstage = %s\n%sshader = %p\n%sdescriptorSetMapping = %p\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = %p\n%sdynamicMemoryViewMapping = %p\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, (void*)(pStruct->shader), prefix, (void*)(pStruct->descriptorSetMapping), prefix, (pStruct->linkConstBufferCount), prefix, (void*)(pStruct->pLinkConstBufferInfo), prefix, (void*)&(pStruct->dynamicMemoryViewMapping));
-    return str;
-}
-char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sflags = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sblendEnable = %s\n%sformat = %p\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, (void*)&(pStruct->format), prefix, (pStruct->channelWriteMask));
-    return str;
-}
-char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%spUserData = %p\n%spfnAlloc = %p\n%spfnFree = %p\n", prefix, (pStruct->pUserData), prefix, (void*)(pStruct->pfnAlloc), prefix, (void*)(pStruct->pfnFree));
-    return str;
-}
-char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sformat = %p\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, (void*)&(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sformat = %p\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, (void*)&(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_image_copy(const XGL_IMAGE_COPY* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%ssrcSubresource = %p\n%ssrcOffset = %p\n%sdestSubresource = %p\n%sdestOffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->srcSubresource), prefix, (void*)&(pStruct->srcOffset), prefix, (void*)&(pStruct->destSubresource), prefix, (void*)&(pStruct->destOffset), prefix, (void*)&(pStruct->extent));
-    return str;
-}
-char* xgl_print_xgl_msaa_state_create_info(const XGL_MSAA_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%ssamples = %u\n%ssampleMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->samples), prefix, (pStruct->sampleMask));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%ssamples = %u\n%ssampleMask = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->samples), prefix, (pStruct->sampleMask), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_descriptor_set_create_info(const XGL_DESCRIPTOR_SET_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sslots = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->slots));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sslots = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->slots), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sview = %p\n%scolorAttachmentState = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_STATE(pStruct->colorAttachmentState));
-    return str;
-}
-char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sflags = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%ssize = %u\n%salignment = %u\n%sheapCount = %u\n%sheaps = %p\n", prefix, (pStruct->size), prefix, (pStruct->alignment), prefix, (pStruct->heapCount), prefix, (void*)(pStruct->heaps));
-    return str;
-}
-char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%ssharedSemaphore = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedSemaphore));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%ssharedSemaphore = %p\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedSemaphore), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%ssrcSubresource = %p\n%ssrcOffset = %p\n%sdestSubresource = %p\n%sdestOffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->srcSubresource), prefix, (void*)&(pStruct->srcOffset), prefix, (void*)&(pStruct->destSubresource), prefix, (void*)&(pStruct->destOffset), prefix, (void*)&(pStruct->extent));
-    return str;
-}
-char* xgl_print_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sindexCount = %u\n%sinstanceCount = %u\n%sfirstIndex = %u\n%svertexOffset = %i\n%sfirstInstance = %u\n", prefix, (pStruct->indexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstIndex), prefix, (pStruct->vertexOffset), prefix, (pStruct->firstInstance));
-    return str;
-}
-char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%scs = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->cs), prefix, (pStruct->flags));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%scs = %p\n%sflags = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->cs), prefix, (pStruct->flags), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%slayerCount = %u\n%sppActiveLayerNames = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->layerCount), prefix, (pStruct->ppActiveLayerNames));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%slayerCount = %u\n%sppActiveLayerNames = %p\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->layerCount), prefix, (pStruct->ppActiveLayerNames), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sstructSize = %u\n%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->structSize), prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE");
-    return str;
-}
-char* xgl_print_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%soffset = %u\n%ssize = %u\n%srowPitch = %u\n%sdepthPitch = %u\n", prefix, (pStruct->offset), prefix, (pStruct->size), prefix, (pStruct->rowPitch), prefix, (pStruct->depthPitch));
-    return str;
-}
-char* xgl_print_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
-    return str;
-}
-char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sinitialCount = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->initialCount), prefix, (pStruct->flags));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sinitialCount = %u\n%sflags = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->initialCount), prefix, (pStruct->flags), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_format(const XGL_FORMAT* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%schannelFormat = %s\n%snumericFormat = %s\n", prefix, string_XGL_CHANNEL_FORMAT(pStruct->channelFormat), prefix, string_XGL_NUM_FORMAT(pStruct->numericFormat));
-    return str;
-}
-char* xgl_print_xgl_memory_state_transition(const XGL_MEMORY_STATE_TRANSITION* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%smem = %p\n%soldState = %s\n%snewState = %s\n%soffset = %u\n%sregionSize = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->mem), prefix, string_XGL_MEMORY_STATE(pStruct->oldState), prefix, string_XGL_MEMORY_STATE(pStruct->newState), prefix, (pStruct->offset), prefix, (pStruct->regionSize));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%smem = %p\n%soldState = %s\n%snewState = %s\n%soffset = %u\n%sregionSize = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->mem), prefix, string_XGL_MEMORY_STATE(pStruct->oldState), prefix, string_XGL_MEMORY_STATE(pStruct->newState), prefix, (pStruct->offset), prefix, (pStruct->regionSize), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth));
-    return str;
-}
-char* xgl_print_xgl_dynamic_memory_view_slot_info(const XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sslotObjectType = %s\n%sshaderEntityIndex = %u\n", prefix, string_XGL_DESCRIPTOR_SET_SLOT_TYPE(pStruct->slotObjectType), prefix, (pStruct->shaderEntityIndex));
-    return str;
-}
-char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sview = %p\n%sstate = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_STATE(pStruct->state));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sview = %p\n%sstate = %s\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_STATE(pStruct->state), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%saspect = %s\n%sbaseMipLevel = %u\n%smipLevels = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->baseMipLevel), prefix, (pStruct->mipLevels), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
-    return str;
-}
-char* xgl_print_xgl_pipeline_db_state_create_info(const XGL_PIPELINE_DB_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sformat = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->format));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sformat = %p\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->format), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%spAppName = %p\n%sappVersion = %u\n%spEngineName = %p\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->pAppName), prefix, (pStruct->appVersion), prefix, (pStruct->pEngineName), prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%spAppName = %p\n%sappVersion = %u\n%spEngineName = %p\n%sengineVersion = %u\n%sapiVersion = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->pAppName), prefix, (pStruct->appVersion), prefix, (pStruct->pEngineName), prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
-    return str;
-}
-char* xgl_print_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sfsInvocations = %lu\n%scPrimitives = %lu\n%scInvocations = %lu\n%svsInvocations = %lu\n%sgsInvocations = %lu\n%sgsPrimitives = %lu\n%siaPrimitives = %lu\n%siaVertices = %lu\n%stcsInvocations = %lu\n%stesInvocations = %lu\n%scsInvocations = %lu\n", prefix, (pStruct->fsInvocations), prefix, (pStruct->cPrimitives), prefix, (pStruct->cInvocations), prefix, (pStruct->vsInvocations), prefix, (pStruct->gsInvocations), prefix, (pStruct->gsPrimitives), prefix, (pStruct->iaPrimitives), prefix, (pStruct->iaVertices), prefix, (pStruct->tcsInvocations), prefix, (pStruct->tesInvocations), prefix, (pStruct->csInvocations));
-    return str;
-}
-char* xgl_print_xgl_viewport_state_create_info(const XGL_VIEWPORT_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sviewportCount = %u\n%sscissorEnable = %s\n%sviewports = %p\n%sscissors = %p\n", prefix, (pStruct->viewportCount), prefix, (pStruct->scissorEnable) ? "TRUE" : "FALSE", prefix, (void*)(pStruct->viewports), prefix, (void*)(pStruct->scissors));
-    return str;
-}
-char* xgl_print_xgl_image_state_transition(const XGL_IMAGE_STATE_TRANSITION* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%simage = %p\n%soldState = %s\n%snewState = %s\n%ssubresourceRange = %p\n", prefix, (void*)(pStruct->image), prefix, string_XGL_IMAGE_STATE(pStruct->oldState), prefix, string_XGL_IMAGE_STATE(pStruct->newState), prefix, (void*)&(pStruct->subresourceRange));
-    return str;
-}
-char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%squeueRecordCount = %u\n%spRequestedQueues = %p\n%sextensionCount = %u\n%sppEnabledExtensionNames = %p\n%smaxValidationLevel = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->queueRecordCount), prefix, (void*)(pStruct->pRequestedQueues), prefix, (pStruct->extensionCount), prefix, (pStruct->ppEnabledExtensionNames), prefix, string_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel), prefix, (pStruct->flags));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%squeueRecordCount = %u\n%spRequestedQueues = %p\n%sextensionCount = %u\n%sppEnabledExtensionNames = %p\n%smaxValidationLevel = %s\n%sflags = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->queueRecordCount), prefix, (void*)(pStruct->pRequestedQueues), prefix, (pStruct->extensionCount), prefix, (pStruct->ppEnabledExtensionNames), prefix, string_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel), prefix, (pStruct->flags), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%simageType = %s\n%sformat = %p\n%sextent = %p\n%smipLevels = %u\n%sarraySize = %u\n%ssamples = %u\n%stiling = %s\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_IMAGE_TYPE(pStruct->imageType), prefix, (void*)&(pStruct->format), prefix, (void*)&(pStruct->extent), prefix, (pStruct->mipLevels), prefix, (pStruct->arraySize), prefix, (pStruct->samples), prefix, string_XGL_IMAGE_TILING(pStruct->tiling), prefix, (pStruct->usage), prefix, (pStruct->flags));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%simageType = %s\n%sformat = %p\n%sextent = %p\n%smipLevels = %u\n%sarraySize = %u\n%ssamples = %u\n%stiling = %s\n%susage = %u\n%sflags = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_IMAGE_TYPE(pStruct->imageType), prefix, (void*)&(pStruct->format), prefix, (void*)&(pStruct->extent), prefix, (pStruct->mipLevels), prefix, (pStruct->arraySize), prefix, (pStruct->samples), prefix, string_XGL_IMAGE_TILING(pStruct->tiling), prefix, (pStruct->usage), prefix, (pStruct->flags), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%soffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->offset), prefix, (void*)&(pStruct->extent));
-    return str;
-}
-char* xgl_print_xgl_memory_copy(const XGL_MEMORY_COPY* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%ssrcOffset = %u\n%sdestOffset = %u\n%scopySize = %u\n", prefix, (pStruct->srcOffset), prefix, (pStruct->destOffset), prefix, (pStruct->copySize));
-    return str;
-}
-char* xgl_print_xgl_descriptor_slot_info(const XGL_DESCRIPTOR_SLOT_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sslotObjectType = %s\n%sshaderEntityIndex = %u\n%spNextLevelSet = %p\n", prefix, string_XGL_DESCRIPTOR_SET_SLOT_TYPE(pStruct->slotObjectType), prefix, (pStruct->shaderEntityIndex), prefix, (pStruct->pNextLevelSet));
-    return str;
-}
-char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sbufferId = %u\n%sbufferSize = %u\n%spBufferData = %p\n", prefix, (pStruct->bufferId), prefix, (pStruct->bufferSize), prefix, (pStruct->pBufferData));
-    return str;
-}
-char* xgl_print_xgl_memory_image_copy(const XGL_MEMORY_IMAGE_COPY* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%smemOffset = %u\n%simageSubresource = %p\n%simageOffset = %p\n%simageExtent = %p\n", prefix, (pStruct->memOffset), prefix, (void*)&(pStruct->imageSubresource), prefix, (void*)&(pStruct->imageOffset), prefix, (void*)&(pStruct->imageExtent));
-    return str;
-}
-char* xgl_print_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sbinding = %u\n%sformat = %p\n%soffsetInBytes = %u\n", prefix, (pStruct->binding), prefix, (void*)&(pStruct->format), prefix, (pStruct->offsetInBytes));
-    return str;
-}
-char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%soriginX = %f\n%soriginY = %f\n%swidth = %f\n%sheight = %f\n%sminDepth = %f\n%smaxDepth = %f\n", prefix, (pStruct->originX), prefix, (pStruct->originY), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth));
-    return str;
-}
-char* xgl_print_xgl_descriptor_set_mapping(const XGL_DESCRIPTOR_SET_MAPPING* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sdescriptorCount = %u\n%spDescriptorInfo = %p\n", prefix, (pStruct->descriptorCount), prefix, (void*)(pStruct->pDescriptorInfo));
-    return str;
-}
-char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%soriginalMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->originalMem));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%soriginalMem = %p\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->originalMem), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%soriginalImage = %p\n", prefix, (void*)(pStruct->originalImage));
-    return str;
-}
-char* xgl_print_xgl_descriptor_set_attach_info(const XGL_DESCRIPTOR_SET_ATTACH_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sdescriptorSet = %p\n%sslotOffset = %u\n", prefix, (void*)(pStruct->descriptorSet), prefix, (pStruct->slotOffset));
-    return str;
-}
-char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sdepthClipEnable = %s\n%srasterizerDiscardEnable = %s\n%spointSize = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->depthClipEnable) ? "TRUE" : "FALSE", prefix, (pStruct->rasterizerDiscardEnable) ? "TRUE" : "FALSE", prefix, (pStruct->pointSize));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sdepthClipEnable = %s\n%srasterizerDiscardEnable = %s\n%spointSize = %f\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->depthClipEnable) ? "TRUE" : "FALSE", prefix, (pStruct->rasterizerDiscardEnable) ? "TRUE" : "FALSE", prefix, (pStruct->pointSize), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n%sstencilRef = %u\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc), prefix, (pStruct->stencilRef));
-    return str;
-}
-char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%scodeSize = %u\n%spCode = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->codeSize), prefix, (pStruct->pCode), prefix, (pStruct->flags));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%scodeSize = %u\n%spCode = %p\n%sflags = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->codeSize), prefix, (pStruct->pCode), prefix, (pStruct->flags), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_color_blend_state_create_info(const XGL_COLOR_BLEND_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sattachment = %p\n%sblendConst = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->attachment), prefix, (void*)(pStruct->blendConst));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sattachment = %p\n%sblendConst = %p\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->attachment), prefix, (void*)(pStruct->blendConst), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%salphaToCoverageEnable = %s\n%sdualSourceBlendEnable = %s\n%slogicOp = %s\n%sattachment = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->alphaToCoverageEnable) ? "TRUE" : "FALSE", prefix, (pStruct->dualSourceBlendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_LOGIC_OP(pStruct->logicOp), prefix, (void*)(pStruct->attachment));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%salphaToCoverageEnable = %s\n%sdualSourceBlendEnable = %s\n%slogicOp = %s\n%sattachment = %p\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->alphaToCoverageEnable) ? "TRUE" : "FALSE", prefix, (pStruct->dualSourceBlendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_LOGIC_OP(pStruct->logicOp), prefix, (void*)(pStruct->attachment), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_depth_stencil_state_create_info(const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sdepthTestEnable = %s\n%sdepthWriteEnable = %s\n%sdepthFunc = %s\n%sdepthBoundsEnable = %s\n%sminDepth = %f\n%smaxDepth = %f\n%sstencilTestEnable = %s\n%sstencilReadMask = %u\n%sstencilWriteMask = %u\n%sfront = %p\n%sback = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->depthTestEnable) ? "TRUE" : "FALSE", prefix, (pStruct->depthWriteEnable) ? "TRUE" : "FALSE", prefix, string_XGL_COMPARE_FUNC(pStruct->depthFunc), prefix, (pStruct->depthBoundsEnable) ? "TRUE" : "FALSE", prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth), prefix, (pStruct->stencilTestEnable) ? "TRUE" : "FALSE", prefix, (pStruct->stencilReadMask), prefix, (pStruct->stencilWriteMask), prefix, (void*)&(pStruct->front), prefix, (void*)&(pStruct->back));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sdepthTestEnable = %s\n%sdepthWriteEnable = %s\n%sdepthFunc = %s\n%sdepthBoundsEnable = %s\n%sminDepth = %f\n%smaxDepth = %f\n%sstencilTestEnable = %s\n%sstencilReadMask = %u\n%sstencilWriteMask = %u\n%sfront = %p\n%sback = %p\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->depthTestEnable) ? "TRUE" : "FALSE", prefix, (pStruct->depthWriteEnable) ? "TRUE" : "FALSE", prefix, string_XGL_COMPARE_FUNC(pStruct->depthFunc), prefix, (pStruct->depthBoundsEnable) ? "TRUE" : "FALSE", prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth), prefix, (pStruct->stencilTestEnable) ? "TRUE" : "FALSE", prefix, (pStruct->stencilReadMask), prefix, (pStruct->stencilWriteMask), prefix, (void*)&(pStruct->front), prefix, (void*)&(pStruct->back), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sr = %s\n%sg = %s\n%sb = %s\n%sa = %s\n", prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->r), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->g), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->b), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->a));
-    return str;
-}
-char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%simage = %p\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (pStruct->flags));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%simage = %p\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%sflags = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (pStruct->flags), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_virtual_memory_remap_range(const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%svirtualMem = %p\n%svirtualStartPage = %u\n%srealMem = %p\n%srealStartPage = %u\n%spageCount = %u\n", prefix, (void*)(pStruct->virtualMem), prefix, (pStruct->virtualStartPage), prefix, (void*)(pStruct->realMem), prefix, (pStruct->realStartPage), prefix, (pStruct->pageCount));
-    return str;
-}
-char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%squeueType = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUEUE_TYPE(pStruct->queueType), prefix, (pStruct->flags));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%squeueType = %s\n%sflags = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUEUE_TYPE(pStruct->queueType), prefix, (pStruct->flags), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%slinearTilingFeatures = %u\n%soptimalTilingFeatures = %u\n", prefix, (pStruct->linearTilingFeatures), prefix, (pStruct->optimalTilingFeatures));
-    return str;
-}
-char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sstructSize = %u\n%sapiVersion = %u\n%sdriverVersion = %u\n%svendorId = %u\n%sdeviceId = %u\n%sgpuType = %s\n%sgpuName = %s\n%smaxMemRefsPerSubmission = %u\n%svirtualMemPageSize = %u\n%smaxInlineMemoryUpdateSize = %u\n%smaxBoundDescriptorSets = %u\n%smaxThreadGroupSize = %u\n%stimestampFrequency = %lu\n%smultiColorAttachmentClears = %s\n", prefix, (pStruct->structSize), prefix, (pStruct->apiVersion), prefix, (pStruct->driverVersion), prefix, (pStruct->vendorId), prefix, (pStruct->deviceId), prefix, string_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType), prefix, (pStruct->gpuName), prefix, (pStruct->maxMemRefsPerSubmission), prefix, (pStruct->virtualMemPageSize), prefix, (pStruct->maxInlineMemoryUpdateSize), prefix, (pStruct->maxBoundDescriptorSets), prefix, (pStruct->maxThreadGroupSize), prefix, (pStruct->timestampFrequency), prefix, (pStruct->multiColorAttachmentClears) ? "TRUE" : "FALSE");
-    return str;
-}
-char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sview = %p\n%sdepthState = %s\n%sstencilState = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_STATE(pStruct->depthState), prefix, string_XGL_IMAGE_STATE(pStruct->stencilState));
-    return str;
-}
-char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%svertexCount = %u\n%sinstanceCount = %u\n%sfirstVertex = %u\n%sfirstInstance = %u\n", prefix, (pStruct->vertexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstVertex), prefix, (pStruct->firstInstance));
-    return str;
-}
-char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sflags = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%stopology = %s\n%sdisableVertexReuse = %s\n%sprovokingVertex = %s\n%sprimitiveRestartEnable = %s\n%sprimitiveRestartIndex = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology), prefix, (pStruct->disableVertexReuse) ? "TRUE" : "FALSE", prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex), prefix, (pStruct->primitiveRestartEnable) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartIndex));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%stopology = %s\n%sdisableVertexReuse = %s\n%sprovokingVertex = %s\n%sprimitiveRestartEnable = %s\n%sprimitiveRestartIndex = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology), prefix, (pStruct->disableVertexReuse) ? "TRUE" : "FALSE", prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex), prefix, (pStruct->primitiveRestartEnable) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartIndex), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_color_attachment_blend_state(const XGL_COLOR_ATTACHMENT_BLEND_STATE* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sblendEnable = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha));
-    return str;
-}
-char* xgl_print_xgl_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height));
-    return str;
-}
-char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sallocationSize = %u\n%salignment = %u\n%sflags = %u\n%sheapCount = %u\n%sheaps = %p\n%smemPriority = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->allocationSize), prefix, (pStruct->alignment), prefix, (pStruct->flags), prefix, (pStruct->heapCount), prefix, (void*)(pStruct->heaps), prefix, string_XGL_MEMORY_PRIORITY(pStruct->memPriority));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sallocationSize = %u\n%salignment = %u\n%sflags = %u\n%sheapCount = %u\n%sheaps = %p\n%smemPriority = %s\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->allocationSize), prefix, (pStruct->alignment), prefix, (pStruct->flags), prefix, (pStruct->heapCount), prefix, (void*)(pStruct->heaps), prefix, string_XGL_MEMORY_PRIORITY(pStruct->memPriority), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_memory_ref(const XGL_MEMORY_REF* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%smem = %p\n%sflags = %u\n", prefix, (void*)(pStruct->mem), prefix, (pStruct->flags));
-    return str;
-}
-char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sbindingCount = %u\n%spVertexBindingDescriptions = %p\n%sattributeCount = %u\n%spVertexAttributeDescriptions = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->bindingCount), prefix, (void*)(pStruct->pVertexBindingDescriptions), prefix, (pStruct->attributeCount), prefix, (void*)(pStruct->pVertexAttributeDescriptions));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sbindingCount = %u\n%spVertexBindingDescriptions = %p\n%sattributeCount = %u\n%spVertexAttributeDescriptions = %p\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->bindingCount), prefix, (void*)(pStruct->pVertexBindingDescriptions), prefix, (pStruct->attributeCount), prefix, (void*)(pStruct->pVertexAttributeDescriptions), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate));
-    return str;
-}
-char* xgl_print_xgl_offset3d(const XGL_OFFSET3D* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
-    return str;
-}
-char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sshader = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->shader));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%sshader = %p\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->shader), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%squeryType = %s\n%sslots = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUERY_TYPE(pStruct->queryType), prefix, (pStruct->slots));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%squeryType = %s\n%sslots = %u\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUERY_TYPE(pStruct->queryType), prefix, (pStruct->slots), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_memory_view_attach_info(const XGL_MEMORY_VIEW_ATTACH_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    if (!pStruct->pNext) {
-        str = (char*)malloc(sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%smem = %p\n%soffset = %u\n%srange = %u\n%sstride = %u\n%sformat = %p\n%sstate = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->mem), prefix, (pStruct->offset), prefix, (pStruct->range), prefix, (pStruct->stride), prefix, (void*)&(pStruct->format), prefix, string_XGL_MEMORY_STATE(pStruct->state));
-    } else {
-        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);
-        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);
-        sprintf(str, "%ssType = %s\n%spNext = %p\n%smem = %p\n%soffset = %u\n%srange = %u\n%sstride = %u\n%sformat = %p\n%sstate = %s\n   %spNext (%p)\n%s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->mem), prefix, (pStruct->offset), prefix, (pStruct->range), prefix, (pStruct->stride), prefix, (void*)&(pStruct->format), prefix, string_XGL_MEMORY_STATE(pStruct->state), prefix, (void*)pStruct->pNext, pTmpStr);
-        free(pTmpStr);
-    }
-    return str;
-}
-char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
-{
-    char* str;
-    str = (char*)malloc(sizeof(char)*1024);
-    sprintf(str, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
-    return str;
-}
-char* dynamic_display(const XGL_VOID* pStruct, const char* prefix)
-{
-    // Cast to APP_INFO ptr initially just to pull sType off struct
-    XGL_STRUCTURE_TYPE sType = ((XGL_APPLICATION_INFO*)pStruct)->sType;
-    char indent[100];
-    strcpy(indent, "    ");
-    strcat(indent, prefix);
-    switch (sType)
-    {
-        case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
-        {
-            return xgl_print_xgl_application_info((XGL_APPLICATION_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
-        {
-            return xgl_print_xgl_cmd_buffer_create_info((XGL_CMD_BUFFER_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
-        {
-            return xgl_print_xgl_color_attachment_view_create_info((XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO:
-        {
-            return xgl_print_xgl_color_blend_state_create_info((XGL_COLOR_BLEND_STATE_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
-        {
-            return xgl_print_xgl_compute_pipeline_create_info((XGL_COMPUTE_PIPELINE_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO:
-        {
-            return xgl_print_xgl_depth_stencil_state_create_info((XGL_DEPTH_STENCIL_STATE_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
-        {
-            return xgl_print_xgl_depth_stencil_view_create_info((XGL_DEPTH_STENCIL_VIEW_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO:
-        {
-            return xgl_print_xgl_descriptor_set_create_info((XGL_DESCRIPTOR_SET_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
-        {
-            return xgl_print_xgl_device_create_info((XGL_DEVICE_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
-        {
-            return xgl_print_xgl_event_create_info((XGL_EVENT_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
-        {
-            return xgl_print_xgl_fence_create_info((XGL_FENCE_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
-        {
-            return xgl_print_xgl_graphics_pipeline_create_info((XGL_GRAPHICS_PIPELINE_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
-        {
-            return xgl_print_xgl_image_create_info((XGL_IMAGE_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
-        {
-            return xgl_print_xgl_image_view_attach_info((XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
-        {
-            return xgl_print_xgl_image_view_create_info((XGL_IMAGE_VIEW_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
-        {
-            return xgl_print_xgl_layer_create_info((XGL_LAYER_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
-        {
-            return xgl_print_xgl_memory_alloc_info((XGL_MEMORY_ALLOC_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
-        {
-            return xgl_print_xgl_memory_open_info((XGL_MEMORY_OPEN_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION:
-        {
-            return xgl_print_xgl_memory_state_transition((XGL_MEMORY_STATE_TRANSITION*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO:
-        {
-            return xgl_print_xgl_memory_view_attach_info((XGL_MEMORY_VIEW_ATTACH_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO:
-        {
-            return xgl_print_xgl_msaa_state_create_info((XGL_MSAA_STATE_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
-        {
-            return xgl_print_xgl_peer_memory_open_info((XGL_PEER_MEMORY_OPEN_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
-        {
-            return xgl_print_xgl_pipeline_cb_state_create_info((XGL_PIPELINE_CB_STATE*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO:
-        {
-            return xgl_print_xgl_pipeline_db_state_create_info((XGL_PIPELINE_DB_STATE_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
-        {
-            return xgl_print_xgl_pipeline_ia_state_create_info((XGL_PIPELINE_IA_STATE_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
-        {
-            return xgl_print_xgl_pipeline_rs_state_create_info((XGL_PIPELINE_RS_STATE_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
-        {
-            return xgl_print_xgl_pipeline_shader_stage_create_info((XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
-        {
-            return xgl_print_xgl_pipeline_tess_state_create_info((XGL_PIPELINE_TESS_STATE_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
-        {
-            return xgl_print_xgl_pipeline_vertex_input_create_info((XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
-        {
-            return xgl_print_xgl_query_pool_create_info((XGL_QUERY_POOL_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO:
-        {
-            return xgl_print_xgl_raster_state_create_info((XGL_RASTER_STATE_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
-        {
-            return xgl_print_xgl_sampler_create_info((XGL_SAMPLER_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:
-        {
-            return xgl_print_xgl_queue_semaphore_create_info((XGL_QUEUE_SEMAPHORE_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO:
-        {
-            return xgl_print_xgl_queue_semaphore_open_info((XGL_QUEUE_SEMAPHORE_OPEN_INFO*)pStruct, indent);
-        }
-        break;
-        case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
-        {
-            return xgl_print_xgl_shader_create_info((XGL_SHADER_CREATE_INFO*)pStruct, indent);
-        }
-        break;
-    }
-}
\ No newline at end of file
diff --git a/xgl-helper.py b/xgl-helper.py
index 66474dba..af703a50 100755
--- a/xgl-helper.py
+++ b/xgl-helper.py
@@ -1,3 +1,26 @@
+#!/usr/bin/env python3
+#
+# XGL
+#
+# Copyright (C) 2014 LunarG, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
 import argparse
 import os
 import sys
@@ -332,7 +355,7 @@ class StructWrapperGen:
     def _generateCppHeader(self):
         header = []
         header.append("//#includes, #defines, globals and such...\n")
-        header.append("#include <stdio.h>\n#include <%s>\n#include <%s_string_helper.h>\n" % (os.path.basename(self.header_filename), self.api))
+        header.append("#include <stdio.h>\n#include <%s>\n#include <%s_enum_string_helper.h>\n" % (os.path.basename(self.header_filename), self.api))
         return "".join(header)
         
     def _generateClassDefinition(self):
@@ -480,8 +503,8 @@ class StructWrapperGen:
                 tmp_p_out += '   %spNext (%p)\\n%s\\n"' 
                 tmp_p_args += ", prefix, (void*)pStruct->pNext, pTmpStr);\n"
                 sh_funcs.append('    } else {\n')
+                sh_funcs.append('        str = (char*)malloc(sizeof(char)*2048);\n')
                 sh_funcs.append('        char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);\n')
-                sh_funcs.append('        str = (char*)malloc(strlen(pTmpStr) + sizeof(char)*1024);\n')
                 sh_funcs.append('        sprintf(str, "')
                 sh_funcs.append('%s%s' % (tmp_p_out, tmp_p_args))
                 sh_funcs.append('        free(pTmpStr);\n')
@@ -612,9 +635,9 @@ class StructWrapperGen:
         header = []
         header.append("//#includes, #defines, globals and such...\n")
         for f in self.include_headers:
-            if 'xgl_string_helper' not in f:
+            if 'xgl_enum_string_helper' not in f:
                 header.append("#include <%s>\n" % f)
-        header.append('#include "xgl_string_helper.h"\n\n// Prototype for dynamic print function\n')
+        header.append('#include "xgl_enum_string_helper.h"\n\n// Prototype for dynamic print function\n')
         header.append("char* dynamic_display(const XGL_VOID* pStruct, const char* prefix);\n")
         return "".join(header)
         
@@ -784,9 +807,9 @@ def main(argv=None):
     #print(typedef_dict)
     #print(struct_dict)
     if (opts.abs_out_dir is not None):
-        enum_filename = os.path.join(opts.abs_out_dir, os.path.basename(opts.input_file).strip(".h")+"_string_helper.h")
+        enum_filename = os.path.join(opts.abs_out_dir, os.path.basename(opts.input_file).strip(".h")+"_enum_string_helper.h")
     else:
-        enum_filename = os.path.join(os.getcwd(), opts.rel_out_dir, os.path.basename(opts.input_file).strip(".h")+"_string_helper.h")
+        enum_filename = os.path.join(os.getcwd(), opts.rel_out_dir, os.path.basename(opts.input_file).strip(".h")+"_enum_string_helper.h")
     enum_filename = os.path.abspath(enum_filename)
     if not os.path.exists(os.path.dirname(enum_filename)):
         print("Creating output dir %s" % os.path.dirname(enum_filename))